patterns.h

#ifndef ctl_declarations
#error The 'ctl_declarations' template parameter was not defined.  It should be a string defined before #include.
#endif

#ifndef DATAGEN_H
#include "ctl/dg/datagen.h"
#endif

#define UNDEF_ALL
#include "ctl/dg/blank.h"

/****************************************************************************
 * \ingroup Patterns
 * Declare a protocol
 * 
 * This defines a basic naming convention and code body for enumeration 
 * handlers.  Declaring it like this makes auto-generating a switch or a 
 * lookup table very straight-forward.  
 * 
 * The following code defines the protocol pattern
 * 
 *  protocol_begin( label )
 *      data decls
 *      ...
 *  protocol_end( label )
 ****************************************************************************/

#define protocol_begin( label )


/****************************************************************************
 * \ingroup Patterns
 * Declare an enumeration
 * 
 * This defines a basic naming convention and code body for enumeration 
 * handlers.  Declaring it like this makes auto-generating a switch or a 
 * lookup table very straight-forward.  
 * 
 * The following code defines the enumeration pattern
 * 
 *  enum_begin( label )
 *      enum_item( label )
 *      ...
 *  enum_end( label )
 ****************************************************************************/

#define enum_begin( label )             typedef enum {

#define enum_item( label )                  label,

#define enum_end( label )                   enum_count( label )\
                                        } label;\
                                        extern const bool ppConcat(label,_isscalar);\
                                        extern const char* const ppConcat(szz,label)[];


/****************************************************************************
 * \ingroup Patterns
 * Declare a class/struct/record
 *
 * A record basically produces a C structure that native C code can make 
 * normal use of, while generating all the glue that would normally need to
 * be separately written and maintained.
 *
 * The following code defines the record pattern
 * 
 *  record_begin(label)
 *      record_var(label,type,val)
 *      record_varok(label,type,val,min,max)
 *      record_array(label,type,alen,val)
 *      record_arrayok(label,type,alen,val,min,max)
 *      record_objarray(label,type,alen)
 *      record_achar(label,type,alen,val)
 *      record_string(label,type)
 *      record_obj(label,type)
 *      record_ref(label,type)
 *      record_preref(label,type)
 *      record_enum(label,type,val)
 *      record_member(stuff)
 *      record_serial(label)
 *      record_serialref(label)
 *      record_atinit(stuff)
 *      record_atdestroy(stuff)
 *      ...
 *  record_end(label)
 * 
 ****************************************************************************/

#define record_begin(label)                         typedef struct label {

#define record_var(label,type,val)                      type label;

#define record_varok(label,type,val,min,max)            type label;

#define record_array(label,type,alen,val)               type label[alen];

#define record_arrayok(label,type,alen,val,min,max)     type label[alen];

#define record_objarray(label,type,alen)                type label[alen];

#define record_achar(label,type,alen,val)               type label[alen];

#define record_string(label,type)                       ctl_gstring(type) label;

#define record_obj(label,type)                          type label;

#define record_ref(label,type)                          type* label;

#define record_preref(label,type)                       type* label;

#define record_enum(label,type,val)                     type label;

#define record_serial(label)                            ctl_serial  label;

#define record_serialref(label)                         ctl_serial  label;


#define record_member(stuff)                            stuff

#define RECORD_MEMBERS

#define record_atinit(stuff)

#define record_atdestroy(stuff)

#define record_atcopy(stuff)

#define record_atmove(stuff)

#define record_atswap(stuff)

#define record_end(label)                               ppCPP( public: )    /* C++ code generated if we're building under C++ */\
                                                        ppCPP( const classname& operator=( const label& src ) { ppConcat(label,_destroy)(this); ppConcat(label,_copy)(this,&src); return *this; } )\
                                                    } label;\
                                                    /* These functions are bundled up so we can semi-trivially manufacture record declarations for extensions */\
                                                    ctl_datagen_declare_functions(label);\
                                                    /* Unit test optional randomizer */\
                                                    RANDOMIZER( void ppConcat(label,_randomize)( label* self ); )\


#define record_alias(label,type)

#ifdef MAKE_RANDOMIZE
#define RANDOMIZER(def) def
#else
#define RANDOMIZER(def)
#endif

/****************************************************************************
 * \ingroup Patterns
 * \brief Declare an enumerated union type
 * \param label What to call the record
 * \param etype Enumeration that controls union switch
 * This particular pass makes the enumeration for the union items
 * union_begin(label,etype)
 *  union_member(label,type,enum)
 *  union_alias(type,enum)
 *  union_alias(type,enum)
 *  union_member(label,type,enum)
 *  ...
 * union_end(label,etype)
 ****************************************************************************/
#define union_begin(label,etype)            typedef struct label {\
                                                etype   type;\
                                                union {


#define union_alias(type,enum)

#define union_member(label,type,enum)               type label;

#define union_end(label,etype)                  }   obj;\
                                            } label;\
                                            /* These functions are bundled up so we can semi-trivially manufacture record declarations for extensions */\
                                            ctl_datagen_declare_functions(label);\
                                            /* Unit test optional randomizer */\
                                            RANDOMIZER( void ppConcat(label,_randomize)( label* self ); )\
                                            void ppConcat(label,_setup)( label* self, etype which );\
                                            void ppConcat(label,_reset)( label* self, etype which );

/****************************************************************************
 * \ingroup Patterns
 * Declare various containers
 *
 * In this system, records and containers are tightly integrated, such that 
 * all containers and their contained records are copied, serialized, etc. 
 * correctly.  This manufactures the code to correctly serialize based on 
 * the established structure/class/record patterns.  
 * 
 * All containers are initially empty and consume only their own structure 
 * overhead.  
 * 
 ****************************************************************************/

#define container_array(label,type,size)            ctl_declare_array(label,type,size);

#define container_vector(label,type)                ctl_declare_vector(label,type);

#define container_list(label,type)                  ctl_declare_list(label,type);

#define container_map(label,keytype,type)           ctl_declare_map(label,keytype,type);

#define container_multimap(label,keytype,type)      ctl_declare_multimap(label,keytype,type);

#define container_set(label,type)                   ctl_declare_set(label,type);

#define container_multiset(label,type)              ctl_declare_multiset(label,type);

#define protocol_end( label )

#include ctl_declarations
#define UNDEF_ALL
#include "ctl/dg/blank.h"

#define protocol_begin(label)           typedef enum label {

#define enum_begin( label )
#define enum_item( label )
#define enum_end( label )

#define record_begin(label)                 ppConcat(e,label),
#define record_var(label,type,val)
#define record_varok(label,type,val,min,max)
#define record_array(label,type,alen,val)
#define record_arrayok(label,type,alen,val,min,max)
#define record_objarray(label,type,alen)
#define record_achar(label,type,alen,val)
#define record_string(label,type)
#define record_obj(label,type)
#define record_ref(label,type)
#define record_preref(label,type)
#define record_enum(label,type,val)
#define record_serial(label)
#define record_serialref(label)
#define record_member(stuff)
#define record_atinit(stuff)
#define record_atdestroy(stuff)
#define record_atcopy(stuff)
#define record_atmove(stuff)
#define record_atswap(stuff)
#define record_end(label)

#define record_alias(label,type)            ppConcat(e,label),

#define union_begin(label,etype)            ppConcat(e,label),
#define union_alias(type,enum)
#define union_member(label,type,enum)
#define union_end(label,etype)


#define container_array(label,type,size)
#define container_vector(label,type)
#define container_list(label,type)
#define container_map(label,keytype,type)
#define container_multimap(label,keytype,type)
#define container_set(label,type)
#define container_multiset(label,type)

#define protocol_end(label)                 enum_count( label )\
                                        } label;\
                                        extern const bool ppConcat(label,_isscalar);\
                                        extern const char* const ppConcat(szz,label)[];

#include ctl_declarations
#undef ctl_declarations
#undef ctl_classdef
#define UNDEF_ALL
#include "ctl/dg/blank.h"