osprey/be/com/cxx_base.h File Reference

#include "errors.h"

Include dependency graph for cxx_base.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Types
module	SLIST_NODE
module	SLIST
module	SLIST_ITER
module	CHAIN_NODE
module	CHAIN
module	CHAIN_ITER
module	CLIST_NODE
module	CLIST
module	CLIST_ITER
Defines
#define	DECLARE_SLIST_NODE_CLASS(NAME_NODE)
#define	DECLARE_SLIST_CLASS(NAME_LIST, NAME_NODE)
#define	DECLARE_SLIST_ITER_CLASS(NAME_ITER, NAME_NODE, NAME_LIST)
#define	DECLARE_SLIST_CONST_ITER_CLASS(NAME_ITER, NAME_NODE, NAME_LIST)
#define	DECLARE_CHAIN_NODE_CLASS(NAME_NODE)
#define	DECLARE_CHAIN_CLASS(NAME_LIST, NAME_NODE)
#define	DECLARE_CHAIN_ITER_CLASS(NAME_ITER, NAME_NODE, NAME_LIST)
#define	DECLARE_CHAIN_CONST_ITER_CLASS(NAME_ITER, NAME_NODE, NAME_LIST)
#define	DECLARE_CLIST_NODE_CLASS(NAME_LIST)
#define	DECLARE_CLIST_CLASS(NAME_LIST, NAME_NODE)
#define	DECLARE_CLIST_ITER_CLASS(NAME_ITER, NAME_NODE, NAME_LIST)

---

Define Documentation

#define DECLARE_CHAIN_CLASS	(	NAME_LIST,
		NAME_NODE		)

Definition at line 1016 of file cxx_base.h.

#define DECLARE_CHAIN_CONST_ITER_CLASS	(	NAME_ITER,
		NAME_NODE,
		NAME_LIST		)

Value:

public:                 \
  NAME_ITER(const NAME_LIST *nl)          \
        { CHAIN_ITER::Init((NAME_LIST *)nl); }      \
  const NAME_NODE *First(void)            \
              { return (const NAME_NODE *) CHAIN_ITER::First(); } \
  const NAME_NODE *Last(void)             \
              { return (const NAME_NODE *) CHAIN_ITER::Last(); }  \
  const NAME_NODE *Next(void)             \
              { return (const NAME_NODE *) CHAIN_ITER::Next(); }  \
  const NAME_NODE *Prev(void)             \
              { return (const NAME_NODE *) CHAIN_ITER::Prev(); }  \
  const NAME_NODE *List(void)             \
              { return (const NAME_NODE *) CHAIN_ITER::List(); }  \
  const NAME_NODE *Nth(INT n)           \
              { return (const NAME_NODE *) CHAIN_ITER::Nth(n); }  \
  const NAME_NODE *Last_Nth(INT n)                                      \
              { return (const NAME_NODE *) CHAIN_ITER::Last_Nth(n); } \
  const NAME_NODE *Peek_Next(void)          \
              { return (const NAME_NODE *) CHAIN_ITER::Peek_Next(); } \
  const NAME_NODE *Head(void)           \
              { return (const NAME_NODE *) CHAIN_ITER::List(); }  \
  const NAME_NODE *Cur(void)            \
              { return (const NAME_NODE *) CHAIN_ITER::Cur(); }   \
  BOOL Is_Empty(void) { return CHAIN_ITER::Is_Empty(); }    \
  BOOL Is_Empty_Reverse(void) { return CHAIN_ITER::Is_Empty(); }  \

Definition at line 1076 of file cxx_base.h.

#define DECLARE_CHAIN_ITER_CLASS	(	NAME_ITER,
		NAME_NODE,
		NAME_LIST		)

Value:

public:                 \
  NAME_ITER(NAME_LIST *nl) { CHAIN_ITER::Init(nl); }        \
  NAME_NODE *First(void) { return (NAME_NODE *) CHAIN_ITER::First(); }  \
  NAME_NODE *Last(void) { return (NAME_NODE *) CHAIN_ITER::Last(); }  \
  NAME_NODE *Next(void) { return (NAME_NODE *) CHAIN_ITER::Next(); }  \
  NAME_NODE *Prev(void) { return (NAME_NODE *) CHAIN_ITER::Prev(); }  \
  NAME_NODE *List(void) { return (NAME_NODE *) CHAIN_ITER::List(); }  \
  NAME_NODE *Nth(INT n) { return (NAME_NODE *) CHAIN_ITER::Nth(n); }  \
  NAME_NODE *Last_Nth(INT n)                                            \
        { return (NAME_NODE *) CHAIN_ITER::Last_Nth(n); } \
  NAME_NODE *Peek_Next(void) { return (NAME_NODE *) CHAIN_ITER::Peek_Next(); }\
  NAME_NODE *Head(void) { return (NAME_NODE *) CHAIN_ITER::List(); }  \
  NAME_NODE *Cur(void) { return (NAME_NODE *) CHAIN_ITER::Cur(); }  \
  BOOL Is_Empty(void) { return CHAIN_ITER::Is_Empty(); }            \
  BOOL Is_Empty_Reverse(void) { return CHAIN_ITER::Is_Empty(); }  \

Definition at line 1058 of file cxx_base.h.

#define DECLARE_CHAIN_NODE_CLASS

(

NAME_NODE

)

Value:

public:                 \
  NAME_NODE *Next(void)             \
    {return (NAME_NODE *)CHAIN_NODE::Next();}   \
  NAME_NODE *Prev(void)             \
    {return (NAME_NODE *)CHAIN_NODE::Prev();}   \
  const NAME_NODE *Next(void) const           \
    {return (const NAME_NODE *)CHAIN_NODE::Next();}   \
  const NAME_NODE *Prev(void) const           \
    {return (const NAME_NODE *)CHAIN_NODE::Prev();}   \
  NAME_NODE *Insert_Before(NAME_NODE *nd) {       \
    return (NAME_NODE*) CHAIN_NODE::Insert_Before(nd);                  \
  }                                                                     \
  NAME_NODE *Insert_After(NAME_NODE *nd) {        \
    return (NAME_NODE*) CHAIN_NODE::Insert_After(nd);                   \
  }                                                                     \
  NAME_NODE *Remove() {             \
    return (NAME_NODE*) CHAIN_NODE::Remove();                           \
  }                                                                     \

Definition at line 989 of file cxx_base.h.

#define DECLARE_CLIST_CLASS	(	NAME_LIST,
		NAME_NODE		)

Value:

public:                 \
  NAME_LIST(NAME_NODE *nd) { CLIST::Init(nd); }       \
  void Append(NAME_NODE *nd) { CLIST::Append(nd); }     \
  void Append(NAME_NODE *nd, NAME_NODE *od) {         \
    CLIST::Append(nd, od);            \
  }                 \
  void Prepend(NAME_NODE *nd) { CLIST::Prepend(nd); }     \
  void Prepend(NAME_NODE *nd, NAME_NODE *od) {        \
    CLIST::Prepend(nd, od);           \
  }                 \
  void Append_List(NAME_LIST *nl) { CLIST::Append_List(nl); }   \
  void Prepend_List(NAME_LIST *nl) { CLIST::Prepend_List(nl); }   \
  NAME_NODE *Remove_Headnode(void) {          \
    return (NAME_NODE*)CLIST::Remove_Headnode();      \
  }                 \
  NAME_NODE *Head(void) { return (NAME_NODE *) CLIST::Head(); }   \
  NAME_NODE *Tail(void) { return (NAME_NODE *) CLIST::Tail(); }   \
  BOOL       Is_Empty(void) const { return CLIST::Is_Empty(); }   \
  INT32      Len(void) const { return CLIST::Len(); }     \

Definition at line 1454 of file cxx_base.h.

#define DECLARE_CLIST_ITER_CLASS	(	NAME_ITER,
		NAME_NODE,
		NAME_LIST		)

Value:

public:                 \
  NAME_ITER(NAME_NODE *nd) { CLIST_ITER::Init(nd); }      \
  NAME_ITER(NAME_LIST *nl) { CLIST_ITER::Init(nl); }        \
  NAME_ITER(void)          { CLIST_ITER::Init();   }                    \
  void Init(NAME_NODE *nd) { CLIST_ITER::Init(nd); }      \
  void Init(NAME_LIST *nl) { CLIST_ITER::Init(nl); }                    \
  void Set(NAME_NODE *nd) { CLIST_ITER::Set(nd); }      \
  NAME_NODE *First(void) { return (NAME_NODE *) CLIST_ITER::First(); }  \
  NAME_NODE *Next(void) { return (NAME_NODE *) CLIST_ITER::Next(); }  \
  NAME_NODE *Peek_Next(void){ return (NAME_NODE *) CLIST_ITER::Peek_Next(); }\
  NAME_NODE *Head(void) { return (NAME_NODE *) CLIST_ITER::Head(); }  \
  NAME_NODE *Cur(void) { return (NAME_NODE *) CLIST_ITER::Cur(); }  \
  BOOL       Saw_Head(void) { return CLIST_ITER::Saw_Head(); }    \

Definition at line 1484 of file cxx_base.h.

#define DECLARE_CLIST_NODE_CLASS

(

NAME_LIST

)

Value:

\
public:                     \
  NAME_LIST *Next(void) {return (NAME_LIST *) CLIST_NODE::Next();}    \
  void Insert_After(NAME_LIST *nd) {                    \
    CLIST_NODE::Insert_After(nd);             \
  }                           \
  void Insert_Before(NAME_LIST *nd) {                   \
    CLIST_NODE::Insert_Before(nd);                    \
  }                           \
  NAME_NODE* Remove(NAME_LIST *prev) {                          \
    return (NAME_NODE*)CLIST_NODE::Remove(prev);          \
  }                     \
  void Set_Next(NAME_LIST *nd) {              \
    CLIST_NODE::Set_Next(nd);               \
  }                     \
  INT32 Len(void)  { return CLIST_NODE::Len(); }          \

Definition at line 1428 of file cxx_base.h.

#define DECLARE_SLIST_CLASS	(	NAME_LIST,
		NAME_NODE		)

Value:

public:                                                     \
  typedef NAME_NODE CONTAINER_NODE;                 \
  NAME_LIST(NAME_NODE *nd) { SLIST::Init(nd); }       \
  NAME_LIST() : SLIST() {}            \
  void Append(NAME_NODE *nd) { SLIST::Append(nd); }     \
  BOOL Append(NAME_NODE *nd, NAME_NODE *od) {         \
    return SLIST::Append(nd, od);         \
  }                 \
  void Prepend(NAME_NODE *nd) { SLIST::Prepend(nd); }     \
  BOOL Prepend(NAME_NODE *nd, NAME_NODE *od) {        \
    return SLIST::Prepend(nd, od);          \
  }                 \
  void Append_List(NAME_LIST *nl) { SLIST::Append_List(nl); }   \
  void Prepend_List(NAME_LIST *nl) { SLIST::Prepend_List(nl); }   \
  NAME_NODE *Remove_Headnode(void) {          \
    return (NAME_NODE*) SLIST::Remove_Headnode();     \
  }                   \
  NAME_NODE *Remove(NAME_NODE *prev, NAME_NODE *cur) {      \
    return (NAME_NODE*) SLIST::Remove(prev, cur);     \
  }                   \
  NAME_NODE *Head(void) { return (NAME_NODE *) SLIST::Head(); }   \
  const NAME_NODE *Head(void) const           \
    { return (const NAME_NODE *) SLIST::Head(); }   \
  NAME_NODE *Tail(void) { return (NAME_NODE *) SLIST::Tail(); }   \
  const NAME_NODE *Tail(void) const         \
    { return (const NAME_NODE *) SLIST::Tail(); }   \
  BOOL       Is_Empty(void) const { return SLIST::Is_Empty(); }   \
  INT32      Len(void) const { return SLIST::Len(); }     \
  INT        Pos(NAME_NODE *od) { return SLIST::Pos(od); }              \

Definition at line 563 of file cxx_base.h.

#define DECLARE_SLIST_CONST_ITER_CLASS	(	NAME_ITER,
		NAME_NODE,
		NAME_LIST		)

Value:

public:                 \
  NAME_ITER(const NAME_NODE *nd) { SLIST_ITER::Init((NAME_NODE*)nd); } \
  NAME_ITER(const NAME_LIST *nl) { SLIST_ITER::Init((NAME_LIST*)nl); } \
  NAME_ITER(void)          { SLIST_ITER::Init();   }                    \
  void Init(NAME_NODE *nd) { SLIST_ITER::Init(nd); }      \
  void Init(NAME_LIST *nl) { SLIST_ITER::Init(nl); }      \
  void Set(NAME_NODE *nd) { SLIST_ITER::Set(nd); }      \
  const NAME_NODE *First(void) { return (NAME_NODE *) SLIST_ITER::First(); } \
  const NAME_NODE *Next(void) { return (NAME_NODE *) SLIST_ITER::Next(); }   \
  const NAME_NODE *Nth(INT n) { return (NAME_NODE *) SLIST_ITER::Nth(n); }   \
  const NAME_NODE *Peek_Next(void) { return (NAME_NODE *) SLIST_ITER::Peek_Next(); }   \
  const NAME_NODE *Head(void) { return (NAME_NODE *) SLIST_ITER::Head(); }   \
  const NAME_NODE *Cur(void) { return (NAME_NODE *) SLIST_ITER::Cur(); }     \
  BOOL Is_Empty(void) { return SLIST_ITER::Is_Empty(); }           \

Definition at line 618 of file cxx_base.h.

#define DECLARE_SLIST_ITER_CLASS	(	NAME_ITER,
		NAME_NODE,
		NAME_LIST		)

Value:

public:                 \
  NAME_ITER(NAME_NODE *nd) { SLIST_ITER::Init(nd); }      \
  NAME_ITER(NAME_LIST *nl) { SLIST_ITER::Init(nl); }        \
  NAME_ITER(void)          { SLIST_ITER::Init();   }                    \
  void Init(NAME_NODE *nd) { SLIST_ITER::Init(nd); }      \
  void Init(NAME_LIST *nl) { SLIST_ITER::Init(nl); }                    \
  void Set(NAME_NODE *nd) { SLIST_ITER::Set(nd); }      \
  NAME_NODE *First(void) { return (NAME_NODE *) SLIST_ITER::First(); }  \
  NAME_NODE *Next(void) { return (NAME_NODE *) SLIST_ITER::Next(); }  \
  NAME_NODE *Nth(INT n) { return (NAME_NODE *) SLIST_ITER::Nth(n); }  \
  NAME_NODE *Peek_Next(void) { return (NAME_NODE *) SLIST_ITER::Peek_Next(); }\
  NAME_NODE *Head(void) { return (NAME_NODE *) SLIST_ITER::Head(); }  \
  NAME_NODE *Cur(void) { return (NAME_NODE *) SLIST_ITER::Cur(); }  \
  BOOL Is_Empty(void) { return SLIST_ITER::Is_Empty(); }      \

Definition at line 602 of file cxx_base.h.

#define DECLARE_SLIST_NODE_CLASS

(

NAME_NODE

)

Value:

\
public:                     \
  NAME_NODE *Next(void) {               \
    return (NAME_NODE *) SLIST_NODE::Next();                          \
  }                     \
  const NAME_NODE *Next(void) const {             \
    return (NAME_NODE *) SLIST_NODE::Next();                          \
  }                     \
  void Insert_After(NAME_NODE *nd) {              \
    SLIST_NODE::Insert_After(nd);               \
  }                     \
  void Insert_Before(NAME_NODE *nd) {             \
    SLIST_NODE::Insert_Before(nd);              \
  }                     \
  NAME_NODE *Remove(NAME_NODE *prev) {              \
    return (NAME_NODE*) SLIST_NODE::Remove(prev);             \
  }                     \
  void Set_Next(NAME_NODE *nd) {              \
    SLIST_NODE::Set_Next(nd);                 \
  }                     \
  INT32  Len(void) const    { return SLIST_NODE::Len(); }             \
  INT    Pos(NAME_NODE *od) { return SLIST_NODE::Pos(od); }           \

Definition at line 532 of file cxx_base.h.