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

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

#ifndef RioHPP
#define RioHPP

#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 <Intfinfo.hpp>	// Pascal unit
#include <Opconvert.hpp>	// Pascal unit
#include <Invokeregistry.hpp>	// Pascal unit
#include <Webnode.hpp>	// Pascal unit
#include <Soapattachintf.hpp>	// Pascal unit
#include <Wsdlintf.hpp>	// Pascal unit

//-- user supplied -----------------------------------------------------------
#if defined(__WIN32__)
#pragma link "wininet.lib"
#endif

namespace Rio
{
//-- type declarations -------------------------------------------------------
__interface IRIOAccess;
typedef System::DelphiInterface<IRIOAccess> _di_IRIOAccess;
class DELPHICLASS TRIO;
__interface  INTERFACE_UUID("{FEF7C9CC-A477-40B7-ACBE-487EDA3E5DFE}") IRIOAccess  : public IInterface 
{
	
public:
	virtual TRIO* __fastcall GetRIO(void) = 0 ;
	__property TRIO* RIO = {read=GetRIO};
};

typedef void __fastcall (__closure *TBeforeExecuteEvent)(const AnsiString MethodName, WideString &SOAPRequest);

typedef void __fastcall (__closure *TAfterExecuteEvent)(const AnsiString MethodName, Classes::TStream* SOAPResponse);

class PASCALIMPLEMENTATION TRIO : public Classes::TComponent 
{
	typedef Classes::TComponent inherited;
	
private:
	bool FInterfaceBound;
	int FRefCount;
	void *IntfTable;
	void *IntfTableP;
	void *IntfStubs;
	void *StubAddr;
	void *ErrorStubAddr;
	bool IntfReg;
	bool LegalCC;
	bool HasRTTI;
	Byte CallStub[19];
	int CallStubIdx;
	Invokeregistry::TSOAPHeaders* FSOAPHeaders;
	Invokeregistry::THeaderList* FHeadersOutBound;
	Invokeregistry::THeaderList* FHeadersInbound;
	Invokeregistry::TInvContext* FContext;
	TAfterExecuteEvent FOnAfterExecute;
	TBeforeExecuteEvent FOnBeforeExecute;
	Soapattachintf::TOnSendAttachmentEvent FOnSendAttachment;
	Soapattachintf::TOnGetAttachmentEvent FOnGetAttachment;
	__int64 __fastcall Generic(int CallID, void * Params);
	void __fastcall GenericStub(void);
	void __fastcall ErrorEntry(void);
	bool __fastcall GenVTable(const GUID &IID);
	void __fastcall GenPushI(int I);
	void __fastcall GenDWORD(unsigned DW);
	void __fastcall GenByte(Byte B);
	void __fastcall GenRET(Word BytesPushed = (Word)(0x0));
	HIDESBASE int __stdcall _AddRef(void);
	HIDESBASE int __stdcall _Release(void);
	int __stdcall _AddRefFromIntf(void);
	int __stdcall _ReleaseFromIntf(void);
	HRESULT __stdcall _QIFromIntf(const GUID &IID, /* out */ void *Obj);
	TRIO* __fastcall GetRIO(void);
	
protected:
	#pragma pack(push,1)
	GUID FIID;
	#pragma pack(pop)
	Intfinfo::TIntfMetaData IntfMD;
	Opconvert::_di_IOPConvert FConverter;
	Webnode::_di_IWebNode FWebNode;
	virtual HRESULT __stdcall QueryInterface(const GUID &IID, /* out */ void *Obj);
	virtual void __fastcall DoAfterExecute(const AnsiString MethodName, Classes::TStream* Response);
	virtual void __fastcall DoBeforeExecute(const AnsiString MethodName, Classes::TStream* Request);
	virtual Classes::TStream* __fastcall GetResponseStream(Wsdlintf::TWebServiceBindingType BindingType);
	
public:
	__fastcall virtual TRIO(Classes::TComponent* AOwner);
	__fastcall virtual ~TRIO(void);
	virtual void __fastcall AfterConstruction(void);
	virtual void __fastcall BeforeDestruction(void);
	/* virtual class method */ virtual System::TObject* __fastcall NewInstance(TMetaClass* vmt);
	__property int RefCount = {read=FRefCount, nodefault};
	__property Opconvert::_di_IOPConvert Converter = {read=FConverter, write=FConverter};
	__property Webnode::_di_IWebNode WebNode = {read=FWebNode, write=FWebNode};
	__property Invokeregistry::TSOAPHeaders* SOAPHeaders = {read=FSOAPHeaders};
	
__published:
	__property TAfterExecuteEvent OnAfterExecute = {read=FOnAfterExecute, write=FOnAfterExecute};
	__property TBeforeExecuteEvent OnBeforeExecute = {read=FOnBeforeExecute, write=FOnBeforeExecute};
	__property Soapattachintf::TOnSendAttachmentEvent OnSendAttachment = {read=FOnSendAttachment, write=FOnSendAttachment};
	__property Soapattachintf::TOnGetAttachmentEvent OnGetAttachment = {read=FOnGetAttachment, write=FOnGetAttachment};
private:
	void *__IRIOAccess;	/* Rio::IRIOAccess */
	
public:
	operator IRIOAccess*(void) { return (IRIOAccess*)&__IRIOAccess; }
	operator IInterface*(void) { return (IInterface*)&__IRIOAccess; }
	
};


//-- var, const, procedure ---------------------------------------------------
static const Shortint StubSize = 0x13;

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

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