sorts.temp.h

00001 
00007 #ifndef ctl_declarations
00008 #error The 'ctl_declarations' template parameter was not defined.  It should be a string to pass to #include.
00009 #endif
00010 
00011 /*
00012  * Clean up the namespace from dg_patterns.h
00013  */
00014 #define UNDEF_ALL
00015 #include "ctl/dg/blank.h"
00016 
00017 #ifndef NO_RECORD_MOVE
00018 
00019 /****************************************************************************
00020  * \ingroup Patterns
00021  * Move
00022  *
00023  * Generate code to move contents of one record to another
00024  * This is more efficient than to copy and destroy a record when there is 
00025  * allocated data.
00026  *
00027  * Generally most useful for 'vector' data, when inserting/erasing members.
00028  *
00029  ****************************************************************************/
00030 
00035 #define RECORD_MOVES
00036 
00037 /*
00038  * Make protocol
00039  */
00040 #define protocol_begin( label )     enum_begin( label )
00041 
00042 /*
00043  * Make enum
00044  */
00045 #define enum_begin( label )                         void ppConcat(label,_move)( label* dst, label* src ) { *dst = *src; }
00046 #define enum_item( label )
00047 #define enum_end( label )
00048 
00049 
00050 /*
00051  * Make record
00052  */
00053 #define record_begin(label)                         void ppConcat(label,_move)( label* dst, label* src ) \
00054                                                     {\
00055                                                         assertobjptr(dst);\
00056                                                         assertobjptr(src);
00057 #define record_var(label,type,val)                      dst->label = src->label;
00058 #define record_varok(label,type,val,min,max)            dst->label = src->label;
00059 #define record_array(label,type,alen,val)               record_objarray(label,type,alen)
00060 #define record_arrayok(label,type,alen,val,min,max)     record_objarray(label,type,alen)
00061 #define record_objarray(label,type,alen)                {   type* dstcurr = dst->label; \
00062                                                             type* srccurr = src->label; \
00063                                                             const type* pend = dstcurr + (alen); \
00064                                                             while( dstcurr < pend ) \
00065                                                                 ppConcat(type,_move)(dstcurr++,srccurr++);\
00066                                                         }
00067 #define record_achar(label,type,alen,val)               cstrncpy(type)(dst->label,src->label,alen);
00068 #define record_string(label,type)                       ctl_gstring_move(tchar, &dst->label, &src->label );
00069 #define record_obj(label,type)                          ppConcat(type,_move)(&dst->label,&src->label);
00070 #define record_ref(label,type)                          {\
00071                                                             ctl_delete(dst->label); \
00072                                                             ctl_ref(dst->label,src->label); \
00073                                                             ctl_delete(src->label);\
00074                                                         }
00075 #define record_preref(label,type)                       record_ref(label,type)
00076 #define record_enum(label,enum,val)                     dst->label = src->label;
00077 #define record_serial(label)                            { dst->label = src->label; src->label.buff = NULL; }
00078 #define record_serialref(label)                         record_serial(label)
00079 #define record_member(stuff)                            
00080 #define record_atinit(stuff)
00081 #define record_atdestroy(stuff)
00082 #define record_atcopy(stuff)                            
00083 #define record_atmove(stuff)                            {stuff}
00084 #define record_atswap(stuff)
00085 #define record_end(label)                           }
00086 
00087 #define record_alias(label,type)
00088 
00089 /*
00090  * Make union move
00091  */
00092 #define union_begin(label,etype)                    void ppConcat(label,_move)( label* dst, label* src ) \
00093                                                     {\
00094                                                         dst->type = src->type;\
00095                                                         switch( dst->type )\
00096                                                         {
00097 #define union_alias(type,enum)                          case enum:
00098 #define union_member(label,type,enum)                   case enum:\
00099                                                             ppConcat(type,_move)(&dst->obj.label,&src->obj.label);\
00100                                                             break;
00101 #define union_end(label,etype)                          default:\
00102                                                             /* Unknown type */\
00103                                                             throwassert(ppTokStr(ppConcat(label,_move)) ":Unknown type");\
00104                                                             break;\
00105                                                         }\
00106                                                     }
00107 
00108 #define container_array(label,type,size)
00109 #define container_vector(label,type)
00110 #define container_list( label, type )
00111 #define container_map( label, keytype, type )
00112 #define container_multimap( label, keytype, type )
00113 #define container_set( label, type )
00114 #define container_multiset( label, type )
00115 
00116 #define protocol_end( label )       enum_end( label )
00117 
00118 /* Run definitions through translation */
00119 #include ctl_declarations
00120 
00121 /*
00122  * Clean up the namespace 
00123  */
00124 #define UNDEF_ALL
00125 #include "ctl/dg/blank.h"
00126 
00127 #endif /* NO_RECORD_MOVE */
00128 
00129 #ifndef NO_RECORD_SORT
00130 
00131 /****************************************************************************
00132  * \ingroup Patterns
00133  * Swap
00134  *
00135  * Generate code to swap one record to another
00136  * Generally most useful for the vector type, when sorting.
00137  *
00138  ****************************************************************************/
00139 
00144 #define RECORD_SWAPS
00145 
00146 /*
00147  * Make protocol
00148  */
00149 #define protocol_begin( label )     enum_begin( label )
00150 #define protocol_item( type )       enum_item( ppConcat(e,type) )
00151 #define protocol_end( label )       enum_end( label )
00152 
00153 /*
00154  * Make enum
00155  */
00156 #define enum_begin( label )                         void ppConcat(label,_swap)( label* p1, label* p2 ) { label tmp = *p1; *p1 = *p2; *p2 = tmp; }
00157 #define enum_item( label )
00158 #define enum_end( label )
00159 
00160 
00161 /*
00162  * Make record
00163  */
00164 #define record_begin(label)                         void ppConcat(label,_swap)( label* p1, label* p2 ) \
00165                                                     {\
00166                                                         assertobjptr(p1);\
00167                                                         assertobjptr(p2);
00168 #define record_var(label,type,val)                      ppConcat(type,_swap)(&p1->label,&p2->label);
00169 #define record_varok(label,type,val,min,max)            ppConcat(type,_swap)(&p1->label,&p2->label);
00170 #define record_array(label,type,alen,val)               record_objarray(label,type,alen)
00171 #define record_arrayok(label,type,alen,val,min,max)     record_objarray(label,type,alen)
00172 #define record_objarray(label,type,alen)                {   type* p1curr = p1->label; \
00173                                                             type* p2curr = p2->label; \
00174                                                             const type* pend = p1curr + (alen); \
00175                                                             while( p1curr < pend ) \
00176                                                                 ppConcat(type,_swap)(p1curr++,p2curr++);\
00177                                                         }
00178 #define record_achar(label,type,alen,val)               ppConcat(type,_string_swap)( p1->label, p2->label, alen );
00179 #define record_string(label,type)                       ctl_gstring_swap(type, &p1->label, &p2->label );
00180 #define record_obj(label,type)                          ppConcat(type,_swap)(&p1->label,&p2->label);
00181 #define record_ref(label,type)                          { type* tmp = p1->label; p1->label = p2->label; p2->label = tmp; }
00182 #define record_preref(label,type)                       { type* tmp = p1->label; p1->label = p2->label; p2->label = tmp; }
00183 #define record_enum(label,enum,val)                     { enum tmp = p1->label; p1->label = p2->label; p2->label = tmp; }
00184 #define record_serial(label)                            { ctl_serial tmp = p1->label; p1->label = p2->label; p2->label = tmp; }
00185 #define record_serialref(label)                         record_serial(label) 
00186 #define record_member(stuff)                            
00187 #define record_atinit(stuff)
00188 #define record_atdestroy(stuff)
00189 #define record_atcopy(stuff)                            
00190 #define record_atmove(stuff)
00191 #define record_atswap(stuff)                            {stuff}
00192 #define record_end(label)                           }\
00193                                                     ctl_array_qsort_implement(label)
00194 #define record_alias(label,type)
00195 
00196 /*
00197  * Make union swap
00198  */
00199 #define union_begin(label,etype)                    void ppConcat(label,_swap)( label* dst, label* src ) \
00200                                                     {\
00201                                                         if( dst->type == src->type )\
00202                                                         {\
00203                                                             switch( dst->type )\
00204                                                             {
00205 #define union_alias(type,enum)                              case enum:
00206 #define union_member(label,type,enum)                       case enum:\
00207                                                                 ppConcat(type,_swap)(&dst->obj.label,&src->obj.label);\
00208                                                                 break;
00209 #define union_end(label,etype)                              default:\
00210                                                                 throwassert(ppTokStr(ppConcat(label,_swap)) ":Unknown type");\
00211                                                                 break;\
00212                                                             }\
00213                                                         }\
00214                                                         else\
00215                                                         {   /* Probably broken */\
00216                                                             label tmp;\
00217                                                             tmp = *dst;\
00218                                                             *dst = *src;\
00219                                                             *src = tmp;\
00220                                                         }\
00221                                                     }
00222 
00223 #define container_array(label,type,size)
00224 #define container_vector(label,type)
00225 #define container_list( label, type )
00226 #define container_map( label, keytype, type )
00227 #define container_multimap( label, keytype, type )
00228 #define container_set( label, type )
00229 #define container_multiset( label, type )
00230 
00231 /* Run definitions through translation */
00232 #include ctl_declarations
00233 
00234 /*
00235  * Clean up the namespace 
00236  */
00237 #define UNDEF_ALL
00238 #include "ctl/dg/blank.h"
00239 
00240 #endif /* NO_RECORD_SORT */
00241 
00242 #ifndef NO_RECORD_COMPARE
00243 
00244 /****************************************************************************
00245  * \ingroup Patterns
00246  * Compare
00247  *
00248  * Generate code to compare between two instances of record, compatibly with 
00249  * qsort, lsearch, bsearch, etc. functions.
00250  *
00251  * Note that the order of your record's data defines the significance of the 
00252  * sorted data.  If you really mean to sort by Z, then Y, then X, write your
00253  * record definition's members in that order, and you're done.  Otherwise, 
00254  * define a different function of your own to do the same job.  
00255  *
00256  ****************************************************************************/
00257 
00258 /*
00259  * Make protocol
00260  */
00261 #define protocol_begin( label )     enum_begin( label )
00262 #define protocol_item( type )       enum_item( ppConcat(e,type) )
00263 #define protocol_end( label )       enum_end( label )
00264 
00265 /*
00266  * Make enum
00267  */
00268 #define enum_begin( label )                         int ppConcat(label,_compare)( const label* p1, const label* p2 ) { return *p1 - *p2; }\
00269                                                     int ppConcat(label,_rcompare)( const label* p1, const label* p2 ) { return *p2 - *p1; }
00270 #define enum_item( label )
00271 #define enum_end( label )
00272 
00273 /*
00274  * Make record
00275  */
00276 #define record_begin(label)                         int ppConcat(label,_rcompare)( const label* p1, const label* p2 ) { return ppConcat(label,_compare)( p2,p1 ); }\
00277                                                     int ppConcat(label,_compare)( const label* p1, const label* p2 ) \
00278                                                     {\
00279                                                         int result = 0;\
00280                                                         if( p1 == p2 )\
00281                                                             return 0;\
00282                                                         assertobjconst(p1);\
00283                                                         assertobjconst(p2);
00284 #define record_var(label,type,val)                      result = ppConcat(type,_compare)( &p1->label, &p2->label ); if( result ) return result;
00285 #define record_varok(label,type,val,min,max)            result = ppConcat(type,_compare)( &p1->label, &p2->label ); if( result ) return result;
00286 #define record_array(label,type,alen,val)               record_objarray(label,type,alen)
00287 #define record_arrayok(label,type,alen,val,min,max)     record_objarray(label,type,alen)
00288 #define record_objarray(label,type,alen)                {\
00289                                                             size_t count = (alen);\
00290                                                             const type* p1curr = p1->label; \
00291                                                             const type* p2curr = p2->label; \
00292                                                             while( count-- ) \
00293                                                             { \
00294                                                                 result = ppConcat(type,_compare)(p1curr++,p2curr++);\
00295                                                                 if( result )\
00296                                                                     return result;\
00297                                                             }\
00298                                                         }
00299 #define record_achar(label,type,alen,val)               result = cstrncmp(type)(p1->label, p2->label, alen ); if( result ) return result;
00300 #define record_string(label,type)                       result = ctl_mstring_(type,grow, compare )(&p1->label, &p2->label); if( result ) return result;
00301 #define record_obj(label,type)                          result = ppConcat(type,_compare)(&p1->label,&p2->label); if( result ) return result;
00302 #define record_ref(label,type)                          {\
00303                                                             if( !p1->label || !p2->label )\
00304                                                             {\
00305                                                                 if( p1->label > p2->label )\
00306                                                                     return 1;\
00307                                                                 if( p1->label < p2->label )\
00308                                                                     return -1;\
00309                                                             }\
00310                                                             else\
00311                                                             {\
00312                                                                 result = ppConcat(type,_compare)(p1->label,p2->label); if( result ) return result;\
00313                                                             }\
00314                                                         }
00315 #define record_preref(label,type)                       record_ref(label,type)
00316 #define record_enum(label,enum,val)                     result = (int)p1->label - (int)p2->label;  if( result ) return result;
00317 #define record_serial(label)                            {\
00318                                                             size_t s1 = ctl_serial_total( &p1->label );\
00319                                                             size_t s2 = ctl_serial_total( &p2->label );\
00320                                                             if( s1 > s2 )\
00321                                                             {\
00322                                                                 result = memcmp( p1->label.begin,p2->label.begin,s2); if( 0 != result ) return result;\
00323                                                                 return 1;\
00324                                                             }\
00325                                                             else if( s1 < s2 )\
00326                                                             {\
00327                                                                 result = memcmp( p1->label.begin,p2->label.begin,s1); if( 0 != result ) return result;\
00328                                                                 return -1;\
00329                                                             }\
00330                                                             else\
00331                                                             {\
00332                                                                 result = memcmp( p1->label.begin,p2->label.begin,s1); if( 0 != result ) return result;\
00333                                                             }\
00334                                                         }
00335 #define record_serialref(label)                         record_serial(label)
00336 
00337 #define record_member(stuff)                            
00338 #define record_atinit(stuff)                            
00339 #define record_atdestroy(stuff)
00340 #define record_atcopy(stuff)
00341 #define record_atmove(stuff)
00342 #define record_atswap(stuff)
00343 #define record_end(label)                               return result;\
00344                                                     }
00345 #define record_alias(label,type)
00346 
00347 /*
00348  * Make union compare
00349  */
00350 #define union_begin(label,etype)                    int ppConcat(label,_rcompare)( const label* p1, const label* p2 ) { return ppConcat(label,_compare)( p2,p1 ); }\
00351                                                     int ppConcat(label,_compare)( const label* p1, const label* p2 ) \
00352                                                     {\
00353                                                         int diff = p1->type - p2->type;\
00354                                                         if( diff )\
00355                                                             return diff;\
00356                                                         switch( p1->type )\
00357                                                         {
00358 #define union_alias(type,enum)                          case enum:
00359 #define union_member(label,type,enum)                   case enum:\
00360                                                             return ppConcat(type,_compare)(&p1->obj.label,&p2->obj.label);
00361 #define union_end(label,etype)                          default:\
00362                                                             /* Unknown type */\
00363                                                             throwassert(ppTokStr(ppConcat(label,_compare)) ":Unknown type");\
00364                                                             break;\
00365                                                         }\
00366                                                         return 0;\
00367                                                     }
00368 
00369 #define container_array(label,type,size)
00370 #define container_vector(label,type)
00371 #define container_list( label, type )
00372 #define container_map( label, keytype, type )
00373 #define container_multimap( label, keytype, type )
00374 #define container_set( label, type )
00375 #define container_multiset( label, type )
00376 
00377 /* Run definitions through translation */
00378 #include ctl_declarations
00379 
00380 /*
00381  * Clean up the namespace 
00382  */
00383 #define UNDEF_ALL
00384 #include "ctl/dg/blank.h"
00385 
00386 #endif /* NO_RECORD_COMPARE */
00387 

Generated on Fri Jan 2 15:28:35 2009 for Squat by  doxygen 1.5.6