//==================================================================================================
// S t a n d a r d                                                                        Interface
// S e r i a l i z a t i o n
//                                                                                By Bruno Bachelet
//==================================================================================================
// Copyright (c) 1999-2016
// Bruno Bachelet - bruno@nawouak.net - http://www.nawouak.net
//
// This file is part of the B++ Library. This library is free software; you can redistribute it
// and/or modify it under the terms of the GNU Library General Public License as published by the
// Free Software Foundation; either version 2 of the License, or (at your option) any later
// version.
//
// This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
// without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
// the GNU Library General Public License for more details (http://www.gnu.org).

/*DESCRIPTION*/
/* This module provides facilities to serialize objects (i.e. to convert them into sequences of
   bytes). */

// File Name //-------------------------------------------------------------------------------------
#line __LINE__ "standard/serialization.hpp"

// Guardian //--------------------------------------------------------------------------------------
#ifndef guStandardSerialization
#define guStandardSerialization

// Headers //---------------------------------------------------------------------------------------
#include <bpp/standard/maths.hpp> /*INCLUDE*/
#include <deque> /*INCLUDE*/

namespace bpp {

// Importation/Exportation //-----------------------------------------------------------------------
#ifdef STANDARD_DLL
 #define dll_export DLL_EXPORT
#else
 #define dll_export DLL_IMPORT
#endif

// Namespaces //------------------------------------------------------------------------------------
#define public_area  standardSerialization
#define private_area standardSerialization_private

namespace public_area  { /*NAMESPACE*/ using namespace standardMaths; }
namespace private_area { using namespace public_area; }

extern_module_name;

// Initialization //--------------------------------------------------------------------------------
#define iniStandardSerialization
has_initializer;

// Macrocommands //---------------------------------------------------------------------------------
/*ALIAS*/
#define tdMap \
class prKey,class prValue,template <class> class prComparator, \
template <class> class prAllocator,template <class,class,class,class> class prContainer //

/*ALIAS*/
#define tuMap \
prContainer<prKey,prValue,prComparator<prKey>, \
prAllocator< STL_MAP_ALLOCATOR_PARAMETERS(prKey,prValue) > > //

/*ALIAS*/
#define tdPair class prType1,class prType2 //

/*ALIAS*/
#define tuPair std_pair(prType1,prType2) //

/*ALIAS*/
#define tdSequence \
class prType,template <class> class prAllocator,template <class,class> class prContainer //

/*ALIAS*/
#define tuSequence prContainer<prType,prAllocator<prType> > //

/*ALIAS*/
#define tdSet \
class prType,template <class> class prComparator, \
template <class> class prAllocator,template <class,class,class> class prContainer //

/*ALIAS*/
#define tuSet prContainer< prType,prComparator<prType>,prAllocator<prType> > //

/*MACROCOMMAND*/ /* Declares the static methods of a deflator for a given type of objects. */
#define declare_deflator_methods(prType)                                   \
 public_property static tyCardinal deflate(clSerializer &,const prType &); \
 public_property static tyCardinal inflate(clSerializer &,prType &);       \
 public_property static tyCardinal length(tcBinary)                        \

// Types & Classes //-------------------------------------------------------------------------------
namespace public_area {
 //------------------------------------------------------------------------------------------Classes
 class clSerializer;

 template <class prType> class clDeflator;
 //-----------------------------------------------------------------------------------Constant Types
 typedef const clSerializer ctSerializer;
}

namespace private_area {
 template <class prContainer,class prType> class clContainerDeflator;
}

// Functions Interface //---------------------------------------------------------------------------
namespace public_area {
 function void decodeHexa(clString &,ctString &);
 function void decodeHexa(tyBinary,ctString &,tyCardinal &);
 function void encodeHexa(clString &,ctString &);
 function void encodeHexa(clString &,tcBinary,tyCardinal);

 template <class prType> inline clSerializer & operator << (clSerializer &,const prType &);
 template <class prType> inline clSerializer & operator >> (clSerializer &,prType &);

 template <class prType> inline tyCardinal deserialize(prType &,tcBinary);
 template <class prType> inline tyCardinal deserialize(prType &,tcString);
 template <class prType> inline tyCardinal deserialize(prType &,ctString &);

 template <class prType> inline tyCardinal serialize(tyBinary &,const prType &);
 template <class prType> inline tyCardinal serialize(clString &,const prType &);
}

namespace private_area {
 testing_mode (
  function void autoTest(void);
  function void test(void);
 )
}

// Errors //----------------------------------------------------------------------------------------
namespace public_area {
 /*ERROR*/ extern_error erCardinalSize; /* Not enough bytes in cardinal to deserialize. */
 /*ERROR*/ extern_error erIntegerSize; /* Not enough bytes in integer to deserialize. */
}

// Constants & Variables //-------------------------------------------------------------------------
extern_static_constant(private,tcString,goHexaDigitS,?);

// D e f l a t o r  Interface //--------------------------------------------------------------------
namespace public_area {
 /*CLASS clDeflator */
 /* Provides static methods for the serialization of a specific type of objects.
    This generic class must be statically specialized for any type of object. */
 template <class prType> class clDeflator {
  //------------------------------------------------------------------------------------------Public
  /*AMETHOD clDeflator */
  /* Deflates an object into a serializer. Returns the number of bytes it has generated. */
  public_property static tyCardinal deflate(clSerializer &,const prType &) ;//

  /*AMETHOD clDeflator */
  /* Inflates an object from a serializer. Returns the number of bytes it has used. */
  public_property static tyCardinal inflate(clSerializer &,prType &) ;//

  /*AMETHOD clDeflator */
  /* Returns the number of bytes that would be used to inflate an object from a given array. */
  public_property static tyCardinal length(tcBinary) ;//
 };

 /*CLASS clDeflator<tyBoolean> */
 /* Specialization of the <CODE>Deflator</CODE> generic class. */
 template <> class clDeflator<tyBoolean> { declare_deflator_methods(tyBoolean); };

 /*CLASS clDeflator<tyByte> */
 /* Specialization of the <CODE>Deflator</CODE> generic class. */
 template <> class clDeflator<tyByte> { declare_deflator_methods(tyByte); };

 /*CLASS clDeflator<tyCharacter> */
 /* Specialization of the <CODE>Deflator</CODE> generic class. */
 template <> class clDeflator<tyCharacter> { declare_deflator_methods(tyCharacter); };

 /*CLASS clDeflator<tyCardinal> */
 /* Specialization of the <CODE>Deflator</CODE> generic class. */
 template <> class clDeflator<tyCardinal> { declare_deflator_methods(tyCardinal); };

 /*CLASS clDeflator<tyInteger> */
 /* Specialization of the <CODE>Deflator</CODE> generic class. */
 template <> class clDeflator<tyInteger> { declare_deflator_methods(tyInteger); };

 /*CLASS clDeflator<tyReal> */
 /* Specialization of the <CODE>Deflator</CODE> generic class. */
 template <> class clDeflator<tyReal> { declare_deflator_methods(tyReal); };

 /*CLASS clDeflator<tcString> */
 /* Specialization of the <CODE>Deflator</CODE> generic class. */
 template <> class clDeflator<tcString> { declare_deflator_methods(tcString); };

 /*CLASS clDeflator<clString> */
 /* Specialization of the <CODE>Deflator</CODE> generic class. */
 template <> class clDeflator<clString> { declare_deflator_methods(clString); };

 /*CLASS clDeflator<std_pair(?,?)> */
 /* Specialization of the <CODE>Deflator</CODE> generic class. */
 template <tdPair> class clDeflator<tuPair> { declare_deflator_methods(tuPair); };

 #ifndef NEED_MONOLITHIC_TEMPLATE_TEMPLATE
  /*CLASS clDeflator<std_sequence(?)> */
  /* Specialization of the <CODE>Deflator</CODE> generic class. */
  template <tdSequence> class clDeflator<tuSequence> { declare_deflator_methods(tuSequence); };

  /*CLASS clDeflator<std_map(?,?)> */
  /* Specialization of the <CODE>Deflator</CODE> generic class. */
  template <tdMap> class clDeflator<tuMap> { declare_deflator_methods(tuMap); };

  #ifdef NEED_STL_SET_SPECIFIC_DEFLATOR
   /*CLASS clDeflator<std_set(?)> */
   /* Specialization of the <CODE>Deflator</CODE> generic class. */
   template <tdSet> class clDeflator<tuSet> { declare_deflator_methods(tuSet); };
  #endif
 #endif
}

// S e r i a l i z e r  Interface //----------------------------------------------------------------
namespace public_area {
 /*CLASS clSerializer */
 /* Represents a serializer that potentially converts any type of object into a sequence of bytes,
    and vice versa. The serializer stores a sequence of bytes where objects of different kinds
    can be added or retrieved. */
 class clSerializer {
  //-----------------------------------------------------------------------------------------Friends
  template <class prType>                   friend class clDeflator;
  template <class prContainer,class prType> friend class private_area::clContainerDeflator;
  //-------------------------------------------------------------------------------------------Types
  private_property typedef std_deque(tyByte)  clBinaryData;
  private_property typedef const clBinaryData ctBinaryData;
  //-----------------------------------------------------------------------------------------Private
  private_property clBinaryData atBinary;
  //------------------------------------------------------------------------------------------Public
  public_property constructor clSerializer(void);
  public_property constructor clSerializer(ctSerializer &);
  public_property destructor clSerializer(void);

  public_property clSerializer & operator = (ctSerializer &);

  public_property tyCardinal length(void) const;

  public_property tyCardinal loadBinary(tcBinary,tyCardinal);
  public_property tyCardinal loadHexa(tcString);
  public_property tyCardinal loadHexa(ctString &);
  public_property tyCardinal saveBinary(tyBinary) const;
  public_property tyCardinal saveHexa(clString &) const;

  public_property template <class prType> tyCardinal deflate(const prType &);
  public_property template <class prType> tyCardinal inflate(prType &);
 };
}

// C o n t a i n e r D e f l a t o r  Interface //--------------------------------------------------
namespace private_area {
 template <class prContainer,class prType> class clContainerDeflator {
  //------------------------------------------------------------------------------------------Public
  public_property static tyCardinal deflate(clSerializer &,const prContainer &);
  public_property static tyCardinal inflate(clSerializer &,prContainer &);
  public_property static tyCardinal length(tcBinary);
 };
}

// Functions Inline //------------------------------------------------------------------------------
namespace public_area {
 //--------------------------------------------------------------------------------------Operator <<
 /*FUNCTION*/
 /* Serializes an object and stores the resulting sequence of bytes into a serializer. */
 template <class prType>
 inline clSerializer & operator << (clSerializer & agSerializer,const prType & agValue) {
  agSerializer.deflate(agValue);
  return (agSerializer);
 }
 //--------------------------------------------------------------------------------------Operator >>
 /*FUNCTION*/ /* Deserializes an object from the sequence of bytes of a serializer. */
 template <class prType>
 inline clSerializer & operator >> (clSerializer & agSerializer,prType & agValue) {
  agSerializer.inflate(agValue);
  return (agSerializer);
 }
 //--------------------------------------------------------------------------------------Deserialize
 /*FUNCTION*/
 /* Deserializes an object from an array of bytes. Returns the number of bytes used to
    deserialize. */
 template <class prType> inline tyCardinal deserialize(prType & agValue,tcBinary agBinary) {
  clSerializer lcSerializer;

  lcSerializer.loadBinary(agBinary,clDeflator<prType>::length(agBinary));
  return (lcSerializer.inflate(agValue));
 }
 //--------------------------------------------------------------------------------------Deserialize
 /*FUNCTION*/
 /* Deserializes an object from an hexadecimal string. Returns the number of bytes used to
    deserialize. */
 template <class prType> inline tyCardinal deserialize(prType & agValue,tcString agHexa) {
  clSerializer lcSerializer;

  lcSerializer.loadHexa(agHexa);
  return (lcSerializer.inflate(agValue));
 }
 //--------------------------------------------------------------------------------------Deserialize
 /*FUNCTION*/
 /* Deserializes an object from an hexadecimal string. Returns the number of bytes used to
    deserialize. */
 template <class prType> inline tyCardinal deserialize(prType & agValue,clString & agHexa)
 { return (deserialize(agValue,agHexa.data())); }
 //----------------------------------------------------------------------------------------Serialize
 /*FUNCTION*/ /* Serializes an object and stores the resulting sequence of bytes into an array. */
 template <class prType> inline tyCardinal serialize(tyBinary & agBinary,const prType & agValue) {
  tyCardinal   lcLength;
  clSerializer lcSerializer;

  lcLength=lcSerializer.deflate(agValue);
  agBinary=new_array(tyByte,lcLength);
  lcSerializer.saveBinary(agBinary);
  return (lcLength);
 }
 //----------------------------------------------------------------------------------------Serialize
 /*FUNCTION*/
 /* Serializes an object and stores the resulting sequence of bytes into an hexadecimal string. */
 template <class prType> inline tyCardinal serialize(clString & agHexa,const prType & agValue) {
  tyCardinal   lcLength;
  clSerializer lcSerializer;

  lcLength=lcSerializer.deflate(agValue);
  lcSerializer.saveHexa(agHexa);
  return (lcLength);
 }
}

namespace private_area {}

// D e f l a t o r < B o o l e a n >  Inline //-----------------------------------------------------
namespace public_area {
 //------------------------------------------------------------------------------------------Deflate
 /*METHOD clDeflator<tyBoolean> */ /* Deflates a boolean. */
 inline tyCardinal clDeflator<tyBoolean>::deflate(clSerializer & agSerializer,
                                                  tcBoolean & agValue) {
  agSerializer.atBinary.push_back(tyByte(agValue ? 1 : 0));
  return (1);
 }
 //------------------------------------------------------------------------------------------Inflate
 /*METHOD clDeflator<tyBoolean> */ /* Inflates a boolean. */
 inline tyCardinal clDeflator<tyBoolean>::inflate(clSerializer & agSerializer,
                                                  tyBoolean & agValue) {
  agValue=(agSerializer.atBinary.front()!=0);
  agSerializer.atBinary.pop_front();
  return (1);
 }
 //-------------------------------------------------------------------------------------------Length
 /*METHOD clDeflator<tyBoolean> */
 /* Returns the number of bytes that would be used to inflate a boolean from a given array. */
 inline tyCardinal clDeflator<tyBoolean>::length(tcBinary) { return (1); }
}

// D e f l a t o r < B y t e >  Inline //-----------------------------------------------------------
namespace public_area {
 //------------------------------------------------------------------------------------------Deflate
 /*METHOD clDeflator<tyByte> */ /* Deflates a byte. */
 inline tyCardinal clDeflator<tyByte>::deflate(clSerializer & agSerializer,tcByte & agValue) {
  agSerializer.atBinary.push_back(agValue);
  return (1);
 }
 //------------------------------------------------------------------------------------------Inflate
 /*METHOD clDeflator<tyByte> */ /* Inflates a byte. */
 inline tyCardinal clDeflator<tyByte>::inflate(clSerializer & agSerializer,tyByte & agValue) {
  agValue=agSerializer.atBinary.front();
  agSerializer.atBinary.pop_front();
  return (1);
 }
 //-------------------------------------------------------------------------------------------Length
 /*METHOD clDeflator<tyByte> */
 /* Returns the number of bytes that would be used to inflate a byte from a given array. */
 inline tyCardinal clDeflator<tyByte>::length(tcBinary) { return (1); }
}

// D e f l a t o r < C h a r a c t e r >  Inline //-------------------------------------------------
namespace public_area {
 //------------------------------------------------------------------------------------------Deflate
 /*METHOD clDeflator<tyCharacter> */ /* Deflates a character. */
 inline tyCardinal clDeflator<tyCharacter>::deflate(clSerializer & agSerializer,
                                                    tcCharacter & agValue) {
  agSerializer.atBinary.push_back(tyByte(agValue));
  return (1);
 }
 //------------------------------------------------------------------------------------------Inflate
 /*METHOD clDeflator<tyCharacter> */ /* Inflates a character. */
 inline tyCardinal clDeflator<tyCharacter>::inflate(clSerializer & agSerializer,
                                                    tyCharacter & agValue) {
  agValue=tyCharacter(agSerializer.atBinary.front());
  agSerializer.atBinary.pop_front();
  return (1);
 }
 //-------------------------------------------------------------------------------------------Length
 /*METHOD clDeflator<tyCharacter> */
 /* Returns the number of bytes that would be used to inflate a character from a given array. */
 inline tyCardinal clDeflator<tyCharacter>::length(tcBinary) { return (1); }
}

// D e f l a t o r < C a r d i n a l >  Inline //---------------------------------------------------
namespace public_area {
 //------------------------------------------------------------------------------------------Deflate
 /*METHOD clDeflator<tyCardinal> */ /* Deflates a cardinal. */
 inline tyCardinal clDeflator<tyCardinal>::deflate(clSerializer & agSerializer,
                                                   tcCardinal & agValue) {
  agSerializer.atBinary.push_back(tyByte((agValue/256/256/256)%256));
  agSerializer.atBinary.push_back(tyByte((agValue/256/256)%256));
  agSerializer.atBinary.push_back(tyByte((agValue/256)%256));
  agSerializer.atBinary.push_back(tyByte(agValue%256));
  return (4);
 }
 //-------------------------------------------------------------------------------------------Length
 /*METHOD clDeflator<tyCardinal> */
 /* Returns the number of bytes that would be used to inflate a cardinal from a given array. */
 inline tyCardinal clDeflator<tyCardinal>::length(tcBinary) { return (4); }
}

// D e f l a t o r < I n t e g e r >  Inline //-----------------------------------------------------
namespace public_area {
 //------------------------------------------------------------------------------------------Deflate
 /*METHOD clDeflator<tyInteger> */ /* Deflates an integer. */
 inline tyCardinal clDeflator<tyInteger>::deflate(clSerializer & agSerializer,
                                                  tcInteger & agValue) {
  tyInteger  lcModSign  = modSign(agValue);
  tyBoolean  lcNegative = (agValue<0);
  tyCardinal lcLength   = agSerializer.deflate(lcNegative);

  agSerializer.atBinary.push_back(tyByte(lcModSign*((agValue/256/256/256)%256)));
  agSerializer.atBinary.push_back(tyByte(lcModSign*((agValue/256/256)%256)));
  agSerializer.atBinary.push_back(tyByte(lcModSign*((agValue/256)%256)));
  agSerializer.atBinary.push_back(tyByte(lcModSign*(agValue%256)));
  return (lcLength+4);
 }
 //-------------------------------------------------------------------------------------------Length
 /*METHOD clDeflator<tyInteger> */
 /* Returns the number of bytes that would be used to inflate an integer from a given array. */
 inline tyCardinal clDeflator<tyInteger>::length(tcBinary)
 { return (clDeflator<tyBoolean>::length(nil)+4); }
}

// D e f l a t o r < R e a l >  Inline //-----------------------------------------------------------
namespace public_area {
 //------------------------------------------------------------------------------------------Deflate
 /*METHOD clDeflator<tyReal> */ /* Deflates a real number. */
 inline tyCardinal clDeflator<tyReal>::deflate(clSerializer & agSerializer,tcReal & agValue) {
  tcReal lc2Power32 = 4294967296.0;

  tyInteger  lcExponent;
  tyBoolean  lcInfinite;
  tyReal     lcMantissa0;
  tyCardinal lcMantissa1;
  tyCardinal lcMantissa2;
  tyBoolean  lcNegative;

  if (agValue==0.0) {
   lcNegative=false;
   lcInfinite=false;
   lcExponent=integerMin();
   lcMantissa0=0.0;
  }
  else if (agValue>0) {
   lcNegative=false;
   lcInfinite=(agValue==realMax());

   if (not lcInfinite) {
    lcExponent=tyInteger(floor(log2(agValue)));
    lcMantissa0=agValue/power2(lcExponent)-1.0;
   }
  }
  else {
   lcNegative=true;
   lcInfinite=(agValue==realMin());

   if (not lcInfinite) {
    lcExponent=tyInteger(std::floor(log2(-agValue)));
    lcMantissa0=-agValue/power2(lcExponent)-1.0;
   }
  }

  agSerializer.deflate(lcNegative);
  agSerializer.deflate(lcInfinite);

  if (lcInfinite) return (2*clDeflator<tyBoolean>::length(nil));

  // if (lcMantissa0>=-REAL_EPSILON and lcMantissa0<=REAL_EPSILON) lcMantissa0=0.0;

  // if (lcMantissa0>=1.0-REAL_EPSILON and lcMantissa0<=1.0+REAL_EPSILON) {
  //  lcMantissa0=0.0;
  //  ++lcExponent;
  // }

  lcMantissa1=tyCardinal(floor(lcMantissa0*lc2Power32));
  lcMantissa2=tyCardinal(floor((lcMantissa0*lc2Power32-lcMantissa1)*lc2Power32));
  agSerializer.deflate(lcExponent);
  agSerializer.deflate(lcMantissa1);
  agSerializer.deflate(lcMantissa2);

  return (2*clDeflator<tyBoolean>::length(nil) + clDeflator<tyInteger>::length(nil)
          + 2*clDeflator<tyCardinal>::length(nil));
 }
 //------------------------------------------------------------------------------------------Inflate
 /*METHOD clDeflator<tyReal> */ /* Inflates a real number. */
 inline tyCardinal clDeflator<tyReal>::inflate(clSerializer & agSerializer,tyReal & agValue) {
  tcReal lc2Power32 = 4294967296.0;

  tyInteger  lcExponent;
  tyBoolean  lcInfinite;
  tyCardinal lcMantissa1;
  tyCardinal lcMantissa2;
  tyBoolean  lcNegative;

  agSerializer.inflate(lcNegative);
  agSerializer.inflate(lcInfinite);

  if (lcInfinite) {
   agValue=(lcNegative ? realMin() : realMax());
   return (2*clDeflator<tyBoolean>::length(nil));
  }

  agSerializer.inflate(lcExponent);
  agSerializer.inflate(lcMantissa1);
  agSerializer.inflate(lcMantissa2);

  agValue = (lcNegative ? -1.0 : 1.0)
            * (1.0+(lcMantissa2/lc2Power32+lcMantissa1)/lc2Power32) * power2(lcExponent);

  return (2*clDeflator<tyBoolean>::length(nil) + clDeflator<tyInteger>::length(nil)
          + 2*clDeflator<tyCardinal>::length(nil));
 }
 //-------------------------------------------------------------------------------------------Length
 /*METHOD clDeflator<tyReal> */
 /* Returns the number of bytes that would be used to inflate a real number from a given array. */
 inline tyCardinal clDeflator<tyReal>::length(tcBinary agBinary) {
  tyBoolean lcInfinite;

  deserialize(lcInfinite,agBinary+1);

  if (lcInfinite) return (2*clDeflator<tyBoolean>::length(nil));

  return (2*clDeflator<tyBoolean>::length(nil) + clDeflator<tyInteger>::length(nil)
          + 2*clDeflator<tyCardinal>::length(nil));
 }
}

// D e f l a t o r < S t r i n g >  Inline //-------------------------------------------------------
namespace public_area {
 //------------------------------------------------------------------------------------------Deflate
 /*METHOD clDeflator<clString> */ /* Deflates a string. */
 inline tyCardinal clDeflator<clString>::deflate(clSerializer & agSerializer,ctString & agValue)
 { return (agSerializer.deflate<tcString>(agValue.data())); }
 //------------------------------------------------------------------------------------------Inflate
 /*METHOD clDeflator<clString> */ /* Inflates a string. */
 inline tyCardinal clDeflator<clString>::inflate(clSerializer & agSerializer,clString & agValue) {
  tyCardinal lcLength;
  tcString   lcString;

  lcLength=clDeflator<tcString>::inflate(agSerializer,lcString);
  agValue=lcString;
  delete_array(tyString(lcString));

  return (lcLength);
 }
 //-------------------------------------------------------------------------------------------Length
 /*METHOD clDeflator<tcString> */
 /* Returns the number of bytes that would be used to inflate a string from a given array. */
 inline tyCardinal clDeflator<tcString>::length(tcBinary agBinary) {
  tyCardinal lcLength;

  deserialize(lcLength,agBinary);
  return (clDeflator<tyCardinal>::length(nil) + clDeflator<tyCharacter>::length(nil)*lcLength);
 }
 //-------------------------------------------------------------------------------------------Length
 /*METHOD clDeflator<clString> */
 /* Returns the number of bytes that would be used to inflate a string from a given array. */
 inline tyCardinal clDeflator<clString>::length(tcBinary agBinary)
 { return (clDeflator<tcString>::length(agBinary)); }
}

// D e f l a t o r < P a i r >  Inline //-----------------------------------------------------------
namespace public_area {
 //------------------------------------------------------------------------------------------Deflate
 /*METHOD clDeflator<std_pair(?,?)> */ /* Deflates a pair of objects. */
 template <tdPair> inline tyCardinal clDeflator<tuPair>::deflate(clSerializer & agSerializer,
                                                                 const tuPair & agPair) {
  tyCardinal lcLength = agSerializer.deflate(agPair.first);

  lcLength+=agSerializer.deflate(agPair.second);
  return (lcLength);
 }
 //------------------------------------------------------------------------------------------Inflate
 /*METHOD clDeflator<std_pair(?,?)> */ /* Inflates a pair of objects. */
 template <tdPair> inline tyCardinal clDeflator<tuPair>::inflate(clSerializer & agSerializer,
                                                                 tuPair & agPair) {
  tyCardinal lcLength = agSerializer.inflate(agPair.first);

  lcLength+=agSerializer.inflate(agPair.second);
  return (lcLength);
 }
 //-------------------------------------------------------------------------------------------Length
 /*METHOD clDeflator<std_pair(?,?)> */
 /* Returns the number of bytes that would be used to inflate a pair of objects from a given
    array. */
 template <tdPair> inline tyCardinal clDeflator<tuPair>::length(tcBinary agBinary) {
  tyCardinal lcLength1 = clDeflator<prType1>::length(agBinary);
  tyCardinal lcLength2 = clDeflator<prType2>::length(agBinary+lcLength1);

  return (lcLength1+lcLength2);
 }
}

// D e f l a t o r < S e q u e n c e >  Inline //---------------------------------------------------
namespace public_area {
 #ifdef NEED_MONOLITHIC_TEMPLATE_TEMPLATE
  template <tdSequence> class clDeflator<tuSequence> {
 #endif

 //------------------------------------------------------------------------------------------Deflate
 #ifndef NEED_MONOLITHIC_TEMPLATE_TEMPLATE
  /*METHOD clDeflator<std_sequence(?)> */ /* Deflates an STL sequence container. */
  template <tdSequence>
  inline tyCardinal clDeflator<tuSequence>::deflate(clSerializer & agSerializer,
                                                    const tuSequence & agContainer) {
 #else
  public_property inline static tyCardinal deflate(clSerializer & agSerializer,
                                                   const tuSequence & agContainer) {
 #endif

  return (private_area::clContainerDeflator<tuSequence,prType>::deflate(agSerializer,agContainer));
 }
 //------------------------------------------------------------------------------------------Inflate
 #ifndef NEED_MONOLITHIC_TEMPLATE_TEMPLATE
  /*METHOD clDeflator<std_sequence(?)> */ /* Inflates an STL sequence container. */
  template <tdSequence>
  inline tyCardinal clDeflator<tuSequence>::inflate(clSerializer & agSerializer,
                                                    tuSequence & agContainer) {
 #else
  public_property inline static tyCardinal inflate(clSerializer & agSerializer,
                                                   tuSequence & agContainer) {
 #endif

  return (private_area::clContainerDeflator<tuSequence,prType>::inflate(agSerializer,agContainer));
 }
 //-------------------------------------------------------------------------------------------Length
 #ifndef NEED_MONOLITHIC_TEMPLATE_TEMPLATE
  /*METHOD clDeflator<std_sequence(?)> */
  /* Returns the number of bytes that would be used to inflate an STL sequence container from a
     given array. */
  template <tdSequence> inline tyCardinal clDeflator<tuSequence>::length(tcBinary agBinary) {
 #else
  public_property inline static tyCardinal length(tcBinary agBinary) {
 #endif

  return (private_area::clContainerDeflator<tuSequence,prType>::length(agBinary));
 }

 #ifdef NEED_MONOLITHIC_TEMPLATE_TEMPLATE
  };
 #endif
}

// D e f l a t o r < M a p >  Inline //-------------------------------------------------------------
namespace public_area {
 #ifdef NEED_MONOLITHIC_TEMPLATE_TEMPLATE
  template <tdMap> class clDeflator<tuMap> {
 #endif

 //------------------------------------------------------------------------------------------Deflate
 #ifndef NEED_MONOLITHIC_TEMPLATE_TEMPLATE
  /*METHOD clDeflator<std_map(?,?)> */ /* Deflates an STL map container. */
  template <tdMap> inline tyCardinal clDeflator<tuMap>::deflate(clSerializer & agSerializer,
                                                                const tuMap & agContainer) {
 #else
  public_property inline static tyCardinal deflate(clSerializer & agSerializer,
                                                   const tuMap & agContainer) {
 #endif

  return (private_area::clContainerDeflator<tuMap,std_pair(prKey,prValue)>::deflate(agSerializer,
                                                                                    agContainer));
 }
 //------------------------------------------------------------------------------------------Inflate
 #ifndef NEED_MONOLITHIC_TEMPLATE_TEMPLATE
  /*METHOD clDeflator<std_map(?,?)> */ /* Inflates an STL map container. */
  template <tdMap> inline tyCardinal clDeflator<tuMap>::inflate(clSerializer & agSerializer,
                                                                tuMap & agContainer) {
 #else
  public_property inline static tyCardinal inflate(clSerializer & agSerializer,
                                                   tuMap & agContainer) {
 #endif

  return (private_area::clContainerDeflator<tuMap,std_pair(prKey,prValue)>::inflate(agSerializer,
                                                                                    agContainer));
 }
 //-------------------------------------------------------------------------------------------Length
 #ifndef NEED_MONOLITHIC_TEMPLATE_TEMPLATE
  /*METHOD clDeflator<std_map(?,?)> */
  /* Returns the number of bytes that would be used to inflate an STL map container from a given
     array. */
  template <tdMap> inline tyCardinal clDeflator<tuMap>::length(tcBinary agBinary) {
 #else
  public_property inline static tyCardinal length(tcBinary agBinary) {
 #endif

  return (private_area::clContainerDeflator<tuMap,std_pair(prKey,prValue)>::length(agBinary));
 }

 #ifdef NEED_MONOLITHIC_TEMPLATE_TEMPLATE
  };
 #endif
}

// D e f l a t o r < S e t >  Inline //-------------------------------------------------------------
namespace public_area {
 #ifdef NEED_STL_SET_SPECIFIC_DEFLATOR
  #ifdef NEED_MONOLITHIC_TEMPLATE_TEMPLATE
   template <tdSet> class clDeflator<tuSet> {
  #endif

  //-----------------------------------------------------------------------------------------Deflate
  #ifndef NEED_MONOLITHIC_TEMPLATE_TEMPLATE
   /*METHOD clDeflator<std_set(?)> */ /* Deflates an STL set container. */
   template <tdSet> inline tyCardinal clDeflator<tuSet>::deflate(clSerializer & agSerializer,
                                                                 const tuSet & agContainer) {
  #else
   public_property inline static tyCardinal deflate(clSerializer & agSerializer,
                                                    const tuSet & agContainer) {
  #endif

   return (private_area::clContainerDeflator<tuSet,prType>::deflate(agSerializer,agContainer));
  }
  //-----------------------------------------------------------------------------------------Inflate
  #ifndef NEED_MONOLITHIC_TEMPLATE_TEMPLATE
   /*METHOD clDeflator<std_set(?)> */ /* Inflates an STL set container. */
   template <tdSet> inline tyCardinal clDeflator<tuSet>::inflate(clSerializer & agSerializer,
                                                                 tuSet & agContainer) {
  #else
   public_property inline static tyCardinal inflate(clSerializer & agSerializer,
                                                    tuSet & agContainer) {
  #endif

   return (private_area::clContainerDeflator<tuSet,prType>::inflate(agSerializer,agContainer));
  }
  //------------------------------------------------------------------------------------------Length
  #ifndef NEED_MONOLITHIC_TEMPLATE_TEMPLATE
   /*METHOD clDeflator<std_set(?)> */
   /* Returns the number of bytes that would be used to inflate an STL set container from a given
      array. */
   template <tdSet> inline tyCardinal clDeflator<tuSet>::length(tcBinary agBinary) {
  #else
   public_property inline static tyCardinal length(tcBinary agBinary) {
  #endif

   return (private_area::clContainerDeflator<tuSet,prType>::length(agBinary));
  }

  #ifdef NEED_MONOLITHIC_TEMPLATE_TEMPLATE
   };
  #endif
 #endif
}

// S e r i a l i z e r  Inline //-------------------------------------------------------------------
namespace public_area {
 //--------------------------------------------------------------------------------------Constructor
 /*METHOD clSerializer */ /* Builds a serializer. */
 inline clSerializer::clSerializer(void) : atBinary() {}
 //--------------------------------------------------------------------------------------Constructor
 /*METHOD clSerializer */ /* Builds a copy of a serializer. */
 inline clSerializer::clSerializer(ctSerializer & agSerializer)
 : atBinary(agSerializer.atBinary) {}
 //---------------------------------------------------------------------------------------Destructor
 /*METHOD clSerializer */ /* Destructs a serializer. */
 inline clSerializer::~clSerializer(void) {}
 //---------------------------------------------------------------------------------------Operator =
 /*METHOD clSerializer */ /* Copies a serializer. */
 inline clSerializer & clSerializer::operator = (ctSerializer & agSerializer) {
  atBinary=agSerializer.atBinary;
  return (*this);
 }
 //-------------------------------------------------------------------------------------------Length
 /*METHOD clSerializer */
 /* Returns the length of the sequence of bytes stored in the serializer. */
 inline tyCardinal clSerializer::length(void) const { return atBinary.size(); }
 //-----------------------------------------------------------------------------------------LoadHexa
 /*METHOD clSerializer */
 /* Loads an hexadecimal string into the serializer's sequence of bytes. Returns the number of
    bytes actually loaded. */
 inline tyCardinal clSerializer::loadHexa(ctString & agHexa) { return (loadHexa(agHexa.data())); }
 //------------------------------------------------------------------------------------------Deflate
 /*METHOD clSerializer */
 /* Deflates an object into the serializer. Returns the number of bytes it has generated. */
 template <class prType> inline tyCardinal clSerializer::deflate(const prType & agValue)
 { return (clDeflator<prType>::deflate(*this,agValue)); }
 //------------------------------------------------------------------------------------------Inflate
 /*METHOD clSerializer */
 /* Inflates an object from the serializer. Returns the number of bytes it has used. */
 template <class prType> inline tyCardinal clSerializer::inflate(prType & agValue)
 { return (clDeflator<prType>::inflate(*this,agValue)); }
}

// C o n t a i n e r D e f l a t o r  Implementation //---------------------------------------------
namespace private_area {
 //------------------------------------------------------------------------------------------Deflate
 template <class prContainer,class prType>
 tyCardinal clContainerDeflator<prContainer,prType>::deflate(clSerializer & agSerializer,
                                                             const prContainer & agContainer) {
  clSerializer lcSerializer;

  tyCardinal lcLength  = 0;
  tyCardinal lcStart   = agSerializer.atBinary.size();
  tyCardinal lcCounter = agSerializer.deflate(tyCardinal(0));

  typename prContainer::const_iterator lcCurrentElement = agContainer.begin();
  typename prContainer::const_iterator lcLastElement    = agContainer.end();

  while (lcCurrentElement!=lcLastElement) {
   agSerializer.deflate(*lcCurrentElement);
   ++lcCurrentElement;
   ++lcLength;
  }

  lcSerializer.deflate(lcLength);

  while (lcCounter>0) {
   --lcCounter;
   agSerializer.atBinary[lcStart+lcCounter]=lcSerializer.atBinary[lcCounter];
  }

  return (agSerializer.atBinary.size()-lcStart);
 }
 //------------------------------------------------------------------------------------------Inflate
 template <class prContainer,class prType>
 tyCardinal clContainerDeflator<prContainer,prType>::inflate(clSerializer & agSerializer,
                                                             prContainer & agContainer) {
  prType     lcElement;
  tyCardinal lcLength;
  tyCardinal lcTotalLength;

  tyCardinal lcCounter = 0;

  agContainer.erase(agContainer.begin(),agContainer.end());
  lcTotalLength=agSerializer.inflate(lcLength);

  while (lcCounter<lcLength) {
   lcTotalLength+=agSerializer.inflate(lcElement);
   agContainer.insert(agContainer.end(),lcElement);
   ++lcCounter;
  }

  return (lcTotalLength);
 }
 //-------------------------------------------------------------------------------------------Length
 template <class prContainer,class prType>
 tyCardinal clContainerDeflator<prContainer,prType>::length(tcBinary agBinary) {
  tyCardinal lcLength;
  tyCardinal lcTotalLength;

  tyCardinal lcCounter = 0;

  deserialize(lcLength,agBinary);
  lcTotalLength=clDeflator<tyCardinal>::length(nil);

  while (lcCounter<lcLength) {
   lcTotalLength+=clDeflator<prType>::length(agBinary+lcTotalLength);
   ++lcCounter;
  }

  return (lcTotalLength);
 }
}

// End //-------------------------------------------------------------------------------------------
}
#undef dll_export
#undef tdMap
#undef tuMap
#undef tdPair
#undef tuPair
#undef tdSequence
#undef tuSequence
#undef tdSet
#undef tuSet
#undef public_area
#undef private_area
#endif
 
//==================================================================================================
// S t a n d a r d                                                                   Implementation
// S e r i a l i z a t i o n
//                                                                                By Bruno Bachelet
//==================================================================================================
// Copyright (c) 1999-2016
// Bruno Bachelet - bruno@nawouak.net - http://www.nawouak.net
//
// This file is part of the B++ Library. This library is free software; you can redistribute it
// and/or modify it under the terms of the GNU Library General Public License as published by the
// Free Software Foundation; either version 2 of the License, or (at your option) any later
// version.
//
// This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
// without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
// the GNU Library General Public License for more details (http://www.gnu.org).

// File Name //-------------------------------------------------------------------------------------
#line __LINE__ "standard/serialization.cpp"

// DLL Belonging //---------------------------------------------------------------------------------
#define STANDARD_DLL

// Headers //---------------------------------------------------------------------------------------
#include <bpp/standard/serialization.hpp> /*INTERFACE*/

namespace bpp {

// Namespaces //------------------------------------------------------------------------------------
#define public_area  standardSerialization
#define private_area standardSerialization_private
#define dll_export   DLL_EXPORT

namespace public_area  {}
namespace private_area {}

static_module_name("Standard/Serialization");

// Initialization //--------------------------------------------------------------------------------
#undef iniStandardSerialization
static_constant(private_area::clInitializer,goInitializer);

// Errors //----------------------------------------------------------------------------------------
namespace public_area {
 static_error erCardinalSize;
 static_error erIntegerSize;
}

// Constants & Variables //-------------------------------------------------------------------------
static_constant(tcString,goHexaDigitS);

// Static Members //--------------------------------------------------------------------------------
namespace public_area  {}
namespace private_area {}

// Functions Implementation //----------------------------------------------------------------------
namespace public_area {
 //---------------------------------------------------------------------------------------DecodeHexa
 /*FUNCTION*/ /* Converts an hexadecimal string into its equivalent plain string. */
 function void decodeHexa(clString & agString,ctString & agHexa) {
  tcString lcHexa   = agHexa.data();
  tyString lcString = new_array(tyCharacter,agHexa.size()/2+1);
  tyString lcTarget = lcString;

  while (*lcHexa!=end_string and *(lcHexa+1)!=end_string) {
   *(lcTarget++) = tyCharacter(16*tyByte(*lcHexa<='9' ? *lcHexa-'0' : *lcHexa-'a'+10)
                               + tyByte(*(lcHexa+1)<='9' ? *(lcHexa+1)-'0' : *(lcHexa+1)-'a'+10));

   lcHexa+=2;
  }

  *lcTarget=end_string;
  agString=lcString;
  delete_array(lcString);
 }
 //---------------------------------------------------------------------------------------DecodeHexa
 /*FUNCTION*/
 /* Converts an hexadecimal string into its equivalent array of bytes. The length of the array
    will be stored in the last argument of the method. The array must have enough space to
    store the conversion. */
 function void decodeHexa(tyBinary agBinary,ctString & agHexa,tyCardinal & agLength) {
  tyString lcHexa   = agHexa.data();
  tyBinary lcTarget = agBinary;

  while (*lcHexa!=end_string and *(lcHexa+1)!=end_string) {
   *(lcTarget++) = tyByte(16*tyByte(*lcHexa<='9' ? *lcHexa-'0' : *lcHexa-'a'+10)
                          + tyByte(*(lcHexa+1)<='9' ? *(lcHexa+1)-'0' : *(lcHexa+1)-'a'+10));

   lcHexa+=2;
  }

  agLength=lcTarget-agBinary;
 }
 //---------------------------------------------------------------------------------------EncodeHexa
 /*FUNCTION*/ /* Converts a plain string into its equivalent hexadecimal string. */
 function void encodeHexa(clString & agHexa,ctString & agString) {
  tyString lcHexa   = new_array(tyCharacter,agString.size()*2+1);
  tcString lcString = agString.data();
  tyString lcTarget = lcHexa;

  while (*lcString!=end_string) {
   *(lcTarget++)=private_area::goHexaDigitS[tyByte(*lcString)/16];
   *(lcTarget++)=private_area::goHexaDigitS[tyByte(*lcString)%16];
   ++lcString;
  }

  *lcTarget=end_string;
  agHexa=lcHexa;
  delete_array(lcHexa);
 }
 //---------------------------------------------------------------------------------------EncodeHexa
 /*FUNCTION*/
 /* Converts an array of bytes into its equivalent hexadecimal string. The length of the array
    must be provided in the last argument of the method. */
 function void encodeHexa(clString & agHexa,tcBinary agBinary,tyCardinal agLength) {
  tcBinary lcEnd    = agBinary+agLength;
  tyString lcHexa   = new_array(tyCharacter,2*agLength+1);
  tyString lcTarget = lcHexa;

  while (agBinary<lcEnd) {
   *(lcTarget++)=private_area::goHexaDigitS[(*agBinary)/16];
   *(lcTarget++)=private_area::goHexaDigitS[(*agBinary)%16];
   ++agBinary;
  }

  *lcTarget=end_string;
  agHexa=lcHexa;
  delete_array(lcHexa);
 }
}

namespace private_area {}

// D e f l a t o r < C a r d i n a l >  Implementation //-------------------------------------------
namespace public_area {
 //------------------------------------------------------------------------------------------Inflate
 /*METHOD clDeflator<tyCardinal> */ /* Inflates a cardinal. */
 property tyCardinal clDeflator<tyCardinal>::inflate(clSerializer & agSerializer,
                                                     tyCardinal & agValue) {
  tyCardinal lcCounter = 0;

  if (sizeof(tyCardinal)<4) send_inline_error(erCardinalSize,"deflator<cardinal>::inflate");
  agValue=0;

  while (lcCounter<4) {
   agValue=(agValue*256)+tyCardinal(agSerializer.atBinary.front());
   agSerializer.atBinary.pop_front();
   ++lcCounter;
  }

  return (4);
 }
}

// D e f l a t o r < I n t e g e r >  Implementation //---------------------------------------------
namespace public_area {
 //------------------------------------------------------------------------------------------Inflate
 /*METHOD clDeflator<tyInteger> */ /* Inflates an integer. */
 property tyCardinal clDeflator<tyInteger>::inflate(clSerializer & agSerializer,
                                                    tyInteger & agValue) {
  tyCardinal lcLength;
  tyBoolean  lcNegative;

  tyCardinal lcCounter = 0;
  tyInteger  lcSign    = 1;

  if (sizeof(tyInteger)<4) send_inline_error(erIntegerSize,"deflator<integer>::inflate");
  lcLength=agSerializer.inflate(lcNegative);
  if (lcNegative) lcSign=-1;
  agValue=0;

  while (lcCounter<4) {
   agValue=(agValue*256)+lcSign*tyInteger(agSerializer.atBinary.front());
   agSerializer.atBinary.pop_front();
   ++lcCounter;
  }

  return (lcLength+4);
 }
}

// D e f l a t o r < S t r i n g >  Implementation //-----------------------------------------------
namespace public_area {
 //------------------------------------------------------------------------------------------Deflate
 /*METHOD clDeflator<tcString> */ /* Deflates a string. */
 property tyCardinal clDeflator<tcString>::deflate(clSerializer & agSerializer,
                                                   const tcString & agValue) {
  clSerializer lcSerializer;

  tyCardinal lcLength  = 0;
  tyCardinal lcStart   = agSerializer.atBinary.size();
  tcString   lcString  = agValue;
  tyCardinal lcCounter = agSerializer.deflate(tyCardinal(0));

  while (*lcString!=end_string) {
   agSerializer.deflate(*(lcString++));
   ++lcLength;
  }

  lcSerializer.deflate(lcLength);

  while (lcCounter>0) {
   --lcCounter;
   agSerializer.atBinary[lcStart+lcCounter]=lcSerializer.atBinary[lcCounter];
  }

  return (clDeflator<tyCardinal>::length(nil) + clDeflator<tyCharacter>::length(nil)*lcLength);
 }
 //------------------------------------------------------------------------------------------Inflate
 /*METHOD clDeflator<tcString> */ /* Inflates a string. */
 property tyCardinal clDeflator<tcString>::inflate(clSerializer & agSerializer,
                                                   tcString & agValue) {
  tyCardinal lcLength;
  tyString   lcString;

  tyCardinal lcCounter = 0;

  agSerializer.inflate(lcLength);
  lcString=new_array(tyCharacter,lcLength+1);

  while (lcCounter<lcLength) {
   agSerializer.inflate(lcString[lcCounter]);
   ++lcCounter;
  }

  lcString[lcCounter]=end_string;
  agValue=lcString;

  return (clDeflator<tyCardinal>::length(nil) + clDeflator<tyCharacter>::length(nil)*lcLength);
 }
}

// S e r i a l i z e r  Implementation //-----------------------------------------------------------
namespace public_area {
 //---------------------------------------------------------------------------------------LoadBinary
 /*METHOD clSerializer */
 /* Loads an array of bytes into the serializer's sequence. Returns the number of bytes actually
    loaded. */
 property tyCardinal clSerializer::loadBinary(tcBinary agBinary,tyCardinal agLength) {
  tyCardinal lcCounter = 0;

  while (lcCounter<agLength) {
   atBinary.push_back(agBinary[lcCounter]);
   ++lcCounter;
  }

  return (agLength);
 }
 //-----------------------------------------------------------------------------------------LoadHexa
 /*METHOD clSerializer */
 /* Loads an hexadecimal string into the serializer's sequence of bytes. Returns the number of
    bytes actually loaded. */
 property tyCardinal clSerializer::loadHexa(tcString agHexa) {
  tcString lcSource = agHexa;

  while (*lcSource!=end_string and *(lcSource+1)!=end_string) {
   atBinary.push_back(tyByte(16*tyByte(*lcSource<='9' ? *lcSource-'0' : *lcSource-'a'+10)
                      + tyByte(*(lcSource+1)<='9' ? *(lcSource+1)-'0' : *(lcSource+1)-'a'+10)));

   lcSource+=2;
  }

  return ((lcSource-agHexa)/2);
 }
 //---------------------------------------------------------------------------------------SaveBinary
 /*METHOD clSerializer */
 /* Saves the serializer's sequence of bytes into an array. Returns the number of bytes actually
    saved. The array must have enough space to store the whole sequence. */
 property tyCardinal clSerializer::saveBinary(tyBinary agBinary) const {
  clBinaryData::const_iterator lcCurrentByte = atBinary.begin();
  clBinaryData::const_iterator lcLastByte    = atBinary.end();
  tyBinary                     lcTarget      = agBinary;

  while (lcCurrentByte!=lcLastByte) *(lcTarget++)=*(lcCurrentByte++);
  return (lcTarget-agBinary);
 }
 //-----------------------------------------------------------------------------------------SaveHexa
 /*METHOD clSerializer */
 /* Saves the serializer's sequence of bytes into an hexadecimal string. Returns the number of
    bytes actually saved. */
 property tyCardinal clSerializer::saveHexa(clString & agHexa) const {
  clBinaryData::const_iterator lcCurrentByte = atBinary.begin();
  tyString                     lcHexa        = new_array(tyCharacter,2*length()+1);
  clBinaryData::const_iterator lcLastByte    = atBinary.end();
  tyString                     lcTarget      = lcHexa;

  while (lcCurrentByte!=lcLastByte) {
   *(lcTarget++)=private_area::goHexaDigitS[(*lcCurrentByte)/16];
   *(lcTarget++)=private_area::goHexaDigitS[(*lcCurrentByte)%16];
   ++lcCurrentByte;
  }

  *lcTarget=0;
  agHexa=lcHexa;
  delete_array(lcHexa);
  return ((lcTarget-lcHexa)/2);
 }
}

// I n i t i a l i z e r  Implementation //---------------------------------------------------------
namespace private_area {
 //--------------------------------------------------------------------------------------------Start
 property void clInitializer::start(void) {
  if (atCounter++ == 0) {
   try {
    #include <bpp/modules.hpp> /*NEED*/
    registerStop(this);
    environment::informInitialization(goModuleName);

    erCardinalSize.create("Not enough bytes in cardinal to deserialize.");
    erIntegerSize.create("Not enough bytes in integer to deserialize.");

    goHexaDigitS = "0123456789abcdef";
   }

   initializer_catch;
  }
 }
 //---------------------------------------------------------------------------------------------Stop
 property void clInitializer::stop(void) { environment::informTermination(goModuleName); }
}

// End //-------------------------------------------------------------------------------------------
}