diff options
Diffstat (limited to 'mcop/core.h')
| -rw-r--r-- | mcop/core.h | 1561 |
1 files changed, 1561 insertions, 0 deletions
diff --git a/mcop/core.h b/mcop/core.h new file mode 100644 index 0000000..5ab73e1 --- /dev/null +++ b/mcop/core.h @@ -0,0 +1,1561 @@ +/* this file was generated by the MCOP idl compiler - DO NOT EDIT */ + +#ifndef CORE_H +#define CORE_H + +#include "common.h" +#include "arts_export.h" + +namespace Arts { +enum HeaderMagic {MCOP_MAGIC = 1296256848}; +enum MessageType {mcopMessageInvalid = 0, mcopServerHello = 1, mcopClientHello = 2, mcopAuthAccept = 3, mcopInvocation = 4, mcopReturn = 5, mcopOnewayInvocation = 6}; +enum MethodType {methodOneway = 1, methodTwoway = 2, methodMax = 0xffffffff}; +enum AttributeType {streamIn = 1, streamOut = 2, streamMulti = 4, attributeStream = 8, attributeAttribute = 16, streamAsync = 32, streamDefault = 64}; +enum TypeIdentification {tiUnknown = 0, tiVoid = 1, tiLong = 2, tiByte = 3, tiString = 4, tiBoolean = 5, tiFloat = 6, tiEnum = 128, tiType = 129, tiInterface = 130}; +} +namespace Arts { +class ARTS_EXPORT Header : public Arts::Type { +public: + Header(); + Header(Arts::HeaderMagic _a_magic, long _a_messageLength, Arts::MessageType _a_messageType); + Header(Arts::Buffer& stream); + Header(const Header& copyType); + Header& operator=(const Header& assignType); + Arts::HeaderMagic magic; + long messageLength; + Arts::MessageType messageType; + +// marshalling functions + void readType(Arts::Buffer& stream); + void writeType(Arts::Buffer& stream) const; + std::string _typeName() const; +}; + +class ARTS_EXPORT Invocation : public Arts::Type { +public: + Invocation(); + Invocation(long _a_objectID, long _a_methodID, long _a_requestID); + Invocation(Arts::Buffer& stream); + Invocation(const Invocation& copyType); + Invocation& operator=(const Invocation& assignType); + long objectID; + long methodID; + long requestID; + +// marshalling functions + void readType(Arts::Buffer& stream); + void writeType(Arts::Buffer& stream) const; + std::string _typeName() const; +}; + +class ARTS_EXPORT OnewayInvocation : public Arts::Type { +public: + OnewayInvocation(); + OnewayInvocation(long _a_objectID, long _a_methodID); + OnewayInvocation(Arts::Buffer& stream); + OnewayInvocation(const OnewayInvocation& copyType); + OnewayInvocation& operator=(const OnewayInvocation& assignType); + long objectID; + long methodID; + +// marshalling functions + void readType(Arts::Buffer& stream); + void writeType(Arts::Buffer& stream) const; + std::string _typeName() const; +}; + +class ARTS_EXPORT ServerHello : public Arts::Type { +public: + ServerHello(); + ServerHello(const std::string& _a_mcopVersion, const std::string& _a_serverID, const std::vector<std::string>& _a_authProtocols, const std::string& _a_authSeed); + ServerHello(Arts::Buffer& stream); + ServerHello(const ServerHello& copyType); + ServerHello& operator=(const ServerHello& assignType); + std::string mcopVersion; + std::string serverID; + std::vector<std::string> authProtocols; + std::string authSeed; + +// marshalling functions + void readType(Arts::Buffer& stream); + void writeType(Arts::Buffer& stream) const; + std::string _typeName() const; +}; + +class ARTS_EXPORT ClientHello : public Arts::Type { +public: + ClientHello(); + ClientHello(const std::string& _a_serverID, const std::string& _a_authProtocol, const std::string& _a_authData); + ClientHello(Arts::Buffer& stream); + ClientHello(const ClientHello& copyType); + ClientHello& operator=(const ClientHello& assignType); + std::string serverID; + std::string authProtocol; + std::string authData; + +// marshalling functions + void readType(Arts::Buffer& stream); + void writeType(Arts::Buffer& stream) const; + std::string _typeName() const; +}; + +class ARTS_EXPORT AuthAccept : public Arts::Type { +public: + AuthAccept(); + AuthAccept(const std::vector<std::string>& _a_hints); + AuthAccept(Arts::Buffer& stream); + AuthAccept(const AuthAccept& copyType); + AuthAccept& operator=(const AuthAccept& assignType); + std::vector<std::string> hints; + +// marshalling functions + void readType(Arts::Buffer& stream); + void writeType(Arts::Buffer& stream) const; + std::string _typeName() const; +}; + +class ARTS_EXPORT ObjectReference : public Arts::Type { +public: + ObjectReference(); + ObjectReference(const std::string& _a_serverID, long _a_objectID, const std::vector<std::string>& _a_urls); + ObjectReference(Arts::Buffer& stream); + ObjectReference(const ObjectReference& copyType); + ObjectReference& operator=(const ObjectReference& assignType); + std::string serverID; + long objectID; + std::vector<std::string> urls; + +// marshalling functions + void readType(Arts::Buffer& stream); + void writeType(Arts::Buffer& stream) const; + std::string _typeName() const; +}; + +class ARTS_EXPORT ParamDef : public Arts::Type { +public: + ParamDef(); + ParamDef(const std::string& _a_type, const std::string& _a_name, const std::vector<std::string>& _a_hints); + ParamDef(Arts::Buffer& stream); + ParamDef(const ParamDef& copyType); + ParamDef& operator=(const ParamDef& assignType); + std::string type; + std::string name; + std::vector<std::string> hints; + +// marshalling functions + void readType(Arts::Buffer& stream); + void writeType(Arts::Buffer& stream) const; + std::string _typeName() const; +}; + +class ARTS_EXPORT MethodDef : public Arts::Type { +public: + MethodDef(); + MethodDef(const std::string& _a_name, const std::string& _a_type, Arts::MethodType _a_flags, const std::vector<Arts::ParamDef>& _a_signature, const std::vector<std::string>& _a_hints); + MethodDef(Arts::Buffer& stream); + MethodDef(const MethodDef& copyType); + MethodDef& operator=(const MethodDef& assignType); + std::string name; + std::string type; + Arts::MethodType flags; + std::vector<Arts::ParamDef> signature; + std::vector<std::string> hints; + +// marshalling functions + void readType(Arts::Buffer& stream); + void writeType(Arts::Buffer& stream) const; + std::string _typeName() const; +}; + +class ARTS_EXPORT AttributeDef : public Arts::Type { +public: + AttributeDef(); + AttributeDef(const std::string& _a_name, const std::string& _a_type, Arts::AttributeType _a_flags, const std::vector<std::string>& _a_hints); + AttributeDef(Arts::Buffer& stream); + AttributeDef(const AttributeDef& copyType); + AttributeDef& operator=(const AttributeDef& assignType); + std::string name; + std::string type; + Arts::AttributeType flags; + std::vector<std::string> hints; + +// marshalling functions + void readType(Arts::Buffer& stream); + void writeType(Arts::Buffer& stream) const; + std::string _typeName() const; +}; + +class ARTS_EXPORT InterfaceDef : public Arts::Type { +public: + InterfaceDef(); + InterfaceDef(const std::string& _a_name, const std::vector<std::string>& _a_inheritedInterfaces, const std::vector<Arts::MethodDef>& _a_methods, const std::vector<Arts::AttributeDef>& _a_attributes, const std::vector<std::string>& _a_defaultPorts, const std::vector<std::string>& _a_hints); + InterfaceDef(Arts::Buffer& stream); + InterfaceDef(const InterfaceDef& copyType); + InterfaceDef& operator=(const InterfaceDef& assignType); + std::string name; + std::vector<std::string> inheritedInterfaces; + std::vector<Arts::MethodDef> methods; + std::vector<Arts::AttributeDef> attributes; + std::vector<std::string> defaultPorts; + std::vector<std::string> hints; + +// marshalling functions + void readType(Arts::Buffer& stream); + void writeType(Arts::Buffer& stream) const; + std::string _typeName() const; +}; + +class ARTS_EXPORT TypeComponent : public Arts::Type { +public: + TypeComponent(); + TypeComponent(const std::string& _a_type, const std::string& _a_name, const std::vector<std::string>& _a_hints); + TypeComponent(Arts::Buffer& stream); + TypeComponent(const TypeComponent& copyType); + TypeComponent& operator=(const TypeComponent& assignType); + std::string type; + std::string name; + std::vector<std::string> hints; + +// marshalling functions + void readType(Arts::Buffer& stream); + void writeType(Arts::Buffer& stream) const; + std::string _typeName() const; +}; + +class ARTS_EXPORT TypeDef : public Arts::Type { +public: + TypeDef(); + TypeDef(const std::string& _a_name, const std::vector<Arts::TypeComponent>& _a_contents, const std::vector<std::string>& _a_hints); + TypeDef(Arts::Buffer& stream); + TypeDef(const TypeDef& copyType); + TypeDef& operator=(const TypeDef& assignType); + std::string name; + std::vector<Arts::TypeComponent> contents; + std::vector<std::string> hints; + +// marshalling functions + void readType(Arts::Buffer& stream); + void writeType(Arts::Buffer& stream) const; + std::string _typeName() const; +}; + +class ARTS_EXPORT EnumComponent : public Arts::Type { +public: + EnumComponent(); + EnumComponent(const std::string& _a_name, long _a_value, const std::vector<std::string>& _a_hints); + EnumComponent(Arts::Buffer& stream); + EnumComponent(const EnumComponent& copyType); + EnumComponent& operator=(const EnumComponent& assignType); + std::string name; + long value; + std::vector<std::string> hints; + +// marshalling functions + void readType(Arts::Buffer& stream); + void writeType(Arts::Buffer& stream) const; + std::string _typeName() const; +}; + +class ARTS_EXPORT EnumDef : public Arts::Type { +public: + EnumDef(); + EnumDef(const std::string& _a_name, const std::vector<Arts::EnumComponent>& _a_contents, const std::vector<std::string>& _a_hints); + EnumDef(Arts::Buffer& stream); + EnumDef(const EnumDef& copyType); + EnumDef& operator=(const EnumDef& assignType); + std::string name; + std::vector<Arts::EnumComponent> contents; + std::vector<std::string> hints; + +// marshalling functions + void readType(Arts::Buffer& stream); + void writeType(Arts::Buffer& stream) const; + std::string _typeName() const; +}; + +class ARTS_EXPORT ModuleDef : public Arts::Type { +public: + ModuleDef(); + ModuleDef(const std::string& _a_moduleName, const std::vector<Arts::EnumDef>& _a_enums, const std::vector<Arts::TypeDef>& _a_types, const std::vector<Arts::InterfaceDef>& _a_interfaces, const std::vector<std::string>& _a_hints); + ModuleDef(Arts::Buffer& stream); + ModuleDef(const ModuleDef& copyType); + ModuleDef& operator=(const ModuleDef& assignType); + std::string moduleName; + std::vector<Arts::EnumDef> enums; + std::vector<Arts::TypeDef> types; + std::vector<Arts::InterfaceDef> interfaces; + std::vector<std::string> hints; + +// marshalling functions + void readType(Arts::Buffer& stream); + void writeType(Arts::Buffer& stream) const; + std::string _typeName() const; +}; + +class ARTS_EXPORT Any : public Arts::Type { +public: + Any(); + Any(const std::string& _a_type, const std::vector<Arts::mcopbyte>& _a_value); + Any(Arts::Buffer& stream); + Any(const Any& copyType); + Any& operator=(const Any& assignType); + std::string type; + std::vector<Arts::mcopbyte> value; + +// marshalling functions + void readType(Arts::Buffer& stream); + void writeType(Arts::Buffer& stream) const; + std::string _typeName() const; +}; + +class ARTS_EXPORT TraderEntry : public Arts::Type { +public: + TraderEntry(); + TraderEntry(const std::string& _a_interfaceName, const std::vector<std::string>& _a_lines); + TraderEntry(Arts::Buffer& stream); + TraderEntry(const TraderEntry& copyType); + TraderEntry& operator=(const TraderEntry& assignType); + std::string interfaceName; + std::vector<std::string> lines; + +// marshalling functions + void readType(Arts::Buffer& stream); + void writeType(Arts::Buffer& stream) const; + std::string _typeName() const; +}; + +} +namespace Arts { +class InterfaceRepo; +class InterfaceRepoV2; +class FlowSystemSender; +class FlowSystemReceiver; +class FlowSystem; +class GlobalComm; +class TmpGlobalComm; +class TraderOffer; +class TraderQuery; +class Loader; + +class ARTS_EXPORT InterfaceRepo_base : virtual public Arts::Object_base { +public: + static unsigned long _IID; // interface ID + + static InterfaceRepo_base *_create(const std::string& subClass = "Arts::InterfaceRepo"); + static InterfaceRepo_base *_fromString(std::string objectref); + static InterfaceRepo_base *_fromReference(Arts::ObjectReference ref, bool needcopy); + + static InterfaceRepo_base *_fromDynamicCast(const Arts::Object& object); + inline InterfaceRepo_base *_copy() { + assert(_refCnt > 0); + _refCnt++; + return this; + } + + virtual std::vector<std::string> _defaultPortsIn() const; + virtual std::vector<std::string> _defaultPortsOut() const; + + void *_cast(unsigned long iid); + + virtual long insertModule(const Arts::ModuleDef& newModule) = 0; + virtual void removeModule(long moduleID) = 0; + virtual Arts::InterfaceDef queryInterface(const std::string& name) = 0; + virtual Arts::TypeDef queryType(const std::string& name) = 0; + virtual Arts::EnumDef queryEnum(const std::string& name) = 0; + virtual std::vector<std::string> * queryChildren(const std::string& name) = 0; + virtual std::vector<std::string> * queryInterfaces() = 0; + virtual std::vector<std::string> * queryTypes() = 0; + virtual std::vector<std::string> * queryEnums() = 0; +}; + +class ARTS_EXPORT InterfaceRepo_stub : virtual public InterfaceRepo_base, virtual public Arts::Object_stub { +protected: + InterfaceRepo_stub(); + +public: + InterfaceRepo_stub(Arts::Connection *connection, long objectID); + + long insertModule(const Arts::ModuleDef& newModule); + void removeModule(long moduleID); + Arts::InterfaceDef queryInterface(const std::string& name); + Arts::TypeDef queryType(const std::string& name); + Arts::EnumDef queryEnum(const std::string& name); + std::vector<std::string> * queryChildren(const std::string& name); + std::vector<std::string> * queryInterfaces(); + std::vector<std::string> * queryTypes(); + std::vector<std::string> * queryEnums(); +}; + +class ARTS_EXPORT InterfaceRepo_skel : virtual public InterfaceRepo_base, virtual public Arts::Object_skel { +public: + InterfaceRepo_skel(); + + static std::string _interfaceNameSkel(); + std::string _interfaceName(); + bool _isCompatibleWith(const std::string& interfacename); + void _buildMethodTable(); + void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID); +}; + +} +#include "reference.h" +namespace Arts { +class ARTS_EXPORT InterfaceRepo : public Arts::Object { +private: + static Arts::Object_base* _Creator(); + InterfaceRepo_base *_cache; + inline InterfaceRepo_base *_method_call() { + _pool->checkcreate(); + if(_pool->base) { + _cache=(InterfaceRepo_base *)_pool->base->_cast(InterfaceRepo_base::_IID); + assert(_cache); + } + return _cache; + } + +protected: + inline InterfaceRepo(InterfaceRepo_base* b) : Arts::Object(b), _cache(0) {} + + +public: + typedef InterfaceRepo_base _base_class; + + inline InterfaceRepo() : Arts::Object(_Creator), _cache(0) {} + inline InterfaceRepo(const Arts::SubClass& s) : + Arts::Object(InterfaceRepo_base::_create(s.string())), _cache(0) {} + inline InterfaceRepo(const Arts::Reference &r) : + Arts::Object(r.isString()?(InterfaceRepo_base::_fromString(r.string())):(InterfaceRepo_base::_fromReference(r.reference(),true))), _cache(0) {} + inline InterfaceRepo(const Arts::DynamicCast& c) : Arts::Object(InterfaceRepo_base::_fromDynamicCast(c.object())), _cache(0) {} + inline InterfaceRepo(const InterfaceRepo& target) : Arts::Object(target._pool), _cache(target._cache) {} + inline InterfaceRepo(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {} + inline static InterfaceRepo null() {return InterfaceRepo((InterfaceRepo_base*)0);} + inline static InterfaceRepo _from_base(InterfaceRepo_base* b) {return InterfaceRepo(b);} + inline InterfaceRepo& operator=(const InterfaceRepo& target) { + if (_pool == target._pool) return *this; + _pool->Dec(); + _pool = target._pool; + _cache = target._cache; + _pool->Inc(); + return *this; + } + inline InterfaceRepo_base* _base() {return _cache?_cache:_method_call();} + + inline long insertModule(const Arts::ModuleDef& newModule); + inline void removeModule(long moduleID); + inline Arts::InterfaceDef queryInterface(const std::string& name); + inline Arts::TypeDef queryType(const std::string& name); + inline Arts::EnumDef queryEnum(const std::string& name); + inline std::vector<std::string> * queryChildren(const std::string& name); + inline std::vector<std::string> * queryInterfaces(); + inline std::vector<std::string> * queryTypes(); + inline std::vector<std::string> * queryEnums(); +}; + +class ARTS_EXPORT InterfaceRepoV2_base : virtual public Arts::InterfaceRepo_base { +public: + static unsigned long _IID; // interface ID + + static InterfaceRepoV2_base *_create(const std::string& subClass = "Arts::InterfaceRepoV2"); + static InterfaceRepoV2_base *_fromString(std::string objectref); + static InterfaceRepoV2_base *_fromReference(Arts::ObjectReference ref, bool needcopy); + + static InterfaceRepoV2_base *_fromDynamicCast(const Arts::Object& object); + inline InterfaceRepoV2_base *_copy() { + assert(_refCnt > 0); + _refCnt++; + return this; + } + + virtual std::vector<std::string> _defaultPortsIn() const; + virtual std::vector<std::string> _defaultPortsOut() const; + + void *_cast(unsigned long iid); + + virtual Arts::TypeIdentification identifyType(const std::string& name) = 0; +}; + +class ARTS_EXPORT InterfaceRepoV2_stub : virtual public InterfaceRepoV2_base, virtual public Arts::InterfaceRepo_stub { +protected: + InterfaceRepoV2_stub(); + +public: + InterfaceRepoV2_stub(Arts::Connection *connection, long objectID); + + Arts::TypeIdentification identifyType(const std::string& name); +}; + +class ARTS_EXPORT InterfaceRepoV2_skel : virtual public InterfaceRepoV2_base, virtual public Arts::InterfaceRepo_skel { +public: + InterfaceRepoV2_skel(); + + static std::string _interfaceNameSkel(); + std::string _interfaceName(); + bool _isCompatibleWith(const std::string& interfacename); + void _buildMethodTable(); + void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID); +}; + +} +#include "reference.h" +namespace Arts { +class ARTS_EXPORT InterfaceRepoV2 : public Arts::Object { +private: + static Arts::Object_base* _Creator(); + InterfaceRepoV2_base *_cache; + inline InterfaceRepoV2_base *_method_call() { + _pool->checkcreate(); + if(_pool->base) { + _cache=(InterfaceRepoV2_base *)_pool->base->_cast(InterfaceRepoV2_base::_IID); + assert(_cache); + } + return _cache; + } + +protected: + inline InterfaceRepoV2(InterfaceRepoV2_base* b) : Arts::Object(b), _cache(0) {} + + +public: + typedef InterfaceRepoV2_base _base_class; + + inline InterfaceRepoV2() : Arts::Object(_Creator), _cache(0) {} + inline InterfaceRepoV2(const Arts::SubClass& s) : + Arts::Object(InterfaceRepoV2_base::_create(s.string())), _cache(0) {} + inline InterfaceRepoV2(const Arts::Reference &r) : + Arts::Object(r.isString()?(InterfaceRepoV2_base::_fromString(r.string())):(InterfaceRepoV2_base::_fromReference(r.reference(),true))), _cache(0) {} + inline InterfaceRepoV2(const Arts::DynamicCast& c) : Arts::Object(InterfaceRepoV2_base::_fromDynamicCast(c.object())), _cache(0) {} + inline InterfaceRepoV2(const InterfaceRepoV2& target) : Arts::Object(target._pool), _cache(target._cache) {} + inline InterfaceRepoV2(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {} + inline static InterfaceRepoV2 null() {return InterfaceRepoV2((InterfaceRepoV2_base*)0);} + inline static InterfaceRepoV2 _from_base(InterfaceRepoV2_base* b) {return InterfaceRepoV2(b);} + inline InterfaceRepoV2& operator=(const InterfaceRepoV2& target) { + if (_pool == target._pool) return *this; + _pool->Dec(); + _pool = target._pool; + _cache = target._cache; + _pool->Inc(); + return *this; + } + inline operator Arts::InterfaceRepo() const { return Arts::InterfaceRepo(*_pool); } + inline InterfaceRepoV2_base* _base() {return _cache?_cache:_method_call();} + + inline long insertModule(const Arts::ModuleDef& newModule); + inline void removeModule(long moduleID); + inline Arts::InterfaceDef queryInterface(const std::string& name); + inline Arts::TypeDef queryType(const std::string& name); + inline Arts::EnumDef queryEnum(const std::string& name); + inline std::vector<std::string> * queryChildren(const std::string& name); + inline std::vector<std::string> * queryInterfaces(); + inline std::vector<std::string> * queryTypes(); + inline std::vector<std::string> * queryEnums(); + inline Arts::TypeIdentification identifyType(const std::string& name); +}; + +class ARTS_EXPORT FlowSystemSender_base : virtual public Arts::Object_base { +public: + static unsigned long _IID; // interface ID + + static FlowSystemSender_base *_create(const std::string& subClass = "Arts::FlowSystemSender"); + static FlowSystemSender_base *_fromString(std::string objectref); + static FlowSystemSender_base *_fromReference(Arts::ObjectReference ref, bool needcopy); + + static FlowSystemSender_base *_fromDynamicCast(const Arts::Object& object); + inline FlowSystemSender_base *_copy() { + assert(_refCnt > 0); + _refCnt++; + return this; + } + + virtual std::vector<std::string> _defaultPortsIn() const; + virtual std::vector<std::string> _defaultPortsOut() const; + + void *_cast(unsigned long iid); + + virtual void processed() = 0; + virtual void disconnect() = 0; +}; + +class ARTS_EXPORT FlowSystemSender_stub : virtual public FlowSystemSender_base, virtual public Arts::Object_stub { +protected: + FlowSystemSender_stub(); + +public: + FlowSystemSender_stub(Arts::Connection *connection, long objectID); + + void processed(); + void disconnect(); +}; + +class ARTS_EXPORT FlowSystemSender_skel : virtual public FlowSystemSender_base, virtual public Arts::Object_skel { +public: + FlowSystemSender_skel(); + + static std::string _interfaceNameSkel(); + std::string _interfaceName(); + bool _isCompatibleWith(const std::string& interfacename); + void _buildMethodTable(); + void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID); +}; + +} +#include "reference.h" +namespace Arts { +class ARTS_EXPORT FlowSystemSender : public Arts::Object { +private: + static Arts::Object_base* _Creator(); + FlowSystemSender_base *_cache; + inline FlowSystemSender_base *_method_call() { + _pool->checkcreate(); + if(_pool->base) { + _cache=(FlowSystemSender_base *)_pool->base->_cast(FlowSystemSender_base::_IID); + assert(_cache); + } + return _cache; + } + +protected: + inline FlowSystemSender(FlowSystemSender_base* b) : Arts::Object(b), _cache(0) {} + + +public: + typedef FlowSystemSender_base _base_class; + + inline FlowSystemSender() : Arts::Object(_Creator), _cache(0) {} + inline FlowSystemSender(const Arts::SubClass& s) : + Arts::Object(FlowSystemSender_base::_create(s.string())), _cache(0) {} + inline FlowSystemSender(const Arts::Reference &r) : + Arts::Object(r.isString()?(FlowSystemSender_base::_fromString(r.string())):(FlowSystemSender_base::_fromReference(r.reference(),true))), _cache(0) {} + inline FlowSystemSender(const Arts::DynamicCast& c) : Arts::Object(FlowSystemSender_base::_fromDynamicCast(c.object())), _cache(0) {} + inline FlowSystemSender(const FlowSystemSender& target) : Arts::Object(target._pool), _cache(target._cache) {} + inline FlowSystemSender(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {} + inline static FlowSystemSender null() {return FlowSystemSender((FlowSystemSender_base*)0);} + inline static FlowSystemSender _from_base(FlowSystemSender_base* b) {return FlowSystemSender(b);} + inline FlowSystemSender& operator=(const FlowSystemSender& target) { + if (_pool == target._pool) return *this; + _pool->Dec(); + _pool = target._pool; + _cache = target._cache; + _pool->Inc(); + return *this; + } + inline FlowSystemSender_base* _base() {return _cache?_cache:_method_call();} + + inline void processed(); + inline void disconnect(); +}; + +class ARTS_EXPORT FlowSystemReceiver_base : virtual public Arts::Object_base { +public: + static unsigned long _IID; // interface ID + + static FlowSystemReceiver_base *_create(const std::string& subClass = "Arts::FlowSystemReceiver"); + static FlowSystemReceiver_base *_fromString(std::string objectref); + static FlowSystemReceiver_base *_fromReference(Arts::ObjectReference ref, bool needcopy); + + static FlowSystemReceiver_base *_fromDynamicCast(const Arts::Object& object); + inline FlowSystemReceiver_base *_copy() { + assert(_refCnt > 0); + _refCnt++; + return this; + } + + virtual std::vector<std::string> _defaultPortsIn() const; + virtual std::vector<std::string> _defaultPortsOut() const; + + void *_cast(unsigned long iid); + + virtual long receiveHandlerID() = 0; + virtual void disconnect() = 0; +}; + +class ARTS_EXPORT FlowSystemReceiver_stub : virtual public FlowSystemReceiver_base, virtual public Arts::Object_stub { +protected: + FlowSystemReceiver_stub(); + +public: + FlowSystemReceiver_stub(Arts::Connection *connection, long objectID); + + long receiveHandlerID(); + void disconnect(); +}; + +class ARTS_EXPORT FlowSystemReceiver_skel : virtual public FlowSystemReceiver_base, virtual public Arts::Object_skel { +protected: + // emitters for change notifications + inline void receiveHandlerID_changed(long newValue) { + _emit_changed("receiveHandlerID_changed",newValue); + } + +public: + FlowSystemReceiver_skel(); + + static std::string _interfaceNameSkel(); + std::string _interfaceName(); + bool _isCompatibleWith(const std::string& interfacename); + void _buildMethodTable(); + void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID); +}; + +} +#include "reference.h" +namespace Arts { +class ARTS_EXPORT FlowSystemReceiver : public Arts::Object { +private: + static Arts::Object_base* _Creator(); + FlowSystemReceiver_base *_cache; + inline FlowSystemReceiver_base *_method_call() { + _pool->checkcreate(); + if(_pool->base) { + _cache=(FlowSystemReceiver_base *)_pool->base->_cast(FlowSystemReceiver_base::_IID); + assert(_cache); + } + return _cache; + } + +protected: + inline FlowSystemReceiver(FlowSystemReceiver_base* b) : Arts::Object(b), _cache(0) {} + + +public: + typedef FlowSystemReceiver_base _base_class; + + inline FlowSystemReceiver() : Arts::Object(_Creator), _cache(0) {} + inline FlowSystemReceiver(const Arts::SubClass& s) : + Arts::Object(FlowSystemReceiver_base::_create(s.string())), _cache(0) {} + inline FlowSystemReceiver(const Arts::Reference &r) : + Arts::Object(r.isString()?(FlowSystemReceiver_base::_fromString(r.string())):(FlowSystemReceiver_base::_fromReference(r.reference(),true))), _cache(0) {} + inline FlowSystemReceiver(const Arts::DynamicCast& c) : Arts::Object(FlowSystemReceiver_base::_fromDynamicCast(c.object())), _cache(0) {} + inline FlowSystemReceiver(const FlowSystemReceiver& target) : Arts::Object(target._pool), _cache(target._cache) {} + inline FlowSystemReceiver(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {} + inline static FlowSystemReceiver null() {return FlowSystemReceiver((FlowSystemReceiver_base*)0);} + inline static FlowSystemReceiver _from_base(FlowSystemReceiver_base* b) {return FlowSystemReceiver(b);} + inline FlowSystemReceiver& operator=(const FlowSystemReceiver& target) { + if (_pool == target._pool) return *this; + _pool->Dec(); + _pool = target._pool; + _cache = target._cache; + _pool->Inc(); + return *this; + } + inline FlowSystemReceiver_base* _base() {return _cache?_cache:_method_call();} + + inline long receiveHandlerID(); + inline void disconnect(); +}; + +class ARTS_EXPORT FlowSystem_base : virtual public Arts::Object_base { +public: + static unsigned long _IID; // interface ID + + static FlowSystem_base *_create(const std::string& subClass = "Arts::FlowSystem"); + static FlowSystem_base *_fromString(std::string objectref); + static FlowSystem_base *_fromReference(Arts::ObjectReference ref, bool needcopy); + + static FlowSystem_base *_fromDynamicCast(const Arts::Object& object); + inline FlowSystem_base *_copy() { + assert(_refCnt > 0); + _refCnt++; + return this; + } + + virtual std::vector<std::string> _defaultPortsIn() const; + virtual std::vector<std::string> _defaultPortsOut() const; + + void *_cast(unsigned long iid); + + virtual void startObject(Arts::Object node) = 0; + virtual void stopObject(Arts::Object node) = 0; + virtual void connectObject(Arts::Object sourceObject, const std::string& sourcePort, Arts::Object destObject, const std::string& destPort) = 0; + virtual void disconnectObject(Arts::Object sourceObject, const std::string& sourcePort, Arts::Object destObject, const std::string& destPort) = 0; + virtual Arts::AttributeType queryFlags(Arts::Object node, const std::string& port) = 0; + virtual void setFloatValue(Arts::Object node, const std::string& port, float value) = 0; + virtual Arts::FlowSystemReceiver createReceiver(Arts::Object destObject, const std::string& destPort, Arts::FlowSystemSender sender) = 0; +}; + +class ARTS_EXPORT FlowSystem_stub : virtual public FlowSystem_base, virtual public Arts::Object_stub { +protected: + FlowSystem_stub(); + +public: + FlowSystem_stub(Arts::Connection *connection, long objectID); + + void startObject(Arts::Object node); + void stopObject(Arts::Object node); + void connectObject(Arts::Object sourceObject, const std::string& sourcePort, Arts::Object destObject, const std::string& destPort); + void disconnectObject(Arts::Object sourceObject, const std::string& sourcePort, Arts::Object destObject, const std::string& destPort); + Arts::AttributeType queryFlags(Arts::Object node, const std::string& port); + void setFloatValue(Arts::Object node, const std::string& port, float value); + Arts::FlowSystemReceiver createReceiver(Arts::Object destObject, const std::string& destPort, Arts::FlowSystemSender sender); +}; + +class ARTS_EXPORT FlowSystem_skel : virtual public FlowSystem_base, virtual public Arts::Object_skel { +public: + FlowSystem_skel(); + + static std::string _interfaceNameSkel(); + std::string _interfaceName(); + bool _isCompatibleWith(const std::string& interfacename); + void _buildMethodTable(); + void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID); +}; + +} +#include "reference.h" +namespace Arts { +class ARTS_EXPORT FlowSystem : public Arts::Object { +private: + static Arts::Object_base* _Creator(); + FlowSystem_base *_cache; + inline FlowSystem_base *_method_call() { + _pool->checkcreate(); + if(_pool->base) { + _cache=(FlowSystem_base *)_pool->base->_cast(FlowSystem_base::_IID); + assert(_cache); + } + return _cache; + } + +protected: + inline FlowSystem(FlowSystem_base* b) : Arts::Object(b), _cache(0) {} + + +public: + typedef FlowSystem_base _base_class; + + inline FlowSystem() : Arts::Object(_Creator), _cache(0) {} + inline FlowSystem(const Arts::SubClass& s) : + Arts::Object(FlowSystem_base::_create(s.string())), _cache(0) {} + inline FlowSystem(const Arts::Reference &r) : + Arts::Object(r.isString()?(FlowSystem_base::_fromString(r.string())):(FlowSystem_base::_fromReference(r.reference(),true))), _cache(0) {} + inline FlowSystem(const Arts::DynamicCast& c) : Arts::Object(FlowSystem_base::_fromDynamicCast(c.object())), _cache(0) {} + inline FlowSystem(const FlowSystem& target) : Arts::Object(target._pool), _cache(target._cache) {} + inline FlowSystem(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {} + inline static FlowSystem null() {return FlowSystem((FlowSystem_base*)0);} + inline static FlowSystem _from_base(FlowSystem_base* b) {return FlowSystem(b);} + inline FlowSystem& operator=(const FlowSystem& target) { + if (_pool == target._pool) return *this; + _pool->Dec(); + _pool = target._pool; + _cache = target._cache; + _pool->Inc(); + return *this; + } + inline FlowSystem_base* _base() {return _cache?_cache:_method_call();} + + inline void startObject(Arts::Object node); + inline void stopObject(Arts::Object node); + inline void connectObject(Arts::Object sourceObject, const std::string& sourcePort, Arts::Object destObject, const std::string& destPort); + inline void disconnectObject(Arts::Object sourceObject, const std::string& sourcePort, Arts::Object destObject, const std::string& destPort); + inline Arts::AttributeType queryFlags(Arts::Object node, const std::string& port); + inline void setFloatValue(Arts::Object node, const std::string& port, float value); + inline Arts::FlowSystemReceiver createReceiver(Arts::Object destObject, const std::string& destPort, Arts::FlowSystemSender sender); +}; + +class ARTS_EXPORT GlobalComm_base : virtual public Arts::Object_base { +public: + static unsigned long _IID; // interface ID + + static GlobalComm_base *_create(const std::string& subClass = "Arts::GlobalComm"); + static GlobalComm_base *_fromString(std::string objectref); + static GlobalComm_base *_fromReference(Arts::ObjectReference ref, bool needcopy); + + static GlobalComm_base *_fromDynamicCast(const Arts::Object& object); + inline GlobalComm_base *_copy() { + assert(_refCnt > 0); + _refCnt++; + return this; + } + + virtual std::vector<std::string> _defaultPortsIn() const; + virtual std::vector<std::string> _defaultPortsOut() const; + + void *_cast(unsigned long iid); + + virtual bool put(const std::string& variable, const std::string& value) = 0; + virtual std::string get(const std::string& variable) = 0; + virtual void erase(const std::string& variable) = 0; +}; + +class ARTS_EXPORT GlobalComm_stub : virtual public GlobalComm_base, virtual public Arts::Object_stub { +protected: + GlobalComm_stub(); + +public: + GlobalComm_stub(Arts::Connection *connection, long objectID); + + bool put(const std::string& variable, const std::string& value); + std::string get(const std::string& variable); + void erase(const std::string& variable); +}; + +class ARTS_EXPORT GlobalComm_skel : virtual public GlobalComm_base, virtual public Arts::Object_skel { +public: + GlobalComm_skel(); + + static std::string _interfaceNameSkel(); + std::string _interfaceName(); + bool _isCompatibleWith(const std::string& interfacename); + void _buildMethodTable(); + void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID); +}; + +} +#include "reference.h" +namespace Arts { +class ARTS_EXPORT GlobalComm : public Arts::Object { +private: + static Arts::Object_base* _Creator(); + GlobalComm_base *_cache; + inline GlobalComm_base *_method_call() { + _pool->checkcreate(); + if(_pool->base) { + _cache=(GlobalComm_base *)_pool->base->_cast(GlobalComm_base::_IID); + assert(_cache); + } + return _cache; + } + +protected: + inline GlobalComm(GlobalComm_base* b) : Arts::Object(b), _cache(0) {} + + +public: + typedef GlobalComm_base _base_class; + + inline GlobalComm() : Arts::Object(_Creator), _cache(0) {} + inline GlobalComm(const Arts::SubClass& s) : + Arts::Object(GlobalComm_base::_create(s.string())), _cache(0) {} + inline GlobalComm(const Arts::Reference &r) : + Arts::Object(r.isString()?(GlobalComm_base::_fromString(r.string())):(GlobalComm_base::_fromReference(r.reference(),true))), _cache(0) {} + inline GlobalComm(const Arts::DynamicCast& c) : Arts::Object(GlobalComm_base::_fromDynamicCast(c.object())), _cache(0) {} + inline GlobalComm(const GlobalComm& target) : Arts::Object(target._pool), _cache(target._cache) {} + inline GlobalComm(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {} + inline static GlobalComm null() {return GlobalComm((GlobalComm_base*)0);} + inline static GlobalComm _from_base(GlobalComm_base* b) {return GlobalComm(b);} + inline GlobalComm& operator=(const GlobalComm& target) { + if (_pool == target._pool) return *this; + _pool->Dec(); + _pool = target._pool; + _cache = target._cache; + _pool->Inc(); + return *this; + } + inline GlobalComm_base* _base() {return _cache?_cache:_method_call();} + + inline bool put(const std::string& variable, const std::string& value); + inline std::string get(const std::string& variable); + inline void erase(const std::string& variable); +}; + +class ARTS_EXPORT TmpGlobalComm_base : virtual public Arts::GlobalComm_base { +public: + static unsigned long _IID; // interface ID + + static TmpGlobalComm_base *_create(const std::string& subClass = "Arts::TmpGlobalComm"); + static TmpGlobalComm_base *_fromString(std::string objectref); + static TmpGlobalComm_base *_fromReference(Arts::ObjectReference ref, bool needcopy); + + static TmpGlobalComm_base *_fromDynamicCast(const Arts::Object& object); + inline TmpGlobalComm_base *_copy() { + assert(_refCnt > 0); + _refCnt++; + return this; + } + + virtual std::vector<std::string> _defaultPortsIn() const; + virtual std::vector<std::string> _defaultPortsOut() const; + + void *_cast(unsigned long iid); + +}; + +class ARTS_EXPORT TmpGlobalComm_stub : virtual public TmpGlobalComm_base, virtual public Arts::GlobalComm_stub { +protected: + TmpGlobalComm_stub(); + +public: + TmpGlobalComm_stub(Arts::Connection *connection, long objectID); + +}; + +class ARTS_EXPORT TmpGlobalComm_skel : virtual public TmpGlobalComm_base, virtual public Arts::GlobalComm_skel { +public: + TmpGlobalComm_skel(); + + static std::string _interfaceNameSkel(); + std::string _interfaceName(); + bool _isCompatibleWith(const std::string& interfacename); + void _buildMethodTable(); + void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID); +}; + +} +#include "reference.h" +namespace Arts { +class ARTS_EXPORT TmpGlobalComm : public Arts::Object { +private: + static Arts::Object_base* _Creator(); + TmpGlobalComm_base *_cache; + inline TmpGlobalComm_base *_method_call() { + _pool->checkcreate(); + if(_pool->base) { + _cache=(TmpGlobalComm_base *)_pool->base->_cast(TmpGlobalComm_base::_IID); + assert(_cache); + } + return _cache; + } + +protected: + inline TmpGlobalComm(TmpGlobalComm_base* b) : Arts::Object(b), _cache(0) {} + + +public: + typedef TmpGlobalComm_base _base_class; + + inline TmpGlobalComm() : Arts::Object(_Creator), _cache(0) {} + inline TmpGlobalComm(const Arts::SubClass& s) : + Arts::Object(TmpGlobalComm_base::_create(s.string())), _cache(0) {} + inline TmpGlobalComm(const Arts::Reference &r) : + Arts::Object(r.isString()?(TmpGlobalComm_base::_fromString(r.string())):(TmpGlobalComm_base::_fromReference(r.reference(),true))), _cache(0) {} + inline TmpGlobalComm(const Arts::DynamicCast& c) : Arts::Object(TmpGlobalComm_base::_fromDynamicCast(c.object())), _cache(0) {} + inline TmpGlobalComm(const TmpGlobalComm& target) : Arts::Object(target._pool), _cache(target._cache) {} + inline TmpGlobalComm(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {} + inline static TmpGlobalComm null() {return TmpGlobalComm((TmpGlobalComm_base*)0);} + inline static TmpGlobalComm _from_base(TmpGlobalComm_base* b) {return TmpGlobalComm(b);} + inline TmpGlobalComm& operator=(const TmpGlobalComm& target) { + if (_pool == target._pool) return *this; + _pool->Dec(); + _pool = target._pool; + _cache = target._cache; + _pool->Inc(); + return *this; + } + inline operator Arts::GlobalComm() const { return Arts::GlobalComm(*_pool); } + inline TmpGlobalComm_base* _base() {return _cache?_cache:_method_call();} + + inline bool put(const std::string& variable, const std::string& value); + inline std::string get(const std::string& variable); + inline void erase(const std::string& variable); +}; + +class ARTS_EXPORT TraderOffer_base : virtual public Arts::Object_base { +public: + static unsigned long _IID; // interface ID + + static TraderOffer_base *_create(const std::string& subClass = "Arts::TraderOffer"); + static TraderOffer_base *_fromString(std::string objectref); + static TraderOffer_base *_fromReference(Arts::ObjectReference ref, bool needcopy); + + static TraderOffer_base *_fromDynamicCast(const Arts::Object& object); + inline TraderOffer_base *_copy() { + assert(_refCnt > 0); + _refCnt++; + return this; + } + + virtual std::vector<std::string> _defaultPortsIn() const; + virtual std::vector<std::string> _defaultPortsOut() const; + + void *_cast(unsigned long iid); + + virtual std::string interfaceName() = 0; + virtual std::vector<std::string> * getProperty(const std::string& name) = 0; +}; + +class ARTS_EXPORT TraderOffer_stub : virtual public TraderOffer_base, virtual public Arts::Object_stub { +protected: + TraderOffer_stub(); + +public: + TraderOffer_stub(Arts::Connection *connection, long objectID); + + std::string interfaceName(); + std::vector<std::string> * getProperty(const std::string& name); +}; + +class ARTS_EXPORT TraderOffer_skel : virtual public TraderOffer_base, virtual public Arts::Object_skel { +protected: + // emitters for change notifications + inline void interfaceName_changed(const std::string& newValue) { + _emit_changed("interfaceName_changed",newValue); + } + +public: + TraderOffer_skel(); + + static std::string _interfaceNameSkel(); + std::string _interfaceName(); + bool _isCompatibleWith(const std::string& interfacename); + void _buildMethodTable(); + void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID); +}; + +} +#include "reference.h" +namespace Arts { +class ARTS_EXPORT TraderOffer : public Arts::Object { +private: + static Arts::Object_base* _Creator(); + TraderOffer_base *_cache; + inline TraderOffer_base *_method_call() { + _pool->checkcreate(); + if(_pool->base) { + _cache=(TraderOffer_base *)_pool->base->_cast(TraderOffer_base::_IID); + assert(_cache); + } + return _cache; + } + +protected: + inline TraderOffer(TraderOffer_base* b) : Arts::Object(b), _cache(0) {} + + +public: + typedef TraderOffer_base _base_class; + + inline TraderOffer() : Arts::Object(_Creator), _cache(0) {} + inline TraderOffer(const Arts::SubClass& s) : + Arts::Object(TraderOffer_base::_create(s.string())), _cache(0) {} + inline TraderOffer(const Arts::Reference &r) : + Arts::Object(r.isString()?(TraderOffer_base::_fromString(r.string())):(TraderOffer_base::_fromReference(r.reference(),true))), _cache(0) {} + inline TraderOffer(const Arts::DynamicCast& c) : Arts::Object(TraderOffer_base::_fromDynamicCast(c.object())), _cache(0) {} + inline TraderOffer(const TraderOffer& target) : Arts::Object(target._pool), _cache(target._cache) {} + inline TraderOffer(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {} + inline static TraderOffer null() {return TraderOffer((TraderOffer_base*)0);} + inline static TraderOffer _from_base(TraderOffer_base* b) {return TraderOffer(b);} + inline TraderOffer& operator=(const TraderOffer& target) { + if (_pool == target._pool) return *this; + _pool->Dec(); + _pool = target._pool; + _cache = target._cache; + _pool->Inc(); + return *this; + } + inline TraderOffer_base* _base() {return _cache?_cache:_method_call();} + + inline std::string interfaceName(); + inline std::vector<std::string> * getProperty(const std::string& name); +}; + +class ARTS_EXPORT TraderQuery_base : virtual public Arts::Object_base { +public: + static unsigned long _IID; // interface ID + + static TraderQuery_base *_create(const std::string& subClass = "Arts::TraderQuery"); + static TraderQuery_base *_fromString(std::string objectref); + static TraderQuery_base *_fromReference(Arts::ObjectReference ref, bool needcopy); + + static TraderQuery_base *_fromDynamicCast(const Arts::Object& object); + inline TraderQuery_base *_copy() { + assert(_refCnt > 0); + _refCnt++; + return this; + } + + virtual std::vector<std::string> _defaultPortsIn() const; + virtual std::vector<std::string> _defaultPortsOut() const; + + void *_cast(unsigned long iid); + + virtual void supports(const std::string& property, const std::string& value) = 0; + virtual std::vector<Arts::TraderOffer> * query() = 0; +}; + +class ARTS_EXPORT TraderQuery_stub : virtual public TraderQuery_base, virtual public Arts::Object_stub { +protected: + TraderQuery_stub(); + +public: + TraderQuery_stub(Arts::Connection *connection, long objectID); + + void supports(const std::string& property, const std::string& value); + std::vector<Arts::TraderOffer> * query(); +}; + +class ARTS_EXPORT TraderQuery_skel : virtual public TraderQuery_base, virtual public Arts::Object_skel { +public: + TraderQuery_skel(); + + static std::string _interfaceNameSkel(); + std::string _interfaceName(); + bool _isCompatibleWith(const std::string& interfacename); + void _buildMethodTable(); + void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID); +}; + +} +#include "reference.h" +namespace Arts { +class ARTS_EXPORT TraderQuery : public Arts::Object { +private: + static Arts::Object_base* _Creator(); + TraderQuery_base *_cache; + inline TraderQuery_base *_method_call() { + _pool->checkcreate(); + if(_pool->base) { + _cache=(TraderQuery_base *)_pool->base->_cast(TraderQuery_base::_IID); + assert(_cache); + } + return _cache; + } + +protected: + inline TraderQuery(TraderQuery_base* b) : Arts::Object(b), _cache(0) {} + + +public: + typedef TraderQuery_base _base_class; + + inline TraderQuery() : Arts::Object(_Creator), _cache(0) {} + inline TraderQuery(const Arts::SubClass& s) : + Arts::Object(TraderQuery_base::_create(s.string())), _cache(0) {} + inline TraderQuery(const Arts::Reference &r) : + Arts::Object(r.isString()?(TraderQuery_base::_fromString(r.string())):(TraderQuery_base::_fromReference(r.reference(),true))), _cache(0) {} + inline TraderQuery(const Arts::DynamicCast& c) : Arts::Object(TraderQuery_base::_fromDynamicCast(c.object())), _cache(0) {} + inline TraderQuery(const TraderQuery& target) : Arts::Object(target._pool), _cache(target._cache) {} + inline TraderQuery(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {} + inline static TraderQuery null() {return TraderQuery((TraderQuery_base*)0);} + inline static TraderQuery _from_base(TraderQuery_base* b) {return TraderQuery(b);} + inline TraderQuery& operator=(const TraderQuery& target) { + if (_pool == target._pool) return *this; + _pool->Dec(); + _pool = target._pool; + _cache = target._cache; + _pool->Inc(); + return *this; + } + inline TraderQuery_base* _base() {return _cache?_cache:_method_call();} + + inline void supports(const std::string& property, const std::string& value); + inline std::vector<Arts::TraderOffer> * query(); +}; + +class ARTS_EXPORT Loader_base : virtual public Arts::Object_base { +public: + static unsigned long _IID; // interface ID + + static Loader_base *_create(const std::string& subClass = "Arts::Loader"); + static Loader_base *_fromString(std::string objectref); + static Loader_base *_fromReference(Arts::ObjectReference ref, bool needcopy); + + static Loader_base *_fromDynamicCast(const Arts::Object& object); + inline Loader_base *_copy() { + assert(_refCnt > 0); + _refCnt++; + return this; + } + + virtual std::vector<std::string> _defaultPortsIn() const; + virtual std::vector<std::string> _defaultPortsOut() const; + + void *_cast(unsigned long iid); + + virtual std::string dataVersion() = 0; + virtual std::vector<Arts::TraderEntry> * traderEntries() = 0; + virtual std::vector<Arts::ModuleDef> * modules() = 0; + virtual Arts::Object loadObject(Arts::TraderOffer offer) = 0; +}; + +class ARTS_EXPORT Loader_stub : virtual public Loader_base, virtual public Arts::Object_stub { +protected: + Loader_stub(); + +public: + Loader_stub(Arts::Connection *connection, long objectID); + + std::string dataVersion(); + std::vector<Arts::TraderEntry> * traderEntries(); + std::vector<Arts::ModuleDef> * modules(); + Arts::Object loadObject(Arts::TraderOffer offer); +}; + +class ARTS_EXPORT Loader_skel : virtual public Loader_base, virtual public Arts::Object_skel { +protected: + // emitters for change notifications + inline void dataVersion_changed(const std::string& newValue) { + _emit_changed("dataVersion_changed",newValue); + } + +public: + Loader_skel(); + + static std::string _interfaceNameSkel(); + std::string _interfaceName(); + bool _isCompatibleWith(const std::string& interfacename); + void _buildMethodTable(); + void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID); +}; + +} +#include "reference.h" +namespace Arts { +class ARTS_EXPORT Loader : public Arts::Object { +private: + static Arts::Object_base* _Creator(); + Loader_base *_cache; + inline Loader_base *_method_call() { + _pool->checkcreate(); + if(_pool->base) { + _cache=(Loader_base *)_pool->base->_cast(Loader_base::_IID); + assert(_cache); + } + return _cache; + } + +protected: + inline Loader(Loader_base* b) : Arts::Object(b), _cache(0) {} + + +public: + typedef Loader_base _base_class; + + inline Loader() : Arts::Object(_Creator), _cache(0) {} + inline Loader(const Arts::SubClass& s) : + Arts::Object(Loader_base::_create(s.string())), _cache(0) {} + inline Loader(const Arts::Reference &r) : + Arts::Object(r.isString()?(Loader_base::_fromString(r.string())):(Loader_base::_fromReference(r.reference(),true))), _cache(0) {} + inline Loader(const Arts::DynamicCast& c) : Arts::Object(Loader_base::_fromDynamicCast(c.object())), _cache(0) {} + inline Loader(const Loader& target) : Arts::Object(target._pool), _cache(target._cache) {} + inline Loader(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {} + inline static Loader null() {return Loader((Loader_base*)0);} + inline static Loader _from_base(Loader_base* b) {return Loader(b);} + inline Loader& operator=(const Loader& target) { + if (_pool == target._pool) return *this; + _pool->Dec(); + _pool = target._pool; + _cache = target._cache; + _pool->Inc(); + return *this; + } + inline Loader_base* _base() {return _cache?_cache:_method_call();} + + inline std::string dataVersion(); + inline std::vector<Arts::TraderEntry> * traderEntries(); + inline std::vector<Arts::ModuleDef> * modules(); + inline Arts::Object loadObject(Arts::TraderOffer offer); +}; + +} +// Forward wrapper calls to _base classes: + +inline long Arts::InterfaceRepo::insertModule(const Arts::ModuleDef& newModule) +{ + return _cache?static_cast<Arts::InterfaceRepo_base*>(_cache)->insertModule(newModule):static_cast<Arts::InterfaceRepo_base*>(_method_call())->insertModule(newModule); +} + +inline void Arts::InterfaceRepo::removeModule(long moduleID) +{ + _cache?static_cast<Arts::InterfaceRepo_base*>(_cache)->removeModule(moduleID):static_cast<Arts::InterfaceRepo_base*>(_method_call())->removeModule(moduleID); +} + +inline Arts::InterfaceDef Arts::InterfaceRepo::queryInterface(const std::string& name) +{ + return _cache?static_cast<Arts::InterfaceRepo_base*>(_cache)->queryInterface(name):static_cast<Arts::InterfaceRepo_base*>(_method_call())->queryInterface(name); +} + +inline Arts::TypeDef Arts::InterfaceRepo::queryType(const std::string& name) +{ + return _cache?static_cast<Arts::InterfaceRepo_base*>(_cache)->queryType(name):static_cast<Arts::InterfaceRepo_base*>(_method_call())->queryType(name); +} + +inline Arts::EnumDef Arts::InterfaceRepo::queryEnum(const std::string& name) +{ + return _cache?static_cast<Arts::InterfaceRepo_base*>(_cache)->queryEnum(name):static_cast<Arts::InterfaceRepo_base*>(_method_call())->queryEnum(name); +} + +inline std::vector<std::string> * Arts::InterfaceRepo::queryChildren(const std::string& name) +{ + return _cache?static_cast<Arts::InterfaceRepo_base*>(_cache)->queryChildren(name):static_cast<Arts::InterfaceRepo_base*>(_method_call())->queryChildren(name); +} + +inline std::vector<std::string> * Arts::InterfaceRepo::queryInterfaces() +{ + return _cache?static_cast<Arts::InterfaceRepo_base*>(_cache)->queryInterfaces():static_cast<Arts::InterfaceRepo_base*>(_method_call())->queryInterfaces(); +} + +inline std::vector<std::string> * Arts::InterfaceRepo::queryTypes() +{ + return _cache?static_cast<Arts::InterfaceRepo_base*>(_cache)->queryTypes():static_cast<Arts::InterfaceRepo_base*>(_method_call())->queryTypes(); +} + +inline std::vector<std::string> * Arts::InterfaceRepo::queryEnums() +{ + return _cache?static_cast<Arts::InterfaceRepo_base*>(_cache)->queryEnums():static_cast<Arts::InterfaceRepo_base*>(_method_call())->queryEnums(); +} + +inline long Arts::InterfaceRepoV2::insertModule(const Arts::ModuleDef& newModule) +{ + return _cache?static_cast<Arts::InterfaceRepo_base*>(_cache)->insertModule(newModule):static_cast<Arts::InterfaceRepo_base*>(_method_call())->insertModule(newModule); +} + +inline void Arts::InterfaceRepoV2::removeModule(long moduleID) +{ + _cache?static_cast<Arts::InterfaceRepo_base*>(_cache)->removeModule(moduleID):static_cast<Arts::InterfaceRepo_base*>(_method_call())->removeModule(moduleID); +} + +inline Arts::InterfaceDef Arts::InterfaceRepoV2::queryInterface(const std::string& name) +{ + return _cache?static_cast<Arts::InterfaceRepo_base*>(_cache)->queryInterface(name):static_cast<Arts::InterfaceRepo_base*>(_method_call())->queryInterface(name); +} + +inline Arts::TypeDef Arts::InterfaceRepoV2::queryType(const std::string& name) +{ + return _cache?static_cast<Arts::InterfaceRepo_base*>(_cache)->queryType(name):static_cast<Arts::InterfaceRepo_base*>(_method_call())->queryType(name); +} + +inline Arts::EnumDef Arts::InterfaceRepoV2::queryEnum(const std::string& name) +{ + return _cache?static_cast<Arts::InterfaceRepo_base*>(_cache)->queryEnum(name):static_cast<Arts::InterfaceRepo_base*>(_method_call())->queryEnum(name); +} + +inline std::vector<std::string> * Arts::InterfaceRepoV2::queryChildren(const std::string& name) +{ + return _cache?static_cast<Arts::InterfaceRepo_base*>(_cache)->queryChildren(name):static_cast<Arts::InterfaceRepo_base*>(_method_call())->queryChildren(name); +} + +inline std::vector<std::string> * Arts::InterfaceRepoV2::queryInterfaces() +{ + return _cache?static_cast<Arts::InterfaceRepo_base*>(_cache)->queryInterfaces():static_cast<Arts::InterfaceRepo_base*>(_method_call())->queryInterfaces(); +} + +inline std::vector<std::string> * Arts::InterfaceRepoV2::queryTypes() +{ + return _cache?static_cast<Arts::InterfaceRepo_base*>(_cache)->queryTypes():static_cast<Arts::InterfaceRepo_base*>(_method_call())->queryTypes(); +} + +inline std::vector<std::string> * Arts::InterfaceRepoV2::queryEnums() +{ + return _cache?static_cast<Arts::InterfaceRepo_base*>(_cache)->queryEnums():static_cast<Arts::InterfaceRepo_base*>(_method_call())->queryEnums(); +} + +inline Arts::TypeIdentification Arts::InterfaceRepoV2::identifyType(const std::string& name) +{ + return _cache?static_cast<Arts::InterfaceRepoV2_base*>(_cache)->identifyType(name):static_cast<Arts::InterfaceRepoV2_base*>(_method_call())->identifyType(name); +} + +inline void Arts::FlowSystemSender::processed() +{ + _cache?static_cast<Arts::FlowSystemSender_base*>(_cache)->processed():static_cast<Arts::FlowSystemSender_base*>(_method_call())->processed(); +} + +inline void Arts::FlowSystemSender::disconnect() +{ + _cache?static_cast<Arts::FlowSystemSender_base*>(_cache)->disconnect():static_cast<Arts::FlowSystemSender_base*>(_method_call())->disconnect(); +} + +inline long Arts::FlowSystemReceiver::receiveHandlerID() +{ + return _cache?static_cast<Arts::FlowSystemReceiver_base*>(_cache)->receiveHandlerID():static_cast<Arts::FlowSystemReceiver_base*>(_method_call())->receiveHandlerID(); +} + +inline void Arts::FlowSystemReceiver::disconnect() +{ + _cache?static_cast<Arts::FlowSystemReceiver_base*>(_cache)->disconnect():static_cast<Arts::FlowSystemReceiver_base*>(_method_call())->disconnect(); +} + +inline void Arts::FlowSystem::startObject(Arts::Object node) +{ + _cache?static_cast<Arts::FlowSystem_base*>(_cache)->startObject(node):static_cast<Arts::FlowSystem_base*>(_method_call())->startObject(node); +} + +inline void Arts::FlowSystem::stopObject(Arts::Object node) +{ + _cache?static_cast<Arts::FlowSystem_base*>(_cache)->stopObject(node):static_cast<Arts::FlowSystem_base*>(_method_call())->stopObject(node); +} + +inline void Arts::FlowSystem::connectObject(Arts::Object sourceObject, const std::string& sourcePort, Arts::Object destObject, const std::string& destPort) +{ + _cache?static_cast<Arts::FlowSystem_base*>(_cache)->connectObject(sourceObject, sourcePort, destObject, destPort):static_cast<Arts::FlowSystem_base*>(_method_call())->connectObject(sourceObject, sourcePort, destObject, destPort); +} + +inline void Arts::FlowSystem::disconnectObject(Arts::Object sourceObject, const std::string& sourcePort, Arts::Object destObject, const std::string& destPort) +{ + _cache?static_cast<Arts::FlowSystem_base*>(_cache)->disconnectObject(sourceObject, sourcePort, destObject, destPort):static_cast<Arts::FlowSystem_base*>(_method_call())->disconnectObject(sourceObject, sourcePort, destObject, destPort); +} + +inline Arts::AttributeType Arts::FlowSystem::queryFlags(Arts::Object node, const std::string& port) +{ + return _cache?static_cast<Arts::FlowSystem_base*>(_cache)->queryFlags(node, port):static_cast<Arts::FlowSystem_base*>(_method_call())->queryFlags(node, port); +} + +inline void Arts::FlowSystem::setFloatValue(Arts::Object node, const std::string& port, float value) +{ + _cache?static_cast<Arts::FlowSystem_base*>(_cache)->setFloatValue(node, port, value):static_cast<Arts::FlowSystem_base*>(_method_call())->setFloatValue(node, port, value); +} + +inline Arts::FlowSystemReceiver Arts::FlowSystem::createReceiver(Arts::Object destObject, const std::string& destPort, Arts::FlowSystemSender sender) +{ + return _cache?static_cast<Arts::FlowSystem_base*>(_cache)->createReceiver(destObject, destPort, sender):static_cast<Arts::FlowSystem_base*>(_method_call())->createReceiver(destObject, destPort, sender); +} + +inline bool Arts::GlobalComm::put(const std::string& variable, const std::string& value) +{ + return _cache?static_cast<Arts::GlobalComm_base*>(_cache)->put(variable, value):static_cast<Arts::GlobalComm_base*>(_method_call())->put(variable, value); +} + +inline std::string Arts::GlobalComm::get(const std::string& variable) +{ + return _cache?static_cast<Arts::GlobalComm_base*>(_cache)->get(variable):static_cast<Arts::GlobalComm_base*>(_method_call())->get(variable); +} + +inline void Arts::GlobalComm::erase(const std::string& variable) +{ + _cache?static_cast<Arts::GlobalComm_base*>(_cache)->erase(variable):static_cast<Arts::GlobalComm_base*>(_method_call())->erase(variable); +} + +inline bool Arts::TmpGlobalComm::put(const std::string& variable, const std::string& value) +{ + return _cache?static_cast<Arts::GlobalComm_base*>(_cache)->put(variable, value):static_cast<Arts::GlobalComm_base*>(_method_call())->put(variable, value); +} + +inline std::string Arts::TmpGlobalComm::get(const std::string& variable) +{ + return _cache?static_cast<Arts::GlobalComm_base*>(_cache)->get(variable):static_cast<Arts::GlobalComm_base*>(_method_call())->get(variable); +} + +inline void Arts::TmpGlobalComm::erase(const std::string& variable) +{ + _cache?static_cast<Arts::GlobalComm_base*>(_cache)->erase(variable):static_cast<Arts::GlobalComm_base*>(_method_call())->erase(variable); +} + +inline std::string Arts::TraderOffer::interfaceName() +{ + return _cache?static_cast<Arts::TraderOffer_base*>(_cache)->interfaceName():static_cast<Arts::TraderOffer_base*>(_method_call())->interfaceName(); +} + +inline std::vector<std::string> * Arts::TraderOffer::getProperty(const std::string& name) +{ + return _cache?static_cast<Arts::TraderOffer_base*>(_cache)->getProperty(name):static_cast<Arts::TraderOffer_base*>(_method_call())->getProperty(name); +} + +inline void Arts::TraderQuery::supports(const std::string& property, const std::string& value) +{ + _cache?static_cast<Arts::TraderQuery_base*>(_cache)->supports(property, value):static_cast<Arts::TraderQuery_base*>(_method_call())->supports(property, value); +} + +inline std::vector<Arts::TraderOffer> * Arts::TraderQuery::query() +{ + return _cache?static_cast<Arts::TraderQuery_base*>(_cache)->query():static_cast<Arts::TraderQuery_base*>(_method_call())->query(); +} + +inline std::string Arts::Loader::dataVersion() +{ + return _cache?static_cast<Arts::Loader_base*>(_cache)->dataVersion():static_cast<Arts::Loader_base*>(_method_call())->dataVersion(); +} + +inline std::vector<Arts::TraderEntry> * Arts::Loader::traderEntries() +{ + return _cache?static_cast<Arts::Loader_base*>(_cache)->traderEntries():static_cast<Arts::Loader_base*>(_method_call())->traderEntries(); +} + +inline std::vector<Arts::ModuleDef> * Arts::Loader::modules() +{ + return _cache?static_cast<Arts::Loader_base*>(_cache)->modules():static_cast<Arts::Loader_base*>(_method_call())->modules(); +} + +inline Arts::Object Arts::Loader::loadObject(Arts::TraderOffer offer) +{ + return _cache?static_cast<Arts::Loader_base*>(_cache)->loadObject(offer):static_cast<Arts::Loader_base*>(_method_call())->loadObject(offer); +} + +#endif /* CORE_H */ |