connect.hpp

boomerang library 5.11 internet ed

// Borland C++ Builder
// Copyright (c) 1995, 2005 by Borland Software Corporation
// All rights reserved

// (DO NOT EDIT: machine generated header) 'Connect.pas' rev: 10.00

#ifndef ConnectHPP
#define ConnectHPP

#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 <Classes.hpp>	// Pascal unit
#include <Sysutils.hpp>	// Pascal unit
#include <Windows.hpp>	// Pascal unit
#include <Syncobjs.hpp>	// Pascal unit

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

namespace Connect
{
//-- type declarations -------------------------------------------------------
typedef AnsiString TString;

typedef char TChar;

class DELPHICLASS TConnection;
typedef void __fastcall (__closure *TConnectionNotifyEvent)(TConnection* DataSet);

class PASCALIMPLEMENTATION TConnection : public Classes::TComponent 
{
	typedef Classes::TComponent inherited;
	
private:
	bool FActive;
	bool FStreamedActive;
	TConnectionNotifyEvent FBeforeOpen;
	TConnectionNotifyEvent FBeforeClose;
	TConnectionNotifyEvent FAfterOpen;
	TConnectionNotifyEvent FAfterClose;
	void __fastcall SetActive(bool aEnable);
	
protected:
	virtual void __fastcall OpenConn(void) = 0 ;
	virtual void __fastcall CloseConn(void) = 0 ;
	virtual void __fastcall DoBeforeOpen(void);
	virtual void __fastcall DoBeforeClose(void);
	virtual void __fastcall DoAfterOpen(void);
	virtual void __fastcall DoAfterClose(void);
	virtual void __fastcall Loaded(void);
	void __fastcall CheckInactive(void);
	void __fastcall CheckActive(void);
	
public:
	__fastcall virtual ~TConnection(void);
	void __fastcall Open(void);
	void __fastcall Close(void);
	
__published:
	__property bool Active = {read=FActive, write=SetActive, nodefault};
	__property TConnectionNotifyEvent BeforeOpen = {read=FBeforeOpen, write=FBeforeOpen};
	__property TConnectionNotifyEvent BeforeClose = {read=FBeforeClose, write=FBeforeClose};
	__property TConnectionNotifyEvent AfterOpen = {read=FAfterOpen, write=FAfterOpen};
	__property TConnectionNotifyEvent AfterClose = {read=FAfterClose, write=FAfterClose};
public:
	#pragma option push -w-inl
	/* TComponent.Create */ inline __fastcall virtual TConnection(Classes::TComponent* AOwner) : Classes::TComponent(AOwner) { }
	#pragma option pop
	
};


typedef void __fastcall (__closure *TAcceptChannelEvent)(Classes::TComponent* Sender, const AnsiString aLogName, Byte aChannel, bool &aAccept);

typedef void __fastcall (__closure *TOnExceptionEvent)(Classes::TComponent* Sender, Sysutils::Exception* E, const AnsiString aName, Byte aChannel, const AnsiString aOriginalMessage);

class DELPHICLASS TLogger;
class PASCALIMPLEMENTATION TLogger : public TConnection 
{
	typedef TConnection inherited;
	
private:
	Syncobjs::TCriticalSection* FCriticalSection;
	Syncobjs::TCriticalSection* FCriticalSection2;
	bool fAutoOpen;
	TOnExceptionEvent fOnException;
	void __fastcall SetAutoOpen(bool aValue);
	
protected:
	TAcceptChannelEvent FAcceptChannel;
	virtual void __fastcall DoLog(const AnsiString aText) = 0 ;
	virtual void __fastcall DoLog2(const AnsiString aName, Byte aChannel, const AnsiString aText);
	virtual AnsiString __fastcall PreformatText(const AnsiString aName, Byte aChannel, AnsiString aText) = 0 ;
	virtual void __fastcall DoOnException(Sysutils::Exception* E, const AnsiString aName, Byte aChannel, const AnsiString aOriginalMessage);
	
public:
	__property Syncobjs::TCriticalSection* CriticalSection = {read=FCriticalSection};
	__property Syncobjs::TCriticalSection* CriticalSection2 = {read=FCriticalSection2, write=FCriticalSection2};
	__fastcall virtual TLogger(Classes::TComponent* aOwner);
	__fastcall virtual ~TLogger(void);
	void __fastcall Log(const AnsiString aName, Byte aChannel, AnsiString aText);
	
__published:
	__property TAcceptChannelEvent AcceptChannel = {read=FAcceptChannel, write=FAcceptChannel};
	__property bool AutoOpen = {read=fAutoOpen, write=SetAutoOpen, nodefault};
	__property TOnExceptionEvent OnException = {read=fOnException, write=fOnException};
};


#pragma option push -b-
enum TLogFormatFlag { lfInsertName, lfInsertChannel, lfDivideNames, lfDivideChannels, lfDivideStream, lfHexadecimal, lfStamp, lfAutoCR };
#pragma option pop

typedef Set<TLogFormatFlag, lfInsertName, lfAutoCR>  TLogFormatFlags;

typedef void __fastcall (__closure *TOnDivideStream)(Classes::TComponent* Sender, const AnsiString aLogName, Byte aChannel, AnsiString &aText, int &I, bool &aDivide);

class DELPHICLASS TStreamLogger;
class PASCALIMPLEMENTATION TStreamLogger : public TLogger 
{
	typedef TLogger inherited;
	
private:
	Classes::TStream* FLogStream;
	TLogFormatFlags FLogFlags;
	int FMaxLineLength;
	Byte FLastChannel;
	AnsiString FLastName;
	int FLineLength;
	TOnDivideStream FOnDivideStream;
	char FLastCRLF;
	void __fastcall SetLogStream(Classes::TStream* Value);
	
protected:
	virtual void __fastcall OpenConn(void);
	virtual void __fastcall DoLog(const AnsiString aText);
	virtual AnsiString __fastcall PreformatText(const AnsiString aName, Byte aChannel, AnsiString aText);
	virtual bool __fastcall DivideStream(const AnsiString aName, Byte aChannel, AnsiString &aText, int &I);
	
public:
	__fastcall virtual TStreamLogger(Classes::TComponent* aOwner);
	__property Classes::TStream* LogStream = {read=FLogStream, write=SetLogStream};
	
__published:
	__property TLogFormatFlags LogFlags = {read=FLogFlags, write=FLogFlags, nodefault};
	__property int MaxLineLength = {read=FMaxLineLength, write=FMaxLineLength, nodefault};
	__property TOnDivideStream OnDivideStream = {read=FOnDivideStream, write=FOnDivideStream};
public:
	#pragma option push -w-inl
	/* TLogger.Destroy */ inline __fastcall virtual ~TStreamLogger(void) { }
	#pragma option pop
	
};


class DELPHICLASS TFileLogger;
class PASCALIMPLEMENTATION TFileLogger : public TStreamLogger 
{
	typedef TStreamLogger inherited;
	
private:
	AnsiString FLogFile;
	int FMaxFileSize;
	Word FRotateCount;
	void __fastcall SetLogFile(const AnsiString aFile);
	AnsiString __fastcall GetRotateLogFile(int I);
	
protected:
	virtual void __fastcall DoLog(const AnsiString aText);
	virtual void __fastcall OpenConn(void);
	virtual void __fastcall CloseConn(void);
	
__published:
	__property AnsiString LogFile = {read=FLogFile, write=SetLogFile};
	__property int MaxFileSize = {read=FMaxFileSize, write=FMaxFileSize, default=0};
	__property Word RotateCount = {read=FRotateCount, write=FRotateCount, default=0};
public:
	#pragma option push -w-inl
	/* TStreamLogger.Create */ inline __fastcall virtual TFileLogger(Classes::TComponent* aOwner) : TStreamLogger(aOwner) { }
	#pragma option pop
	
public:
	#pragma option push -w-inl
	/* TLogger.Destroy */ inline __fastcall virtual ~TFileLogger(void) { }
	#pragma option pop
	
};


typedef void __fastcall (__closure *TFormatLogEvent)(Classes::TComponent* Sender, Byte aChannel, AnsiString &aText);

class DELPHICLASS TLogConnection;
class PASCALIMPLEMENTATION TLogConnection : public TConnection 
{
	typedef TConnection inherited;
	
private:
	TLogger* FLogger;
	TFormatLogEvent FOnFormatLog;
	AnsiString FLogName;
	
protected:
	virtual void __fastcall DoFormatLog(Byte aChannel, AnsiString &aText);
	
public:
	void __fastcall Log(Byte aChannel, AnsiString aText);
	void __fastcall LogFromStream(Byte aChannel, Classes::TStream* aStream);
	
__published:
	__property TLogger* Logger = {read=FLogger, write=FLogger};
	__property AnsiString LogName = {read=FLogName, write=FLogName};
	__property TFormatLogEvent OnFormatLog = {read=FOnFormatLog, write=FOnFormatLog};
public:
	#pragma option push -w-inl
	/* TConnection.Destroy */ inline __fastcall virtual ~TLogConnection(void) { }
	#pragma option pop
	
public:
	#pragma option push -w-inl
	/* TComponent.Create */ inline __fastcall virtual TLogConnection(Classes::TComponent* AOwner) : TConnection(AOwner) { }
	#pragma option pop
	
};


typedef void __fastcall (__closure *TCommRxCharEvent)(System::TObject* Sender, int Count);

class DELPHICLASS TCommunicationConnection;
class PASCALIMPLEMENTATION TCommunicationConnection : public TLogConnection 
{
	typedef TLogConnection inherited;
	
private:
	TCommRxCharEvent FOnRxChar;
	bool FDontSynchronize;
	
public:
	int __fastcall Send(AnsiString S);
	virtual int __fastcall InQueCount(void) = 0 ;
	AnsiString __fastcall Retrieve(int aCount);
	virtual void __fastcall PurgeIn(void) = 0 ;
	virtual void __fastcall PurgeOut(void) = 0 ;
	__property TCommRxCharEvent OnRxChar = {read=FOnRxChar, write=FOnRxChar};
	__property bool DontSynchronize = {read=FDontSynchronize, write=FDontSynchronize, nodefault};
	
protected:
	virtual int __fastcall Write(void *Buf, int Count) = 0 ;
	virtual int __fastcall Read(void *Buf, int Count) = 0 ;
	virtual void __fastcall DoOnRxChar(int Count);
public:
	#pragma option push -w-inl
	/* TConnection.Destroy */ inline __fastcall virtual ~TCommunicationConnection(void) { }
	#pragma option pop
	
public:
	#pragma option push -w-inl
	/* TComponent.Create */ inline __fastcall virtual TCommunicationConnection(Classes::TComponent* AOwner) : TLogConnection(AOwner) { }
	#pragma option pop
	
};


class DELPHICLASS EConnectError;
class PASCALIMPLEMENTATION EConnectError : public Sysutils::Exception 
{
	typedef Sysutils::Exception inherited;
	
public:
	#pragma option push -w-inl
	/* Exception.Create */ inline __fastcall EConnectError(const AnsiString Msg) : Sysutils::Exception(Msg) { }
	#pragma option pop
	#pragma option push -w-inl
	/* Exception.CreateFmt */ inline __fastcall EConnectError(const AnsiString Msg, System::TVarRec const * Args, const int Args_Size) : Sysutils::Exception(Msg, Args, Args_Size) { }
	#pragma option pop
	#pragma option push -w-inl
	/* Exception.CreateRes */ inline __fastcall EConnectError(int Ident)/* overload */ : Sysutils::Exception(Ident) { }
	#pragma option pop
	#pragma option push -w-inl
	/* Exception.CreateResFmt */ inline __fastcall EConnectError(int Ident, System::TVarRec const * Args, const int Args_Size)/* overload */ : Sysutils::Exception(Ident, Args, Args_Size) { }
	#pragma option pop
	#pragma option push -w-inl
	/* Exception.CreateHelp */ inline __fastcall EConnectError(const AnsiString Msg, int AHelpContext) : Sysutils::Exception(Msg, AHelpContext) { }
	#pragma option pop
	#pragma option push -w-inl
	/* Exception.CreateFmtHelp */ inline __fastcall EConnectError(const AnsiString Msg, System::TVarRec const * Args, const int Args_Size, int AHelpContext) : Sysutils::Exception(Msg, Args, Args_Size, AHelpContext) { }
	#pragma option pop
	#pragma option push -w-inl
	/* Exception.CreateResHelp */ inline __fastcall EConnectError(int Ident, int AHelpContext)/* overload */ : Sysutils::Exception(Ident, AHelpContext) { }
	#pragma option pop
	#pragma option push -w-inl
	/* Exception.CreateResFmtHelp */ inline __fastcall EConnectError(System::PResStringRec ResStringRec, System::TVarRec const * Args, const int Args_Size, int AHelpContext)/* overload */ : Sysutils::Exception(ResStringRec, Args, Args_Size, AHelpContext) { }
	#pragma option pop
	
public:
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~EConnectError(void) { }
	#pragma option pop
	
};


//-- var, const, procedure ---------------------------------------------------
static const Shortint lchNull = 0x0;
static const Shortint lchOut = 0x1;
static const Shortint lchIn = 0x2;
static const Shortint lchError = 0x3;
#define devNull "NUL"
extern PACKAGE System::ResourceString _sActiveConnection;
#define Connect_sActiveConnection System::LoadResourceString(&Connect::_sActiveConnection)
extern PACKAGE System::ResourceString _sInactiveConnection;
#define Connect_sInactiveConnection System::LoadResourceString(&Connect::_sInactiveConnection)
extern PACKAGE AnsiString __fastcall Bin2Hex(const AnsiString S);
extern PACKAGE AnsiString __fastcall Hex2Bin(const AnsiString S);
extern PACKAGE char __fastcall B2C(Byte B);
extern PACKAGE char __fastcall B2C1(Byte B);
extern PACKAGE AnsiString __fastcall UpString(AnsiString S);
extern PACKAGE System::TDateTime __fastcall NowUTC(void);
extern PACKAGE AnsiString __fastcall DateTimemsToStr(System::TDateTime aDT);
extern PACKAGE AnsiString __fastcall StreamReadString(Classes::TStream* St);
extern PACKAGE void __fastcall StreamWriteString(Classes::TStream* St, AnsiString S);
extern PACKAGE AnsiString __fastcall StreamToString(Classes::TStream* St)/* overload */;
extern PACKAGE AnsiString __fastcall StreamToString(Classes::TStream* St, int aLen)/* overload */;
extern PACKAGE void __fastcall StringToStream(const AnsiString S, Classes::TStream* St);
extern PACKAGE void __fastcall Register(void);

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

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