memtabledataeh.hpp

最新的 DBGRIDEH4.0

// CodeGear C++ Builder
// Copyright (c) 1995, 2007 by CodeGear
// All rights reserved

// (DO NOT EDIT: machine generated header) 'Memtabledataeh.pas' rev: 11.00

#ifndef MemtabledataehHPP
#define MemtabledataehHPP

#pragma delphiheader begin
#pragma option push
#pragma option -w-      // All warnings off
#pragma option -Vx      // Zero-length empty class member functions
#pragma pack(push,8)
#include <System.hpp>	// Pascal unit
#include <Sysinit.hpp>	// Pascal unit
#include <Sysutils.hpp>	// Pascal unit
#include <Windows.hpp>	// Pascal unit
#include <Ehlibvcl.hpp>	// Pascal unit
#include <Variants.hpp>	// Pascal unit
#include <Maskutils.hpp>	// Pascal unit
#include <Sqltimst.hpp>	// Pascal unit
#include <Fmtbcd.hpp>	// Pascal unit
#include <Classes.hpp>	// Pascal unit
#include <Db.hpp>	// Pascal unit
#include <Contnrs.hpp>	// Pascal unit
#include <Dbcommon.hpp>	// Pascal unit
#include <Memtreeeh.hpp>	// Pascal unit

//-- user supplied -----------------------------------------------------------

namespace Memtabledataeh
{
//-- type declarations -------------------------------------------------------
typedef DynamicArray<int >  TIntArray;

class DELPHICLASS TAutoIncrementEh;
class PASCALIMPLEMENTATION TAutoIncrementEh : public Classes::TPersistent 
{
	typedef Classes::TPersistent inherited;
	
private:
	int FStep;
	int FInitValue;
	void __fastcall SetInitValue(const int Value);
	
protected:
	int FCurValue;
	
public:
	__fastcall TAutoIncrementEh(void);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	__property int CurValue = {read=FCurValue, nodefault};
	int __fastcall Promote(void);
	void __fastcall Reset(void);
	
__published:
	__property int InitValue = {read=FInitValue, write=SetInitValue, default=-1};
	__property int Step = {read=FStep, write=FStep, default=-1};
public:
	#pragma option push -w-inl
	/* TPersistent.Destroy */ inline __fastcall virtual ~TAutoIncrementEh(void) { }
	#pragma option pop
	
};


class DELPHICLASS TUpdateErrorEh;
class PASCALIMPLEMENTATION TUpdateErrorEh : public System::TObject 
{
	typedef System::TObject inherited;
	
private:
	Sysutils::Exception* FException;
	
public:
	__fastcall TUpdateErrorEh(Sysutils::Exception* AException);
	__fastcall virtual ~TUpdateErrorEh(void);
	__property Sysutils::Exception* ExceptionObject = {read=FException};
};


#pragma option push -b-
enum TDataSetExprParserTypeEh { dsptFilterEh, dsptAggregateEh };
#pragma option pop

class DELPHICLASS TDataSetExprParserEh;
class DELPHICLASS TMemoryRecordEh;
class DELPHICLASS TRecordsViewEh;
class PASCALIMPLEMENTATION TDataSetExprParserEh : public System::TObject 
{
	typedef System::TObject inherited;
	
private:
	Db::TDataSet* FDataSet;
	DynamicArray<Byte >  FExprData;
	int FExprDataSize;
	TDataSetExprParserTypeEh FExprParserType;
	
public:
	__fastcall TDataSetExprParserEh(Db::TDataSet* ADataSet, TDataSetExprParserTypeEh ExprParserType);
	void __fastcall ParseExpression(AnsiString Expr);
	bool __fastcall IsCurRecordInFilter(TMemoryRecordEh* Rec);
	Variant __fastcall CalcAggregateValue(TRecordsViewEh* RecordsView);
	bool __fastcall HasData(void);
public:
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~TDataSetExprParserEh(void) { }
	#pragma option pop
	
};


class DELPHICLASS TMTDataFieldEh;
class DELPHICLASS TMTDataStructEh;
class DELPHICLASS TMemTableDataEh;
class DELPHICLASS TRecordsListEh;
class DELPHICLASS TMTIndexesEh;
class DELPHICLASS TMTIndexEh;
#pragma option push -b-
enum TRecordsListNotification { rlnRecAddingEh, rlnRecAddedEh, rlnRecChangingEh, rlnRecChangedEh, rlnRecDeletingEh, rlnRecDeletedEh, rlnListChangingEh, rlnListChangedEh, rlnRecMarkingForDelEh, rlnRecMarkedForDelEh };
#pragma option pop

class PASCALIMPLEMENTATION TMTIndexesEh : public Classes::TCollection 
{
	typedef Classes::TCollection inherited;
	
private:
	TRecordsListEh* FRecList;
	HIDESBASE TMTIndexEh* __fastcall GetItem(int Index);
	HIDESBASE void __fastcall SetItem(int Index, const TMTIndexEh* Value);
	
protected:
	virtual void __fastcall RecordMoved(TMemoryRecordEh* Item, int OldIndex, int NewIndex);
	void __fastcall RLDataEvent(TMemoryRecordEh* MemRec, int Index, TRecordsListNotification Action);
	
public:
	__fastcall TMTIndexesEh(TRecordsListEh* ARecList);
	__fastcall virtual ~TMTIndexesEh(void);
	HIDESBASE TMTIndexEh* __fastcall Add(void);
	TMTIndexEh* __fastcall GetIndexForFields(AnsiString Fields);
	__property TMTIndexEh* Items[int Index] = {read=GetItem, write=SetItem};
};


typedef TMetaClass* TMemoryRecordEhClass;

typedef DynamicArray<Variant >  TRecDataValues;

typedef int __fastcall (__closure *TCompareRecords)(TMemoryRecordEh* Rec1, TMemoryRecordEh* Rec2, System::TObject* ParamSort);

class PASCALIMPLEMENTATION TRecordsListEh : public Classes::TComponent 
{
	typedef Classes::TComponent inherited;
	
public:
	TMemoryRecordEh* operator[](int Index) { return Rec[Index]; }
	
private:
	bool FCachedUpdates;
	Contnrs::TObjectList* FDeletedList;
	Contnrs::TObjectList* FDeltaList;
	TMTIndexesEh* FIndexes;
	TMetaClass* FItemClass;
	TMemTableDataEh* FMemTableData;
	unsigned FNewHashCode;
	Contnrs::TObjectList* FRecList;
	int FUpdateCount;
	int __fastcall GeRecValCount(void);
	int __fastcall GetCount(void);
	TMTDataStructEh* __fastcall GetDataStruct(void);
	TMemoryRecordEh* __fastcall GetRec(int Index);
	Variant __fastcall GetValue(int RecNo, int ValNo);
	bool __fastcall IsEmpty(void);
	void __fastcall ReadData(Classes::TReader* Reader);
	void __fastcall SetCachedUpdates(const bool Value);
	void __fastcall SetRec(int Index, const TMemoryRecordEh* Value);
	void __fastcall SetValue(int RecNo, int ValNo, const Variant &Value);
	void __fastcall WriteData(Classes::TWriter* Writer);
	
protected:
	int __fastcall AddInsertRecord(TMemoryRecordEh* Rec, int Index, bool Append, bool Fetching);
	TMemoryRecordEh* __fastcall Delete(int Index);
	unsigned __fastcall NewHashCode(void);
	void __fastcall ApplyUpdateFor(TMemoryRecordEh* Rec, Db::TUpdateStatus UpdateStatus);
	void __fastcall ApplyUpdates(TMemTableDataEh* AMemTableData);
	virtual void __fastcall DefineProperties(Classes::TFiler* Filer);
	void __fastcall InitRecord(TRecDataValues RecValues);
	virtual void __fastcall Notify(TMemoryRecordEh* MemRec, int Index, TRecordsListNotification Action);
	virtual void __fastcall RecordMoved(TMemoryRecordEh* Item, int OldIndex, int NewIndex);
	void __fastcall ReIndexRecs(int FromIndex, int ToIndex);
	void __fastcall CheckForDestroyRecord(TMemoryRecordEh* Rec);
	void __fastcall FreeDeletedRecords(void);
	
public:
	__fastcall TRecordsListEh(TMemTableDataEh* AMemTableData);
	__fastcall virtual ~TRecordsListEh(void);
	int __fastcall AddRecord(TMemoryRecordEh* Rec);
	int __fastcall FetchRecord(TMemoryRecordEh* Rec);
	bool __fastcall HasCachedChanges(void);
	int __fastcall IndexOf(TMemoryRecordEh* Item);
	TMemoryRecordEh* __fastcall NewRecord(void);
	virtual void __fastcall BeginUpdate(void);
	void __fastcall CancelUpdates(void);
	void __fastcall CleanupChangedRecs(void);
	void __fastcall Clear(void);
	void __fastcall DeleteRecord(int Index);
	virtual void __fastcall EndUpdate(void);
	void __fastcall InsertRecord(int Index, TMemoryRecordEh* Rec);
	void __fastcall MergeChangeLog(void);
	void __fastcall Move(int CurIndex, int NewIndex);
	void __fastcall PersistDeleteRecord(int Index);
	void __fastcall PersistRemoveRecord(int Index);
	void __fastcall QuickSort(int L, int R, TCompareRecords Compare, System::TObject* ParamSort);
	void __fastcall RefreshRecord(int Index, TMemoryRecordEh* FromRec);
	void __fastcall RevertRecord(int Index);
	void __fastcall SetAutoIncValue(TMemoryRecordEh* Rec);
	void __fastcall SortData(TCompareRecords Compare, System::TObject* ParamSort);
	__property bool CachedUpdates = {read=FCachedUpdates, write=SetCachedUpdates, nodefault};
	__property int Count = {read=GetCount, nodefault};
	__property TMTDataStructEh* DataStruct = {read=GetDataStruct};
	__property Contnrs::TObjectList* DeltaList = {read=FDeltaList};
	__property TMTIndexesEh* Indexes = {read=FIndexes};
	__property TMemTableDataEh* MemTableData = {read=FMemTableData};
	__property TMemoryRecordEh* Rec[int Index] = {read=GetRec, write=SetRec/*, default*/};
	__property int RecValCount = {read=GeRecValCount, nodefault};
	__property Variant Value[int RecNo][int ValNo] = {read=GetValue, write=SetValue};
};


class DELPHICLASS TRecordsListNotificatorEh;
class PASCALIMPLEMENTATION TMemTableDataEh : public Classes::TComponent 
{
	typedef Classes::TComponent inherited;
	
private:
	TAutoIncrementEh* FAutoIncrement;
	TMTDataStructEh* FDataStruct;
	DynamicArray<int >  FIncFieldIndexes;
	TMTDataStructEh* FNewDataStruct;
	Contnrs::TObjectList* FNotificators;
	TRecordsListEh* FRecordsList;
	bool FRestructMode;
	bool __fastcall GetIsEmpty(void);
	void __fastcall AncestorNotFound(Classes::TReader* Reader, const AnsiString ComponentName, TMetaClass* ComponentClass, Classes::TComponent* &Component);
	void __fastcall CreateComponent(Classes::TReader* Reader, TMetaClass* ComponentClass, Classes::TComponent* &Component);
	void __fastcall ReadAutoIncCurValue(Classes::TReader* Reader);
	void __fastcall WriteAutoIncCurValue(Classes::TWriter* Writer);
	
protected:
	virtual TAutoIncrementEh* __fastcall GetAutoIncrement(void);
	virtual TMTDataStructEh* __fastcall GetDataStruct(void);
	virtual TRecordsListEh* __fastcall GetRecordsList(void);
	virtual void __fastcall AddNotificator(TRecordsListNotificatorEh* RecordsList);
	virtual void __fastcall ApplyUpdates(TMemTableDataEh* AMemTableData);
	virtual void __fastcall CheckInactive(void);
	virtual void __fastcall DefineProperties(Classes::TFiler* Filer);
	DYNAMIC void __fastcall GetChildren(Classes::TGetChildProc Proc, Classes::TComponent* Root);
	virtual void __fastcall Notify(TMemoryRecordEh* MemRec, int Index, TRecordsListNotification Action);
	virtual void __fastcall ReadState(Classes::TReader* Reader);
	virtual void __fastcall RecordMoved(TMemoryRecordEh* Item, int OldIndex, int NewIndex);
	void __fastcall RemoveNotificator(TRecordsListNotificatorEh* RecordsList);
	void __fastcall Restruct(void);
	virtual void __fastcall SetAutoIncrement(const TAutoIncrementEh* Value);
	virtual void __fastcall SetAutoIncValue(TMemoryRecordEh* Rec);
	virtual void __fastcall StructChanged(void);
	
public:
	__fastcall virtual TMemTableDataEh(Classes::TComponent* AOwner);
	__fastcall virtual ~TMemTableDataEh(void);
	virtual TMTDataStructEh* __fastcall BeginRestruct(void);
	virtual int __fastcall FetchRecords(int Count);
	virtual void __fastcall CancelRestruct(void);
	virtual void __fastcall CommitRestruct(void);
	virtual void __fastcall DestroyTable(void);
	__property TAutoIncrementEh* AutoIncrement = {read=GetAutoIncrement, write=SetAutoIncrement};
	__property TMTDataStructEh* DataStruct = {read=GetDataStruct};
	__property bool IsEmpty = {read=GetIsEmpty, nodefault};
	__property TRecordsListEh* RecordsList = {read=GetRecordsList};
};


typedef TMetaClass* TMTDataFieldClassEh;

class PASCALIMPLEMENTATION TMTDataStructEh : public Classes::TComponent 
{
	typedef Classes::TComponent inherited;
	
public:
	TMTDataFieldEh* operator[](int Index) { return DataFields[Index]; }
	
private:
	Contnrs::TObjectList* FList;
	TMemTableDataEh* FMemTableData;
	__int64 FNextFieldId;
	int __fastcall GetCount(void);
	TMTDataFieldEh* __fastcall GetDataField(int Index);
	
protected:
	DYNAMIC Classes::TComponent* __fastcall GetChildOwner(void);
	DYNAMIC void __fastcall GetChildren(Classes::TGetChildProc Proc, Classes::TComponent* Root);
	
public:
	__fastcall TMTDataStructEh(TMemTableDataEh* AMemTableData);
	__fastcall virtual ~TMTDataStructEh(void);
	TMTDataFieldEh* __fastcall CreateField(TMetaClass* FieldClass);
	TMTDataFieldEh* __fastcall FieldByName(const AnsiString FieldName);
	int __fastcall FieldIndex(const AnsiString FieldName);
	TIntArray __fastcall FieldsIndex(const AnsiString FieldNames);
	TMTDataFieldEh* __fastcall FindField(const AnsiString FieldName);
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	void __fastcall BuildFieldDefsFromStruct(Db::TFieldDefs* FieldDefs);
	void __fastcall BuildStructFromFieldDefs(Db::TFieldDefs* FieldDefs);
	void __fastcall BuildStructFromFields(Db::TFields* Fields);
	void __fastcall CheckFieldName(const AnsiString FieldName);
	void __fastcall Clear(void);
	void __fastcall GetFieldList(Contnrs::TObjectList* List, const AnsiString FieldNames);
	void __fastcall InsertField(TMTDataFieldEh* Field);
	void __fastcall RemoveField(TMTDataFieldEh* Field);
	__property int Count = {read=GetCount, nodefault};
	__property TMTDataFieldEh* DataFields[int Index] = {read=GetDataField/*, default*/};
	__property TMemTableDataEh* MemTableData = {read=FMemTableData};
};


class PASCALIMPLEMENTATION TMTDataFieldEh : public Classes::TComponent 
{
	typedef Classes::TComponent inherited;
	
private:
	Classes::TAlignment FAlignment;
	bool FAutoIncrement;
	TMTDataStructEh* FDataStruct;
	AnsiString FDefaultExpression;
	AnsiString FDisplayLabel;
	int FDisplayWidth;
	AnsiString FEditMask;
	__int64 FFieldId;
	AnsiString FFieldName;
	bool FReadOnly;
	bool FRequired;
	int FSize;
	bool FVisible;
	void __fastcall SetDataStruct(const TMTDataStructEh* Value);