"Fossies" - the Fresh Open Source Software Archive  

Source code changes of the file "src/include/firebird/IdlFbInterfaces.h" between
Firebird-3.0.2.32703-0.tar.bz2 and Firebird-3.0.4.33054-0.tar.bz2

About: Firebird is a relational database offering many ANSI SQL standard features.

IdlFbInterfaces.h  (Firebird-3.0.2.32703-0.tar.bz2)	:	IdlFbInterfaces.h  (Firebird-3.0.4.33054-0.tar.bz2)
skipping to change at line 733		skipping to change at line 733
return ret;		return ret;
}		}
};		};
class IPluginModule : public IVersioned		class IPluginModule : public IVersioned
{		{
public:		public:
struct VTable : public IVersioned::VTable		struct VTable : public IVersioned::VTable
{		{
void (CLOOP_CARG *doClean)(IPluginModule* self) throw();		void (CLOOP_CARG *doClean)(IPluginModule* self) throw();
		void (CLOOP_CARG *threadDetach)(IPluginModule* self) thro w();
};		};
protected:		protected:
IPluginModule(DoNotInherit)		IPluginModule(DoNotInherit)
: IVersioned(DoNotInherit())		: IVersioned(DoNotInherit())
{		{
}		}
~IPluginModule()		~IPluginModule()
{		{
}		}
public:		public:
static const unsigned VERSION = 2;		static const unsigned VERSION = 3;
void doClean()		void doClean()
{		{
static_cast<VTable*>(this->cloopVTable)->doClean(this);		static_cast<VTable*>(this->cloopVTable)->doClean(this);
}		}
		void threadDetach()
		{
		if (cloopVTable->version < 3)
		{
		return;
		}
		static_cast<VTable*>(this->cloopVTable)->threadDetach(thi
		s);
		}
};		};
class IPluginManager : public IVersioned		class IPluginManager : public IVersioned
{		{
public:		public:
struct VTable : public IVersioned::VTable		struct VTable : public IVersioned::VTable
{		{
void (CLOOP_CARG *registerPluginFactory)(IPluginManager* self, unsigned pluginType, const char* defaultName, IPluginFactory* factory) thr ow();		void (CLOOP_CARG *registerPluginFactory)(IPluginManager* self, unsigned pluginType, const char* defaultName, IPluginFactory* factory) thr ow();
void (CLOOP_CARG *registerModule)(IPluginManager* self, I PluginModule* cleanup) throw();		void (CLOOP_CARG *registerModule)(IPluginManager* self, I PluginModule* cleanup) throw();
void (CLOOP_CARG *unregisterModule)(IPluginManager* self, IPluginModule* cleanup) throw();		void (CLOOP_CARG *unregisterModule)(IPluginManager* self, IPluginModule* cleanup) throw();
skipping to change at line 4064		skipping to change at line 4074
}		}
};		};
class ITraceParams : public IVersioned		class ITraceParams : public IVersioned
{		{
public:		public:
struct VTable : public IVersioned::VTable		struct VTable : public IVersioned::VTable
{		{
unsigned (CLOOP_CARG *getCount)(ITraceParams* self) throw ();		unsigned (CLOOP_CARG *getCount)(ITraceParams* self) throw ();
const dsc* (CLOOP_CARG *getParam)(ITraceParams* self, uns igned idx) throw();		const dsc* (CLOOP_CARG *getParam)(ITraceParams* self, uns igned idx) throw();
		const char* (CLOOP_CARG *getTextUTF8)(ITraceParams* self, IStatus* status, unsigned idx) throw();
};		};
protected:		protected:
ITraceParams(DoNotInherit)		ITraceParams(DoNotInherit)
: IVersioned(DoNotInherit())		: IVersioned(DoNotInherit())
{		{
}		}
~ITraceParams()		~ITraceParams()
{		{
}		}
public:		public:
static const unsigned VERSION = 2;		static const unsigned VERSION = 3;
unsigned getCount()		unsigned getCount()
{		{
unsigned ret = static_cast<VTable*>(this->cloopVTable)->g etCount(this);		unsigned ret = static_cast<VTable*>(this->cloopVTable)->g etCount(this);
return ret;		return ret;
}		}
const dsc* getParam(unsigned idx)		const dsc* getParam(unsigned idx)
{		{
const dsc* ret = static_cast<VTable*>(this->cloopVTable)- >getParam(this, idx);		const dsc* ret = static_cast<VTable*>(this->cloopVTable)- >getParam(this, idx);
return ret;		return ret;
}		}
		template <typename StatusType> const char* getTextUTF8(StatusType
		* status, unsigned idx)
		{
		if (cloopVTable->version < 3)
		{
		StatusType::setVersionError(status, "ITraceParams
		", cloopVTable->version, 3);
		StatusType::checkException(status);
		return 0;
		}
		StatusType::clearException(status);
		const char* ret = static_cast<VTable*>(this->cloopVTable)
		->getTextUTF8(this, status, idx);
		StatusType::checkException(status);
		return ret;
		}
};		};
class ITraceStatement : public IVersioned		class ITraceStatement : public IVersioned
{		{
public:		public:
struct VTable : public IVersioned::VTable		struct VTable : public IVersioned::VTable
{		{
ISC_INT64 (CLOOP_CARG *getStmtID)(ITraceStatement* self) throw();		ISC_INT64 (CLOOP_CARG *getStmtID)(ITraceStatement* self) throw();
PerformanceInfo* (CLOOP_CARG *getPerf)(ITraceStatement* s elf) throw();		PerformanceInfo* (CLOOP_CARG *getPerf)(ITraceStatement* s elf) throw();
};		};
skipping to change at line 6450		skipping to change at line 6475
typedef IPluginModule Declaration;		typedef IPluginModule Declaration;
IPluginModuleBaseImpl(DoNotInherit = DoNotInherit())		IPluginModuleBaseImpl(DoNotInherit = DoNotInherit())
{		{
static struct VTableImpl : Base::VTable		static struct VTableImpl : Base::VTable
{		{
VTableImpl()		VTableImpl()
{		{
this->version = Base::VERSION;		this->version = Base::VERSION;
this->doClean = &Name::cloopdoCleanDispat cher;		this->doClean = &Name::cloopdoCleanDispat cher;
		this->threadDetach = &Name::cloopthreadDe tachDispatcher;
}		}
} vTable;		} vTable;
this->cloopVTable = &vTable;		this->cloopVTable = &vTable;
}		}
static void CLOOP_CARG cloopdoCleanDispatcher(IPluginModule* self ) throw()		static void CLOOP_CARG cloopdoCleanDispatcher(IPluginModule* self ) throw()
{		{
try		try
{		{
static_cast<Name*>(self)->Name::doClean();		static_cast<Name*>(self)->Name::doClean();
}		}
catch (...)		catch (...)
{		{
StatusType::catchException(0);		StatusType::catchException(0);
}		}
}		}
		static void CLOOP_CARG cloopthreadDetachDispatcher(IPluginModule*
		self) throw()
		{
		try
		{
		static_cast<Name*>(self)->Name::threadDetach();
		}
		catch (...)
		{
		StatusType::catchException(0);
		}
		}
};		};
template <typename Name, typename StatusType, typename Base = IVersionedI mpl<Name, StatusType, Inherit<IPluginModule> > >		template <typename Name, typename StatusType, typename Base = IVersionedI mpl<Name, StatusType, Inherit<IPluginModule> > >
class IPluginModuleImpl : public IPluginModuleBaseImpl<Name, StatusType, Base>		class IPluginModuleImpl : public IPluginModuleBaseImpl<Name, StatusType, Base>
{		{
protected:		protected:
IPluginModuleImpl(DoNotInherit = DoNotInherit())		IPluginModuleImpl(DoNotInherit = DoNotInherit())
{		{
}		}
public:		public:
virtual ~IPluginModuleImpl()		virtual ~IPluginModuleImpl()
{		{
}		}
virtual void doClean() = 0;		virtual void doClean() = 0;
		virtual void threadDetach() = 0;
};		};
template <typename Name, typename StatusType, typename Base>		template <typename Name, typename StatusType, typename Base>
class IPluginManagerBaseImpl : public Base		class IPluginManagerBaseImpl : public Base
{		{
public:		public:
typedef IPluginManager Declaration;		typedef IPluginManager Declaration;
IPluginManagerBaseImpl(DoNotInherit = DoNotInherit())		IPluginManagerBaseImpl(DoNotInherit = DoNotInherit())
{		{
skipping to change at line 13668		skipping to change at line 13707
ITraceParamsBaseImpl(DoNotInherit = DoNotInherit())		ITraceParamsBaseImpl(DoNotInherit = DoNotInherit())
{		{
static struct VTableImpl : Base::VTable		static struct VTableImpl : Base::VTable
{		{
VTableImpl()		VTableImpl()
{		{
this->version = Base::VERSION;		this->version = Base::VERSION;
this->getCount = &Name::cloopgetCountDisp atcher;		this->getCount = &Name::cloopgetCountDisp atcher;
this->getParam = &Name::cloopgetParamDisp atcher;		this->getParam = &Name::cloopgetParamDisp atcher;
		this->getTextUTF8 = &Name::cloopgetTextUT F8Dispatcher;
}		}
} vTable;		} vTable;
this->cloopVTable = &vTable;		this->cloopVTable = &vTable;
}		}
static unsigned CLOOP_CARG cloopgetCountDispatcher(ITraceParams* self) throw()		static unsigned CLOOP_CARG cloopgetCountDispatcher(ITraceParams* self) throw()
{		{
try		try
{		{
skipping to change at line 13699		skipping to change at line 13739
try		try
{		{
return static_cast<Name*>(self)->Name::getParam(i dx);		return static_cast<Name*>(self)->Name::getParam(i dx);
}		}
catch (...)		catch (...)
{		{
StatusType::catchException(0);		StatusType::catchException(0);
return static_cast<const dsc*>(0);		return static_cast<const dsc*>(0);
}		}
}		}
		static const char* CLOOP_CARG cloopgetTextUTF8Dispatcher(ITracePa
		rams* self, IStatus* status, unsigned idx) throw()
		{
		StatusType status2(status);
		try
		{
		return static_cast<Name*>(self)->Name::getTextUTF
		8(&status2, idx);
		}
		catch (...)
		{
		StatusType::catchException(&status2);
		return static_cast<const char*>(0);
		}
		}
};		};
template <typename Name, typename StatusType, typename Base = IVersionedI mpl<Name, StatusType, Inherit<ITraceParams> > >		template <typename Name, typename StatusType, typename Base = IVersionedI mpl<Name, StatusType, Inherit<ITraceParams> > >
class ITraceParamsImpl : public ITraceParamsBaseImpl<Name, StatusType, Ba se>		class ITraceParamsImpl : public ITraceParamsBaseImpl<Name, StatusType, Ba se>
{		{
protected:		protected:
ITraceParamsImpl(DoNotInherit = DoNotInherit())		ITraceParamsImpl(DoNotInherit = DoNotInherit())
{		{
}		}
public:		public:
virtual ~ITraceParamsImpl()		virtual ~ITraceParamsImpl()
{		{
}		}
virtual unsigned getCount() = 0;		virtual unsigned getCount() = 0;
virtual const dsc* getParam(unsigned idx) = 0;		virtual const dsc* getParam(unsigned idx) = 0;
		virtual const char* getTextUTF8(StatusType* status, unsigned idx) = 0;
};		};
template <typename Name, typename StatusType, typename Base>		template <typename Name, typename StatusType, typename Base>
class ITraceStatementBaseImpl : public Base		class ITraceStatementBaseImpl : public Base
{		{
public:		public:
typedef ITraceStatement Declaration;		typedef ITraceStatement Declaration;
ITraceStatementBaseImpl(DoNotInherit = DoNotInherit())		ITraceStatementBaseImpl(DoNotInherit = DoNotInherit())
{		{
End of changes. 12 change blocks.
2 lines changed or deleted		65 lines changed or added

---