datagen.h

#ifndef DATAGEN_H
#define DATAGEN_H

#include "ctl/ctldef.h"
#include "ctl/gstring.h"
#include "ctl/algorithm.h"
#include "ctl/xml.h"
#include "ctl/serial.h"
#include "ctl/record.h"

/****************************************************************************

The functions we're looking for

****************************************************************************/

#define ctl_datagen_declare_functions(label)\
    /* Used to clear up certain conditions so we can skip iterations over parts of known size */\
    extern const bool ppConcat(label,_isscalar);\
    /* Initialize this record to a known, default state */\
    void ppConcat(label,_init)( label* self );\
    /* Replicate a record, copying from 'src' to 'dst' */\
    void ppConcat(label,_copy)( label* dst, const label* src );\
    /* Move contents from 'src' to 'dst', leaving 'src' uninitialized. */\
    void ppConcat(label,_move)( label* dst, label* src );\
    /* Swap contents of two records */\
    void ppConcat(label,_swap)( label* p1, label* p2 );\
    /* Declare array sort for this record */\
    ctl_array_qsort_declare(label);\
    /* Compare this record to another record, return <0 if p1<p2, >0 if p2>p1 and 0 if they're equal */\
    int ppConcat(label,_compare)( const label* p1, const label* p2 );\
    /* Compare this record to another record, return >0 if p1<p2, <0 if p2>p1 and 0 if they're equal */\
    int ppConcat(label,_rcompare)( const label* p1, const label* p2 );\
    /* Destroy this record, freeing any contained data */\
    void ppConcat(label,_destroy)( label* self );\
    /* Determine if a record is valid-looking; all validated members in expected range */\
    bool ppConcat(label,_valid)( const label* self );\
    /* Determine total memory footprint of this record */\
    size_t ppConcat(label,_size)( const label* self );\
    /* Determine total size of this record as stingy serial data */\
    size_t ppConcat(label,_serial_size)( const label* self );\
    /* Write data to a stingy serial record */\
    void ppConcat(label,_serial_write)( const label* self, ctl_serial* serial );\
    /* Read data from a stingy serial record */\
    void ppConcat(label,_serial_read)( label* self, ctl_serial* serial );\
    /* Determine total size of this record as robust/archive serial data */\
    size_t ppConcat(label,_record_size)( const label* self, const char* szlabel );\
    /* Write data to a robust binary serial record */\
    void ppConcat(label,_record_write)( const label* self, ctl_serial* serial, const char* szlabel );\
    /* Read data from a robust/archive binary serial record */\
    bool ppConcat(label,_record_read)( label* self, ctl_serial* serial, const char* szlabel );\
    /* Read data from an XML record */\
    bool ppConcat(label,_xml_read)( label* self, ctl_xmlread* xml, const char* szlabel );\
    /* Write data to an XML record */\
    void ppConcat(label,_xml_write)( const label* self, ctl_xmlwrite* xml, const char* szlabel )

#ifndef DG_ARRAY_H
#include "ctl/dg/array.h"
#endif
#ifndef DG_VECTOR_H
#include "ctl/dg/vector.h"
#endif
#ifndef DG_LIST_H
#include "ctl/dg/list.h"
#endif
#ifndef DG_SET_H
#include "ctl/dg/set.h"
#endif
#ifndef DG_MAP_H
#include "ctl/dg/map.h"
#endif


/* Manufacture array sorts for scalars */
#define XSORTS(def,param)   ctl_array_qsort_declare(def);
DEF_ENUMTYPES(XSORTS,unused)
#undef XSORTS

/* Declare scalar qsort comparisons */
#define XCOMPS(type,param)  int ppConcat(type,_compare)( const type* p1, const type* p2 );
DEF_ENUMTYPES(XCOMPS,unused)
#undef XCOMPS

/* Declare reversed scalar qsort comparisons */
#define XCOMPS(type,param)  int ppConcat(type,_rcompare)( const type* p1, const type* p2 );
DEF_ENUMTYPES(XCOMPS,unused)
#undef XCOMPS


void char_string_swap( char* s1, char* s2, size_t count );
void wchar_t_string_swap( wchar_t* s1, wchar_t* s2, size_t count );


/* Manufacture vectors for various types supported by the system */
#define DECL_scalar_vectors(type,unused)        ctl_declare_vector(ppConcat(type,_vector),type);
DEF_ENUMTYPES(DECL_scalar_vectors,unused)
#undef DECL_scalar_vectors

#define enum_count( enum )              ppConcat(enum,_COUNT)

#define enum_isvalid(enum,value)        ( ((unsigned)(value)) < ((unsigned)ppConcat(enum,_COUNT)) )

#define enum_itemname(enum,value)       ( enum_isvalid(enum,value) ? ppConcat(szz,enum)[(value)] : #enum "INVALID" )

#define enum_itemnames( enum )          ppConcat(szz,enum)

#define enum_rand(enum)                 ((enum)(rand() % enum_count( enum )))

#define enum_foreach(enum,iterator)     enum iterator; for ( iterator = (enum)0; iterator < enum_count( enum ); iterator = (enum)(1 + iterator) )

#define enum_foreach_reverse(enum,iterator) enum iterator = enum_count( enum ); while( iterator-- )

#endif /*DATAGEN_H */