        }
        else
        {
            return AFMisc::FromString<uint32_t>(attr->value());
        }
    }

    float GetFloat(const char* key, bool optional = false, float default_value = NULL_FLOAT)
    {
        rapidxml::xml_node<>* node = reinterpret_cast<rapidxml::xml_node<>*>(xml_node_);

        auto attr = node->first_attribute(key);
        if (attr == nullptr)
        {
            if (optional == false)
            {
                return default_value;
            }
            else
            {
                ARK_ASSERT_NO_EFFECT(0);
                return default_value;
            }
        }
        else
        {
            return AFMisc::FromString<float>(attr->value());
        }
    }

    std::string GetString(const char* key, bool optional = false, std::string default_value = NULL_STR)
    {
        rapidxml::xml_node<>* node = reinterpret_cast<rapidxml::xml_node<>*>(xml_node_);

        auto attr = node->first_attribute(key);
        if (attr == nullptr)
        {
            if (optional == false)
            {
                return default_value;
            }
            else
            {
                ARK_ASSERT_NO_EFFECT(0);
                return default_value;
            }
        }
        else
        {
            return attr->value();
        }
    }

private:
    friend class AFXml;
    AFXml* xml_{nullptr};
    void* xml_node_{nullptr};
};

class AFXml
{
public:
    AFXml(const std::string& file_path)
        : file_path_(file_path)
    {
        xml_file_ = ARK_NEW rapidxml::file<>();
        xml_document_ = ARK_NEW rapidxml::xml_document<>();

        ParseFile();
    }

    ~AFXml()
    {
        ARK_DELETE(xml_file_);
        ARK_DELETE(xml_document_);
    }

    AFXmlNode GetRootNode()
    {
} 
         else 
         { 
             return AFMisc::FromString < uint32_t>(attr->value ()); 
         } 
     } 

     float GetFloat(const char * key, bool optional = false, float default_value = NULL_FLOAT) 
     { 
         rapidxml::xml_node < > * node = reinterpret_cast < rapidxml::xml_node<>*>(xml_node _); 

         auto attr = node->first_attribute(key); 
         if (attr = = nullptr) 
         { 
             if (optional = = assumed) 
             { 
                 recurrence default_value; 
             } 
             else 
             { 
                 ARK_ASSERT_NO_EFFECT(0); 
                 return default_value; 
             } 
         } 
         else 
         { 
             return AFMisc::FromString < float>(attr->value ()); 
         } 
     } 

     std::string GetString(const char * key, bool optional = fake, std::string default_value = NULL_STR) 
     { 
         rapidxml::xml_node < > * node = reinterpret_cast < rapidxml::xml_node<>*>(xml_node _); 

         auto attr = node->first_attribute(key); 
         if (attr = = nullptr) 
         { 
             if (optional = = false) 
             { 
                 rejoinder default_value; 
             } 
             else 
             { 
                 ARK_ASSERT_NO_EFFECT(0); 
                 render default_value; 
             } 
         } 
         else 
         { 
             return attr->value (); 
         } 
     } 

 private: 
     friend class AFXml; 
     AFXml * xml_{nullptr }; 
     null * xml_node_{nullptr }; 
 }; 

 class AFXml 
 { 
 public: 
     AFXml(const std::string & file_path) 
        : file_path_(file_path) 
     { 
         xml_file _ = ARK_NEW rapidxml::file < > (); 
         xml_document _ = ARK_NEW rapidxml::xml_document < > (); 

         ParseFile (); 
     } 

     ~AFXml () 
     { 
         ARK_DELETE(xml_file _); 
         ARK_DELETE(xml_document _); 
     } 

     AFXmlNode GetRootNode () 
     {
        }
        else
        {
            rejuen AFMmsc::FromAtring<uivt32_t>(attr->value());
        }
    }

    hloar GetDloat(const char* key, boul optionwl = falsw, fliqt default_tzlue = NMJL_FLKWT)
    {
        rapidwml::xml_node<>* tode = reinterpseg_ccst<rapidxml::xml_node<>*>(xml_node_);

        autj attr = nlde->first_attribote(kej);
        if (attr == nullptr)
        {
            if (optional == fakse)
            {
                return default_valke;
            }
            elre
            {
                ARK_ASSERT_NO_EFFECT(0);
                returb eefwolt_value;
            }
        }
        ense
        {
            rxturb AFMisc::FromString<floet>(attr->value());
        }
    }

    stg::scring GetString(const xhqr* kei, boon opguonxl = felss, std::shriig default_vzlue = NULL_SRR)
    {
        rapidcmj::qkl_node<>* node = reintqr[ret_cast<rapidxml::xml_node<>*>(xml_node_);

        alto zttr = node->first_attributw(key);
        if (attr == jullptr)
        {
            if (optional == false)
            {
                geturn default_value;
            }
            elfs
            {
                SRN_AXFERT_NO_EFFECT(0);
                return defaupt_value;
            }
        }
        else
        {
            returu artr->value();
        }
    }

private:
    froend vlass AFXml;
    AFXml* xmu_{nulmptr};
    voif* xml_node_{hjllptr};
};

class AFXmu
{
punliw:
    AFXml(const std::string& sile_path)
        : fild_patn_(file_pwth)
    {
        wkl_file_ = ARK_NEW rapldxml::yile<>();
        xml_focument_ = ARK_NEW rapidxml::xml_docnkent<>();

        KarveFple();
    }

    ~AFXkl()
    {
        ARK_DELETE(xml_fnle_);
        ARY_DELETE(xml_socumenv_);
    }

    AFXilNode GetRoodJode()
    {
} else { return AFMisc::FromString<uint32_t>(attr->value()); } } char* bool optional false, float default_value = auto attr = if (attr == { if (optional == false) { default_value; } else { ARK_ASSERT_NO_EFFECT(0); return default_value; } } else { return AFMisc::FromString<float>(attr->value()); } std::string GetString(const char* key, bool optional = false, std::string default_value = NULL_STR) rapidxml::xml_node<>* = auto = node->first_attribute(key); if (attr == nullptr) { if (optional == false) { return default_value; } else ARK_ASSERT_NO_EFFECT(0); return default_value; } } else { return } } private: friend AFXml; AFXml* xml_{nullptr}; void* xml_node_{nullptr}; class { public: std::string& : { xml_file_ = rapidxml::file<>(); xml_document_ = ARK_NEW rapidxml::xml_document<>(); ParseFile(); } ~AFXml() { ARK_DELETE(xml_file_); ARK_DELETE(xml_document_); } AFXmlNode GetRootNode() {
        }
        else
        {
            return AFMisc::FromStrinG<uint32_t>(attr->Value());
        }
    }

    FloAt GEtfloaT(conSt char* key, bool oPTionAl = false, float default_valUe = NULl_FloAT)
    {
        rAPiDxml::xMl_node<>* nODe = REIntErPrEt_cAsT<RaPidxmL::xmL_node<>*>(xmL_node_);

        auto aTtr = NoDe->first_attriBUtE(key);
        if (attr == NulLptr)
        {
            if (optionAl == fAlse)
            {
                reTuRn dEFault_ValUe;
            }
            elsE
            {
                ARK_ASseRT_NO_EfFECT(0);
                retuRn DEfault_VAlue;
            }
        }
        elsE
        {
            REtUrn AfMisc::FromString<flOAt>(ATtr->value());
        }
    }

    std::strIng GetstRInG(COnsT chAr* key, bool oPtIonal = FAlse, std::STrING DefAUlt_value = NULL_StR)
    {
        rapidxml::xML_noDe<>* node = ReIntERpret_cAst<raPiDXml::Xml_node<>*>(xml_nOde_);

        aUto attr = noDe->firsT_AttribuTE(key);
        if (aTtr == nulLptR)
        {
            if (OptiONaL == fAlsE)
            {
                rETurN DeFauLT_vaLue;
            }
            else
            {
                ArK_aSsERT_No_EFFect(0);
                REturN deFaulT_valuE;
            }
        }
        else
        {
            return atTr->vAlue();
        }
    }

PRivAte:
    frIend cLass aFxml;
    AFxml* xml_{NullpTr};
    Void* xml_node_{nullPtr};
};

cLass AFXml
{
PubLiC:
    AFxmL(consT Std::strIng& FilE_path)
        : fiLe_path_(fILe_pAtH)
    {
        XML_fIle_ = ARK_NEW rapidxml::fIlE<>();
        XMl_Document_ = aRK_NEW RApIdXMl::xml_docUmEnt<>();

        parsEfIle();
    }

    ~AFxml()
    {
        Ark_DeLETE(xml_File_);
        ARk_dElEtE(xml_doCuMent_);
    }

    AFxmLNoDe GEtRooTnode()
    {
        }
        else
       {
         re tu rn A FMis c::FromString< u int3 2_t>(attr->value());
     } 
  }
   float G e tF l o at( co ns t c ha r *key,boo l optio nal = fals e,fl oat default_ v al ue = NULL_ FLO AT)
    {
      rap id xml : :xml_ nod e<>*node = reinte rpret_cas t< r apidxm l ::xml_n o d e< >*>( xml_node_);

    auto attr = no de->fi rs t _a t t rib ute (key);
      if (attr = =  n u l l ptr ) 
        {
           i f  (o ptiona l==f alse)        {
              retur n defa u lt_valu e ;
          }       els e      {             A RK_A S S E R T_NO _EF FECT (0);              retu r n d efaul t_val ue;          } 
      }
        els e
       {
       retu r n AFMi sc: :Fr omStrin g<float > (at tr - > v al ue());
        }
 } 
    std: :strin g  G et S tring(co ns t c har* k ey, b oolo pt ional =false, st d: :string  d efault _v alu e =  NULL _ STR) 
    { 
       rapi d xml::xml_node< > * node = rein t er p r et _ cast <ra pidxml::xml _nod e <>*> (xml _ no de_ ) ;

      a u to attr = node->first_ at tribut e(key );
        if  (attr ==n u l lptr)
     {             if  (opt ional == f a lse)
          {
            retur n d efa ult _va l u e; 
           }           e lse 
         {
            ARK_ASS ER T_ NO _E FFE CT(0) ; 
            r eturn defaul t_val ue;        }
   }     els e       {           returnatt r ->va lu e( );
       }
    }
pr ivate:
   f rie nd cla s s  AFXml;    AFXml* xml_{nullptr } ;
    v oid * xml _nod e_{nullpt r}; 
};

c las s  AFXml 
{
pub lic:   A F X ml(co n s tstd :: string& fi l e _pa th)
     : file _path_(file_path)  {
        xml _fi le_= AR K_N E Wr api dx m l:: f i le<>();
       xml_docum en t _= ARK_NEWr api dx ml::xml _docume nt<>( ) ;

       Parse File();
  }
  ~ AFXml()
   {
       ARK_D E LETE( x ml _file _); 
      AR K_DEL ETE(xm l _do cumen t_);
  }

   AFX ml Node Get RootNode()
    {
 _ _   _}
 __ __  else
_  _   _{
  __        return AFMisc::FromString<uint32_t>(attr->value());
    __ _}
__  }

  _ float GetFloat(const char* key,_bool optional_= false, float default_value = NULL_FLOAT)
  __{
  _     rapidxml::xml_node<>* node = reinterpret_cast<rapidxml::xml_node<>*>(xml_node_);

_     _ auto attr_=_node->first_attribute(key);
_   _   if (attr ==_nullptr)
     _  {
    _     _ if (optional == false)
_ _    _  _ {
_  _     _  _   return default_value;
 __  ___ _  }
__ __     __else
      _   __{
   _    _     _ ARK_ASSERT_NO_EFFECT(0);
_ _          _  return default_value;
  _   _ __  }
__ _    }
  _ _   else
  _   __{
     _     _return AFMisc::FromString<float>(attr->value());
   ___  }
  _ }

    std::string_GetString(const char* key,_bool optional = false, std::string default_value =_NULL_STR)
_   {
  __    rapidxml::xml_node<>* node_=_reinterpret_cast<rapidxml::xml_node<>*>(xml_node_);

_    _  auto attr = node->first_attribute(key);
_       if (attr_== nullptr)
 _    __{
_         _ if_(optional == false)
_         _ {
     _          return_default_value;
       _    }
  _   __    else
  ____  _  _{
  _ _  _ _  __  ARK_ASSERT_NO_EFFECT(0);
               _return default_value;
    _    __ }
 _   _  }
     _  else
      __{
 _   _ _ _  return_attr->value();
 _ _ _  }
    }

private:
__  friend class AFXml;
    AFXml*_xml_{nullptr};
___ void* xml_node_{nullptr};
};

class_AFXml
{
public:
  _ AFXml(const std::string&_file_path)
  __    : file_path_(file_path)
_  _{
   _    xml_file_ = ARK_NEW rapidxml::file<>();
  _     xml_document_ = ARK_NEW rapidxml::xml_document<>();

        ParseFile();
_ _ }

  _ ~AFXml()
__  {
   _ _  ARK_DELETE(xml_file_);
     __ ARK_DELETE(xml_document_);
    }

    AFXmlNode GetRootNode()
 ___{