elst.h

来自「一个google的OCR源码」· C头文件 代码 · 共 1,147 行 · 第 1/4 页

}


/***********************************************************************
 ********************    MACROS    **************************************
 ***********************************************************************/

/***********************************************************************
  QUOTE_IT   MACRO DEFINITION
  ===========================
Replace <parm> with "<parm>".  <parm> may be an arbitrary number of tokens
***********************************************************************/

#define QUOTE_IT( parm ) #parm

/***********************************************************************
  ELISTIZE( CLASSNAME ) MACROS
  ============================

CLASSNAME is assumed to be the name of a class which has a baseclass of
ELIST_LINK.

NOTE:  Because we dont use virtual functions in the list code, the list code
will NOT work correctly for classes derived from this.

The macros generate:
  - An element deletion function:      CLASSNAME##_zapper
  - An element copier function:        CLASSNAME##_copier
  - An element serialiser function"    CLASSNAME##_serialiser
  - An element de-serialiser function" CLASSNAME##_de_serialiser
  - An E_LIST subclass: CLASSNAME##_LIST
  - An E_LIST_ITERATOR subclass:       CLASSNAME##_IT

NOTE: Generated names are DELIBERATELY designed to clash with those for
ELIST2IZE but NOT with those for CLISTIZE and CLIST2IZE

Four macros are provided: ELISTIZE, ELISTIZE_S, ELISTIZEH and ELISTIZEH_S
The ...IZEH macros just define the class names for use in .h files
The ...IZE macros define the code use in .c files
The _S versions define lists which can be serialised.  They assume that
the make_serialise() macro is used in the list element class derived from
ELIST_LINK to define serialise() and de_serialise() members for the list
elements.
***********************************************************************/

/***********************************************************************
  ELISTIZEH( CLASSNAME )  and  ELISTIZEH_S( CLASSNAME ) MACROS

These macros are constructed from 3 fragments ELISTIZEH_A, ELISTIZEH_B and
ELISTIZEH_C.  ELISTIZEH is simply a concatenation of these parts.
ELISTIZEH_S has some additional bits thrown in the gaps.
***********************************************************************/

#define ELISTIZEH_A( CLASSNAME )                                                        \
                                                                                                        \
extern DLLSYM void          CLASSNAME##_zapper(         /*delete a link*/       \
ELIST_LINK*                 link);                      /*link to delete*/   \
                                                                                                        \
extern DLLSYM ELIST_LINK*   CLASSNAME##_copier(         /*deep copy a link*/    \
ELIST_LINK*                 old_element);   /*source link */

#define ELISTIZEH_B( CLASSNAME )                                                        \
                                                                                                        \
/***********************************************************************        \
*                           CLASS - CLASSNAME##_LIST                                                                    \
*                                                                                                       \
*                           List class for class CLASSNAME                                                          \
*                                                                                                       \
**********************************************************************/         \
                                                                                                        \
class DLLSYM                CLASSNAME##_LIST : public ELIST                         \
{                                                                                                       \
public:                                                                                             \
                            CLASSNAME##_LIST():ELIST() {}\
                                                        /* constructor */       \
                                                                                                        \
                            CLASSNAME##_LIST(           /* dont construct */ \
    const CLASSNAME##_LIST&)                            /*by initial assign*/\
    { DONT_CONSTRUCT_LIST_BY_COPY.error( QUOTE_IT( CLASSNAME##_LIST ),      \
                                                        ABORT, NULL ); }                            \
                                                                                                        \
void                        clear()                     /* delete elements */\
    { ELIST::internal_clear( &CLASSNAME##_zapper ); }                               \
                                                                                                        \
                                    ~CLASSNAME##_LIST() /* destructor */        \
    { clear(); }                                                                                \
                                                                                                        \
void                        deep_copy(                  /* become a deep */  \
    const CLASSNAME##_LIST* list)                       /* copy of src list*/\
    { ELIST::internal_deep_copy( &CLASSNAME##_copier, list ); }                 \
                                                                                                        \
void                        operator=(                  /* prevent assign */    \
    const CLASSNAME##_LIST&)                                                                \
    { DONT_ASSIGN_LISTS.error( QUOTE_IT( CLASSNAME##_LIST ),                        \
                                            ABORT, NULL ); }

#define ELISTIZEH_C( CLASSNAME )                                                        \
};                                                                                                      \
                                                                                                        \
                                                                                                        \
                                                                                                        \
/***********************************************************************        \
*                           CLASS - CLASSNAME##_IT                                                                      \
*                                                                                                       \
*                           Iterator class for class CLASSNAME##_LIST                                           \
*                                                                                                       \
*  Note: We don't need to coerce pointers to member functions input             \
*  parameters as these are automatically converted to the type of the base      \
*  type. ("A ptr to a class may be converted to a pointer to a public base      \
*  class of that class")                                                                        \
**********************************************************************/         \
                                                                                                        \
class DLLSYM                CLASSNAME##_IT : public ELIST_ITERATOR                  \
{                                                                                                       \
public:                                                                                             \
                                CLASSNAME##_IT():ELIST_ITERATOR(){}                     \
                                                                                                        \
                                CLASSNAME##_IT(                                             \
CLASSNAME##_LIST*           list):ELIST_ITERATOR(list){}                                \
                                                                                                        \
    CLASSNAME*          data()                                                          \
        { return (CLASSNAME*) ELIST_ITERATOR::data(); }                             \
                                                                                                        \
    CLASSNAME*          data_relative(                                                  \
    inT8                    offset)                                                         \
        { return (CLASSNAME*) ELIST_ITERATOR::data_relative( offset ); }        \
                                                                                                        \
    CLASSNAME*          forward()                                                       \
        { return (CLASSNAME*) ELIST_ITERATOR::forward(); }                          \
                                                                                                        \
    CLASSNAME*          extract()                                                       \
        { return (CLASSNAME*) ELIST_ITERATOR::extract(); }                          \
                                                                                                        \
    CLASSNAME*          move_to_first()                                             \
        { return (CLASSNAME*) ELIST_ITERATOR::move_to_first(); }                    \
                                                                                                        \
    CLASSNAME*          move_to_last()                                                  \
        { return (CLASSNAME*) ELIST_ITERATOR::move_to_last(); }                 \
};

#define ELISTIZEH( CLASSNAME )                                                      \
                                                                                                        \
ELISTIZEH_A( CLASSNAME )                                                                        \
                                                                                                        \
ELISTIZEH_B( CLASSNAME )                                                                        \
                                                                                                        \
ELISTIZEH_C( CLASSNAME )

#define ELISTIZEH_S( CLASSNAME )                                                        \
                                                                                                        \
ELISTIZEH_A( CLASSNAME )                                                                        \
                                                                                                        \
extern DLLSYM void          CLASSNAME##_serialiser(                                     \
FILE*                       f,                                                                  \
ELIST_LINK*                 element);                                                       \
                                                                                                        \
extern DLLSYM ELIST_LINK*   CLASSNAME##_de_serialiser(                                  \
FILE*                       f);                                                             \
                                                                                                        \
ELISTIZEH_B( CLASSNAME )                                                                        \
                                                                                                        \
    void                    dump(                       /* dump to file */   \
    FILE*                   f)                                                                  \
    { ELIST::internal_dump( f, &CLASSNAME##_serialiser );}                      \
                                                                                                        \
    void                    de_dump(                    /* get from file */  \
    FILE*                   f)                                                                  \
    { ELIST::internal_de_dump( f, &CLASSNAME##_de_serialiser );}                \
                                                                                                        \
    void                    serialise_asc(              /*dump to ascii*/       \
    FILE*                   f);                                                                 \
    void                    de_serialise_asc(           /*de-dump from ascii*/\
    FILE*                   f);                                                                 \
                                                                                                        \
make_serialise( CLASSNAME##_LIST )                                                  \
                                                                                                        \
ELISTIZEH_C( CLASSNAME )

/***********************************************************************
  ELISTIZE( CLASSNAME )  and   ELISTIZE_S( CLASSNAME )  MACROS
ELISTIZE_S is a simple extension to ELISTIZE
***********************************************************************/

#define ELISTIZE( CLASSNAME )                                                 \
                                                                                                        \
/***********************************************************************        \
*                           CLASSNAME##_zapper                                                                          \
*                                                                                                       \
*  A function which can delete a CLASSNAME element.  This is passed to the      \
*  generic clear list member function so that when a list is cleared the        \
*  elements on the list are properly destroyed from the base class, even        \
*  though we dont use a virtual destructor function.                                    \
**********************************************************************/         \
                                                                                                        \
DLLSYM void                 CLASSNAME##_zapper(         /*delete a link*/       \
ELIST_LINK*                 link)                       /*link to delete*/  \
{                                                                                                       \
delete (CLASSNAME *) link;                                                                  \
}                                                                                                       \
                                                                                                        \
/***********************************************************************        \
*                           CLASSNAME##_copier                                                                          \
*                                                                                                       \
*  A function which can generate a new, deep copy of a CLASSNAME element.       \
*  This is passed to the generic deep copy list member function so that when  \
*  a list is copied the elements on the list are properly copied from the       \
*  base class, even though we dont use a virtual function.                          \
**********************************************************************/         \
                                                                                                        \
DLLSYM ELIST_LINK*          CLASSNAME##_copier(         /*deep copy a link*/    \
ELIST_LINK*                 old_element)                /*source link*/     \
{                                                                                                       \
    CLASSNAME*          new_element;                                                \
                                                                                                        \
  new_element = new CLASSNAME;  \
  *new_element = *reinterpret_cast<CLASSNAME*>(old_element); \
return (ELIST_LINK*) new_element;                                                       \
}

#define ELISTIZE_S( CLASSNAME )                                                     \
                                                                                                        \
ELISTIZE( CLASSNAME )                                                                           \
                                                                                                        \
    void                    CLASSNAME##_LIST::serialise_asc( \
                                                        /*dump to ascii*/       \
    FILE*                   f)                                                                  \
    {                                                                                                   \
        CLASSNAME##_IT      it(this);                                                       \
                                                                                                \
        serialise_INT32(f,length());                                                            \
        for (it.mark_cycle_pt();!it.cycled_list();it.forward())                     \
            it.data()->serialise_asc(f);                /*serialise the list*/\
    }                                                                                                   \
                                                                                                        \
    void                    CLASSNAME##_LIST::de_serialise_asc( \
                                                        /*de-dump from ascii*/\
    FILE*                   f)                                                                  \
    {                                                                                                   \
        inT32               len;                        /*length to retrive*/\
        CLASSNAME##_IT      it;                                                             \
        CLASSNAME*      new_elt=NULL;               /*list element*/        \
                                                                                                \
        len=de_serialise_INT32(f);                                                              \
        it.set_to_list(this);                                                                   \
        for (;len>0;len--)                                                                      \
        {                                                                                               \
            new_elt=new CLASSNAME;                                                              \
            new_elt->de_serialise_asc(f);                                                       \
            it.add_to_end(new_elt);                     /*put on the list*/ \
        }                                                                                               \
        return;                                                                                     \
    }                                                                                                   \
                                                                                                        \
                                                                                                        \
/***********************************************************************        \
*                           CLASSNAME##_serialiser                                                                          \
*                                                                                                       \
*  A function which can serialise an element                                                \
*  This is passed to the generic dump member function so that when a list is  \
*  serialised the elements on the list are properly serialised.                 \
**********************************************************************/         \
                                                                                                        \
DLLSYM void                 CLASSNAME##_serialiser(                                     \
FILE*                       f,                                                                  \
ELIST_LINK*                 element)                                                            \
{                                                                                                       \
((CLASSNAME*) element)->serialise( f );                                                 \
}                                                                                                       \
                                                                                                        \
                                                                                                        \
                                                                                                        \
/***********************************************************************        \
*                           CLASSNAME##_de_serialiser                                                                       \
*                                                                                                       \
*  A function which can de-serialise an element                                         \
*  This is passed to the generic de-dump member function so that when a list  \
*  is de-serialised the elements on the list are properly de-serialised.        \
**********************************************************************/         \
                                                                                                        \
DLLSYM ELIST_LINK*          CLASSNAME##_de_serialiser(                                  \
FILE*                       f)                                                                  \
{                                                                                                       \
return (ELIST_LINK*) CLASSNAME::de_serialise( f );                              \
}
#endif