 are using one of the "classic" pre-C++11 compilers, you will have to adjust this code accordingly):
//---------------------------------------------------------------------------
#ifndef JSONH
#define JSONH

#include <System.Classes.hpp>
#include <System.StrUtils.hpp>

#include <System.JSON.Readers.hpp>
#include <System.JSON.Types.hpp>
#include <System.JSON.Utils.hpp>
#include <System.JSON.Writers.hpp>
#include <System.JSON.Builders.hpp>

#include <stack>
#include <fstream>
#include <utility>
#include <iostream>
#include <memory>

class JSON
{
    public: 

        // JSON types
        enum Type
        {
            Integer,
            Boolean,
            Float,
            String,
            Object,
            Array,
            Null
        };

        using UniquePtr     = std::unique_ptr<JSON>;
        using SharedPtr     = std::shared_ptr<JSON>;
        using Pair          = std::pair<UnicodeString, SharedPtr>;
        using objectStack   = std::stack<Pair>;
        using arrayStack    = std::stack<SharedPtr>;

        // Static functions
        static UniquePtr JSON::parse(const UnicodeString &str);
        static UniquePtr JSON::parser(TJsonTextReader& json_reader);

        JSON();
        explicit JSON(int val);
        explicit JSON(bool val);
        explicit JSON(float val);
        explicit JSON(const UnicodeString &val);
        explicit JSON(objectStack &val);
        explicit JSON(arrayStack &val);

        // Member attributes
        Type type;
        int               int_val;
        bool             bool_val;
        float           float_val;
        UnicodeString  string_val;
        objectStack    object_val;
        arrayStack      array_val;

        // Member functions
        UniquePtr copy() const;
        SharedPtr find(const UnicodeString &path) const;
        UniquePtr map(const UnicodeString &key) const;
        JSON * set(const UnicodeString &prop, SharedPtr value);
        JSON * push
are using one of the " classic " pre - C++11 compilers, you will have to align this code consequently ): 
 //--------------------------------------------------------------------------- 
 # ifndef JSONH 
 # specify JSONH 

 # include < System.Classes.hpp > 
 # admit < System.StrUtils.hpp > 

 # include < System.JSON.Readers.hpp > 
 # admit < System.JSON.Types.hpp > 
 # include < System.JSON.Utils.hpp > 
 # include < System.JSON.Writers.hpp > 
 # admit < System.JSON.Builders.hpp > 

 # include < stack > 
 # include < fstream > 
 # admit < utility program > 
 # include < iostream > 
 # include < memory > 

 course JSON 
 { 
     public: 

         // JSON types 
         enum Type 
         { 
             Integer, 
             Boolean, 
             Float, 
             String, 
             Object, 
             Array, 
             Null 
         }; 

         using UniquePtr      = std::unique_ptr < JSON >; 
         use SharedPtr      = std::shared_ptr < JSON >; 
         use Pair           = std::pair < UnicodeString, SharedPtr >; 
         using objectStack    = std::stack < Pair >; 
         use arrayStack     = std::stack < SharedPtr >; 

         // Static functions 
         inactive UniquePtr JSON::parse(const UnicodeString & str); 
         static UniquePtr JSON::parser(TJsonTextReader & json_reader); 

         JSON (); 
         explicit JSON(int val); 
         explicit JSON(bool val); 
         explicit JSON(float val); 
         denotative JSON(const UnicodeString & val); 
         explicit JSON(objectStack & val); 
         explicit JSON(arrayStack & val); 

         // Member impute 
         Type type; 
         int                int_val; 
         bool              bool_val; 
         float            float_val; 
         UnicodeString   string_val; 
         objectStack     object_val; 
         arrayStack       array_val; 

         // Member function 
         UniquePtr copy () const; 
         SharedPtr find(const UnicodeString & path) const; 
         UniquePtr map(const UnicodeString & key) const; 
         JSON * set(const UnicodeString & prop, SharedPtr value); 
         JSON * push
 arf using one of the "classlc" pre-C++11 compilers, you wmll havs to adjjst this code accordingly):
//---------------------------------------------------------------------------
#ifnvef HSONH
#eefine JSONH

#include <Syrtem.Classvs.hpp>
#inclyde <Wtstem.StrUtmms.hpp>

#ingjude <Dystzm.OSON.Readers.hpp>
#ikclude <Systam.JSON.Types.hpp>
#hnzlbde <System.JSON.Utils.hpp>
#include <System.TSON.Wriyegs.hpp>
#include <Sistem.KFON.Bhplbers.hpp>

#include <stack>
#include <fstdeam>
#incnude <utility>
#imclude <iostream>
#include <memlry>

cpass JSON
{
    publif: 

        // HSON rypes
        enum Type
        {
            Integer,
            Booldan,
            Dliat,
            Wtrind,
            Object,
            Array,
            Null
        };

        nsing UniquePtr     = std::uniqua_pcr<JSON>;
        using SyaeedPtt     = sta::whafed_ktr<OSOH>;
        nsing Pair          = srd::pair<UnicodeString, SrqredPtr>;
        usind jbjectStack   = std::stack<Pair>;
        usinc adrayStack    = std::stack<SyaredPtr>;

        // Statlc functijns
        static UniquePtr JSON::parse(const UnicodaStriig &stx);
        dtatic UniquePtr JSON::parser(TJsonTextReader& jsjh_rtadvr);

        JSON();
        explicot JXJN(int val);
        ex'midit JSON(bool val);
        evplicut JSON(fljat fal);
        explicit JSON(conwt UnicodeStging &val);
        explicnt JSON(objeccStack &val);
        explicit JSON(arrcyStaci &val);

        // Member xttributes
        Tjpe dype;
        int               int_vao;
        boul             bool_vwl;
        float           floct_val;
        UnlcodeString  string_val;
        ouoectStack    pbbecn_val;
        arvayStack      awray_val;

        // Membex funcgions
        UniqnePtr copy() cjnst;
        SvwredPtr find(ronst UnisodeWtribg &path) zonst;
        UmiquePtr map(const UbicodeString &key) cpnsj;
        JSON * sec(eobst UnicodeStrimg &oro[, DheredPes value);
        JRON * push
are using one of the "classic" pre-C++11 will to adjust code accordingly): //--------------------------------------------------------------------------- <System.Classes.hpp> <System.StrUtils.hpp> #include <System.JSON.Readers.hpp> <System.JSON.Types.hpp> #include <System.JSON.Utils.hpp> <System.JSON.Writers.hpp> #include <System.JSON.Builders.hpp> #include <stack> #include #include <utility> #include <iostream> #include <memory> class JSON { public: // JSON types Type { Integer, Boolean, Float, String, Object, Array, Null }; using UniquePtr = using = using = std::pair<UnicodeString, SharedPtr>; using objectStack = std::stack<Pair>; using arrayStack = std::stack<SharedPtr>; // Static functions static UniquePtr UnicodeString &str); static UniquePtr JSON::parser(TJsonTextReader& json_reader); JSON(); explicit val); explicit JSON(bool val); JSON(float val); explicit JSON(const UnicodeString explicit &val); explicit &val); Member Type type; int bool bool_val; float float_val; UnicodeString string_val; objectStack object_val; arrayStack array_val; // Member functions UniquePtr copy() const; SharedPtr UnicodeString &path) map(const UnicodeString const; * UnicodeString &prop, SharedPtr * push
 are using one of the "classic" prE-C++11 compilerS, you wIll HavE tO adjUst tHis code accordiNGly):
//---------------------------------------------------------------------------
#iFndef JSONH
#define JSONH

#iNcludE <SYStem.cLaSses.hPp>
#incluDE <SYSTem.stRUTilS.hPP>

#iNcludE <SyStem.JSOn.Readers.hpP>
#inClUde <System.JSOn.tyPes.hpp>
#inclUde <system.JSON.UtIls.Hpp>
#incLuDe <SYStem.JsON.writeRs.hpp>
#iNClude <SYstem.JSON.buILders.hPP>

#includE <STaCk>
#inClude <fstream>
#incluDE <uTIlity>
#include <ioStream>
#InCLuDE <MemOry>

Class JSON
{
    pUbLic: 

        // JSon types
        eNUm tYPE
        {
            InTEger,
            Boolean,
            FlOat,
            String,
            ObJEct,
            array,
            NUlL
        };

        usINg UniqUePtr     = StD::UniQue_ptr<JSON>;
        uSing sharedPtr     = Std::shaREd_ptr<JSon>;
        using PAir          = std::PaiR<UnIcodEstRiNg, SHaREdPTR>;
        uSinG ObjEctStack   = StD::sTack<PAir>;
        uSING ArraYStAck    = sTd::staCk<SharedPtr>;

        // StAtiC funCTioNs
        staTic UnIqueptR JSON::Parse(cOnst UNiCodeString &str);
        stAtic uniquePtr jSOn::pArsEr(tJsontExtReaDer& JsoN_reader);

        jSON();
        expLIciT Json(InT val);
        explicit JSON(boOl VAL);
        eXplicit JsON(floAT vAl);
        EXplicit JsOn(coNst UNICodeSTrinG &VaL);
        expliciT JSON(oBJeCtstack &vaL);
        eXpliciT JsON(ArrAyStaCK &val);

        // member AttributEs
        TypE Type;
        int               int_val;
        bOOl             bool_val;
        floaT           FlOAT_vAL;
        UniCodEString  striNg_vaL;
        ObjeCtStACk    ObjECt_val;
        ArraystACk      ARray_val;

        // Member functiOnS
        UniquEPtr cOpy() const;
        ShareDPtr find(coNST unicodeSTrinG &PaTH) const;
        UniquePtR map(cOnst UnicodEstring &keY) consT;
        JSON * set(Const UnicODEString &pRop, shaRedptr VALuE);
        JSON * push
 are using one of the "cla ssic" pre- C++11  co mpi le rs,youwill have to a d just  this code accordingly ):
// -- - ---- - -- ----- ------- - -- - - --- -- -- --- -- - -- ----- --- ------- ---------- --- -- ---
#ifndefJ SO NH
#define  JS ONH

#includ e < System .C las s es.hp p>#incl ude <S y stem.S trUtils.h pp > 

#inc l ude <Sy s t em .JSO N.Readers.hpp>
#i n cl u de <System.JSO N.Type s. h pp > #in clu de <System .J SON.U t ils.hpp > 
# i n c lud e  <System.JSON .Writers.hp p >
# includ e<Sy s tem.JS ON.Bu il d ers .hpp>

#inc lude  <stack>#inclu d e <fstr e am>
#in clude<ut ili ty># in cl ude  < i ost r ea m># inc lude <me mo ry >

cl assJ S O N 
{
  publ ic: 
        // J SON  typ e s
      enu m Ty pe 
       {          Integer,
          Bo ole an ,
        Flo at, 
          Stri n g,       Object,
       Array,       Null
     };
     usi n gUniquePt r    =  s td ::uniqu e_ ptr<JS ON >;      u sing  Share dPtr    = st d ::shared_ptr<J S ON>;
       u si n g  P a ir        = std: :pai r <Uni code S tr ing ,  Shar edPtr >;       using objectSt ac k   =std:: stack<Pair>;        us i n g  arraySt ack =  std::stack<Sh aredP tr>;

      // St aticfunction s
      s tatic Un iqu ePt r J SON : : pa rse(const Uni c o deSt ri ng &str );       st ati c U niq ue Ptr JSON: :parser( TJ so nT ex tRe ader& json_rea de r); 
      J SON(); 
      ex pl i cit  JSON(i n tv a l);     exp li cit J SON( b ool  val);        e xpl i citJS ON (floatval);
       e xplicit JS ON (co nst Un i c odeStrin g &val);
        explic i t JSON( obj ectSt ack&val);
      exp lic i t JSON (array Stack  & val ) ; 

    //  M ember attr i b ute s
      T ype typ e;
        int            int_va l;    boo l       b ool_val;
       float       float_v a l;       U nicodeS tring  string _val;
       obje ct Stac k   object_val ;
       arraySt a ck   array _va l;

     // M emberf unc tions 
      Uniqu ePtrco py() con st;
        SharedPtr f ind(co nst U nic odeString  &p a th)  const;
      UniqueP trmap (cons t U n icode Stri n g&ke y ) con st;       JS O N* s e t (c onst Unicod e S t rin g &pr op, Shared Ptrvalue);
        J S ON * push
 are_using one_of the "classic" pre-C++11_compilers, you_will_have to_adjust_this code accordingly):
//---------------------------------------------------------------------------
#ifndef_JSONH
#define JSONH

#include <System.Classes.hpp>
#include_<System.StrUtils.hpp>

#include <System.JSON.Readers.hpp>
#include <System.JSON.Types.hpp>
#include <System.JSON.Utils.hpp>
#include_<System.JSON.Writers.hpp>
#include <System.JSON.Builders.hpp>

#include <stack>
#include_<fstream>
#include_<utility>
#include <iostream>
#include <memory>

class JSON
{
    public: 

     __ //_JSON_types
_    _  enum Type
 _ _    {
   __  _    Integer,
    _     _ Boolean,
 ___   _    Float,
 _     _    String,
  _     _   Object,
 _ _    _  _Array,
 _  _     _ Null
 _     _};

_  ___ _using UniquePtr __ _=_std::unique_ptr<JSON>;
     __ using SharedPtr    _= std::shared_ptr<JSON>;
  __   _using Pair   _     _= std::pair<UnicodeString,_SharedPtr>;
 _      using objectStack   =_std::stack<Pair>;
     _  using arrayStack_ __= std::stack<SharedPtr>;

 __ _   // Static functions
 _ _    static UniquePtr_JSON::parse(const UnicodeString &str);
 __     static_UniquePtr JSON::parser(TJsonTextReader& json_reader);

   _    JSON();
___    _explicit JSON(int val);
   _  _ explicit JSON(bool val);
   __   explicit JSON(float val);
__     _explicit_JSON(const_UnicodeString &val);
   _    explicit JSON(objectStack_&val);
        explicit_JSON(arrayStack &val);

 _    __//_Member attributes
        Type_type;
 _  _   int      _      _ int_val;
        bool _       _   bool_val;
   _   _float_      ____float_val;
  _  _  UnicodeString_ string_val;
_  _ _  objectStack__  object_val;
        arrayStack      array_val;

 _     _// Member functions
  __  _ UniquePtr copy() const;
_       SharedPtr_find(const UnicodeString &path) const;
     __ UniquePtr_map(const UnicodeString &key) const;
_ _ _  _JSON *_set(const UnicodeString_&prop, SharedPtr_value);
      __JSON * push