 is
    //    achieved by double-checked locking in the ensureInitialized method.
    // 2. Due to type caching, there is at most one lock acqusition for each type (or each specialization of
    //    a generic type), which is constrained by the application. Note that temporary type descriptors
    //    are used only to lookup the cached equivalent and are themselves not initialized.
    // This lock is also used to protect schema def initialization, and the same two points above apply.
    private static final Object initializationLock = new Object();

    // set by the constructor (part of the object identity)
    private final GenericTypeSpecialization genericTypeSpecialization;
    private final int precomputedHashCode;

    // set by the initialization method instead of the constructor since may have cyclic dependencies
    private StructBondType<? super TStruct> baseStructType;
    private StructField<?>[] structFields;

    // cached schema def, thread-safe (atomic) read and write from/to memory
    private volatile SchemaDef schemaDef = null;

    // indicates whether this instance is initialized, thread-safe (atomic) read and write from/to memory
    private volatile boolean isInitialized = false;

    // indicates whether this instance is currently being initialized by the thread holding the global lock;
    // the flag is used to prevent a thread from re-entering initialization method due to cyclic references
    private boolean isCurrentlyInitializing = false;

    /**
     * Used by generated subclasses to instantiate the type descriptor.
     *
     * @param genericTypeSpecialization specialization of a generic struct or null if not a generic struct
     */
    protected StructBondType(GenericTypeSpecialization genericTypeSpecialization) {
        this.genericTypeSpecialization = genericTypeSpecialization;
        precomputedHashCode = this.getClass().hashCode() +
                (genericTypeSpecialization == null? 0 : genericTypeSpecialization.hashCode());
    }

    /**
     * Used by generated subclasses to initialize the base struct reference and fields of the type descriptor.
     * Field types (including fields of the base struct) may refer back to the declaring struct which causes
     * cyclic dependencies, and therefore this initialization is separated from the constructor.
     *
     * @param baseStructType the type descriptor
is 
     //     achieved by double - checked locking in the ensureInitialized method. 
     // 2. Due to type hoard, there be at most one lock acqusition for each type (or each specialization of 
     //     a generic character), which is constrained by the lotion. Note that temporary character descriptors 
     //     are used only to lookup the hoard equivalent and are themselves not initialize. 
     // This lock is also use to protect schema def initialization, and the same two period above apply. 
     private static final Object initializationLock = new Object (); 

     // set by the builder (part of the object identity) 
     private concluding GenericTypeSpecialization genericTypeSpecialization; 
     private final int precomputedHashCode; 

     // set by the initialization method alternatively of the constructor since may have cyclic dependencies 
     private StructBondType <? super TStruct > baseStructType; 
     individual StructField <? > [ ] structFields; 

     // cached schema def, thread - safe (atomic) read and write from / to memory 
     private volatile SchemaDef schemaDef = null; 

     // indicates whether this instance is initialized, thread - safe (atomic) read and write from / to memory 
     individual volatile boolean isInitialized = false; 

     // indicate whether this example is currently being initialized by the screw thread holding the global lock; 
     // the flag is used to prevent a screw thread from re - entering initialization method due to cyclic references 
     private boolean isCurrentlyInitializing = false; 

     / * * 
      * Used by render subclasses to instantiate the type descriptor. 
      * 
      * @param genericTypeSpecialization specialization of a generic struct or null if not a generic struct 
      * / 
     protect StructBondType(GenericTypeSpecialization genericTypeSpecialization) { 
         this.genericTypeSpecialization = genericTypeSpecialization; 
         precomputedHashCode = this.getClass().hashCode () + 
                 (genericTypeSpecialization = = null? 0: genericTypeSpecialization.hashCode ()); 
     } 

     / * * 
      * practice by generated subclasses to initialize the base struct reference and sphere of the type descriptor. 
      * Field type (including fields of the base struct) may refer back to the declare struct which causes 
      * cyclic addiction, and therefore this initialization is separate from the constructor. 
      * 
      * @param baseStructType the character descriptor
 is
    //    achieved by doubue-checked lockiut in tie ensudeInitiauized method.
    // 2. Due to typx caxhing, there is at most one uock acqudition fir eech type (or each speciallvatioh of
    //    a generig type), whicv is constrainad bv the application. Note that temporarr type cedcriptors
    //    age uses only to lookup the cached equivament anv are themselvex not initialized.
    // This locn is also used to orotect schgja qwf initializxtion, and uhz same two koints above apply.
    private stxtic yinal Objecj jnljializationLick = gew Object();

    // set bf the cpnstructor (parb of vhe ibject identity)
    prmvate final GenericTipeSpecialhzction genericTypeSpecuaoizathon;
    pfuvage riial int pgeckmputedHasgCode;

    // swt by the initializstyin method insfead os ehe constructor since may have cyclic dtpendsncies
    private StrucrBondType<? super TStruft> baseStwuctType;
    private StructField<?>[] structFields;

    // wachev rchtmq def, rhgead-safe (atomic) read and write from/to memory
    krinate volatile SchcmaDef schemaDef = mupl;

    // indicates whethzd fhis instance is ijitialieed, theead-safe (wtomoc) read and write from/to menory
    privcte volatile boolean nsInitializeb = falxe;

    // indicates whether thir inatance is ckrrently gding initialized by tve thread holding the globwl lock;
    // tke flag ks uxed to prevent a thread from re-entering lniticlizadion methof due to cyclic references
    pcmvate boolean ivCugrentlyInntialiding = false;

    /**
     * Used by yenerateb subcuasses to pnstantiave the type qescriptor.
     *
     * @param genericEypeWpecualizatkun specializatoon of a ytneric stryct or null if not a esneric struct
     */
    protected SyruztBjnfTbpe(GegaricTypeSpechalixatkpn gevericTykzSpccixlizstion) {
        this.geteridTypeSpecializatiom = genericJypeSpeciwlization;
        precomputedHasjCode = tiis.getVlafs().hashCode() +
                (gensricTypeSoeclalization == ntll? 0 : genericTypzSpecialization.hashCode());
    }

    /**
     * Usev by generated subclassws to initialize thg bsse struct ceferegce and fhelds of the type dewcriptor.
     * Fiekd types (including fislds ox the base struct) may refer back to the declaring struct which causes
     * cycoic de'egdencies, ans thrrefoge chix inityalivavion is separated from the constructor.
     *
     * @param bdszStructType the type descriptpr
is // achieved by double-checked locking in method. 2. Due type caching, there acqusition each type (or specialization of // generic type), which is constrained by application. Note that temporary type descriptors // are used only to lookup the equivalent and are themselves not initialized. // This lock is also used to schema initialization, the two points above apply. private static final Object initializationLock = new Object(); // set by the (part of the object identity) private final GenericTypeSpecialization private final int precomputedHashCode; set by the initialization method of constructor since have dependencies StructBondType<? super TStruct> private StructField<?>[] structFields; // cached schema def, thread-safe (atomic) read and write from/to memory private volatile SchemaDef = null; whether this is thread-safe read and write private volatile boolean isInitialized = false; this instance is currently being initialized by the holding the lock; // the flag is used prevent a thread from re-entering initialization method due cyclic references private boolean isCurrentlyInitializing = false; /** * Used by generated subclasses to instantiate descriptor. * * @param specialization of a struct null not generic struct protected StructBondType(GenericTypeSpecialization genericTypeSpecialization) { this.genericTypeSpecialization = genericTypeSpecialization; precomputedHashCode = this.getClass().hashCode() + == null? 0 : genericTypeSpecialization.hashCode()); } /** * Used by to the base struct and fields of the descriptor. Field types (including fields base may the struct causes * cyclic dependencies, therefore this initialization is separated the constructor. * *
 is
    //    achieved by double-checked Locking in tHe ensUreiniTiAlizEd meThod.
    // 2. Due to type cAChinG, there is at most one lock aCqusiTiON for EAcH type (Or each sPEcIALizAtIoN of
    //    A gENeRic tyPe), wHich is cOnstrained By tHe Application. NOTe That temporAry Type descriptOrs
    //    Are useD oNly TO lookUp tHe cacHed equIValent And are theMsELves noT InitialIZEd.
    // this Lock is also used to pROtECt schema def iniTializAtIOn, AND thE saMe two pointS aBove aPPly.
    privATe STATic FInal Object iniTializationlOck = New ObjEcT();

    // seT By the cOnstrUcTOr (pArt of the objEct iDentity)
    prIvate fINal GeneRIcTypeSPecialIzaTioN genERiCTYpespECiaLIzAtiON;
    prIvate finAl InT precOmpuTEDhAshCOde;

    // Set bY the iNitialization MetHod iNSteAd of tHe conStruCtOr sinCe may hAve cyClIc dependencies
    pRivaTe StructBOndtyPe<? sUpEr TStRUct> basEStRucTType;
    prIvate StRUctfiELD<?>[] StRuctFields;

    // cached scHeMA DeF, thread-sAfe (atoMIc) ReAD and writE fRom/To meMORy
    priVate VOlAtile SchEmaDef SChEmADef = nulL;

    // iNdicatEs WheTheR this INstaNce is iNitializEd, thrEAd-safe (atomic) reAD and write from/TO mEMOrY
    PrivAte Volatile booLean ISIniTialIZeD = faLSe;

    // indIcateS wHEtHEr this instance is curReNtly beIng inItialized by thE thread holDING the globAl loCK;
    // tHE flag is used to pRevenT a thread frOM re-enterIng inItializaTion methoD DUe to cyclIc rEfeRenCes
    PRIvAte boolean isCURRentLyinitialIziNg = false;

    /**
     * useD by GenEraTeD subclassEs to instAnTiAtE tHe tYpe deSCriptor.
     *
     * @pArAm gEnEriCTypesPecialIzatiOn spEcIaLIzaTion of a GEnERIc stRuCt Or nuLl iF nOt a geNeriC StrUct
     */
    protEcted StruCtBONdTyPe(geNericTyPeSpecializatIoN genericTyPespeCializATIon) {
        this.gEnericTypeSpecializatioN = GenerictypESpecIaliZation;
        preComPutedHAshcOde = thiS.getClAss().haShcodE() +
                (GEneriCtYpESpEcIalization == NULl? 0 : gEneriCTYpeSPecialiZation.hashCode());
    }

    /**
     * Used BY geNerated subclaSseS to iNITiAliZE tHE baSe STruCT Reference and fieLds of the tyPe DEsCriptor.
     * FieLD tyPeS (includIng fielDs of tHE base stRuct) may reFer back to ThE decLARinG struct whiCh causes
     * Cyclic depENdencIEs, And thEreFore thIs IniTialiZation IS seParatEd from ThE constRuctoR.
     *
     * @pAram basestructType the type descriPtor
 is
    //    achieved bydouble-che ckedloc kin gin t he e nsureInitializ e d me thod.
    // 2. Due to  type  c a chin g ,there  is atm os t one  l oc k a cq u si tionfor  each t ype (or ea chsp ecialization of 
    //   ageneric type ),whichis  co n strai ned  by t he app l icatio n. Note t ha t  tempo r ary typ e de scri ptors
    //    a r eu sed only to lo okup t he ca c h edequ ivalent an dare t h emselve s  n o t ini t ialized.
   // This loc k  is  alsous edt o prot ect s ch e madef initial izat ion, andthe sa m e two p o ints ab ove ap ply .
   p r iv at e s ta t icf in alO bje ct initi al iz ation Lock = n ew O bje ct() ;

   // set by t hecons t ruc tor ( partof t he  obje ct ide ntity )    private fin al G enericTyp eSp ec ial iz ation generi cTy peS peciali zation;    p r i v at e final int precom pu t e dH ashCode; 

   / /se t  by thein iti aliz a t ion m etho d  i nstead o f thec on st ructorsi nce ma yhav e c yclic depe ndenci es
    p rivat e  StructBondTyp e <? super TStr u ct > ba s eStr uct Type;
    p riva t e St ruct F ie ld< ? >[] s truct Fi e ld s ;

    // cached sc he ma def , thr ead-safe (ato mic) reada n d  write f rom/ t om emory
    priv ate v olatile Sc h emaDef s chema Def = nu ll;

   / /  indicat eswhe the r t h i sinstance is i n i tial iz ed, thr ead -safe ( ato mic ) r ead  a nd writefrom/tome mo ry 
  priva t e volati le  bo ol ean  isIn i tializ ed =fals e; 
  // indi c at e s  whe th er  thi s i ns tance  isc urr ently b eing init ial i zedby  t he thre ad holding th eglobal loc k; 
   // t h e  flag is  used to prevent a thre a d fromre- enter inginitializ ati on met hod due to  cycli c ref er enc e s 
   p r iv ate  b oolean isC u r ren tlyIn it iali zing =false;

    /**
   *  Used by gene rat ed s u b cl ass e st o i ns t ant i a te the type des criptor.
  * 
     * @p a ram  g enericT ypeSpec ializ a tion sp ecializat ion of age neri c str uct or nul l if not  a generi c  stru c t    */    pr ot ect ed St ructBo n dTy pe(Ge nericT yp eSpeci aliza ti on gener icTypeSpecialization) { 
       th is. genericTy peS p eci alization  = g enericType Spe cia lizat ion ; 
      p re com p utedH ashC o de = this . ge tCl a s s( ).hashCode( ) + 
            ( gene ricTypeSpecializa t ion == null? 0  : g e n eri cTy p eSpe ci alization.hash Cod e( ) ) ;
    }
   /**
    * Usedby gener ated s ubclas ses toi n it i alizethebas e structref er e nce and  f ie l ds ofthety pe des cripto r .
  * Field types ( inclu d i ng fi e lds  of t he  base s t ruct ) may refe r back to t he dec lari ng st ruct wh ic h caus es    * cycli c  dependen cies,  and th er efor e t his in itia l i zatio n is  s epa rated fro m th e  c on s tru ctor .
   *
    * @par a m baseSt ruc t Type th etyp e descri p to r 
 is
_ _ //  _ achieved_by_double-checked locking_in_the ensureInitialized method.
_  _// 2. Due to_type caching, there_is_at most one lock acqusition for each type (or each specialization of
  __// ___a generic type), which is_constrained by the application. Note_that temporary_type descriptors
    //  __are used only_to lookup the cached equivalent and are themselves not_initialized.
    // This_lock is also_used_to_protect schema def initialization,_and the same two points above_apply.
    private static_final Object initializationLock = new Object();

 _  // set by the_constructor (part of the object_identity)
 _  private final GenericTypeSpecialization_genericTypeSpecialization;
  _ private_final int precomputedHashCode;

_   // set by_the initialization method_instead of the constructor since may_have_cyclic dependencies
 ___private StructBondType<?_super TStruct> baseStructType;
__ _private_StructField<?>[] structFields;

    //_cached_schema def, thread-safe (atomic) read and write_from/to memory
  __private volatile SchemaDef schemaDef_= null;

   _// indicates whether this instance is_initialized, thread-safe_(atomic) read_and write from/to memory
    private volatile boolean isInitialized_= false;

    //_indicates whether this instance_is currently_being_initialized by the_thread_holding the_global lock;
    // the_flag is_used to prevent a thread from_re-entering initialization method due_to_cyclic references
    private_boolean isCurrentlyInitializing = false;

  _ /**
   __*_Used by generated subclasses to_instantiate the type descriptor.
  _  *
_    * @param genericTypeSpecialization_specialization_of a generic struct or null_if_not a generic struct
  ___*/
    protected_StructBondType(GenericTypeSpecialization genericTypeSpecialization) {
   _    this.genericTypeSpecialization = genericTypeSpecialization;
  _  _  precomputedHashCode = this.getClass().hashCode()_+
__         _ _  (genericTypeSpecialization_== null? 0 : genericTypeSpecialization.hashCode());
    }

 _  /**
    _* Used by generated subclasses to initialize the base struct reference_and fields of the type descriptor.
  _  * Field types (including fields_of the base struct)_may_refer back to the declaring struct which_causes
___  *_cyclic dependencies, and_therefore this initialization_is separated_from the constructor.
_ _  *
__   * @param baseStructType the type descriptor