Subversion Repositories currency_converter

{

  LkJSON v1.07

  06 november 2009

* Copyright (c) 2006,2007,2008,2009 Leonid Koninin

* leon_kon@users.sourceforge.net

* All rights reserved.

*

* Redistribution and use in source and binary forms, with or without

* modification, are permitted provided that the following conditions are met:

*     * Redistributions of source code must retain the above copyright

*       notice, this list of conditions and the following disclaimer.

*     * Redistributions in binary form must reproduce the above copyright

*       notice, this list of conditions and the following disclaimer in the

*       documentation and/or other materials provided with the distribution.

*     * Neither the name of the <organization> nor the

*       names of its contributors may be used to endorse or promote products

*       derived from this software without specific prior written permission.

*

* THIS SOFTWARE IS PROVIDED BY Leonid Koninin ``AS IS'' AND ANY

* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

* DISCLAIMED. IN NO EVENT SHALL Leonid Koninin BE LIABLE FOR ANY

* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

  changes:

  v1.07 06/11/2009 * fixed a bug in js_string - thanks to Andrew G. Khodotov

                   * fixed error with double-slashes - thanks to anonymous user

                   * fixed a BOM bug in parser, thanks to jasper_dale

  v1.06 13/03/2009 * fixed a bug in string parsing routine

                   * looked routine from the Adrian M. Jones, and get some

                     ideas from it; thanks a lot, Adrian!

                   * checked error reported by phpop and fix it in the string

                     routine; also, thanks for advice.

  v1.05 26/01/2009 + added port to D2009 by Daniele Teti, thanx a lot! really,

                     i haven't the 2009 version, so i can't play with it. I was

                     add USE_D2009 directive below, disabled by default

                   * fixed two small bugs in parsing object: errors with empty

                     object and list; thanx to RSDN's delphi forum members

                   * fixed "[2229135] Value deletion is broken" tracker

                     issue, thanx to anonymous sender provided code for

                     tree version

                   * fixed js_string according to "[1917047] (much) faster

                     js_string Parse" tracker issue by Joao Inacio; a lot of

                     thanx, great speedup!

  v1.04 05/04/2008 + a declaration of Field property moved from TlkJSONobject

                     to TlkJSONbase; thanx for idea to Andrey Lukyanov; this

                     improve objects use, look the bottom of SAMPLE2.DPR

                   * fixed field name in TlkJSONobject to WideString

  v1.03 14/03/2008 + added a code for generating readable JSON text, sended to

                     me by Kusnassriyanto Saiful Bahri, thanx to him!

                   * from this version, library distributed with BSD

                     license, more pleasure for commercial programmers :)

                   * was rewritten internal storing of objects, repacing

                     hash tables with balanced trees (AA tree, by classic

                     author's variant). On mine machine, with enabled fastmm,

                     tree variant is about 30% slower in from-zero creation,

                     but about 50% faster in parsing; also deletion of

                     objects will be much faster than a hash-one.

                     Hashes (old-style) can be switched on by enabling

                     USE_HASH directive below

  v1.02 14/09/2007 * fix mistypes in diffrent places; thanx for reports

                     to Aleksandr Fedorov and Tobias Wrede

  v1.01 18/05/2007 * fix small bug in new text generation routine, check

                     library for leaks by fastmm4; thanx for idea and comments

                     for Glynn Owen

  v1.00 12/05/2007 * some fixes in new code (mistypes, mistypes...)

                   * also many fixes by ideas of Henri Gourvest - big thanx

                     for him again; he send me code for thread-safe initializing

                     of hash table, some FPC-compatible issues (not tested by

                     myself) and better code for localization in latest

                     delphi versions; very, very big thanx!

                   * rewritten procedure of json text generating, with wich

                     work of it speeds up 4-5 times (on test) its good for

                     a large objects

                   * started a large work for making source code self-doc

                     (not autodoc!)

  v0.99 10/05/2007 + add functions to list and object:

                      function getInt(idx: Integer): Integer;

                      function getString(idx: Integer): String;

                      function getWideString(idx: Integer):WideString;

                      function getDouble(idx: Integer): Double;

                      function getBoolean(idx: Integer): Boolean;

                   + add overloaded functions to object:

                      function getDouble(nm: String): Double; overload;

                      function getInt(nm: String): Integer; overload;

                      function getString(nm: String): String; overload;

                      function getWideString(nm: String): WideString; overload;

                      function getBoolean(nm: String): Boolean; overload;

                   * changed storing mech of TlkJSONcustomlist descendants from

                     dynamic array to TList; this gives us great speedup with

                     lesser changes; thanx for idea to Henri Gourvest

                   * also reworked hashtable to work with TList, so it also

                     increase speed of work

  v0.98 09/05/2007 * fix small bug in work with WideStrings(UTF8), thanx to

                     IVO GELOV to description and sources

  v0.97 10/04/2007 + add capabilities to work with KOL delphi projects; for

                     this will define KOL variable in begin of text; of course,

                     in this case object TlkJSONstreamed is not compiled.

  v0.96 03/30/2007 + add TlkJSONFuncEnum and method ForEach in all

                     TlkJSONcustomlist descendants

                   + add property UseHash(r/o) to TlkJSONobject, and parameter

                     UseHash:Boolean to object constructors; set it to false

                     allow to disable using of hash-table, what can increase

                     speed of work in case of objects with low number of

                     methods(fields); [by default it is true]

                   + added conditional compile directive DOTNET for use in .Net

                     based delphi versions; remove dot in declaration below

                     (thanx for idea and sample code to Tim Radford)

                   + added property HashOf to TlkHashTable to allow use of

                     users hash functions; on enter is widestring, on exit is

                     cardinal (32 bit unsigned). Original HashOf renamed to

                     DefaultHashOf

                   * hash table object of TlkJSONobject wrapped by property called

                     HashTable

                   * fixed some minor bugs

  v0.95 03/29/2007 + add object TlkJSONstreamed what descendant of TlkJSON and

                     able to load/save JSON objects from/to streams/files.

                   * fixed small bug in generating of unicode strings representation

  v0.94 03/27/2007 + add properties NameOf and FieldByIndex to TlkJSONobject

                   * fix small error in parsing unicode chars

                   * small changes in hashing code (try to speed up)

  v0.93 03/05/2007 + add overloaded functions to list and object

                   + add enum type TlkJSONtypes

                   + add functions: SelfType:TlkJSONtypes and

                     SelfTypeName: String to every TlkJSONbase child

                   * fix mistype 'IndefOfName' to 'IndexOfName'

                   * fix mistype 'IndefOfObject' to 'IndexOfObject'

  v0.92 03/02/2007 + add some fix to TlkJSON.ParseText to fix bug with parsing

                     objects - object methods not always added properly

                     to hash array (thanx to Chris Matheson)

  ...

}

unit uLkJSON;

{$IFDEF fpc}

  {$MODE objfpc}

  {$H+}

  {.$DEFINE HAVE_FORMATSETTING}

{$ELSE}

  {$IF RTLVersion > 14.00}

    {$DEFINE HAVE_FORMATSETTING}

    {$IF RTLVersion > 19.00}

      {$DEFINE USE_D2009}

    {$IFEND}

  {$IFEND}

{$ENDIF}

interface

{.$DEFINE USE_D2009}

{.$DEFINE KOL}

{.$define DOTNET}

{$DEFINE THREADSAFE}

{$DEFINE NEW_STYLE_GENERATE}

{.$DEFINE USE_HASH}

{.$DEFINE TCB_EXT}

uses windows,

  SysUtils,

{$IFNDEF KOL}

  classes,

{$ELSE}

  kol,

{$ENDIF}

  variants;

type

  TlkJSONtypes = (jsBase, jsNumber, jsString, jsBoolean, jsNull,

    jsList, jsObject);

{$IFDEF DOTNET}

  TlkJSONdotnetclass = class

  public

    constructor Create;

    destructor Destroy; override;

    procedure AfterConstruction; virtual;

    procedure BeforeDestruction; virtual;

  end;

{$ENDIF DOTNET}

  TlkJSONbase = class{$IFDEF DOTNET}(TlkJSONdotnetclass){$ENDIF}

  protected

    function GetValue: variant; virtual;

    procedure SetValue(const AValue: variant); virtual;

    function GetChild(idx: Integer): TlkJSONbase; virtual;

    procedure SetChild(idx: Integer; const AValue: TlkJSONbase);

      virtual;

    function GetCount: Integer; virtual;

    function GetField(AName: Variant):TlkJSONbase; virtual;

  public

    property Field[AName: Variant]: TlkJSONbase read GetField;

    property Count: Integer read GetCount;

    property Child[idx: Integer]: TlkJSONbase read GetChild write SetChild;

    property Value: variant read GetValue write SetValue;

    class function SelfType: TlkJSONtypes; virtual;

    class function SelfTypeName: string; virtual;

  end;

  TlkJSONnumber = class(TlkJSONbase)

  protected

    FValue: extended;

    function GetValue: Variant; override;

    procedure SetValue(const AValue: Variant); override;

  public

    procedure AfterConstruction; override;

    class function Generate(AValue: extended = 0): TlkJSONnumber;

    class function SelfType: TlkJSONtypes; override;

    class function SelfTypeName: string; override;

  end;

  TlkJSONstring = class(TlkJSONbase)

  protected

    FValue: WideString;

    function GetValue: Variant; override;

    procedure SetValue(const AValue: Variant); override;

  public

    procedure AfterConstruction; override;

    class function Generate(const wsValue: WideString = ''):

      TlkJSONstring;

    class function SelfType: TlkJSONtypes; override;

    class function SelfTypeName: string; override;

  end;

  TlkJSONboolean = class(TlkJSONbase)

  protected

    FValue: Boolean;

    function GetValue: Variant; override;

    procedure SetValue(const AValue: Variant); override;

  public

    procedure AfterConstruction; override;

    class function Generate(AValue: Boolean = true): TlkJSONboolean;

    class function SelfType: TlkJSONtypes; override;

    class function SelfTypeName: string; override;

  end;

  TlkJSONnull = class(TlkJSONbase)

  protected

    function GetValue: Variant; override;

    function Generate: TlkJSONnull;

  public

    class function SelfType: TlkJSONtypes; override;

    class function SelfTypeName: string; override;

  end;

  TlkJSONFuncEnum = procedure(ElName: string; Elem: TlkJSONbase;

    data: pointer; var Continue: Boolean) of object;

  TlkJSONcustomlist = class(TlkJSONbase)

  protected

//    FValue: array of TlkJSONbase;

    fList: TList;

    function GetCount: Integer; override;

    function GetChild(idx: Integer): TlkJSONbase; override;

    procedure SetChild(idx: Integer; const AValue: TlkJSONbase);

      override;

    function ForEachElement(idx: Integer; var nm: string):

      TlkJSONbase; virtual;

    function GetField(AName: Variant):TlkJSONbase; override;

    function _Add(obj: TlkJSONbase): Integer; virtual;

    procedure _Delete(iIndex: Integer); virtual;

    function _IndexOf(obj: TlkJSONbase): Integer; virtual;

  public

    procedure ForEach(fnCallBack: TlkJSONFuncEnum; pUserData:

      pointer);

    procedure AfterConstruction; override;

    procedure BeforeDestruction; override;

    function getInt(idx: Integer): Integer; virtual;

    function getString(idx: Integer): string; virtual;

    function getWideString(idx: Integer): WideString; virtual;

    function getDouble(idx: Integer): Double; virtual;

    function getBoolean(idx: Integer): Boolean; virtual;

  end;

  TlkJSONlist = class(TlkJSONcustomlist)

  protected

  public

    function Add(obj: TlkJSONbase): Integer; overload;

    function Add(aboolean: Boolean): Integer; overload;

    function Add(nmb: double): Integer; overload;

    function Add(s: string): Integer; overload;

    function Add(const ws: WideString): Integer; overload;

    function Add(inmb: Integer): Integer; overload;

    procedure Delete(idx: Integer);

    function IndexOf(obj: TlkJSONbase): Integer;

    class function Generate: TlkJSONlist;

    class function SelfType: TlkJSONtypes; override;

    class function SelfTypeName: string; override;

  end;

  TlkJSONobjectmethod = class(TlkJSONbase)

  protected

    FValue: TlkJSONbase;

    FName: WideString;

    procedure SetName(const AValue: WideString);

  public

    property ObjValue: TlkJSONbase read FValue;

    procedure AfterConstruction; override;

    procedure BeforeDestruction; override;

    property Name: WideString read FName write SetName;

    class function Generate(const aname: WideString; aobj: TlkJSONbase):

      TlkJSONobjectmethod;

  end;

{$IFDEF USE_HASH}

  PlkHashItem = ^TlkHashItem;

  TlkHashItem = packed record

    hash: cardinal;

    index: Integer;

  end;

  TlkHashFunction = function(const ws: WideString): cardinal of

    object;

  TlkHashTable = class

  private

    FParent: TObject; // TCB:parent for check chaining op.

    FHashFunction: TlkHashFunction;

    procedure SetHashFunction(const AValue: TlkHashFunction);

  protected

    a_x: array[0..255] of TList;

    procedure hswap(j, k, l: Integer);

    function InTable(const ws: WideString; var i, j, k: cardinal):

      Boolean;

  public

    function counters: string;

    function DefaultHashOf(const ws: WideString): cardinal;

    function SimpleHashOf(const ws: WideString): cardinal;

    property HashOf: TlkHashFunction read FHashFunction write

      SetHashFunction;

    function IndexOf(const ws: WideString): Integer;

    procedure AddPair(const ws: WideString; idx: Integer);

    procedure Delete(const ws: WideString);

    constructor Create;

    destructor Destroy; override;

  end;

{$ELSE}

// implementation based on "Arne Andersson, Balanced Search Trees Made Simpler"

  PlkBalNode = ^TlkBalNode;

  TlkBalNode = packed record

    left,right: PlkBalNode;

    level: byte;

    key: Integer;

    nm: WideString;

  end;

  TlkBalTree = class

  protected

    fdeleted,flast,fbottom,froot: PlkBalNode;

    procedure skew(var t:PlkBalNode);

    procedure split(var t:PlkBalNode);

  public

    function counters: string;

    procedure Clear;

    function Insert(const ws: WideString; x: Integer): Boolean;

    function Delete(const ws: WideString): Boolean;

    function IndexOf(const ws: WideString): Integer;

    constructor Create;

    destructor Destroy; override;

  end;

{$ENDIF USE_HASH}

  TlkJSONobject = class(TlkJSONcustomlist)

  protected

{$IFDEF USE_HASH}

    ht: TlkHashTable;

{$ELSE}

    ht: TlkBalTree;

{$ENDIF USE_HASH}

    FUseHash: Boolean;

    function GetFieldByIndex(idx: Integer): TlkJSONbase;

    function GetNameOf(idx: Integer): WideString;

    procedure SetFieldByIndex(idx: Integer; const AValue: TlkJSONbase);

{$IFDEF USE_HASH}

    function GetHashTable: TlkHashTable;

{$ELSE}

    function GetHashTable: TlkBalTree;

{$ENDIF USE_HASH}

    function ForEachElement(idx: Integer; var nm: string): TlkJSONbase;

      override;

    function GetField(AName: Variant):TlkJSONbase; override;

  public

    property UseHash: Boolean read FUseHash;

{$IFDEF USE_HASH}

    property HashTable: TlkHashTable read GetHashTable;

{$ELSE}

    property HashTable: TlkBalTree read GetHashTable;

{$ENDIF USE_HASH}

    function Add(const aname: WideString; aobj: TlkJSONbase): Integer;

      overload;

    function OldGetField(nm: WideString): TlkJSONbase;

    procedure OldSetField(nm: WideString; const AValue: TlkJSONbase);

    function Add(const aname: WideString; aboolean: Boolean): Integer; overload;

    function Add(const aname: WideString; nmb: double): Integer; overload;

    function Add(const aname: WideString; s: string): Integer; overload;

    function Add(const aname: WideString; const ws: WideString): Integer;

      overload;

    function Add(const aname: WideString; inmb: Integer): Integer; overload;

    procedure Delete(idx: Integer);

    function IndexOfName(const aname: WideString): Integer;

    function IndexOfObject(aobj: TlkJSONbase): Integer;

    property Field[nm: WideString]: TlkJSONbase read OldGetField

      write OldSetField; default;

    constructor Create(bUseHash: Boolean = true);

    destructor Destroy; override;

    class function Generate(AUseHash: Boolean = true): TlkJSONobject;

    class function SelfType: TlkJSONtypes; override;

    class function SelfTypeName: string; override;

    property FieldByIndex[idx: Integer]: TlkJSONbase read GetFieldByIndex

    write SetFieldByIndex;

    property NameOf[idx: Integer]: WideString read GetNameOf;

    function getDouble(idx: Integer): Double; overload; override;

    function getInt(idx: Integer): Integer; overload; override;

    function getString(idx: Integer): string; overload; override;

    function getWideString(idx: Integer): WideString; overload; override;

    function getBoolean(idx: Integer): Boolean; overload; override;

    function {$ifdef TCB_EXT}getDoubleFromName{$else}getDouble{$endif}

      (nm: string): Double; overload;

    function {$ifdef TCB_EXT}getIntFromName{$else}getInt{$endif}

      (nm: string): Integer; overload;

    function {$ifdef TCB_EXT}getStringFromName{$else}getString{$endif}

      (nm: string): string; overload;

    function {$ifdef TCB_EXT}getWideStringFromName{$else}getWideString{$endif}

      (nm: string): WideString; overload;

    function {$ifdef TCB_EXT}getBooleanFromName{$else}getBoolean{$endif}

      (nm: string): Boolean; overload;

  end;

  TlkJSON = class

  public

    class function ParseText(const txt: string): TlkJSONbase;

    class function GenerateText(obj: TlkJSONbase): string;

  end;

{$IFNDEF KOL}

  TlkJSONstreamed = class(TlkJSON)

    class function LoadFromStream(src: TStream): TlkJSONbase;

    class procedure SaveToStream(obj: TlkJSONbase; dst: TStream);

    class function LoadFromFile(srcname: string): TlkJSONbase;

    class procedure SaveToFile(obj: TlkJSONbase; dstname: string);

  end;

{$ENDIF}

function GenerateReadableText(vObj: TlkJSONbase; var vLevel:

  Integer): string;

implementation

uses math,strutils;

type

  ElkIntException = class(Exception)

  public

    idx: Integer;

    constructor Create(idx: Integer; msg: string);

  end;

// author of next two functions is Kusnassriyanto Saiful Bahri

function Indent(vTab: Integer): string;

begin

  result := DupeString('  ', vTab);

end;

function GenerateReadableText(vObj: TlkJSONbase; var vLevel:

  Integer): string;

var

  i: Integer;

  vStr: string;

  xs: TlkJSONstring;

begin

  vLevel := vLevel + 1;

  if vObj is TlkJSONObject then

    begin

      vStr := '';

      for i := 0 to TlkJSONobject(vObj).Count - 1 do

        begin

          if vStr <> '' then

            begin

              vStr := vStr + ','#13#10;

            end;

          vStr := vStr + Indent(vLevel) +

            GenerateReadableText(TlkJSONobject(vObj).Child[i], vLevel);

        end;

      if vStr <> '' then

        begin

          vStr := '{'#13#10 + vStr + #13#10 + Indent(vLevel - 1) + '}';

        end

      else

        begin

          vStr := '{}';

        end;

      result := vStr;

    end

  else if vObj is TlkJSONList then

    begin

      vStr := '';

      for i := 0 to TlkJSONList(vObj).Count - 1 do

        begin

          if vStr <> '' then

            begin

              vStr := vStr + ','#13#10;

            end;

          vStr := vStr + Indent(vLevel) +

              GenerateReadableText(TlkJSONList(vObj).Child[i], vLevel);

        end;

      if vStr <> '' then

        begin

          vStr := '['#13#10 + vStr + #13#10 + Indent(vLevel - 1) + ']';

        end

      else

        begin

          vStr := '[]';

        end;

      result := vStr;

    end

  else if vObj is TlkJSONobjectmethod then

    begin

      vStr := '';

      xs := TlkJSONstring.Create;

      try

        xs.Value := TlkJSONobjectMethod(vObj).Name;

        vStr := GenerateReadableText(xs, vLevel);

        vLevel := vLevel - 1;

        vStr := vStr + ':' + GenerateReadableText(TlkJSONbase(

          TlkJSONobjectmethod(vObj).ObjValue), vLevel);

      //vStr := vStr + ':' + GenerateReadableText(TlkJSONbase(vObj), vLevel);

        vLevel := vLevel + 1;

        result := vStr;

      finally

        xs.Free;

      end;

    end

  else

    begin

      if vObj is TlkJSONobjectmethod then

        begin

          if TlkJSONobjectMethod(vObj).Name <> '' then

            begin

            end;

        end;

      result := TlkJSON.GenerateText(vObj);

    end;

  vLevel := vLevel - 1;

end;

// author of this routine is IVO GELOV

function code2utf(iNumber: Integer): UTF8String;

begin

  if iNumber < 128 then Result := chr(iNumber)

  else if iNumber < 2048 then

    Result := chr((iNumber shr 6) + 192) + chr((iNumber and 63) + 128)

  else if iNumber < 65536 then

    Result := chr((iNumber shr 12) + 224) + chr(((iNumber shr 6) and

      63) + 128) + chr((iNumber and 63) + 128)

  else if iNumber < 2097152 then

    Result := chr((iNumber shr 18) + 240) + chr(((iNumber shr 12) and

      63) + 128) + chr(((iNumber shr 6) and 63) + 128) +

      chr((iNumber and 63) + 128);

end;

{ TlkJSONbase }

function TlkJSONbase.GetChild(idx: Integer): TlkJSONbase;

begin

  result := nil;

end;

function TlkJSONbase.GetCount: Integer;

begin

  result := 0;

end;

function TlkJSONbase.GetField(AName: Variant):TlkJSONbase;

begin

  result := self;

end;

function TlkJSONbase.GetValue: variant;

begin

  result := variants.Null;

end;

class function TlkJSONbase.SelfType: TlkJSONtypes;

begin

  result := jsBase;

end;

class function TlkJSONbase.SelfTypeName: string;

begin

  result := 'jsBase';

end;

procedure TlkJSONbase.SetChild(idx: Integer; const AValue:

  TlkJSONbase);

begin

end;

procedure TlkJSONbase.SetValue(const AValue: variant);

begin

end;

{ TlkJSONnumber }

procedure TlkJSONnumber.AfterConstruction;

begin

  inherited;

  FValue := 0;

end;

class function TlkJSONnumber.Generate(AValue: extended):

  TlkJSONnumber;

begin

  result := TlkJSONnumber.Create;

  result.FValue := AValue;

end;

function TlkJSONnumber.GetValue: Variant;

begin

  result := FValue;

end;

class function TlkJSONnumber.SelfType: TlkJSONtypes;

begin

  result := jsNumber;

end;

class function TlkJSONnumber.SelfTypeName: string;

begin

  result := 'jsNumber';

end;

procedure TlkJSONnumber.SetValue(const AValue: Variant);

begin

  FValue := VarAsType(AValue, varDouble);

end;

{ TlkJSONstring }

procedure TlkJSONstring.AfterConstruction;

begin

  inherited;

  FValue := '';

end;

class function TlkJSONstring.Generate(const wsValue: WideString):

  TlkJSONstring;

begin

  result := TlkJSONstring.Create;

  result.FValue := wsValue;

end;

function TlkJSONstring.GetValue: Variant;

begin

  result := FValue;

end;

class function TlkJSONstring.SelfType: TlkJSONtypes;

begin

  result := jsString;

end;

class function TlkJSONstring.SelfTypeName: string;

begin

  result := 'jsString';

end;

procedure TlkJSONstring.SetValue(const AValue: Variant);

begin

  FValue := VarToWideStr(AValue);

end;

{ TlkJSONboolean }

procedure TlkJSONboolean.AfterConstruction;

begin

  FValue := false;

end;

class function TlkJSONboolean.Generate(AValue: Boolean):

  TlkJSONboolean;

begin

  result := TlkJSONboolean.Create;

  result.Value := AValue;

end;

function TlkJSONboolean.GetValue: Variant;

begin

  result := FValue;

end;

class function TlkJSONboolean.SelfType: TlkJSONtypes;

begin

  Result := jsBoolean;

end;

class function TlkJSONboolean.SelfTypeName: string;

begin

  Result := 'jsBoolean';

end;

procedure TlkJSONboolean.SetValue(const AValue: Variant);

begin

  FValue := boolean(AValue);

end;

{ TlkJSONnull }

function TlkJSONnull.Generate: TlkJSONnull;

begin

  result := TlkJSONnull.Create;

end;

function TlkJSONnull.GetValue: Variant;

begin

  result := variants.Null;

end;

class function TlkJSONnull.SelfType: TlkJSONtypes;

begin

  result := jsNull;

end;

class function TlkJSONnull.SelfTypeName: string;

begin

  result := 'jsNull';

end;

{ TlkJSONcustomlist }

function TlkJSONcustomlist._Add(obj: TlkJSONbase): Integer;

begin

  if not Assigned(obj) then

    begin

      result := -1;