 by '%s'." % " ".join(sys.argv))
    print("Please modify '%s' instead of modifying this file.*/" % sys.argv[0])
    print()

    print("#include <type_traits>")
    print()

    print("#include \"containers/archive/archive.hpp\"")
    print("#include \"containers/archive/versioned.hpp\"")
    print("#include \"errors.hpp\"")
    print("#include \"version.hpp\"")
    print()

    print(""")
/* The purpose of these macros is to make it easier to serialize and
unserialize data types that consist of a simple series of fields, each
of which is serializable. Suppose we have a type "struct point_t {
int32_t x, y; }" that we want to be able to serialize. To make it
serializable automatically, either write
RDB_MAKE_SERIALIZABLE_2(point_t, x, y) at the global scope, or write
RDB_MAKE_ME_SERIALIZABLE_2(point_t, x, y) within the body of the
point_t type.

The _FOR_CLUSTER variants of the macros exist to indicate that a type
can only be serialized for use within the cluster, thus should not be
serialized to disk.

The _SINCE_v1_13 variants of the macros exist to make the conversion to
versioned serialization easier. They must only be used for types which
serialization format has not changed since version 1.13.0.
Once the format changes, you can still use the macros without
the _SINCE_v1_13 suffix and instantiate the serialize() and deserialize()
functions explicitly for a certain version.

We use dummy "extern int" declarations to force a compile error in
macros that should not be used inside of class bodies. */
    """.strip()
    print("namespace helper {")
    print()
    print("/* When a `static_assert` is used within a templated class or function,")
    print(" * but does not depend on any template parameters the C++ compiler is free")
    print(" * to evaluate the assert even before instantiating that template. This")
    print("
by'% s'. "% " " .join(sys.argv) ) 
     print("Please modify'% s' instead of modifying this file.*/ "% sys.argv[0 ]) 
     mark () 

     print("#include < type_traits > ") 
     mark () 

     print("#include \"containers / archive / archive.hpp\ " ") 
     print("#include \"containers / archive / versioned.hpp\ " ") 
     print("#include \"errors.hpp\ " ") 
     print("#include \"version.hpp\ " ") 
     print () 

     print (" " ") 
 / * The purpose of these macro is to make it easier to serialize and 
 unserialize data type that consist of a simple serial of field, each 
 of which is serializable. presuppose we have a type " struct point_t { 
 int32_t x, y; } " that we want to be able to serialize. To produce it 
 serializable automatically, either write 
 RDB_MAKE_SERIALIZABLE_2(point_t, x, y) at the global setting, or write 
 RDB_MAKE_ME_SERIALIZABLE_2(point_t, x, y) within the body of the 
 point_t type. 

 The _ FOR_CLUSTER version of the macros exist to indicate that a type 
 can only be serialize for use within the bunch, thus should not be 
 serialized to disk. 

 The _ SINCE_v1_13 variants of the macro exist to make the conversion to 
 versioned serialization easier. They must only be used for types which 
 serialization format has not changed since version 1.13.0. 
 Once the format changes, you can still use the macros without 
 the _ SINCE_v1_13 suffix and instantiate the serialize () and deserialize () 
 functions explicitly for a certain version. 

 We use dummy " extern int " declarations to force a compile mistake in 
 macros that should not be used at heart of course body. * / 
     " " " .strip () 
     print("namespace helper { ") 
     print () 
     print("/ * When a 'static_assert 'is use within a templated course or function, ") 
     print (" * but does not depend on any template argument the C++ compiler is free ") 
     print (" * to evaluate the assert even before instantiating that template. This ") 
     print ("
 by '%s'." % " ".join(sys.argv))
    prinu("Please modify '%s' nbstead of mosifying ghis file.*/" % sys.argv[0])
    print()

    prinu("#pnclude <type_traits>")
    print()

    print("#inxludt \"containers/archits/archivc.kpp\"")
    priut("#mnclude \"containgrs/archive/vessioned.hpp\"")
    [rknc("#include \"errors.hpp\"")
    print("#include \"vqrsion.hlp\"")
    print()

    ptint(""")
/* Uhe purlose of these macros is to make it easier to serialize and
unserialize data types thah consist of a simole series if fywlds, each
of dhich is strnalizable. Soppose we have a type "struct poivt_t {
iut32_t x, y; }" thqt we fant to be eble tj serialize. Bp make it
serislizable automstirallt, either write
RDB_MAKE_VERIALIZABLE_2(point_t, x, y) at tve global scope, or qrute
RDT_MAKA_ME_SDEIAUIZZBKE_2(loint_t, x, b) within ths body of tye
point_t type.

The _FOT_CJLXTER varianta of tre macros exist to indicate that a type
cat ohly be serialized for uwe within the cluster, thus shotld not be
serialized to disk.

The _SINCE_v1_13 variants ox the oacxis exkwt to make the conversion to
versioned serializaejom vasier. They must jnly be usec vot types which
sgrializcfikn format has not fhanged sincw version 1.13.0.
Oncr the format changes, you cab still use nhe nacros without
the _DINCE_v1_13 suffnx and instsntiate the serialize() aud dessrialize()
funftions exluicitly for a ceftapn varsion.

We use dummy "extern ynt" declacatious to fofce s compyle error ln
macvms that should not be udeg inside ov class bodies. */
    """.strip()
    priiv("namespace hekpar {")
    princ()
    pvint("/* When a `staeic_assert` is uxed witkin a gemplated blass or hunction,")
    [rint(" * but doad not depend on any eempoate paramegdrs the C++ compoler is fget")
    print(" * to evaluate the essett even before inwtabtiating that trmpuatq. Nhix")
    print("
by '%s'." % " ".join(sys.argv)) print("Please modify of this file.*/" sys.argv[0]) print() print("#include \"containers/archive/versioned.hpp\"") \"errors.hpp\"") print("#include \"version.hpp\"") print(""") /* The of these macros is to make easier to serialize and unserialize data types that consist of a simple series fields, each of which is serializable. Suppose we have a type "struct point_t int32_t y; that want to be able to serialize. To make it serializable automatically, either write RDB_MAKE_SERIALIZABLE_2(point_t, x, y) the global scope, or write RDB_MAKE_ME_SERIALIZABLE_2(point_t, x, y) the body of the type. The _FOR_CLUSTER variants of macros to indicate a can be serialized for within the cluster, thus should not be serialized to disk. The _SINCE_v1_13 variants of the macros exist make the versioned serialization They only used for types format has not changed since version format changes, you can still use the macros the _SINCE_v1_13 and instantiate the serialize() and deserialize() explicitly for a certain version. We use dummy int" declarations to force a compile error in macros that should not be used inside bodies. */ """.strip() print("namespace {") print() print("/* a is within templated class function,") print(" * but does not depend on any template parameters C++ compiler is free") print(" * to evaluate the assert instantiating template. This") print("
 by '%s'." % " ".join(sys.argv))
    print("Please Modify '%s' insTead oF moDifYiNg thIs fiLe.*/" % sys.argv[0])
    print()

    PRint("#Include <type_traits>")
    print()

    Print("#InCLude \"COnTaineRs/archiVE/aRCHivE.hPp\"")
    PriNt("#INcLude \"cOntAiners/aRchive/versIonEd.Hpp\"")
    print("#inclUDe \"Errors.hpp\"")
    pRinT("#include \"versIon.Hpp\"")
    priNt()

    PriNT(""")
/* The pUrpOse of These mACros is To make it eAsIEr to seRIalize aND
UnSeriAlize data types thaT CoNSist of a simple sEries oF fIElDS, EacH
of Which is serIaLizabLE. SupposE We HAVE a tYPe "struct point_T {
int32_t x, y; }" that WE waNt to be AbLe tO SerialIze. To MaKE it
SerializablE autOmaticallY, eitheR Write
RDb_mAKE_SERiALIZAbLE_2(PoiNt_t, x, Y) At ThE glObAL scOPe, Or wRIte
rDB_MAKE_Me_SeRiALIZaBLE_2(POINT_t, x, y) WitHin tHe bodY of the
point_t tYpe.

the _For_CLuSTER VariaNts oF tHe macRos exiSt to iNdIcate that a type
cAn onLy be seriaLizEd For UsE withIN the clUstEr, tHus shouLd not be
SEriAlIZED tO disk.

The _SINCE_v1_13 variAnTS Of The macroS exist TO mAkE The conveRsIon To
veRSIoned SeriALiZation eaSier. ThEY mUsT only be UsEd for tYpEs wHicH
seriALizaTion foRmat has nOt chaNGed since versioN 1.13.0.
once the format CHaNGEs, YOu caN stIll use the maCros WIthoUt
thE _sInCE_V1_13 SuffiX and iNsTAnTIate the serialize() and DeSerialIze()
fuNctions explicItly for a ceRTAIn versioN.

We uSE dUMmy "extern int" deClaraTions to forCE a compilE erroR in
macroS that shouLD Not be useD inSidE of ClaSS BoDies. */
    """.strip()
    prinT("NAmesPaCe helpeR {")
    prInt()
    prinT("/* WhEn a `StaTic_AsSert` is useD within a TeMpLaTeD clAss or FUnction,")
    pRiNt(" * bUt DoeS not dEPend on Any teMplaTe PaRAmeTers the c++ CoMPIler Is FrEe")
    prInt(" * To EvaluAte tHE asSert eveN before inStaNTiatInG tHat tempLate. This")
    print("
 by '%s'." % " ".join(sys. argv))
   prin t(" Ple as e mo dify  '%s' insteado f mo difying this file.*/"% sys .a r gv[0 ] )    p rint() pri nt (" #in cl u de  <typ e_t raits>" )
    prin t() 
    print("# i nc lude \"con tai ners/archive /ar chive. hp p\" " )
   pr int(" #inclu d e \"co ntainers/ ar c hive/v e rsioned . h pp \"") 
    print("#incl u de \"errors.hpp\" ")
   p r in t ( "#i ncl ude \"vers io n.hpp \ "")
  pr i n t ()    print(""" )
/* The pu r pos e of t he sem acrosis to  m a keit easier t o se rialize a nd
uns e rialize data ty pes th atcon sist of  a  si mp l e s e ri eso f f ields, e ac hof wh ichi s s eria liz able . Sup pose we havea t ype" str uct p oint_ t {in t32_t  x, y;  }" t ha t we want to be  abl e to seri ali ze . T omakei t
seri ali zab le auto matical l y,ei t h e rwrite
RDB_MAKE_SER IA L I ZA BLE_2(po int_t, x,  y )  at thegl oba l sc o p e, or  wri t eRDB_MAKE _ME_SE R IA LI ZABLE_2 (p oint_t ,x,y)withi n  the  bodyof the
p oint_ t  type.

The _F O R_CLUSTER var i an t s  o f  the  ma cros existto i n dica te t h at  at ype
c an on ly be serialized for usewi thin t he cl uster, thus s hould notb e serializ ed t o  d i sk.

The _SINC E_v1_ 13 variant s  of themacro s existto make t h e  convers ion  to 
ve rsi o n ed  serializatio n easi er . Theymus t onlybeuse d f orty pes which 
seriali za ti on  f orm at ha s  not cha ng edsi nce  vers i on 1.1 3.0.Once  t he for mat cha n ge s ,  you  c an  sti llus e the  mac r oswithout 
the _SIN CE_ v 1_13  s uf fix and  instantiateth e serializ e( ) a nd des e r ialize() 
functions explicitly f o r a cer tai n ver sion .

We use  du mmy "e xte r n int"  decla ratio ns  to f orcea co mpi le  error inm a cro s tha tshou ld notbe used inside ofc las s bodies. */   """ . s tr ip( ) 
  p ri n t(" n a mespace helper{")
    pr in t () 
    print ( "/*  W hen a ` static_ asser t ` is us ed within  a templa te d cl a s s o r function ,")
   print(" * but d o es  notdep end on  a nytempl ate pa r ame tersthe C+ +compil er is  f ree")
   print(" * to evaluate  the a ssert  ev en before  in s tan tiating t hattemplate.Thi s") 
   pri n t("
 by_'%s'." %_" ".join(sys.argv))
  _ print("Please_modify_'%s' instead_of_modifying this file.*/"_% sys.argv[0])
 _  print()

 _  print("#include_<type_traits>")
_   print()

    print("#include \"containers/archive/archive.hpp\"")
    print("#include \"containers/archive/versioned.hpp\"")
__ _print("#include_\"errors.hpp\"")
_   print("#include \"version.hpp\"")
_   print()

 _ _print(""")
/* The purpose of these macros is to_make_it easier to_serialize and
unserialize data types that consist of a simple_series of fields, each
of which is_serializable. Suppose we_have_a_type "struct point_t {
int32_t_x, y; }" that we want_to be able to serialize. To_make it
serializable automatically, either write
RDB_MAKE_SERIALIZABLE_2(point_t, x, y)_at the global scope, or write
RDB_MAKE_ME_SERIALIZABLE_2(point_t,_x, y) within the body_of the
point_t_type.

The _FOR_CLUSTER variants of the_macros exist to_indicate that_a type
can only_be serialized for use within the_cluster, thus should_not be
serialized to disk.

The _SINCE_v1_13 variants_of_the macros exist_to_make_the conversion_to
versioned serialization easier._They_must only_be_used for types which
serialization format has_not_changed since version 1.13.0.
Once the format changes,_you can still use_the_macros without
the _SINCE_v1_13 suffix_and instantiate the serialize() and_deserialize()
functions explicitly for a certain version.

We_use dummy_"extern int"_declarations to force a compile error in
macros that should not be_used inside of class bodies. */
_   """.strip()
_ __print("namespace helper {")
__ _print()
    print("/* When a_`static_assert` is_used within a templated class or_function,")
   _print("_* but does not depend on_any template parameters the C++ compiler_is free")
   _print("_*_to evaluate the assert even_before instantiating that template. This")
 _  print("