memtabledataeh.hpp

最新的 DBGRIDEH4.0

	__property DisplayLabel ;
	__property DisplayWidth ;
	__property TVariantDataFieldTypesEh VariantDataType = {read=FVariantDataType, write=FVariantDataType, nodefault};
	__property Required ;
	__property Visible ;
public:
	#pragma option push -w-inl
	/* TMTDataFieldEh.Create */ inline __fastcall virtual TMTVariantDataFieldEh(Classes::TComponent* AOwner) : TMTDataFieldEh(AOwner) { }
	#pragma option pop
	#pragma option push -w-inl
	/* TMTDataFieldEh.Destroy */ inline __fastcall virtual ~TMTVariantDataFieldEh(void) { }
	#pragma option pop
	
};


class DELPHICLASS TMTRefObjectFieldEh;
class PASCALIMPLEMENTATION TMTRefObjectFieldEh : public TMTDataFieldEh 
{
	typedef TMTDataFieldEh inherited;
	
protected:
	virtual Db::TFieldType __fastcall GetDataType(void);
	
public:
	virtual bool __fastcall CanDinaSize(void);
	virtual void __fastcall AssignDataType(Db::TFieldType FieldType);
	
__published:
	__property Alignment ;
	__property DisplayLabel ;
	__property DisplayWidth ;
	__property Required ;
	__property Visible ;
public:
	#pragma option push -w-inl
	/* TMTDataFieldEh.Create */ inline __fastcall virtual TMTRefObjectFieldEh(Classes::TComponent* AOwner) : TMTDataFieldEh(AOwner) { }
	#pragma option pop
	#pragma option push -w-inl
	/* TMTDataFieldEh.Destroy */ inline __fastcall virtual ~TMTRefObjectFieldEh(void) { }
	#pragma option pop
	
};


#pragma option push -b-
enum TSQLTimeStampDataFieldTypesEh { fdtTimeStampEh, fdtOraTimeStampEh };
#pragma option pop

class DELPHICLASS TMTSQLTimeStampDataFieldEh;
class PASCALIMPLEMENTATION TMTSQLTimeStampDataFieldEh : public TMTDataFieldEh 
{
	typedef TMTDataFieldEh inherited;
	
private:
	AnsiString FDisplayFormat;
	TSQLTimeStampDataFieldTypesEh FSQLTimeStampDataFieldType;
	
protected:
	virtual Db::TFieldType __fastcall GetDataType(void);
	
public:
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	virtual void __fastcall AssignDataType(Db::TFieldType FieldType);
	virtual void __fastcall AssignProps(Db::TField* Field);
	
__published:
	__property TSQLTimeStampDataFieldTypesEh SQLTimeStampDataFieldType = {read=FSQLTimeStampDataFieldType, write=FSQLTimeStampDataFieldType, nodefault};
	__property Alignment ;
	__property DefaultExpression ;
	__property DisplayLabel ;
	__property DisplayWidth ;
	__property EditMask ;
	__property Required ;
	__property Visible ;
	__property AnsiString DisplayFormat = {read=FDisplayFormat, write=FDisplayFormat};
public:
	#pragma option push -w-inl
	/* TMTDataFieldEh.Create */ inline __fastcall virtual TMTSQLTimeStampDataFieldEh(Classes::TComponent* AOwner) : TMTDataFieldEh(AOwner) { }
	#pragma option pop
	#pragma option push -w-inl
	/* TMTDataFieldEh.Destroy */ inline __fastcall virtual ~TMTSQLTimeStampDataFieldEh(void) { }
	#pragma option pop
	
};


typedef TRecDataValues *PRecValues;

typedef Variant TMemBlobData;

typedef void __fastcall (__closure *TRecordsListNotificatorDataEventEh)(TMemoryRecordEh* MemRec, int Index, TRecordsListNotification Action);

#pragma option push -b-
enum TDataValueVersionEh { dvvOldValueEh, dvvCurValueEh, dvvEditValueEh, dvvValueEh, dvvOldestValue, dvvRefreshValue };
#pragma option pop

#pragma option push -b-
enum TRecordEditStateEh { resBrowseEh, resEditEh, resInsertEh };
#pragma option pop

class PASCALIMPLEMENTATION TMemoryRecordEh : public Classes::TPersistent 
{
	typedef Classes::TPersistent inherited;
	
private:
	DynamicArray<Variant >  FData;
	bool FEditChanged;
	TRecordEditStateEh FEditState;
	unsigned FHashCode;
	int FIndex;
	DynamicArray<Variant >  FOldData;
	TRecordsListEh* FRecordsList;
	DynamicArray<Variant >  FTmpOldRecValue;
	TUpdateErrorEh* FUpdateError;
	int FUpdateIndex;
	Db::TUpdateStatus FUpdateStatus;
	bool __fastcall GetAttached(void);
	Variant __fastcall GetDataIndexValues(const TIntArray FieldIndexes, TDataValueVersionEh DataValueVersion);
	TMTDataStructEh* __fastcall GetDataStruct(void);
	Variant __fastcall GetDataValue(const int FieldIndex, TDataValueVersionEh DataValueVersion);
	Variant __fastcall GetDataValues(const AnsiString FieldNames, TDataValueVersionEh DataValueVersion);
	int __fastcall GetIndex(void);
	void __fastcall SetDataIndexValues(const TIntArray FieldIndexes, TDataValueVersionEh DataValueVersion, const Variant &VarValue);
	void __fastcall SetDataValue(const int FieldIndex, TDataValueVersionEh DataValueVersion, const Variant &Value);
	void __fastcall SetDataValues(const AnsiString FieldNames, TDataValueVersionEh DataValueVersion, const Variant &VarValue);
	void __fastcall SetUpdateStatus(const Db::TUpdateStatus Value);
	
protected:
	void __fastcall ReadData(Classes::TReader* Reader);
	void __fastcall SetIndex(int Value);
	void __fastcall WriteData(Classes::TWriter* Writer);
	__property TRecDataValues Data = {read=FData};
	
public:
	__fastcall TMemoryRecordEh(void);
	__fastcall virtual ~TMemoryRecordEh(void);
	TRecordEditStateEh __fastcall EditState(void);
	void __fastcall Cancel(void);
	void __fastcall Edit(void);
	void __fastcall MergeChanges(void);
	void __fastcall Post(void);
	void __fastcall RefreshRecord(TMemoryRecordEh* Rec);
	void __fastcall RevertRecord(void);
	__property int Index = {read=GetIndex, nodefault};
	__property bool Attached = {read=GetAttached, nodefault};
	__property Variant DataValues[AnsiString FieldNames][TDataValueVersionEh DataValueVersion] = {read=GetDataValues, write=SetDataValues};
	__property Variant DataIndexValues[TIntArray FieldIndexes][TDataValueVersionEh DataValueVersion] = {read=GetDataIndexValues, write=SetDataIndexValues};
	__property Variant Value[int FieldIndex][TDataValueVersionEh DataValueVersion] = {read=GetDataValue, write=SetDataValue};
	__property TMTDataStructEh* DataStruct = {read=GetDataStruct};
	__property unsigned HashCode = {read=FHashCode, nodefault};
	__property TRecDataValues OldData = {read=FOldData};
	__property TRecordsListEh* RecordsList = {read=FRecordsList};
	__property TUpdateErrorEh* UpdateError = {read=FUpdateError, write=FUpdateError};
	__property int UpdateIndex = {read=FUpdateIndex, write=FUpdateIndex, nodefault};
	__property Db::TUpdateStatus UpdateStatus = {read=FUpdateStatus, write=SetUpdateStatus, nodefault};
};


typedef int __fastcall (__closure *TRecordsListFetchRecordsEventEh)(int Count);

typedef void __fastcall (__closure *TRecordsListApplyUpdatesEventEh)(TMemTableDataEh* AMemTableData);

typedef void __fastcall (__closure *TRecordsListRecordMovedEventEh)(TMemoryRecordEh* Item, int OldIndex, int NewIndex);

class PASCALIMPLEMENTATION TRecordsListNotificatorEh : public Classes::TComponent 
{
	typedef Classes::TComponent inherited;
	
private:
	TMemTableDataEh* FMemTableData;
	TRecordsListNotificatorDataEventEh FOnAfterDataEvent;
	TRecordsListApplyUpdatesEventEh FOnApplyUpdates;
	TRecordsListNotificatorDataEventEh FOnDataEvent;
	TRecordsListFetchRecordsEventEh FOnFetchRecords;
	TRecordsListRecordMovedEventEh FOnRecordMoved;
	Classes::TComponent* FDataObject;
	void __fastcall SetMemTableData(const TMemTableDataEh* Value);
	void __fastcall SetDataObject(const Classes::TComponent* Value);
	
protected:
	virtual int __fastcall FetchRecords(int Count);
	virtual void __fastcall AfterDataEvent(TMemoryRecordEh* MemRec, int Index, TRecordsListNotification Action);
	void __fastcall ApplyUpdates(TMemTableDataEh* AMemTableData);
	virtual void __fastcall DataEvent(TMemoryRecordEh* MemRec, int Index, TRecordsListNotification Action);
	virtual void __fastcall Notification(Classes::TComponent* AComponent, Classes::TOperation Operation);
	virtual void __fastcall RecordAdded(TMemoryRecordEh* MemRec, int Index);
	virtual void __fastcall RecordChanged(TMemoryRecordEh* MemRec, int Index);
	virtual void __fastcall RecordDeleted(TMemoryRecordEh* MemRec, int Index);
	virtual void __fastcall RecordListChanged(void);
	virtual void __fastcall RecordMoved(TMemoryRecordEh* Item, int OldIndex, int NewIndex);
	
public:
	__fastcall virtual TRecordsListNotificatorEh(Classes::TComponent* AOwner);
	__fastcall virtual ~TRecordsListNotificatorEh(void);
	__property Classes::TComponent* DataObject = {read=FDataObject, write=SetDataObject};
	__property TRecordsListNotificatorDataEventEh OnAfterDataEvent = {read=FOnAfterDataEvent, write=FOnAfterDataEvent};
	__property TRecordsListApplyUpdatesEventEh OnApplyUpdates = {read=FOnApplyUpdates, write=FOnApplyUpdates};
	__property TRecordsListNotificatorDataEventEh OnDataEvent = {read=FOnDataEvent, write=FOnDataEvent};
	__property TRecordsListFetchRecordsEventEh OnFetchRecords = {read=FOnFetchRecords, write=FOnFetchRecords};
	__property TRecordsListRecordMovedEventEh OnRecordMoved = {read=FOnRecordMoved, write=FOnRecordMoved};
};


class DELPHICLASS TMemTableDataShadowEh;
class PASCALIMPLEMENTATION TMemTableDataShadowEh : public TMemTableDataEh 
{
	typedef TMemTableDataEh inherited;
	
private:
	TMemTableDataEh* FMasterTable;
	
protected:
	virtual TMTDataStructEh* __fastcall GetDataStruct(void);
	virtual void __fastcall SetAutoIncValue(TMemoryRecordEh* Rec);
	
public:
	__fastcall virtual TMemTableDataShadowEh(TMemTableDataEh* AMasterTable);
	__fastcall virtual ~TMemTableDataShadowEh(void);
};


class DELPHICLASS TIndexItemEh;
class PASCALIMPLEMENTATION TIndexItemEh : public System::TObject 
{
	typedef System::TObject inherited;
	
public:
	Variant Value;
	int RecIndex;
	__fastcall TIndexItemEh(const Variant &AValue, int ARecIndex);
public:
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~TIndexItemEh(void) { }
	#pragma option pop
	
};


typedef Exception EUnicalKeyViolationEh;
;

class PASCALIMPLEMENTATION TMTIndexEh : public Classes::TCollectionItem 
{
	typedef Classes::TCollectionItem inherited;
	
private:
	bool FActive;
	AnsiString FFields;
	Variant FOldValue;
	bool FPrimary;
	Contnrs::TObjectList* FRecList;
	TRecordsListEh* FRecordsList;
	bool FUnical;
	TIndexItemEh* __fastcall GetItems(int Index);
	Variant __fastcall GetKeyValue(int Index);
	void __fastcall SetActive(const bool Value);
	void __fastcall SetFields(const AnsiString Value);
	void __fastcall SetKeyValue(int Index, const Variant &Value);
	void __fastcall SetPrimary(const bool Value);
	void __fastcall SetUnical(const bool Value);
	
protected:
	__property Contnrs::TObjectList* RecList = {read=FRecList};
	void __fastcall RLDataEvent(TMemoryRecordEh* MemRec, int Index, TRecordsListNotification Action);
	virtual void __fastcall RecordMoved(TMemoryRecordEh* Item, int OldIndex, int NewIndex);
	virtual void __fastcall InsertIndexItemForValue(int InitIndex, const Variant &Value, TIndexItemEh* IndexItem);
	
public:
	__fastcall virtual TMTIndexEh(Classes::TCollection* Collection);
	__fastcall TMTIndexEh(TRecordsListEh* ARecordsList);
	__fastcall virtual ~TMTIndexEh(void);
	int __fastcall Count(void);
	bool __fastcall FindKeyValueIndex(const Variant &Value, int &Index);
	bool __fastcall FindRecordIndexByKey(const Variant &Value, int &Index);
	TRecordsListEh* __fastcall RecordsList(void);
	void __fastcall ClearIndex(void);
	void __fastcall FillMatchedKeyList(const Variant &Value, Contnrs::TObjectList* List);
	void __fastcall FillMatchedRecsList(const Variant &Value, Contnrs::TObjectList* List);
	void __fastcall QuickSort(int L, int R);
	void __fastcall RebuildIndex(void);
	__property bool Active = {read=FActive, write=SetActive, default=0};
	__property AnsiString Fields = {read=FFields, write=SetFields};
	__property TIndexItemEh* Item[int Index] = {read=GetItems};
	__property Variant KeyValue[int Index] = {read=GetKeyValue};
	__property bool Primary = {read=FPrimary, write=SetPrimary, default=0};
	__property bool Unical = {read=FUnical, write=SetUnical, default=0};
};


class DELPHICLASS TMTAggregateEh;
class DELPHICLASS TMTAggregatesEh;
class PASCALIMPLEMENTATION TMTAggregateEh : public Classes::TCollectionItem 
{
	typedef Classes::TCollectionItem inherited;
	
private:
	bool FActive;
	TDataSetExprParserEh* FAggrExpr;
	Db::TDataSet* FDataSet;
	Db::TFieldType FDataType;
	AnsiString FExpression;
	bool FInUse;
	Variant FValue;
	void __fastcall SetActive(bool Value);
	void __fastcall SetExpression(const AnsiString Text);
	
public:
	__fastcall TMTAggregateEh(TMTAggregatesEh* Aggregates, Db::TDataSet* ADataSet)/* overload */;
	__fastcall virtual ~TMTAggregateEh(void);
	TMTAggregatesEh* __fastcall Aggregates(void);
	virtual AnsiString __fastcall GetDisplayName();
	Variant __fastcall Value();
	virtual void __fastcall Assign(Classes::TPersistent* Source);
	void __fastcall Recalc(void);
	void __fastcall Reset(void);
	__property Db::TDataSet* DataSet = {read=FDataSet};
	__property Db::TFieldType DataType = {read=FDataType, nodefault};
	
__published:
	__property bool Active = {read=FActive, write=SetActive, default=0};
	__property AnsiString Expression = {read=FExpression, write=SetExpression};
};


class PASCALIMPLEMENTATION TMTAggregatesEh : public Classes::TCollection 
{
	typedef Classes::TCollection inherited;
	
public:
	TMTAggregateEh* operator[](int Index) { return Items[Index]; }
	
private:
	bool FActive;
	Classes::TPersistent* FOwner;
	HIDESBASE TMTAggregateEh* __fastcall GetItem(int Index);
	void __fastcall SetActive(const bool Value);
	HIDESBASE void __fastcall SetItem(int Index, TMTAggregateEh* Value);
	
protected:
	DYNAMIC Classes::TPersistent* __fastcall GetOwner(void);
	
public:
	__fastcall TMTAggregatesEh(Classes::TPersistent* Owner);