rm_stbase.hpp

这是一个功能强大

	/* Exception.CreateFmtHelp */ inline __fastcall EStExprError(const AnsiString Msg, System::TVarRec const * Args, const int Args_Size, int AHelpContext) : EStException(Msg, Args, Args_Size, AHelpContext) { }
	#pragma option pop
	#pragma option push -w-inl
	/* Exception.CreateResHelp */ inline __fastcall EStExprError(int Ident, int AHelpContext)/* overload */ : EStException(Ident, AHelpContext) { }
	#pragma option pop
	#pragma option push -w-inl
	/* Exception.CreateResFmtHelp */ inline __fastcall EStExprError(System::PResStringRec ResStringRec, System::TVarRec const * Args, const int Args_Size, int AHelpContext)/* overload */ : EStException(ResStringRec, Args, Args_Size, AHelpContext) { }
	#pragma option pop
	
public:
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~EStExprError(void) { }
	#pragma option pop
	
};


typedef char TSmallArray[260];

typedef Byte BTable[256];

typedef double *PDouble;

typedef double TDoubleArray[268435455];

typedef TDoubleArray *PDoubleArray;

typedef int TIntArray[536870911];

typedef TIntArray *PIntArray;

typedef Extended TStFloat;

class DELPHICLASS TStNode;
class PASCALIMPLEMENTATION TStNode : public Classes::TPersistent 
{
	typedef Classes::TPersistent inherited;
	
protected:
	void *FData;
	
public:
	__fastcall virtual TStNode(void * AData);
	__property void * Data = {read=FData, write=FData};
public:
	#pragma option push -w-inl
	/* TPersistent.Destroy */ inline __fastcall virtual ~TStNode(void) { }
	#pragma option pop
	
};


typedef TMetaClass* TStNodeClass;

typedef int __fastcall (*TCompareFunc)(void * Data1, void * Data2);

typedef void __fastcall (__closure *TStCompareEvent)(System::TObject* Sender, void * Data1, void * Data2, int &Compare);

typedef void __fastcall (*TDisposeDataProc)(void * Data);

typedef void __fastcall (__closure *TStDisposeDataEvent)(System::TObject* Sender, void * Data);

typedef void * __fastcall (*TLoadDataFunc)(Classes::TReader* Reader);

typedef void __fastcall (__closure *TStLoadDataEvent)(System::TObject* Sender, Classes::TReader* Reader, void * &Data);

typedef void __fastcall (*TStoreDataProc)(Classes::TWriter* Writer, void * Data);

typedef void __fastcall (__closure *TStStoreDataEvent)(System::TObject* Sender, Classes::TWriter* Writer, void * Data);

typedef int __fastcall (*TStringCompareFunc)(const AnsiString String1, const AnsiString String2);

typedef void __fastcall (__closure *TStStringCompareEvent)(System::TObject* Sender, const AnsiString String1, const AnsiString String2, int &Compare);

typedef int __fastcall (*TUntypedCompareFunc)(const void *El1, const void *El2);

typedef void __fastcall (__closure *TStUntypedCompareEvent)(System::TObject* Sender, const void *El1, const void *El2, int &Compare);

class DELPHICLASS TStContainer;
typedef bool __fastcall (*TIterateFunc)(TStContainer* Container, TStNode* Node, void * OtherData);

typedef bool __fastcall (*TIteratePointerFunc)(TStContainer* Container, void * Data, void * OtherData);

typedef bool __fastcall (*TIterateUntypedFunc)(TStContainer* Container, void *Data, void * OtherData);

class PASCALIMPLEMENTATION TStContainer : public Classes::TPersistent 
{
	typedef Classes::TPersistent inherited;
	
protected:
	TCompareFunc FCompare;
	TDisposeDataProc FDisposeData;
	TLoadDataFunc FLoadData;
	TStoreDataProc FStoreData;
	TStCompareEvent FOnCompare;
	TStDisposeDataEvent FOnDisposeData;
	TStLoadDataEvent FOnLoadData;
	TStStoreDataEvent FOnStoreData;
	_RTL_CRITICAL_SECTION conThreadSafe;
	void __fastcall SetCompare(TCompareFunc C);
	void __fastcall SetDisposeData(TDisposeDataProc D);
	void __fastcall SetLoadData(TLoadDataFunc L);
	void __fastcall SetStoreData(TStoreDataProc S);
	TMetaClass* conNodeClass;
	int conNodeProt;
	int FCount;
	bool __fastcall AssignPointers(Classes::TPersistent* Source, TIteratePointerFunc AssignData);
	bool __fastcall AssignUntypedVars(Classes::TPersistent* Source, TIterateUntypedFunc AssignData);
	virtual void __fastcall ForEachPointer(TIteratePointerFunc Action, void * OtherData);
	virtual void __fastcall ForEachUntypedVar(TIterateUntypedFunc Action, void * OtherData);
	virtual void __fastcall GetArraySizes(unsigned &RowCount, unsigned &ColCount, unsigned &ElSize);
	virtual void __fastcall SetArraySizes(unsigned RowCount, unsigned ColCount, unsigned ElSize);
	virtual bool __fastcall StoresPointers(void);
	virtual bool __fastcall StoresUntypedVars(void);
	void __fastcall IncNodeProtection(void);
	void __fastcall DecNodeProtection(void);
	void __fastcall EnterCS(void);
	void __fastcall LeaveCS(void);
	
public:
	__fastcall TStContainer(TMetaClass* NodeClass, int Dummy);
	__fastcall virtual ~TStContainer(void);
	virtual void __fastcall Clear(void) = 0 ;
	void __fastcall DisposeNodeData(TStNode* P);
	virtual int __fastcall DoCompare(void * Data1, void * Data2);
	virtual void __fastcall DoDisposeData(void * Data);
	virtual void * __fastcall DoLoadData(Classes::TReader* Reader);
	virtual void __fastcall DoStoreData(Classes::TWriter* Writer, void * Data);
	DYNAMIC void __fastcall LoadFromFile(const AnsiString FileName);
	DYNAMIC void __fastcall LoadFromStream(Classes::TStream* S) = 0 ;
	DYNAMIC void __fastcall StoreToFile(const AnsiString FileName);
	DYNAMIC void __fastcall StoreToStream(Classes::TStream* S) = 0 ;
	__property int Count = {read=FCount, nodefault};
	__property TCompareFunc Compare = {read=FCompare, write=SetCompare};
	__property TDisposeDataProc DisposeData = {read=FDisposeData, write=SetDisposeData};
	__property TLoadDataFunc LoadData = {read=FLoadData, write=SetLoadData};
	__property TStoreDataProc StoreData = {read=FStoreData, write=SetStoreData};
	__property TStCompareEvent OnCompare = {read=FOnCompare, write=FOnCompare};
	__property TStDisposeDataEvent OnDisposeData = {read=FOnDisposeData, write=FOnDisposeData};
	__property TStLoadDataEvent OnLoadData = {read=FOnLoadData, write=FOnLoadData};
	__property TStStoreDataEvent OnStoreData = {read=FOnStoreData, write=FOnStoreData};
public:
	#pragma option push -w-inl
	/* TObject.Create */ inline __fastcall TStContainer(void) : Classes::TPersistent() { }
	#pragma option pop
	
};


struct TAssignRowData
{
	
public:
	int RowNum;
	Byte Data[1];
} ;

class DELPHICLASS TStComponent;
class PASCALIMPLEMENTATION TStComponent : public Classes::TComponent 
{
	typedef Classes::TComponent inherited;
	
protected:
	AnsiString __fastcall GetVersion();
	void __fastcall SetVersion(const AnsiString Value);
	
__published:
	__property AnsiString Version = {read=GetVersion, write=SetVersion, stored=false};
public:
	#pragma option push -w-inl
	/* TComponent.Create */ inline __fastcall virtual TStComponent(Classes::TComponent* AOwner) : Classes::TComponent(AOwner) { }
	#pragma option pop
	#pragma option push -w-inl
	/* TComponent.Destroy */ inline __fastcall virtual ~TStComponent(void) { }
	#pragma option pop
	
};


class DELPHICLASS TStBaseEdit;
class PASCALIMPLEMENTATION TStBaseEdit : public Stdctrls::TEdit 
{
	typedef Stdctrls::TEdit inherited;
	
protected:
	AnsiString __fastcall GetVersion();
	void __fastcall SetVersion(const AnsiString Value);
	
__published:
	__property AnsiString Version = {read=GetVersion, write=SetVersion, stored=false};
public:
	#pragma option push -w-inl
	/* TCustomEdit.Create */ inline __fastcall virtual TStBaseEdit(Classes::TComponent* AOwner) : Stdctrls::TEdit(AOwner) { }
	#pragma option pop
	
public:
	#pragma option push -w-inl
	/* TWinControl.CreateParented */ inline __fastcall TStBaseEdit(HWND ParentWindow) : Stdctrls::TEdit(ParentWindow) { }
	#pragma option pop
	#pragma option push -w-inl
	/* TWinControl.Destroy */ inline __fastcall virtual ~TStBaseEdit(void) { }
	#pragma option pop
	
};


//-- var, const, procedure ---------------------------------------------------
static const int StMaxBlockSize = 2147483647;
static const Word StMaxFileLen = 0x104;
static const Shortint StRLEMaxCount = 0x7f;
static const Byte StRLERunMode = 0x80;
extern PACKAGE Byte StLetterValues[26];
extern PACKAGE char StHexDigits[16];
extern PACKAGE Set<char, 0, 255>  DosDelimSet;
extern PACKAGE WideString StHexDigitsW;
extern PACKAGE WideString DosDelimSetW;
extern PACKAGE unsigned WMCOPYID;
extern PACKAGE void __fastcall RaiseStError(TMetaClass* ExceptionClass, int Code);
extern PACKAGE void __fastcall RaiseStWin32Error(TMetaClass* ExceptionClass, int Code);
extern PACKAGE void __fastcall RaiseStWin32ErrorEx(TMetaClass* ExceptionClass, int Code, AnsiString Info);
extern PACKAGE bool __fastcall DestroyNode(TStContainer* Container, TStNode* Node, void * OtherData);
extern PACKAGE void __fastcall HugeFillChar(void *Dest, int Count, Byte Value);
extern PACKAGE int __fastcall HugeCompressRLE(const void *InBuffer, int InLen, void *OutBuffer);
extern PACKAGE int __fastcall HugeDecompressRLE(const void *InBuffer, int InLen, void *OutBuffer, int OutLen);
extern PACKAGE void __fastcall HugeFillStruc(void *Dest, int Count, const void *Value, unsigned ValSize);
extern PACKAGE void __fastcall HugeFreeMem(void * &P, int Size);
extern PACKAGE void __fastcall HugeGetMem(void * &P, int Size);
extern PACKAGE void __fastcall HugeMove(const void *Src, void *Dest, int Count);
extern PACKAGE char __fastcall Upcase(char C);
extern PACKAGE char __fastcall LoCase(char C);
extern PACKAGE bool __fastcall ProductOverflow(int A, int B);
extern PACKAGE unsigned __fastcall CompareLetterSets(int Set1, int Set2);
extern PACKAGE int __fastcall CompStruct(const void *S1, const void *S2, unsigned Size);
extern PACKAGE bool __fastcall Search(const void *Buffer, unsigned BufLength, const void *Match, unsigned MatLength, unsigned &Pos);
extern PACKAGE bool __fastcall SearchUC(const void *Buffer, unsigned BufLength, const void *Match, unsigned MatLength, unsigned &Pos);
extern PACKAGE void __fastcall ValLongInt( System::ShortString &S, int &LI, int &ErrorCode);
extern PACKAGE void __fastcall ValSmallint(const System::ShortString &S, short &SI, int &ErrorCode);
extern PACKAGE void __fastcall ValWord(const System::ShortString &S, Word &Wd, int &ErrorCode);
extern PACKAGE bool __fastcall IsOrInheritsFrom(TMetaClass* Root, TMetaClass* Candidate);
extern PACKAGE void __fastcall RaiseContainerError(int Code);
extern PACKAGE void __fastcall RaiseContainerErrorFmt(int Code, System::TVarRec * Data, const int Data_Size);

}	/* namespace Rm_stbase */
using namespace Rm_stbase;
#pragma pack(pop)
#pragma option pop

#pragma delphiheader end.
//-- end unit ----------------------------------------------------------------
#endif	// Rm_stbase