xtool/contrib/CoreCipher/Source/DataFrameEngine.pas

{ ****************************************************************************** }
{ * Data Struct Engine                                                         * }
{ * written by QQ 600585@qq.com                                                * }
{ * https://zpascal.net                                                        * }
{ * https://github.com/PassByYou888/zAI                                        * }
{ * https://github.com/PassByYou888/ZServer4D                                  * }
{ * https://github.com/PassByYou888/PascalString                               * }
{ * https://github.com/PassByYou888/zRasterization                             * }
{ * https://github.com/PassByYou888/CoreCipher                                 * }
{ * https://github.com/PassByYou888/zSound                                     * }
{ * https://github.com/PassByYou888/zChinese                                   * }
{ * https://github.com/PassByYou888/zExpression                                * }
{ * https://github.com/PassByYou888/zGameWare                                  * }
{ * https://github.com/PassByYou888/zAnalysis                                  * }
{ * https://github.com/PassByYou888/FFMPEG-Header                              * }
{ * https://github.com/PassByYou888/zTranslate                                 * }
{ * https://github.com/PassByYou888/InfiniteIoT                                * }
{ * https://github.com/PassByYou888/FastMD5                                    * }
{ ****************************************************************************** }
(*
  update history
  2017-12-6
  added supported pointer
*)

unit DataFrameEngine;

{$INCLUDE zDefine.inc}

interface

uses SysUtils, CoreClasses, Types,
  ListEngine, MemoryStream64, CoreCipher,
  DoStatusIO, GeometryLib, TextDataEngine, Geometry2DUnit, Geometry3DUnit,
{$IFNDEF FPC} ZS_JsonDataObjects, {$ENDIF}
  CoreCompress, UnicodeMixedLib, PascalStrings;

type
  TDataFrameBase = class(TCoreClassObject)
  protected
    FID: Byte; // data frame id
  public
    constructor Create(ID: Byte);
    destructor Destroy; override;

    procedure LoadFromStream(stream: TMemoryStream64); virtual; abstract;
    procedure SaveToStream(stream: TMemoryStream64); virtual; abstract;
{$IFNDEF FPC}
    procedure LoadFromJson(jarry: TJsonArray; index_: Integer); virtual; abstract;
    procedure SaveToJson(jarry: TJsonArray; index_: Integer); virtual; abstract;
{$ENDIF}
    function ComputeEncodeSize: Int64; virtual; abstract;
  end;

  TDataFrameString = class sealed(TDataFrameBase)
  public
    Buffer: TBytes;

    constructor Create(ID: Byte);
    destructor Destroy; override;

    procedure LoadFromStream(stream: TMemoryStream64); override;
    procedure SaveToStream(stream: TMemoryStream64); override;
{$IFNDEF FPC}
    procedure LoadFromJson(jarry: TJsonArray; index_: Integer); override;
    procedure SaveToJson(jarry: TJsonArray; index_: Integer); override;
{$ENDIF}
    function ComputeEncodeSize: Int64; override;
  end;

  TDataFrameInteger = class sealed(TDataFrameBase)
  private
  protected
    FBuffer: Integer;
  public
    constructor Create(ID: Byte);
    destructor Destroy; override;

    procedure LoadFromStream(stream: TMemoryStream64); override;
    procedure SaveToStream(stream: TMemoryStream64); override;
{$IFNDEF FPC}
    procedure LoadFromJson(jarry: TJsonArray; index_: Integer); override;
    procedure SaveToJson(jarry: TJsonArray; index_: Integer); override;
{$ENDIF}
    function ComputeEncodeSize: Int64; override;

    property Buffer: Integer read FBuffer write FBuffer;
  end;

  TDataFrameCardinal = class sealed(TDataFrameBase)
  private
  protected
    FBuffer: Cardinal;
  public
    constructor Create(ID: Byte);
    destructor Destroy; override;

    procedure LoadFromStream(stream: TMemoryStream64); override;
    procedure SaveToStream(stream: TMemoryStream64); override;
{$IFNDEF FPC}
    procedure LoadFromJson(jarry: TJsonArray; index_: Integer); override;
    procedure SaveToJson(jarry: TJsonArray; index_: Integer); override;
{$ENDIF}
    function ComputeEncodeSize: Int64; override;

    property Buffer: Cardinal read FBuffer write FBuffer;
  end;

  TDataFrameWord = class sealed(TDataFrameBase)
  private
  protected
    FBuffer: Word;
  public
    constructor Create(ID: Byte);
    destructor Destroy; override;

    procedure LoadFromStream(stream: TMemoryStream64); override;
    procedure SaveToStream(stream: TMemoryStream64); override;
{$IFNDEF FPC}
    procedure LoadFromJson(jarry: TJsonArray; index_: Integer); override;
    procedure SaveToJson(jarry: TJsonArray; index_: Integer); override;
{$ENDIF}
    function ComputeEncodeSize: Int64; override;

    property Buffer: Word read FBuffer write FBuffer;
  end;

  TDataFrameByte = class sealed(TDataFrameBase)
  private
  protected
    FBuffer: Byte;
  public
    constructor Create(ID: Byte);
    destructor Destroy; override;

    procedure LoadFromStream(stream: TMemoryStream64); override;
    procedure SaveToStream(stream: TMemoryStream64); override;
{$IFNDEF FPC}
    procedure LoadFromJson(jarry: TJsonArray; index_: Integer); override;
    procedure SaveToJson(jarry: TJsonArray; index_: Integer); override;
{$ENDIF}
    function ComputeEncodeSize: Int64; override;

    property Buffer: Byte read FBuffer write FBuffer;
  end;

  TDataFrameSingle = class sealed(TDataFrameBase)
  private
  protected
    FBuffer: Single;
  public
    constructor Create(ID: Byte);
    destructor Destroy; override;

    procedure LoadFromStream(stream: TMemoryStream64); override;
    procedure SaveToStream(stream: TMemoryStream64); override;
{$IFNDEF FPC}
    procedure LoadFromJson(jarry: TJsonArray; index_: Integer); override;
    procedure SaveToJson(jarry: TJsonArray; index_: Integer); override;
{$ENDIF}
    function ComputeEncodeSize: Int64; override;

    property Buffer: Single read FBuffer write FBuffer;
  end;

  TDataFrameDouble = class sealed(TDataFrameBase)
  private
  protected
    FBuffer: Double;
  public
    constructor Create(ID: Byte);
    destructor Destroy; override;

    procedure LoadFromStream(stream: TMemoryStream64); override;
    procedure SaveToStream(stream: TMemoryStream64); override;
{$IFNDEF FPC}
    procedure LoadFromJson(jarry: TJsonArray; index_: Integer); override;
    procedure SaveToJson(jarry: TJsonArray; index_: Integer); override;
{$ENDIF}
    function ComputeEncodeSize: Int64; override;

    property Buffer: Double read FBuffer write FBuffer;
  end;

  TDataFrameArrayInteger = class sealed(TDataFrameBase)
  protected
    FBuffer: TCoreClassList;
  public
    constructor Create(ID: Byte);
    destructor Destroy; override;

    procedure Clear;
    procedure Add(v: Integer);
    procedure Delete(index_: Integer);
    function Count: Integer;
    procedure WriteArray(const a: array of Integer);

    procedure LoadFromStream(stream: TMemoryStream64); override;
    procedure SaveToStream(stream: TMemoryStream64); override;
{$IFNDEF FPC}
    procedure LoadFromJson(jarry: TJsonArray; index_: Integer); override;
    procedure SaveToJson(jarry: TJsonArray; index_: Integer); override;
{$ENDIF}
    function ComputeEncodeSize: Int64; override;

    function GetBuffer(index_: Integer): Integer;
    procedure SetBuffer(index_: Integer; Value: Integer);
    property Buffer[index_: Integer]: Integer read GetBuffer write SetBuffer; default;
  end;

  TDataFrameArrayShortInt = class sealed(TDataFrameBase)
  protected
    FBuffer: TCoreClassList;
  public
    constructor Create(ID: ShortInt);
    destructor Destroy; override;

    procedure Clear;
    procedure Add(v: ShortInt);
    procedure Delete(index_: Integer);
    function Count: Integer;
    procedure WriteArray(const a: array of ShortInt);

    procedure LoadFromStream(stream: TMemoryStream64); override;
    procedure SaveToStream(stream: TMemoryStream64); override;
{$IFNDEF FPC}
    procedure LoadFromJson(jarry: TJsonArray; index_: Integer); override;
    procedure SaveToJson(jarry: TJsonArray; index_: Integer); override;
{$ENDIF}
    function ComputeEncodeSize: Int64; override;

    function GetBuffer(index_: Integer): ShortInt;
    procedure SetBuffer(index_: Integer; Value: ShortInt);
    property Buffer[index_: Integer]: ShortInt read GetBuffer write SetBuffer; default;
  end;

  TDataFrameArrayByte = class sealed(TDataFrameBase)
  protected
    FBuffer: TCoreClassList;
  public
    constructor Create(ID: Byte);
    destructor Destroy; override;

    procedure Clear;
    procedure Add(v: Byte);
    procedure AddPtrBuff(p: PByte; Size: Integer);
    procedure AddI64(v: Int64);
    procedure AddU64(v: UInt64);
    procedure Addi(v: Integer);
    procedure AddWord(v: Word);
    procedure Delete(index_: Integer);
    function Count: Integer;
    procedure WriteArray(const a: array of Byte);
    procedure SetArray(const a: array of Byte);
    procedure SetBuff(p: PByte; Size: Integer);
    procedure GetBuff(p: PByte);

    procedure LoadFromStream(stream: TMemoryStream64); override;
    procedure SaveToStream(stream: TMemoryStream64); override;
{$IFNDEF FPC}
    procedure LoadFromJson(jarry: TJsonArray; index_: Integer); override;
    procedure SaveToJson(jarry: TJsonArray; index_: Integer); override;
{$ENDIF}
    function ComputeEncodeSize: Int64; override;

    function GetBuffer(index_: Integer): Byte;
    procedure SetBuffer(index_: Integer; Value: Byte);
    property Buffer[index_: Integer]: Byte read GetBuffer write SetBuffer; default;
  end;

  TDataFrameArraySingle = class sealed(TDataFrameBase)
  protected
    FBuffer: TCoreClassList;
  public
    constructor Create(ID: Byte);
    destructor Destroy; override;

    procedure Clear;
    procedure Add(v: Single);
    procedure Delete(index_: Integer);
    function Count: Integer;
    procedure WriteArray(const a: array of Single);

    procedure LoadFromStream(stream: TMemoryStream64); override;
    procedure SaveToStream(stream: TMemoryStream64); override;
{$IFNDEF FPC}
    procedure LoadFromJson(jarry: TJsonArray; index_: Integer); override;
    procedure SaveToJson(jarry: TJsonArray; index_: Integer); override;
{$ENDIF}
    function ComputeEncodeSize: Int64; override;

    function GetBuffer(index_: Integer): Single;
    procedure SetBuffer(index_: Integer; Value: Single);
    property Buffer[index_: Integer]: Single read GetBuffer write SetBuffer; default;
  end;

  TDataFrameArrayDouble = class sealed(TDataFrameBase)
  private
  protected
    FBuffer: TCoreClassList;
  public
    constructor Create(ID: Byte);
    destructor Destroy; override;

    procedure Clear;
    procedure Add(v: Double);
    procedure Delete(index_: Integer);
    function Count: Integer;
    procedure WriteArray(const a: array of Double);

    procedure LoadFromStream(stream: TMemoryStream64); override;
    procedure SaveToStream(stream: TMemoryStream64); override;
{$IFNDEF FPC}
    procedure LoadFromJson(jarry: TJsonArray; index_: Integer); override;
    procedure SaveToJson(jarry: TJsonArray; index_: Integer); override;
{$ENDIF}
    function ComputeEncodeSize: Int64; override;

    function GetBuffer(index_: Integer): Double;
    procedure SetBuffer(index_: Integer; Value: Double);
    property Buffer[index_: Integer]: Double read GetBuffer write SetBuffer; default;
  end;

  TDataFrameArrayInt64 = class sealed(TDataFrameBase)
  private
  protected
    FBuffer: TCoreClassList;
  public
    constructor Create(ID: Byte);
    destructor Destroy; override;

    procedure Clear;
    procedure Add(v: Int64);
    procedure Delete(index_: Integer);
    function Count: Integer;
    procedure WriteArray(const a: array of Int64);

    procedure LoadFromStream(stream: TMemoryStream64); override;
    procedure SaveToStream(stream: TMemoryStream64); override;
{$IFNDEF FPC}
    procedure LoadFromJson(jarry: TJsonArray; index_: Integer); override;
    procedure SaveToJson(jarry: TJsonArray; index_: Integer); override;
{$ENDIF}
    function ComputeEncodeSize: Int64; override;

    function GetBuffer(index_: Integer): Int64;
    procedure SetBuffer(index_: Integer; Value: Int64);
    property Buffer[index_: Integer]: Int64 read GetBuffer write SetBuffer; default;
  end;

  TDataFrameStream = class sealed(TDataFrameBase)
  private
  protected
    FBuffer: TMemoryStream64;
  public
    constructor Create(ID: Byte);
    destructor Destroy; override;

    procedure Clear;

    procedure LoadFromStream(stream: TMemoryStream64); override;
    procedure SaveToStream(stream: TMemoryStream64); override;
{$IFNDEF FPC}
    procedure LoadFromJson(jarry: TJsonArray; index_: Integer); override;
    procedure SaveToJson(jarry: TJsonArray; index_: Integer); override;
{$ENDIF}
    function ComputeEncodeSize: Int64; override;

    function GetBuffer: TCoreClassStream;
    procedure SetBuffer(_Buffer: TCoreClassStream);
    property Buffer: TCoreClassStream read GetBuffer write SetBuffer;
  end;

  TDataFrameVariant = class sealed(TDataFrameBase)
  private
  protected
    FBuffer: Variant;
  public
    constructor Create(ID: Byte);
    destructor Destroy; override;

    procedure LoadFromStream(stream: TMemoryStream64); override;
    procedure SaveToStream(stream: TMemoryStream64); override;
{$IFNDEF FPC}
    procedure LoadFromJson(jarry: TJsonArray; index_: Integer); override;
    procedure SaveToJson(jarry: TJsonArray; index_: Integer); override;
{$ENDIF}
    function ComputeEncodeSize: Int64; override;

    property Buffer: Variant read FBuffer write FBuffer;
  end;

  TDataFrameInt64 = class sealed(TDataFrameBase)
  private
  protected
    FBuffer: Int64;
  public
    constructor Create(ID: Byte);
    destructor Destroy; override;

    procedure LoadFromStream(stream: TMemoryStream64); override;
    procedure SaveToStream(stream: TMemoryStream64); override;
{$IFNDEF FPC}
    procedure LoadFromJson(jarry: TJsonArray; index_: Integer); override;
    procedure SaveToJson(jarry: TJsonArray; index_: Integer); override;
{$ENDIF}
    function ComputeEncodeSize: Int64; override;

    property Buffer: Int64 read FBuffer write FBuffer;
  end;

  TDataFrameUInt64 = class sealed(TDataFrameBase)
  private
  protected
    FBuffer: UInt64;
  public
    constructor Create(ID: Byte);
    destructor Destroy; override;

    procedure LoadFromStream(stream: TMemoryStream64); override;
    procedure SaveToStream(stream: TMemoryStream64); override;
{$IFNDEF FPC}
    procedure LoadFromJson(jarry: TJsonArray; index_: Integer); override;
    procedure SaveToJson(jarry: TJsonArray; index_: Integer); override;
{$ENDIF}
    function ComputeEncodeSize: Int64; override;

    property Buffer: UInt64 read FBuffer write FBuffer;
  end;

  TDataFrameEngine = class;

  TDataFrameEngineReader = class sealed(TCoreClassObject)
  private
    FOwner: TDataFrameEngine;
    FIndex: Integer;
  public
    constructor Create(AOwner: TDataFrameEngine);
    destructor Destroy; override;
    property index: Integer read FIndex write FIndex;
    //
    function IsEnd: Boolean;
    function NotEnd: Boolean;
    procedure GoNext;
    //
    function ReadString: SystemString;
    function ReadBytes: TBytes;
    function ReadInteger: Integer;
    function ReadCardinal: Cardinal;
    function ReadWord: Word;
    function ReadBool: Boolean;
    function ReadBoolean: Boolean;
    function ReadByte: Byte;
    function ReadSingle: Single;
    function ReadDouble: Double;
    function ReadArrayInteger: TDataFrameArrayInteger;
    function ReadArrayShortInt: TDataFrameArrayShortInt;
    function ReadArrayByte: TDataFrameArrayByte;
    function ReadMD5: TMD5;
    function ReadArraySingle: TDataFrameArraySingle;
    function ReadArrayDouble: TDataFrameArrayDouble;
    function ReadArrayInt64: TDataFrameArrayInt64;
    procedure ReadStream(output: TCoreClassStream);
    function ReadVariant: Variant;
    function ReadInt64: Int64;
    function ReadUInt64: UInt64;
    procedure ReadStrings(output: TCoreClassStrings);
    procedure ReadListStrings(output: TListString);
    procedure ReadPascalStrings(output: TListPascalString);
    procedure ReadDataFrame(output: TDataFrameEngine);
    procedure ReadHashStringList(output: THashStringList);
    procedure ReadVariantList(output: THashVariantList);
    procedure ReadSectionText(output: TSectionTextData);
    procedure ReadTextSection(output: TSectionTextData);
{$IFNDEF FPC} procedure ReadJson(output: TJsonObject); {$ENDIF}
    function ReadRect: TRect;
    function ReadRectf: TRectf;
    function ReadPoint: TPoint;
    function ReadPointf: TPointf;
    function ReadVector: TVector;
    function ReadAffineVector: TAffineVector;
    function ReadVec3: TVec3;
    function ReadVec4: TVec4;
    function ReadVector3: TVector3;
    function ReadVector4: TVector4;
    function ReadMat4: TMat4;
    function ReadMatrix4: TMatrix4;
    function Read2DPoint: T2DPoint;
    function ReadVec2: TVec2;
    function ReadRectV2: TRectV2;
    function ReadPointer: UInt64;
    // auto read from stream data
    procedure Read(var aBuf; aCount: Int64); overload;
    // read as TDataFrameBase
    function Read: TDataFrameBase; overload;
  end;

  TDataFrameEngine = class(TCoreClassObject)
  private type
    TRunTimeDataType = (rdtString, rdtInteger, rdtLongWord, rdtWORD, rdtByte, rdtSingle, rdtDouble,
      rdtArrayInteger, rdtArraySingle, rdtArrayDouble, rdtStream, rdtVariant, rdtInt64, rdtArrayShortInt, rdtCardinal, rdtUInt64, rdtArrayByte,
      rdtArrayInt64);
  private
    FDataList: TCoreClassListForObj;
    FReader: TDataFrameEngineReader;
    FCompressorDeflate: TCompressorDeflate;
    FCompressorBRRC: TCompressorBRRC;
  protected
    function DataTypeToByte(v: TRunTimeDataType): Byte;
    function ByteToDataType(v: Byte): TRunTimeDataType;
  public
    constructor Create;
    destructor Destroy; override;

    property Reader: TDataFrameEngineReader read FReader;

    procedure Clear;
    function AddData(v: TRunTimeDataType): TDataFrameBase;
    function GetData(index_: Integer): TDataFrameBase;
    function GetDataInfo(Obj_: TDataFrameBase): SystemString;
    function Count: Integer;
    function Delete(index_: Integer): Boolean;
    function DeleteFirst: Boolean;
    function DeleteLast: Boolean; overload;
    function DeleteLastCount(cnt: Integer): Boolean; overload;
    function DeleteCount(index_, _Count: Integer): Boolean;
    //
    procedure Assign(source: TDataFrameEngine);
    function Clone: TDataFrameEngine;
    //
    procedure WriteString(v: SystemString); overload;
    procedure WriteString(v: TPascalString); overload;
    procedure WriteBytes(v: TBytes);
    procedure WriteInteger(v: Integer);
    procedure WriteCardinal(v: Cardinal);
    procedure WriteWORD(v: Word);
    procedure WriteBool(v: Boolean);
    procedure WriteBoolean(v: Boolean);
    procedure WriteByte(v: Byte);
    procedure WriteSingle(v: Single);
    procedure WriteDouble(v: Double);
    function WriteArrayInteger: TDataFrameArrayInteger;
    function WriteArrayShortInt: TDataFrameArrayShortInt;
    function WriteArrayByte: TDataFrameArrayByte;
    procedure WriteMD5(md5: TMD5);
    function WriteArraySingle: TDataFrameArraySingle;
    function WriteArrayDouble: TDataFrameArrayDouble;
    function WriteArrayInt64: TDataFrameArrayInt64;
    procedure WriteStream(v: TCoreClassStream);
    procedure WriteVariant(v: Variant);
    procedure WriteInt64(v: Int64);
    procedure WriteUInt64(v: UInt64);
    procedure WriteStrings(v: TCoreClassStrings);
    procedure WriteListStrings(v: TListString);
    procedure WritePascalStrings(v: TListPascalString);
    procedure WriteDataFrame(v: TDataFrameEngine);
    procedure WriteDataFrameCompressed(v: TDataFrameEngine);
    procedure WriteHashStringList(v: THashStringList);
    procedure WriteVariantList(v: THashVariantList);
    procedure WriteSectionText(v: TSectionTextData);
    procedure WriteTextSection(v: TSectionTextData);
{$IFNDEF FPC} procedure WriteJson(v: TJsonObject); {$ENDIF}
    procedure WriteFile(fn: SystemString);
    procedure WriteRect(v: TRect);
    procedure WriteRectf(v: TRectf);
    procedure WritePoint(v: TPoint);
    procedure WritePointf(v: TPointf);
    procedure WriteVector(v: TVector);
    procedure WriteAffineVector(v: TAffineVector);
    procedure WriteVec4(v: TVec4);
    procedure WriteVec3(v: TVec3);
    procedure WriteVector4(v: TVector4);
    procedure WriteVector3(v: TVector3);
    procedure WriteMat4(v: TMat4);
    procedure WriteMatrix4(v: TMatrix4);
    procedure Write2DPoint(v: T2DPoint);
    procedure WriteVec2(v: TVec2);
    procedure WriteRectV2(v: TRectV2);
    procedure WritePointer(v: Pointer); overload;
    procedure WritePointer(v: UInt64); overload;
    // auto append new stream and write
    procedure write(const aBuf; aCount: Int64);
    //
    function ReadString(index_: Integer): SystemString;
    function ReadBytes(index_: Integer): TBytes;
    function ReadInteger(index_: Integer): Integer;
    function ReadCardinal(index_: Integer): Cardinal;
    function ReadWord(index_: Integer): Word;
    function ReadBool(index_: Integer): Boolean;
    function ReadBoolean(index_: Integer): Boolean;
    function ReadByte(index_: Integer): Byte;
    function ReadSingle(index_: Integer): Single;
    function ReadDouble(index_: Integer): Double;
    function ReadArrayInteger(index_: Integer): TDataFrameArrayInteger;
    function ReadArrayShortInt(index_: Integer): TDataFrameArrayShortInt;
    function ReadArrayByte(index_: Integer): TDataFrameArrayByte;
    function ReadMD5(index_: Integer): TMD5;
    function ReadArraySingle(index_: Integer): TDataFrameArraySingle;
    function ReadArrayDouble(index_: Integer): TDataFrameArrayDouble;
    function ReadArrayInt64(index_: Integer): TDataFrameArrayInt64;
    procedure ReadStream(index_: Integer; output: TCoreClassStream);
    function ReadVariant(index_: Integer): Variant;
    function ReadInt64(index_: Integer): Int64;
    function ReadUInt64(index_: Integer): UInt64;
    procedure ReadStrings(index_: Integer; output: TCoreClassStrings);
    procedure ReadListStrings(index_: Integer; output: TListString);
    procedure ReadPascalStrings(index_: Integer; output: TListPascalString);
    procedure ReadDataFrame(index_: Integer; output: TDataFrameEngine);
    procedure ReadHashStringList(index_: Integer; output: THashStringList);
    procedure ReadVariantList(index_: Integer; output: THashVariantList);
    procedure ReadSectionText(index_: Integer; output: TSectionTextData);
    procedure ReadTextSection(index_: Integer; output: TSectionTextData);
{$IFNDEF FPC} procedure ReadJson(index_: Integer; output: TJsonObject); {$ENDIF}
    function ReadRect(index_: Integer): TRect;
    function ReadRectf(index_: Integer): TRectf;
    function ReadPoint(index_: Integer): TPoint;
    function ReadPointf(index_: Integer): TPointf;
    function ReadVector(index_: Integer): TVector;
    function ReadAffineVector(index_: Integer): TAffineVector;
    function ReadVec3(index_: Integer): TVec3;
    function ReadVec4(index_: Integer): TVec4;
    function ReadVector3(index_: Integer): TVector3;
    function ReadVector4(index_: Integer): TVector4;
    function ReadMat4(index_: Integer): TMat4;
    function ReadMatrix4(index_: Integer): TMatrix4;
    function Read2DPoint(index_: Integer): T2DPoint;
    function ReadVec2(index_: Integer): TVec2;
    function ReadRectV2(index_: Integer): TRectV2;
    function ReadPointer(index_: Integer): UInt64;
    // read from stream data
    procedure Read(index_: Integer; var aBuf; aCount: Int64); overload;
    // read as TDataFrameBase
    function Read(index_: Integer): TDataFrameBase; overload;
    //
    function ComputeEncodeSize: Int64;

    class procedure BuildEmptyStream(output: TCoreClassStream);

    function EncodeTo(output: TCoreClassStream; const FastMode: Boolean): Integer; overload;
    function EncodeTo(output: TCoreClassStream): Integer; overload;

    // data security support
    // QuantumCryptographyPassword: used sha-3-512 cryptography as 512 bits password
    procedure Encrypt(output: TCoreClassStream; Compressed_: Boolean; SecurityLevel: Integer; Key: TCipherKeyBuffer);
    function Decrypt(input: TCoreClassStream; Key: TCipherKeyBuffer): Boolean;

    // json support
{$IFNDEF FPC}
    procedure EncodeAsPublicJson(var output: TPascalString); overload;
    procedure EncodeAsPublicJson(output: TCoreClassStream); overload;
    procedure EncodeAsJson(output: TCoreClassStream);
    procedure DecodeFromJson(stream: TCoreClassStream); overload;
    procedure DecodeFromJson(const s: TPascalString); overload;
{$ENDIF}
    //
    // Parallel compressor
    function EncodeAsSelectCompressor(scm: TSelectCompressionMethod; output: TCoreClassStream; const FastMode: Boolean): Integer; overload;
    function EncodeAsSelectCompressor(output: TCoreClassStream; const FastMode: Boolean): Integer; overload;
    function EncodeAsSelectCompressor(output: TCoreClassStream): Integer; overload;

    // ZLib compressor
    function EncodeAsZLib(output: TCoreClassStream; const FastMode: Boolean): Integer; overload;
    function EncodeAsZLib(output: TCoreClassStream): Integer; overload;

    // Deflate compressor
    function EncodeAsDeflate(output: TCoreClassStream; const FastMode: Boolean): Integer; overload;
    function EncodeAsDeflate(output: TCoreClassStream): Integer; overload;

    // BRRC compressor
    function EncodeAsBRRC(output: TCoreClassStream; const FastMode: Boolean): Integer; overload;
    function EncodeAsBRRC(output: TCoreClassStream): Integer; overload;

    function IsCompressed(source: TCoreClassStream): Boolean;

    function DecodeFrom(source: TCoreClassStream; const FastMode: Boolean): Integer; overload;
    function DecodeFrom(source: TCoreClassStream): Integer; overload;

    procedure EncodeToBytes(const Compressed, FastMode: Boolean; var output: TBytes);
    procedure DecodeFromBytes(var buff: TBytes); overload;
    procedure DecodeFromBytes(var buff: TBytes; const FastMode: Boolean); overload;

    function GetMD5(const FastMode: Boolean): TMD5;

    // fast compare
    function Compare(source: TDataFrameEngine): Boolean;

    procedure LoadFromStream(stream: TCoreClassStream);
    procedure SaveToStream(stream: TCoreClassStream);

    property Data[index_: Integer]: TDataFrameBase read GetData; default;
    property List: TCoreClassListForObj read FDataList;
  end;

  TDataWriter = class sealed(TCoreClassPersistent)
  protected
    FEngine: TDataFrameEngine;
    FStream: TCoreClassStream;
  public
    constructor Create(AStream: TCoreClassStream);
    destructor Destroy; override;

    procedure Clear; { virtual; }

    procedure WriteString(v: SystemString);                  { virtual; }
    procedure WriteBytes(v: TBytes);                         { virtual; }
    procedure WriteInteger(v: Integer);                      { virtual; }
    procedure WriteCardinal(v: Cardinal);                    { virtual; }
    procedure WriteWORD(v: Word);                            { virtual; }
    procedure WriteBool(v: Boolean);                         { virtual; }
    procedure WriteBoolean(v: Boolean);                      { virtual; }
    procedure WriteByte(v: Byte);                            { virtual; }
    procedure WriteSingle(v: Single);                        { virtual; }
    procedure WriteDouble(v: Double);                        { virtual; }
    procedure WriteArrayInteger(v: array of Integer);        { virtual; }
    procedure WriteArrayShortInt(v: array of ShortInt);      { virtual; }
    procedure WriteArrayByte(v: array of Byte);              { virtual; }
    procedure WriteArraySingle(v: array of Single);          { virtual; }
    procedure WriteArrayDouble(v: array of Double);          { virtual; }
    procedure WriteArrayInt64(v: array of Int64);            { virtual; }
    procedure WriteStream(v: TCoreClassStream);              { virtual; }
    procedure WriteVariant(v: Variant);                      { virtual; }
    procedure WriteInt64(v: Int64);                          { virtual; }
    procedure WriteUInt64(v: UInt64);                        { virtual; }
    procedure WriteStrings(v: TCoreClassStrings);            { virtual; }
    procedure WriteListStrings(v: TListString);              { virtual; }
    procedure WritePascalStrings(v: TListPascalString);      { virtual; }
    procedure WriteDataFrame(v: TDataFrameEngine);           { virtual; }
    procedure WriteDataFrameCompressed(v: TDataFrameEngine); { virtual; }
    procedure WriteHashStringList(v: THashStringList);       { virtual; }
    procedure WriteVariantList(v: THashVariantList);         { virtual; }
    procedure WriteSectionText(v: TSectionTextData);         { virtual; }
{$IFNDEF FPC} procedure WriteJson(v: TJsonObject); { virtual; }    {$ENDIF}
    procedure WriteRect(v: TRect);                 { virtual; }
    procedure WriteRectf(v: TRectf);               { virtual; }
    procedure WritePoint(v: TPoint);               { virtual; }
    procedure WritePointf(v: TPointf);             { virtual; }
    procedure WriteVector(v: TVector);             { virtual; }
    procedure WriteAffineVector(v: TAffineVector); { virtual; }
    procedure WriteVec4(v: TVec4);                 { virtual; }
    procedure WriteVec3(v: TVec3);                 { virtual; }
    procedure WriteVector4(v: TVector4);           { virtual; }
    procedure WriteVector3(v: TVector3);           { virtual; }
    procedure WriteMat4(v: TMat4);                 { virtual; }
    procedure WriteMatrix4(v: TMatrix4);           { virtual; }
    procedure Write2DPoint(v: T2DPoint);           { virtual; }
    procedure WriteVec2(v: TVec2);                 { virtual; }
    procedure WriteRectV2(v: TRectV2);             { virtual; }
    procedure WritePointer(v: Pointer);            { virtual; }
    procedure write(const aBuf; aCount: Int64);    { virtual; }
  end;

  TDataReader = class sealed(TCoreClassPersistent)
  protected
    FEngine: TDataFrameEngine;
  public
    constructor Create(AStream: TCoreClassStream);
    destructor Destroy; override;

    function ReadString: SystemString;                        { virtual; }
    function ReadBytes: TBytes;                               { virtual; }
    function ReadInteger: Integer;                            { virtual; }
    function ReadCardinal: Cardinal;                          { virtual; }
    function ReadWord: Word;                                  { virtual; }
    function ReadBool: Boolean;                               { virtual; }
    function ReadBoolean: Boolean;                            { virtual; }
    function ReadByte: Byte;                                  { virtual; }
    function ReadSingle: Single;                              { virtual; }
    function ReadDouble: Double;                              { virtual; }
    procedure ReadArrayInteger(var Data: array of Integer);   { virtual; }
    procedure ReadArrayShortInt(var Data: array of ShortInt); { virtual; }
    procedure ReadArrayByte(var Data: array of Byte);         { virtual; }
    procedure ReadArraySingle(var Data: array of Single);     { virtual; }
    procedure ReadArrayDouble(var Data: array of Double);     { virtual; }
    procedure ReadArrayInt64(var Data: array of Int64);       { virtual; }
    procedure ReadStream(output: TCoreClassStream);           { virtual; }
    function ReadVariant: Variant;                            { virtual; }
    function ReadInt64: Int64;                                { virtual; }
    function ReadUInt64: UInt64;                              { virtual; }
    procedure ReadStrings(output: TCoreClassStrings);         { virtual; }
    procedure ReadListStrings(output: TListString);           { virtual; }
    procedure ReadPascalStrings(output: TListPascalString);   { virtual; }
    procedure ReadDataFrame(output: TDataFrameEngine);        { virtual; }
    procedure ReadHashStringList(output: THashStringList);    { virtual; }
    procedure ReadVariantList(output: THashVariantList);      { virtual; }
    procedure ReadSectionText(output: TSectionTextData);      { virtual; }
{$IFNDEF FPC} procedure ReadJson(output: TJsonObject); { virtual; }    {$ENDIF}
    function ReadRect: TRect;                 { virtual; }
    function ReadRectf: TRectf;               { virtual; }
    function ReadPoint: TPoint;               { virtual; }
    function ReadPointf: TPointf;             { virtual; }
    function ReadVector: TVector;             { virtual; }
    function ReadAffineVector: TAffineVector; { virtual; }
    function ReadVec3: TVec3;                 { virtual; }
    function ReadVec4: TVec4;                 { virtual; }
    function ReadVector3: TVector3;           { virtual; }
    function ReadVector4: TVector4;           { virtual; }
    function ReadMat4: TMat4;                 { virtual; }
    function ReadMatrix4: TMatrix4;           { virtual; }
    function Read2DPoint: T2DPoint;           { virtual; }
    function ReadVec2: TVec2;                 { virtual; }
    function ReadRectV2: TRectV2;             { virtual; }
    function ReadPointer: UInt64;             { virtual; }
    procedure Read(var aBuf; aCount: Int64);  { virtual; }
  end;

implementation

constructor TDataFrameBase.Create(ID: Byte);
begin
  inherited Create;
  FID := ID;
end;

destructor TDataFrameBase.Destroy;
begin
  inherited Destroy;
end;

constructor TDataFrameString.Create(ID: Byte);
begin
  inherited Create(ID);
  SetLength(Buffer, 0);
end;

destructor TDataFrameString.Destroy;
begin
  SetLength(Buffer, 0);
  inherited Destroy;
end;

procedure TDataFrameString.LoadFromStream(stream: TMemoryStream64);
var
  _Len: Integer;
begin
  stream.Read64(_Len, C_Integer_Size);
  SetLength(Buffer, _Len);
  if (_Len > 0) then
      stream.Read64(Buffer[0], _Len);
end;

procedure TDataFrameString.SaveToStream(stream: TMemoryStream64);
var
  _Len: Integer;
begin
  _Len := length(Buffer);
  stream.Write64(_Len, C_Integer_Size);
  if _Len > 0 then
      stream.Write64(Buffer[0], _Len);
end;

{$IFNDEF FPC}


procedure TDataFrameString.LoadFromJson(jarry: TJsonArray; index_: Integer);
begin
  Buffer := umlBytesOf(jarry.s[index_]);
end;

procedure TDataFrameString.SaveToJson(jarry: TJsonArray; index_: Integer);
begin
  jarry.Add(umlStringOf(Buffer));
end;
{$ENDIF}


function TDataFrameString.ComputeEncodeSize: Int64;
begin
  Result := C_Integer_Size + length(Buffer);
end;

constructor TDataFrameInteger.Create(ID: Byte);
begin
  inherited Create(ID);
  Buffer := 0;
end;

destructor TDataFrameInteger.Destroy;
begin
  inherited Destroy;
end;

procedure TDataFrameInteger.LoadFromStream(stream: TMemoryStream64);
begin
  stream.Read64(FBuffer, C_Integer_Size);
end;

procedure TDataFrameInteger.SaveToStream(stream: TMemoryStream64);
begin
  stream.Write64(FBuffer, C_Integer_Size);
end;

{$IFNDEF FPC}


procedure TDataFrameInteger.LoadFromJson(jarry: TJsonArray; index_: Integer);
begin
  FBuffer := jarry.i[index_];
end;

procedure TDataFrameInteger.SaveToJson(jarry: TJsonArray; index_: Integer);
begin
  jarry.Add(FBuffer);
end;
{$ENDIF}


function TDataFrameInteger.ComputeEncodeSize: Int64;
begin
  Result := C_Integer_Size;
end;

constructor TDataFrameCardinal.Create(ID: Byte);
begin
  inherited Create(ID);
  Buffer := 0;
end;

destructor TDataFrameCardinal.Destroy;
begin
  inherited Destroy;
end;

procedure TDataFrameCardinal.LoadFromStream(stream: TMemoryStream64);
begin
  stream.Read64(FBuffer, C_Cardinal_Size);
end;

procedure TDataFrameCardinal.SaveToStream(stream: TMemoryStream64);
begin
  stream.Write64(FBuffer, C_Cardinal_Size);
end;

{$IFNDEF FPC}


procedure TDataFrameCardinal.LoadFromJson(jarry: TJsonArray; index_: Integer);
begin
  FBuffer := jarry.i[index_];
end;

procedure TDataFrameCardinal.SaveToJson(jarry: TJsonArray; index_: Integer);
begin
  jarry.Add(FBuffer);
end;
{$ENDIF}


function TDataFrameCardinal.ComputeEncodeSize: Int64;
begin
  Result := C_Cardinal_Size;
end;

constructor TDataFrameWord.Create(ID: Byte);
begin
  inherited Create(ID);
  Buffer := 0;
end;

destructor TDataFrameWord.Destroy;
begin
  inherited Destroy;
end;

procedure TDataFrameWord.LoadFromStream(stream: TMemoryStream64);
begin
  stream.Read64(FBuffer, C_Word_Size);
end;

procedure TDataFrameWord.SaveToStream(stream: TMemoryStream64);
begin
  stream.Write64(FBuffer, C_Word_Size);
end;

{$IFNDEF FPC}


procedure TDataFrameWord.LoadFromJson(jarry: TJsonArray; index_: Integer);
begin
  FBuffer := jarry.i[index_];
end;

procedure TDataFrameWord.SaveToJson(jarry: TJsonArray; index_: Integer);
begin
  jarry.Add(FBuffer);
end;
{$ENDIF}


function TDataFrameWord.ComputeEncodeSize: Int64;
begin
  Result := C_Word_Size;
end;

constructor TDataFrameByte.Create(ID: Byte);
begin
  inherited Create(ID);
  Buffer := 0;
end;

destructor TDataFrameByte.Destroy;
begin
  inherited Destroy;
end;

procedure TDataFrameByte.LoadFromStream(stream: TMemoryStream64);
begin
  stream.Read64(FBuffer, C_Byte_Size);
end;

procedure TDataFrameByte.SaveToStream(stream: TMemoryStream64);
begin
  stream.Write64(FBuffer, C_Byte_Size);
end;

{$IFNDEF FPC}


procedure TDataFrameByte.LoadFromJson(jarry: TJsonArray; index_: Integer);
begin
  FBuffer := jarry.i[index_];
end;

procedure TDataFrameByte.SaveToJson(jarry: TJsonArray; index_: Integer);
begin
  jarry.Add(FBuffer);
end;
{$ENDIF}


function TDataFrameByte.ComputeEncodeSize: Int64;
begin
  Result := C_Byte_Size;
end;

constructor TDataFrameSingle.Create(ID: Byte);
begin
  inherited Create(ID);
  Buffer := 0;
end;

destructor TDataFrameSingle.Destroy;
begin
  inherited Destroy;
end;

procedure TDataFrameSingle.LoadFromStream(stream: TMemoryStream64);
begin
  stream.Read64(FBuffer, C_Single_Size);
end;

procedure TDataFrameSingle.SaveToStream(stream: TMemoryStream64);
begin
  stream.Write64(FBuffer, C_Single_Size);
end;

{$IFNDEF FPC}


procedure TDataFrameSingle.LoadFromJson(jarry: TJsonArray; index_: Integer);
begin
  FBuffer := jarry.f[index_];
end;

procedure TDataFrameSingle.SaveToJson(jarry: TJsonArray; index_: Integer);
begin
  jarry.AddF(FBuffer);
end;
{$ENDIF}


function TDataFrameSingle.ComputeEncodeSize: Int64;
begin
  Result := C_Single_Size;
end;

constructor TDataFrameDouble.Create(ID: Byte);
begin
  inherited Create(ID);
  Buffer := 0;
end;

destructor TDataFrameDouble.Destroy;
begin
  inherited Destroy;
end;

procedure TDataFrameDouble.LoadFromStream(stream: TMemoryStream64);
begin
  stream.Read64(FBuffer, C_Double_Size);
end;

procedure TDataFrameDouble.SaveToStream(stream: TMemoryStream64);
begin
  stream.Write64(FBuffer, C_Double_Size);
end;

{$IFNDEF FPC}


procedure TDataFrameDouble.LoadFromJson(jarry: TJsonArray; index_: Integer);
begin
  FBuffer := jarry.f[index_];
end;

procedure TDataFrameDouble.SaveToJson(jarry: TJsonArray; index_: Integer);
begin
  jarry.AddF(FBuffer);
end;
{$ENDIF}


function TDataFrameDouble.ComputeEncodeSize: Int64;
begin
  Result := C_Double_Size;
end;

constructor TDataFrameArrayInteger.Create(ID: Byte);
begin
  inherited Create(ID);
  FBuffer := TCoreClassList.Create;
end;

destructor TDataFrameArrayInteger.Destroy;
begin
  Clear;
  DisposeObject(FBuffer);
  inherited Destroy;
end;

procedure TDataFrameArrayInteger.Clear;
var
  i: Integer;
  p: PInteger;
begin
  for i := 0 to FBuffer.Count - 1 do
    begin
      p := FBuffer[i];
      Dispose(p);
    end;
  FBuffer.Clear;
end;

procedure TDataFrameArrayInteger.Add(v: Integer);
var
  _PV: PInteger;
begin
  new(_PV);
  _PV^ := v;
  FBuffer.Add(_PV);
end;

procedure TDataFrameArrayInteger.Delete(index_: Integer);
begin
  Dispose(PInteger(FBuffer[index_]));
  FBuffer.Delete(index_);
end;

function TDataFrameArrayInteger.Count: Integer;
begin
  Result := FBuffer.Count;
end;

procedure TDataFrameArrayInteger.WriteArray(const a: array of Integer);
var
  i: Integer;
begin
  for i := low(a) to high(a) do
      Add(a[i]);
end;

procedure TDataFrameArrayInteger.LoadFromStream(stream: TMemoryStream64);
var
  i, L: Integer;
  d: Integer;
begin
  Clear;
  stream.Read64(L, C_Integer_Size);
  for i := 0 to L - 1 do
    begin
      stream.Read64(d, C_Integer_Size);
      Add(d);
    end;
end;

procedure TDataFrameArrayInteger.SaveToStream(stream: TMemoryStream64);
var
  i, L: Integer;
  d: Integer;
begin
  L := Count;
  stream.Write64(L, C_Integer_Size);
  for i := 0 to L - 1 do
    begin
      d := Buffer[i];
      stream.Write64(d, C_Integer_Size);
    end;
end;

{$IFNDEF FPC}


procedure TDataFrameArrayInteger.LoadFromJson(jarry: TJsonArray; index_: Integer);
var
  ja: TJsonArray;
  i: Integer;
begin
  ja := jarry.a[index_];
  for i := 0 to ja.Count - 1 do
      Add(ja.i[i]);
end;

procedure TDataFrameArrayInteger.SaveToJson(jarry: TJsonArray; index_: Integer);
var
  ja: TJsonArray;
  i: Integer;
begin
  ja := jarry.AddArray;
  for i := 0 to Count - 1 do
      ja.Add(Buffer[i]);
end;
{$ENDIF}


function TDataFrameArrayInteger.ComputeEncodeSize: Int64;
begin
  Result := C_Integer_Size + C_Integer_Size * Count;
end;

function TDataFrameArrayInteger.GetBuffer(index_: Integer): Integer;
begin
  Result := PInteger(FBuffer[index_])^;
end;

procedure TDataFrameArrayInteger.SetBuffer(index_: Integer; Value: Integer);
begin
  PInteger(FBuffer[index_])^ := Value;
end;

constructor TDataFrameArrayShortInt.Create(ID: ShortInt);
begin
  inherited Create(ID);
  FBuffer := TCoreClassList.Create;
end;

destructor TDataFrameArrayShortInt.Destroy;
begin
  Clear;
  DisposeObject(FBuffer);
  inherited Destroy;
end;

procedure TDataFrameArrayShortInt.Clear;
var
  i: Integer;
  p: PShortInt;
begin
  for i := 0 to FBuffer.Count - 1 do
    begin
      p := FBuffer[i];
      Dispose(p);
    end;
  FBuffer.Clear;
end;

procedure TDataFrameArrayShortInt.Add(v: ShortInt);
var
  _PV: PShortInt;
begin
  new(_PV);
  _PV^ := v;
  FBuffer.Add(_PV);
end;

procedure TDataFrameArrayShortInt.Delete(index_: Integer);
begin
  Dispose(PShortInt(FBuffer[index_]));
  FBuffer.Delete(index_);
end;

function TDataFrameArrayShortInt.Count: Integer;
begin
  Result := FBuffer.Count;
end;

procedure TDataFrameArrayShortInt.WriteArray(const a: array of ShortInt);
var
  i: Integer;
begin
  for i := low(a) to high(a) do
      Add(a[i]);
end;

procedure TDataFrameArrayShortInt.LoadFromStream(stream: TMemoryStream64);
var
  i, L: Integer;
  d: ShortInt;
begin
  Clear;
  stream.Read64(L, C_Integer_Size);
  for i := 0 to L - 1 do
    begin
      stream.Read64(d, C_Short_Int_Size);
      Add(d);
    end;
end;

procedure TDataFrameArrayShortInt.SaveToStream(stream: TMemoryStream64);
var
  i, L: Integer;
  d: ShortInt;
begin
  L := Count;
  stream.Write64(L, C_Integer_Size);
  for i := 0 to L - 1 do
    begin
      d := Buffer[i];
      stream.Write64(d, C_Short_Int_Size);
    end;
end;

{$IFNDEF FPC}


procedure TDataFrameArrayShortInt.LoadFromJson(jarry: TJsonArray; index_: Integer);
var
  ja: TJsonArray;
  i: Integer;
begin
  ja := jarry.a[index_];
  for i := 0 to ja.Count - 1 do
      Add(ja.i[i]);
end;

procedure TDataFrameArrayShortInt.SaveToJson(jarry: TJsonArray; index_: Integer);
var
  ja: TJsonArray;
  i: Integer;
begin
  ja := jarry.AddArray;
  for i := 0 to Count - 1 do
      ja.Add(Buffer[i]);
end;
{$ENDIF}


function TDataFrameArrayShortInt.ComputeEncodeSize: Int64;
begin
  Result := C_Integer_Size + C_Short_Int_Size * Count;
end;

function TDataFrameArrayShortInt.GetBuffer(index_: Integer): ShortInt;
begin
  Result := PShortInt(FBuffer[index_])^;
end;

procedure TDataFrameArrayShortInt.SetBuffer(index_: Integer; Value: ShortInt);
begin
  PShortInt(FBuffer[index_])^ := Value;
end;

constructor TDataFrameArrayByte.Create(ID: Byte);
begin
  inherited Create(ID);
  FBuffer := TCoreClassList.Create;
end;

destructor TDataFrameArrayByte.Destroy;
begin
  Clear;
  DisposeObject(FBuffer);
  inherited Destroy;
end;

procedure TDataFrameArrayByte.Clear;
var
  i: Integer;
  p: PByte;
begin
  for i := 0 to FBuffer.Count - 1 do
    begin
      p := FBuffer[i];
      Dispose(p);
    end;
  FBuffer.Clear;
end;

procedure TDataFrameArrayByte.Add(v: Byte);
var
  _PV: PByte;
begin
  new(_PV);
  _PV^ := v;
  FBuffer.Add(_PV);
end;

procedure TDataFrameArrayByte.AddPtrBuff(p: PByte; Size: Integer);
var
  i: Integer;
begin
  for i := 0 to Size - 1 do
    begin
      Add(p^);
      inc(p);
    end;
end;

procedure TDataFrameArrayByte.AddI64(v: Int64);
begin
  AddPtrBuff(@v, C_Int64_Size);
end;

procedure TDataFrameArrayByte.AddU64(v: UInt64);
begin
  AddPtrBuff(@v, C_UInt64_Size);
end;

procedure TDataFrameArrayByte.Addi(v: Integer);
begin
  AddPtrBuff(@v, C_Integer_Size);
end;

procedure TDataFrameArrayByte.AddWord(v: Word);
begin
  AddPtrBuff(@v, C_Word_Size);
end;

procedure TDataFrameArrayByte.Delete(index_: Integer);
begin
  Dispose(PByte(FBuffer[index_]));
  FBuffer.Delete(index_);
end;

function TDataFrameArrayByte.Count: Integer;
begin
  Result := FBuffer.Count;
end;

procedure TDataFrameArrayByte.WriteArray(const a: array of Byte);
var
  i: Integer;
begin
  for i := low(a) to high(a) do
      Add(a[i]);
end;

procedure TDataFrameArrayByte.SetArray(const a: array of Byte);
var
  i: Integer;
begin
  Clear;
  for i := low(a) to high(a) do
      Add(a[i]);
end;

procedure TDataFrameArrayByte.SetBuff(p: PByte; Size: Integer);
begin
  Clear;
  AddPtrBuff(p, Size);
end;

procedure TDataFrameArrayByte.GetBuff(p: PByte);
var
  i: Integer;
begin
  for i := 0 to Count - 1 do
    begin
      p^ := PByte(FBuffer[i])^;
      inc(p);
    end;
end;

procedure TDataFrameArrayByte.LoadFromStream(stream: TMemoryStream64);
var
  i, L: Integer;
  d: Byte;
begin
  Clear;
  stream.Read64(L, C_Integer_Size);
  for i := 0 to L - 1 do
    begin
      stream.Read64(d, C_Byte_Size);
      Add(d);
    end;
end;

procedure TDataFrameArrayByte.SaveToStream(stream: TMemoryStream64);
var
  i, L: Integer;
  d: Byte;
begin
  L := Count;
  stream.Write64(L, C_Integer_Size);
  for i := 0 to L - 1 do
    begin
      d := Buffer[i];
      stream.Write64(d, C_Byte_Size);
    end;
end;

{$IFNDEF FPC}


procedure TDataFrameArrayByte.LoadFromJson(jarry: TJsonArray; index_: Integer);
var
  ja: TJsonArray;
  i: Integer;
begin
  ja := jarry.a[index_];
  for i := 0 to ja.Count - 1 do
      Add(ja.i[i]);
end;

procedure TDataFrameArrayByte.SaveToJson(jarry: TJsonArray; index_: Integer);
var
  ja: TJsonArray;
  i: Integer;
begin
  ja := jarry.AddArray;
  for i := 0 to Count - 1 do
      ja.Add(Buffer[i]);
end;
{$ENDIF}


function TDataFrameArrayByte.ComputeEncodeSize: Int64;
begin
  Result := C_Integer_Size + C_Byte_Size * Count;
end;

function TDataFrameArraySingle.GetBuffer(index_: Integer): Single;
begin
  Result := PSingle(FBuffer[index_])^;
end;

procedure TDataFrameArraySingle.SetBuffer(index_: Integer; Value: Single);
begin
  PSingle(FBuffer[index_])^ := Value;
end;

function TDataFrameArrayByte.GetBuffer(index_: Integer): Byte;
begin
  Result := PByte(FBuffer[index_])^;
end;

procedure TDataFrameArrayByte.SetBuffer(index_: Integer; Value: Byte);
begin
  PByte(FBuffer[index_])^ := Value;
end;

constructor TDataFrameArraySingle.Create(ID: Byte);
begin
  inherited Create(ID);
  FBuffer := TCoreClassList.Create;
end;

destructor TDataFrameArraySingle.Destroy;
begin
  Clear;
  DisposeObject(FBuffer);
  inherited Destroy;
end;

procedure TDataFrameArraySingle.Clear;
var
  i: Integer;
  p: PSingle;
begin
  for i := 0 to FBuffer.Count - 1 do
    begin
      p := FBuffer[i];
      Dispose(p);
    end;
  FBuffer.Clear;
end;

procedure TDataFrameArraySingle.Add(v: Single);
var
  _PV: PSingle;
begin
  new(_PV);
  _PV^ := v;
  FBuffer.Add(_PV);
end;

procedure TDataFrameArraySingle.Delete(index_: Integer);
begin
  Dispose(PSingle(FBuffer[index_]));
  FBuffer.Delete(index_);
end;

function TDataFrameArraySingle.Count: Integer;
begin
  Result := FBuffer.Count;
end;

procedure TDataFrameArraySingle.WriteArray(const a: array of Single);
var
  i: Integer;
begin
  for i := low(a) to high(a) do
      Add(a[i]);
end;

procedure TDataFrameArraySingle.LoadFromStream(stream: TMemoryStream64);
var
  i, L: Integer;
  d: Single;
begin
  Clear;
  stream.Read64(L, C_Integer_Size);
  for i := 0 to L - 1 do
    begin
      stream.Read64(d, C_Single_Size);
      Add(d);
    end;
end;

procedure TDataFrameArraySingle.SaveToStream(stream: TMemoryStream64);
var
  i, L: Integer;
  d: Single;
begin
  L := Count;
  stream.Write64(L, C_Integer_Size);
  for i := 0 to L - 1 do
    begin
      d := Buffer[i];
      stream.Write64(d, C_Single_Size);
    end;
end;

{$IFNDEF FPC}


procedure TDataFrameArraySingle.LoadFromJson(jarry: TJsonArray; index_: Integer);
var
  ja: TJsonArray;
  i: Integer;
begin
  ja := jarry.a[index_];
  for i := 0 to ja.Count - 1 do
      Add(ja.f[i]);
end;

procedure TDataFrameArraySingle.SaveToJson(jarry: TJsonArray; index_: Integer);
var
  ja: TJsonArray;
  i: Integer;
begin
  ja := jarry.AddArray;
  for i := 0 to Count - 1 do
      ja.AddF(Buffer[i]);
end;
{$ENDIF}


function TDataFrameArraySingle.ComputeEncodeSize: Int64;
begin
  Result := C_Integer_Size + C_Single_Size * Count;
end;

constructor TDataFrameArrayDouble.Create(ID: Byte);
begin
  inherited Create(ID);
  FBuffer := TCoreClassList.Create;
end;

destructor TDataFrameArrayDouble.Destroy;
begin
  Clear;
  DisposeObject(FBuffer);
  inherited Destroy;
end;

procedure TDataFrameArrayDouble.Clear;
var
  i: Integer;
  p: PDouble;
begin
  for i := 0 to FBuffer.Count - 1 do
    begin
      p := FBuffer[i];
      Dispose(p);
    end;
  FBuffer.Clear;
end;

procedure TDataFrameArrayDouble.Add(v: Double);
var
  _PV: PDouble;
begin
  new(_PV);
  _PV^ := v;
  FBuffer.Add(_PV);
end;

procedure TDataFrameArrayDouble.Delete(index_: Integer);
begin
  Dispose(PDouble(FBuffer[index_]));
  FBuffer.Delete(index_);
end;

function TDataFrameArrayDouble.Count: Integer;
begin
  Result := FBuffer.Count;
end;

procedure TDataFrameArrayDouble.WriteArray(const a: array of Double);
var
  i: Integer;
begin
  for i := low(a) to high(a) do
      Add(a[i]);
end;

procedure TDataFrameArrayDouble.LoadFromStream(stream: TMemoryStream64);
var
  i, L: Integer;
  d: Double;
begin
  Clear;
  stream.Read64(L, C_Integer_Size);
  for i := 0 to L - 1 do
    begin
      stream.Read64(d, C_Double_Size);
      Add(d);
    end;
end;

procedure TDataFrameArrayDouble.SaveToStream(stream: TMemoryStream64);
var
  i, L: Integer;
  d: Double;
begin
  L := Count;
  stream.Write64(L, C_Integer_Size);
  for i := 0 to L - 1 do
    begin
      d := Buffer[i];
      stream.Write64(d, C_Double_Size);
    end;
end;

{$IFNDEF FPC}


procedure TDataFrameArrayDouble.LoadFromJson(jarry: TJsonArray; index_: Integer);
var
  ja: TJsonArray;
  i: Integer;
begin
  ja := jarry.a[index_];
  for i := 0 to ja.Count - 1 do
      Add(ja.f[i]);
end;

procedure TDataFrameArrayDouble.SaveToJson(jarry: TJsonArray; index_: Integer);
var
  ja: TJsonArray;
  i: Integer;
begin
  ja := jarry.AddArray;
  for i := 0 to Count - 1 do
      ja.AddF(Buffer[i]);
end;
{$ENDIF}


function TDataFrameArrayDouble.ComputeEncodeSize: Int64;
begin
  Result := C_Integer_Size + C_Double_Size * Count;
end;

function TDataFrameArrayDouble.GetBuffer(index_: Integer): Double;
begin
  Result := PDouble(FBuffer[index_])^;
end;

procedure TDataFrameArrayDouble.SetBuffer(index_: Integer; Value: Double);
begin
  PDouble(FBuffer[index_])^ := Value;
end;

constructor TDataFrameArrayInt64.Create(ID: Byte);
begin
  inherited Create(ID);
  FBuffer := TCoreClassList.Create;
end;

destructor TDataFrameArrayInt64.Destroy;
begin
  Clear;
  DisposeObject(FBuffer);
  inherited Destroy;
end;

procedure TDataFrameArrayInt64.Clear;
var
  i: Integer;
  p: PInt64;
begin
  for i := 0 to FBuffer.Count - 1 do
    begin
      p := FBuffer[i];
      Dispose(p);
    end;
  FBuffer.Clear;
end;

procedure TDataFrameArrayInt64.Add(v: Int64);
var
  _PV: PInt64;
begin
  new(_PV);
  _PV^ := v;
  FBuffer.Add(_PV);
end;

procedure TDataFrameArrayInt64.Delete(index_: Integer);
begin
  Dispose(PInt64(FBuffer[index_]));
  FBuffer.Delete(index_);
end;

function TDataFrameArrayInt64.Count: Integer;
begin
  Result := FBuffer.Count;
end;

procedure TDataFrameArrayInt64.WriteArray(const a: array of Int64);
var
  i: Integer;
begin
  for i := low(a) to high(a) do
      Add(a[i]);
end;

procedure TDataFrameArrayInt64.LoadFromStream(stream: TMemoryStream64);
var
  i, L: Integer;
  d: Int64;
begin
  Clear;
  stream.Read64(L, C_Integer_Size);
  for i := 0 to L - 1 do
    begin
      stream.Read64(d, C_Int64_Size);
      Add(d);
    end;
end;

procedure TDataFrameArrayInt64.SaveToStream(stream: TMemoryStream64);
var
  i, L: Integer;
  d: Int64;
begin
  L := Count;
  stream.Write64(L, C_Integer_Size);
  for i := 0 to L - 1 do
    begin
      d := Buffer[i];
      stream.Write64(d, C_Int64_Size);
    end;
end;

{$IFNDEF FPC}


procedure TDataFrameArrayInt64.LoadFromJson(jarry: TJsonArray; index_: Integer);
var
  ja: TJsonArray;
  i: Integer;
begin
  ja := jarry.a[index_];
  for i := 0 to ja.Count - 1 do
      Add(ja.L[i]);
end;

procedure TDataFrameArrayInt64.SaveToJson(jarry: TJsonArray; index_: Integer);
var
  ja: TJsonArray;
  i: Integer;
begin
  ja := jarry.AddArray;
  for i := 0 to Count - 1 do
      ja.Add(Buffer[i]);
end;
{$ENDIF}


function TDataFrameArrayInt64.ComputeEncodeSize: Int64;
begin
  Result := C_Integer_Size + C_Int64_Size * Count;
end;

function TDataFrameArrayInt64.GetBuffer(index_: Integer): Int64;
begin
  Result := PInt64(FBuffer[index_])^;
end;

procedure TDataFrameArrayInt64.SetBuffer(index_: Integer; Value: Int64);
begin
  PInt64(FBuffer[index_])^ := Value;
end;

constructor TDataFrameStream.Create(ID: Byte);
begin
  inherited Create(ID);
  FBuffer := TMemoryStream64.Create;
end;

destructor TDataFrameStream.Destroy;
begin
  DisposeObject(FBuffer);
  inherited Destroy;
end;

procedure TDataFrameStream.Clear;
begin
  FBuffer.Clear;
end;

procedure TDataFrameStream.LoadFromStream(stream: TMemoryStream64);
var
  _Len: Integer;
begin
  FBuffer.Clear;
  stream.Read64(_Len, C_Integer_Size);
  if (_Len > 0) then
      FBuffer.CopyFrom(stream, _Len);
end;

procedure TDataFrameStream.SaveToStream(stream: TMemoryStream64);
var
  _Len: Integer;
begin
  _Len := FBuffer.Size;
  stream.Write64(_Len, C_Integer_Size);
  if _Len > 0 then
    begin
      FBuffer.Position := 0;
      stream.CopyFrom(FBuffer, _Len);
    end;
end;

{$IFNDEF FPC}


procedure TDataFrameStream.LoadFromJson(jarry: TJsonArray; index_: Integer);
var
  b64: TPascalString;
begin
  FBuffer.Clear;
  b64.Text := jarry.s[index_];
  umlDecodeStreamBASE64(b64, FBuffer);
end;

procedure TDataFrameStream.SaveToJson(jarry: TJsonArray; index_: Integer);
var
  b64: TPascalString;
begin
  umlEncodeStreamBASE64(FBuffer, b64);
  jarry.Add(b64.Text);
end;
{$ENDIF}


function TDataFrameStream.ComputeEncodeSize: Int64;
begin
  Result := C_Integer_Size + FBuffer.Size;
end;

function TDataFrameStream.GetBuffer: TCoreClassStream;
begin
  Result := FBuffer;
end;

procedure TDataFrameStream.SetBuffer(_Buffer: TCoreClassStream);
var
  _P: Int64;
begin
  FBuffer.Clear;
  _P := _Buffer.Position;
  _Buffer.Position := 0;
  if _Buffer.Size > 0 then
      FBuffer.CopyFrom(_Buffer, _Buffer.Size);
  _Buffer.Position := _P;
end;

constructor TDataFrameVariant.Create(ID: Byte);
begin
  inherited Create(ID);
end;

destructor TDataFrameVariant.Destroy;
begin
  inherited Destroy;
end;

procedure TDataFrameVariant.LoadFromStream(stream: TMemoryStream64);
var
  vt: TVarType;
begin
  vt := TVarType(stream.ReadUInt16);
  case vt of
    varSmallInt: FBuffer := stream.ReadInt16;
    varInteger: FBuffer := stream.ReadInt32;
    varSingle: FBuffer := stream.ReadSingle;
    varDouble: FBuffer := stream.ReadDouble;
    varCurrency: FBuffer := stream.ReadCurrency;
    varBoolean: FBuffer := stream.ReadBool;
    varShortInt: FBuffer := stream.ReadInt8;
    varByte: FBuffer := stream.ReadUInt8;
    varWord: FBuffer := stream.ReadUInt16;
    varLongWord: FBuffer := stream.ReadUInt32;
    varInt64: FBuffer := stream.ReadInt64;
    varUInt64: FBuffer := stream.ReadUInt64;
    varOleStr, varString, varUString: FBuffer := stream.ReadString.Text;
    else RaiseInfo('error variant type');
  end;
end;

procedure TDataFrameVariant.SaveToStream(stream: TMemoryStream64);
var
  vt: TVarType;
begin
  vt := TVarData(FBuffer).VType;
  stream.WriteUInt16(Word(vt));
  case vt of
    varSmallInt: stream.WriteInt16(FBuffer);
    varInteger: stream.WriteInt32(FBuffer);
    varSingle: stream.WriteSingle(FBuffer);
    varDouble: stream.WriteDouble(FBuffer);
    varCurrency: stream.WriteCurrency(FBuffer);
    varBoolean: stream.WriteBool(FBuffer);
    varShortInt: stream.WriteInt8(FBuffer);
    varByte: stream.WriteUInt8(FBuffer);
    varWord: stream.WriteUInt16(FBuffer);
    varLongWord: stream.WriteUInt32(FBuffer);
    varInt64: stream.WriteInt64(FBuffer);
    varUInt64: stream.WriteUInt64(FBuffer);
    varOleStr, varString, varUString: stream.WriteString(FBuffer);
    else
      RaiseInfo('error variant type');
  end;
end;

{$IFNDEF FPC}


procedure TDataFrameVariant.LoadFromJson(jarry: TJsonArray; index_: Integer);
begin
  FBuffer := umlStrToVar(jarry.s[index_]);
end;

procedure TDataFrameVariant.SaveToJson(jarry: TJsonArray; index_: Integer);
begin
  jarry.Add(umlVarToStr(FBuffer, True).Text);
end;
{$ENDIF}


function TDataFrameVariant.ComputeEncodeSize: Int64;
var
  tmp: TMemoryStream64;
begin
  tmp := TMemoryStream64.CustomCreate(1024);
  SaveToStream(tmp);
  Result := tmp.Size;
  DisposeObject(tmp);
end;

constructor TDataFrameInt64.Create(ID: Byte);
begin
  inherited Create(ID);
  Buffer := 0;
end;

destructor TDataFrameInt64.Destroy;
begin
  inherited Destroy;
end;

procedure TDataFrameInt64.LoadFromStream(stream: TMemoryStream64);
begin
  stream.Read64(FBuffer, C_Int64_Size);
end;

procedure TDataFrameInt64.SaveToStream(stream: TMemoryStream64);
begin
  stream.Write64(FBuffer, C_Int64_Size);
end;

{$IFNDEF FPC}


procedure TDataFrameInt64.LoadFromJson(jarry: TJsonArray; index_: Integer);
begin
  FBuffer := jarry.L[index_];
end;

procedure TDataFrameInt64.SaveToJson(jarry: TJsonArray; index_: Integer);
begin
  jarry.Add(FBuffer);
end;
{$ENDIF}


function TDataFrameInt64.ComputeEncodeSize: Int64;
begin
  Result := C_Int64_Size;
end;

constructor TDataFrameUInt64.Create(ID: Byte);
begin
  inherited Create(ID);
  Buffer := 0;
end;

destructor TDataFrameUInt64.Destroy;
begin
  inherited Destroy;
end;

procedure TDataFrameUInt64.LoadFromStream(stream: TMemoryStream64);
begin
  stream.Read64(FBuffer, C_UInt64_Size);
end;

procedure TDataFrameUInt64.SaveToStream(stream: TMemoryStream64);
begin
  stream.Write64(FBuffer, C_UInt64_Size);
end;

{$IFNDEF FPC}


procedure TDataFrameUInt64.LoadFromJson(jarry: TJsonArray; index_: Integer);
begin
  FBuffer := jarry.u[index_];
end;

procedure TDataFrameUInt64.SaveToJson(jarry: TJsonArray; index_: Integer);
begin
  jarry.Add(FBuffer);
end;
{$ENDIF}


function TDataFrameUInt64.ComputeEncodeSize: Int64;
begin
  Result := C_UInt64_Size;
end;

constructor TDataFrameEngineReader.Create(AOwner: TDataFrameEngine);
begin
  inherited Create;
  FOwner := AOwner;
  FIndex := 0;
end;

destructor TDataFrameEngineReader.Destroy;
begin
  inherited Destroy;
end;

function TDataFrameEngineReader.IsEnd: Boolean;
begin
  Result := FIndex >= FOwner.Count;
end;

function TDataFrameEngineReader.NotEnd: Boolean;
begin
  Result := FIndex < FOwner.Count;
end;

procedure TDataFrameEngineReader.GoNext;
begin
  inc(FIndex);
end;

function TDataFrameEngineReader.ReadString: SystemString;
begin
  Result := FOwner.ReadString(FIndex);
  inc(FIndex);
end;

function TDataFrameEngineReader.ReadBytes: TBytes;
begin
  Result := FOwner.ReadBytes(FIndex);
  inc(FIndex);
end;

function TDataFrameEngineReader.ReadInteger: Integer;
begin
  Result := FOwner.ReadInteger(FIndex);
  inc(FIndex);
end;

function TDataFrameEngineReader.ReadCardinal: Cardinal;
begin
  Result := FOwner.ReadCardinal(FIndex);
  inc(FIndex);
end;

function TDataFrameEngineReader.ReadWord: Word;
begin
  Result := FOwner.ReadWord(FIndex);
  inc(FIndex);
end;

function TDataFrameEngineReader.ReadBool: Boolean;
begin
  Result := FOwner.ReadBool(FIndex);
  inc(FIndex);
end;

function TDataFrameEngineReader.ReadBoolean: Boolean;
begin
  Result := ReadBool;
end;

function TDataFrameEngineReader.ReadByte: Byte;
begin
  Result := FOwner.ReadByte(FIndex);
  inc(FIndex);
end;

function TDataFrameEngineReader.ReadSingle: Single;
begin
  Result := FOwner.ReadSingle(FIndex);
  inc(FIndex);
end;

function TDataFrameEngineReader.ReadDouble: Double;
begin
  Result := FOwner.ReadDouble(FIndex);
  inc(FIndex);
end;

function TDataFrameEngineReader.ReadArrayInteger: TDataFrameArrayInteger;
begin
  Result := FOwner.ReadArrayInteger(FIndex);
  inc(FIndex);
end;

function TDataFrameEngineReader.ReadArrayShortInt: TDataFrameArrayShortInt;
begin
  Result := FOwner.ReadArrayShortInt(FIndex);
  inc(FIndex);
end;

function TDataFrameEngineReader.ReadArrayByte: TDataFrameArrayByte;
begin
  Result := FOwner.ReadArrayByte(FIndex);
  inc(FIndex);
end;

function TDataFrameEngineReader.ReadMD5: TMD5;
begin
  Result := FOwner.ReadMD5(FIndex);
  inc(FIndex);
end;

function TDataFrameEngineReader.ReadArraySingle: TDataFrameArraySingle;
begin
  Result := FOwner.ReadArraySingle(FIndex);
  inc(FIndex);
end;

function TDataFrameEngineReader.ReadArrayDouble: TDataFrameArrayDouble;
begin
  Result := FOwner.ReadArrayDouble(FIndex);
  inc(FIndex);
end;

function TDataFrameEngineReader.ReadArrayInt64: TDataFrameArrayInt64;
begin
  Result := FOwner.ReadArrayInt64(FIndex);
  inc(FIndex);
end;

procedure TDataFrameEngineReader.ReadStream(output: TCoreClassStream);
begin
  FOwner.ReadStream(FIndex, output);
  inc(FIndex);
end;

function TDataFrameEngineReader.ReadVariant: Variant;
begin
  Result := FOwner.ReadVariant(FIndex);
  inc(FIndex);
end;

function TDataFrameEngineReader.ReadInt64: Int64;
begin
  Result := FOwner.ReadInt64(FIndex);
  inc(FIndex);
end;

function TDataFrameEngineReader.ReadUInt64: UInt64;
begin
  Result := FOwner.ReadUInt64(FIndex);
  inc(FIndex);
end;

procedure TDataFrameEngineReader.ReadStrings(output: TCoreClassStrings);
begin
  FOwner.ReadStrings(FIndex, output);
  inc(FIndex);
end;

procedure TDataFrameEngineReader.ReadListStrings(output: TListString);
begin
  FOwner.ReadListStrings(FIndex, output);
  inc(FIndex);
end;

procedure TDataFrameEngineReader.ReadPascalStrings(output: TListPascalString);
begin
  FOwner.ReadPascalStrings(FIndex, output);
  inc(FIndex);
end;

procedure TDataFrameEngineReader.ReadDataFrame(output: TDataFrameEngine);
begin
  FOwner.ReadDataFrame(FIndex, output);
  inc(FIndex);
end;

procedure TDataFrameEngineReader.ReadHashStringList(output: THashStringList);
begin
  FOwner.ReadHashStringList(FIndex, output);
  inc(FIndex);
end;

procedure TDataFrameEngineReader.ReadVariantList(output: THashVariantList);
begin
  FOwner.ReadVariantList(FIndex, output);
  inc(FIndex);
end;

procedure TDataFrameEngineReader.ReadSectionText(output: TSectionTextData);
begin
  FOwner.ReadSectionText(FIndex, output);
  inc(FIndex);
end;

procedure TDataFrameEngineReader.ReadTextSection(output: TSectionTextData);
begin
  ReadSectionText(output);
end;

{$IFNDEF FPC}


procedure TDataFrameEngineReader.ReadJson(output: TJsonObject);
begin
  FOwner.ReadJson(FIndex, output);
  inc(FIndex);
end;
{$ENDIF}


function TDataFrameEngineReader.ReadRect: TRect;
begin
  Result := FOwner.ReadRect(FIndex);
  inc(FIndex);
end;

function TDataFrameEngineReader.ReadRectf: TRectf;
begin
  Result := FOwner.ReadRectf(FIndex);
  inc(FIndex);
end;

function TDataFrameEngineReader.ReadPoint: TPoint;
begin
  Result := FOwner.ReadPoint(FIndex);
  inc(FIndex);
end;

function TDataFrameEngineReader.ReadPointf: TPointf;
begin
  Result := FOwner.ReadPointf(FIndex);
  inc(FIndex);
end;

function TDataFrameEngineReader.ReadVector: TVector;
begin
  Result := FOwner.ReadVector(FIndex);
  inc(FIndex);
end;

function TDataFrameEngineReader.ReadAffineVector: TAffineVector;
begin
  Result := FOwner.ReadAffineVector(FIndex);
  inc(FIndex);
end;

function TDataFrameEngineReader.ReadVec3: TVec3;
begin
  Result := FOwner.ReadVec3(FIndex);
  inc(FIndex);
end;

function TDataFrameEngineReader.ReadVec4: TVec4;
begin
  Result := FOwner.ReadVec4(FIndex);
  inc(FIndex);
end;

function TDataFrameEngineReader.ReadVector3: TVector3;
begin
  Result := FOwner.ReadVector3(FIndex);
  inc(FIndex);
end;

function TDataFrameEngineReader.ReadVector4: TVector4;
begin
  Result := FOwner.ReadVector4(FIndex);
  inc(FIndex);
end;

function TDataFrameEngineReader.ReadMat4: TMat4;
begin
  Result := FOwner.ReadMat4(FIndex);
  inc(FIndex);
end;

function TDataFrameEngineReader.ReadMatrix4: TMatrix4;
begin
  Result := FOwner.ReadMatrix4(FIndex);
  inc(FIndex);
end;

function TDataFrameEngineReader.Read2DPoint: T2DPoint;
begin
  Result := FOwner.Read2DPoint(FIndex);
  inc(FIndex);
end;

function TDataFrameEngineReader.ReadVec2: TVec2;
begin
  Result := FOwner.ReadVec2(FIndex);
  inc(FIndex);
end;

function TDataFrameEngineReader.ReadRectV2: TRectV2;
begin
  Result := FOwner.ReadRectV2(FIndex);
  inc(FIndex);
end;

function TDataFrameEngineReader.ReadPointer: UInt64;
begin
  Result := FOwner.ReadPointer(FIndex);
  inc(FIndex);
end;

procedure TDataFrameEngineReader.Read(var aBuf; aCount: Int64);
begin
  FOwner.Read(FIndex, aBuf, aCount);
  inc(FIndex);
end;

function TDataFrameEngineReader.Read: TDataFrameBase;
begin
  Result := FOwner.Read(FIndex);
  inc(FIndex);
end;

function TDataFrameEngine.DataTypeToByte(v: TRunTimeDataType): Byte;
begin
  Result := Byte(v);
end;

function TDataFrameEngine.ByteToDataType(v: Byte): TRunTimeDataType;
begin
  Result := TRunTimeDataType(v);
end;

constructor TDataFrameEngine.Create;
begin
  inherited Create;
  FDataList := TCoreClassListForObj.Create;
  FReader := TDataFrameEngineReader.Create(Self);
  FCompressorDeflate := nil;
  FCompressorBRRC := nil;
end;

destructor TDataFrameEngine.Destroy;
begin
  Clear;
  DisposeObject(FDataList);
  DisposeObject(FReader);
  if FCompressorDeflate <> nil then
      DisposeObject(FCompressorDeflate);
  if FCompressorBRRC <> nil then
      DisposeObject(FCompressorBRRC);
  inherited Destroy;
end;

procedure TDataFrameEngine.Clear;
var
  i: Integer;
  Obj: TDataFrameBase;
begin
  for i := 0 to FDataList.Count - 1 do
    begin
      Obj := TDataFrameBase(FDataList[i]);
      try
          DisposeObject(Obj);
      except
      end;
    end;

  try
      FDataList.Clear;
  except
  end;

  FReader.index := 0;
end;

function TDataFrameEngine.AddData(v: TRunTimeDataType): TDataFrameBase;
begin
  case v of
    rdtString: Result := TDataFrameString.Create(DataTypeToByte(v));
    rdtInteger: Result := TDataFrameInteger.Create(DataTypeToByte(v));
    rdtCardinal: Result := TDataFrameCardinal.Create(DataTypeToByte(v));
    rdtWORD: Result := TDataFrameWord.Create(DataTypeToByte(v));
    rdtByte: Result := TDataFrameByte.Create(DataTypeToByte(v));
    rdtSingle: Result := TDataFrameSingle.Create(DataTypeToByte(v));
    rdtDouble: Result := TDataFrameDouble.Create(DataTypeToByte(v));
    rdtArrayInteger: Result := TDataFrameArrayInteger.Create(DataTypeToByte(v));
    rdtArrayShortInt: Result := TDataFrameArrayShortInt.Create(DataTypeToByte(v));
    rdtArrayByte: Result := TDataFrameArrayByte.Create(DataTypeToByte(v));
    rdtArraySingle: Result := TDataFrameArraySingle.Create(DataTypeToByte(v));
    rdtArrayDouble: Result := TDataFrameArrayDouble.Create(DataTypeToByte(v));
    rdtArrayInt64: Result := TDataFrameArrayInt64.Create(DataTypeToByte(v));
    rdtStream: Result := TDataFrameStream.Create(DataTypeToByte(v));
    rdtVariant: Result := TDataFrameVariant.Create(DataTypeToByte(v));
    rdtInt64: Result := TDataFrameInt64.Create(DataTypeToByte(v));
    rdtUInt64: Result := TDataFrameUInt64.Create(DataTypeToByte(v));
    else
      Result := nil;
  end;
  if Result <> nil then
      FDataList.Add(Result);
end;

function TDataFrameEngine.GetData(index_: Integer): TDataFrameBase;
begin
  if (index_ >= 0) and (index_ < FDataList.Count) then
      Result := TDataFrameBase(FDataList[index_])
  else
      Result := nil;
end;

function TDataFrameEngine.GetDataInfo(Obj_: TDataFrameBase): SystemString;
begin
  case ByteToDataType(Obj_.FID) of
    rdtString:
      Result := 'SystemString';
    rdtInteger:
      Result := 'Integer';
    rdtCardinal:
      Result := 'Cardinal';
    rdtWORD:
      Result := 'WORD';
    rdtByte:
      Result := 'Byte';
    rdtSingle:
      Result := 'Single';
    rdtDouble:
      Result := 'Double';
    rdtArrayInteger:
      Result := 'ArrayInteger';
    rdtArrayShortInt:
      Result := 'ShortInt';
    rdtArrayByte:
      Result := 'Byte';
    rdtArraySingle:
      Result := 'ArraySingle';
    rdtArrayDouble:
      Result := 'ArrayDouble';
    rdtArrayInt64:
      Result := 'ArrayInt64';
    rdtStream:
      Result := 'Stream';
    rdtVariant:
      Result := 'Variant';
    rdtInt64:
      Result := 'Int64';
    rdtUInt64:
      Result := 'UInt64';
    else
      Result := '';
  end;
end;

function TDataFrameEngine.Count: Integer;
begin
  Result := FDataList.Count;
end;

function TDataFrameEngine.Delete(index_: Integer): Boolean;
begin
  try
    DisposeObject(TDataFrameBase(FDataList[index_]));
    FDataList.Delete(index_);
    Result := True;
  except
      Result := False;
  end;
end;

function TDataFrameEngine.DeleteFirst: Boolean;
begin
  Result := Delete(0);
end;

function TDataFrameEngine.DeleteLast: Boolean;
begin
  Result := Delete(Count - 1);
end;

function TDataFrameEngine.DeleteLastCount(cnt: Integer): Boolean;
begin
  Result := True;
  while cnt > 0 do
    begin
      Result := Result and DeleteLast;
      dec(cnt);
    end;
end;

function TDataFrameEngine.DeleteCount(index_, _Count: Integer): Boolean;
var
  i: Integer;
begin
  Result := True;
  for i := 0 to _Count - 1 do
      Result := Result and Delete(index_);
end;

procedure TDataFrameEngine.Assign(source: TDataFrameEngine);
var
  s: TMemoryStream64;
  i: Integer;
  DataFrame_: TDataFrameBase;
begin
  Clear;
  s := TMemoryStream64.CustomCreate(8192);
  for i := 0 to source.Count - 1 do
    begin
      DataFrame_ := AddData(ByteToDataType(source[i].FID));
      s.Clear;
      source[i].SaveToStream(s);
      s.Position := 0;
      DataFrame_.LoadFromStream(s);
      s.Clear;
    end;
  DisposeObject(s);
end;

function TDataFrameEngine.Clone: TDataFrameEngine;
begin
  Result := TDataFrameEngine.Create;
  Result.Assign(Self);
end;

procedure TDataFrameEngine.WriteString(v: SystemString);
var
  Obj_: TDataFrameString;
begin
  Obj_ := TDataFrameString.Create(DataTypeToByte(rdtString));
  Obj_.Buffer := umlBytesOf(v);
  FDataList.Add(Obj_);
end;

procedure TDataFrameEngine.WriteString(v: TPascalString);
var
  Obj_: TDataFrameString;
begin
  Obj_ := TDataFrameString.Create(DataTypeToByte(rdtString));
  Obj_.Buffer := v.Bytes;
  FDataList.Add(Obj_);
end;

procedure TDataFrameEngine.WriteBytes(v: TBytes);
var
  Obj_: TDataFrameString;
begin
  Obj_ := TDataFrameString.Create(DataTypeToByte(rdtString));
  SetLength(Obj_.Buffer, length(v));
  if length(v) > 0 then
      CopyPtr(@v[0], @Obj_.Buffer[0], length(v));
  FDataList.Add(Obj_);
end;

procedure TDataFrameEngine.WriteInteger(v: Integer);
var
  Obj_: TDataFrameInteger;
begin
  Obj_ := TDataFrameInteger.Create(DataTypeToByte(rdtInteger));
  Obj_.Buffer := v;
  FDataList.Add(Obj_);
end;

procedure TDataFrameEngine.WriteCardinal(v: Cardinal);
var
  Obj_: TDataFrameCardinal;
begin
  Obj_ := TDataFrameCardinal.Create(DataTypeToByte(rdtCardinal));
  Obj_.Buffer := v;
  FDataList.Add(Obj_);
end;

procedure TDataFrameEngine.WriteWORD(v: Word);
var
  Obj_: TDataFrameWord;
begin
  Obj_ := TDataFrameWord.Create(DataTypeToByte(rdtWORD));
  Obj_.Buffer := v;
  FDataList.Add(Obj_);
end;

procedure TDataFrameEngine.WriteBool(v: Boolean);
begin
  if v then
      WriteByte(1)
  else
      WriteByte(0);
end;

procedure TDataFrameEngine.WriteBoolean(v: Boolean);
begin
  WriteBool(v);
end;

procedure TDataFrameEngine.WriteByte(v: Byte);
var
  Obj_: TDataFrameByte;
begin
  Obj_ := TDataFrameByte.Create(DataTypeToByte(rdtByte));
  Obj_.Buffer := v;
  FDataList.Add(Obj_);
end;

procedure TDataFrameEngine.WriteSingle(v: Single);
var
  Obj_: TDataFrameSingle;
begin
  Obj_ := TDataFrameSingle.Create(DataTypeToByte(rdtSingle));
  Obj_.Buffer := v;
  FDataList.Add(Obj_);
end;

procedure TDataFrameEngine.WriteDouble(v: Double);
var
  Obj_: TDataFrameDouble;
begin
  Obj_ := TDataFrameDouble.Create(DataTypeToByte(rdtDouble));
  Obj_.Buffer := v;
  FDataList.Add(Obj_);
end;

function TDataFrameEngine.WriteArrayInteger: TDataFrameArrayInteger;
begin
  Result := TDataFrameArrayInteger.Create(DataTypeToByte(rdtArrayInteger));
  FDataList.Add(Result);
end;

function TDataFrameEngine.WriteArrayShortInt: TDataFrameArrayShortInt;
begin
  Result := TDataFrameArrayShortInt.Create(DataTypeToByte(rdtArrayShortInt));
  FDataList.Add(Result);
end;

function TDataFrameEngine.WriteArrayByte: TDataFrameArrayByte;
begin
  Result := TDataFrameArrayByte.Create(DataTypeToByte(rdtArrayByte));
  FDataList.Add(Result);
end;

procedure TDataFrameEngine.WriteMD5(md5: TMD5);
begin
  WriteArrayByte.WriteArray(md5);
end;

function TDataFrameEngine.WriteArraySingle: TDataFrameArraySingle;
begin
  Result := TDataFrameArraySingle.Create(DataTypeToByte(rdtArraySingle));
  FDataList.Add(Result);
end;

function TDataFrameEngine.WriteArrayDouble: TDataFrameArrayDouble;
begin
  Result := TDataFrameArrayDouble.Create(DataTypeToByte(rdtArrayDouble));
  FDataList.Add(Result);
end;

function TDataFrameEngine.WriteArrayInt64: TDataFrameArrayInt64;
begin
  Result := TDataFrameArrayInt64.Create(DataTypeToByte(rdtArrayInt64));
  FDataList.Add(Result);
end;

procedure TDataFrameEngine.WriteStream(v: TCoreClassStream);
var
  Obj_: TDataFrameStream;
begin
  Obj_ := TDataFrameStream.Create(DataTypeToByte(rdtStream));
  Obj_.Buffer := v;
  FDataList.Add(Obj_);
end;

procedure TDataFrameEngine.WriteVariant(v: Variant);
var
  Obj_: TDataFrameVariant;
begin
  Obj_ := TDataFrameVariant.Create(DataTypeToByte(rdtVariant));
  Obj_.Buffer := v;
  FDataList.Add(Obj_);
end;

procedure TDataFrameEngine.WriteInt64(v: Int64);
var
  Obj_: TDataFrameInt64;
begin
  Obj_ := TDataFrameInt64.Create(DataTypeToByte(rdtInt64));
  Obj_.Buffer := v;
  FDataList.Add(Obj_);
end;

procedure TDataFrameEngine.WriteUInt64(v: UInt64);
var
  Obj_: TDataFrameUInt64;
begin
  Obj_ := TDataFrameUInt64.Create(DataTypeToByte(rdtUInt64));
  Obj_.Buffer := v;
  FDataList.Add(Obj_);
end;

procedure TDataFrameEngine.WriteStrings(v: TCoreClassStrings);
var
  d: TMemoryStream64;
begin
  d := TMemoryStream64.Create;
{$IFDEF FPC}
  v.SaveToStream(d);
{$ELSE}
  v.SaveToStream(d, TEncoding.UTF8);
{$ENDIF}
  d.Position := 0;
  WriteStream(d);
  DisposeObject(d);
end;

procedure TDataFrameEngine.WriteListStrings(v: TListString);
var
  d: TMemoryStream64;
begin
  d := TMemoryStream64.Create;
  v.SaveToStream(d);
  d.Position := 0;
  WriteStream(d);
  DisposeObject(d);
end;

procedure TDataFrameEngine.WritePascalStrings(v: TListPascalString);
var
  d: TMemoryStream64;
begin
  d := TMemoryStream64.Create;
  v.SaveToStream(d);
  d.Position := 0;
  WriteStream(d);
  DisposeObject(d);
end;

procedure TDataFrameEngine.WriteDataFrame(v: TDataFrameEngine);
var
  Obj_: TDataFrameStream;
begin
  Obj_ := TDataFrameStream.Create(DataTypeToByte(rdtStream));
  v.EncodeTo(Obj_.Buffer, True);
  FDataList.Add(Obj_);
end;

procedure TDataFrameEngine.WriteDataFrameCompressed(v: TDataFrameEngine);
var
  Obj_: TDataFrameStream;
begin
  Obj_ := TDataFrameStream.Create(DataTypeToByte(rdtStream));
  v.EncodeAsZLib(Obj_.Buffer, True);
  FDataList.Add(Obj_);
end;

procedure TDataFrameEngine.WriteHashStringList(v: THashStringList);
var
  ms: TMemoryStream64;
  h: THashStringTextStream;
begin
  ms := TMemoryStream64.Create;
  h := THashStringTextStream.Create(v);
  h.SaveToStream(ms);
  DisposeObject(h);
  ms.Position := 0;
  WriteStream(ms);
  DisposeObject(ms);
end;

procedure TDataFrameEngine.WriteVariantList(v: THashVariantList);
var
  ms: TMemoryStream64;
  h: THashVariantTextStream;
begin
  ms := TMemoryStream64.Create;
  h := THashVariantTextStream.Create(v);
  h.SaveToStream(ms);
  DisposeObject(h);
  ms.Position := 0;
  WriteStream(ms);
  DisposeObject(ms);
end;

procedure TDataFrameEngine.WriteSectionText(v: TSectionTextData);
var
  ms: TMemoryStream64;
begin
  ms := TMemoryStream64.Create;
  v.SaveToStream(ms);
  ms.Position := 0;
  WriteStream(ms);
  DisposeObject(ms);
end;

procedure TDataFrameEngine.WriteTextSection(v: TSectionTextData);
begin
  WriteSectionText(v);
end;

{$IFNDEF FPC}


procedure TDataFrameEngine.WriteJson(v: TJsonObject);
var
  ms: TMemoryStream64;
begin
  ms := TMemoryStream64.Create;
  v.SaveToStream(ms, False, TEncoding.UTF8, True);
  ms.Position := 0;
  WriteStream(ms);
  DisposeObject(ms);
end;
{$ENDIF}


procedure TDataFrameEngine.WriteFile(fn: SystemString);
var
  fs: TCoreClassFileStream;
begin
  if umlFileExists(fn) then
    begin
      fs := TCoreClassFileStream.Create(fn, fmOpenRead or fmShareDenyNone);
      fs.Position := 0;
      WriteStream(fs);
      DisposeObject(fs);
    end;
end;

procedure TDataFrameEngine.WriteRect(v: TRect);
begin
  with WriteArrayInteger do
    begin
      Add(v.Left);
      Add(v.Top);
      Add(v.Right);
      Add(v.Bottom);
    end;
end;

procedure TDataFrameEngine.WriteRectf(v: TRectf);
begin
  with WriteArraySingle do
    begin
      Add(v.Left);
      Add(v.Top);
      Add(v.Right);
      Add(v.Bottom);
    end;
end;

procedure TDataFrameEngine.WritePoint(v: TPoint);
begin
  with WriteArrayInteger do
    begin
      Add(v.x);
      Add(v.y);
    end;
end;

procedure TDataFrameEngine.WritePointf(v: TPointf);
begin
  with WriteArraySingle do
    begin
      Add(v.x);
      Add(v.y);
    end;
end;

procedure TDataFrameEngine.WriteVector(v: TVector);
begin
  WriteArraySingle.WriteArray(v);
end;

procedure TDataFrameEngine.WriteAffineVector(v: TAffineVector);
begin
  WriteArraySingle.WriteArray(v);
end;

procedure TDataFrameEngine.WriteVec4(v: TVec4);
begin
  WriteArraySingle.WriteArray(v);
end;

procedure TDataFrameEngine.WriteVec3(v: TVec3);
begin
  WriteArraySingle.WriteArray(v);
end;

procedure TDataFrameEngine.WriteVector4(v: TVector4);
begin
  WriteArraySingle.WriteArray(v.buff);
end;

procedure TDataFrameEngine.WriteVector3(v: TVector3);
begin
  WriteArraySingle.WriteArray(v.buff);
end;

procedure TDataFrameEngine.WriteMat4(v: TMat4);
begin
  with WriteArraySingle do
    begin
      WriteArray(v[0]);
      WriteArray(v[1]);
      WriteArray(v[2]);
      WriteArray(v[3]);
    end;
end;

procedure TDataFrameEngine.WriteMatrix4(v: TMatrix4);
begin
  WriteMat4(v.buff);
end;

procedure TDataFrameEngine.Write2DPoint(v: T2DPoint);
begin
  with WriteArraySingle do
      WriteArray(v);
end;

procedure TDataFrameEngine.WriteVec2(v: TVec2);
begin
  Write2DPoint(v);
end;

procedure TDataFrameEngine.WriteRectV2(v: TRectV2);
begin
  with WriteArraySingle do
    begin
      WriteArray(v[0]);
      WriteArray(v[1]);
    end;
end;

procedure TDataFrameEngine.WritePointer(v: Pointer);
begin
  WriteUInt64(UInt64(v));
end;

procedure TDataFrameEngine.WritePointer(v: UInt64);
begin
  WriteUInt64(v);
end;

// append new stream and write
procedure TDataFrameEngine.write(const aBuf; aCount: Int64);
var
  s: TMemoryStream64;
begin
  s := TMemoryStream64.Create;
  s.Write64(aBuf, aCount);
  WriteStream(s);
  DisposeObject(s);
end;

function TDataFrameEngine.ReadString(index_: Integer): SystemString;
var
  Obj_: TDataFrameBase;
  i: Integer;
begin
  Obj_ := Data[index_];
  if Obj_ is TDataFrameString then
      Result := umlStringOf(TDataFrameString(Obj_).Buffer).Text
  else if Obj_ is TDataFrameInteger then
      Result := IntToStr(TDataFrameInteger(Obj_).Buffer)
  else if Obj_ is TDataFrameCardinal then
      Result := IntToStr(TDataFrameCardinal(Obj_).Buffer)
  else if Obj_ is TDataFrameWord then
      Result := IntToStr(TDataFrameWord(Obj_).Buffer)
  else if Obj_ is TDataFrameByte then
      Result := IntToStr(TDataFrameByte(Obj_).Buffer)
  else if Obj_ is TDataFrameSingle then
      Result := FloatToStr(TDataFrameSingle(Obj_).Buffer)
  else if Obj_ is TDataFrameDouble then
      Result := FloatToStr(TDataFrameDouble(Obj_).Buffer)
  else if Obj_ is TDataFrameArrayInteger then
    begin
      Result := '(';
      with TDataFrameArrayInteger(Obj_) do
        begin
          for i := 0 to Count - 1 do
            if Result <> '(' then
                Result := Result + ',' + IntToStr(Buffer[i])
            else
                Result := Result + IntToStr(Buffer[i]);
        end;
      Result := Result + ')';
    end
  else if Obj_ is TDataFrameArrayShortInt then
    begin
      Result := '(';
      with TDataFrameArrayShortInt(Obj_) do
        begin
          for i := 0 to Count - 1 do
            if Result <> '(' then
                Result := Result + ',' + IntToStr(Buffer[i])
            else
                Result := Result + IntToStr(Buffer[i]);
        end;
      Result := Result + ')';
    end
  else if Obj_ is TDataFrameArrayByte then
    begin
      Result := '(';
      with TDataFrameArrayByte(Obj_) do
        begin
          for i := 0 to Count - 1 do
            if Result <> '(' then
                Result := Result + ',' + IntToStr(Buffer[i])
            else
                Result := Result + IntToStr(Buffer[i]);
        end;
      Result := Result + ')';
    end
  else if Obj_ is TDataFrameArraySingle then
    begin
      Result := '(';
      with TDataFrameArraySingle(Obj_) do
        begin
          for i := 0 to Count - 1 do
            if Result <> '(' then
                Result := Result + ',' + FloatToStr(Buffer[i])
            else
                Result := Result + FloatToStr(Buffer[i]);
        end;
      Result := Result + ')';
    end
  else if Obj_ is TDataFrameArrayDouble then
    begin
      Result := '(';
      with TDataFrameArrayDouble(Obj_) do
        begin
          for i := 0 to Count - 1 do
            if Result <> '(' then
                Result := Result + ',' + FloatToStr(Buffer[i])
            else
                Result := Result + FloatToStr(Buffer[i]);
        end;
      Result := Result + ')';
    end
  else if Obj_ is TDataFrameArrayInt64 then
    begin
      Result := '(';
      with TDataFrameArrayInt64(Obj_) do
        begin
          for i := 0 to Count - 1 do
            if Result <> '(' then
                Result := Result + ',' + IntToStr(Buffer[i])
            else
                Result := Result + IntToStr(Buffer[i]);
        end;
      Result := Result + ')';
    end
  else if Obj_ is TDataFrameVariant then
      Result := umlVarToStr(TDataFrameVariant(Obj_).Buffer)
  else if Obj_ is TDataFrameInt64 then
      Result := IntToStr(TDataFrameInt64(Obj_).Buffer)
  else if Obj_ is TDataFrameUInt64 then
{$IFDEF FPC}
    Result := IntToStr(TDataFrameUInt64(Obj_).Buffer)
{$ELSE}
    Result := UIntToStr(TDataFrameUInt64(Obj_).Buffer)
{$ENDIF}
  else
      Result := '';
end;

function TDataFrameEngine.ReadBytes(index_: Integer): TBytes;
var
  Obj_: TDataFrameBase;
  i: Integer;
begin
  Obj_ := Data[index_];
  if Obj_ is TDataFrameString then
    begin
      SetLength(Result, length(TDataFrameString(Obj_).Buffer));
      if length(Result) > 0 then
          CopyPtr(@TDataFrameString(Obj_).Buffer[0], @Result[0], length(Result));
    end
  else if Obj_ is TDataFrameArrayByte then
    begin
      SetLength(Result, TDataFrameArrayByte(Obj_).Count);
      for i := 0 to TDataFrameArrayByte(Obj_).Count - 1 do
          Result[i] := TDataFrameArrayByte(Obj_).Buffer[i];
    end
  else
      SetLength(Result, 0);
end;

function TDataFrameEngine.ReadInteger(index_: Integer): Integer;
var
  Obj_: TDataFrameBase;
begin
  Obj_ := Data[index_];
  if Obj_ is TDataFrameInteger then
      Result := TDataFrameInteger(Obj_).Buffer
  else if Obj_ is TDataFrameString then
      Result := umlStrToInt(umlStringOf(TDataFrameString(Obj_).Buffer), 0)
  else if Obj_ is TDataFrameCardinal then
      Result := TDataFrameCardinal(Obj_).Buffer
  else if Obj_ is TDataFrameWord then
      Result := TDataFrameWord(Obj_).Buffer
  else if Obj_ is TDataFrameByte then
      Result := TDataFrameByte(Obj_).Buffer
  else if Obj_ is TDataFrameSingle then
      Result := Trunc(TDataFrameSingle(Obj_).Buffer)
  else if Obj_ is TDataFrameDouble then
      Result := Trunc(TDataFrameDouble(Obj_).Buffer)
  else if Obj_ is TDataFrameVariant then
      Result := (TDataFrameVariant(Obj_).Buffer)
  else if Obj_ is TDataFrameInt64 then
      Result := (TDataFrameInt64(Obj_).Buffer)
  else if Obj_ is TDataFrameUInt64 then
      Result := (TDataFrameUInt64(Obj_).Buffer)
  else
      Result := 0;
end;

function TDataFrameEngine.ReadCardinal(index_: Integer): Cardinal;
var
  Obj_: TDataFrameBase;
begin
  Obj_ := Data[index_];
  if Obj_ is TDataFrameCardinal then
      Result := TDataFrameCardinal(Obj_).Buffer
  else if Obj_ is TDataFrameString then
      Result := umlStrToInt(umlStringOf(TDataFrameString(Obj_).Buffer), 0)
  else if Obj_ is TDataFrameInteger then
      Result := TDataFrameInteger(Obj_).Buffer
  else if Obj_ is TDataFrameWord then
      Result := TDataFrameWord(Obj_).Buffer
  else if Obj_ is TDataFrameByte then
      Result := TDataFrameByte(Obj_).Buffer
  else if Obj_ is TDataFrameSingle then
      Result := Trunc(TDataFrameSingle(Obj_).Buffer)
  else if Obj_ is TDataFrameDouble then
      Result := Trunc(TDataFrameDouble(Obj_).Buffer)
  else if Obj_ is TDataFrameVariant then
      Result := (TDataFrameVariant(Obj_).Buffer)
  else if Obj_ is TDataFrameInt64 then
      Result := (TDataFrameInt64(Obj_).Buffer)
  else if Obj_ is TDataFrameUInt64 then
      Result := (TDataFrameUInt64(Obj_).Buffer)
  else
      Result := 0;
end;

function TDataFrameEngine.ReadWord(index_: Integer): Word;
var
  Obj_: TDataFrameBase;
begin
  Obj_ := Data[index_];
  if Obj_ is TDataFrameWord then
      Result := TDataFrameWord(Obj_).Buffer
  else if Obj_ is TDataFrameString then
      Result := umlStrToInt(umlStringOf(TDataFrameString(Obj_).Buffer), 0)
  else if Obj_ is TDataFrameInteger then
      Result := TDataFrameInteger(Obj_).Buffer
  else if Obj_ is TDataFrameCardinal then
      Result := TDataFrameCardinal(Obj_).Buffer
  else if Obj_ is TDataFrameByte then
      Result := TDataFrameByte(Obj_).Buffer
  else if Obj_ is TDataFrameSingle then
      Result := Trunc(TDataFrameSingle(Obj_).Buffer)
  else if Obj_ is TDataFrameDouble then
      Result := Trunc(TDataFrameDouble(Obj_).Buffer)
  else if Obj_ is TDataFrameVariant then
      Result := (TDataFrameVariant(Obj_).Buffer)
  else if Obj_ is TDataFrameInt64 then
      Result := (TDataFrameInt64(Obj_).Buffer)
  else if Obj_ is TDataFrameUInt64 then
      Result := (TDataFrameUInt64(Obj_).Buffer)
  else
      Result := 0;
end;

function TDataFrameEngine.ReadBool(index_: Integer): Boolean;
begin
  Result := ReadByte(index_) = 1;
end;

function TDataFrameEngine.ReadBoolean(index_: Integer): Boolean;
begin
  Result := ReadBool(index_);
end;

function TDataFrameEngine.ReadByte(index_: Integer): Byte;
var
  Obj_: TDataFrameBase;
begin
  Obj_ := Data[index_];
  if Obj_ is TDataFrameByte then
      Result := TDataFrameByte(Obj_).Buffer
  else if Obj_ is TDataFrameString then
      Result := umlStrToInt(umlStringOf(TDataFrameString(Obj_).Buffer), 0)
  else if Obj_ is TDataFrameInteger then
      Result := TDataFrameInteger(Obj_).Buffer
  else if Obj_ is TDataFrameCardinal then
      Result := TDataFrameCardinal(Obj_).Buffer
  else if Obj_ is TDataFrameWord then
      Result := TDataFrameWord(Obj_).Buffer
  else if Obj_ is TDataFrameSingle then
      Result := Trunc(TDataFrameSingle(Obj_).Buffer)
  else if Obj_ is TDataFrameDouble then
      Result := Trunc(TDataFrameDouble(Obj_).Buffer)
  else if Obj_ is TDataFrameVariant then
      Result := (TDataFrameVariant(Obj_).Buffer)
  else if Obj_ is TDataFrameInt64 then
      Result := (TDataFrameInt64(Obj_).Buffer)
  else if Obj_ is TDataFrameUInt64 then
      Result := (TDataFrameUInt64(Obj_).Buffer)
  else
      Result := 0;
end;

function TDataFrameEngine.ReadSingle(index_: Integer): Single;
var
  Obj_: TDataFrameBase;
begin
  Obj_ := Data[index_];
  if Obj_ is TDataFrameSingle then
      Result := TDataFrameSingle(Obj_).Buffer
  else if Obj_ is TDataFrameString then
      Result := umlStrToFloat(umlStringOf(TDataFrameString(Obj_).Buffer), 0)
  else if Obj_ is TDataFrameInteger then
      Result := TDataFrameInteger(Obj_).Buffer
  else if Obj_ is TDataFrameCardinal then
      Result := TDataFrameCardinal(Obj_).Buffer
  else if Obj_ is TDataFrameWord then
      Result := TDataFrameWord(Obj_).Buffer
  else if Obj_ is TDataFrameByte then
      Result := TDataFrameByte(Obj_).Buffer
  else if Obj_ is TDataFrameDouble then
      Result := TDataFrameDouble(Obj_).Buffer
  else if Obj_ is TDataFrameVariant then
      Result := (TDataFrameVariant(Obj_).Buffer)
  else if Obj_ is TDataFrameInt64 then
      Result := (TDataFrameInt64(Obj_).Buffer)
  else if Obj_ is TDataFrameUInt64 then
      Result := (TDataFrameUInt64(Obj_).Buffer)
  else
      Result := 0;
end;

function TDataFrameEngine.ReadDouble(index_: Integer): Double;
var
  Obj_: TDataFrameBase;
begin
  Obj_ := Data[index_];
  if Obj_ is TDataFrameDouble then
      Result := TDataFrameDouble(Obj_).Buffer
  else if Obj_ is TDataFrameString then
      Result := umlStrToFloat(umlStringOf(TDataFrameString(Obj_).Buffer), 0)
  else if Obj_ is TDataFrameInteger then
      Result := TDataFrameInteger(Obj_).Buffer
  else if Obj_ is TDataFrameCardinal then
      Result := TDataFrameCardinal(Obj_).Buffer
  else if Obj_ is TDataFrameWord then
      Result := TDataFrameWord(Obj_).Buffer
  else if Obj_ is TDataFrameByte then
      Result := TDataFrameByte(Obj_).Buffer
  else if Obj_ is TDataFrameSingle then
      Result := TDataFrameSingle(Obj_).Buffer
  else if Obj_ is TDataFrameVariant then
      Result := (TDataFrameVariant(Obj_).Buffer)
  else if Obj_ is TDataFrameInt64 then
      Result := (TDataFrameInt64(Obj_).Buffer)
  else if Obj_ is TDataFrameUInt64 then
      Result := (TDataFrameUInt64(Obj_).Buffer)
  else
      Result := 0;
end;

function TDataFrameEngine.ReadArrayInteger(index_: Integer): TDataFrameArrayInteger;
var
  Obj_: TDataFrameBase;
begin
  Obj_ := Data[index_];
  if Obj_ is TDataFrameArrayInteger then
      Result := TDataFrameArrayInteger(Obj_)
  else
      Result := nil;
end;

function TDataFrameEngine.ReadArrayShortInt(index_: Integer): TDataFrameArrayShortInt;
var
  Obj_: TDataFrameBase;
begin
  Obj_ := Data[index_];
  if Obj_ is TDataFrameArrayShortInt then
      Result := TDataFrameArrayShortInt(Obj_)
  else
      Result := nil;
end;

function TDataFrameEngine.ReadArrayByte(index_: Integer): TDataFrameArrayByte;
var
  Obj_: TDataFrameBase;
begin
  Obj_ := Data[index_];
  if Obj_ is TDataFrameArrayByte then
      Result := TDataFrameArrayByte(Obj_)
  else
      Result := nil;
end;

function TDataFrameEngine.ReadMD5(index_: Integer): TMD5;
var
  i: Integer;
begin
  with ReadArrayByte(index_) do
    for i := low(TMD5) to high(TMD5) do
        Result[i] := Buffer[i];
end;

function TDataFrameEngine.ReadArraySingle(index_: Integer): TDataFrameArraySingle;
var
  Obj_: TDataFrameBase;
begin
  Obj_ := Data[index_];
  if Obj_ is TDataFrameArraySingle then
      Result := TDataFrameArraySingle(Obj_)
  else
      Result := nil;
end;

function TDataFrameEngine.ReadArrayDouble(index_: Integer): TDataFrameArrayDouble;
var
  Obj_: TDataFrameBase;
begin
  Obj_ := Data[index_];
  if Obj_ is TDataFrameArrayDouble then
      Result := TDataFrameArrayDouble(Obj_)
  else
      Result := nil;
end;

function TDataFrameEngine.ReadArrayInt64(index_: Integer): TDataFrameArrayInt64;
var
  Obj_: TDataFrameBase;
begin
  Obj_ := Data[index_];
  if Obj_ is TDataFrameArrayInt64 then
      Result := TDataFrameArrayInt64(Obj_)
  else
      Result := nil;
end;

procedure TDataFrameEngine.ReadStream(index_: Integer; output: TCoreClassStream);
var
  Obj_: TDataFrameBase;
  LNeedResetPos: Boolean;
begin
  Obj_ := Data[index_];
  LNeedResetPos := output.Size = 0;
  if Obj_ is TDataFrameStream then
    begin
      with TDataFrameStream(Obj_) do
        begin
          Buffer.Position := 0;
          output.CopyFrom(Buffer, Buffer.Size);
          Buffer.Position := 0;
        end;
    end
  else if output is TMemoryStream64 then
      Obj_.SaveToStream(TMemoryStream64(output))
  else
      RaiseInfo('no support');
  if LNeedResetPos then
      output.Position := 0;
end;

function TDataFrameEngine.ReadVariant(index_: Integer): Variant;
var
  Obj_: TDataFrameBase;
begin
  Obj_ := Data[index_];
  if Obj_ is TDataFrameVariant then
      Result := TDataFrameVariant(Obj_).Buffer
  else if Obj_ is TDataFrameString then
      Result := TDataFrameString(Obj_).Buffer
  else if Obj_ is TDataFrameInteger then
      Result := TDataFrameInteger(Obj_).Buffer
  else if Obj_ is TDataFrameCardinal then
      Result := TDataFrameCardinal(Obj_).Buffer
  else if Obj_ is TDataFrameWord then
      Result := TDataFrameWord(Obj_).Buffer
  else if Obj_ is TDataFrameByte then
      Result := TDataFrameByte(Obj_).Buffer
  else if Obj_ is TDataFrameSingle then
      Result := TDataFrameSingle(Obj_).Buffer
  else if Obj_ is TDataFrameDouble then
      Result := TDataFrameDouble(Obj_).Buffer
  else if Obj_ is TDataFrameInt64 then
      Result := (TDataFrameInt64(Obj_).Buffer)
  else
      Result := 0;
end;

function TDataFrameEngine.ReadInt64(index_: Integer): Int64;
var
  Obj_: TDataFrameBase;
begin
  Obj_ := Data[index_];
  if Obj_ is TDataFrameInt64 then
      Result := TDataFrameInt64(Obj_).Buffer
  else if Obj_ is TDataFrameUInt64 then
      Result := TDataFrameUInt64(Obj_).Buffer
  else if Obj_ is TDataFrameInteger then
      Result := TDataFrameInteger(Obj_).Buffer
  else if Obj_ is TDataFrameCardinal then
      Result := TDataFrameCardinal(Obj_).Buffer
  else if Obj_ is TDataFrameWord then
      Result := TDataFrameWord(Obj_).Buffer
  else if Obj_ is TDataFrameByte then
      Result := TDataFrameByte(Obj_).Buffer
  else if Obj_ is TDataFrameSingle then
      Result := Trunc(TDataFrameSingle(Obj_).Buffer)
  else if Obj_ is TDataFrameDouble then
      Result := Trunc(TDataFrameDouble(Obj_).Buffer)
  else if Obj_ is TDataFrameVariant then
      Result := TDataFrameVariant(Obj_).Buffer
  else
      Result := 0;
end;

function TDataFrameEngine.ReadUInt64(index_: Integer): UInt64;
var
  Obj_: TDataFrameBase;
begin
  Obj_ := Data[index_];
  if Obj_ is TDataFrameUInt64 then
      Result := TDataFrameUInt64(Obj_).Buffer
  else if Obj_ is TDataFrameInt64 then
      Result := TDataFrameInt64(Obj_).Buffer
  else if Obj_ is TDataFrameInteger then
      Result := TDataFrameInteger(Obj_).Buffer
  else if Obj_ is TDataFrameCardinal then
      Result := TDataFrameCardinal(Obj_).Buffer
  else if Obj_ is TDataFrameWord then
      Result := TDataFrameWord(Obj_).Buffer
  else if Obj_ is TDataFrameByte then
      Result := TDataFrameByte(Obj_).Buffer
  else if Obj_ is TDataFrameSingle then
      Result := Trunc(TDataFrameSingle(Obj_).Buffer)
  else if Obj_ is TDataFrameDouble then
      Result := Trunc(TDataFrameDouble(Obj_).Buffer)
  else if Obj_ is TDataFrameVariant then
      Result := TDataFrameVariant(Obj_).Buffer
  else
      Result := 0;
end;

procedure TDataFrameEngine.ReadStrings(index_: Integer; output: TCoreClassStrings);
var
  d: TMemoryStream64;
begin
  d := TMemoryStream64.Create;
  ReadStream(index_, d);
  d.Position := 0;

{$IFDEF FPC}
  output.LoadFromStream(d);
{$ELSE}
  output.LoadFromStream(d, TEncoding.UTF8);
{$ENDIF}
  DisposeObject(d);
end;

procedure TDataFrameEngine.ReadListStrings(index_: Integer; output: TListString);
var
  d: TMemoryStream64;
begin
  d := TMemoryStream64.Create;
  ReadStream(index_, d);
  d.Position := 0;

  output.LoadFromStream(d);
  DisposeObject(d);
end;

procedure TDataFrameEngine.ReadPascalStrings(index_: Integer; output: TListPascalString);
var
  d: TMemoryStream64;
begin
  d := TMemoryStream64.Create;
  ReadStream(index_, d);
  d.Position := 0;

  output.LoadFromStream(d);
  DisposeObject(d);
end;

procedure TDataFrameEngine.ReadDataFrame(index_: Integer; output: TDataFrameEngine);
var
  Obj_: TDataFrameBase;
  d: TMemoryStream64;
begin
  Obj_ := Data[index_];
  if Obj_ is TDataFrameStream then
    begin
      TDataFrameStream(Obj_).Buffer.Position := 0;
      output.DecodeFrom(TDataFrameStream(Obj_).Buffer, True);
      TDataFrameStream(Obj_).Buffer.Position := 0;
    end
  else
    begin
      d := TMemoryStream64.Create;
      ReadStream(index_, d);
      d.Position := 0;
      output.DecodeFrom(d, True);
      DisposeObject(d);
    end;
end;

procedure TDataFrameEngine.ReadHashStringList(index_: Integer; output: THashStringList);
var
  d: TMemoryStream64;
  h: THashStringTextStream;
begin
  d := TMemoryStream64.Create;
  ReadStream(index_, d);
  d.Position := 0;
  h := THashStringTextStream.Create(output);
  h.LoadFromStream(d);
  DisposeObject(h);
  DisposeObject(d);
end;

procedure TDataFrameEngine.ReadVariantList(index_: Integer; output: THashVariantList);
var
  d: TMemoryStream64;
  h: THashVariantTextStream;
begin
  d := TMemoryStream64.Create;
  ReadStream(index_, d);
  d.Position := 0;
  h := THashVariantTextStream.Create(output);
  h.LoadFromStream(d);
  DisposeObject(h);
  DisposeObject(d);
end;

procedure TDataFrameEngine.ReadSectionText(index_: Integer; output: TSectionTextData);
var
  d: TMemoryStream64;
begin
  d := TMemoryStream64.Create;
  ReadStream(index_, d);
  d.Position := 0;
  output.LoadFromStream(d);
  DisposeObject(d);
end;

procedure TDataFrameEngine.ReadTextSection(index_: Integer; output: TSectionTextData);
begin
  ReadSectionText(index_, output);
end;

{$IFNDEF FPC}


procedure TDataFrameEngine.ReadJson(index_: Integer; output: TJsonObject);
var
  d: TMemoryStream64;
begin
  d := TMemoryStream64.Create;
  ReadStream(index_, d);
  d.Position := 0;
  output.LoadFromStream(d, TEncoding.UTF8, False);
  DisposeObject(d);
end;
{$ENDIF}


function TDataFrameEngine.ReadRect(index_: Integer): TRect;
begin
  with ReadArrayInteger(index_) do
    begin
      Result := Rect(Buffer[0], Buffer[1], Buffer[2], Buffer[3]);
    end;
end;

function TDataFrameEngine.ReadRectf(index_: Integer): TRectf;
begin
  with ReadArraySingle(index_) do
    begin
      Result := Rectf(Buffer[0], Buffer[1], Buffer[2], Buffer[3]);
    end;
end;

function TDataFrameEngine.ReadPoint(index_: Integer): TPoint;
begin
  with ReadArrayInteger(index_) do
    begin
      Result := Point(Buffer[0], Buffer[1]);
    end;
end;

function TDataFrameEngine.ReadPointf(index_: Integer): TPointf;
begin
  with ReadArraySingle(index_) do
    begin
      Result := Pointf(Buffer[0], Buffer[1]);
    end;
end;

function TDataFrameEngine.ReadVector(index_: Integer): TVector;
begin
  with ReadArraySingle(index_) do
    begin
      Result[0] := Buffer[0];
      Result[1] := Buffer[1];
      Result[2] := Buffer[2];
      Result[3] := Buffer[3];
    end;
end;

function TDataFrameEngine.ReadAffineVector(index_: Integer): TAffineVector;
begin
  with ReadArraySingle(index_) do
    begin
      Result[0] := Buffer[0];
      Result[1] := Buffer[1];
      Result[2] := Buffer[2];
    end;
end;

function TDataFrameEngine.ReadVec3(index_: Integer): TVec3;
begin
  with ReadArraySingle(index_) do
    begin
      Result[0] := Buffer[0];
      Result[1] := Buffer[1];
      Result[2] := Buffer[2];
    end;
end;

function TDataFrameEngine.ReadVec4(index_: Integer): TVec4;
begin
  with ReadArraySingle(index_) do
    begin
      Result[0] := Buffer[0];
      Result[1] := Buffer[1];
      Result[2] := Buffer[2];
      Result[3] := Buffer[3];
    end;
end;

function TDataFrameEngine.ReadVector3(index_: Integer): TVector3;
begin
  with ReadArraySingle(index_) do
    begin
      Result := Vector3(Buffer[0], Buffer[1], Buffer[2]);
    end;
end;

function TDataFrameEngine.ReadVector4(index_: Integer): TVector4;
begin
  with ReadArraySingle(index_) do
    begin
      Result := Vector4(Buffer[0], Buffer[1], Buffer[2], Buffer[3]);
    end;
end;

function TDataFrameEngine.ReadMat4(index_: Integer): TMat4;
var
  i, j: Integer;
begin
  with ReadArraySingle(index_) do
    begin
      for i := 0 to 3 do
        for j := 0 to 3 do
            Result[i][j] := Buffer[i * 4 + j];
    end;
end;

function TDataFrameEngine.ReadMatrix4(index_: Integer): TMatrix4;
begin
  Result.buff := ReadMat4(index_);
end;

function TDataFrameEngine.Read2DPoint(index_: Integer): T2DPoint;
begin
  with ReadArraySingle(index_) do
    begin
      Result[0] := Buffer[0];
      Result[1] := Buffer[1];
    end;
end;

function TDataFrameEngine.ReadVec2(index_: Integer): TVec2;
begin
  Result := Read2DPoint(index_);
end;

function TDataFrameEngine.ReadRectV2(index_: Integer): TRectV2;
begin
  with ReadArraySingle(index_) do
    begin
      Result[0][0] := Buffer[0];
      Result[0][1] := Buffer[1];
      Result[1][0] := Buffer[2];
      Result[1][1] := Buffer[3];
    end;
end;

function TDataFrameEngine.ReadPointer(index_: Integer): UInt64;
begin
  Result := ReadUInt64(index_);
end;

procedure TDataFrameEngine.Read(index_: Integer; var aBuf; aCount: Int64);
var
  s: TMemoryStream64;
begin
  s := TMemoryStream64.Create;
  ReadStream(index_, s);
  s.Read64(aBuf, aCount);
  DisposeObject(s);
end;

function TDataFrameEngine.Read(index_: Integer): TDataFrameBase;
begin
  Result := Data[index_];
end;

function TDataFrameEngine.ComputeEncodeSize: Int64;
var
  i: Integer;
begin
  Result := C_Integer_Size;
  for i := 0 to Count - 1 do
      Result := Result + C_Byte_Size + GetData(i).ComputeEncodeSize;
end;

class procedure TDataFrameEngine.BuildEmptyStream(output: TCoreClassStream);
var
  editionToken: Byte;
  sizeInfo: Cardinal;
  compToken: Byte;
  md5: TMD5;
  cnt: Integer;
begin
  // make header
  editionToken := $FF;
  sizeInfo := C_Integer_Size;
  compToken := 0;
  md5 := NullMD5;
  cnt := 0;

  output.write(editionToken, C_Byte_Size);
  output.write(sizeInfo, C_Cardinal_Size);
  output.write(compToken, C_Byte_Size);
  output.write(md5[0], C_MD5_Size);
  output.write(cnt, C_Integer_Size);
end;

function TDataFrameEngine.EncodeTo(output: TCoreClassStream; const FastMode: Boolean): Integer;
var
  i: Integer;
  DataFrame_: TDataFrameBase;
  StoreStream, nStream: TMemoryStream64;
  ID: Byte;

  editionToken: Byte;
  sizeInfo32: Cardinal;
  sizeInfo64: Int64;
  compToken: Byte;
  md5: TMD5;
begin
  Result := Count;

  if Result = 0 then
    begin
      BuildEmptyStream(output);
      Exit;
    end;

  // if encode size too large(>1M), we use EncodeAsSelectCompressor
  if ComputeEncodeSize > 1024 * 1024 then
    begin
      Result := EncodeAsSelectCompressor(TSelectCompressionMethod.scmZLIB, output, FastMode);
      Exit;
    end;

  StoreStream := TMemoryStream64.CustomCreate(8192);

  // make body
  StoreStream.Write64(Result, C_Integer_Size);

  nStream := TMemoryStream64.Create;
  for i := 0 to Count - 1 do
    begin
      DataFrame_ := GetData(i);
      ID := DataFrame_.FID;
      DataFrame_.SaveToStream(nStream);

      StoreStream.Write64(ID, C_Byte_Size);
      nStream.Position := 0;
      StoreStream.CopyFrom(nStream, nStream.Size);
      nStream.Clear;
    end;

  // make header
  sizeInfo32 := Cardinal(StoreStream.Size);
  sizeInfo64 := StoreStream.Size;
  if sizeInfo64 > C_Max_UInt32 then
      editionToken := $FA
  else
      editionToken := $FF;
  compToken := 0;
  StoreStream.Position := 0;
  if FastMode then
      md5 := NullMD5
  else
      md5 := umlMD5(StoreStream.Memory, StoreStream.Size);

  // prepare write header
  nStream.Clear;
  nStream.write(editionToken, C_Byte_Size);
  if sizeInfo64 > C_Max_UInt32 then
      nStream.write(sizeInfo64, C_Int64_Size)
  else
      nStream.write(sizeInfo32, C_Cardinal_Size);
  nStream.write(compToken, C_Byte_Size);
  nStream.write(md5[0], C_MD5_Size);

  // write header
  nStream.Position := 0;
  output.CopyFrom(nStream, nStream.Size);
  DisposeObject(nStream);

  // write body
  StoreStream.Position := 0;
  output.CopyFrom(StoreStream, StoreStream.Size);
  DisposeObject(StoreStream);
end;

function TDataFrameEngine.EncodeTo(output: TCoreClassStream): Integer;
begin
  Result := EncodeTo(output, False);
end;

procedure TDataFrameEngine.Encrypt(output: TCoreClassStream; Compressed_: Boolean; SecurityLevel: Integer; Key: TCipherKeyBuffer);
var
  m64: TMemoryStream64;
begin
  m64 := TMemoryStream64.Create;
  if Compressed_ then
      EncodeAsSelectCompressor(m64, True)
  else
      EncodeTo(m64, True);

  QuantumEncrypt(m64, output, SecurityLevel, Key);
  DisposeObject(m64);
end;

function TDataFrameEngine.Decrypt(input: TCoreClassStream; Key: TCipherKeyBuffer): Boolean;
var
  m64: TMemoryStream64;
begin
  m64 := TMemoryStream64.Create;
  Result := QuantumDecrypt(input, m64, Key);
  if Result then
    begin
      m64.Position := 0;
      DecodeFrom(m64, True);
    end;

  DisposeObject(m64);
end;

{$IFNDEF FPC}


procedure TDataFrameEngine.EncodeAsPublicJson(var output: TPascalString);
var
  m64: TMemoryStream64;
  buff: TBytes;
begin
  m64 := TMemoryStream64.Create;
  EncodeAsPublicJson(m64);
  SetLength(buff, m64.Size);
  CopyPtr(m64.Memory, @buff[0], m64.Size);
  DisposeObject(m64);
  output.Bytes := buff;
  SetLength(buff, 0);
end;

procedure TDataFrameEngine.EncodeAsPublicJson(output: TCoreClassStream);
var
  j: TJsonObject;
  i: Integer;
begin
  j := TJsonObject.Create;
  j.s['help'] := 'This JSON with TDataFrameEngine encode';

  for i := 0 to Count - 1 do
    begin
      j.a['Ref'].Add(TDataFrameBase(FDataList[i]).FID);
      TDataFrameBase(FDataList[i]).SaveToJson(j.a['Data'], i);
    end;

  j.SaveToStream(output, False, TEncoding.UTF8, True);

  DisposeObject(j);
end;

procedure TDataFrameEngine.EncodeAsJson(output: TCoreClassStream);
var
  j: TJsonObject;
  i: Integer;
  DataFrame_: TDataFrameBase;
begin
  j := TJsonObject.Create;

  for i := 0 to Count - 1 do
    begin
      DataFrame_ := TDataFrameBase(FDataList[i]);
      DataFrame_.SaveToJson(j.a['Data'], i);
      j.a['Ref'].Add(DataFrame_.FID);
    end;

  j.SaveToStream(output, True, TEncoding.UTF8, True);

  DisposeObject(j);
end;

procedure TDataFrameEngine.DecodeFromJson(stream: TCoreClassStream);
var
  j: TJsonObject;
  t: Byte;
  i: Integer;
  DataFrame_: TDataFrameBase;
begin
  Clear;
  j := TJsonObject.Create;
  try
      j.LoadFromStream(stream, TEncoding.UTF8, True);
  except
    DisposeObject(j);
    Exit;
  end;

  try
    for i := 0 to j.a['Ref'].Count - 1 do
      begin
        t := j.a['Ref'].i[i];
        DataFrame_ := AddData(ByteToDataType(t));
        DataFrame_.LoadFromJson(j.a['Data'], i);
      end;
  except
    DisposeObject(j);
    Exit;
  end;

  DisposeObject(j);
end;

procedure TDataFrameEngine.DecodeFromJson(const s: TPascalString);
var
  buff: TBytes;
  m64: TMemoryStream64;
begin
  buff := s.Bytes;
  m64 := TMemoryStream64.Create;
  m64.SetPointerWithProtectedMode(@buff[0], length(buff));
  m64.Position := 0;
  DecodeFromJson(m64);
  DisposeObject(m64);
  SetLength(buff, 0);
end;

{$ENDIF}


function TDataFrameEngine.EncodeAsSelectCompressor(scm: TSelectCompressionMethod; output: TCoreClassStream; const FastMode: Boolean): Integer;
var
  i: Integer;
  DataFrame_: TDataFrameBase;
  StoreStream, nStream, compStream: TMemoryStream64;
  ID: Byte;

  editionToken: Byte;
  sizeInfo32: Cardinal;
  sizeInfo64: Int64;
  compToken: Byte;
  compsizeInfo32: Cardinal;
  compsizeInfo64: Int64;
  md5: TMD5;
begin
  Result := Count;

  if Result = 0 then
    begin
      BuildEmptyStream(output);
      Exit;
    end;

  StoreStream := TMemoryStream64.CustomCreate(8192);

  // make body
  StoreStream.Write64(Result, C_Integer_Size);

  nStream := TMemoryStream64.Create;
  for i := 0 to Count - 1 do
    begin
      DataFrame_ := GetData(i);
      ID := DataFrame_.FID;
      DataFrame_.SaveToStream(nStream);

      StoreStream.Write64(ID, C_Byte_Size);
      nStream.Position := 0;
      StoreStream.CopyFrom(nStream, nStream.Size);
      nStream.Clear;
    end;

  // compress body and make header
  compsizeInfo32 := Cardinal(StoreStream.Size);
  compsizeInfo64 := StoreStream.Size;
  StoreStream.Position := 0;
  if FastMode then
      md5 := NullMD5
  else
      md5 := umlMD5(StoreStream.Memory, StoreStream.Size);

  compStream := TMemoryStream64.CustomCreate($FFFF);
  ParallelCompressStream(scm, StoreStream, compStream);
  DisposeObject(StoreStream);

  // make header
  sizeInfo32 := Cardinal(compStream.Size);
  sizeInfo64 := compStream.Size;
  if sizeInfo64 > C_Max_UInt32 then
      editionToken := $FA
  else
      editionToken := $FF;
  if compsizeInfo64 > C_Max_UInt32 then
      compToken := 44
  else
      compToken := 4;

  // prepare write header
  nStream.Clear;
  nStream.write(editionToken, C_Byte_Size);
  if sizeInfo64 > C_Max_UInt32 then
      nStream.write(sizeInfo64, C_Int64_Size)
  else
      nStream.write(sizeInfo32, C_Cardinal_Size);
  nStream.write(compToken, C_Byte_Size);
  if compsizeInfo64 > C_Max_UInt32 then
      nStream.write(compsizeInfo64, C_Int64_Size)
  else
      nStream.write(compsizeInfo32, C_Cardinal_Size);
  nStream.write(md5[0], C_MD5_Size);

  // write header
  nStream.Position := 0;
  output.CopyFrom(nStream, nStream.Size);
  DisposeObject(nStream);

  // write body
  compStream.Position := 0;
  output.CopyFrom(compStream, compStream.Size);
  DisposeObject(compStream);
end;

function TDataFrameEngine.EncodeAsSelectCompressor(output: TCoreClassStream; const FastMode: Boolean): Integer;
var
  scm: TSelectCompressionMethod;
begin
  if ComputeEncodeSize > 64 * 1024 then
    begin
      if FastMode then
          scm := TSelectCompressionMethod.scmZLIB
      else
          scm := TSelectCompressionMethod.scmZLIB_Max;
      Result := EncodeAsSelectCompressor(scm, output, FastMode);
    end
  else
      Result := EncodeAsZLib(output, FastMode);
end;

function TDataFrameEngine.EncodeAsSelectCompressor(output: TCoreClassStream): Integer;
begin
  Result := EncodeAsSelectCompressor(output, False);
end;

function TDataFrameEngine.EncodeAsZLib(output: TCoreClassStream; const FastMode: Boolean): Integer;
var
  i: Integer;
  DataFrame_: TDataFrameBase;
  StoreStream, nStream, compStream: TMemoryStream64;
  ZCompStream: TCompressionStream;
  ID: Byte;

  editionToken: Byte;
  sizeInfo32: Cardinal;
  sizeInfo64: Int64;
  compToken: Byte;
  compsizeInfo32: Cardinal;
  compsizeInfo64: Int64;
  md5: TMD5;
begin
  Result := Count;

  if Result = 0 then
    begin
      BuildEmptyStream(output);
      Exit;
    end;

  // if encode size too large(>1M), we use EncodeAsSelectCompressor
  if ComputeEncodeSize > 1024 * 1024 then
    begin
      Result := EncodeAsSelectCompressor(TSelectCompressionMethod.scmZLIB, output, FastMode);
      Exit;
    end;

  StoreStream := TMemoryStream64.CustomCreate(8192);

  // make body
  StoreStream.Write64(Result, C_Integer_Size);

  nStream := TMemoryStream64.Create;
  for i := 0 to Count - 1 do
    begin
      DataFrame_ := GetData(i);
      ID := DataFrame_.FID;
      DataFrame_.SaveToStream(nStream);

      StoreStream.Write64(ID, C_Byte_Size);
      nStream.Position := 0;
      StoreStream.CopyFrom(nStream, nStream.Size);
      nStream.Clear;
    end;

  // compress body and make header
  compsizeInfo32 := Cardinal(StoreStream.Size);
  compsizeInfo64 := StoreStream.Size;
  StoreStream.Position := 0;
  if FastMode then
      md5 := NullMD5
  else
      md5 := umlMD5(StoreStream.Memory, StoreStream.Size);

  compStream := TMemoryStream64.CustomCreate($FFFF);
  ZCompStream := TCompressionStream.Create(compStream);
  StoreStream.Position := 0;
  ZCompStream.CopyFrom(StoreStream, StoreStream.Size);
  DisposeObject(ZCompStream);
  DisposeObject(StoreStream);

  // make header
  sizeInfo32 := compStream.Size;
  sizeInfo64 := compStream.Size;
  if sizeInfo64 > C_Max_UInt32 then
      editionToken := $FA
  else
      editionToken := $FF;
  if compsizeInfo64 > C_Max_UInt32 then
      compToken := 11
  else
      compToken := 1;

  // prepare write header
  nStream.Clear;
  nStream.write(editionToken, C_Byte_Size);
  if sizeInfo64 > C_Max_UInt32 then
      nStream.write(sizeInfo64, C_Int64_Size)
  else
      nStream.write(sizeInfo32, C_Cardinal_Size);
  nStream.write(compToken, C_Byte_Size);
  if compsizeInfo64 > C_Max_UInt32 then
      nStream.write(compsizeInfo64, C_Int64_Size)
  else
      nStream.write(compsizeInfo32, C_Cardinal_Size);
  nStream.write(md5[0], C_MD5_Size);

  // write header
  nStream.Position := 0;
  output.CopyFrom(nStream, nStream.Size);
  DisposeObject(nStream);

  // write body
  compStream.Position := 0;
  output.CopyFrom(compStream, compStream.Size);
  DisposeObject(compStream);
end;

function TDataFrameEngine.EncodeAsZLib(output: TCoreClassStream): Integer;
begin
  Result := EncodeAsZLib(output, False);
end;

function TDataFrameEngine.EncodeAsDeflate(output: TCoreClassStream; const FastMode: Boolean): Integer;
var
  i: Integer;
  DataFrame_: TDataFrameBase;
  StoreStream, nStream, compStream: TMemoryStream64;
  ID: Byte;

  editionToken: Byte;
  sizeInfo32: Cardinal;
  sizeInfo64: Int64;
  compToken: Byte;
  compsizeInfo32: Cardinal;
  compsizeInfo64: Int64;
  md5: TMD5;
begin
  Result := Count;

  if Result = 0 then
    begin
      BuildEmptyStream(output);
      Exit;
    end;

  // if encode size too large(>1M), we use EncodeAsSelectCompressor
  if ComputeEncodeSize > 1024 * 1024 then
    begin
      Result := EncodeAsSelectCompressor(TSelectCompressionMethod.scmZLIB, output, FastMode);
      Exit;
    end;

  StoreStream := TMemoryStream64.CustomCreate(8192);

  // make body
  StoreStream.Write64(Result, C_Integer_Size);

  nStream := TMemoryStream64.Create;
  for i := 0 to Count - 1 do
    begin
      DataFrame_ := GetData(i);
      ID := DataFrame_.FID;
      DataFrame_.SaveToStream(nStream);

      StoreStream.Write64(ID, C_Byte_Size);
      nStream.Position := 0;
      StoreStream.CopyFrom(nStream, nStream.Size);
      nStream.Clear;
    end;

  // compress body and make header
  compsizeInfo32 := Cardinal(StoreStream.Size);
  compsizeInfo64 := StoreStream.Size;
  StoreStream.Position := 0;
  if FastMode then
      md5 := NullMD5
  else
      md5 := umlMD5(StoreStream.Memory, StoreStream.Size);

  compStream := TMemoryStream64.Create;
  StoreStream.Position := 0;

  if FCompressorDeflate = nil then
      FCompressorDeflate := TCompressorDeflate.Create;

  CoreCompressStream(FCompressorDeflate, StoreStream, compStream);
  DisposeObject(StoreStream);

  // make header
  sizeInfo32 := Cardinal(compStream.Size);
  sizeInfo64 := compStream.Size;
  if sizeInfo64 > C_Max_UInt32 then
      editionToken := $FA
  else
      editionToken := $FF;
  if compsizeInfo64 > C_Max_UInt32 then
      compToken := 22
  else
      compToken := 2;

  // prepare write header
  nStream.Clear;
  nStream.write(editionToken, C_Byte_Size);
  if sizeInfo64 > C_Max_UInt32 then
      nStream.write(sizeInfo64, C_Int64_Size)
  else
      nStream.write(sizeInfo32, C_Cardinal_Size);
  nStream.write(compToken, C_Byte_Size);
  if compsizeInfo64 > C_Max_UInt32 then
      nStream.write(compsizeInfo64, C_Int64_Size)
  else
      nStream.write(compsizeInfo32, C_Cardinal_Size);
  nStream.write(md5[0], C_MD5_Size);

  // write header
  nStream.Position := 0;
  output.CopyFrom(nStream, nStream.Size);
  DisposeObject(nStream);

  // write body
  compStream.Position := 0;
  output.CopyFrom(compStream, compStream.Size);
  DisposeObject(compStream);
end;

function TDataFrameEngine.EncodeAsDeflate(output: TCoreClassStream): Integer;
begin
  Result := EncodeAsDeflate(output, False);
end;

function TDataFrameEngine.EncodeAsBRRC(output: TCoreClassStream; const FastMode: Boolean): Integer;
var
  i: Integer;
  DataFrame_: TDataFrameBase;
  StoreStream, nStream, compStream: TMemoryStream64;
  ID: Byte;

  editionToken: Byte;
  sizeInfo32: Cardinal;
  sizeInfo64: Int64;
  compToken: Byte;
  compsizeInfo32: Cardinal;
  compsizeInfo64: Int64;
  md5: TMD5;
begin
  Result := Count;

  if Result = 0 then
    begin
      BuildEmptyStream(output);
      Exit;
    end;

  // if encode size too large(>1M), we use EncodeAsSelectCompressor
  if ComputeEncodeSize > 1024 * 1024 then
    begin
      Result := EncodeAsSelectCompressor(TSelectCompressionMethod.scmZLIB, output, FastMode);
      Exit;
    end;

  StoreStream := TMemoryStream64.CustomCreate(8192);

  // make body
  StoreStream.Write64(Result, C_Integer_Size);

  nStream := TMemoryStream64.Create;
  for i := 0 to Count - 1 do
    begin
      DataFrame_ := GetData(i);
      ID := DataFrame_.FID;
      DataFrame_.SaveToStream(nStream);

      StoreStream.Write64(ID, C_Byte_Size);
      nStream.Position := 0;
      StoreStream.CopyFrom(nStream, nStream.Size);
      nStream.Clear;
    end;

  // compress body and make header
  compsizeInfo32 := Cardinal(StoreStream.Size);
  compsizeInfo64 := StoreStream.Size;
  StoreStream.Position := 0;
  if FastMode then
      md5 := NullMD5
  else
      md5 := umlMD5(StoreStream.Memory, StoreStream.Size);

  compStream := TMemoryStream64.Create;
  StoreStream.Position := 0;

  if FCompressorBRRC = nil then
      FCompressorBRRC := TCompressorBRRC.Create;

  CoreCompressStream(FCompressorBRRC, StoreStream, compStream);
  DisposeObject(StoreStream);

  // make header
  sizeInfo32 := Cardinal(compStream.Size);
  sizeInfo64 := compStream.Size;
  if sizeInfo64 > C_Max_UInt32 then
      editionToken := $FA
  else
      editionToken := $FF;
  if compsizeInfo64 > C_Max_UInt32 then
      compToken := 33
  else
      compToken := 3;

  // prepare write header
  nStream.Clear;
  nStream.write(editionToken, C_Byte_Size);
  if sizeInfo64 > C_Max_UInt32 then
      nStream.write(sizeInfo64, C_Int64_Size)
  else
      nStream.write(sizeInfo32, C_Cardinal_Size);
  nStream.write(compToken, C_Byte_Size);
  if compsizeInfo64 > C_Max_UInt32 then
      nStream.write(compsizeInfo64, C_Int64_Size)
  else
      nStream.write(compsizeInfo32, C_Cardinal_Size);
  nStream.write(md5[0], C_MD5_Size);

  // write header
  nStream.Position := 0;
  output.CopyFrom(nStream, nStream.Size);
  DisposeObject(nStream);

  // write body
  compStream.Position := 0;
  output.CopyFrom(compStream, compStream.Size);
  DisposeObject(compStream);
end;

function TDataFrameEngine.EncodeAsBRRC(output: TCoreClassStream): Integer;
begin
  Result := EncodeAsBRRC(output, False);
end;

function TDataFrameEngine.IsCompressed(source: TCoreClassStream): Boolean;
var
  bakPos: Int64;

  editionToken: Byte;
  sizeInfo32: Cardinal;
  sizeInfo64, sizeInfo: Int64;
  compToken: Byte;
begin
  bakPos := source.Position;
  Result := False;

  source.Read(editionToken, C_Byte_Size);
  if (editionToken in [$FF, $FA]) then
    begin
      if editionToken = $FF then
        begin
          source.Read(sizeInfo32, C_Cardinal_Size);
          sizeInfo := sizeInfo32;
        end
      else
        begin
          source.Read(sizeInfo64, C_Int64_Size);
          sizeInfo := sizeInfo64;
        end;

      source.Read(compToken, C_Byte_Size);

      Result := compToken in [1, 11, 2, 22, 3, 33, 4, 44];
    end;

  source.Position := bakPos;
end;

function TDataFrameEngine.DecodeFrom(source: TCoreClassStream; const FastMode: Boolean): Integer;
var
  i, cnt: Integer;
  ID: Byte;
  StoreStream: TMemoryStream64;
  ZDecompStream: TDecompressionStream;
  DataFrame_: TDataFrameBase;

  editionToken: Byte;
  sizeInfo32: Cardinal;
  sizeInfo64, sizeInfo: Int64;
  compToken: Byte;
  compsizeInfo32: Cardinal;
  compsizeInfo64, compsizeInfo: Int64;
  md5: TMD5;
begin
  Clear;

  Result := -1;

  StoreStream := TMemoryStream64.Create;

  source.Read(editionToken, C_Byte_Size);
  if (editionToken in [$FF, $FA]) then
    begin
      if editionToken = $FF then
        begin
          source.Read(sizeInfo32, C_Cardinal_Size);
          sizeInfo := sizeInfo32;
        end
      else
        begin
          source.Read(sizeInfo64, C_Int64_Size);
          sizeInfo := sizeInfo64;
        end;

      source.Read(compToken, C_Byte_Size);

      if compToken = 0 then
        begin
          source.Read(md5[0], 16);

          if source is TMemoryStream64 then
              StoreStream.SetPointerWithProtectedMode(TMemoryStream64(source).PositionAsPtr, sizeInfo)
          else
            begin
              if sizeInfo > 0 then
                  StoreStream.CopyFrom(source, sizeInfo);
            end;

          StoreStream.Position := 0;
          if (not FastMode) and (not umlIsNullMD5(md5)) then
            if not umlMD5Compare(umlMD5(StoreStream.Memory, StoreStream.Size), md5) then
              begin
                DoStatus('dataframe md5 error!');
                DisposeObject(StoreStream);
                Exit;
              end;
        end
      else if compToken in [1, 11] then
        begin
          if compToken = 1 then
            begin
              source.Read(compsizeInfo32, C_Cardinal_Size);
              compsizeInfo := compsizeInfo32;
            end
          else
            begin
              source.Read(compsizeInfo64, C_Int64_Size);
              compsizeInfo := compsizeInfo64;
            end;

          source.Read(md5[0], 16);

          ZDecompStream := TDecompressionStream.Create(source);
          StoreStream.CopyFrom(ZDecompStream, compsizeInfo);
          DisposeObject(ZDecompStream);

          StoreStream.Position := 0;
          if (not FastMode) and (not umlIsNullMD5(md5)) then
            if not umlMD5Compare(umlMD5(StoreStream.Memory, StoreStream.Size), md5) then
              begin
                DoStatus('ZLib md5 error!');
                DisposeObject(StoreStream);
                Exit;
              end;
        end
      else if compToken in [2, 22] then
        begin
          if compToken = 2 then
            begin
              source.Read(compsizeInfo32, C_Cardinal_Size);
              compsizeInfo := compsizeInfo32;
            end
          else
            begin
              source.Read(compsizeInfo64, C_Int64_Size);
              compsizeInfo := compsizeInfo64;
            end;
          source.Read(md5[0], 16);

          if FCompressorDeflate = nil then
              FCompressorDeflate := TCompressorDeflate.Create;
          CoreDecompressStream(FCompressorDeflate, source, StoreStream);

          StoreStream.Position := 0;
          if (not FastMode) and (not umlIsNullMD5(md5)) then
            if not umlMD5Compare(umlMD5(StoreStream.Memory, StoreStream.Size), md5) then
              begin
                DoStatus('Deflate md5 error!');
                DisposeObject(StoreStream);
                Exit;
              end;
        end
      else if compToken in [3, 33] then
        begin
          if compToken = 3 then
            begin
              source.Read(compsizeInfo32, C_Cardinal_Size);
              compsizeInfo := compsizeInfo32;
            end
          else
            begin
              source.Read(compsizeInfo64, C_Int64_Size);
              compsizeInfo := compsizeInfo64;
            end;
          source.Read(md5[0], 16);

          if FCompressorBRRC = nil then
              FCompressorBRRC := TCompressorBRRC.Create;
          CoreDecompressStream(FCompressorBRRC, source, StoreStream);

          StoreStream.Position := 0;
          if (not FastMode) and (not umlIsNullMD5(md5)) then
            if not umlMD5Compare(umlMD5(StoreStream.Memory, StoreStream.Size), md5) then
              begin
                DoStatus('BRRC md5 error!');
                DisposeObject(StoreStream);
                Exit;
              end;
        end
      else if compToken in [4, 44] then
        begin
          if compToken = 4 then
            begin
              source.Read(compsizeInfo32, C_Cardinal_Size);
              compsizeInfo := compsizeInfo32;
            end
          else
            begin
              source.Read(compsizeInfo64, C_Int64_Size);
              compsizeInfo := compsizeInfo64;
            end;
          source.Read(md5[0], 16);

          ParallelDecompressStream(source, StoreStream);

          StoreStream.Position := 0;
          if (not FastMode) and (not umlIsNullMD5(md5)) then
            if not umlMD5Compare(umlMD5(StoreStream.Memory, StoreStream.Size), md5) then
              begin
                DoStatus('select compression md5 error!');
                DisposeObject(StoreStream);
                Exit;
              end;
        end;

      StoreStream.Position := 0;

      StoreStream.Read64(cnt, C_Integer_Size);
      for i := 0 to cnt - 1 do
        begin
          StoreStream.Read64(ID, C_Byte_Size);
          DataFrame_ := AddData(ByteToDataType(ID));
          DataFrame_.LoadFromStream(StoreStream);
        end;
      DisposeObject(StoreStream);
      Result := cnt;
    end
  else
    begin
      DoStatus('dataframe decode error!');
      DisposeObject(StoreStream);
      Exit;
    end;
end;

function TDataFrameEngine.DecodeFrom(source: TCoreClassStream): Integer;
begin
  Result := DecodeFrom(source, False);
end;

procedure TDataFrameEngine.EncodeToBytes(const Compressed, FastMode: Boolean; var output: TBytes);
var
  enStream: TMemoryStream64;
begin
  enStream := TMemoryStream64.Create;
  if Compressed then
      EncodeAsSelectCompressor(enStream, FastMode)
  else
      EncodeTo(enStream, FastMode);

  SetLength(output, enStream.Size);
  CopyPtr(enStream.Memory, @output[0], enStream.Size);
  DisposeObject(enStream);
end;

procedure TDataFrameEngine.DecodeFromBytes(var buff: TBytes);
begin
  DecodeFromBytes(buff, False);
end;

procedure TDataFrameEngine.DecodeFromBytes(var buff: TBytes; const FastMode: Boolean);
var
  enStream: TMemoryStream64;
begin
  enStream := TMemoryStream64.Create;
  enStream.SetPointerWithProtectedMode(@buff[0], length(buff));
  DecodeFrom(enStream, FastMode);
  DisposeObject(enStream);
end;

function TDataFrameEngine.GetMD5(const FastMode: Boolean): TMD5;
var
  enStream: TMemoryStream64;
begin
  enStream := TMemoryStream64.Create;
  EncodeTo(enStream, FastMode);

  Result := umlMD5(enStream.Memory, enStream.Size);
  DisposeObject(enStream);
end;

function TDataFrameEngine.Compare(source: TDataFrameEngine): Boolean;
var
  i: Integer;
  s1, s2: TMemoryStream64;
begin
  Result := False;

  if Count <> source.Count then
      Exit;

  s1 := TMemoryStream64.CustomCreate(8192);
  s2 := TMemoryStream64.CustomCreate(8192);
  try
    for i := 0 to Count - 1 do
      begin
        if FDataList[i].ClassType <> source[i].ClassType then
            Exit;
        if TDataFrameBase(FDataList[i]).FID <> TDataFrameBase(source[i]).FID then
            Exit;
        if TDataFrameBase(FDataList[i]).ComputeEncodeSize <> TDataFrameBase(source[i]).ComputeEncodeSize then
            Exit;

        s1.Clear;
        s2.Clear;
        TDataFrameBase(FDataList[i]).SaveToStream(s1);
        TDataFrameBase(source[i]).SaveToStream(s2);
        if s1.Size <> s2.Size then
            Exit;
        if not CompareMemory(s1.Memory, s2.Memory, s1.Size) then
            Exit;
        s1.Clear;
        s2.Clear;
      end;
    Result := True;
  finally
    DisposeObject(s1);
    DisposeObject(s2);
  end;
end;

procedure TDataFrameEngine.LoadFromStream(stream: TCoreClassStream);
begin
  try
      DecodeFrom(stream);
  except
  end;
end;

procedure TDataFrameEngine.SaveToStream(stream: TCoreClassStream);
var
  siz: Integer;
begin
  try
    siz := ComputeEncodeSize;
    if siz > 1024 then
        EncodeAsSelectCompressor(stream)
    else
        EncodeTo(stream);
  except
  end;
end;

constructor TDataWriter.Create(AStream: TCoreClassStream);
begin
  inherited Create;
  FEngine := TDataFrameEngine.Create;
  FStream := AStream;
end;

destructor TDataWriter.Destroy;
var
  FlagCompressed: Boolean;
  verflag: TBytes;
  Len: Int64;
  M: TMemoryStream64;
begin
  if FStream <> nil then
    begin
      M := TMemoryStream64.Create;
      FEngine.EncodeTo(M);
      Len := M.Size;

      // write version flag
      verflag := umlBytesOf('0001');
      FStream.write(verflag, 4);

      // write compressed flag
      FlagCompressed := False;
      FStream.write(FlagCompressed, C_Boolean_Size);

      // write length info
      FStream.write(Len, C_Int64_Size);

      // write buffer
      M.Position := 0;
      FStream.CopyFrom(M, Len);
      DisposeObject(M);
    end;

  DisposeObject(FEngine);
  inherited Destroy;
end;

procedure TDataWriter.Clear;
begin
  FEngine.Clear;
end;

procedure TDataWriter.WriteString(v: SystemString);
begin
  FEngine.WriteString(v);
end;

procedure TDataWriter.WriteBytes(v: TBytes);
begin
  FEngine.WriteBytes(v);
end;

procedure TDataWriter.WriteInteger(v: Integer);
begin
  FEngine.WriteInteger(v);
end;

procedure TDataWriter.WriteCardinal(v: Cardinal);
begin
  FEngine.WriteCardinal(v);
end;

procedure TDataWriter.WriteWORD(v: Word);
begin
  FEngine.WriteWORD(v);
end;

procedure TDataWriter.WriteBool(v: Boolean);
begin
  FEngine.WriteBool(v);
end;

procedure TDataWriter.WriteBoolean(v: Boolean);
begin
  FEngine.WriteBoolean(v);
end;

procedure TDataWriter.WriteByte(v: Byte);
begin
  FEngine.WriteByte(v);
end;

procedure TDataWriter.WriteSingle(v: Single);
begin
  FEngine.WriteSingle(v);
end;

procedure TDataWriter.WriteDouble(v: Double);
begin
  FEngine.WriteDouble(v);
end;

procedure TDataWriter.WriteArrayInteger(v: array of Integer);
begin
  FEngine.WriteArrayInteger.WriteArray(v);
end;

procedure TDataWriter.WriteArrayShortInt(v: array of ShortInt);
begin
  FEngine.WriteArrayShortInt.WriteArray(v);
end;

procedure TDataWriter.WriteArrayByte(v: array of Byte);
begin
  FEngine.WriteArrayByte.WriteArray(v);
end;

procedure TDataWriter.WriteArraySingle(v: array of Single);
begin
  FEngine.WriteArraySingle.WriteArray(v);
end;

procedure TDataWriter.WriteArrayDouble(v: array of Double);
begin
  FEngine.WriteArrayDouble.WriteArray(v);
end;

procedure TDataWriter.WriteArrayInt64(v: array of Int64);
begin
  FEngine.WriteArrayInt64.WriteArray(v);
end;

procedure TDataWriter.WriteStream(v: TCoreClassStream);
begin
  FEngine.WriteStream(v);
end;

procedure TDataWriter.WriteVariant(v: Variant);
begin
  FEngine.WriteVariant(v);
end;

procedure TDataWriter.WriteInt64(v: Int64);
begin
  FEngine.WriteInt64(v);
end;

procedure TDataWriter.WriteUInt64(v: UInt64);
begin
  FEngine.WriteUInt64(v);
end;

procedure TDataWriter.WriteStrings(v: TCoreClassStrings);
begin
  FEngine.WriteStrings(v);
end;

procedure TDataWriter.WriteListStrings(v: TListString);
begin
  FEngine.WriteListStrings(v);
end;

procedure TDataWriter.WritePascalStrings(v: TListPascalString);
begin
  FEngine.WritePascalStrings(v);
end;

procedure TDataWriter.WriteDataFrame(v: TDataFrameEngine);
begin
  FEngine.WriteDataFrame(v);
end;

procedure TDataWriter.WriteDataFrameCompressed(v: TDataFrameEngine);
begin
  FEngine.WriteDataFrameCompressed(v);
end;

procedure TDataWriter.WriteHashStringList(v: THashStringList);
begin
  FEngine.WriteHashStringList(v);
end;

procedure TDataWriter.WriteVariantList(v: THashVariantList);
begin
  FEngine.WriteVariantList(v);
end;

procedure TDataWriter.WriteSectionText(v: TSectionTextData);
begin
  FEngine.WriteSectionText(v);
end;

{$IFNDEF FPC}


procedure TDataWriter.WriteJson(v: TJsonObject);
begin
  FEngine.WriteJson(v);
end;
{$ENDIF}


procedure TDataWriter.WriteRect(v: TRect);
begin
  FEngine.WriteRect(v);
end;

procedure TDataWriter.WriteRectf(v: TRectf);
begin
  FEngine.WriteRectf(v);
end;

procedure TDataWriter.WritePoint(v: TPoint);
begin
  FEngine.WritePoint(v);
end;

procedure TDataWriter.WritePointf(v: TPointf);
begin
  FEngine.WritePointf(v);
end;

procedure TDataWriter.WriteVector(v: TVector);
begin
  FEngine.WriteVector(v);
end;

procedure TDataWriter.WriteAffineVector(v: TAffineVector);
begin
  FEngine.WriteAffineVector(v);
end;

procedure TDataWriter.WriteVec4(v: TVec4);
begin
  FEngine.WriteVec4(v);
end;

procedure TDataWriter.WriteVec3(v: TVec3);
begin
  FEngine.WriteVec3(v);
end;

procedure TDataWriter.WriteVector4(v: TVector4);
begin
  FEngine.WriteVector4(v);
end;

procedure TDataWriter.WriteVector3(v: TVector3);
begin
  FEngine.WriteVector3(v);
end;

procedure TDataWriter.WriteMat4(v: TMat4);
begin
  FEngine.WriteMat4(v);
end;

procedure TDataWriter.WriteMatrix4(v: TMatrix4);
begin
  FEngine.WriteMatrix4(v);
end;

procedure TDataWriter.Write2DPoint(v: T2DPoint);
begin
  FEngine.Write2DPoint(v);
end;

procedure TDataWriter.WriteVec2(v: TVec2);
begin
  FEngine.WriteVec2(v);
end;

procedure TDataWriter.WriteRectV2(v: TRectV2);
begin
  FEngine.WriteRectV2(v);
end;

procedure TDataWriter.WritePointer(v: Pointer);
begin
  FEngine.WritePointer(v);
end;

procedure TDataWriter.write(const aBuf; aCount: Int64);
begin
  FEngine.write(aBuf, aCount);
end;

constructor TDataReader.Create(AStream: TCoreClassStream);
var
  verflag: TBytes;
  FlagCompressed: Boolean;
  Len: Int64;
  M: TMemoryStream64;
begin
  inherited Create;
  FEngine := TDataFrameEngine.Create;
  if AStream <> nil then
    begin
      // read version flag
      SetLength(verflag, 4);
      AStream.Read(verflag, 4);
      if umlStringOf(verflag) <> '0001' then
          raise Exception.Create('Version flag Does not match!');

      // read compressed flag
      AStream.Read(FlagCompressed, C_Boolean_Size);

      // read length info
      AStream.Read(Len, C_Int64_Size);

      // write buffer
      M := TMemoryStream64.Create;
      M.CopyFrom(AStream, Len);
      M.Position := 0;
      FEngine.DecodeFrom(M);
      DisposeObject(M);
    end;
end;

destructor TDataReader.Destroy;
begin
  DisposeObject(FEngine);
  inherited Destroy;
end;

function TDataReader.ReadString: SystemString;
begin
  Result := FEngine.Reader.ReadString;
end;

function TDataReader.ReadBytes: TBytes;
begin
  Result := FEngine.Reader.ReadBytes;
end;

function TDataReader.ReadInteger: Integer;
begin
  Result := FEngine.Reader.ReadInteger;
end;

function TDataReader.ReadCardinal: Cardinal;
begin
  Result := FEngine.Reader.ReadCardinal;
end;

function TDataReader.ReadWord: Word;
begin
  Result := FEngine.Reader.ReadWord;
end;

function TDataReader.ReadBool: Boolean;
begin
  Result := FEngine.Reader.ReadBool;
end;

function TDataReader.ReadBoolean: Boolean;
begin
  Result := FEngine.Reader.ReadBoolean;
end;

function TDataReader.ReadByte: Byte;
begin
  Result := FEngine.Reader.ReadByte;
end;

function TDataReader.ReadSingle: Single;
begin
  Result := FEngine.Reader.ReadSingle;
end;

function TDataReader.ReadDouble: Double;
begin
  Result := FEngine.Reader.ReadDouble;
end;

procedure TDataReader.ReadArrayInteger(var Data: array of Integer);
var
  i: Integer;
  rb: TDataFrameArrayInteger;
begin
  rb := FEngine.Reader.ReadArrayInteger;
  for i := low(Data) to high(Data) do
      Data[i] := rb[i];
end;

procedure TDataReader.ReadArrayShortInt(var Data: array of ShortInt);
var
  i: Integer;
  rb: TDataFrameArrayShortInt;
begin
  rb := FEngine.Reader.ReadArrayShortInt;
  for i := low(Data) to high(Data) do
      Data[i] := rb[i];
end;

procedure TDataReader.ReadArrayByte(var Data: array of Byte);
var
  i: Integer;
  rb: TDataFrameArrayByte;
begin
  rb := FEngine.Reader.ReadArrayByte;
  for i := low(Data) to high(Data) do
      Data[i] := rb[i];
end;

procedure TDataReader.ReadArraySingle(var Data: array of Single);
var
  i: Integer;
  rb: TDataFrameArraySingle;
begin
  rb := FEngine.Reader.ReadArraySingle;
  for i := low(Data) to high(Data) do
      Data[i] := rb[i];
end;

procedure TDataReader.ReadArrayDouble(var Data: array of Double);
var
  i: Integer;
  rb: TDataFrameArrayDouble;
begin
  rb := FEngine.Reader.ReadArrayDouble;
  for i := low(Data) to high(Data) do
      Data[i] := rb[i];
end;

procedure TDataReader.ReadArrayInt64(var Data: array of Int64);
var
  i: Integer;
  rb: TDataFrameArrayInt64;
begin
  rb := FEngine.Reader.ReadArrayInt64;
  for i := low(Data) to high(Data) do
      Data[i] := rb[i];
end;

procedure TDataReader.ReadStream(output: TCoreClassStream);
begin
  FEngine.Reader.ReadStream(output);
end;

function TDataReader.ReadVariant: Variant;
begin
  Result := FEngine.Reader.ReadVariant;
end;

function TDataReader.ReadInt64: Int64;
begin
  Result := FEngine.Reader.ReadInt64;
end;

function TDataReader.ReadUInt64: UInt64;
begin
  Result := FEngine.Reader.ReadUInt64;
end;

procedure TDataReader.ReadStrings(output: TCoreClassStrings);
begin
  FEngine.Reader.ReadStrings(output);
end;

procedure TDataReader.ReadListStrings(output: TListString);
begin
  FEngine.Reader.ReadListStrings(output);
end;

procedure TDataReader.ReadPascalStrings(output: TListPascalString);
begin
  FEngine.Reader.ReadPascalStrings(output);
end;

procedure TDataReader.ReadDataFrame(output: TDataFrameEngine);
begin
  FEngine.Reader.ReadDataFrame(output);
end;

procedure TDataReader.ReadHashStringList(output: THashStringList);
begin
  FEngine.Reader.ReadHashStringList(output);
end;

procedure TDataReader.ReadVariantList(output: THashVariantList);
begin
  FEngine.Reader.ReadVariantList(output);
end;

procedure TDataReader.ReadSectionText(output: TSectionTextData);
begin
  FEngine.Reader.ReadSectionText(output);
end;

{$IFNDEF FPC}


procedure TDataReader.ReadJson(output: TJsonObject);
begin
  FEngine.Reader.ReadJson(output);
end;
{$ENDIF}


function TDataReader.ReadRect: TRect;
begin
  Result := FEngine.Reader.ReadRect;
end;

function TDataReader.ReadRectf: TRectf;
begin
  Result := FEngine.Reader.ReadRectf;
end;

function TDataReader.ReadPoint: TPoint;
begin
  Result := FEngine.Reader.ReadPoint;
end;

function TDataReader.ReadPointf: TPointf;
begin
  Result := FEngine.Reader.ReadPointf;
end;

function TDataReader.ReadVector: TVector;
begin
  Result := FEngine.Reader.ReadVector;
end;

function TDataReader.ReadAffineVector: TAffineVector;
begin
  Result := FEngine.Reader.ReadAffineVector;
end;

function TDataReader.ReadVec3: TVec3;
begin
  Result := FEngine.Reader.ReadVec3;
end;

function TDataReader.ReadVec4: TVec4;
begin
  Result := FEngine.Reader.ReadVec4;
end;

function TDataReader.ReadVector3: TVector3;
begin
  Result := FEngine.Reader.ReadVector3;
end;

function TDataReader.ReadVector4: TVector4;
begin
  Result := FEngine.Reader.ReadVector4;
end;

function TDataReader.ReadMat4: TMat4;
begin
  Result := FEngine.Reader.ReadMat4;
end;

function TDataReader.ReadMatrix4: TMatrix4;
begin
  Result := FEngine.Reader.ReadMatrix4;
end;

function TDataReader.Read2DPoint: T2DPoint;
begin
  Result := FEngine.Reader.Read2DPoint;
end;

function TDataReader.ReadVec2: TVec2;
begin
  Result := FEngine.Reader.ReadVec2;
end;

function TDataReader.ReadRectV2: TRectV2;
begin
  Result := FEngine.Reader.ReadRectV2;
end;

function TDataReader.ReadPointer: UInt64;
begin
  Result := FEngine.Reader.ReadPointer;
end;

procedure TDataReader.Read(var aBuf; aCount: Int64);
begin
  FEngine.Reader.Read(aBuf, aCount);
end;

end.