/*
	$Revision: 49 $
	$Date: 18/08/06 17:57 $
	Copyright © 2001-2006, FSL Technologies Limited. Contact "http://fost.3.felspar.com".
*/


#ifndef FOST_COM_HPP
#define FOST_COM_HPP
#pragma once


#include <FOST.util.hpp>
#include <FOST.internet.hpp>


#ifdef F3UTIL_EXPORTS
#define FOST_COM_HPP_ARCHIVE L"$Archive: /FOST.3/F3Util/FOST.com.hpp $"
#define FOST_COM_HPP_REVISION L"$Revision: 49 $"
#define FOST_COM_HPP_DATE L"$Date: 18/08/06 17:57 $"
#endif


struct IFSLibInput;


namespace FSLib {


	namespace Exceptions {


		class F3UTIL_DECLSPEC ComError : public Exception {
		public:
			ComError( const FSLib::wstring &message );
			ComError( const FSLib::wstring &message, const FSLib::wstring &information );
			ComError( const _com_error &c );
			ComError( const _com_error &c, const FSLib::wstring & );

		protected:
			inline const wchar_t * const message() const throw ();
		};


		class F3UTIL_DECLSPEC IISError : public FSLib::Exceptions::Exception {
		public:
			inline IISError( const FSLib::wstring &message );
			inline IISError( const FSLib::wstring &message, const FSLib::wstring &diagnostic );

		protected:
			inline const wchar_t * const message() const throw ();
		};


		class F3UTIL_DECLSPEC PageStartEnd : public IISError {
		public:
			PageStartEnd( const FSLib::wstring &error );
			PageStartEnd( const FSLib::wstring &error, const FSLib::wstring &aux );

		protected:
			inline const wchar_t * const message() const throw ();
		};


		class F3UTIL_DECLSPEC VariantCast : public Exception {
		public:
			inline VariantCast( const FSLib::wstring & );

		protected:
			inline const wchar_t * const message() const throw ();
		};


		class F3UTIL_DECLSPEC Field : public Exception {
		public:
			inline Field( const FSLib::wstring &msg );
			inline Field( const FSLib::wstring &msg, const FSLib::wstring &name );

		protected:
			inline const wchar_t * const message() const throw();
		};


	}


	extern class F3UTIL_DECLSPEC ComHR {
	public:
		ComHR( void ) throw () {}
		inline ComHR( HRESULT hr, size_t line, const char *file );
		ComHR( HRESULT hr, const wchar_t *error ) {
			try {
				check( hr );
			} catch ( FSLib::Exceptions::Exception &e ) {
				e.info() << error << std::endl;
				throw;
			}
		}
		ComHR( HRESULT hr, const wchar_t *error, IUnknown *iface ) {
			try {
				check( hr );
			} catch ( FSLib::Exceptions::Exception &e ) {
				e.info() << error << std::endl << format( iface ) << std::endl;
				throw;
			}
		}

		HRESULT operator =( HRESULT hr ) const { check( hr ); return hr; }
		HRESULT operator()( HRESULT hr ) const { check( hr ); return hr; }

		static wstring format( HRESULT hr );
		static wstring format( IUnknown *iface );

	private:
		void check( HRESULT hr ) const { if ( FAILED( hr ) ) doThrow( hr ); }
		void doThrow( HRESULT hr ) const;
	} HR;


	// Casts from COM types
	F3UTIL_DECLSPEC bool VARIANT_is_null( const VARIANT & );

	F3UTIL_DECLSPEC FSLib::wstring BSTR_to_wstring( const BSTR & );
	F3UTIL_DECLSPEC void wstring_to_BSTR( const FSLib::wstring &, BSTR & );

	F3UTIL_DECLSPEC bool VARIANT_to_bool( const VARIANT & );
	F3UTIL_DECLSPEC long VARIANT_to_long( const VARIANT & );
	F3UTIL_DECLSPEC unsigned __int16 VARIANT_to_U16( const VARIANT & );
	F3UTIL_DECLSPEC float VARIANT_to_float( const VARIANT & );
	F3UTIL_DECLSPEC double VARIANT_to_double( const VARIANT & );
	F3UTIL_DECLSPEC FSLib::string VARIANT_to_string( const VARIANT & );
	F3UTIL_DECLSPEC FSLib::wstring VARIANT_to_wstring( const VARIANT & );

	F3UTIL_DECLSPEC Nullable< FSLib::wstring > BSTR_to_Nullable_wstring( const BSTR & );
	F3UTIL_DECLSPEC Nullable< FSLib::wstring > VARIANT_to_Nullable_wstring( const VARIANT & );


	// Casts to COM types
	F3UTIL_DECLSPEC _variant_t wstring_to_VARIANT( const FSLib::wstring & );


	template< typename T > inline
	T variant_cast( const VARIANT &v ) {
		return T( VARIANT_to_wstring( v ) );
	}

	template<> inline
	FSLib::string variant_cast( const VARIANT &v ) {
		return VARIANT_to_string( v );
	}
	template<> inline
	FSLib::wstring variant_cast( const VARIANT &v ) {
		return VARIANT_to_wstring( v );
	}
	template<> inline
	long variant_cast( const VARIANT &v ) {
		return VARIANT_to_long( v );
	}
	template<> inline
	int variant_cast( const VARIANT &v ) {
		return VARIANT_to_long( v );
	}
	template<> inline
	bool variant_cast( const VARIANT &v ) {
		return VARIANT_to_long( v ) ? true : false;
	}
	template<> inline
	unsigned __int16 variant_cast( const VARIANT &v ) {
		return VARIANT_to_U16( v );
	}
	template<> inline
	__int64 variant_cast( const VARIANT &v ) {
		return _wtoi64( VARIANT_to_wstring( v ).c_str() );
	}
	template<> inline
	float variant_cast( const VARIANT &v ) {
		return VARIANT_to_float( v );
	}
	template<> inline
	double variant_cast( const VARIANT &v ) {
		return VARIANT_to_double( v );
	}

	template<> inline
	FSLib::Nullable< FSLib::string > variant_cast( const VARIANT &v ) {
		if ( VARIANT_is_null( v ) ) return Null;
		return VARIANT_to_string( v );
	}
	template<> inline
	FSLib::Nullable< FSLib::wstring > variant_cast( const VARIANT &v ) {
		if ( VARIANT_is_null( v ) ) return Null;
		return VARIANT_to_wstring( v );
	}
	template<> inline
	FSLib::Nullable< long > variant_cast( const VARIANT &v ) {
		if ( VARIANT_is_null( v ) ) return Null;
		return VARIANT_to_long( v );
	}
	template<> inline
	FSLib::Nullable< int > variant_cast( const VARIANT &v ) {
		if ( VARIANT_is_null( v ) ) return Null;
		return VARIANT_to_long( v );
	}
	template<> inline
	FSLib::Nullable< bool > variant_cast( const VARIANT &v ) {
		if ( VARIANT_is_null( v ) ) return Null;
		return VARIANT_to_long( v ) ? true : false;
	}
	template<> inline
	FSLib::Nullable< __int64 > variant_cast( const VARIANT &v ) {
		if ( VARIANT_is_null( v ) ) return Null;
		return _wtoi64( VARIANT_to_wstring( v ).c_str() );
	}
	template<> inline
	FSLib::Nullable< float > variant_cast( const VARIANT &v ) {
		if ( VARIANT_is_null( v ) ) return Null;
		return VARIANT_to_float( v );
	}
	template<> inline
	FSLib::Nullable< double > variant_cast( const VARIANT &v ) {
		if ( VARIANT_is_null( v ) ) return Null;
		return VARIANT_to_double( v );
	}


	namespace Iis {


		class F3UTIL_DECLSPEC InputServer : public Input {
		public:
			InputServer( ATL::CComPtr< IRequest > );

			using Input::exists;
			using Input::value;
			size_t exists( const FSLib::wstring &name, const FSLib::Nullable< FSLib::wstring > &partition = Null ) const;
			_variant_t value( const FSLib::wstring &name, const Nullable< size_t > &num = Null, const FSLib::Nullable< FSLib::wstring > &partition = Null ) const;

		private:
			IRequestDictionary *server() const;

			ATL::CComPtr< IRequest > m_request;
			mutable init_ptr< IRequestDictionary > m_server;
		};


		class F3UTIL_DECLSPEC PageHandler {
		protected:
			PageHandler();
			virtual ~PageHandler();

			bool inPage() const { return m_inPage; }
			void assertInPage() const;
			void assertNotInPage() const;

			ATL::CComPtr< IRequest > &request();
			ATL::CComPtr< IResponse > &response();
			ATL::CComPtr< IServer > &server();

			STDMETHOD(OnStartPage)(IUnknown* IUnk);
			STDMETHOD(OnEndPage)();

		private:
			mutable bool m_inPage;
			ATL::CComPtr< IRequest > m_piRequest;
			ATL::CComPtr< IResponse > m_piResponse;
			ATL::CComPtr< IServer > m_piServer;
		};


	}


}


F3UTIL_DECLSPEC bool operator ==( const _variant_t &l, const FSLib::t_null );
F3UTIL_DECLSPEC bool operator ==( const FSLib::t_null, const _variant_t &l );
F3UTIL_DECLSPEC bool operator !=( const _variant_t &l, const FSLib::t_null );
F3UTIL_DECLSPEC bool operator !=( const FSLib::t_null, const _variant_t &l );


// Exception handling header and footer for COM methods and properties
#define FSL_TRY FSLib::Exceptions::StructuredHandler handler; try {

#define FSL_CATCH_ONLY } catch( exception &e ) { Error( e.what() ); return E_FAIL; } catch ( _com_error &c ) { Error( FSLib::Exceptions::ComError( c ).what() ); return E_FAIL; }
#define FSL_CATCH return S_OK; FSL_CATCH_ONLY

#define FSL_CATCH_ONLY_NOCOCLASS } catch( exception & ) { return E_FAIL; } catch ( _com_error & ) { return E_FAIL; }
#define FSL_CATCH_NOCOCLASS return S_OK; FSL_CATCH_ONLY_NOCOCLASS


// Handle (Object/Facet) properties


#define FSL_GET_BSTR_BODY( member, var, prop ) *var = CComBSTR( member->prop().c_str() ).Detach();
#define FSL_PUT_BSTR_BODY( member, var, prop ) member->prop( FSLib::BSTR_to_wstring( var ) );

#define FSL_GET_BOOL_BODY( member, var, prop ) *var = member->prop();
#define FSL_PUT_BOOL_BODY( member, var, prop ) member->prop( var );

#define FSL_GET_LONG_BODY( member, var, prop ) *var = member->prop();
#define FSL_PUT_LONG_BODY( member, var, prop ) member->prop( var );

#define FSL_GET_ID_BODY( member, var, prop ) *var = _wtoi( member->prop().asString().c_str() );
#define FSL_PUT_ID_BODY( member, var, prop ) member->prop( FSLib::ID( var ) );

#define FSL_GET_DATE_BODY( member, var, prop ) *var = CComBSTR( member->prop().asString().c_str() ).Detach();
#define FSL_PUT_DATE_BODY( member, var, prop ) member->prop( FSLib::Date( FSLib::BSTR_to_wstring( var ) ) );

#define FSL_GET_PERIOD_BODY( member, var, prop ) *var = CComBSTR( member->prop().asString().c_str() ).Detach();
#define FSL_PUT_PERIOD_BODY( member, var, prop ) member->prop( FSLib::Period< void >( FSLib::BSTR_to_wstring( var ) ) );

#define FSL_GET_VARIANT_BSTR_BODY( member, var, prop ) if ( member->prop().isnull() ) { *var = _variant_t().Detach(); } else { *var = _variant_t( member->prop().value().c_str() ).Detach(); }
#define FSL_PUT_VARIANT_BSTR_BODY( member, var, prop ) if ( FSLib::VARIANT_is_null( var ) || FSLib::VARIANT_to_wstring( var ).length() == 0 ) { member->prop( FSLib::Nullable< FSLib::wstring >() ); } else { member->prop( FSLib::VARIANT_to_wstring( var ) ); }

#define FSL_GET_VARIANT_BOOL_BODY( member, var, prop ) if ( member->prop().isnull() ) { *var = _variant_t().Detach(); } else { *var = _variant_t( member->prop().value() );}
#define FSL_PUT_VARIANT_BOOL_BODY( member, var, prop ) if ( FSLib::VARIANT_is_null( var ) || FSLib::VARIANT_to_wstring( var ).length() == 0 || FSLib::VARIANT_to_wstring( var ).find_first_not_of( L" \t\r\n" ) == FSLib::wstring::npos ) { member->prop( FSLib::Nullable< bool >() ); } else { member->prop( FSLib::VARIANT_to_bool( var ) ); }

#define FSL_GET_VARIANT_ID_BODY( member, var, prop ) if ( member->prop().isnull() ) { *var = _variant_t().Detach(); } else { *var = _variant_t( _wtol( member->prop().value().asString().c_str() ) );}
#define FSL_PUT_VARIANT_ID_BODY( member, var, prop ) if ( FSLib::VARIANT_is_null( var ) || FSLib::VARIANT_to_wstring( var ).length() == 0 ) { member->prop( FSLib::Nullable< FSLib::ID >() ); } else { member->prop( FSLib::ID( FSLib::VARIANT_to_long( var ) ) ); }

#define FSL_GET_VARIANT_DATE_BODY( member, var, prop ) if ( member->prop().isnull() ) { *var = _variant_t().Detach(); } else { *var = _variant_t( member->prop().value().asString().c_str() ).Detach(); }
#define FSL_PUT_VARIANT_DATE_BODY( member, var, prop ) if ( FSLib::VARIANT_is_null( var ) || FSLib::VARIANT_to_wstring( var ).length() == 0 ) { member->prop( FSLib::Nullable< FSLib::Date >() ); } else { member->prop( FSLib::Date( FSLib::VARIANT_to_wstring( var ) ) ); }


// Final Object macros
#define FSL_GET_BSTR( cls, prop ) STDMETHODIMP cls::get_##prop( BSTR *pVal ) { FSL_TRY FSL_GET_BSTR_BODY( m_object, pVal, prop ) FSL_CATCH }
#define FSL_PUT_BSTR( cls, prop ) STDMETHODIMP cls::put_##prop( BSTR newVal ) { FSL_TRY FSL_PUT_BSTR_BODY( m_object, newVal, prop ) FSL_CATCH }

#define FSL_GET_BOOL( cls, prop ) STDMETHODIMP cls::get_##prop( BOOL *pVal ) { FSL_TRY FSL_GET_BOOL_BODY( m_object, pVal, prop ) FSL_CATCH }
#define FSL_PUT_BOOL( cls, prop ) STDMETHODIMP cls::put_##prop( BOOL newVal ) { FSL_TRY FSL_PUT_BOOL_BODY( m_object, newVal, prop ) FSL_CATCH }

#define FSL_GET_LONG( cls, prop ) STDMETHODIMP cls::get_##prop( LONG *pVal ) { FSL_TRY FSL_GET_LONG_BODY( m_object, pVal, prop ) FSL_CATCH }
#define FSL_PUT_LONG( cls, prop ) STDMETHODIMP cls::put_##prop( LONG newVal ) { FSL_TRY FSL_PUT_LONG_BODY( m_object, newVal, prop ) FSL_CATCH }

#define FSL_GET_ID( cls, prop ) STDMETHODIMP cls::get_##prop( LONG *pVal ) { FSL_TRY FSL_GET_ID_BODY( m_object, pVal, prop ) FSL_CATCH }
#define FSL_PUT_ID( cls, prop ) STDMETHODIMP cls::put_##prop( LONG newVal ) { FSL_TRY FSL_PUT_ID_BODY( m_object, newVal, prop ) FSL_CATCH }

#define FSL_GET_DATE( cls, prop ) STDMETHODIMP cls::get_##prop( BSTR *pVal ) { FSL_TRY FSL_GET_DATE_BODY( m_object, pVal, prop ) FSL_CATCH }
#define FSL_PUT_DATE( cls, prop ) STDMETHODIMP cls::put_##prop( BSTR newVal ) { FSL_TRY FSL_PUT_DATE_BODY( m_object, newVal, prop ) FSL_CATCH }

#define FSL_GET_PERIOD( cls, prop ) STDMETHODIMP cls::get_##prop( BSTR *pVal ) { FSL_TRY FSL_GET_PERIOD_BODY( m_object, pVal, prop ) FSL_CATCH }
#define FSL_PUT_PERIOD( cls, prop ) STDMETHODIMP cls::put_##prop( BSTR newVal ) { FSL_TRY FSL_PUT_PERIOD_BODY( m_object, newVal, prop ) FSL_CATCH }

#define FSL_GET_VARIANT_BSTR( cls, prop ) STDMETHODIMP cls::get_##prop(VARIANT *pVal) { FSL_TRY FSL_GET_VARIANT_BSTR_BODY( m_object, pVal, prop ) FSL_CATCH }
#define FSL_PUT_VARIANT_BSTR( cls, prop ) STDMETHODIMP cls::put_##prop(VARIANT newVal) { FSL_TRY FSL_PUT_VARIANT_BSTR_BODY( m_object, newVal, prop ) FSL_CATCH }

#define FSL_GET_VARIANT_BOOL( cls, prop ) STDMETHODIMP cls::get_##prop(VARIANT *pVal) { FSL_TRY FSL_GET_VARIANT_BOOL_BODY( m_object, pVal, prop ) FSL_CATCH }
#define FSL_PUT_VARIANT_BOOL( cls, prop ) STDMETHODIMP cls::put_##prop(VARIANT newVal) { FSL_TRY FSL_PUT_VARIANT_BOOL_BODY( m_object, newVal, prop ) FSL_CATCH }

#define FSL_GET_VARIANT_ID( cls, prop ) STDMETHODIMP cls::get_##prop(VARIANT *pVal) { FSL_TRY FSL_GET_VARIANT_ID_BODY( m_object, pVal, prop ) FSL_CATCH }
#define FSL_PUT_VARIANT_ID( cls, prop ) STDMETHODIMP cls::put_##prop(VARIANT newVal) { FSL_TRY FSL_PUT_VARIANT_ID_BODY( m_object, newVal, prop ) FSL_CATCH }

#define FSL_GET_VARIANT_DATE( cls, prop ) STDMETHODIMP cls::get_##prop(VARIANT *pVal) { FSL_TRY FSL_GET_VARIANT_DATE_BODY( m_object, pVal, prop ) FSL_CATCH }
#define FSL_PUT_VARIANT_DATE( cls, prop ) STDMETHODIMP cls::put_##prop(VARIANT newVal) { FSL_TRY FSL_PUT_VARIANT_DATE_BODY( m_object, newVal, prop ) FSL_CATCH }


// Final Facet macros
#define FSL_FACET_GET_BSTR( cls, prop ) STDMETHODIMP cls::get_##prop( BSTR *pVal ) { FSL_TRY FSL_GET_BSTR_BODY( getFacetPointer(), pVal, prop ) FSL_CATCH_NOCOCLASS }
#define FSL_FACET_PUT_BSTR( cls, prop ) STDMETHODIMP cls::put_##prop( BSTR newVal ) { FSL_TRY FSL_PUT_BSTR_BODY( getFacetPointer(), newVal, prop ) FSL_CATCH_NOCOCLASS }

#define FSL_FACET_GET_BOOL( cls, prop ) STDMETHODIMP cls::get_##prop( BOOL *pVal ) { FSL_TRY FSL_GET_BOOL_BODY( getFacetPointer(), pVal, prop ) FSL_CATCH_NOCOCLASS }
#define FSL_FACET_PUT_BOOL( cls, prop ) STDMETHODIMP cls::put_##prop( BOOL newVal ) { FSL_TRY FSL_PUT_BOOL_BODY( getFacetPointer(), newVal, prop ) FSL_CATCH_NOCOCLASS }

#define FSL_FACET_GET_LONG( cls, prop ) STDMETHODIMP cls::get_##prop( LONG *pVal ) { FSL_TRY FSL_GET_LONG_BODY( getFacetPointer(), pVal, prop ) FSL_CATCH_NOCOCLASS }
#define FSL_FACET_PUT_LONG( cls, prop ) STDMETHODIMP cls::put_##prop( LONG newVal ) { FSL_TRY FSL_PUT_LONG_BODY( getFacetPointer(), newVal, prop ) FSL_CATCH_NOCOCLASS }

#define FSL_FACET_GET_ID( cls, prop ) STDMETHODIMP cls::get_##prop( LONG *pVal ) { FSL_TRY FSL_GET_ID_BODY( getFacetPointer(), pVal, prop ) FSL_CATCH_NOCOCLASS }
#define FSL_FACET_PUT_ID( cls, prop ) STDMETHODIMP cls::put_##prop( LONG newVal ) { FSL_TRY FSL_PUT_ID_BODY( getFacetPointer(), newVal, prop ) FSL_CATCH_NOCOCLASS }

#define FSL_FACET_GET_DATE( cls, prop ) STDMETHODIMP cls::get_##prop( BSTR *pVal ) { FSL_TRY FSL_GET_DATE_BODY( getFacetPointer(), pVal, prop ) FSL_CATCH_NOCOCLASS }
#define FSL_FACET_PUT_DATE( cls, prop ) STDMETHODIMP cls::put_##prop( BSTR newVal ) { FSL_TRY FSL_PUT_DATE_BODY( getFacetPointer(), newVal, prop ) FSL_CATCH_NOCOCLASS }

#define FSL_FACET_GET_PERIOD( cls, prop ) STDMETHODIMP cls::get_##prop( BSTR *pVal ) { FSL_TRY FSL_GET_PERIOD_BODY( getFacetPointer(), pVal, prop ) FSL_CATCH_NOCOCLASS }
#define FSL_FACET_PUT_PERIOD( cls, prop ) STDMETHODIMP cls::put_##prop( BSTR newVal ) { FSL_TRY FSL_PUT_PERIOD_BODY( getFacetPointer(), newVal, prop ) FSL_CATCH_NOCOCLASS }

#define FSL_FACET_GET_VARIANT_BSTR( cls, prop ) STDMETHODIMP cls::get_##prop(VARIANT *pVal) { FSL_TRY FSL_GET_VARIANT_BSTR_BODY( getFacetPointer(), pVal, prop ) FSL_CATCH_NOCOCLASS }
#define FSL_FACET_PUT_VARIANT_BSTR( cls, prop ) STDMETHODIMP cls::put_##prop(VARIANT newVal) { FSL_TRY FSL_PUT_VARIANT_BSTR_BODY( getFacetPointer(), newVal, prop ) FSL_CATCH_NOCOCLASS }

#define FSL_FACET_GET_VARIANT_BOOL( cls, prop ) STDMETHODIMP cls::get_##prop(VARIANT *pVal) { FSL_TRY FSL_GET_VARIANT_BOOL_BODY( getFacetPointer(), pVal, prop ) FSL_CATCH_NOCOCLASS }
#define FSL_FACET_PUT_VARIANT_BOOL( cls, prop ) STDMETHODIMP cls::put_##prop(VARIANT newVal) { FSL_TRY FSL_PUT_VARIANT_BOOL_BODY( getFacetPointer(), newVal, prop ) FSL_CATCH_NOCOCLASS }

#define FSL_FACET_GET_VARIANT_ID( cls, prop ) STDMETHODIMP cls::get_##prop(VARIANT *pVal) { FSL_TRY FSL_GET_VARIANT_ID_BODY( getFacetPointer(), pVal, prop ) FSL_CATCH_NOCOCLASS }
#define FSL_FACET_PUT_VARIANT_ID( cls, prop ) STDMETHODIMP cls::put_##prop(VARIANT newVal) { FSL_TRY FSL_PUT_VARIANT_ID_BODY( getFacetPointer(), newVal, prop ) FSL_CATCH_NOCOCLASS }

#define FSL_FACET_GET_VARIANT_DATE( cls, prop ) STDMETHODIMP cls::get_##prop(VARIANT *pVal) { FSL_TRY FSL_GET_VARIANT_DATE_BODY( getFacetPointer(), pVal, prop ) FSL_CATCH_NOCOCLASS }
#define FSL_FACET_PUT_VARIANT_DATE( cls, prop ) STDMETHODIMP cls::put_##prop(VARIANT newVal) { FSL_TRY FSL_PUT_VARIANT_DATE_BODY( getFacetPointer(), newVal, prop ) FSL_CATCH_NOCOCLASS }


// Period handlers
#define FSL_PERIOD_GET_REN( cm, attr, ptr, cat ) STDMETHOD( get_##cm )( BSTR *pVal ) { FSL_TRY *pVal = CComBSTR( ptr->attr.asString().c_str() ).Detach(); cat }
#define FSL_PERIOD_PUT_REN( cm, attr, ptr, cat ) STDMETHOD( put_##cm )( BSTR val ) { FSL_TRY ptr->attr.period( FSLib::Period< void >( FSLib::BSTR_to_wstring( val ) ) ); cat }


// New style attribute handlers
#define FSL_ATTR_GET_REN_CAST( cm, attr, ptr, ctype, rtype, cat ) STDMETHOD( get_##cm )( ctype *pVal ) { FSL_TRY ptr->attr.get( reinterpret_cast< rtype * >( pVal ) ); cat }
#define FSL_ATTR_GET_REN( cm, attr, ptr, type, cat ) STDMETHOD( get_##cm )( type *pVal ) { FSL_TRY ptr->attr.get( pVal ); cat }
#define FSL_ATTR_PUT_REN( cm, attr, ptr, type, cat ) STDMETHOD( put_##cm )( type newVal ) { FSL_TRY ptr->attr.put( newVal ); cat }
#define FSL_ATTRIBUTE_GET( attrib, ptr, type, cat ) FSL_ATTR_GET_REN( attrib, attrib, ptr, type, cat )
#define FSL_ATTRIBUTE_PUT( attrib, ptr, type, cat ) FSL_ATTR_PUT_REN( attrib, attrib, ptr, type, cat )
#define FSL_OBJECT_ATTRIB( attrib, type ) FSL_ATTR_GET_REN( attrib, attrib, m_object, type, FSL_CATCH ) FSL_ATTR_PUT_REN( attrib, attrib, m_object, type, FSL_CATCH )
#define FSL_FACET_ATTRIB( attrib, type ) FSL_ATTR_GET_REN( attrib, attrib, getFacetPointer(), type, FSL_CATCH_NOCOCLASS ) FSL_ATTR_PUT_REN( attrib, attrib, getFacetPointer(), type, FSL_CATCH_NOCOCLASS )


#endif // FOST_COM_HPP