NuSMV/code/nusmv/core/utils/NodeList.h

Go to the documentation of this file.

/* ---------------------------------------------------------------------------


  This file is part of the ``utils'' package of NuSMV version 2.
  Copyright (C) 2003 by FBK-irst.

  NuSMV version 2 is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2 of the License, or (at your option) any later version.

  NuSMV version 2 is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA.

  For more information on NuSMV see <http://nusmv.fbk.eu>
  or email to <nusmv-users@fbk.eu>.
  Please report bugs to <nusmv-users@fbk.eu>.

  To contact the NuSMV development board, email to <nusmv@fbk.eu>.

-----------------------------------------------------------------------------*/

#ifndef __NUSMV_CORE_UTILS_NODE_LIST_H__
#define __NUSMV_CORE_UTILS_NODE_LIST_H__

#include "nusmv/core/node/node.h"
#include "nusmv/core/utils/utils.h"
#include "nusmv/core/node/printers/MasterPrinter.h"

typedef struct NodeList_TAG* NodeList_ptr;

#define NODE_LIST(x)  \
        ((NodeList_ptr) (x))

#define NODE_LIST_CHECK_INSTANCE(x)  \
        (nusmv_assert(NODE_LIST(x) != NODE_LIST(NULL)))

typedef struct Link_TAG* ListIter_ptr;

#define LIST_ITER(x)  \
        ((ListIter_ptr) (x))

typedef boolean (*NodeListPred) (node_ptr element, void* arg);


typedef boolean (*NODE_LIST_FOREACH_FUN_P)(NodeList_ptr list, ListIter_ptr iter,
                                           void* user_data);


/* NodeList_ptr, ListIter_ptr */

#define NODE_LIST_FOREACH(list, iter)                               \
   for (iter=NodeList_get_first_iter(list); !ListIter_is_end(iter); \
        iter=ListIter_get_next(iter))

/* Constructors, Destructors, Copiers and Cleaners ****************************/

NodeList_ptr NodeList_create(void);

NodeList_ptr NodeList_create_from_list(node_ptr list);

NodeList_ptr NodeList_create_from_element(node_ptr node);

NodeList_ptr NodeList_copy(NodeList_ptr self);

void NodeList_destroy(NodeList_ptr self);


/* Getters and Setters ********************************************************/

int NodeList_get_length(const NodeList_ptr self);


/* Queries  *******************************************************************/

boolean NodeList_is_empty(const NodeList_ptr self);

boolean
NodeList_belongs_to(const NodeList_ptr self, node_ptr elem);


/* Insertion ******************************************************************/

void NodeList_append(NodeList_ptr self, node_ptr elem);

void NodeList_prepend(NodeList_ptr self, node_ptr elem);


/* Retrieval********************************************************************/

node_ptr NodeList_get_elem_at(const NodeList_ptr self,
                                     const ListIter_ptr iter);


/* Removal ********************************************************************/

int NodeList_remove_elems(NodeList_ptr self,
                                 const NodeList_ptr other,
                                 NodeListPred disposer,
                                 void* disposer_arg);


/* ListIter subinterface ******************************************************/

ListIter_ptr ListIter_get_next(const ListIter_ptr self);

boolean ListIter_is_end(const ListIter_ptr self);

ListIter_ptr ListIter_get_end(void);


/* ListIter *******************************************************************/

ListIter_ptr NodeList_get_first_iter(const NodeList_ptr self);

void NodeList_insert_before(NodeList_ptr self, ListIter_ptr iter,
                                   node_ptr elem);

void NodeList_insert_after(NodeList_ptr self, ListIter_ptr iter,
                                  node_ptr elem);

node_ptr NodeList_remove_elem_at(NodeList_ptr self,
                                        ListIter_ptr iter);

ListIter_ptr
NodeList_search(const NodeList_ptr self, NodeListPred pred, void* arg);


/* Printers *******************************************************************/

void NodeList_print_nodes(const NodeList_ptr self,
                          MasterPrinter_ptr printer,
                          FILE* out);


/* Miscellaneous **************************************************************/

void NodeList_reverse(NodeList_ptr self);

void NodeList_concat(NodeList_ptr self, const NodeList_ptr src);

void NodeList_concat_unique(NodeList_ptr self, const NodeList_ptr src);

int
NodeList_count_elem(const NodeList_ptr self, node_ptr elem);

int
NodeList_foreach(NodeList_ptr self, NODE_LIST_FOREACH_FUN_P foo,
                 void* user_data);

NodeList_ptr NodeList_map(const NodeList_ptr self, NPFN foo);

NodeList_ptr NodeList_filter(const NodeList_ptr self, BPFN foo);

void NodeList_sort(NodeList_ptr self, int (*cmp)(const void* el1, const void* el2));

int NodeList_test(NuSMVEnv_ptr env);


#endif /* __NUSMV_CORE_UTILS_NODE_LIST_H__ */

---