home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Linux / SLAX 6.0.8 / slax-6.0.8.iso / slax / base / 006-devel.lzm / usr / include / arts / artsbuilder.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-10-24  |  64.0 KB  |  1,737 lines
  1. /* this file was generated by the MCOP idl compiler - DO NOT EDIT */
  2.  
  3. #ifndef ARTSBUILDER_H
  4. #define ARTSBUILDER_H
  5.  
  6. #include "common.h"
  7.  
  8. #include "arts_export.h"
  9.  
  10. // includes of other idl definitions
  11. #include "core.h"
  12. #include "artsflow.h"
  13.  
  14. namespace Arts {
  15. enum PortDirection {input = 0, output = 1};
  16. enum PortConnType {conn_stream = 0, conn_event = 1, conn_property = 2};
  17. }
  18. namespace Arts {
  19. class ARTS_EXPORT PortType : public Arts::Type {
  20. public:
  21.     PortType();
  22.     PortType(Arts::PortDirection _a_direction, const std::string& _a_dataType, Arts::PortConnType _a_connType, bool _a_isMultiPort);
  23.     PortType(Arts::Buffer& stream);
  24.     PortType(const PortType& copyType);
  25.     PortType& operator=(const PortType& assignType);
  26.     Arts::PortDirection direction;
  27.     std::string dataType;
  28.     Arts::PortConnType connType;
  29.     bool isMultiPort;
  30.  
  31. // marshalling functions
  32.     void readType(Arts::Buffer& stream);
  33.     void writeType(Arts::Buffer& stream) const;
  34.     std::string _typeName() const;
  35. };
  36.  
  37. class ARTS_EXPORT ModuleInfo : public Arts::Type {
  38. public:
  39.     ModuleInfo();
  40.     ModuleInfo(const std::string& _a_name, const std::vector<Arts::PortType>& _a_ports, const std::vector<std::string>& _a_portnames, bool _a_isInterface, bool _a_isStructure);
  41.     ModuleInfo(Arts::Buffer& stream);
  42.     ModuleInfo(const ModuleInfo& copyType);
  43.     ModuleInfo& operator=(const ModuleInfo& assignType);
  44.     std::string name;
  45.     std::vector<Arts::PortType> ports;
  46.     std::vector<std::string> portnames;
  47.     bool isInterface;
  48.     bool isStructure;
  49.  
  50. // marshalling functions
  51.     void readType(Arts::Buffer& stream);
  52.     void writeType(Arts::Buffer& stream) const;
  53.     std::string _typeName() const;
  54. };
  55.  
  56. }
  57. namespace Arts {
  58. class PortDesc;
  59. class ModuleDesc;
  60. class StructureDesc;
  61. class StructurePortDesc;
  62. class ObjectFactory;
  63. class LocalFactory;
  64. class StructureBuilder;
  65. class ArtsBuilderLoader;
  66. class Structure;
  67.  
  68. class ARTS_EXPORT PortDesc_base : virtual public Arts::Object_base {
  69. public:
  70.     static unsigned long _IID; // interface ID
  71.  
  72.     static PortDesc_base *_create(const std::string& subClass = "Arts::PortDesc");
  73.     static PortDesc_base *_fromString(const std::string& objectref);
  74.     static PortDesc_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  75.  
  76.     static PortDesc_base *_fromDynamicCast(const Arts::Object& object);
  77.     inline PortDesc_base *_copy() {
  78.         assert(_refCnt > 0);
  79.         _refCnt++;
  80.         return this;
  81.     }
  82.  
  83.     virtual std::vector<std::string> _defaultPortsIn() const;
  84.     virtual std::vector<std::string> _defaultPortsOut() const;
  85.  
  86.     void *_cast(unsigned long iid);
  87.  
  88.     virtual long ID() = 0;
  89.     virtual Arts::ModuleDesc parent() = 0;
  90.     virtual std::string name() = 0;
  91.     virtual Arts::PortType type() = 0;
  92.     virtual bool isConnected() = 0;
  93.     virtual bool hasValue() = 0;
  94.     virtual void hasValue(bool newValue) = 0;
  95.     virtual std::vector<Arts::PortDesc> * connections() = 0;
  96.     virtual float floatValue() = 0;
  97.     virtual void floatValue(float newValue) = 0;
  98.     virtual std::string stringValue() = 0;
  99.     virtual void stringValue(const std::string& newValue) = 0;
  100.     virtual Arts::Any value() = 0;
  101.     virtual void value(const Arts::Any& newValue) = 0;
  102.     virtual long internalOldID() = 0;
  103.     virtual void constructor(Arts::ModuleDesc parent, const std::string& name, const Arts::PortType& type) = 0;
  104.     virtual bool connectTo(Arts::PortDesc port) = 0;
  105.     virtual void disconnectFrom(Arts::PortDesc port) = 0;
  106.     virtual void disconnectAll() = 0;
  107.     virtual std::vector<std::string> * saveToList() = 0;
  108.     virtual void loadFromList(const std::vector<std::string>& list) = 0;
  109.     virtual void internalConnectInput(Arts::PortDesc port) = 0;
  110.     virtual void internalReConnect(const std::vector<Arts::PortDesc>& allports) = 0;
  111. };
  112.  
  113. class ARTS_EXPORT PortDesc_stub : virtual public PortDesc_base, virtual public Arts::Object_stub {
  114. protected:
  115.     PortDesc_stub();
  116.  
  117. public:
  118.     PortDesc_stub(Arts::Connection *connection, long objectID);
  119.  
  120.     long ID();
  121.     Arts::ModuleDesc parent();
  122.     std::string name();
  123.     Arts::PortType type();
  124.     bool isConnected();
  125.     bool hasValue();
  126.     void hasValue(bool newValue);
  127.     std::vector<Arts::PortDesc> * connections();
  128.     float floatValue();
  129.     void floatValue(float newValue);
  130.     std::string stringValue();
  131.     void stringValue(const std::string& newValue);
  132.     Arts::Any value();
  133.     void value(const Arts::Any& newValue);
  134.     long internalOldID();
  135.     void constructor(Arts::ModuleDesc parent, const std::string& name, const Arts::PortType& type);
  136.     bool connectTo(Arts::PortDesc port);
  137.     void disconnectFrom(Arts::PortDesc port);
  138.     void disconnectAll();
  139.     std::vector<std::string> * saveToList();
  140.     void loadFromList(const std::vector<std::string>& list);
  141.     void internalConnectInput(Arts::PortDesc port);
  142.     void internalReConnect(const std::vector<Arts::PortDesc>& allports);
  143. };
  144.  
  145. class ARTS_EXPORT PortDesc_skel : virtual public PortDesc_base, virtual public Arts::Object_skel {
  146. protected:
  147.     // emitters for change notifications
  148.     inline void ID_changed(long newValue) {
  149.         _emit_changed("ID_changed",newValue);
  150.     }
  151.     inline void name_changed(const std::string& newValue) {
  152.         _emit_changed("name_changed",newValue);
  153.     }
  154.     inline void isConnected_changed(bool newValue) {
  155.         _emit_changed("isConnected_changed",newValue);
  156.     }
  157.     inline void hasValue_changed(bool newValue) {
  158.         _emit_changed("hasValue_changed",newValue);
  159.     }
  160.     inline void floatValue_changed(float newValue) {
  161.         _emit_changed("floatValue_changed",newValue);
  162.     }
  163.     inline void stringValue_changed(const std::string& newValue) {
  164.         _emit_changed("stringValue_changed",newValue);
  165.     }
  166.     inline void internalOldID_changed(long newValue) {
  167.         _emit_changed("internalOldID_changed",newValue);
  168.     }
  169.  
  170. public:
  171.     PortDesc_skel();
  172.  
  173.     static std::string _interfaceNameSkel();
  174.     std::string _interfaceName();
  175.     bool _isCompatibleWith(const std::string& interfacename);
  176.     void _buildMethodTable();
  177.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  178. };
  179.  
  180. }
  181. #include "reference.h"
  182. namespace Arts {
  183. class ARTS_EXPORT PortDesc : public Arts::Object {
  184. private:
  185.     static Arts::Object_base* _Creator();
  186.     PortDesc_base *_cache;
  187.     inline PortDesc_base *_method_call() {
  188.         _pool->checkcreate();
  189.         if(_pool->base) {
  190.             _cache=(PortDesc_base *)_pool->base->_cast(PortDesc_base::_IID);
  191.             assert(_cache);
  192.         }
  193.         return _cache;
  194.     }
  195.  
  196. protected:
  197.     inline PortDesc(PortDesc_base* b) : Arts::Object(b), _cache(0) {}
  198.  
  199.  
  200. public:
  201.     typedef PortDesc_base _base_class;
  202.  
  203.     inline PortDesc() : Arts::Object(_Creator), _cache(0) {}
  204.     inline PortDesc(const Arts::SubClass& s) :
  205.         Arts::Object(PortDesc_base::_create(s.string())), _cache(0) {}
  206.     inline PortDesc(const Arts::Reference &r) :
  207.         Arts::Object(r.isString()?(PortDesc_base::_fromString(r.string())):(PortDesc_base::_fromReference(r.reference(),true))), _cache(0) {}
  208.     inline PortDesc(const Arts::DynamicCast& c) : Arts::Object(PortDesc_base::_fromDynamicCast(c.object())), _cache(0) {}
  209.     inline PortDesc(const PortDesc& target) : Arts::Object(target._pool), _cache(target._cache) {}
  210.     inline PortDesc(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  211.     inline static PortDesc null() {return PortDesc((PortDesc_base*)0);}
  212.     inline static PortDesc _from_base(PortDesc_base* b) {return PortDesc(b);}
  213.     inline PortDesc& operator=(const PortDesc& target) {
  214.         if (_pool == target._pool) return *this;
  215.         _pool->Dec();
  216.         _pool = target._pool;
  217.         _cache = target._cache;
  218.         _pool->Inc();
  219.         return *this;
  220.     }
  221.     inline PortDesc_base* _base() {return _cache?_cache:_method_call();}
  222.  
  223.     inline long ID();
  224.     inline Arts::ModuleDesc parent();
  225.     inline std::string name();
  226.     inline Arts::PortType type();
  227.     inline bool isConnected();
  228.     inline bool hasValue();
  229.     inline void hasValue(bool _newValue);
  230.     inline std::vector<Arts::PortDesc> * connections();
  231.     inline float floatValue();
  232.     inline void floatValue(float _newValue);
  233.     inline std::string stringValue();
  234.     inline void stringValue(const std::string& _newValue);
  235.     inline Arts::Any value();
  236.     inline void value(const Arts::Any& _newValue);
  237.     inline long internalOldID();
  238.     inline PortDesc(Arts::ModuleDesc parent, const std::string& name, const Arts::PortType& type);
  239.     inline bool connectTo(Arts::PortDesc port);
  240.     inline void disconnectFrom(Arts::PortDesc port);
  241.     inline void disconnectAll();
  242.     inline std::vector<std::string> * saveToList();
  243.     inline void loadFromList(const std::vector<std::string>& list);
  244.     inline void internalConnectInput(Arts::PortDesc port);
  245.     inline void internalReConnect(const std::vector<Arts::PortDesc>& allports);
  246. };
  247.  
  248. class ARTS_EXPORT ModuleDesc_base : virtual public Arts::Object_base {
  249. public:
  250.     static unsigned long _IID; // interface ID
  251.  
  252.     static ModuleDesc_base *_create(const std::string& subClass = "Arts::ModuleDesc");
  253.     static ModuleDesc_base *_fromString(const std::string& objectref);
  254.     static ModuleDesc_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  255.  
  256.     static ModuleDesc_base *_fromDynamicCast(const Arts::Object& object);
  257.     inline ModuleDesc_base *_copy() {
  258.         assert(_refCnt > 0);
  259.         _refCnt++;
  260.         return this;
  261.     }
  262.  
  263.     virtual std::vector<std::string> _defaultPortsIn() const;
  264.     virtual std::vector<std::string> _defaultPortsOut() const;
  265.  
  266.     void *_cast(unsigned long iid);
  267.  
  268.     virtual long ID() = 0;
  269.     virtual Arts::StructureDesc parent() = 0;
  270.     virtual std::string name() = 0;
  271.     virtual std::vector<Arts::PortDesc> * ports() = 0;
  272.     virtual long x() = 0;
  273.     virtual long y() = 0;
  274.     virtual long width() = 0;
  275.     virtual long height() = 0;
  276.     virtual bool isInterface() = 0;
  277.     virtual bool isStructure() = 0;
  278.     virtual void constructor(Arts::StructureDesc parent, const Arts::ModuleInfo& info) = 0;
  279.     virtual bool moveTo(long x, long y) = 0;
  280.     virtual Arts::PortDesc findPort(const std::string& name) = 0;
  281.     virtual std::vector<std::string> * saveToList() = 0;
  282.     virtual void loadFromList(const std::vector<std::string>& list) = 0;
  283. };
  284.  
  285. class ARTS_EXPORT ModuleDesc_stub : virtual public ModuleDesc_base, virtual public Arts::Object_stub {
  286. protected:
  287.     ModuleDesc_stub();
  288.  
  289. public:
  290.     ModuleDesc_stub(Arts::Connection *connection, long objectID);
  291.  
  292.     long ID();
  293.     Arts::StructureDesc parent();
  294.     std::string name();
  295.     std::vector<Arts::PortDesc> * ports();
  296.     long x();
  297.     long y();
  298.     long width();
  299.     long height();
  300.     bool isInterface();
  301.     bool isStructure();
  302.     void constructor(Arts::StructureDesc parent, const Arts::ModuleInfo& info);
  303.     bool moveTo(long x, long y);
  304.     Arts::PortDesc findPort(const std::string& name);
  305.     std::vector<std::string> * saveToList();
  306.     void loadFromList(const std::vector<std::string>& list);
  307. };
  308.  
  309. class ARTS_EXPORT ModuleDesc_skel : virtual public ModuleDesc_base, virtual public Arts::Object_skel {
  310. protected:
  311.     // emitters for change notifications
  312.     inline void ID_changed(long newValue) {
  313.         _emit_changed("ID_changed",newValue);
  314.     }
  315.     inline void name_changed(const std::string& newValue) {
  316.         _emit_changed("name_changed",newValue);
  317.     }
  318.     inline void x_changed(long newValue) {
  319.         _emit_changed("x_changed",newValue);
  320.     }
  321.     inline void y_changed(long newValue) {
  322.         _emit_changed("y_changed",newValue);
  323.     }
  324.     inline void width_changed(long newValue) {
  325.         _emit_changed("width_changed",newValue);
  326.     }
  327.     inline void height_changed(long newValue) {
  328.         _emit_changed("height_changed",newValue);
  329.     }
  330.     inline void isInterface_changed(bool newValue) {
  331.         _emit_changed("isInterface_changed",newValue);
  332.     }
  333.     inline void isStructure_changed(bool newValue) {
  334.         _emit_changed("isStructure_changed",newValue);
  335.     }
  336.  
  337. public:
  338.     ModuleDesc_skel();
  339.  
  340.     static std::string _interfaceNameSkel();
  341.     std::string _interfaceName();
  342.     bool _isCompatibleWith(const std::string& interfacename);
  343.     void _buildMethodTable();
  344.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  345. };
  346.  
  347. }
  348. #include "reference.h"
  349. namespace Arts {
  350. class ARTS_EXPORT ModuleDesc : public Arts::Object {
  351. private:
  352.     static Arts::Object_base* _Creator();
  353.     ModuleDesc_base *_cache;
  354.     inline ModuleDesc_base *_method_call() {
  355.         _pool->checkcreate();
  356.         if(_pool->base) {
  357.             _cache=(ModuleDesc_base *)_pool->base->_cast(ModuleDesc_base::_IID);
  358.             assert(_cache);
  359.         }
  360.         return _cache;
  361.     }
  362.  
  363. protected:
  364.     inline ModuleDesc(ModuleDesc_base* b) : Arts::Object(b), _cache(0) {}
  365.  
  366.  
  367. public:
  368.     typedef ModuleDesc_base _base_class;
  369.  
  370.     inline ModuleDesc() : Arts::Object(_Creator), _cache(0) {}
  371.     inline ModuleDesc(const Arts::SubClass& s) :
  372.         Arts::Object(ModuleDesc_base::_create(s.string())), _cache(0) {}
  373.     inline ModuleDesc(const Arts::Reference &r) :
  374.         Arts::Object(r.isString()?(ModuleDesc_base::_fromString(r.string())):(ModuleDesc_base::_fromReference(r.reference(),true))), _cache(0) {}
  375.     inline ModuleDesc(const Arts::DynamicCast& c) : Arts::Object(ModuleDesc_base::_fromDynamicCast(c.object())), _cache(0) {}
  376.     inline ModuleDesc(const ModuleDesc& target) : Arts::Object(target._pool), _cache(target._cache) {}
  377.     inline ModuleDesc(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  378.     inline static ModuleDesc null() {return ModuleDesc((ModuleDesc_base*)0);}
  379.     inline static ModuleDesc _from_base(ModuleDesc_base* b) {return ModuleDesc(b);}
  380.     inline ModuleDesc& operator=(const ModuleDesc& target) {
  381.         if (_pool == target._pool) return *this;
  382.         _pool->Dec();
  383.         _pool = target._pool;
  384.         _cache = target._cache;
  385.         _pool->Inc();
  386.         return *this;
  387.     }
  388.     inline ModuleDesc_base* _base() {return _cache?_cache:_method_call();}
  389.  
  390.     inline long ID();
  391.     inline Arts::StructureDesc parent();
  392.     inline std::string name();
  393.     inline std::vector<Arts::PortDesc> * ports();
  394.     inline long x();
  395.     inline long y();
  396.     inline long width();
  397.     inline long height();
  398.     inline bool isInterface();
  399.     inline bool isStructure();
  400.     inline ModuleDesc(Arts::StructureDesc parent, const Arts::ModuleInfo& info);
  401.     inline bool moveTo(long x, long y);
  402.     inline Arts::PortDesc findPort(const std::string& name);
  403.     inline std::vector<std::string> * saveToList();
  404.     inline void loadFromList(const std::vector<std::string>& list);
  405. };
  406.  
  407. class ARTS_EXPORT StructureDesc_base : virtual public Arts::Object_base {
  408. public:
  409.     static unsigned long _IID; // interface ID
  410.  
  411.     static StructureDesc_base *_create(const std::string& subClass = "Arts::StructureDesc");
  412.     static StructureDesc_base *_fromString(const std::string& objectref);
  413.     static StructureDesc_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  414.  
  415.     static StructureDesc_base *_fromDynamicCast(const Arts::Object& object);
  416.     inline StructureDesc_base *_copy() {
  417.         assert(_refCnt > 0);
  418.         _refCnt++;
  419.         return this;
  420.     }
  421.  
  422.     virtual std::vector<std::string> _defaultPortsIn() const;
  423.     virtual std::vector<std::string> _defaultPortsOut() const;
  424.  
  425.     void *_cast(unsigned long iid);
  426.  
  427.     virtual bool valid() = 0;
  428.     virtual std::string name() = 0;
  429.     virtual void name(const std::string& newValue) = 0;
  430.     virtual std::vector<Arts::ModuleDesc> * modules() = 0;
  431.     virtual std::vector<Arts::StructurePortDesc> * ports() = 0;
  432.     virtual std::vector<std::string> * inheritedInterfaces() = 0;
  433.     virtual Arts::ModuleInfo externalInterface() = 0;
  434.     virtual long obtainID() = 0;
  435.     virtual std::vector<std::string> * saveToList() = 0;
  436.     virtual void loadFromList(const std::vector<std::string>& list) = 0;
  437.     virtual void clear() = 0;
  438.     virtual Arts::ModuleDesc createModuleDesc(const Arts::ModuleInfo& info) = 0;
  439.     virtual void freeModuleDesc(Arts::ModuleDesc moduledesc) = 0;
  440.     virtual Arts::StructurePortDesc createStructurePortDesc(const Arts::PortType& type, const std::string& name) = 0;
  441.     virtual void freeStructurePortDesc(Arts::StructurePortDesc portdesc) = 0;
  442.     virtual void moveStructurePortDesc(Arts::StructurePortDesc portdesc, long newposition) = 0;
  443.     virtual void addInheritedInterface(const std::string& iface) = 0;
  444.     virtual void removeInheritedInterface(const std::string& iface) = 0;
  445. };
  446.  
  447. class ARTS_EXPORT StructureDesc_stub : virtual public StructureDesc_base, virtual public Arts::Object_stub {
  448. protected:
  449.     StructureDesc_stub();
  450.  
  451. public:
  452.     StructureDesc_stub(Arts::Connection *connection, long objectID);
  453.  
  454.     bool valid();
  455.     std::string name();
  456.     void name(const std::string& newValue);
  457.     std::vector<Arts::ModuleDesc> * modules();
  458.     std::vector<Arts::StructurePortDesc> * ports();
  459.     std::vector<std::string> * inheritedInterfaces();
  460.     Arts::ModuleInfo externalInterface();
  461.     long obtainID();
  462.     std::vector<std::string> * saveToList();
  463.     void loadFromList(const std::vector<std::string>& list);
  464.     void clear();
  465.     Arts::ModuleDesc createModuleDesc(const Arts::ModuleInfo& info);
  466.     void freeModuleDesc(Arts::ModuleDesc moduledesc);
  467.     Arts::StructurePortDesc createStructurePortDesc(const Arts::PortType& type, const std::string& name);
  468.     void freeStructurePortDesc(Arts::StructurePortDesc portdesc);
  469.     void moveStructurePortDesc(Arts::StructurePortDesc portdesc, long newposition);
  470.     void addInheritedInterface(const std::string& iface);
  471.     void removeInheritedInterface(const std::string& iface);
  472. };
  473.  
  474. class ARTS_EXPORT StructureDesc_skel : virtual public StructureDesc_base, virtual public Arts::Object_skel {
  475. protected:
  476.     // emitters for change notifications
  477.     inline void valid_changed(bool newValue) {
  478.         _emit_changed("valid_changed",newValue);
  479.     }
  480.     inline void name_changed(const std::string& newValue) {
  481.         _emit_changed("name_changed",newValue);
  482.     }
  483.     inline void inheritedInterfaces_changed(const std::vector<std::string>& newValue) {
  484.         _emit_changed("inheritedInterfaces_changed",newValue);
  485.     }
  486.  
  487. public:
  488.     StructureDesc_skel();
  489.  
  490.     static std::string _interfaceNameSkel();
  491.     std::string _interfaceName();
  492.     bool _isCompatibleWith(const std::string& interfacename);
  493.     void _buildMethodTable();
  494.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  495. };
  496.  
  497. }
  498. #include "reference.h"
  499. namespace Arts {
  500. class ARTS_EXPORT StructureDesc : public Arts::Object {
  501. private:
  502.     static Arts::Object_base* _Creator();
  503.     StructureDesc_base *_cache;
  504.     inline StructureDesc_base *_method_call() {
  505.         _pool->checkcreate();
  506.         if(_pool->base) {
  507.             _cache=(StructureDesc_base *)_pool->base->_cast(StructureDesc_base::_IID);
  508.             assert(_cache);
  509.         }
  510.         return _cache;
  511.     }
  512.  
  513. protected:
  514.     inline StructureDesc(StructureDesc_base* b) : Arts::Object(b), _cache(0) {}
  515.  
  516.  
  517. public:
  518.     typedef StructureDesc_base _base_class;
  519.  
  520.     inline StructureDesc() : Arts::Object(_Creator), _cache(0) {}
  521.     inline StructureDesc(const Arts::SubClass& s) :
  522.         Arts::Object(StructureDesc_base::_create(s.string())), _cache(0) {}
  523.     inline StructureDesc(const Arts::Reference &r) :
  524.         Arts::Object(r.isString()?(StructureDesc_base::_fromString(r.string())):(StructureDesc_base::_fromReference(r.reference(),true))), _cache(0) {}
  525.     inline StructureDesc(const Arts::DynamicCast& c) : Arts::Object(StructureDesc_base::_fromDynamicCast(c.object())), _cache(0) {}
  526.     inline StructureDesc(const StructureDesc& target) : Arts::Object(target._pool), _cache(target._cache) {}
  527.     inline StructureDesc(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  528.     inline static StructureDesc null() {return StructureDesc((StructureDesc_base*)0);}
  529.     inline static StructureDesc _from_base(StructureDesc_base* b) {return StructureDesc(b);}
  530.     inline StructureDesc& operator=(const StructureDesc& target) {
  531.         if (_pool == target._pool) return *this;
  532.         _pool->Dec();
  533.         _pool = target._pool;
  534.         _cache = target._cache;
  535.         _pool->Inc();
  536.         return *this;
  537.     }
  538.     inline StructureDesc_base* _base() {return _cache?_cache:_method_call();}
  539.  
  540.     inline bool valid();
  541.     inline std::string name();
  542.     inline void name(const std::string& _newValue);
  543.     inline std::vector<Arts::ModuleDesc> * modules();
  544.     inline std::vector<Arts::StructurePortDesc> * ports();
  545.     inline std::vector<std::string> * inheritedInterfaces();
  546.     inline Arts::ModuleInfo externalInterface();
  547.     inline long obtainID();
  548.     inline std::vector<std::string> * saveToList();
  549.     inline void loadFromList(const std::vector<std::string>& list);
  550.     inline void clear();
  551.     inline Arts::ModuleDesc createModuleDesc(const Arts::ModuleInfo& info);
  552.     inline void freeModuleDesc(Arts::ModuleDesc moduledesc);
  553.     inline Arts::StructurePortDesc createStructurePortDesc(const Arts::PortType& type, const std::string& name);
  554.     inline void freeStructurePortDesc(Arts::StructurePortDesc portdesc);
  555.     inline void moveStructurePortDesc(Arts::StructurePortDesc portdesc, long newposition);
  556.     inline void addInheritedInterface(const std::string& iface);
  557.     inline void removeInheritedInterface(const std::string& iface);
  558. };
  559.  
  560. class ARTS_EXPORT StructurePortDesc_base : virtual public Arts::PortDesc_base {
  561. public:
  562.     static unsigned long _IID; // interface ID
  563.  
  564.     static StructurePortDesc_base *_create(const std::string& subClass = "Arts::StructurePortDesc");
  565.     static StructurePortDesc_base *_fromString(const std::string& objectref);
  566.     static StructurePortDesc_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  567.  
  568.     static StructurePortDesc_base *_fromDynamicCast(const Arts::Object& object);
  569.     inline StructurePortDesc_base *_copy() {
  570.         assert(_refCnt > 0);
  571.         _refCnt++;
  572.         return this;
  573.     }
  574.  
  575.     virtual std::vector<std::string> _defaultPortsIn() const;
  576.     virtual std::vector<std::string> _defaultPortsOut() const;
  577.  
  578.     void *_cast(unsigned long iid);
  579.  
  580.     virtual long x() = 0;
  581.     virtual long y() = 0;
  582.     virtual long position() = 0;
  583.     virtual Arts::StructureDesc parentStructure() = 0;
  584.     virtual std::string inheritedInterface() = 0;
  585.     virtual void inheritedInterface(const std::string& newValue) = 0;
  586.     virtual void constructor(Arts::StructureDesc parent, const std::string& name, const Arts::PortType& type) = 0;
  587.     virtual bool moveTo(long x, long y) = 0;
  588.     virtual void lowerPosition() = 0;
  589.     virtual void raisePosition() = 0;
  590.     virtual void rename(const std::string& newname) = 0;
  591.     virtual void internalSetPosition(long position) = 0;
  592. };
  593.  
  594. class ARTS_EXPORT StructurePortDesc_stub : virtual public StructurePortDesc_base, virtual public Arts::PortDesc_stub {
  595. protected:
  596.     StructurePortDesc_stub();
  597.  
  598. public:
  599.     StructurePortDesc_stub(Arts::Connection *connection, long objectID);
  600.  
  601.     long x();
  602.     long y();
  603.     long position();
  604.     Arts::StructureDesc parentStructure();
  605.     std::string inheritedInterface();
  606.     void inheritedInterface(const std::string& newValue);
  607.     void constructor(Arts::StructureDesc parent, const std::string& name, const Arts::PortType& type);
  608.     bool moveTo(long x, long y);
  609.     void lowerPosition();
  610.     void raisePosition();
  611.     void rename(const std::string& newname);
  612.     void internalSetPosition(long position);
  613. };
  614.  
  615. class ARTS_EXPORT StructurePortDesc_skel : virtual public StructurePortDesc_base, virtual public Arts::PortDesc_skel {
  616. protected:
  617.     // emitters for change notifications
  618.     inline void x_changed(long newValue) {
  619.         _emit_changed("x_changed",newValue);
  620.     }
  621.     inline void y_changed(long newValue) {
  622.         _emit_changed("y_changed",newValue);
  623.     }
  624.     inline void position_changed(long newValue) {
  625.         _emit_changed("position_changed",newValue);
  626.     }
  627.     inline void inheritedInterface_changed(const std::string& newValue) {
  628.         _emit_changed("inheritedInterface_changed",newValue);
  629.     }
  630.  
  631. public:
  632.     StructurePortDesc_skel();
  633.  
  634.     static std::string _interfaceNameSkel();
  635.     std::string _interfaceName();
  636.     bool _isCompatibleWith(const std::string& interfacename);
  637.     void _buildMethodTable();
  638.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  639. };
  640.  
  641. }
  642. #include "reference.h"
  643. namespace Arts {
  644. class ARTS_EXPORT StructurePortDesc : public Arts::Object {
  645. private:
  646.     static Arts::Object_base* _Creator();
  647.     StructurePortDesc_base *_cache;
  648.     inline StructurePortDesc_base *_method_call() {
  649.         _pool->checkcreate();
  650.         if(_pool->base) {
  651.             _cache=(StructurePortDesc_base *)_pool->base->_cast(StructurePortDesc_base::_IID);
  652.             assert(_cache);
  653.         }
  654.         return _cache;
  655.     }
  656.  
  657. protected:
  658.     inline StructurePortDesc(StructurePortDesc_base* b) : Arts::Object(b), _cache(0) {}
  659.  
  660.  
  661. public:
  662.     typedef StructurePortDesc_base _base_class;
  663.  
  664.     inline StructurePortDesc() : Arts::Object(_Creator), _cache(0) {}
  665.     inline StructurePortDesc(const Arts::SubClass& s) :
  666.         Arts::Object(StructurePortDesc_base::_create(s.string())), _cache(0) {}
  667.     inline StructurePortDesc(const Arts::Reference &r) :
  668.         Arts::Object(r.isString()?(StructurePortDesc_base::_fromString(r.string())):(StructurePortDesc_base::_fromReference(r.reference(),true))), _cache(0) {}
  669.     inline StructurePortDesc(const Arts::DynamicCast& c) : Arts::Object(StructurePortDesc_base::_fromDynamicCast(c.object())), _cache(0) {}
  670.     inline StructurePortDesc(const StructurePortDesc& target) : Arts::Object(target._pool), _cache(target._cache) {}
  671.     inline StructurePortDesc(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  672.     inline static StructurePortDesc null() {return StructurePortDesc((StructurePortDesc_base*)0);}
  673.     inline static StructurePortDesc _from_base(StructurePortDesc_base* b) {return StructurePortDesc(b);}
  674.     inline StructurePortDesc& operator=(const StructurePortDesc& target) {
  675.         if (_pool == target._pool) return *this;
  676.         _pool->Dec();
  677.         _pool = target._pool;
  678.         _cache = target._cache;
  679.         _pool->Inc();
  680.         return *this;
  681.     }
  682.     inline operator Arts::PortDesc() const { return Arts::PortDesc(*_pool); }
  683.     inline StructurePortDesc_base* _base() {return _cache?_cache:_method_call();}
  684.  
  685.     inline long ID();
  686.     inline Arts::ModuleDesc parent();
  687.     inline std::string name();
  688.     inline Arts::PortType type();
  689.     inline bool isConnected();
  690.     inline bool hasValue();
  691.     inline void hasValue(bool _newValue);
  692.     inline std::vector<Arts::PortDesc> * connections();
  693.     inline float floatValue();
  694.     inline void floatValue(float _newValue);
  695.     inline std::string stringValue();
  696.     inline void stringValue(const std::string& _newValue);
  697.     inline Arts::Any value();
  698.     inline void value(const Arts::Any& _newValue);
  699.     inline long internalOldID();
  700.     inline StructurePortDesc(Arts::ModuleDesc parent, const std::string& name, const Arts::PortType& type);
  701.     inline bool connectTo(Arts::PortDesc port);
  702.     inline void disconnectFrom(Arts::PortDesc port);
  703.     inline void disconnectAll();
  704.     inline std::vector<std::string> * saveToList();
  705.     inline void loadFromList(const std::vector<std::string>& list);
  706.     inline void internalConnectInput(Arts::PortDesc port);
  707.     inline void internalReConnect(const std::vector<Arts::PortDesc>& allports);
  708.     inline long x();
  709.     inline long y();
  710.     inline long position();
  711.     inline Arts::StructureDesc parentStructure();
  712.     inline std::string inheritedInterface();
  713.     inline void inheritedInterface(const std::string& _newValue);
  714.     inline StructurePortDesc(Arts::StructureDesc parent, const std::string& name, const Arts::PortType& type);
  715.     inline bool moveTo(long x, long y);
  716.     inline void lowerPosition();
  717.     inline void raisePosition();
  718.     inline void rename(const std::string& newname);
  719.     inline void internalSetPosition(long position);
  720. };
  721.  
  722. class ARTS_EXPORT ObjectFactory_base : virtual public Arts::Object_base {
  723. public:
  724.     static unsigned long _IID; // interface ID
  725.  
  726.     static ObjectFactory_base *_create(const std::string& subClass = "Arts::ObjectFactory");
  727.     static ObjectFactory_base *_fromString(const std::string& objectref);
  728.     static ObjectFactory_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  729.  
  730.     static ObjectFactory_base *_fromDynamicCast(const Arts::Object& object);
  731.     inline ObjectFactory_base *_copy() {
  732.         assert(_refCnt > 0);
  733.         _refCnt++;
  734.         return this;
  735.     }
  736.  
  737.     virtual std::vector<std::string> _defaultPortsIn() const;
  738.     virtual std::vector<std::string> _defaultPortsOut() const;
  739.  
  740.     void *_cast(unsigned long iid);
  741.  
  742.     virtual Arts::Object createObject(const std::string& name) = 0;
  743. };
  744.  
  745. class ARTS_EXPORT ObjectFactory_stub : virtual public ObjectFactory_base, virtual public Arts::Object_stub {
  746. protected:
  747.     ObjectFactory_stub();
  748.  
  749. public:
  750.     ObjectFactory_stub(Arts::Connection *connection, long objectID);
  751.  
  752.     Arts::Object createObject(const std::string& name);
  753. };
  754.  
  755. class ARTS_EXPORT ObjectFactory_skel : virtual public ObjectFactory_base, virtual public Arts::Object_skel {
  756. public:
  757.     ObjectFactory_skel();
  758.  
  759.     static std::string _interfaceNameSkel();
  760.     std::string _interfaceName();
  761.     bool _isCompatibleWith(const std::string& interfacename);
  762.     void _buildMethodTable();
  763.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  764. };
  765.  
  766. }
  767. #include "reference.h"
  768. namespace Arts {
  769. class ARTS_EXPORT ObjectFactory : public Arts::Object {
  770. private:
  771.     static Arts::Object_base* _Creator();
  772.     ObjectFactory_base *_cache;
  773.     inline ObjectFactory_base *_method_call() {
  774.         _pool->checkcreate();
  775.         if(_pool->base) {
  776.             _cache=(ObjectFactory_base *)_pool->base->_cast(ObjectFactory_base::_IID);
  777.             assert(_cache);
  778.         }
  779.         return _cache;
  780.     }
  781.  
  782. protected:
  783.     inline ObjectFactory(ObjectFactory_base* b) : Arts::Object(b), _cache(0) {}
  784.  
  785.  
  786. public:
  787.     typedef ObjectFactory_base _base_class;
  788.  
  789.     inline ObjectFactory() : Arts::Object(_Creator), _cache(0) {}
  790.     inline ObjectFactory(const Arts::SubClass& s) :
  791.         Arts::Object(ObjectFactory_base::_create(s.string())), _cache(0) {}
  792.     inline ObjectFactory(const Arts::Reference &r) :
  793.         Arts::Object(r.isString()?(ObjectFactory_base::_fromString(r.string())):(ObjectFactory_base::_fromReference(r.reference(),true))), _cache(0) {}
  794.     inline ObjectFactory(const Arts::DynamicCast& c) : Arts::Object(ObjectFactory_base::_fromDynamicCast(c.object())), _cache(0) {}
  795.     inline ObjectFactory(const ObjectFactory& target) : Arts::Object(target._pool), _cache(target._cache) {}
  796.     inline ObjectFactory(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  797.     inline static ObjectFactory null() {return ObjectFactory((ObjectFactory_base*)0);}
  798.     inline static ObjectFactory _from_base(ObjectFactory_base* b) {return ObjectFactory(b);}
  799.     inline ObjectFactory& operator=(const ObjectFactory& target) {
  800.         if (_pool == target._pool) return *this;
  801.         _pool->Dec();
  802.         _pool = target._pool;
  803.         _cache = target._cache;
  804.         _pool->Inc();
  805.         return *this;
  806.     }
  807.     inline ObjectFactory_base* _base() {return _cache?_cache:_method_call();}
  808.  
  809.     inline Arts::Object createObject(const std::string& name);
  810. };
  811.  
  812. class ARTS_EXPORT LocalFactory_base : virtual public Arts::ObjectFactory_base {
  813. public:
  814.     static unsigned long _IID; // interface ID
  815.  
  816.     static LocalFactory_base *_create(const std::string& subClass = "Arts::LocalFactory");
  817.     static LocalFactory_base *_fromString(const std::string& objectref);
  818.     static LocalFactory_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  819.  
  820.     static LocalFactory_base *_fromDynamicCast(const Arts::Object& object);
  821.     inline LocalFactory_base *_copy() {
  822.         assert(_refCnt > 0);
  823.         _refCnt++;
  824.         return this;
  825.     }
  826.  
  827.     virtual std::vector<std::string> _defaultPortsIn() const;
  828.     virtual std::vector<std::string> _defaultPortsOut() const;
  829.  
  830.     void *_cast(unsigned long iid);
  831.  
  832. };
  833.  
  834. class ARTS_EXPORT LocalFactory_stub : virtual public LocalFactory_base, virtual public Arts::ObjectFactory_stub {
  835. protected:
  836.     LocalFactory_stub();
  837.  
  838. public:
  839.     LocalFactory_stub(Arts::Connection *connection, long objectID);
  840.  
  841. };
  842.  
  843. class ARTS_EXPORT LocalFactory_skel : virtual public LocalFactory_base, virtual public Arts::ObjectFactory_skel {
  844. public:
  845.     LocalFactory_skel();
  846.  
  847.     static std::string _interfaceNameSkel();
  848.     std::string _interfaceName();
  849.     bool _isCompatibleWith(const std::string& interfacename);
  850.     void _buildMethodTable();
  851.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  852. };
  853.  
  854. }
  855. #include "reference.h"
  856. namespace Arts {
  857. class ARTS_EXPORT LocalFactory : public Arts::Object {
  858. private:
  859.     static Arts::Object_base* _Creator();
  860.     LocalFactory_base *_cache;
  861.     inline LocalFactory_base *_method_call() {
  862.         _pool->checkcreate();
  863.         if(_pool->base) {
  864.             _cache=(LocalFactory_base *)_pool->base->_cast(LocalFactory_base::_IID);
  865.             assert(_cache);
  866.         }
  867.         return _cache;
  868.     }
  869.  
  870. protected:
  871.     inline LocalFactory(LocalFactory_base* b) : Arts::Object(b), _cache(0) {}
  872.  
  873.  
  874. public:
  875.     typedef LocalFactory_base _base_class;
  876.  
  877.     inline LocalFactory() : Arts::Object(_Creator), _cache(0) {}
  878.     inline LocalFactory(const Arts::SubClass& s) :
  879.         Arts::Object(LocalFactory_base::_create(s.string())), _cache(0) {}
  880.     inline LocalFactory(const Arts::Reference &r) :
  881.         Arts::Object(r.isString()?(LocalFactory_base::_fromString(r.string())):(LocalFactory_base::_fromReference(r.reference(),true))), _cache(0) {}
  882.     inline LocalFactory(const Arts::DynamicCast& c) : Arts::Object(LocalFactory_base::_fromDynamicCast(c.object())), _cache(0) {}
  883.     inline LocalFactory(const LocalFactory& target) : Arts::Object(target._pool), _cache(target._cache) {}
  884.     inline LocalFactory(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  885.     inline static LocalFactory null() {return LocalFactory((LocalFactory_base*)0);}
  886.     inline static LocalFactory _from_base(LocalFactory_base* b) {return LocalFactory(b);}
  887.     inline LocalFactory& operator=(const LocalFactory& target) {
  888.         if (_pool == target._pool) return *this;
  889.         _pool->Dec();
  890.         _pool = target._pool;
  891.         _cache = target._cache;
  892.         _pool->Inc();
  893.         return *this;
  894.     }
  895.     inline operator Arts::ObjectFactory() const { return Arts::ObjectFactory(*_pool); }
  896.     inline LocalFactory_base* _base() {return _cache?_cache:_method_call();}
  897.  
  898.     inline Arts::Object createObject(const std::string& name);
  899. };
  900.  
  901. class ARTS_EXPORT StructureBuilder_base : virtual public Arts::Object_base {
  902. public:
  903.     static unsigned long _IID; // interface ID
  904.  
  905.     static StructureBuilder_base *_create(const std::string& subClass = "Arts::StructureBuilder");
  906.     static StructureBuilder_base *_fromString(const std::string& objectref);
  907.     static StructureBuilder_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  908.  
  909.     static StructureBuilder_base *_fromDynamicCast(const Arts::Object& object);
  910.     inline StructureBuilder_base *_copy() {
  911.         assert(_refCnt > 0);
  912.         _refCnt++;
  913.         return this;
  914.     }
  915.  
  916.     virtual std::vector<std::string> _defaultPortsIn() const;
  917.     virtual std::vector<std::string> _defaultPortsOut() const;
  918.  
  919.     void *_cast(unsigned long iid);
  920.  
  921.     virtual void addFactory(Arts::ObjectFactory factory) = 0;
  922.     virtual Arts::Object createObject(Arts::StructureDesc structure) = 0;
  923.     virtual Arts::ModuleDef createTypeInfo(Arts::StructureDesc structure) = 0;
  924. };
  925.  
  926. class ARTS_EXPORT StructureBuilder_stub : virtual public StructureBuilder_base, virtual public Arts::Object_stub {
  927. protected:
  928.     StructureBuilder_stub();
  929.  
  930. public:
  931.     StructureBuilder_stub(Arts::Connection *connection, long objectID);
  932.  
  933.     void addFactory(Arts::ObjectFactory factory);
  934.     Arts::Object createObject(Arts::StructureDesc structure);
  935.     Arts::ModuleDef createTypeInfo(Arts::StructureDesc structure);
  936. };
  937.  
  938. class ARTS_EXPORT StructureBuilder_skel : virtual public StructureBuilder_base, virtual public Arts::Object_skel {
  939. public:
  940.     StructureBuilder_skel();
  941.  
  942.     static std::string _interfaceNameSkel();
  943.     std::string _interfaceName();
  944.     bool _isCompatibleWith(const std::string& interfacename);
  945.     void _buildMethodTable();
  946.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  947. };
  948.  
  949. }
  950. #include "reference.h"
  951. namespace Arts {
  952. class ARTS_EXPORT StructureBuilder : public Arts::Object {
  953. private:
  954.     static Arts::Object_base* _Creator();
  955.     StructureBuilder_base *_cache;
  956.     inline StructureBuilder_base *_method_call() {
  957.         _pool->checkcreate();
  958.         if(_pool->base) {
  959.             _cache=(StructureBuilder_base *)_pool->base->_cast(StructureBuilder_base::_IID);
  960.             assert(_cache);
  961.         }
  962.         return _cache;
  963.     }
  964.  
  965. protected:
  966.     inline StructureBuilder(StructureBuilder_base* b) : Arts::Object(b), _cache(0) {}
  967.  
  968.  
  969. public:
  970.     typedef StructureBuilder_base _base_class;
  971.  
  972.     inline StructureBuilder() : Arts::Object(_Creator), _cache(0) {}
  973.     inline StructureBuilder(const Arts::SubClass& s) :
  974.         Arts::Object(StructureBuilder_base::_create(s.string())), _cache(0) {}
  975.     inline StructureBuilder(const Arts::Reference &r) :
  976.         Arts::Object(r.isString()?(StructureBuilder_base::_fromString(r.string())):(StructureBuilder_base::_fromReference(r.reference(),true))), _cache(0) {}
  977.     inline StructureBuilder(const Arts::DynamicCast& c) : Arts::Object(StructureBuilder_base::_fromDynamicCast(c.object())), _cache(0) {}
  978.     inline StructureBuilder(const StructureBuilder& target) : Arts::Object(target._pool), _cache(target._cache) {}
  979.     inline StructureBuilder(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  980.     inline static StructureBuilder null() {return StructureBuilder((StructureBuilder_base*)0);}
  981.     inline static StructureBuilder _from_base(StructureBuilder_base* b) {return StructureBuilder(b);}
  982.     inline StructureBuilder& operator=(const StructureBuilder& target) {
  983.         if (_pool == target._pool) return *this;
  984.         _pool->Dec();
  985.         _pool = target._pool;
  986.         _cache = target._cache;
  987.         _pool->Inc();
  988.         return *this;
  989.     }
  990.     inline StructureBuilder_base* _base() {return _cache?_cache:_method_call();}
  991.  
  992.     inline void addFactory(Arts::ObjectFactory factory);
  993.     inline Arts::Object createObject(Arts::StructureDesc structure);
  994.     inline Arts::ModuleDef createTypeInfo(Arts::StructureDesc structure);
  995. };
  996.  
  997. class ARTS_EXPORT ArtsBuilderLoader_base : virtual public Arts::Loader_base {
  998. public:
  999.     static unsigned long _IID; // interface ID
  1000.  
  1001.     static ArtsBuilderLoader_base *_create(const std::string& subClass = "Arts::ArtsBuilderLoader");
  1002.     static ArtsBuilderLoader_base *_fromString(const std::string& objectref);
  1003.     static ArtsBuilderLoader_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  1004.  
  1005.     static ArtsBuilderLoader_base *_fromDynamicCast(const Arts::Object& object);
  1006.     inline ArtsBuilderLoader_base *_copy() {
  1007.         assert(_refCnt > 0);
  1008.         _refCnt++;
  1009.         return this;
  1010.     }
  1011.  
  1012.     virtual std::vector<std::string> _defaultPortsIn() const;
  1013.     virtual std::vector<std::string> _defaultPortsOut() const;
  1014.  
  1015.     void *_cast(unsigned long iid);
  1016.  
  1017. };
  1018.  
  1019. class ARTS_EXPORT ArtsBuilderLoader_stub : virtual public ArtsBuilderLoader_base, virtual public Arts::Loader_stub {
  1020. protected:
  1021.     ArtsBuilderLoader_stub();
  1022.  
  1023. public:
  1024.     ArtsBuilderLoader_stub(Arts::Connection *connection, long objectID);
  1025.  
  1026. };
  1027.  
  1028. class ARTS_EXPORT ArtsBuilderLoader_skel : virtual public ArtsBuilderLoader_base, virtual public Arts::Loader_skel {
  1029. public:
  1030.     ArtsBuilderLoader_skel();
  1031.  
  1032.     static std::string _interfaceNameSkel();
  1033.     std::string _interfaceName();
  1034.     bool _isCompatibleWith(const std::string& interfacename);
  1035.     void _buildMethodTable();
  1036.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  1037. };
  1038.  
  1039. }
  1040. #include "reference.h"
  1041. namespace Arts {
  1042. class ARTS_EXPORT ArtsBuilderLoader : public Arts::Object {
  1043. private:
  1044.     static Arts::Object_base* _Creator();
  1045.     ArtsBuilderLoader_base *_cache;
  1046.     inline ArtsBuilderLoader_base *_method_call() {
  1047.         _pool->checkcreate();
  1048.         if(_pool->base) {
  1049.             _cache=(ArtsBuilderLoader_base *)_pool->base->_cast(ArtsBuilderLoader_base::_IID);
  1050.             assert(_cache);
  1051.         }
  1052.         return _cache;
  1053.     }
  1054.  
  1055. protected:
  1056.     inline ArtsBuilderLoader(ArtsBuilderLoader_base* b) : Arts::Object(b), _cache(0) {}
  1057.  
  1058.  
  1059. public:
  1060.     typedef ArtsBuilderLoader_base _base_class;
  1061.  
  1062.     inline ArtsBuilderLoader() : Arts::Object(_Creator), _cache(0) {}
  1063.     inline ArtsBuilderLoader(const Arts::SubClass& s) :
  1064.         Arts::Object(ArtsBuilderLoader_base::_create(s.string())), _cache(0) {}
  1065.     inline ArtsBuilderLoader(const Arts::Reference &r) :
  1066.         Arts::Object(r.isString()?(ArtsBuilderLoader_base::_fromString(r.string())):(ArtsBuilderLoader_base::_fromReference(r.reference(),true))), _cache(0) {}
  1067.     inline ArtsBuilderLoader(const Arts::DynamicCast& c) : Arts::Object(ArtsBuilderLoader_base::_fromDynamicCast(c.object())), _cache(0) {}
  1068.     inline ArtsBuilderLoader(const ArtsBuilderLoader& target) : Arts::Object(target._pool), _cache(target._cache) {}
  1069.     inline ArtsBuilderLoader(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  1070.     inline static ArtsBuilderLoader null() {return ArtsBuilderLoader((ArtsBuilderLoader_base*)0);}
  1071.     inline static ArtsBuilderLoader _from_base(ArtsBuilderLoader_base* b) {return ArtsBuilderLoader(b);}
  1072.     inline ArtsBuilderLoader& operator=(const ArtsBuilderLoader& target) {
  1073.         if (_pool == target._pool) return *this;
  1074.         _pool->Dec();
  1075.         _pool = target._pool;
  1076.         _cache = target._cache;
  1077.         _pool->Inc();
  1078.         return *this;
  1079.     }
  1080.     inline operator Arts::Loader() const { return Arts::Loader(*_pool); }
  1081.     inline ArtsBuilderLoader_base* _base() {return _cache?_cache:_method_call();}
  1082.  
  1083.     inline std::string dataVersion();
  1084.     inline std::vector<Arts::TraderEntry> * traderEntries();
  1085.     inline std::vector<Arts::ModuleDef> * modules();
  1086.     inline Arts::Object loadObject(Arts::TraderOffer offer);
  1087. };
  1088.  
  1089. class ARTS_EXPORT Structure_base : virtual public Arts::SynthModule_base {
  1090. public:
  1091.     static unsigned long _IID; // interface ID
  1092.  
  1093.     static Structure_base *_create(const std::string& subClass = "Arts::Structure");
  1094.     static Structure_base *_fromString(const std::string& objectref);
  1095.     static Structure_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  1096.  
  1097.     static Structure_base *_fromDynamicCast(const Arts::Object& object);
  1098.     inline Structure_base *_copy() {
  1099.         assert(_refCnt > 0);
  1100.         _refCnt++;
  1101.         return this;
  1102.     }
  1103.  
  1104.     virtual std::vector<std::string> _defaultPortsIn() const;
  1105.     virtual std::vector<std::string> _defaultPortsOut() const;
  1106.  
  1107.     void *_cast(unsigned long iid);
  1108.  
  1109.     virtual void run() = 0;
  1110.     virtual void halt() = 0;
  1111. };
  1112.  
  1113. class ARTS_EXPORT Structure_stub : virtual public Structure_base, virtual public Arts::SynthModule_stub {
  1114. protected:
  1115.     Structure_stub();
  1116.  
  1117. public:
  1118.     Structure_stub(Arts::Connection *connection, long objectID);
  1119.  
  1120.     void run();
  1121.     void halt();
  1122. };
  1123.  
  1124. class ARTS_EXPORT Structure_skel : virtual public Structure_base, virtual public Arts::SynthModule_skel {
  1125. public:
  1126.     Structure_skel();
  1127.  
  1128.     static std::string _interfaceNameSkel();
  1129.     std::string _interfaceName();
  1130.     bool _isCompatibleWith(const std::string& interfacename);
  1131.     void _buildMethodTable();
  1132.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  1133. };
  1134.  
  1135. }
  1136. #include "reference.h"
  1137. namespace Arts {
  1138. class ARTS_EXPORT Structure : public Arts::Object {
  1139. private:
  1140.     static Arts::Object_base* _Creator();
  1141.     Structure_base *_cache;
  1142.     inline Structure_base *_method_call() {
  1143.         _pool->checkcreate();
  1144.         if(_pool->base) {
  1145.             _cache=(Structure_base *)_pool->base->_cast(Structure_base::_IID);
  1146.             assert(_cache);
  1147.         }
  1148.         return _cache;
  1149.     }
  1150.  
  1151. protected:
  1152.     inline Structure(Structure_base* b) : Arts::Object(b), _cache(0) {}
  1153.  
  1154.  
  1155. public:
  1156.     typedef Structure_base _base_class;
  1157.  
  1158.     inline Structure() : Arts::Object(_Creator), _cache(0) {}
  1159.     inline Structure(const Arts::SubClass& s) :
  1160.         Arts::Object(Structure_base::_create(s.string())), _cache(0) {}
  1161.     inline Structure(const Arts::Reference &r) :
  1162.         Arts::Object(r.isString()?(Structure_base::_fromString(r.string())):(Structure_base::_fromReference(r.reference(),true))), _cache(0) {}
  1163.     inline Structure(const Arts::DynamicCast& c) : Arts::Object(Structure_base::_fromDynamicCast(c.object())), _cache(0) {}
  1164.     inline Structure(const Structure& target) : Arts::Object(target._pool), _cache(target._cache) {}
  1165.     inline Structure(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  1166.     inline static Structure null() {return Structure((Structure_base*)0);}
  1167.     inline static Structure _from_base(Structure_base* b) {return Structure(b);}
  1168.     inline Structure& operator=(const Structure& target) {
  1169.         if (_pool == target._pool) return *this;
  1170.         _pool->Dec();
  1171.         _pool = target._pool;
  1172.         _cache = target._cache;
  1173.         _pool->Inc();
  1174.         return *this;
  1175.     }
  1176.     inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
  1177.     inline Structure_base* _base() {return _cache?_cache:_method_call();}
  1178.  
  1179.     inline Arts::AutoSuspendState autoSuspend();
  1180.     inline void start();
  1181.     inline void stop();
  1182.     inline void streamInit();
  1183.     inline void streamStart();
  1184.     inline void streamEnd();
  1185.     inline void run();
  1186.     inline void halt();
  1187. };
  1188.  
  1189. }
  1190. // Forward wrapper calls to _base classes:
  1191.  
  1192. inline long Arts::PortDesc::ID()
  1193. {
  1194.     return _cache?static_cast<Arts::PortDesc_base*>(_cache)->ID():static_cast<Arts::PortDesc_base*>(_method_call())->ID();
  1195. }
  1196.  
  1197. inline Arts::ModuleDesc Arts::PortDesc::parent()
  1198. {
  1199.     return _cache?static_cast<Arts::PortDesc_base*>(_cache)->parent():static_cast<Arts::PortDesc_base*>(_method_call())->parent();
  1200. }
  1201.  
  1202. inline std::string Arts::PortDesc::name()
  1203. {
  1204.     return _cache?static_cast<Arts::PortDesc_base*>(_cache)->name():static_cast<Arts::PortDesc_base*>(_method_call())->name();
  1205. }
  1206.  
  1207. inline Arts::PortType Arts::PortDesc::type()
  1208. {
  1209.     return _cache?static_cast<Arts::PortDesc_base*>(_cache)->type():static_cast<Arts::PortDesc_base*>(_method_call())->type();
  1210. }
  1211.  
  1212. inline bool Arts::PortDesc::isConnected()
  1213. {
  1214.     return _cache?static_cast<Arts::PortDesc_base*>(_cache)->isConnected():static_cast<Arts::PortDesc_base*>(_method_call())->isConnected();
  1215. }
  1216.  
  1217. inline bool Arts::PortDesc::hasValue()
  1218. {
  1219.     return _cache?static_cast<Arts::PortDesc_base*>(_cache)->hasValue():static_cast<Arts::PortDesc_base*>(_method_call())->hasValue();
  1220. }
  1221.  
  1222. inline void Arts::PortDesc::hasValue(bool _newValue)
  1223. {
  1224.      _cache?static_cast<Arts::PortDesc_base*>(_cache)->hasValue(_newValue):static_cast<Arts::PortDesc_base*>(_method_call())->hasValue(_newValue);
  1225. }
  1226.  
  1227. inline std::vector<Arts::PortDesc> * Arts::PortDesc::connections()
  1228. {
  1229.     return _cache?static_cast<Arts::PortDesc_base*>(_cache)->connections():static_cast<Arts::PortDesc_base*>(_method_call())->connections();
  1230. }
  1231.  
  1232. inline float Arts::PortDesc::floatValue()
  1233. {
  1234.     return _cache?static_cast<Arts::PortDesc_base*>(_cache)->floatValue():static_cast<Arts::PortDesc_base*>(_method_call())->floatValue();
  1235. }
  1236.  
  1237. inline void Arts::PortDesc::floatValue(float _newValue)
  1238. {
  1239.      _cache?static_cast<Arts::PortDesc_base*>(_cache)->floatValue(_newValue):static_cast<Arts::PortDesc_base*>(_method_call())->floatValue(_newValue);
  1240. }
  1241.  
  1242. inline std::string Arts::PortDesc::stringValue()
  1243. {
  1244.     return _cache?static_cast<Arts::PortDesc_base*>(_cache)->stringValue():static_cast<Arts::PortDesc_base*>(_method_call())->stringValue();
  1245. }
  1246.  
  1247. inline void Arts::PortDesc::stringValue(const std::string& _newValue)
  1248. {
  1249.      _cache?static_cast<Arts::PortDesc_base*>(_cache)->stringValue(_newValue):static_cast<Arts::PortDesc_base*>(_method_call())->stringValue(_newValue);
  1250. }
  1251.  
  1252. inline Arts::Any Arts::PortDesc::value()
  1253. {
  1254.     return _cache?static_cast<Arts::PortDesc_base*>(_cache)->value():static_cast<Arts::PortDesc_base*>(_method_call())->value();
  1255. }
  1256.  
  1257. inline void Arts::PortDesc::value(const Arts::Any& _newValue)
  1258. {
  1259.      _cache?static_cast<Arts::PortDesc_base*>(_cache)->value(_newValue):static_cast<Arts::PortDesc_base*>(_method_call())->value(_newValue);
  1260. }
  1261.  
  1262. inline long Arts::PortDesc::internalOldID()
  1263. {
  1264.     return _cache?static_cast<Arts::PortDesc_base*>(_cache)->internalOldID():static_cast<Arts::PortDesc_base*>(_method_call())->internalOldID();
  1265. }
  1266.  
  1267. inline Arts::PortDesc::PortDesc(Arts::ModuleDesc parent, const std::string& name, const Arts::PortType& type)
  1268.         : Arts::Object(PortDesc_base::_create())
  1269. {
  1270.     static_cast<Arts::PortDesc_base*>(_method_call())->constructor(parent, name, type);
  1271. }
  1272.  
  1273. inline bool Arts::PortDesc::connectTo(Arts::PortDesc port)
  1274. {
  1275.     return _cache?static_cast<Arts::PortDesc_base*>(_cache)->connectTo(port):static_cast<Arts::PortDesc_base*>(_method_call())->connectTo(port);
  1276. }
  1277.  
  1278. inline void Arts::PortDesc::disconnectFrom(Arts::PortDesc port)
  1279. {
  1280.      _cache?static_cast<Arts::PortDesc_base*>(_cache)->disconnectFrom(port):static_cast<Arts::PortDesc_base*>(_method_call())->disconnectFrom(port);
  1281. }
  1282.  
  1283. inline void Arts::PortDesc::disconnectAll()
  1284. {
  1285.      _cache?static_cast<Arts::PortDesc_base*>(_cache)->disconnectAll():static_cast<Arts::PortDesc_base*>(_method_call())->disconnectAll();
  1286. }
  1287.  
  1288. inline std::vector<std::string> * Arts::PortDesc::saveToList()
  1289. {
  1290.     return _cache?static_cast<Arts::PortDesc_base*>(_cache)->saveToList():static_cast<Arts::PortDesc_base*>(_method_call())->saveToList();
  1291. }
  1292.  
  1293. inline void Arts::PortDesc::loadFromList(const std::vector<std::string>& list)
  1294. {
  1295.      _cache?static_cast<Arts::PortDesc_base*>(_cache)->loadFromList(list):static_cast<Arts::PortDesc_base*>(_method_call())->loadFromList(list);
  1296. }
  1297.  
  1298. inline void Arts::PortDesc::internalConnectInput(Arts::PortDesc port)
  1299. {
  1300.      _cache?static_cast<Arts::PortDesc_base*>(_cache)->internalConnectInput(port):static_cast<Arts::PortDesc_base*>(_method_call())->internalConnectInput(port);
  1301. }
  1302.  
  1303. inline void Arts::PortDesc::internalReConnect(const std::vector<Arts::PortDesc>& allports)
  1304. {
  1305.      _cache?static_cast<Arts::PortDesc_base*>(_cache)->internalReConnect(allports):static_cast<Arts::PortDesc_base*>(_method_call())->internalReConnect(allports);
  1306. }
  1307.  
  1308. inline long Arts::ModuleDesc::ID()
  1309. {
  1310.     return _cache?static_cast<Arts::ModuleDesc_base*>(_cache)->ID():static_cast<Arts::ModuleDesc_base*>(_method_call())->ID();
  1311. }
  1312.  
  1313. inline Arts::StructureDesc Arts::ModuleDesc::parent()
  1314. {
  1315.     return _cache?static_cast<Arts::ModuleDesc_base*>(_cache)->parent():static_cast<Arts::ModuleDesc_base*>(_method_call())->parent();
  1316. }
  1317.  
  1318. inline std::string Arts::ModuleDesc::name()
  1319. {
  1320.     return _cache?static_cast<Arts::ModuleDesc_base*>(_cache)->name():static_cast<Arts::ModuleDesc_base*>(_method_call())->name();
  1321. }
  1322.  
  1323. inline std::vector<Arts::PortDesc> * Arts::ModuleDesc::ports()
  1324. {
  1325.     return _cache?static_cast<Arts::ModuleDesc_base*>(_cache)->ports():static_cast<Arts::ModuleDesc_base*>(_method_call())->ports();
  1326. }
  1327.  
  1328. inline long Arts::ModuleDesc::x()
  1329. {
  1330.     return _cache?static_cast<Arts::ModuleDesc_base*>(_cache)->x():static_cast<Arts::ModuleDesc_base*>(_method_call())->x();
  1331. }
  1332.  
  1333. inline long Arts::ModuleDesc::y()
  1334. {
  1335.     return _cache?static_cast<Arts::ModuleDesc_base*>(_cache)->y():static_cast<Arts::ModuleDesc_base*>(_method_call())->y();
  1336. }
  1337.  
  1338. inline long Arts::ModuleDesc::width()
  1339. {
  1340.     return _cache?static_cast<Arts::ModuleDesc_base*>(_cache)->width():static_cast<Arts::ModuleDesc_base*>(_method_call())->width();
  1341. }
  1342.  
  1343. inline long Arts::ModuleDesc::height()
  1344. {
  1345.     return _cache?static_cast<Arts::ModuleDesc_base*>(_cache)->height():static_cast<Arts::ModuleDesc_base*>(_method_call())->height();
  1346. }
  1347.  
  1348. inline bool Arts::ModuleDesc::isInterface()
  1349. {
  1350.     return _cache?static_cast<Arts::ModuleDesc_base*>(_cache)->isInterface():static_cast<Arts::ModuleDesc_base*>(_method_call())->isInterface();
  1351. }
  1352.  
  1353. inline bool Arts::ModuleDesc::isStructure()
  1354. {
  1355.     return _cache?static_cast<Arts::ModuleDesc_base*>(_cache)->isStructure():static_cast<Arts::ModuleDesc_base*>(_method_call())->isStructure();
  1356. }
  1357.  
  1358. inline Arts::ModuleDesc::ModuleDesc(Arts::StructureDesc parent, const Arts::ModuleInfo& info)
  1359.         : Arts::Object(ModuleDesc_base::_create())
  1360. {
  1361.     static_cast<Arts::ModuleDesc_base*>(_method_call())->constructor(parent, info);
  1362. }
  1363.  
  1364. inline bool Arts::ModuleDesc::moveTo(long x, long y)
  1365. {
  1366.     return _cache?static_cast<Arts::ModuleDesc_base*>(_cache)->moveTo(x, y):static_cast<Arts::ModuleDesc_base*>(_method_call())->moveTo(x, y);
  1367. }
  1368.  
  1369. inline Arts::PortDesc Arts::ModuleDesc::findPort(const std::string& name)
  1370. {
  1371.     return _cache?static_cast<Arts::ModuleDesc_base*>(_cache)->findPort(name):static_cast<Arts::ModuleDesc_base*>(_method_call())->findPort(name);
  1372. }
  1373.  
  1374. inline std::vector<std::string> * Arts::ModuleDesc::saveToList()
  1375. {
  1376.     return _cache?static_cast<Arts::ModuleDesc_base*>(_cache)->saveToList():static_cast<Arts::ModuleDesc_base*>(_method_call())->saveToList();
  1377. }
  1378.  
  1379. inline void Arts::ModuleDesc::loadFromList(const std::vector<std::string>& list)
  1380. {
  1381.      _cache?static_cast<Arts::ModuleDesc_base*>(_cache)->loadFromList(list):static_cast<Arts::ModuleDesc_base*>(_method_call())->loadFromList(list);
  1382. }
  1383.  
  1384. inline bool Arts::StructureDesc::valid()
  1385. {
  1386.     return _cache?static_cast<Arts::StructureDesc_base*>(_cache)->valid():static_cast<Arts::StructureDesc_base*>(_method_call())->valid();
  1387. }
  1388.  
  1389. inline std::string Arts::StructureDesc::name()
  1390. {
  1391.     return _cache?static_cast<Arts::StructureDesc_base*>(_cache)->name():static_cast<Arts::StructureDesc_base*>(_method_call())->name();
  1392. }
  1393.  
  1394. inline void Arts::StructureDesc::name(const std::string& _newValue)
  1395. {
  1396.      _cache?static_cast<Arts::StructureDesc_base*>(_cache)->name(_newValue):static_cast<Arts::StructureDesc_base*>(_method_call())->name(_newValue);
  1397. }
  1398.  
  1399. inline std::vector<Arts::ModuleDesc> * Arts::StructureDesc::modules()
  1400. {
  1401.     return _cache?static_cast<Arts::StructureDesc_base*>(_cache)->modules():static_cast<Arts::StructureDesc_base*>(_method_call())->modules();
  1402. }
  1403.  
  1404. inline std::vector<Arts::StructurePortDesc> * Arts::StructureDesc::ports()
  1405. {
  1406.     return _cache?static_cast<Arts::StructureDesc_base*>(_cache)->ports():static_cast<Arts::StructureDesc_base*>(_method_call())->ports();
  1407. }
  1408.  
  1409. inline std::vector<std::string> * Arts::StructureDesc::inheritedInterfaces()
  1410. {
  1411.     return _cache?static_cast<Arts::StructureDesc_base*>(_cache)->inheritedInterfaces():static_cast<Arts::StructureDesc_base*>(_method_call())->inheritedInterfaces();
  1412. }
  1413.  
  1414. inline Arts::ModuleInfo Arts::StructureDesc::externalInterface()
  1415. {
  1416.     return _cache?static_cast<Arts::StructureDesc_base*>(_cache)->externalInterface():static_cast<Arts::StructureDesc_base*>(_method_call())->externalInterface();
  1417. }
  1418.  
  1419. inline long Arts::StructureDesc::obtainID()
  1420. {
  1421.     return _cache?static_cast<Arts::StructureDesc_base*>(_cache)->obtainID():static_cast<Arts::StructureDesc_base*>(_method_call())->obtainID();
  1422. }
  1423.  
  1424. inline std::vector<std::string> * Arts::StructureDesc::saveToList()
  1425. {
  1426.     return _cache?static_cast<Arts::StructureDesc_base*>(_cache)->saveToList():static_cast<Arts::StructureDesc_base*>(_method_call())->saveToList();
  1427. }
  1428.  
  1429. inline void Arts::StructureDesc::loadFromList(const std::vector<std::string>& list)
  1430. {
  1431.      _cache?static_cast<Arts::StructureDesc_base*>(_cache)->loadFromList(list):static_cast<Arts::StructureDesc_base*>(_method_call())->loadFromList(list);
  1432. }
  1433.  
  1434. inline void Arts::StructureDesc::clear()
  1435. {
  1436.      _cache?static_cast<Arts::StructureDesc_base*>(_cache)->clear():static_cast<Arts::StructureDesc_base*>(_method_call())->clear();
  1437. }
  1438.  
  1439. inline Arts::ModuleDesc Arts::StructureDesc::createModuleDesc(const Arts::ModuleInfo& info)
  1440. {
  1441.     return _cache?static_cast<Arts::StructureDesc_base*>(_cache)->createModuleDesc(info):static_cast<Arts::StructureDesc_base*>(_method_call())->createModuleDesc(info);
  1442. }
  1443.  
  1444. inline void Arts::StructureDesc::freeModuleDesc(Arts::ModuleDesc moduledesc)
  1445. {
  1446.      _cache?static_cast<Arts::StructureDesc_base*>(_cache)->freeModuleDesc(moduledesc):static_cast<Arts::StructureDesc_base*>(_method_call())->freeModuleDesc(moduledesc);
  1447. }
  1448.  
  1449. inline Arts::StructurePortDesc Arts::StructureDesc::createStructurePortDesc(const Arts::PortType& type, const std::string& name)
  1450. {
  1451.     return _cache?static_cast<Arts::StructureDesc_base*>(_cache)->createStructurePortDesc(type, name):static_cast<Arts::StructureDesc_base*>(_method_call())->createStructurePortDesc(type, name);
  1452. }
  1453.  
  1454. inline void Arts::StructureDesc::freeStructurePortDesc(Arts::StructurePortDesc portdesc)
  1455. {
  1456.      _cache?static_cast<Arts::StructureDesc_base*>(_cache)->freeStructurePortDesc(portdesc):static_cast<Arts::StructureDesc_base*>(_method_call())->freeStructurePortDesc(portdesc);
  1457. }
  1458.  
  1459. inline void Arts::StructureDesc::moveStructurePortDesc(Arts::StructurePortDesc portdesc, long newposition)
  1460. {
  1461.      _cache?static_cast<Arts::StructureDesc_base*>(_cache)->moveStructurePortDesc(portdesc, newposition):static_cast<Arts::StructureDesc_base*>(_method_call())->moveStructurePortDesc(portdesc, newposition);
  1462. }
  1463.  
  1464. inline void Arts::StructureDesc::addInheritedInterface(const std::string& iface)
  1465. {
  1466.      _cache?static_cast<Arts::StructureDesc_base*>(_cache)->addInheritedInterface(iface):static_cast<Arts::StructureDesc_base*>(_method_call())->addInheritedInterface(iface);
  1467. }
  1468.  
  1469. inline void Arts::StructureDesc::removeInheritedInterface(const std::string& iface)
  1470. {
  1471.      _cache?static_cast<Arts::StructureDesc_base*>(_cache)->removeInheritedInterface(iface):static_cast<Arts::StructureDesc_base*>(_method_call())->removeInheritedInterface(iface);
  1472. }
  1473.  
  1474. inline long Arts::StructurePortDesc::ID()
  1475. {
  1476.     return _cache?static_cast<Arts::PortDesc_base*>(_cache)->ID():static_cast<Arts::PortDesc_base*>(_method_call())->ID();
  1477. }
  1478.  
  1479. inline Arts::ModuleDesc Arts::StructurePortDesc::parent()
  1480. {
  1481.     return _cache?static_cast<Arts::PortDesc_base*>(_cache)->parent():static_cast<Arts::PortDesc_base*>(_method_call())->parent();
  1482. }
  1483.  
  1484. inline std::string Arts::StructurePortDesc::name()
  1485. {
  1486.     return _cache?static_cast<Arts::PortDesc_base*>(_cache)->name():static_cast<Arts::PortDesc_base*>(_method_call())->name();
  1487. }
  1488.  
  1489. inline Arts::PortType Arts::StructurePortDesc::type()
  1490. {
  1491.     return _cache?static_cast<Arts::PortDesc_base*>(_cache)->type():static_cast<Arts::PortDesc_base*>(_method_call())->type();
  1492. }
  1493.  
  1494. inline bool Arts::StructurePortDesc::isConnected()
  1495. {
  1496.     return _cache?static_cast<Arts::PortDesc_base*>(_cache)->isConnected():static_cast<Arts::PortDesc_base*>(_method_call())->isConnected();
  1497. }
  1498.  
  1499. inline bool Arts::StructurePortDesc::hasValue()
  1500. {
  1501.     return _cache?static_cast<Arts::PortDesc_base*>(_cache)->hasValue():static_cast<Arts::PortDesc_base*>(_method_call())->hasValue();
  1502. }
  1503.  
  1504. inline void Arts::StructurePortDesc::hasValue(bool _newValue)
  1505. {
  1506.      _cache?static_cast<Arts::PortDesc_base*>(_cache)->hasValue(_newValue):static_cast<Arts::PortDesc_base*>(_method_call())->hasValue(_newValue);
  1507. }
  1508.  
  1509. inline std::vector<Arts::PortDesc> * Arts::StructurePortDesc::connections()
  1510. {
  1511.     return _cache?static_cast<Arts::PortDesc_base*>(_cache)->connections():static_cast<Arts::PortDesc_base*>(_method_call())->connections();
  1512. }
  1513.  
  1514. inline float Arts::StructurePortDesc::floatValue()
  1515. {
  1516.     return _cache?static_cast<Arts::PortDesc_base*>(_cache)->floatValue():static_cast<Arts::PortDesc_base*>(_method_call())->floatValue();
  1517. }
  1518.  
  1519. inline void Arts::StructurePortDesc::floatValue(float _newValue)
  1520. {
  1521.      _cache?static_cast<Arts::PortDesc_base*>(_cache)->floatValue(_newValue):static_cast<Arts::PortDesc_base*>(_method_call())->floatValue(_newValue);
  1522. }
  1523.  
  1524. inline std::string Arts::StructurePortDesc::stringValue()
  1525. {
  1526.     return _cache?static_cast<Arts::PortDesc_base*>(_cache)->stringValue():static_cast<Arts::PortDesc_base*>(_method_call())->stringValue();
  1527. }
  1528.  
  1529. inline void Arts::StructurePortDesc::stringValue(const std::string& _newValue)
  1530. {
  1531.      _cache?static_cast<Arts::PortDesc_base*>(_cache)->stringValue(_newValue):static_cast<Arts::PortDesc_base*>(_method_call())->stringValue(_newValue);
  1532. }
  1533.  
  1534. inline Arts::Any Arts::StructurePortDesc::value()
  1535. {
  1536.     return _cache?static_cast<Arts::PortDesc_base*>(_cache)->value():static_cast<Arts::PortDesc_base*>(_method_call())->value();
  1537. }
  1538.  
  1539. inline void Arts::StructurePortDesc::value(const Arts::Any& _newValue)
  1540. {
  1541.      _cache?static_cast<Arts::PortDesc_base*>(_cache)->value(_newValue):static_cast<Arts::PortDesc_base*>(_method_call())->value(_newValue);
  1542. }
  1543.  
  1544. inline long Arts::StructurePortDesc::internalOldID()
  1545. {
  1546.     return _cache?static_cast<Arts::PortDesc_base*>(_cache)->internalOldID():static_cast<Arts::PortDesc_base*>(_method_call())->internalOldID();
  1547. }
  1548.  
  1549. inline Arts::StructurePortDesc::StructurePortDesc(Arts::ModuleDesc parent, const std::string& name, const Arts::PortType& type)
  1550.         : Arts::Object(StructurePortDesc_base::_create())
  1551. {
  1552.     static_cast<Arts::PortDesc_base*>(_method_call())->constructor(parent, name, type);
  1553. }
  1554.  
  1555. inline bool Arts::StructurePortDesc::connectTo(Arts::PortDesc port)
  1556. {
  1557.     return _cache?static_cast<Arts::PortDesc_base*>(_cache)->connectTo(port):static_cast<Arts::PortDesc_base*>(_method_call())->connectTo(port);
  1558. }
  1559.  
  1560. inline void Arts::StructurePortDesc::disconnectFrom(Arts::PortDesc port)
  1561. {
  1562.      _cache?static_cast<Arts::PortDesc_base*>(_cache)->disconnectFrom(port):static_cast<Arts::PortDesc_base*>(_method_call())->disconnectFrom(port);
  1563. }
  1564.  
  1565. inline void Arts::StructurePortDesc::disconnectAll()
  1566. {
  1567.      _cache?static_cast<Arts::PortDesc_base*>(_cache)->disconnectAll():static_cast<Arts::PortDesc_base*>(_method_call())->disconnectAll();
  1568. }
  1569.  
  1570. inline std::vector<std::string> * Arts::StructurePortDesc::saveToList()
  1571. {
  1572.     return _cache?static_cast<Arts::PortDesc_base*>(_cache)->saveToList():static_cast<Arts::PortDesc_base*>(_method_call())->saveToList();
  1573. }
  1574.  
  1575. inline void Arts::StructurePortDesc::loadFromList(const std::vector<std::string>& list)
  1576. {
  1577.      _cache?static_cast<Arts::PortDesc_base*>(_cache)->loadFromList(list):static_cast<Arts::PortDesc_base*>(_method_call())->loadFromList(list);
  1578. }
  1579.  
  1580. inline void Arts::StructurePortDesc::internalConnectInput(Arts::PortDesc port)
  1581. {
  1582.      _cache?static_cast<Arts::PortDesc_base*>(_cache)->internalConnectInput(port):static_cast<Arts::PortDesc_base*>(_method_call())->internalConnectInput(port);
  1583. }
  1584.  
  1585. inline void Arts::StructurePortDesc::internalReConnect(const std::vector<Arts::PortDesc>& allports)
  1586. {
  1587.      _cache?static_cast<Arts::PortDesc_base*>(_cache)->internalReConnect(allports):static_cast<Arts::PortDesc_base*>(_method_call())->internalReConnect(allports);
  1588. }
  1589.  
  1590. inline long Arts::StructurePortDesc::x()
  1591. {
  1592.     return _cache?static_cast<Arts::StructurePortDesc_base*>(_cache)->x():static_cast<Arts::StructurePortDesc_base*>(_method_call())->x();
  1593. }
  1594.  
  1595. inline long Arts::StructurePortDesc::y()
  1596. {
  1597.     return _cache?static_cast<Arts::StructurePortDesc_base*>(_cache)->y():static_cast<Arts::StructurePortDesc_base*>(_method_call())->y();
  1598. }
  1599.  
  1600. inline long Arts::StructurePortDesc::position()
  1601. {
  1602.     return _cache?static_cast<Arts::StructurePortDesc_base*>(_cache)->position():static_cast<Arts::StructurePortDesc_base*>(_method_call())->position();
  1603. }
  1604.  
  1605. inline Arts::StructureDesc Arts::StructurePortDesc::parentStructure()
  1606. {
  1607.     return _cache?static_cast<Arts::StructurePortDesc_base*>(_cache)->parentStructure():static_cast<Arts::StructurePortDesc_base*>(_method_call())->parentStructure();
  1608. }
  1609.  
  1610. inline std::string Arts::StructurePortDesc::inheritedInterface()
  1611. {
  1612.     return _cache?static_cast<Arts::StructurePortDesc_base*>(_cache)->inheritedInterface():static_cast<Arts::StructurePortDesc_base*>(_method_call())->inheritedInterface();
  1613. }
  1614.  
  1615. inline void Arts::StructurePortDesc::inheritedInterface(const std::string& _newValue)
  1616. {
  1617.      _cache?static_cast<Arts::StructurePortDesc_base*>(_cache)->inheritedInterface(_newValue):static_cast<Arts::StructurePortDesc_base*>(_method_call())->inheritedInterface(_newValue);
  1618. }
  1619.  
  1620. inline Arts::StructurePortDesc::StructurePortDesc(Arts::StructureDesc parent, const std::string& name, const Arts::PortType& type)
  1621.         : Arts::Object(StructurePortDesc_base::_create())
  1622. {
  1623.     static_cast<Arts::StructurePortDesc_base*>(_method_call())->constructor(parent, name, type);
  1624. }
  1625.  
  1626. inline bool Arts::StructurePortDesc::moveTo(long x, long y)
  1627. {
  1628.     return _cache?static_cast<Arts::StructurePortDesc_base*>(_cache)->moveTo(x, y):static_cast<Arts::StructurePortDesc_base*>(_method_call())->moveTo(x, y);
  1629. }
  1630.  
  1631. inline void Arts::StructurePortDesc::lowerPosition()
  1632. {
  1633.      _cache?static_cast<Arts::StructurePortDesc_base*>(_cache)->lowerPosition():static_cast<Arts::StructurePortDesc_base*>(_method_call())->lowerPosition();
  1634. }
  1635.  
  1636. inline void Arts::StructurePortDesc::raisePosition()
  1637. {
  1638.      _cache?static_cast<Arts::StructurePortDesc_base*>(_cache)->raisePosition():static_cast<Arts::StructurePortDesc_base*>(_method_call())->raisePosition();
  1639. }
  1640.  
  1641. inline void Arts::StructurePortDesc::rename(const std::string& newname)
  1642. {
  1643.      _cache?static_cast<Arts::StructurePortDesc_base*>(_cache)->rename(newname):static_cast<Arts::StructurePortDesc_base*>(_method_call())->rename(newname);
  1644. }
  1645.  
  1646. inline void Arts::StructurePortDesc::internalSetPosition(long position)
  1647. {
  1648.      _cache?static_cast<Arts::StructurePortDesc_base*>(_cache)->internalSetPosition(position):static_cast<Arts::StructurePortDesc_base*>(_method_call())->internalSetPosition(position);
  1649. }
  1650.  
  1651. inline Arts::Object Arts::ObjectFactory::createObject(const std::string& name)
  1652. {
  1653.     return _cache?static_cast<Arts::ObjectFactory_base*>(_cache)->createObject(name):static_cast<Arts::ObjectFactory_base*>(_method_call())->createObject(name);
  1654. }
  1655.  
  1656. inline Arts::Object Arts::LocalFactory::createObject(const std::string& name)
  1657. {
  1658.     return _cache?static_cast<Arts::ObjectFactory_base*>(_cache)->createObject(name):static_cast<Arts::ObjectFactory_base*>(_method_call())->createObject(name);
  1659. }
  1660.  
  1661. inline void Arts::StructureBuilder::addFactory(Arts::ObjectFactory factory)
  1662. {
  1663.      _cache?static_cast<Arts::StructureBuilder_base*>(_cache)->addFactory(factory):static_cast<Arts::StructureBuilder_base*>(_method_call())->addFactory(factory);
  1664. }
  1665.  
  1666. inline Arts::Object Arts::StructureBuilder::createObject(Arts::StructureDesc structure)
  1667. {
  1668.     return _cache?static_cast<Arts::StructureBuilder_base*>(_cache)->createObject(structure):static_cast<Arts::StructureBuilder_base*>(_method_call())->createObject(structure);
  1669. }
  1670.  
  1671. inline Arts::ModuleDef Arts::StructureBuilder::createTypeInfo(Arts::StructureDesc structure)
  1672. {
  1673.     return _cache?static_cast<Arts::StructureBuilder_base*>(_cache)->createTypeInfo(structure):static_cast<Arts::StructureBuilder_base*>(_method_call())->createTypeInfo(structure);
  1674. }
  1675.  
  1676. inline std::string Arts::ArtsBuilderLoader::dataVersion()
  1677. {
  1678.     return _cache?static_cast<Arts::Loader_base*>(_cache)->dataVersion():static_cast<Arts::Loader_base*>(_method_call())->dataVersion();
  1679. }
  1680.  
  1681. inline std::vector<Arts::TraderEntry> * Arts::ArtsBuilderLoader::traderEntries()
  1682. {
  1683.     return _cache?static_cast<Arts::Loader_base*>(_cache)->traderEntries():static_cast<Arts::Loader_base*>(_method_call())->traderEntries();
  1684. }
  1685.  
  1686. inline std::vector<Arts::ModuleDef> * Arts::ArtsBuilderLoader::modules()
  1687. {
  1688.     return _cache?static_cast<Arts::Loader_base*>(_cache)->modules():static_cast<Arts::Loader_base*>(_method_call())->modules();
  1689. }
  1690.  
  1691. inline Arts::Object Arts::ArtsBuilderLoader::loadObject(Arts::TraderOffer offer)
  1692. {
  1693.     return _cache?static_cast<Arts::Loader_base*>(_cache)->loadObject(offer):static_cast<Arts::Loader_base*>(_method_call())->loadObject(offer);
  1694. }
  1695.  
  1696. inline Arts::AutoSuspendState Arts::Structure::autoSuspend()
  1697. {
  1698.     return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
  1699. }
  1700.  
  1701. inline void Arts::Structure::start()
  1702. {
  1703.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
  1704. }
  1705.  
  1706. inline void Arts::Structure::stop()
  1707. {
  1708.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
  1709. }
  1710.  
  1711. inline void Arts::Structure::streamInit()
  1712. {
  1713.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
  1714. }
  1715.  
  1716. inline void Arts::Structure::streamStart()
  1717. {
  1718.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
  1719. }
  1720.  
  1721. inline void Arts::Structure::streamEnd()
  1722. {
  1723.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
  1724. }
  1725.  
  1726. inline void Arts::Structure::run()
  1727. {
  1728.      _cache?static_cast<Arts::Structure_base*>(_cache)->run():static_cast<Arts::Structure_base*>(_method_call())->run();
  1729. }
  1730.  
  1731. inline void Arts::Structure::halt()
  1732. {
  1733.      _cache?static_cast<Arts::Structure_base*>(_cache)->halt():static_cast<Arts::Structure_base*>(_method_call())->halt();
  1734. }
  1735.  
  1736. #endif /* ARTSBUILDER_H */
  1737.