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 / artsflow.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-09-11  |  147.7 KB  |  4,164 lines
  1. /* this file was generated by the MCOP idl compiler - DO NOT EDIT */
  2.  
  3. #ifndef ARTSFLOW_H
  4. #define ARTSFLOW_H
  5.  
  6. #include "common.h"
  7.  
  8. #include "arts_export.h"
  9.  
  10. namespace Arts {
  11. enum AutoSuspendState {asNoSuspend = 0, asSuspend = 1, asSuspendStop = 2, asSuspendMask = 3, asProducer = 16, asConsumer = 32, asDirectionMask = 48};
  12. enum AudioManagerDirection {amPlay = 0, amRecord = 1};
  13. }
  14. namespace Arts {
  15. class ARTS_EXPORT AudioManagerInfo : public Arts::Type {
  16. public:
  17.     AudioManagerInfo();
  18.     AudioManagerInfo(long _a_ID, const std::string& _a_destination, Arts::AudioManagerDirection _a_direction, const std::string& _a_title, const std::string& _a_autoRestoreID);
  19.     AudioManagerInfo(Arts::Buffer& stream);
  20.     AudioManagerInfo(const AudioManagerInfo& copyType);
  21.     AudioManagerInfo& operator=(const AudioManagerInfo& assignType);
  22.     long ID;
  23.     std::string destination;
  24.     Arts::AudioManagerDirection direction;
  25.     std::string title;
  26.     std::string autoRestoreID;
  27.  
  28. // marshalling functions
  29.     void readType(Arts::Buffer& stream);
  30.     void writeType(Arts::Buffer& stream) const;
  31.     std::string _typeName() const;
  32. };
  33.  
  34. }
  35. namespace Arts {
  36. class SynthModule;
  37. class Synth_PLAY;
  38. class Synth_RECORD;
  39. class Synth_FREQUENCY;
  40. class Synth_WAVE_SIN;
  41. class Synth_MULTI_ADD;
  42. class Synth_ADD;
  43. class Synth_MUL;
  44. class Synth_PLAY_WAV;
  45. class Synth_BUS_UPLINK;
  46. class Synth_BUS_DOWNLINK;
  47. class ByteStreamToAudio;
  48. class AudioToByteStream;
  49. class StereoEffect;
  50. class StereoVolumeControl;
  51. class StereoFFTScope;
  52. class StereoEffectStack;
  53. class AudioManagerClient;
  54. class AudioManager;
  55. class Synth_AMAN_PLAY;
  56. class Synth_AMAN_RECORD;
  57. class DataHandle;
  58. class ReversedDataHandle;
  59. class CroppedDataHandle;
  60. class CutDataHandle;
  61. class DataHandlePlay;
  62. class WaveDataHandle;
  63.  
  64. class ARTS_EXPORT SynthModule_base : virtual public Arts::Object_base {
  65. public:
  66.     static unsigned long _IID; // interface ID
  67.  
  68.     static SynthModule_base *_create(const std::string& subClass = "Arts::SynthModule");
  69.     static SynthModule_base *_fromString(const std::string& objectref);
  70.     static SynthModule_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  71.  
  72.     static SynthModule_base *_fromDynamicCast(const Arts::Object& object);
  73.     inline SynthModule_base *_copy() {
  74.         assert(_refCnt > 0);
  75.         _refCnt++;
  76.         return this;
  77.     }
  78.  
  79.     virtual std::vector<std::string> _defaultPortsIn() const;
  80.     virtual std::vector<std::string> _defaultPortsOut() const;
  81.  
  82.     void *_cast(unsigned long iid);
  83.  
  84.     virtual Arts::AutoSuspendState autoSuspend() = 0;
  85.     virtual void start() = 0;
  86.     virtual void stop() = 0;
  87.     virtual void streamInit() = 0;
  88.     virtual void streamStart() = 0;
  89.     virtual void streamEnd() = 0;
  90. };
  91.  
  92. class ARTS_EXPORT SynthModule_stub : virtual public SynthModule_base, virtual public Arts::Object_stub {
  93. protected:
  94.     SynthModule_stub();
  95.  
  96. public:
  97.     SynthModule_stub(Arts::Connection *connection, long objectID);
  98.  
  99.     Arts::AutoSuspendState autoSuspend();
  100.     void start();
  101.     void stop();
  102.     void streamInit();
  103.     void streamStart();
  104.     void streamEnd();
  105. };
  106.  
  107. class ARTS_EXPORT SynthModule_skel : virtual public SynthModule_base, virtual public Arts::Object_skel {
  108. protected:
  109.     // emitters for change notifications
  110.     inline void autoSuspend_changed(Arts::AutoSuspendState newValue) {
  111.         _emit_changed("autoSuspend_changed",newValue);
  112.     }
  113.  
  114. public:
  115.     SynthModule_skel();
  116.  
  117.     static std::string _interfaceNameSkel();
  118.     std::string _interfaceName();
  119.     bool _isCompatibleWith(const std::string& interfacename);
  120.     void _buildMethodTable();
  121.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  122. };
  123.  
  124. }
  125. #include "reference.h"
  126. namespace Arts {
  127. class ARTS_EXPORT SynthModule : public Arts::Object {
  128. private:
  129.     static Arts::Object_base* _Creator();
  130.     SynthModule_base *_cache;
  131.     inline SynthModule_base *_method_call() {
  132.         _pool->checkcreate();
  133.         if(_pool->base) {
  134.             _cache=(SynthModule_base *)_pool->base->_cast(SynthModule_base::_IID);
  135.             assert(_cache);
  136.         }
  137.         return _cache;
  138.     }
  139.  
  140. protected:
  141.     inline SynthModule(SynthModule_base* b) : Arts::Object(b), _cache(0) {}
  142.  
  143.  
  144. public:
  145.     typedef SynthModule_base _base_class;
  146.  
  147.     inline SynthModule() : Arts::Object(_Creator), _cache(0) {}
  148.     inline SynthModule(const Arts::SubClass& s) :
  149.         Arts::Object(SynthModule_base::_create(s.string())), _cache(0) {}
  150.     inline SynthModule(const Arts::Reference &r) :
  151.         Arts::Object(r.isString()?(SynthModule_base::_fromString(r.string())):(SynthModule_base::_fromReference(r.reference(),true))), _cache(0) {}
  152.     inline SynthModule(const Arts::DynamicCast& c) : Arts::Object(SynthModule_base::_fromDynamicCast(c.object())), _cache(0) {}
  153.     inline SynthModule(const SynthModule& target) : Arts::Object(target._pool), _cache(target._cache) {}
  154.     inline SynthModule(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  155.     inline static SynthModule null() {return SynthModule((SynthModule_base*)0);}
  156.     inline static SynthModule _from_base(SynthModule_base* b) {return SynthModule(b);}
  157.     inline SynthModule& operator=(const SynthModule& target) {
  158.         if (_pool == target._pool) return *this;
  159.         _pool->Dec();
  160.         _pool = target._pool;
  161.         _cache = target._cache;
  162.         _pool->Inc();
  163.         return *this;
  164.     }
  165.     inline SynthModule_base* _base() {return _cache?_cache:_method_call();}
  166.  
  167.     inline Arts::AutoSuspendState autoSuspend();
  168.     inline void start();
  169.     inline void stop();
  170.     inline void streamInit();
  171.     inline void streamStart();
  172.     inline void streamEnd();
  173. };
  174.  
  175. class ARTS_EXPORT Synth_PLAY_base : virtual public Arts::SynthModule_base {
  176. public:
  177.     static unsigned long _IID; // interface ID
  178.  
  179.     static Synth_PLAY_base *_create(const std::string& subClass = "Arts::Synth_PLAY");
  180.     static Synth_PLAY_base *_fromString(const std::string& objectref);
  181.     static Synth_PLAY_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  182.  
  183.     static Synth_PLAY_base *_fromDynamicCast(const Arts::Object& object);
  184.     inline Synth_PLAY_base *_copy() {
  185.         assert(_refCnt > 0);
  186.         _refCnt++;
  187.         return this;
  188.     }
  189.  
  190.     virtual std::vector<std::string> _defaultPortsIn() const;
  191.     virtual std::vector<std::string> _defaultPortsOut() const;
  192.  
  193.     void *_cast(unsigned long iid);
  194.  
  195. };
  196.  
  197. class ARTS_EXPORT Synth_PLAY_stub : virtual public Synth_PLAY_base, virtual public Arts::SynthModule_stub {
  198. protected:
  199.     Synth_PLAY_stub();
  200.  
  201. public:
  202.     Synth_PLAY_stub(Arts::Connection *connection, long objectID);
  203.  
  204. };
  205.  
  206. class ARTS_EXPORT Synth_PLAY_skel : virtual public Synth_PLAY_base, virtual public Arts::SynthModule_skel {
  207. protected:
  208.     // variables for streams
  209.     float *invalue_left;                      // incoming stream
  210.     float *invalue_right;                     // incoming stream
  211.  
  212. public:
  213.     Synth_PLAY_skel();
  214.  
  215.     static std::string _interfaceNameSkel();
  216.     std::string _interfaceName();
  217.     bool _isCompatibleWith(const std::string& interfacename);
  218.     void _buildMethodTable();
  219.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  220. };
  221.  
  222. }
  223. #include "reference.h"
  224. namespace Arts {
  225. class ARTS_EXPORT Synth_PLAY : public Arts::Object {
  226. private:
  227.     static Arts::Object_base* _Creator();
  228.     Synth_PLAY_base *_cache;
  229.     inline Synth_PLAY_base *_method_call() {
  230.         _pool->checkcreate();
  231.         if(_pool->base) {
  232.             _cache=(Synth_PLAY_base *)_pool->base->_cast(Synth_PLAY_base::_IID);
  233.             assert(_cache);
  234.         }
  235.         return _cache;
  236.     }
  237.  
  238. protected:
  239.     inline Synth_PLAY(Synth_PLAY_base* b) : Arts::Object(b), _cache(0) {}
  240.  
  241.  
  242. public:
  243.     typedef Synth_PLAY_base _base_class;
  244.  
  245.     inline Synth_PLAY() : Arts::Object(_Creator), _cache(0) {}
  246.     inline Synth_PLAY(const Arts::SubClass& s) :
  247.         Arts::Object(Synth_PLAY_base::_create(s.string())), _cache(0) {}
  248.     inline Synth_PLAY(const Arts::Reference &r) :
  249.         Arts::Object(r.isString()?(Synth_PLAY_base::_fromString(r.string())):(Synth_PLAY_base::_fromReference(r.reference(),true))), _cache(0) {}
  250.     inline Synth_PLAY(const Arts::DynamicCast& c) : Arts::Object(Synth_PLAY_base::_fromDynamicCast(c.object())), _cache(0) {}
  251.     inline Synth_PLAY(const Synth_PLAY& target) : Arts::Object(target._pool), _cache(target._cache) {}
  252.     inline Synth_PLAY(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  253.     inline static Synth_PLAY null() {return Synth_PLAY((Synth_PLAY_base*)0);}
  254.     inline static Synth_PLAY _from_base(Synth_PLAY_base* b) {return Synth_PLAY(b);}
  255.     inline Synth_PLAY& operator=(const Synth_PLAY& target) {
  256.         if (_pool == target._pool) return *this;
  257.         _pool->Dec();
  258.         _pool = target._pool;
  259.         _cache = target._cache;
  260.         _pool->Inc();
  261.         return *this;
  262.     }
  263.     inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
  264.     inline Synth_PLAY_base* _base() {return _cache?_cache:_method_call();}
  265.  
  266.     inline Arts::AutoSuspendState autoSuspend();
  267.     inline void start();
  268.     inline void stop();
  269.     inline void streamInit();
  270.     inline void streamStart();
  271.     inline void streamEnd();
  272. };
  273.  
  274. class ARTS_EXPORT Synth_RECORD_base : virtual public Arts::SynthModule_base {
  275. public:
  276.     static unsigned long _IID; // interface ID
  277.  
  278.     static Synth_RECORD_base *_create(const std::string& subClass = "Arts::Synth_RECORD");
  279.     static Synth_RECORD_base *_fromString(const std::string& objectref);
  280.     static Synth_RECORD_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  281.  
  282.     static Synth_RECORD_base *_fromDynamicCast(const Arts::Object& object);
  283.     inline Synth_RECORD_base *_copy() {
  284.         assert(_refCnt > 0);
  285.         _refCnt++;
  286.         return this;
  287.     }
  288.  
  289.     virtual std::vector<std::string> _defaultPortsIn() const;
  290.     virtual std::vector<std::string> _defaultPortsOut() const;
  291.  
  292.     void *_cast(unsigned long iid);
  293.  
  294. };
  295.  
  296. class ARTS_EXPORT Synth_RECORD_stub : virtual public Synth_RECORD_base, virtual public Arts::SynthModule_stub {
  297. protected:
  298.     Synth_RECORD_stub();
  299.  
  300. public:
  301.     Synth_RECORD_stub(Arts::Connection *connection, long objectID);
  302.  
  303. };
  304.  
  305. class ARTS_EXPORT Synth_RECORD_skel : virtual public Synth_RECORD_base, virtual public Arts::SynthModule_skel {
  306. protected:
  307.     // variables for streams
  308.     float *left;                              // outgoing stream
  309.     float *right;                             // outgoing stream
  310.  
  311. public:
  312.     Synth_RECORD_skel();
  313.  
  314.     static std::string _interfaceNameSkel();
  315.     std::string _interfaceName();
  316.     bool _isCompatibleWith(const std::string& interfacename);
  317.     void _buildMethodTable();
  318.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  319. };
  320.  
  321. }
  322. #include "reference.h"
  323. namespace Arts {
  324. class ARTS_EXPORT Synth_RECORD : public Arts::Object {
  325. private:
  326.     static Arts::Object_base* _Creator();
  327.     Synth_RECORD_base *_cache;
  328.     inline Synth_RECORD_base *_method_call() {
  329.         _pool->checkcreate();
  330.         if(_pool->base) {
  331.             _cache=(Synth_RECORD_base *)_pool->base->_cast(Synth_RECORD_base::_IID);
  332.             assert(_cache);
  333.         }
  334.         return _cache;
  335.     }
  336.  
  337. protected:
  338.     inline Synth_RECORD(Synth_RECORD_base* b) : Arts::Object(b), _cache(0) {}
  339.  
  340.  
  341. public:
  342.     typedef Synth_RECORD_base _base_class;
  343.  
  344.     inline Synth_RECORD() : Arts::Object(_Creator), _cache(0) {}
  345.     inline Synth_RECORD(const Arts::SubClass& s) :
  346.         Arts::Object(Synth_RECORD_base::_create(s.string())), _cache(0) {}
  347.     inline Synth_RECORD(const Arts::Reference &r) :
  348.         Arts::Object(r.isString()?(Synth_RECORD_base::_fromString(r.string())):(Synth_RECORD_base::_fromReference(r.reference(),true))), _cache(0) {}
  349.     inline Synth_RECORD(const Arts::DynamicCast& c) : Arts::Object(Synth_RECORD_base::_fromDynamicCast(c.object())), _cache(0) {}
  350.     inline Synth_RECORD(const Synth_RECORD& target) : Arts::Object(target._pool), _cache(target._cache) {}
  351.     inline Synth_RECORD(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  352.     inline static Synth_RECORD null() {return Synth_RECORD((Synth_RECORD_base*)0);}
  353.     inline static Synth_RECORD _from_base(Synth_RECORD_base* b) {return Synth_RECORD(b);}
  354.     inline Synth_RECORD& operator=(const Synth_RECORD& target) {
  355.         if (_pool == target._pool) return *this;
  356.         _pool->Dec();
  357.         _pool = target._pool;
  358.         _cache = target._cache;
  359.         _pool->Inc();
  360.         return *this;
  361.     }
  362.     inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
  363.     inline Synth_RECORD_base* _base() {return _cache?_cache:_method_call();}
  364.  
  365.     inline Arts::AutoSuspendState autoSuspend();
  366.     inline void start();
  367.     inline void stop();
  368.     inline void streamInit();
  369.     inline void streamStart();
  370.     inline void streamEnd();
  371. };
  372.  
  373. class ARTS_EXPORT Synth_FREQUENCY_base : virtual public Arts::SynthModule_base {
  374. public:
  375.     static unsigned long _IID; // interface ID
  376.  
  377.     static Synth_FREQUENCY_base *_create(const std::string& subClass = "Arts::Synth_FREQUENCY");
  378.     static Synth_FREQUENCY_base *_fromString(const std::string& objectref);
  379.     static Synth_FREQUENCY_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  380.  
  381.     static Synth_FREQUENCY_base *_fromDynamicCast(const Arts::Object& object);
  382.     inline Synth_FREQUENCY_base *_copy() {
  383.         assert(_refCnt > 0);
  384.         _refCnt++;
  385.         return this;
  386.     }
  387.  
  388.     virtual std::vector<std::string> _defaultPortsIn() const;
  389.     virtual std::vector<std::string> _defaultPortsOut() const;
  390.  
  391.     void *_cast(unsigned long iid);
  392.  
  393. };
  394.  
  395. class ARTS_EXPORT Synth_FREQUENCY_stub : virtual public Synth_FREQUENCY_base, virtual public Arts::SynthModule_stub {
  396. protected:
  397.     Synth_FREQUENCY_stub();
  398.  
  399. public:
  400.     Synth_FREQUENCY_stub(Arts::Connection *connection, long objectID);
  401.  
  402. };
  403.  
  404. class ARTS_EXPORT Synth_FREQUENCY_skel : virtual public Synth_FREQUENCY_base, virtual public Arts::SynthModule_skel {
  405. protected:
  406.     // variables for streams
  407.     float *frequency;                         // incoming stream
  408.     float *pos;                               // outgoing stream
  409.  
  410. public:
  411.     Synth_FREQUENCY_skel();
  412.  
  413.     static std::string _interfaceNameSkel();
  414.     std::string _interfaceName();
  415.     bool _isCompatibleWith(const std::string& interfacename);
  416.     void _buildMethodTable();
  417.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  418. };
  419.  
  420. }
  421. #include "reference.h"
  422. namespace Arts {
  423. class ARTS_EXPORT Synth_FREQUENCY : public Arts::Object {
  424. private:
  425.     static Arts::Object_base* _Creator();
  426.     Synth_FREQUENCY_base *_cache;
  427.     inline Synth_FREQUENCY_base *_method_call() {
  428.         _pool->checkcreate();
  429.         if(_pool->base) {
  430.             _cache=(Synth_FREQUENCY_base *)_pool->base->_cast(Synth_FREQUENCY_base::_IID);
  431.             assert(_cache);
  432.         }
  433.         return _cache;
  434.     }
  435.  
  436. protected:
  437.     inline Synth_FREQUENCY(Synth_FREQUENCY_base* b) : Arts::Object(b), _cache(0) {}
  438.  
  439.  
  440. public:
  441.     typedef Synth_FREQUENCY_base _base_class;
  442.  
  443.     inline Synth_FREQUENCY() : Arts::Object(_Creator), _cache(0) {}
  444.     inline Synth_FREQUENCY(const Arts::SubClass& s) :
  445.         Arts::Object(Synth_FREQUENCY_base::_create(s.string())), _cache(0) {}
  446.     inline Synth_FREQUENCY(const Arts::Reference &r) :
  447.         Arts::Object(r.isString()?(Synth_FREQUENCY_base::_fromString(r.string())):(Synth_FREQUENCY_base::_fromReference(r.reference(),true))), _cache(0) {}
  448.     inline Synth_FREQUENCY(const Arts::DynamicCast& c) : Arts::Object(Synth_FREQUENCY_base::_fromDynamicCast(c.object())), _cache(0) {}
  449.     inline Synth_FREQUENCY(const Synth_FREQUENCY& target) : Arts::Object(target._pool), _cache(target._cache) {}
  450.     inline Synth_FREQUENCY(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  451.     inline static Synth_FREQUENCY null() {return Synth_FREQUENCY((Synth_FREQUENCY_base*)0);}
  452.     inline static Synth_FREQUENCY _from_base(Synth_FREQUENCY_base* b) {return Synth_FREQUENCY(b);}
  453.     inline Synth_FREQUENCY& operator=(const Synth_FREQUENCY& target) {
  454.         if (_pool == target._pool) return *this;
  455.         _pool->Dec();
  456.         _pool = target._pool;
  457.         _cache = target._cache;
  458.         _pool->Inc();
  459.         return *this;
  460.     }
  461.     inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
  462.     inline Synth_FREQUENCY_base* _base() {return _cache?_cache:_method_call();}
  463.  
  464.     inline Arts::AutoSuspendState autoSuspend();
  465.     inline void start();
  466.     inline void stop();
  467.     inline void streamInit();
  468.     inline void streamStart();
  469.     inline void streamEnd();
  470. };
  471.  
  472. class ARTS_EXPORT Synth_WAVE_SIN_base : virtual public Arts::SynthModule_base {
  473. public:
  474.     static unsigned long _IID; // interface ID
  475.  
  476.     static Synth_WAVE_SIN_base *_create(const std::string& subClass = "Arts::Synth_WAVE_SIN");
  477.     static Synth_WAVE_SIN_base *_fromString(const std::string& objectref);
  478.     static Synth_WAVE_SIN_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  479.  
  480.     static Synth_WAVE_SIN_base *_fromDynamicCast(const Arts::Object& object);
  481.     inline Synth_WAVE_SIN_base *_copy() {
  482.         assert(_refCnt > 0);
  483.         _refCnt++;
  484.         return this;
  485.     }
  486.  
  487.     virtual std::vector<std::string> _defaultPortsIn() const;
  488.     virtual std::vector<std::string> _defaultPortsOut() const;
  489.  
  490.     void *_cast(unsigned long iid);
  491.  
  492. };
  493.  
  494. class ARTS_EXPORT Synth_WAVE_SIN_stub : virtual public Synth_WAVE_SIN_base, virtual public Arts::SynthModule_stub {
  495. protected:
  496.     Synth_WAVE_SIN_stub();
  497.  
  498. public:
  499.     Synth_WAVE_SIN_stub(Arts::Connection *connection, long objectID);
  500.  
  501. };
  502.  
  503. class ARTS_EXPORT Synth_WAVE_SIN_skel : virtual public Synth_WAVE_SIN_base, virtual public Arts::SynthModule_skel {
  504. protected:
  505.     // variables for streams
  506.     float *pos;                               // incoming stream
  507.     float *outvalue;                          // outgoing stream
  508.  
  509. public:
  510.     Synth_WAVE_SIN_skel();
  511.  
  512.     static std::string _interfaceNameSkel();
  513.     std::string _interfaceName();
  514.     bool _isCompatibleWith(const std::string& interfacename);
  515.     void _buildMethodTable();
  516.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  517. };
  518.  
  519. }
  520. #include "reference.h"
  521. namespace Arts {
  522. class ARTS_EXPORT Synth_WAVE_SIN : public Arts::Object {
  523. private:
  524.     static Arts::Object_base* _Creator();
  525.     Synth_WAVE_SIN_base *_cache;
  526.     inline Synth_WAVE_SIN_base *_method_call() {
  527.         _pool->checkcreate();
  528.         if(_pool->base) {
  529.             _cache=(Synth_WAVE_SIN_base *)_pool->base->_cast(Synth_WAVE_SIN_base::_IID);
  530.             assert(_cache);
  531.         }
  532.         return _cache;
  533.     }
  534.  
  535. protected:
  536.     inline Synth_WAVE_SIN(Synth_WAVE_SIN_base* b) : Arts::Object(b), _cache(0) {}
  537.  
  538.  
  539. public:
  540.     typedef Synth_WAVE_SIN_base _base_class;
  541.  
  542.     inline Synth_WAVE_SIN() : Arts::Object(_Creator), _cache(0) {}
  543.     inline Synth_WAVE_SIN(const Arts::SubClass& s) :
  544.         Arts::Object(Synth_WAVE_SIN_base::_create(s.string())), _cache(0) {}
  545.     inline Synth_WAVE_SIN(const Arts::Reference &r) :
  546.         Arts::Object(r.isString()?(Synth_WAVE_SIN_base::_fromString(r.string())):(Synth_WAVE_SIN_base::_fromReference(r.reference(),true))), _cache(0) {}
  547.     inline Synth_WAVE_SIN(const Arts::DynamicCast& c) : Arts::Object(Synth_WAVE_SIN_base::_fromDynamicCast(c.object())), _cache(0) {}
  548.     inline Synth_WAVE_SIN(const Synth_WAVE_SIN& target) : Arts::Object(target._pool), _cache(target._cache) {}
  549.     inline Synth_WAVE_SIN(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  550.     inline static Synth_WAVE_SIN null() {return Synth_WAVE_SIN((Synth_WAVE_SIN_base*)0);}
  551.     inline static Synth_WAVE_SIN _from_base(Synth_WAVE_SIN_base* b) {return Synth_WAVE_SIN(b);}
  552.     inline Synth_WAVE_SIN& operator=(const Synth_WAVE_SIN& target) {
  553.         if (_pool == target._pool) return *this;
  554.         _pool->Dec();
  555.         _pool = target._pool;
  556.         _cache = target._cache;
  557.         _pool->Inc();
  558.         return *this;
  559.     }
  560.     inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
  561.     inline Synth_WAVE_SIN_base* _base() {return _cache?_cache:_method_call();}
  562.  
  563.     inline Arts::AutoSuspendState autoSuspend();
  564.     inline void start();
  565.     inline void stop();
  566.     inline void streamInit();
  567.     inline void streamStart();
  568.     inline void streamEnd();
  569. };
  570.  
  571. class ARTS_EXPORT Synth_MULTI_ADD_base : virtual public Arts::SynthModule_base {
  572. public:
  573.     static unsigned long _IID; // interface ID
  574.  
  575.     static Synth_MULTI_ADD_base *_create(const std::string& subClass = "Arts::Synth_MULTI_ADD");
  576.     static Synth_MULTI_ADD_base *_fromString(const std::string& objectref);
  577.     static Synth_MULTI_ADD_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  578.  
  579.     static Synth_MULTI_ADD_base *_fromDynamicCast(const Arts::Object& object);
  580.     inline Synth_MULTI_ADD_base *_copy() {
  581.         assert(_refCnt > 0);
  582.         _refCnt++;
  583.         return this;
  584.     }
  585.  
  586.     virtual std::vector<std::string> _defaultPortsIn() const;
  587.     virtual std::vector<std::string> _defaultPortsOut() const;
  588.  
  589.     void *_cast(unsigned long iid);
  590.  
  591. };
  592.  
  593. class ARTS_EXPORT Synth_MULTI_ADD_stub : virtual public Synth_MULTI_ADD_base, virtual public Arts::SynthModule_stub {
  594. protected:
  595.     Synth_MULTI_ADD_stub();
  596.  
  597. public:
  598.     Synth_MULTI_ADD_stub(Arts::Connection *connection, long objectID);
  599.  
  600. };
  601.  
  602. class ARTS_EXPORT Synth_MULTI_ADD_skel : virtual public Synth_MULTI_ADD_base, virtual public Arts::SynthModule_skel {
  603. protected:
  604.     // variables for streams
  605.     float **invalue;                          // incoming stream
  606.     float *outvalue;                          // outgoing stream
  607.  
  608. public:
  609.     Synth_MULTI_ADD_skel();
  610.  
  611.     static std::string _interfaceNameSkel();
  612.     std::string _interfaceName();
  613.     bool _isCompatibleWith(const std::string& interfacename);
  614.     void _buildMethodTable();
  615.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  616. };
  617.  
  618. }
  619. #include "reference.h"
  620. namespace Arts {
  621. class ARTS_EXPORT Synth_MULTI_ADD : public Arts::Object {
  622. private:
  623.     static Arts::Object_base* _Creator();
  624.     Synth_MULTI_ADD_base *_cache;
  625.     inline Synth_MULTI_ADD_base *_method_call() {
  626.         _pool->checkcreate();
  627.         if(_pool->base) {
  628.             _cache=(Synth_MULTI_ADD_base *)_pool->base->_cast(Synth_MULTI_ADD_base::_IID);
  629.             assert(_cache);
  630.         }
  631.         return _cache;
  632.     }
  633.  
  634. protected:
  635.     inline Synth_MULTI_ADD(Synth_MULTI_ADD_base* b) : Arts::Object(b), _cache(0) {}
  636.  
  637.  
  638. public:
  639.     typedef Synth_MULTI_ADD_base _base_class;
  640.  
  641.     inline Synth_MULTI_ADD() : Arts::Object(_Creator), _cache(0) {}
  642.     inline Synth_MULTI_ADD(const Arts::SubClass& s) :
  643.         Arts::Object(Synth_MULTI_ADD_base::_create(s.string())), _cache(0) {}
  644.     inline Synth_MULTI_ADD(const Arts::Reference &r) :
  645.         Arts::Object(r.isString()?(Synth_MULTI_ADD_base::_fromString(r.string())):(Synth_MULTI_ADD_base::_fromReference(r.reference(),true))), _cache(0) {}
  646.     inline Synth_MULTI_ADD(const Arts::DynamicCast& c) : Arts::Object(Synth_MULTI_ADD_base::_fromDynamicCast(c.object())), _cache(0) {}
  647.     inline Synth_MULTI_ADD(const Synth_MULTI_ADD& target) : Arts::Object(target._pool), _cache(target._cache) {}
  648.     inline Synth_MULTI_ADD(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  649.     inline static Synth_MULTI_ADD null() {return Synth_MULTI_ADD((Synth_MULTI_ADD_base*)0);}
  650.     inline static Synth_MULTI_ADD _from_base(Synth_MULTI_ADD_base* b) {return Synth_MULTI_ADD(b);}
  651.     inline Synth_MULTI_ADD& operator=(const Synth_MULTI_ADD& target) {
  652.         if (_pool == target._pool) return *this;
  653.         _pool->Dec();
  654.         _pool = target._pool;
  655.         _cache = target._cache;
  656.         _pool->Inc();
  657.         return *this;
  658.     }
  659.     inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
  660.     inline Synth_MULTI_ADD_base* _base() {return _cache?_cache:_method_call();}
  661.  
  662.     inline Arts::AutoSuspendState autoSuspend();
  663.     inline void start();
  664.     inline void stop();
  665.     inline void streamInit();
  666.     inline void streamStart();
  667.     inline void streamEnd();
  668. };
  669.  
  670. class ARTS_EXPORT Synth_ADD_base : virtual public Arts::SynthModule_base {
  671. public:
  672.     static unsigned long _IID; // interface ID
  673.  
  674.     static Synth_ADD_base *_create(const std::string& subClass = "Arts::Synth_ADD");
  675.     static Synth_ADD_base *_fromString(const std::string& objectref);
  676.     static Synth_ADD_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  677.  
  678.     static Synth_ADD_base *_fromDynamicCast(const Arts::Object& object);
  679.     inline Synth_ADD_base *_copy() {
  680.         assert(_refCnt > 0);
  681.         _refCnt++;
  682.         return this;
  683.     }
  684.  
  685.     virtual std::vector<std::string> _defaultPortsIn() const;
  686.     virtual std::vector<std::string> _defaultPortsOut() const;
  687.  
  688.     void *_cast(unsigned long iid);
  689.  
  690. };
  691.  
  692. class ARTS_EXPORT Synth_ADD_stub : virtual public Synth_ADD_base, virtual public Arts::SynthModule_stub {
  693. protected:
  694.     Synth_ADD_stub();
  695.  
  696. public:
  697.     Synth_ADD_stub(Arts::Connection *connection, long objectID);
  698.  
  699. };
  700.  
  701. class ARTS_EXPORT Synth_ADD_skel : virtual public Synth_ADD_base, virtual public Arts::SynthModule_skel {
  702. protected:
  703.     // variables for streams
  704.     float *invalue1;                          // incoming stream
  705.     float *invalue2;                          // incoming stream
  706.     float *outvalue;                          // outgoing stream
  707.  
  708. public:
  709.     Synth_ADD_skel();
  710.  
  711.     static std::string _interfaceNameSkel();
  712.     std::string _interfaceName();
  713.     bool _isCompatibleWith(const std::string& interfacename);
  714.     void _buildMethodTable();
  715.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  716. };
  717.  
  718. }
  719. #include "reference.h"
  720. namespace Arts {
  721. class ARTS_EXPORT Synth_ADD : public Arts::Object {
  722. private:
  723.     static Arts::Object_base* _Creator();
  724.     Synth_ADD_base *_cache;
  725.     inline Synth_ADD_base *_method_call() {
  726.         _pool->checkcreate();
  727.         if(_pool->base) {
  728.             _cache=(Synth_ADD_base *)_pool->base->_cast(Synth_ADD_base::_IID);
  729.             assert(_cache);
  730.         }
  731.         return _cache;
  732.     }
  733.  
  734. protected:
  735.     inline Synth_ADD(Synth_ADD_base* b) : Arts::Object(b), _cache(0) {}
  736.  
  737.  
  738. public:
  739.     typedef Synth_ADD_base _base_class;
  740.  
  741.     inline Synth_ADD() : Arts::Object(_Creator), _cache(0) {}
  742.     inline Synth_ADD(const Arts::SubClass& s) :
  743.         Arts::Object(Synth_ADD_base::_create(s.string())), _cache(0) {}
  744.     inline Synth_ADD(const Arts::Reference &r) :
  745.         Arts::Object(r.isString()?(Synth_ADD_base::_fromString(r.string())):(Synth_ADD_base::_fromReference(r.reference(),true))), _cache(0) {}
  746.     inline Synth_ADD(const Arts::DynamicCast& c) : Arts::Object(Synth_ADD_base::_fromDynamicCast(c.object())), _cache(0) {}
  747.     inline Synth_ADD(const Synth_ADD& target) : Arts::Object(target._pool), _cache(target._cache) {}
  748.     inline Synth_ADD(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  749.     inline static Synth_ADD null() {return Synth_ADD((Synth_ADD_base*)0);}
  750.     inline static Synth_ADD _from_base(Synth_ADD_base* b) {return Synth_ADD(b);}
  751.     inline Synth_ADD& operator=(const Synth_ADD& target) {
  752.         if (_pool == target._pool) return *this;
  753.         _pool->Dec();
  754.         _pool = target._pool;
  755.         _cache = target._cache;
  756.         _pool->Inc();
  757.         return *this;
  758.     }
  759.     inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
  760.     inline Synth_ADD_base* _base() {return _cache?_cache:_method_call();}
  761.  
  762.     inline Arts::AutoSuspendState autoSuspend();
  763.     inline void start();
  764.     inline void stop();
  765.     inline void streamInit();
  766.     inline void streamStart();
  767.     inline void streamEnd();
  768. };
  769.  
  770. class ARTS_EXPORT Synth_MUL_base : virtual public Arts::SynthModule_base {
  771. public:
  772.     static unsigned long _IID; // interface ID
  773.  
  774.     static Synth_MUL_base *_create(const std::string& subClass = "Arts::Synth_MUL");
  775.     static Synth_MUL_base *_fromString(const std::string& objectref);
  776.     static Synth_MUL_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  777.  
  778.     static Synth_MUL_base *_fromDynamicCast(const Arts::Object& object);
  779.     inline Synth_MUL_base *_copy() {
  780.         assert(_refCnt > 0);
  781.         _refCnt++;
  782.         return this;
  783.     }
  784.  
  785.     virtual std::vector<std::string> _defaultPortsIn() const;
  786.     virtual std::vector<std::string> _defaultPortsOut() const;
  787.  
  788.     void *_cast(unsigned long iid);
  789.  
  790. };
  791.  
  792. class ARTS_EXPORT Synth_MUL_stub : virtual public Synth_MUL_base, virtual public Arts::SynthModule_stub {
  793. protected:
  794.     Synth_MUL_stub();
  795.  
  796. public:
  797.     Synth_MUL_stub(Arts::Connection *connection, long objectID);
  798.  
  799. };
  800.  
  801. class ARTS_EXPORT Synth_MUL_skel : virtual public Synth_MUL_base, virtual public Arts::SynthModule_skel {
  802. protected:
  803.     // variables for streams
  804.     float *invalue1;                          // incoming stream
  805.     float *invalue2;                          // incoming stream
  806.     float *outvalue;                          // outgoing stream
  807.  
  808. public:
  809.     Synth_MUL_skel();
  810.  
  811.     static std::string _interfaceNameSkel();
  812.     std::string _interfaceName();
  813.     bool _isCompatibleWith(const std::string& interfacename);
  814.     void _buildMethodTable();
  815.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  816. };
  817.  
  818. }
  819. #include "reference.h"
  820. namespace Arts {
  821. class ARTS_EXPORT Synth_MUL : public Arts::Object {
  822. private:
  823.     static Arts::Object_base* _Creator();
  824.     Synth_MUL_base *_cache;
  825.     inline Synth_MUL_base *_method_call() {
  826.         _pool->checkcreate();
  827.         if(_pool->base) {
  828.             _cache=(Synth_MUL_base *)_pool->base->_cast(Synth_MUL_base::_IID);
  829.             assert(_cache);
  830.         }
  831.         return _cache;
  832.     }
  833.  
  834. protected:
  835.     inline Synth_MUL(Synth_MUL_base* b) : Arts::Object(b), _cache(0) {}
  836.  
  837.  
  838. public:
  839.     typedef Synth_MUL_base _base_class;
  840.  
  841.     inline Synth_MUL() : Arts::Object(_Creator), _cache(0) {}
  842.     inline Synth_MUL(const Arts::SubClass& s) :
  843.         Arts::Object(Synth_MUL_base::_create(s.string())), _cache(0) {}
  844.     inline Synth_MUL(const Arts::Reference &r) :
  845.         Arts::Object(r.isString()?(Synth_MUL_base::_fromString(r.string())):(Synth_MUL_base::_fromReference(r.reference(),true))), _cache(0) {}
  846.     inline Synth_MUL(const Arts::DynamicCast& c) : Arts::Object(Synth_MUL_base::_fromDynamicCast(c.object())), _cache(0) {}
  847.     inline Synth_MUL(const Synth_MUL& target) : Arts::Object(target._pool), _cache(target._cache) {}
  848.     inline Synth_MUL(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  849.     inline static Synth_MUL null() {return Synth_MUL((Synth_MUL_base*)0);}
  850.     inline static Synth_MUL _from_base(Synth_MUL_base* b) {return Synth_MUL(b);}
  851.     inline Synth_MUL& operator=(const Synth_MUL& target) {
  852.         if (_pool == target._pool) return *this;
  853.         _pool->Dec();
  854.         _pool = target._pool;
  855.         _cache = target._cache;
  856.         _pool->Inc();
  857.         return *this;
  858.     }
  859.     inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
  860.     inline Synth_MUL_base* _base() {return _cache?_cache:_method_call();}
  861.  
  862.     inline Arts::AutoSuspendState autoSuspend();
  863.     inline void start();
  864.     inline void stop();
  865.     inline void streamInit();
  866.     inline void streamStart();
  867.     inline void streamEnd();
  868. };
  869.  
  870. class ARTS_EXPORT Synth_PLAY_WAV_base : virtual public Arts::SynthModule_base {
  871. public:
  872.     static unsigned long _IID; // interface ID
  873.  
  874.     static Synth_PLAY_WAV_base *_create(const std::string& subClass = "Arts::Synth_PLAY_WAV");
  875.     static Synth_PLAY_WAV_base *_fromString(const std::string& objectref);
  876.     static Synth_PLAY_WAV_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  877.  
  878.     static Synth_PLAY_WAV_base *_fromDynamicCast(const Arts::Object& object);
  879.     inline Synth_PLAY_WAV_base *_copy() {
  880.         assert(_refCnt > 0);
  881.         _refCnt++;
  882.         return this;
  883.     }
  884.  
  885.     virtual std::vector<std::string> _defaultPortsIn() const;
  886.     virtual std::vector<std::string> _defaultPortsOut() const;
  887.  
  888.     void *_cast(unsigned long iid);
  889.  
  890.     virtual float speed() = 0;
  891.     virtual void speed(float newValue) = 0;
  892.     virtual std::string filename() = 0;
  893.     virtual void filename(const std::string& newValue) = 0;
  894.     virtual bool finished() = 0;
  895. };
  896.  
  897. class ARTS_EXPORT Synth_PLAY_WAV_stub : virtual public Synth_PLAY_WAV_base, virtual public Arts::SynthModule_stub {
  898. protected:
  899.     Synth_PLAY_WAV_stub();
  900.  
  901. public:
  902.     Synth_PLAY_WAV_stub(Arts::Connection *connection, long objectID);
  903.  
  904.     float speed();
  905.     void speed(float newValue);
  906.     std::string filename();
  907.     void filename(const std::string& newValue);
  908.     bool finished();
  909. };
  910.  
  911. class ARTS_EXPORT Synth_PLAY_WAV_skel : virtual public Synth_PLAY_WAV_base, virtual public Arts::SynthModule_skel {
  912. protected:
  913.     // variables for streams
  914.     float *left;                              // outgoing stream
  915.     float *right;                             // outgoing stream
  916.  
  917. protected:
  918.     // emitters for change notifications
  919.     inline void speed_changed(float newValue) {
  920.         _emit_changed("speed_changed",newValue);
  921.     }
  922.     inline void filename_changed(const std::string& newValue) {
  923.         _emit_changed("filename_changed",newValue);
  924.     }
  925.     inline void finished_changed(bool newValue) {
  926.         _emit_changed("finished_changed",newValue);
  927.     }
  928.  
  929. public:
  930.     Synth_PLAY_WAV_skel();
  931.  
  932.     static std::string _interfaceNameSkel();
  933.     std::string _interfaceName();
  934.     bool _isCompatibleWith(const std::string& interfacename);
  935.     void _buildMethodTable();
  936.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  937. };
  938.  
  939. }
  940. #include "reference.h"
  941. namespace Arts {
  942. class ARTS_EXPORT Synth_PLAY_WAV : public Arts::Object {
  943. private:
  944.     static Arts::Object_base* _Creator();
  945.     Synth_PLAY_WAV_base *_cache;
  946.     inline Synth_PLAY_WAV_base *_method_call() {
  947.         _pool->checkcreate();
  948.         if(_pool->base) {
  949.             _cache=(Synth_PLAY_WAV_base *)_pool->base->_cast(Synth_PLAY_WAV_base::_IID);
  950.             assert(_cache);
  951.         }
  952.         return _cache;
  953.     }
  954.  
  955. protected:
  956.     inline Synth_PLAY_WAV(Synth_PLAY_WAV_base* b) : Arts::Object(b), _cache(0) {}
  957.  
  958.  
  959. public:
  960.     typedef Synth_PLAY_WAV_base _base_class;
  961.  
  962.     inline Synth_PLAY_WAV() : Arts::Object(_Creator), _cache(0) {}
  963.     inline Synth_PLAY_WAV(const Arts::SubClass& s) :
  964.         Arts::Object(Synth_PLAY_WAV_base::_create(s.string())), _cache(0) {}
  965.     inline Synth_PLAY_WAV(const Arts::Reference &r) :
  966.         Arts::Object(r.isString()?(Synth_PLAY_WAV_base::_fromString(r.string())):(Synth_PLAY_WAV_base::_fromReference(r.reference(),true))), _cache(0) {}
  967.     inline Synth_PLAY_WAV(const Arts::DynamicCast& c) : Arts::Object(Synth_PLAY_WAV_base::_fromDynamicCast(c.object())), _cache(0) {}
  968.     inline Synth_PLAY_WAV(const Synth_PLAY_WAV& target) : Arts::Object(target._pool), _cache(target._cache) {}
  969.     inline Synth_PLAY_WAV(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  970.     inline static Synth_PLAY_WAV null() {return Synth_PLAY_WAV((Synth_PLAY_WAV_base*)0);}
  971.     inline static Synth_PLAY_WAV _from_base(Synth_PLAY_WAV_base* b) {return Synth_PLAY_WAV(b);}
  972.     inline Synth_PLAY_WAV& operator=(const Synth_PLAY_WAV& target) {
  973.         if (_pool == target._pool) return *this;
  974.         _pool->Dec();
  975.         _pool = target._pool;
  976.         _cache = target._cache;
  977.         _pool->Inc();
  978.         return *this;
  979.     }
  980.     inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
  981.     inline Synth_PLAY_WAV_base* _base() {return _cache?_cache:_method_call();}
  982.  
  983.     inline Arts::AutoSuspendState autoSuspend();
  984.     inline void start();
  985.     inline void stop();
  986.     inline void streamInit();
  987.     inline void streamStart();
  988.     inline void streamEnd();
  989.     inline float speed();
  990.     inline void speed(float _newValue);
  991.     inline std::string filename();
  992.     inline void filename(const std::string& _newValue);
  993.     inline bool finished();
  994. };
  995.  
  996. class ARTS_EXPORT Synth_BUS_UPLINK_base : virtual public Arts::SynthModule_base {
  997. public:
  998.     static unsigned long _IID; // interface ID
  999.  
  1000.     static Synth_BUS_UPLINK_base *_create(const std::string& subClass = "Arts::Synth_BUS_UPLINK");
  1001.     static Synth_BUS_UPLINK_base *_fromString(const std::string& objectref);
  1002.     static Synth_BUS_UPLINK_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  1003.  
  1004.     static Synth_BUS_UPLINK_base *_fromDynamicCast(const Arts::Object& object);
  1005.     inline Synth_BUS_UPLINK_base *_copy() {
  1006.         assert(_refCnt > 0);
  1007.         _refCnt++;
  1008.         return this;
  1009.     }
  1010.  
  1011.     virtual std::vector<std::string> _defaultPortsIn() const;
  1012.     virtual std::vector<std::string> _defaultPortsOut() const;
  1013.  
  1014.     void *_cast(unsigned long iid);
  1015.  
  1016.     virtual std::string busname() = 0;
  1017.     virtual void busname(const std::string& newValue) = 0;
  1018. };
  1019.  
  1020. class ARTS_EXPORT Synth_BUS_UPLINK_stub : virtual public Synth_BUS_UPLINK_base, virtual public Arts::SynthModule_stub {
  1021. protected:
  1022.     Synth_BUS_UPLINK_stub();
  1023.  
  1024. public:
  1025.     Synth_BUS_UPLINK_stub(Arts::Connection *connection, long objectID);
  1026.  
  1027.     std::string busname();
  1028.     void busname(const std::string& newValue);
  1029. };
  1030.  
  1031. class ARTS_EXPORT Synth_BUS_UPLINK_skel : virtual public Synth_BUS_UPLINK_base, virtual public Arts::SynthModule_skel {
  1032. protected:
  1033.     // variables for streams
  1034.     float *left;                              // incoming stream
  1035.     float *right;                             // incoming stream
  1036.  
  1037. protected:
  1038.     // emitters for change notifications
  1039.     inline void busname_changed(const std::string& newValue) {
  1040.         _emit_changed("busname_changed",newValue);
  1041.     }
  1042.  
  1043. public:
  1044.     Synth_BUS_UPLINK_skel();
  1045.  
  1046.     static std::string _interfaceNameSkel();
  1047.     std::string _interfaceName();
  1048.     bool _isCompatibleWith(const std::string& interfacename);
  1049.     void _buildMethodTable();
  1050.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  1051. };
  1052.  
  1053. }
  1054. #include "reference.h"
  1055. namespace Arts {
  1056. class ARTS_EXPORT Synth_BUS_UPLINK : public Arts::Object {
  1057. private:
  1058.     static Arts::Object_base* _Creator();
  1059.     Synth_BUS_UPLINK_base *_cache;
  1060.     inline Synth_BUS_UPLINK_base *_method_call() {
  1061.         _pool->checkcreate();
  1062.         if(_pool->base) {
  1063.             _cache=(Synth_BUS_UPLINK_base *)_pool->base->_cast(Synth_BUS_UPLINK_base::_IID);
  1064.             assert(_cache);
  1065.         }
  1066.         return _cache;
  1067.     }
  1068.  
  1069. protected:
  1070.     inline Synth_BUS_UPLINK(Synth_BUS_UPLINK_base* b) : Arts::Object(b), _cache(0) {}
  1071.  
  1072.  
  1073. public:
  1074.     typedef Synth_BUS_UPLINK_base _base_class;
  1075.  
  1076.     inline Synth_BUS_UPLINK() : Arts::Object(_Creator), _cache(0) {}
  1077.     inline Synth_BUS_UPLINK(const Arts::SubClass& s) :
  1078.         Arts::Object(Synth_BUS_UPLINK_base::_create(s.string())), _cache(0) {}
  1079.     inline Synth_BUS_UPLINK(const Arts::Reference &r) :
  1080.         Arts::Object(r.isString()?(Synth_BUS_UPLINK_base::_fromString(r.string())):(Synth_BUS_UPLINK_base::_fromReference(r.reference(),true))), _cache(0) {}
  1081.     inline Synth_BUS_UPLINK(const Arts::DynamicCast& c) : Arts::Object(Synth_BUS_UPLINK_base::_fromDynamicCast(c.object())), _cache(0) {}
  1082.     inline Synth_BUS_UPLINK(const Synth_BUS_UPLINK& target) : Arts::Object(target._pool), _cache(target._cache) {}
  1083.     inline Synth_BUS_UPLINK(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  1084.     inline static Synth_BUS_UPLINK null() {return Synth_BUS_UPLINK((Synth_BUS_UPLINK_base*)0);}
  1085.     inline static Synth_BUS_UPLINK _from_base(Synth_BUS_UPLINK_base* b) {return Synth_BUS_UPLINK(b);}
  1086.     inline Synth_BUS_UPLINK& operator=(const Synth_BUS_UPLINK& target) {
  1087.         if (_pool == target._pool) return *this;
  1088.         _pool->Dec();
  1089.         _pool = target._pool;
  1090.         _cache = target._cache;
  1091.         _pool->Inc();
  1092.         return *this;
  1093.     }
  1094.     inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
  1095.     inline Synth_BUS_UPLINK_base* _base() {return _cache?_cache:_method_call();}
  1096.  
  1097.     inline Arts::AutoSuspendState autoSuspend();
  1098.     inline void start();
  1099.     inline void stop();
  1100.     inline void streamInit();
  1101.     inline void streamStart();
  1102.     inline void streamEnd();
  1103.     inline std::string busname();
  1104.     inline void busname(const std::string& _newValue);
  1105. };
  1106.  
  1107. class ARTS_EXPORT Synth_BUS_DOWNLINK_base : virtual public Arts::SynthModule_base {
  1108. public:
  1109.     static unsigned long _IID; // interface ID
  1110.  
  1111.     static Synth_BUS_DOWNLINK_base *_create(const std::string& subClass = "Arts::Synth_BUS_DOWNLINK");
  1112.     static Synth_BUS_DOWNLINK_base *_fromString(const std::string& objectref);
  1113.     static Synth_BUS_DOWNLINK_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  1114.  
  1115.     static Synth_BUS_DOWNLINK_base *_fromDynamicCast(const Arts::Object& object);
  1116.     inline Synth_BUS_DOWNLINK_base *_copy() {
  1117.         assert(_refCnt > 0);
  1118.         _refCnt++;
  1119.         return this;
  1120.     }
  1121.  
  1122.     virtual std::vector<std::string> _defaultPortsIn() const;
  1123.     virtual std::vector<std::string> _defaultPortsOut() const;
  1124.  
  1125.     void *_cast(unsigned long iid);
  1126.  
  1127.     virtual std::string busname() = 0;
  1128.     virtual void busname(const std::string& newValue) = 0;
  1129. };
  1130.  
  1131. class ARTS_EXPORT Synth_BUS_DOWNLINK_stub : virtual public Synth_BUS_DOWNLINK_base, virtual public Arts::SynthModule_stub {
  1132. protected:
  1133.     Synth_BUS_DOWNLINK_stub();
  1134.  
  1135. public:
  1136.     Synth_BUS_DOWNLINK_stub(Arts::Connection *connection, long objectID);
  1137.  
  1138.     std::string busname();
  1139.     void busname(const std::string& newValue);
  1140. };
  1141.  
  1142. class ARTS_EXPORT Synth_BUS_DOWNLINK_skel : virtual public Synth_BUS_DOWNLINK_base, virtual public Arts::SynthModule_skel {
  1143. protected:
  1144.     // variables for streams
  1145.     float *left;                              // outgoing stream
  1146.     float *right;                             // outgoing stream
  1147.  
  1148. protected:
  1149.     // emitters for change notifications
  1150.     inline void busname_changed(const std::string& newValue) {
  1151.         _emit_changed("busname_changed",newValue);
  1152.     }
  1153.  
  1154. public:
  1155.     Synth_BUS_DOWNLINK_skel();
  1156.  
  1157.     static std::string _interfaceNameSkel();
  1158.     std::string _interfaceName();
  1159.     bool _isCompatibleWith(const std::string& interfacename);
  1160.     void _buildMethodTable();
  1161.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  1162. };
  1163.  
  1164. }
  1165. #include "reference.h"
  1166. namespace Arts {
  1167. class ARTS_EXPORT Synth_BUS_DOWNLINK : public Arts::Object {
  1168. private:
  1169.     static Arts::Object_base* _Creator();
  1170.     Synth_BUS_DOWNLINK_base *_cache;
  1171.     inline Synth_BUS_DOWNLINK_base *_method_call() {
  1172.         _pool->checkcreate();
  1173.         if(_pool->base) {
  1174.             _cache=(Synth_BUS_DOWNLINK_base *)_pool->base->_cast(Synth_BUS_DOWNLINK_base::_IID);
  1175.             assert(_cache);
  1176.         }
  1177.         return _cache;
  1178.     }
  1179.  
  1180. protected:
  1181.     inline Synth_BUS_DOWNLINK(Synth_BUS_DOWNLINK_base* b) : Arts::Object(b), _cache(0) {}
  1182.  
  1183.  
  1184. public:
  1185.     typedef Synth_BUS_DOWNLINK_base _base_class;
  1186.  
  1187.     inline Synth_BUS_DOWNLINK() : Arts::Object(_Creator), _cache(0) {}
  1188.     inline Synth_BUS_DOWNLINK(const Arts::SubClass& s) :
  1189.         Arts::Object(Synth_BUS_DOWNLINK_base::_create(s.string())), _cache(0) {}
  1190.     inline Synth_BUS_DOWNLINK(const Arts::Reference &r) :
  1191.         Arts::Object(r.isString()?(Synth_BUS_DOWNLINK_base::_fromString(r.string())):(Synth_BUS_DOWNLINK_base::_fromReference(r.reference(),true))), _cache(0) {}
  1192.     inline Synth_BUS_DOWNLINK(const Arts::DynamicCast& c) : Arts::Object(Synth_BUS_DOWNLINK_base::_fromDynamicCast(c.object())), _cache(0) {}
  1193.     inline Synth_BUS_DOWNLINK(const Synth_BUS_DOWNLINK& target) : Arts::Object(target._pool), _cache(target._cache) {}
  1194.     inline Synth_BUS_DOWNLINK(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  1195.     inline static Synth_BUS_DOWNLINK null() {return Synth_BUS_DOWNLINK((Synth_BUS_DOWNLINK_base*)0);}
  1196.     inline static Synth_BUS_DOWNLINK _from_base(Synth_BUS_DOWNLINK_base* b) {return Synth_BUS_DOWNLINK(b);}
  1197.     inline Synth_BUS_DOWNLINK& operator=(const Synth_BUS_DOWNLINK& target) {
  1198.         if (_pool == target._pool) return *this;
  1199.         _pool->Dec();
  1200.         _pool = target._pool;
  1201.         _cache = target._cache;
  1202.         _pool->Inc();
  1203.         return *this;
  1204.     }
  1205.     inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
  1206.     inline Synth_BUS_DOWNLINK_base* _base() {return _cache?_cache:_method_call();}
  1207.  
  1208.     inline Arts::AutoSuspendState autoSuspend();
  1209.     inline void start();
  1210.     inline void stop();
  1211.     inline void streamInit();
  1212.     inline void streamStart();
  1213.     inline void streamEnd();
  1214.     inline std::string busname();
  1215.     inline void busname(const std::string& _newValue);
  1216. };
  1217.  
  1218. class ARTS_EXPORT ByteStreamToAudio_base : virtual public Arts::SynthModule_base {
  1219. public:
  1220.     static unsigned long _IID; // interface ID
  1221.  
  1222.     static ByteStreamToAudio_base *_create(const std::string& subClass = "Arts::ByteStreamToAudio");
  1223.     static ByteStreamToAudio_base *_fromString(const std::string& objectref);
  1224.     static ByteStreamToAudio_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  1225.  
  1226.     static ByteStreamToAudio_base *_fromDynamicCast(const Arts::Object& object);
  1227.     inline ByteStreamToAudio_base *_copy() {
  1228.         assert(_refCnt > 0);
  1229.         _refCnt++;
  1230.         return this;
  1231.     }
  1232.  
  1233.     virtual std::vector<std::string> _defaultPortsIn() const;
  1234.     virtual std::vector<std::string> _defaultPortsOut() const;
  1235.  
  1236.     void *_cast(unsigned long iid);
  1237.  
  1238.     virtual long samplingRate() = 0;
  1239.     virtual void samplingRate(long newValue) = 0;
  1240.     virtual long channels() = 0;
  1241.     virtual void channels(long newValue) = 0;
  1242.     virtual long bits() = 0;
  1243.     virtual void bits(long newValue) = 0;
  1244.     virtual bool running() = 0;
  1245. };
  1246.  
  1247. class ARTS_EXPORT ByteStreamToAudio_stub : virtual public ByteStreamToAudio_base, virtual public Arts::SynthModule_stub {
  1248. protected:
  1249.     ByteStreamToAudio_stub();
  1250.  
  1251. public:
  1252.     ByteStreamToAudio_stub(Arts::Connection *connection, long objectID);
  1253.  
  1254.     long samplingRate();
  1255.     void samplingRate(long newValue);
  1256.     long channels();
  1257.     void channels(long newValue);
  1258.     long bits();
  1259.     void bits(long newValue);
  1260.     bool running();
  1261. };
  1262.  
  1263. class ARTS_EXPORT ByteStreamToAudio_skel : virtual public ByteStreamToAudio_base, virtual public Arts::SynthModule_skel {
  1264. protected:
  1265.     // variables for streams
  1266.     Arts::ByteAsyncStream indata;             // incoming stream
  1267.     float *left;                              // outgoing stream
  1268.     float *right;                             // outgoing stream
  1269.  
  1270.     // handler for asynchronous streams
  1271.     virtual void process_indata(Arts::DataPacket<Arts::mcopbyte> *) = 0;
  1272.  
  1273. protected:
  1274.     // emitters for change notifications
  1275.     inline void samplingRate_changed(long newValue) {
  1276.         _emit_changed("samplingRate_changed",newValue);
  1277.     }
  1278.     inline void channels_changed(long newValue) {
  1279.         _emit_changed("channels_changed",newValue);
  1280.     }
  1281.     inline void bits_changed(long newValue) {
  1282.         _emit_changed("bits_changed",newValue);
  1283.     }
  1284.     inline void running_changed(bool newValue) {
  1285.         _emit_changed("running_changed",newValue);
  1286.     }
  1287.  
  1288. public:
  1289.     ByteStreamToAudio_skel();
  1290.  
  1291.     static std::string _interfaceNameSkel();
  1292.     std::string _interfaceName();
  1293.     bool _isCompatibleWith(const std::string& interfacename);
  1294.     void _buildMethodTable();
  1295.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  1296.     void notify(const Arts::Notification& notification);
  1297. };
  1298.  
  1299. }
  1300. #include "reference.h"
  1301. namespace Arts {
  1302. class ARTS_EXPORT ByteStreamToAudio : public Arts::Object {
  1303. private:
  1304.     static Arts::Object_base* _Creator();
  1305.     ByteStreamToAudio_base *_cache;
  1306.     inline ByteStreamToAudio_base *_method_call() {
  1307.         _pool->checkcreate();
  1308.         if(_pool->base) {
  1309.             _cache=(ByteStreamToAudio_base *)_pool->base->_cast(ByteStreamToAudio_base::_IID);
  1310.             assert(_cache);
  1311.         }
  1312.         return _cache;
  1313.     }
  1314.  
  1315. protected:
  1316.     inline ByteStreamToAudio(ByteStreamToAudio_base* b) : Arts::Object(b), _cache(0) {}
  1317.  
  1318.  
  1319. public:
  1320.     typedef ByteStreamToAudio_base _base_class;
  1321.  
  1322.     inline ByteStreamToAudio() : Arts::Object(_Creator), _cache(0) {}
  1323.     inline ByteStreamToAudio(const Arts::SubClass& s) :
  1324.         Arts::Object(ByteStreamToAudio_base::_create(s.string())), _cache(0) {}
  1325.     inline ByteStreamToAudio(const Arts::Reference &r) :
  1326.         Arts::Object(r.isString()?(ByteStreamToAudio_base::_fromString(r.string())):(ByteStreamToAudio_base::_fromReference(r.reference(),true))), _cache(0) {}
  1327.     inline ByteStreamToAudio(const Arts::DynamicCast& c) : Arts::Object(ByteStreamToAudio_base::_fromDynamicCast(c.object())), _cache(0) {}
  1328.     inline ByteStreamToAudio(const ByteStreamToAudio& target) : Arts::Object(target._pool), _cache(target._cache) {}
  1329.     inline ByteStreamToAudio(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  1330.     inline static ByteStreamToAudio null() {return ByteStreamToAudio((ByteStreamToAudio_base*)0);}
  1331.     inline static ByteStreamToAudio _from_base(ByteStreamToAudio_base* b) {return ByteStreamToAudio(b);}
  1332.     inline ByteStreamToAudio& operator=(const ByteStreamToAudio& target) {
  1333.         if (_pool == target._pool) return *this;
  1334.         _pool->Dec();
  1335.         _pool = target._pool;
  1336.         _cache = target._cache;
  1337.         _pool->Inc();
  1338.         return *this;
  1339.     }
  1340.     inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
  1341.     inline ByteStreamToAudio_base* _base() {return _cache?_cache:_method_call();}
  1342.  
  1343.     inline Arts::AutoSuspendState autoSuspend();
  1344.     inline void start();
  1345.     inline void stop();
  1346.     inline void streamInit();
  1347.     inline void streamStart();
  1348.     inline void streamEnd();
  1349.     inline long samplingRate();
  1350.     inline void samplingRate(long _newValue);
  1351.     inline long channels();
  1352.     inline void channels(long _newValue);
  1353.     inline long bits();
  1354.     inline void bits(long _newValue);
  1355.     inline bool running();
  1356. };
  1357.  
  1358. class ARTS_EXPORT AudioToByteStream_base : virtual public Arts::SynthModule_base {
  1359. public:
  1360.     static unsigned long _IID; // interface ID
  1361.  
  1362.     static AudioToByteStream_base *_create(const std::string& subClass = "Arts::AudioToByteStream");
  1363.     static AudioToByteStream_base *_fromString(const std::string& objectref);
  1364.     static AudioToByteStream_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  1365.  
  1366.     static AudioToByteStream_base *_fromDynamicCast(const Arts::Object& object);
  1367.     inline AudioToByteStream_base *_copy() {
  1368.         assert(_refCnt > 0);
  1369.         _refCnt++;
  1370.         return this;
  1371.     }
  1372.  
  1373.     virtual std::vector<std::string> _defaultPortsIn() const;
  1374.     virtual std::vector<std::string> _defaultPortsOut() const;
  1375.  
  1376.     void *_cast(unsigned long iid);
  1377.  
  1378.     virtual long samplingRate() = 0;
  1379.     virtual void samplingRate(long newValue) = 0;
  1380.     virtual long channels() = 0;
  1381.     virtual void channels(long newValue) = 0;
  1382.     virtual long bits() = 0;
  1383.     virtual void bits(long newValue) = 0;
  1384. };
  1385.  
  1386. class ARTS_EXPORT AudioToByteStream_stub : virtual public AudioToByteStream_base, virtual public Arts::SynthModule_stub {
  1387. protected:
  1388.     AudioToByteStream_stub();
  1389.  
  1390. public:
  1391.     AudioToByteStream_stub(Arts::Connection *connection, long objectID);
  1392.  
  1393.     long samplingRate();
  1394.     void samplingRate(long newValue);
  1395.     long channels();
  1396.     void channels(long newValue);
  1397.     long bits();
  1398.     void bits(long newValue);
  1399. };
  1400.  
  1401. class ARTS_EXPORT AudioToByteStream_skel : virtual public AudioToByteStream_base, virtual public Arts::SynthModule_skel {
  1402. protected:
  1403.     // variables for streams
  1404.     Arts::ByteAsyncStream outdata;            // outgoing stream
  1405.     float *left;                              // incoming stream
  1406.     float *right;                             // incoming stream
  1407.  
  1408.     // handler for asynchronous streams
  1409.     virtual void request_outdata(Arts::DataPacket<Arts::mcopbyte> *);
  1410.  
  1411. protected:
  1412.     // emitters for change notifications
  1413.     inline void samplingRate_changed(long newValue) {
  1414.         _emit_changed("samplingRate_changed",newValue);
  1415.     }
  1416.     inline void channels_changed(long newValue) {
  1417.         _emit_changed("channels_changed",newValue);
  1418.     }
  1419.     inline void bits_changed(long newValue) {
  1420.         _emit_changed("bits_changed",newValue);
  1421.     }
  1422.  
  1423. public:
  1424.     AudioToByteStream_skel();
  1425.  
  1426.     static std::string _interfaceNameSkel();
  1427.     std::string _interfaceName();
  1428.     bool _isCompatibleWith(const std::string& interfacename);
  1429.     void _buildMethodTable();
  1430.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  1431.     void notify(const Arts::Notification& notification);
  1432. };
  1433.  
  1434. }
  1435. #include "reference.h"
  1436. namespace Arts {
  1437. class ARTS_EXPORT AudioToByteStream : public Arts::Object {
  1438. private:
  1439.     static Arts::Object_base* _Creator();
  1440.     AudioToByteStream_base *_cache;
  1441.     inline AudioToByteStream_base *_method_call() {
  1442.         _pool->checkcreate();
  1443.         if(_pool->base) {
  1444.             _cache=(AudioToByteStream_base *)_pool->base->_cast(AudioToByteStream_base::_IID);
  1445.             assert(_cache);
  1446.         }
  1447.         return _cache;
  1448.     }
  1449.  
  1450. protected:
  1451.     inline AudioToByteStream(AudioToByteStream_base* b) : Arts::Object(b), _cache(0) {}
  1452.  
  1453.  
  1454. public:
  1455.     typedef AudioToByteStream_base _base_class;
  1456.  
  1457.     inline AudioToByteStream() : Arts::Object(_Creator), _cache(0) {}
  1458.     inline AudioToByteStream(const Arts::SubClass& s) :
  1459.         Arts::Object(AudioToByteStream_base::_create(s.string())), _cache(0) {}
  1460.     inline AudioToByteStream(const Arts::Reference &r) :
  1461.         Arts::Object(r.isString()?(AudioToByteStream_base::_fromString(r.string())):(AudioToByteStream_base::_fromReference(r.reference(),true))), _cache(0) {}
  1462.     inline AudioToByteStream(const Arts::DynamicCast& c) : Arts::Object(AudioToByteStream_base::_fromDynamicCast(c.object())), _cache(0) {}
  1463.     inline AudioToByteStream(const AudioToByteStream& target) : Arts::Object(target._pool), _cache(target._cache) {}
  1464.     inline AudioToByteStream(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  1465.     inline static AudioToByteStream null() {return AudioToByteStream((AudioToByteStream_base*)0);}
  1466.     inline static AudioToByteStream _from_base(AudioToByteStream_base* b) {return AudioToByteStream(b);}
  1467.     inline AudioToByteStream& operator=(const AudioToByteStream& target) {
  1468.         if (_pool == target._pool) return *this;
  1469.         _pool->Dec();
  1470.         _pool = target._pool;
  1471.         _cache = target._cache;
  1472.         _pool->Inc();
  1473.         return *this;
  1474.     }
  1475.     inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
  1476.     inline AudioToByteStream_base* _base() {return _cache?_cache:_method_call();}
  1477.  
  1478.     inline Arts::AutoSuspendState autoSuspend();
  1479.     inline void start();
  1480.     inline void stop();
  1481.     inline void streamInit();
  1482.     inline void streamStart();
  1483.     inline void streamEnd();
  1484.     inline long samplingRate();
  1485.     inline void samplingRate(long _newValue);
  1486.     inline long channels();
  1487.     inline void channels(long _newValue);
  1488.     inline long bits();
  1489.     inline void bits(long _newValue);
  1490. };
  1491.  
  1492. class ARTS_EXPORT StereoEffect_base : virtual public Arts::SynthModule_base {
  1493. public:
  1494.     static unsigned long _IID; // interface ID
  1495.  
  1496.     static StereoEffect_base *_create(const std::string& subClass = "Arts::StereoEffect");
  1497.     static StereoEffect_base *_fromString(const std::string& objectref);
  1498.     static StereoEffect_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  1499.  
  1500.     static StereoEffect_base *_fromDynamicCast(const Arts::Object& object);
  1501.     inline StereoEffect_base *_copy() {
  1502.         assert(_refCnt > 0);
  1503.         _refCnt++;
  1504.         return this;
  1505.     }
  1506.  
  1507.     virtual std::vector<std::string> _defaultPortsIn() const;
  1508.     virtual std::vector<std::string> _defaultPortsOut() const;
  1509.  
  1510.     void *_cast(unsigned long iid);
  1511.  
  1512. };
  1513.  
  1514. class ARTS_EXPORT StereoEffect_stub : virtual public StereoEffect_base, virtual public Arts::SynthModule_stub {
  1515. protected:
  1516.     StereoEffect_stub();
  1517.  
  1518. public:
  1519.     StereoEffect_stub(Arts::Connection *connection, long objectID);
  1520.  
  1521. };
  1522.  
  1523. class ARTS_EXPORT StereoEffect_skel : virtual public StereoEffect_base, virtual public Arts::SynthModule_skel {
  1524. protected:
  1525.     // variables for streams
  1526.     float *inleft;                            // incoming stream
  1527.     float *inright;                           // incoming stream
  1528.     float *outleft;                           // outgoing stream
  1529.     float *outright;                          // outgoing stream
  1530.  
  1531. public:
  1532.     StereoEffect_skel();
  1533.  
  1534.     static std::string _interfaceNameSkel();
  1535.     std::string _interfaceName();
  1536.     bool _isCompatibleWith(const std::string& interfacename);
  1537.     void _buildMethodTable();
  1538.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  1539. };
  1540.  
  1541. }
  1542. #include "reference.h"
  1543. namespace Arts {
  1544. class ARTS_EXPORT StereoEffect : public Arts::Object {
  1545. private:
  1546.     static Arts::Object_base* _Creator();
  1547.     StereoEffect_base *_cache;
  1548.     inline StereoEffect_base *_method_call() {
  1549.         _pool->checkcreate();
  1550.         if(_pool->base) {
  1551.             _cache=(StereoEffect_base *)_pool->base->_cast(StereoEffect_base::_IID);
  1552.             assert(_cache);
  1553.         }
  1554.         return _cache;
  1555.     }
  1556.  
  1557. protected:
  1558.     inline StereoEffect(StereoEffect_base* b) : Arts::Object(b), _cache(0) {}
  1559.  
  1560.  
  1561. public:
  1562.     typedef StereoEffect_base _base_class;
  1563.  
  1564.     inline StereoEffect() : Arts::Object(_Creator), _cache(0) {}
  1565.     inline StereoEffect(const Arts::SubClass& s) :
  1566.         Arts::Object(StereoEffect_base::_create(s.string())), _cache(0) {}
  1567.     inline StereoEffect(const Arts::Reference &r) :
  1568.         Arts::Object(r.isString()?(StereoEffect_base::_fromString(r.string())):(StereoEffect_base::_fromReference(r.reference(),true))), _cache(0) {}
  1569.     inline StereoEffect(const Arts::DynamicCast& c) : Arts::Object(StereoEffect_base::_fromDynamicCast(c.object())), _cache(0) {}
  1570.     inline StereoEffect(const StereoEffect& target) : Arts::Object(target._pool), _cache(target._cache) {}
  1571.     inline StereoEffect(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  1572.     inline static StereoEffect null() {return StereoEffect((StereoEffect_base*)0);}
  1573.     inline static StereoEffect _from_base(StereoEffect_base* b) {return StereoEffect(b);}
  1574.     inline StereoEffect& operator=(const StereoEffect& target) {
  1575.         if (_pool == target._pool) return *this;
  1576.         _pool->Dec();
  1577.         _pool = target._pool;
  1578.         _cache = target._cache;
  1579.         _pool->Inc();
  1580.         return *this;
  1581.     }
  1582.     inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
  1583.     inline StereoEffect_base* _base() {return _cache?_cache:_method_call();}
  1584.  
  1585.     inline Arts::AutoSuspendState autoSuspend();
  1586.     inline void start();
  1587.     inline void stop();
  1588.     inline void streamInit();
  1589.     inline void streamStart();
  1590.     inline void streamEnd();
  1591. };
  1592.  
  1593. class ARTS_EXPORT StereoVolumeControl_base : virtual public Arts::StereoEffect_base {
  1594. public:
  1595.     static unsigned long _IID; // interface ID
  1596.  
  1597.     static StereoVolumeControl_base *_create(const std::string& subClass = "Arts::StereoVolumeControl");
  1598.     static StereoVolumeControl_base *_fromString(const std::string& objectref);
  1599.     static StereoVolumeControl_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  1600.  
  1601.     static StereoVolumeControl_base *_fromDynamicCast(const Arts::Object& object);
  1602.     inline StereoVolumeControl_base *_copy() {
  1603.         assert(_refCnt > 0);
  1604.         _refCnt++;
  1605.         return this;
  1606.     }
  1607.  
  1608.     virtual std::vector<std::string> _defaultPortsIn() const;
  1609.     virtual std::vector<std::string> _defaultPortsOut() const;
  1610.  
  1611.     void *_cast(unsigned long iid);
  1612.  
  1613.     virtual float scaleFactor() = 0;
  1614.     virtual void scaleFactor(float newValue) = 0;
  1615.     virtual float currentVolumeLeft() = 0;
  1616.     virtual float currentVolumeRight() = 0;
  1617. };
  1618.  
  1619. class ARTS_EXPORT StereoVolumeControl_stub : virtual public StereoVolumeControl_base, virtual public Arts::StereoEffect_stub {
  1620. protected:
  1621.     StereoVolumeControl_stub();
  1622.  
  1623. public:
  1624.     StereoVolumeControl_stub(Arts::Connection *connection, long objectID);
  1625.  
  1626.     float scaleFactor();
  1627.     void scaleFactor(float newValue);
  1628.     float currentVolumeLeft();
  1629.     float currentVolumeRight();
  1630. };
  1631.  
  1632. class ARTS_EXPORT StereoVolumeControl_skel : virtual public StereoVolumeControl_base, virtual public Arts::StereoEffect_skel {
  1633. protected:
  1634.     // emitters for change notifications
  1635.     inline void scaleFactor_changed(float newValue) {
  1636.         _emit_changed("scaleFactor_changed",newValue);
  1637.     }
  1638.     inline void currentVolumeLeft_changed(float newValue) {
  1639.         _emit_changed("currentVolumeLeft_changed",newValue);
  1640.     }
  1641.     inline void currentVolumeRight_changed(float newValue) {
  1642.         _emit_changed("currentVolumeRight_changed",newValue);
  1643.     }
  1644.  
  1645. public:
  1646.     StereoVolumeControl_skel();
  1647.  
  1648.     static std::string _interfaceNameSkel();
  1649.     std::string _interfaceName();
  1650.     bool _isCompatibleWith(const std::string& interfacename);
  1651.     void _buildMethodTable();
  1652.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  1653. };
  1654.  
  1655. }
  1656. #include "reference.h"
  1657. namespace Arts {
  1658. class ARTS_EXPORT StereoVolumeControl : public Arts::Object {
  1659. private:
  1660.     static Arts::Object_base* _Creator();
  1661.     StereoVolumeControl_base *_cache;
  1662.     inline StereoVolumeControl_base *_method_call() {
  1663.         _pool->checkcreate();
  1664.         if(_pool->base) {
  1665.             _cache=(StereoVolumeControl_base *)_pool->base->_cast(StereoVolumeControl_base::_IID);
  1666.             assert(_cache);
  1667.         }
  1668.         return _cache;
  1669.     }
  1670.  
  1671. protected:
  1672.     inline StereoVolumeControl(StereoVolumeControl_base* b) : Arts::Object(b), _cache(0) {}
  1673.  
  1674.  
  1675. public:
  1676.     typedef StereoVolumeControl_base _base_class;
  1677.  
  1678.     inline StereoVolumeControl() : Arts::Object(_Creator), _cache(0) {}
  1679.     inline StereoVolumeControl(const Arts::SubClass& s) :
  1680.         Arts::Object(StereoVolumeControl_base::_create(s.string())), _cache(0) {}
  1681.     inline StereoVolumeControl(const Arts::Reference &r) :
  1682.         Arts::Object(r.isString()?(StereoVolumeControl_base::_fromString(r.string())):(StereoVolumeControl_base::_fromReference(r.reference(),true))), _cache(0) {}
  1683.     inline StereoVolumeControl(const Arts::DynamicCast& c) : Arts::Object(StereoVolumeControl_base::_fromDynamicCast(c.object())), _cache(0) {}
  1684.     inline StereoVolumeControl(const StereoVolumeControl& target) : Arts::Object(target._pool), _cache(target._cache) {}
  1685.     inline StereoVolumeControl(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  1686.     inline static StereoVolumeControl null() {return StereoVolumeControl((StereoVolumeControl_base*)0);}
  1687.     inline static StereoVolumeControl _from_base(StereoVolumeControl_base* b) {return StereoVolumeControl(b);}
  1688.     inline StereoVolumeControl& operator=(const StereoVolumeControl& target) {
  1689.         if (_pool == target._pool) return *this;
  1690.         _pool->Dec();
  1691.         _pool = target._pool;
  1692.         _cache = target._cache;
  1693.         _pool->Inc();
  1694.         return *this;
  1695.     }
  1696.     inline operator Arts::StereoEffect() const { return Arts::StereoEffect(*_pool); }
  1697.     inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
  1698.     inline StereoVolumeControl_base* _base() {return _cache?_cache:_method_call();}
  1699.  
  1700.     inline Arts::AutoSuspendState autoSuspend();
  1701.     inline void start();
  1702.     inline void stop();
  1703.     inline void streamInit();
  1704.     inline void streamStart();
  1705.     inline void streamEnd();
  1706.     inline float scaleFactor();
  1707.     inline void scaleFactor(float _newValue);
  1708.     inline float currentVolumeLeft();
  1709.     inline float currentVolumeRight();
  1710. };
  1711.  
  1712. class ARTS_EXPORT StereoFFTScope_base : virtual public Arts::StereoEffect_base {
  1713. public:
  1714.     static unsigned long _IID; // interface ID
  1715.  
  1716.     static StereoFFTScope_base *_create(const std::string& subClass = "Arts::StereoFFTScope");
  1717.     static StereoFFTScope_base *_fromString(const std::string& objectref);
  1718.     static StereoFFTScope_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  1719.  
  1720.     static StereoFFTScope_base *_fromDynamicCast(const Arts::Object& object);
  1721.     inline StereoFFTScope_base *_copy() {
  1722.         assert(_refCnt > 0);
  1723.         _refCnt++;
  1724.         return this;
  1725.     }
  1726.  
  1727.     virtual std::vector<std::string> _defaultPortsIn() const;
  1728.     virtual std::vector<std::string> _defaultPortsOut() const;
  1729.  
  1730.     void *_cast(unsigned long iid);
  1731.  
  1732.     virtual std::vector<float> * scope() = 0;
  1733. };
  1734.  
  1735. class ARTS_EXPORT StereoFFTScope_stub : virtual public StereoFFTScope_base, virtual public Arts::StereoEffect_stub {
  1736. protected:
  1737.     StereoFFTScope_stub();
  1738.  
  1739. public:
  1740.     StereoFFTScope_stub(Arts::Connection *connection, long objectID);
  1741.  
  1742.     std::vector<float> * scope();
  1743. };
  1744.  
  1745. class ARTS_EXPORT StereoFFTScope_skel : virtual public StereoFFTScope_base, virtual public Arts::StereoEffect_skel {
  1746. protected:
  1747.     // emitters for change notifications
  1748.     inline void scope_changed(const std::vector<float>& newValue) {
  1749.         _emit_changed("scope_changed",newValue);
  1750.     }
  1751.  
  1752. public:
  1753.     StereoFFTScope_skel();
  1754.  
  1755.     static std::string _interfaceNameSkel();
  1756.     std::string _interfaceName();
  1757.     bool _isCompatibleWith(const std::string& interfacename);
  1758.     void _buildMethodTable();
  1759.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  1760. };
  1761.  
  1762. }
  1763. #include "reference.h"
  1764. namespace Arts {
  1765. class ARTS_EXPORT StereoFFTScope : public Arts::Object {
  1766. private:
  1767.     static Arts::Object_base* _Creator();
  1768.     StereoFFTScope_base *_cache;
  1769.     inline StereoFFTScope_base *_method_call() {
  1770.         _pool->checkcreate();
  1771.         if(_pool->base) {
  1772.             _cache=(StereoFFTScope_base *)_pool->base->_cast(StereoFFTScope_base::_IID);
  1773.             assert(_cache);
  1774.         }
  1775.         return _cache;
  1776.     }
  1777.  
  1778. protected:
  1779.     inline StereoFFTScope(StereoFFTScope_base* b) : Arts::Object(b), _cache(0) {}
  1780.  
  1781.  
  1782. public:
  1783.     typedef StereoFFTScope_base _base_class;
  1784.  
  1785.     inline StereoFFTScope() : Arts::Object(_Creator), _cache(0) {}
  1786.     inline StereoFFTScope(const Arts::SubClass& s) :
  1787.         Arts::Object(StereoFFTScope_base::_create(s.string())), _cache(0) {}
  1788.     inline StereoFFTScope(const Arts::Reference &r) :
  1789.         Arts::Object(r.isString()?(StereoFFTScope_base::_fromString(r.string())):(StereoFFTScope_base::_fromReference(r.reference(),true))), _cache(0) {}
  1790.     inline StereoFFTScope(const Arts::DynamicCast& c) : Arts::Object(StereoFFTScope_base::_fromDynamicCast(c.object())), _cache(0) {}
  1791.     inline StereoFFTScope(const StereoFFTScope& target) : Arts::Object(target._pool), _cache(target._cache) {}
  1792.     inline StereoFFTScope(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  1793.     inline static StereoFFTScope null() {return StereoFFTScope((StereoFFTScope_base*)0);}
  1794.     inline static StereoFFTScope _from_base(StereoFFTScope_base* b) {return StereoFFTScope(b);}
  1795.     inline StereoFFTScope& operator=(const StereoFFTScope& target) {
  1796.         if (_pool == target._pool) return *this;
  1797.         _pool->Dec();
  1798.         _pool = target._pool;
  1799.         _cache = target._cache;
  1800.         _pool->Inc();
  1801.         return *this;
  1802.     }
  1803.     inline operator Arts::StereoEffect() const { return Arts::StereoEffect(*_pool); }
  1804.     inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
  1805.     inline StereoFFTScope_base* _base() {return _cache?_cache:_method_call();}
  1806.  
  1807.     inline Arts::AutoSuspendState autoSuspend();
  1808.     inline void start();
  1809.     inline void stop();
  1810.     inline void streamInit();
  1811.     inline void streamStart();
  1812.     inline void streamEnd();
  1813.     inline std::vector<float> * scope();
  1814. };
  1815.  
  1816. class ARTS_EXPORT StereoEffectStack_base : virtual public Arts::StereoEffect_base {
  1817. public:
  1818.     static unsigned long _IID; // interface ID
  1819.  
  1820.     static StereoEffectStack_base *_create(const std::string& subClass = "Arts::StereoEffectStack");
  1821.     static StereoEffectStack_base *_fromString(const std::string& objectref);
  1822.     static StereoEffectStack_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  1823.  
  1824.     static StereoEffectStack_base *_fromDynamicCast(const Arts::Object& object);
  1825.     inline StereoEffectStack_base *_copy() {
  1826.         assert(_refCnt > 0);
  1827.         _refCnt++;
  1828.         return this;
  1829.     }
  1830.  
  1831.     virtual std::vector<std::string> _defaultPortsIn() const;
  1832.     virtual std::vector<std::string> _defaultPortsOut() const;
  1833.  
  1834.     void *_cast(unsigned long iid);
  1835.  
  1836.     virtual long insertTop(Arts::StereoEffect effect, const std::string& name) = 0;
  1837.     virtual long insertBottom(Arts::StereoEffect effect, const std::string& name) = 0;
  1838.     virtual void remove(long ID) = 0;
  1839. };
  1840.  
  1841. class ARTS_EXPORT StereoEffectStack_stub : virtual public StereoEffectStack_base, virtual public Arts::StereoEffect_stub {
  1842. protected:
  1843.     StereoEffectStack_stub();
  1844.  
  1845. public:
  1846.     StereoEffectStack_stub(Arts::Connection *connection, long objectID);
  1847.  
  1848.     long insertTop(Arts::StereoEffect effect, const std::string& name);
  1849.     long insertBottom(Arts::StereoEffect effect, const std::string& name);
  1850.     void remove(long ID);
  1851. };
  1852.  
  1853. class ARTS_EXPORT StereoEffectStack_skel : virtual public StereoEffectStack_base, virtual public Arts::StereoEffect_skel {
  1854. public:
  1855.     StereoEffectStack_skel();
  1856.  
  1857.     static std::string _interfaceNameSkel();
  1858.     std::string _interfaceName();
  1859.     bool _isCompatibleWith(const std::string& interfacename);
  1860.     void _buildMethodTable();
  1861.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  1862. };
  1863.  
  1864. }
  1865. #include "reference.h"
  1866. namespace Arts {
  1867. class ARTS_EXPORT StereoEffectStack : public Arts::Object {
  1868. private:
  1869.     static Arts::Object_base* _Creator();
  1870.     StereoEffectStack_base *_cache;
  1871.     inline StereoEffectStack_base *_method_call() {
  1872.         _pool->checkcreate();
  1873.         if(_pool->base) {
  1874.             _cache=(StereoEffectStack_base *)_pool->base->_cast(StereoEffectStack_base::_IID);
  1875.             assert(_cache);
  1876.         }
  1877.         return _cache;
  1878.     }
  1879.  
  1880. protected:
  1881.     inline StereoEffectStack(StereoEffectStack_base* b) : Arts::Object(b), _cache(0) {}
  1882.  
  1883.  
  1884. public:
  1885.     typedef StereoEffectStack_base _base_class;
  1886.  
  1887.     inline StereoEffectStack() : Arts::Object(_Creator), _cache(0) {}
  1888.     inline StereoEffectStack(const Arts::SubClass& s) :
  1889.         Arts::Object(StereoEffectStack_base::_create(s.string())), _cache(0) {}
  1890.     inline StereoEffectStack(const Arts::Reference &r) :
  1891.         Arts::Object(r.isString()?(StereoEffectStack_base::_fromString(r.string())):(StereoEffectStack_base::_fromReference(r.reference(),true))), _cache(0) {}
  1892.     inline StereoEffectStack(const Arts::DynamicCast& c) : Arts::Object(StereoEffectStack_base::_fromDynamicCast(c.object())), _cache(0) {}
  1893.     inline StereoEffectStack(const StereoEffectStack& target) : Arts::Object(target._pool), _cache(target._cache) {}
  1894.     inline StereoEffectStack(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  1895.     inline static StereoEffectStack null() {return StereoEffectStack((StereoEffectStack_base*)0);}
  1896.     inline static StereoEffectStack _from_base(StereoEffectStack_base* b) {return StereoEffectStack(b);}
  1897.     inline StereoEffectStack& operator=(const StereoEffectStack& target) {
  1898.         if (_pool == target._pool) return *this;
  1899.         _pool->Dec();
  1900.         _pool = target._pool;
  1901.         _cache = target._cache;
  1902.         _pool->Inc();
  1903.         return *this;
  1904.     }
  1905.     inline operator Arts::StereoEffect() const { return Arts::StereoEffect(*_pool); }
  1906.     inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
  1907.     inline StereoEffectStack_base* _base() {return _cache?_cache:_method_call();}
  1908.  
  1909.     inline Arts::AutoSuspendState autoSuspend();
  1910.     inline void start();
  1911.     inline void stop();
  1912.     inline void streamInit();
  1913.     inline void streamStart();
  1914.     inline void streamEnd();
  1915.     inline long insertTop(Arts::StereoEffect effect, const std::string& name);
  1916.     inline long insertBottom(Arts::StereoEffect effect, const std::string& name);
  1917.     inline void remove(long ID);
  1918. };
  1919.  
  1920. class ARTS_EXPORT AudioManagerClient_base : virtual public Arts::Object_base {
  1921. public:
  1922.     static unsigned long _IID; // interface ID
  1923.  
  1924.     static AudioManagerClient_base *_create(const std::string& subClass = "Arts::AudioManagerClient");
  1925.     static AudioManagerClient_base *_fromString(const std::string& objectref);
  1926.     static AudioManagerClient_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  1927.  
  1928.     static AudioManagerClient_base *_fromDynamicCast(const Arts::Object& object);
  1929.     inline AudioManagerClient_base *_copy() {
  1930.         assert(_refCnt > 0);
  1931.         _refCnt++;
  1932.         return this;
  1933.     }
  1934.  
  1935.     virtual std::vector<std::string> _defaultPortsIn() const;
  1936.     virtual std::vector<std::string> _defaultPortsOut() const;
  1937.  
  1938.     void *_cast(unsigned long iid);
  1939.  
  1940.     virtual long ID() = 0;
  1941.     virtual Arts::AudioManagerDirection direction() = 0;
  1942.     virtual void direction(Arts::AudioManagerDirection newValue) = 0;
  1943.     virtual std::string title() = 0;
  1944.     virtual void title(const std::string& newValue) = 0;
  1945.     virtual std::string autoRestoreID() = 0;
  1946.     virtual void autoRestoreID(const std::string& newValue) = 0;
  1947.     virtual void constructor(Arts::AudioManagerDirection direction, const std::string& title, const std::string& autoRestoreID) = 0;
  1948. };
  1949.  
  1950. class ARTS_EXPORT AudioManagerClient_stub : virtual public AudioManagerClient_base, virtual public Arts::Object_stub {
  1951. protected:
  1952.     AudioManagerClient_stub();
  1953.  
  1954. public:
  1955.     AudioManagerClient_stub(Arts::Connection *connection, long objectID);
  1956.  
  1957.     long ID();
  1958.     Arts::AudioManagerDirection direction();
  1959.     void direction(Arts::AudioManagerDirection newValue);
  1960.     std::string title();
  1961.     void title(const std::string& newValue);
  1962.     std::string autoRestoreID();
  1963.     void autoRestoreID(const std::string& newValue);
  1964.     void constructor(Arts::AudioManagerDirection direction, const std::string& title, const std::string& autoRestoreID);
  1965. };
  1966.  
  1967. class ARTS_EXPORT AudioManagerClient_skel : virtual public AudioManagerClient_base, virtual public Arts::Object_skel {
  1968. protected:
  1969.     // emitters for change notifications
  1970.     inline void ID_changed(long newValue) {
  1971.         _emit_changed("ID_changed",newValue);
  1972.     }
  1973.     inline void direction_changed(Arts::AudioManagerDirection newValue) {
  1974.         _emit_changed("direction_changed",newValue);
  1975.     }
  1976.     inline void title_changed(const std::string& newValue) {
  1977.         _emit_changed("title_changed",newValue);
  1978.     }
  1979.     inline void autoRestoreID_changed(const std::string& newValue) {
  1980.         _emit_changed("autoRestoreID_changed",newValue);
  1981.     }
  1982.  
  1983. public:
  1984.     AudioManagerClient_skel();
  1985.  
  1986.     static std::string _interfaceNameSkel();
  1987.     std::string _interfaceName();
  1988.     bool _isCompatibleWith(const std::string& interfacename);
  1989.     void _buildMethodTable();
  1990.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  1991. };
  1992.  
  1993. }
  1994. #include "reference.h"
  1995. namespace Arts {
  1996. class ARTS_EXPORT AudioManagerClient : public Arts::Object {
  1997. private:
  1998.     static Arts::Object_base* _Creator();
  1999.     AudioManagerClient_base *_cache;
  2000.     inline AudioManagerClient_base *_method_call() {
  2001.         _pool->checkcreate();
  2002.         if(_pool->base) {
  2003.             _cache=(AudioManagerClient_base *)_pool->base->_cast(AudioManagerClient_base::_IID);
  2004.             assert(_cache);
  2005.         }
  2006.         return _cache;
  2007.     }
  2008.  
  2009. protected:
  2010.     inline AudioManagerClient(AudioManagerClient_base* b) : Arts::Object(b), _cache(0) {}
  2011.  
  2012.  
  2013. public:
  2014.     typedef AudioManagerClient_base _base_class;
  2015.  
  2016.     inline AudioManagerClient() : Arts::Object(_Creator), _cache(0) {}
  2017.     inline AudioManagerClient(const Arts::SubClass& s) :
  2018.         Arts::Object(AudioManagerClient_base::_create(s.string())), _cache(0) {}
  2019.     inline AudioManagerClient(const Arts::Reference &r) :
  2020.         Arts::Object(r.isString()?(AudioManagerClient_base::_fromString(r.string())):(AudioManagerClient_base::_fromReference(r.reference(),true))), _cache(0) {}
  2021.     inline AudioManagerClient(const Arts::DynamicCast& c) : Arts::Object(AudioManagerClient_base::_fromDynamicCast(c.object())), _cache(0) {}
  2022.     inline AudioManagerClient(const AudioManagerClient& target) : Arts::Object(target._pool), _cache(target._cache) {}
  2023.     inline AudioManagerClient(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  2024.     inline static AudioManagerClient null() {return AudioManagerClient((AudioManagerClient_base*)0);}
  2025.     inline static AudioManagerClient _from_base(AudioManagerClient_base* b) {return AudioManagerClient(b);}
  2026.     inline AudioManagerClient& operator=(const AudioManagerClient& target) {
  2027.         if (_pool == target._pool) return *this;
  2028.         _pool->Dec();
  2029.         _pool = target._pool;
  2030.         _cache = target._cache;
  2031.         _pool->Inc();
  2032.         return *this;
  2033.     }
  2034.     inline AudioManagerClient_base* _base() {return _cache?_cache:_method_call();}
  2035.  
  2036.     inline long ID();
  2037.     inline Arts::AudioManagerDirection direction();
  2038.     inline void direction(Arts::AudioManagerDirection _newValue);
  2039.     inline std::string title();
  2040.     inline void title(const std::string& _newValue);
  2041.     inline std::string autoRestoreID();
  2042.     inline void autoRestoreID(const std::string& _newValue);
  2043.     inline AudioManagerClient(Arts::AudioManagerDirection direction, const std::string& title, const std::string& autoRestoreID);
  2044. };
  2045.  
  2046. class ARTS_EXPORT AudioManager_base : virtual public Arts::Object_base {
  2047. public:
  2048.     static unsigned long _IID; // interface ID
  2049.  
  2050.     static AudioManager_base *_create(const std::string& subClass = "Arts::AudioManager");
  2051.     static AudioManager_base *_fromString(const std::string& objectref);
  2052.     static AudioManager_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  2053.  
  2054.     static AudioManager_base *_fromDynamicCast(const Arts::Object& object);
  2055.     inline AudioManager_base *_copy() {
  2056.         assert(_refCnt > 0);
  2057.         _refCnt++;
  2058.         return this;
  2059.     }
  2060.  
  2061.     virtual std::vector<std::string> _defaultPortsIn() const;
  2062.     virtual std::vector<std::string> _defaultPortsOut() const;
  2063.  
  2064.     void *_cast(unsigned long iid);
  2065.  
  2066.     virtual std::vector<std::string> * destinations() = 0;
  2067.     virtual std::vector<Arts::AudioManagerInfo> * clients() = 0;
  2068.     virtual long changes() = 0;
  2069.     virtual void setDestination(long ID, const std::string& destination) = 0;
  2070. };
  2071.  
  2072. class ARTS_EXPORT AudioManager_stub : virtual public AudioManager_base, virtual public Arts::Object_stub {
  2073. protected:
  2074.     AudioManager_stub();
  2075.  
  2076. public:
  2077.     AudioManager_stub(Arts::Connection *connection, long objectID);
  2078.  
  2079.     std::vector<std::string> * destinations();
  2080.     std::vector<Arts::AudioManagerInfo> * clients();
  2081.     long changes();
  2082.     void setDestination(long ID, const std::string& destination);
  2083. };
  2084.  
  2085. class ARTS_EXPORT AudioManager_skel : virtual public AudioManager_base, virtual public Arts::Object_skel {
  2086. protected:
  2087.     // emitters for change notifications
  2088.     inline void destinations_changed(const std::vector<std::string>& newValue) {
  2089.         _emit_changed("destinations_changed",newValue);
  2090.     }
  2091.     inline void changes_changed(long newValue) {
  2092.         _emit_changed("changes_changed",newValue);
  2093.     }
  2094.  
  2095. public:
  2096.     AudioManager_skel();
  2097.  
  2098.     static std::string _interfaceNameSkel();
  2099.     std::string _interfaceName();
  2100.     bool _isCompatibleWith(const std::string& interfacename);
  2101.     void _buildMethodTable();
  2102.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  2103. };
  2104.  
  2105. }
  2106. #include "reference.h"
  2107. namespace Arts {
  2108. class ARTS_EXPORT AudioManager : public Arts::Object {
  2109. private:
  2110.     static Arts::Object_base* _Creator();
  2111.     AudioManager_base *_cache;
  2112.     inline AudioManager_base *_method_call() {
  2113.         _pool->checkcreate();
  2114.         if(_pool->base) {
  2115.             _cache=(AudioManager_base *)_pool->base->_cast(AudioManager_base::_IID);
  2116.             assert(_cache);
  2117.         }
  2118.         return _cache;
  2119.     }
  2120.  
  2121. protected:
  2122.     inline AudioManager(AudioManager_base* b) : Arts::Object(b), _cache(0) {}
  2123.  
  2124.  
  2125. public:
  2126.     typedef AudioManager_base _base_class;
  2127.  
  2128.     inline AudioManager() : Arts::Object(_Creator), _cache(0) {}
  2129.     inline AudioManager(const Arts::SubClass& s) :
  2130.         Arts::Object(AudioManager_base::_create(s.string())), _cache(0) {}
  2131.     inline AudioManager(const Arts::Reference &r) :
  2132.         Arts::Object(r.isString()?(AudioManager_base::_fromString(r.string())):(AudioManager_base::_fromReference(r.reference(),true))), _cache(0) {}
  2133.     inline AudioManager(const Arts::DynamicCast& c) : Arts::Object(AudioManager_base::_fromDynamicCast(c.object())), _cache(0) {}
  2134.     inline AudioManager(const AudioManager& target) : Arts::Object(target._pool), _cache(target._cache) {}
  2135.     inline AudioManager(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  2136.     inline static AudioManager null() {return AudioManager((AudioManager_base*)0);}
  2137.     inline static AudioManager _from_base(AudioManager_base* b) {return AudioManager(b);}
  2138.     inline AudioManager& operator=(const AudioManager& target) {
  2139.         if (_pool == target._pool) return *this;
  2140.         _pool->Dec();
  2141.         _pool = target._pool;
  2142.         _cache = target._cache;
  2143.         _pool->Inc();
  2144.         return *this;
  2145.     }
  2146.     inline AudioManager_base* _base() {return _cache?_cache:_method_call();}
  2147.  
  2148.     inline std::vector<std::string> * destinations();
  2149.     inline std::vector<Arts::AudioManagerInfo> * clients();
  2150.     inline long changes();
  2151.     inline void setDestination(long ID, const std::string& destination);
  2152. };
  2153.  
  2154. class ARTS_EXPORT Synth_AMAN_PLAY_base : virtual public Arts::SynthModule_base {
  2155. public:
  2156.     static unsigned long _IID; // interface ID
  2157.  
  2158.     static Synth_AMAN_PLAY_base *_create(const std::string& subClass = "Arts::Synth_AMAN_PLAY");
  2159.     static Synth_AMAN_PLAY_base *_fromString(const std::string& objectref);
  2160.     static Synth_AMAN_PLAY_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  2161.  
  2162.     static Synth_AMAN_PLAY_base *_fromDynamicCast(const Arts::Object& object);
  2163.     inline Synth_AMAN_PLAY_base *_copy() {
  2164.         assert(_refCnt > 0);
  2165.         _refCnt++;
  2166.         return this;
  2167.     }
  2168.  
  2169.     virtual std::vector<std::string> _defaultPortsIn() const;
  2170.     virtual std::vector<std::string> _defaultPortsOut() const;
  2171.  
  2172.     void *_cast(unsigned long iid);
  2173.  
  2174.     virtual std::string title() = 0;
  2175.     virtual void title(const std::string& newValue) = 0;
  2176.     virtual std::string autoRestoreID() = 0;
  2177.     virtual void autoRestoreID(const std::string& newValue) = 0;
  2178.     virtual void constructor(Arts::AudioManagerClient client) = 0;
  2179. };
  2180.  
  2181. class ARTS_EXPORT Synth_AMAN_PLAY_stub : virtual public Synth_AMAN_PLAY_base, virtual public Arts::SynthModule_stub {
  2182. protected:
  2183.     Synth_AMAN_PLAY_stub();
  2184.  
  2185. public:
  2186.     Synth_AMAN_PLAY_stub(Arts::Connection *connection, long objectID);
  2187.  
  2188.     std::string title();
  2189.     void title(const std::string& newValue);
  2190.     std::string autoRestoreID();
  2191.     void autoRestoreID(const std::string& newValue);
  2192.     void constructor(Arts::AudioManagerClient client);
  2193. };
  2194.  
  2195. class ARTS_EXPORT Synth_AMAN_PLAY_skel : virtual public Synth_AMAN_PLAY_base, virtual public Arts::SynthModule_skel {
  2196. protected:
  2197.     // variables for streams
  2198.     float *left;                              // incoming stream
  2199.     float *right;                             // incoming stream
  2200.  
  2201. protected:
  2202.     // emitters for change notifications
  2203.     inline void title_changed(const std::string& newValue) {
  2204.         _emit_changed("title_changed",newValue);
  2205.     }
  2206.     inline void autoRestoreID_changed(const std::string& newValue) {
  2207.         _emit_changed("autoRestoreID_changed",newValue);
  2208.     }
  2209.  
  2210. public:
  2211.     Synth_AMAN_PLAY_skel();
  2212.  
  2213.     static std::string _interfaceNameSkel();
  2214.     std::string _interfaceName();
  2215.     bool _isCompatibleWith(const std::string& interfacename);
  2216.     void _buildMethodTable();
  2217.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  2218. };
  2219.  
  2220. }
  2221. #include "reference.h"
  2222. namespace Arts {
  2223. class ARTS_EXPORT Synth_AMAN_PLAY : public Arts::Object {
  2224. private:
  2225.     static Arts::Object_base* _Creator();
  2226.     Synth_AMAN_PLAY_base *_cache;
  2227.     inline Synth_AMAN_PLAY_base *_method_call() {
  2228.         _pool->checkcreate();
  2229.         if(_pool->base) {
  2230.             _cache=(Synth_AMAN_PLAY_base *)_pool->base->_cast(Synth_AMAN_PLAY_base::_IID);
  2231.             assert(_cache);
  2232.         }
  2233.         return _cache;
  2234.     }
  2235.  
  2236. protected:
  2237.     inline Synth_AMAN_PLAY(Synth_AMAN_PLAY_base* b) : Arts::Object(b), _cache(0) {}
  2238.  
  2239.  
  2240. public:
  2241.     typedef Synth_AMAN_PLAY_base _base_class;
  2242.  
  2243.     inline Synth_AMAN_PLAY() : Arts::Object(_Creator), _cache(0) {}
  2244.     inline Synth_AMAN_PLAY(const Arts::SubClass& s) :
  2245.         Arts::Object(Synth_AMAN_PLAY_base::_create(s.string())), _cache(0) {}
  2246.     inline Synth_AMAN_PLAY(const Arts::Reference &r) :
  2247.         Arts::Object(r.isString()?(Synth_AMAN_PLAY_base::_fromString(r.string())):(Synth_AMAN_PLAY_base::_fromReference(r.reference(),true))), _cache(0) {}
  2248.     inline Synth_AMAN_PLAY(const Arts::DynamicCast& c) : Arts::Object(Synth_AMAN_PLAY_base::_fromDynamicCast(c.object())), _cache(0) {}
  2249.     inline Synth_AMAN_PLAY(const Synth_AMAN_PLAY& target) : Arts::Object(target._pool), _cache(target._cache) {}
  2250.     inline Synth_AMAN_PLAY(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  2251.     inline static Synth_AMAN_PLAY null() {return Synth_AMAN_PLAY((Synth_AMAN_PLAY_base*)0);}
  2252.     inline static Synth_AMAN_PLAY _from_base(Synth_AMAN_PLAY_base* b) {return Synth_AMAN_PLAY(b);}
  2253.     inline Synth_AMAN_PLAY& operator=(const Synth_AMAN_PLAY& target) {
  2254.         if (_pool == target._pool) return *this;
  2255.         _pool->Dec();
  2256.         _pool = target._pool;
  2257.         _cache = target._cache;
  2258.         _pool->Inc();
  2259.         return *this;
  2260.     }
  2261.     inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
  2262.     inline Synth_AMAN_PLAY_base* _base() {return _cache?_cache:_method_call();}
  2263.  
  2264.     inline Arts::AutoSuspendState autoSuspend();
  2265.     inline void start();
  2266.     inline void stop();
  2267.     inline void streamInit();
  2268.     inline void streamStart();
  2269.     inline void streamEnd();
  2270.     inline std::string title();
  2271.     inline void title(const std::string& _newValue);
  2272.     inline std::string autoRestoreID();
  2273.     inline void autoRestoreID(const std::string& _newValue);
  2274.     inline Synth_AMAN_PLAY(Arts::AudioManagerClient client);
  2275. };
  2276.  
  2277. class ARTS_EXPORT Synth_AMAN_RECORD_base : virtual public Arts::SynthModule_base {
  2278. public:
  2279.     static unsigned long _IID; // interface ID
  2280.  
  2281.     static Synth_AMAN_RECORD_base *_create(const std::string& subClass = "Arts::Synth_AMAN_RECORD");
  2282.     static Synth_AMAN_RECORD_base *_fromString(const std::string& objectref);
  2283.     static Synth_AMAN_RECORD_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  2284.  
  2285.     static Synth_AMAN_RECORD_base *_fromDynamicCast(const Arts::Object& object);
  2286.     inline Synth_AMAN_RECORD_base *_copy() {
  2287.         assert(_refCnt > 0);
  2288.         _refCnt++;
  2289.         return this;
  2290.     }
  2291.  
  2292.     virtual std::vector<std::string> _defaultPortsIn() const;
  2293.     virtual std::vector<std::string> _defaultPortsOut() const;
  2294.  
  2295.     void *_cast(unsigned long iid);
  2296.  
  2297.     virtual std::string title() = 0;
  2298.     virtual void title(const std::string& newValue) = 0;
  2299.     virtual std::string autoRestoreID() = 0;
  2300.     virtual void autoRestoreID(const std::string& newValue) = 0;
  2301.     virtual void constructor(Arts::AudioManagerClient client) = 0;
  2302. };
  2303.  
  2304. class ARTS_EXPORT Synth_AMAN_RECORD_stub : virtual public Synth_AMAN_RECORD_base, virtual public Arts::SynthModule_stub {
  2305. protected:
  2306.     Synth_AMAN_RECORD_stub();
  2307.  
  2308. public:
  2309.     Synth_AMAN_RECORD_stub(Arts::Connection *connection, long objectID);
  2310.  
  2311.     std::string title();
  2312.     void title(const std::string& newValue);
  2313.     std::string autoRestoreID();
  2314.     void autoRestoreID(const std::string& newValue);
  2315.     void constructor(Arts::AudioManagerClient client);
  2316. };
  2317.  
  2318. class ARTS_EXPORT Synth_AMAN_RECORD_skel : virtual public Synth_AMAN_RECORD_base, virtual public Arts::SynthModule_skel {
  2319. protected:
  2320.     // variables for streams
  2321.     float *left;                              // outgoing stream
  2322.     float *right;                             // outgoing stream
  2323.  
  2324. protected:
  2325.     // emitters for change notifications
  2326.     inline void title_changed(const std::string& newValue) {
  2327.         _emit_changed("title_changed",newValue);
  2328.     }
  2329.     inline void autoRestoreID_changed(const std::string& newValue) {
  2330.         _emit_changed("autoRestoreID_changed",newValue);
  2331.     }
  2332.  
  2333. public:
  2334.     Synth_AMAN_RECORD_skel();
  2335.  
  2336.     static std::string _interfaceNameSkel();
  2337.     std::string _interfaceName();
  2338.     bool _isCompatibleWith(const std::string& interfacename);
  2339.     void _buildMethodTable();
  2340.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  2341. };
  2342.  
  2343. }
  2344. #include "reference.h"
  2345. namespace Arts {
  2346. class ARTS_EXPORT Synth_AMAN_RECORD : public Arts::Object {
  2347. private:
  2348.     static Arts::Object_base* _Creator();
  2349.     Synth_AMAN_RECORD_base *_cache;
  2350.     inline Synth_AMAN_RECORD_base *_method_call() {
  2351.         _pool->checkcreate();
  2352.         if(_pool->base) {
  2353.             _cache=(Synth_AMAN_RECORD_base *)_pool->base->_cast(Synth_AMAN_RECORD_base::_IID);
  2354.             assert(_cache);
  2355.         }
  2356.         return _cache;
  2357.     }
  2358.  
  2359. protected:
  2360.     inline Synth_AMAN_RECORD(Synth_AMAN_RECORD_base* b) : Arts::Object(b), _cache(0) {}
  2361.  
  2362.  
  2363. public:
  2364.     typedef Synth_AMAN_RECORD_base _base_class;
  2365.  
  2366.     inline Synth_AMAN_RECORD() : Arts::Object(_Creator), _cache(0) {}
  2367.     inline Synth_AMAN_RECORD(const Arts::SubClass& s) :
  2368.         Arts::Object(Synth_AMAN_RECORD_base::_create(s.string())), _cache(0) {}
  2369.     inline Synth_AMAN_RECORD(const Arts::Reference &r) :
  2370.         Arts::Object(r.isString()?(Synth_AMAN_RECORD_base::_fromString(r.string())):(Synth_AMAN_RECORD_base::_fromReference(r.reference(),true))), _cache(0) {}
  2371.     inline Synth_AMAN_RECORD(const Arts::DynamicCast& c) : Arts::Object(Synth_AMAN_RECORD_base::_fromDynamicCast(c.object())), _cache(0) {}
  2372.     inline Synth_AMAN_RECORD(const Synth_AMAN_RECORD& target) : Arts::Object(target._pool), _cache(target._cache) {}
  2373.     inline Synth_AMAN_RECORD(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  2374.     inline static Synth_AMAN_RECORD null() {return Synth_AMAN_RECORD((Synth_AMAN_RECORD_base*)0);}
  2375.     inline static Synth_AMAN_RECORD _from_base(Synth_AMAN_RECORD_base* b) {return Synth_AMAN_RECORD(b);}
  2376.     inline Synth_AMAN_RECORD& operator=(const Synth_AMAN_RECORD& target) {
  2377.         if (_pool == target._pool) return *this;
  2378.         _pool->Dec();
  2379.         _pool = target._pool;
  2380.         _cache = target._cache;
  2381.         _pool->Inc();
  2382.         return *this;
  2383.     }
  2384.     inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
  2385.     inline Synth_AMAN_RECORD_base* _base() {return _cache?_cache:_method_call();}
  2386.  
  2387.     inline Arts::AutoSuspendState autoSuspend();
  2388.     inline void start();
  2389.     inline void stop();
  2390.     inline void streamInit();
  2391.     inline void streamStart();
  2392.     inline void streamEnd();
  2393.     inline std::string title();
  2394.     inline void title(const std::string& _newValue);
  2395.     inline std::string autoRestoreID();
  2396.     inline void autoRestoreID(const std::string& _newValue);
  2397.     inline Synth_AMAN_RECORD(Arts::AudioManagerClient client);
  2398. };
  2399.  
  2400. class ARTS_EXPORT DataHandle_base : virtual public Arts::Object_base {
  2401. public:
  2402.     static unsigned long _IID; // interface ID
  2403.  
  2404.     static DataHandle_base *_create(const std::string& subClass = "Arts::DataHandle");
  2405.     static DataHandle_base *_fromString(const std::string& objectref);
  2406.     static DataHandle_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  2407.  
  2408.     static DataHandle_base *_fromDynamicCast(const Arts::Object& object);
  2409.     inline DataHandle_base *_copy() {
  2410.         assert(_refCnt > 0);
  2411.         _refCnt++;
  2412.         return this;
  2413.     }
  2414.  
  2415.     virtual std::vector<std::string> _defaultPortsIn() const;
  2416.     virtual std::vector<std::string> _defaultPortsOut() const;
  2417.  
  2418.     void *_cast(unsigned long iid);
  2419.  
  2420.     virtual long bitDepth() = 0;
  2421.     virtual long channelCount() = 0;
  2422.     virtual long valueCount() = 0;
  2423.     virtual long errorNo() = 0;
  2424. };
  2425.  
  2426. class ARTS_EXPORT DataHandle_stub : virtual public DataHandle_base, virtual public Arts::Object_stub {
  2427. protected:
  2428.     DataHandle_stub();
  2429.  
  2430. public:
  2431.     DataHandle_stub(Arts::Connection *connection, long objectID);
  2432.  
  2433.     long bitDepth();
  2434.     long channelCount();
  2435.     long valueCount();
  2436.     long errorNo();
  2437. };
  2438.  
  2439. class ARTS_EXPORT DataHandle_skel : virtual public DataHandle_base, virtual public Arts::Object_skel {
  2440. protected:
  2441.     // emitters for change notifications
  2442.     inline void bitDepth_changed(long newValue) {
  2443.         _emit_changed("bitDepth_changed",newValue);
  2444.     }
  2445.     inline void channelCount_changed(long newValue) {
  2446.         _emit_changed("channelCount_changed",newValue);
  2447.     }
  2448.     inline void valueCount_changed(long newValue) {
  2449.         _emit_changed("valueCount_changed",newValue);
  2450.     }
  2451.     inline void errorNo_changed(long newValue) {
  2452.         _emit_changed("errorNo_changed",newValue);
  2453.     }
  2454.  
  2455. public:
  2456.     DataHandle_skel();
  2457.  
  2458.     static std::string _interfaceNameSkel();
  2459.     std::string _interfaceName();
  2460.     bool _isCompatibleWith(const std::string& interfacename);
  2461.     void _buildMethodTable();
  2462.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  2463. };
  2464.  
  2465. }
  2466. #include "reference.h"
  2467. namespace Arts {
  2468. class ARTS_EXPORT DataHandle : public Arts::Object {
  2469. private:
  2470.     static Arts::Object_base* _Creator();
  2471.     DataHandle_base *_cache;
  2472.     inline DataHandle_base *_method_call() {
  2473.         _pool->checkcreate();
  2474.         if(_pool->base) {
  2475.             _cache=(DataHandle_base *)_pool->base->_cast(DataHandle_base::_IID);
  2476.             assert(_cache);
  2477.         }
  2478.         return _cache;
  2479.     }
  2480.  
  2481. protected:
  2482.     inline DataHandle(DataHandle_base* b) : Arts::Object(b), _cache(0) {}
  2483.  
  2484.  
  2485. public:
  2486.     typedef DataHandle_base _base_class;
  2487.  
  2488.     inline DataHandle() : Arts::Object(_Creator), _cache(0) {}
  2489.     inline DataHandle(const Arts::SubClass& s) :
  2490.         Arts::Object(DataHandle_base::_create(s.string())), _cache(0) {}
  2491.     inline DataHandle(const Arts::Reference &r) :
  2492.         Arts::Object(r.isString()?(DataHandle_base::_fromString(r.string())):(DataHandle_base::_fromReference(r.reference(),true))), _cache(0) {}
  2493.     inline DataHandle(const Arts::DynamicCast& c) : Arts::Object(DataHandle_base::_fromDynamicCast(c.object())), _cache(0) {}
  2494.     inline DataHandle(const DataHandle& target) : Arts::Object(target._pool), _cache(target._cache) {}
  2495.     inline DataHandle(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  2496.     inline static DataHandle null() {return DataHandle((DataHandle_base*)0);}
  2497.     inline static DataHandle _from_base(DataHandle_base* b) {return DataHandle(b);}
  2498.     inline DataHandle& operator=(const DataHandle& target) {
  2499.         if (_pool == target._pool) return *this;
  2500.         _pool->Dec();
  2501.         _pool = target._pool;
  2502.         _cache = target._cache;
  2503.         _pool->Inc();
  2504.         return *this;
  2505.     }
  2506.     inline DataHandle_base* _base() {return _cache?_cache:_method_call();}
  2507.  
  2508.     inline long bitDepth();
  2509.     inline long channelCount();
  2510.     inline long valueCount();
  2511.     inline long errorNo();
  2512. };
  2513.  
  2514. class ARTS_EXPORT ReversedDataHandle_base : virtual public Arts::DataHandle_base {
  2515. public:
  2516.     static unsigned long _IID; // interface ID
  2517.  
  2518.     static ReversedDataHandle_base *_create(const std::string& subClass = "Arts::ReversedDataHandle");
  2519.     static ReversedDataHandle_base *_fromString(const std::string& objectref);
  2520.     static ReversedDataHandle_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  2521.  
  2522.     static ReversedDataHandle_base *_fromDynamicCast(const Arts::Object& object);
  2523.     inline ReversedDataHandle_base *_copy() {
  2524.         assert(_refCnt > 0);
  2525.         _refCnt++;
  2526.         return this;
  2527.     }
  2528.  
  2529.     virtual std::vector<std::string> _defaultPortsIn() const;
  2530.     virtual std::vector<std::string> _defaultPortsOut() const;
  2531.  
  2532.     void *_cast(unsigned long iid);
  2533.  
  2534.     virtual void init(Arts::DataHandle sourceHandle) = 0;
  2535. };
  2536.  
  2537. class ARTS_EXPORT ReversedDataHandle_stub : virtual public ReversedDataHandle_base, virtual public Arts::DataHandle_stub {
  2538. protected:
  2539.     ReversedDataHandle_stub();
  2540.  
  2541. public:
  2542.     ReversedDataHandle_stub(Arts::Connection *connection, long objectID);
  2543.  
  2544.     void init(Arts::DataHandle sourceHandle);
  2545. };
  2546.  
  2547. class ARTS_EXPORT ReversedDataHandle_skel : virtual public ReversedDataHandle_base, virtual public Arts::DataHandle_skel {
  2548. public:
  2549.     ReversedDataHandle_skel();
  2550.  
  2551.     static std::string _interfaceNameSkel();
  2552.     std::string _interfaceName();
  2553.     bool _isCompatibleWith(const std::string& interfacename);
  2554.     void _buildMethodTable();
  2555.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  2556. };
  2557.  
  2558. }
  2559. #include "reference.h"
  2560. namespace Arts {
  2561. class ARTS_EXPORT ReversedDataHandle : public Arts::Object {
  2562. private:
  2563.     static Arts::Object_base* _Creator();
  2564.     ReversedDataHandle_base *_cache;
  2565.     inline ReversedDataHandle_base *_method_call() {
  2566.         _pool->checkcreate();
  2567.         if(_pool->base) {
  2568.             _cache=(ReversedDataHandle_base *)_pool->base->_cast(ReversedDataHandle_base::_IID);
  2569.             assert(_cache);
  2570.         }
  2571.         return _cache;
  2572.     }
  2573.  
  2574. protected:
  2575.     inline ReversedDataHandle(ReversedDataHandle_base* b) : Arts::Object(b), _cache(0) {}
  2576.  
  2577.  
  2578. public:
  2579.     typedef ReversedDataHandle_base _base_class;
  2580.  
  2581.     inline ReversedDataHandle() : Arts::Object(_Creator), _cache(0) {}
  2582.     inline ReversedDataHandle(const Arts::SubClass& s) :
  2583.         Arts::Object(ReversedDataHandle_base::_create(s.string())), _cache(0) {}
  2584.     inline ReversedDataHandle(const Arts::Reference &r) :
  2585.         Arts::Object(r.isString()?(ReversedDataHandle_base::_fromString(r.string())):(ReversedDataHandle_base::_fromReference(r.reference(),true))), _cache(0) {}
  2586.     inline ReversedDataHandle(const Arts::DynamicCast& c) : Arts::Object(ReversedDataHandle_base::_fromDynamicCast(c.object())), _cache(0) {}
  2587.     inline ReversedDataHandle(const ReversedDataHandle& target) : Arts::Object(target._pool), _cache(target._cache) {}
  2588.     inline ReversedDataHandle(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  2589.     inline static ReversedDataHandle null() {return ReversedDataHandle((ReversedDataHandle_base*)0);}
  2590.     inline static ReversedDataHandle _from_base(ReversedDataHandle_base* b) {return ReversedDataHandle(b);}
  2591.     inline ReversedDataHandle& operator=(const ReversedDataHandle& target) {
  2592.         if (_pool == target._pool) return *this;
  2593.         _pool->Dec();
  2594.         _pool = target._pool;
  2595.         _cache = target._cache;
  2596.         _pool->Inc();
  2597.         return *this;
  2598.     }
  2599.     inline operator Arts::DataHandle() const { return Arts::DataHandle(*_pool); }
  2600.     inline ReversedDataHandle_base* _base() {return _cache?_cache:_method_call();}
  2601.  
  2602.     inline long bitDepth();
  2603.     inline long channelCount();
  2604.     inline long valueCount();
  2605.     inline long errorNo();
  2606.     inline void init(Arts::DataHandle sourceHandle);
  2607. };
  2608.  
  2609. class ARTS_EXPORT CroppedDataHandle_base : virtual public Arts::DataHandle_base {
  2610. public:
  2611.     static unsigned long _IID; // interface ID
  2612.  
  2613.     static CroppedDataHandle_base *_create(const std::string& subClass = "Arts::CroppedDataHandle");
  2614.     static CroppedDataHandle_base *_fromString(const std::string& objectref);
  2615.     static CroppedDataHandle_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  2616.  
  2617.     static CroppedDataHandle_base *_fromDynamicCast(const Arts::Object& object);
  2618.     inline CroppedDataHandle_base *_copy() {
  2619.         assert(_refCnt > 0);
  2620.         _refCnt++;
  2621.         return this;
  2622.     }
  2623.  
  2624.     virtual std::vector<std::string> _defaultPortsIn() const;
  2625.     virtual std::vector<std::string> _defaultPortsOut() const;
  2626.  
  2627.     void *_cast(unsigned long iid);
  2628.  
  2629.     virtual void init(Arts::DataHandle sourceHandle, long headCutValueCount, long tailCutValueCount) = 0;
  2630. };
  2631.  
  2632. class ARTS_EXPORT CroppedDataHandle_stub : virtual public CroppedDataHandle_base, virtual public Arts::DataHandle_stub {
  2633. protected:
  2634.     CroppedDataHandle_stub();
  2635.  
  2636. public:
  2637.     CroppedDataHandle_stub(Arts::Connection *connection, long objectID);
  2638.  
  2639.     void init(Arts::DataHandle sourceHandle, long headCutValueCount, long tailCutValueCount);
  2640. };
  2641.  
  2642. class ARTS_EXPORT CroppedDataHandle_skel : virtual public CroppedDataHandle_base, virtual public Arts::DataHandle_skel {
  2643. public:
  2644.     CroppedDataHandle_skel();
  2645.  
  2646.     static std::string _interfaceNameSkel();
  2647.     std::string _interfaceName();
  2648.     bool _isCompatibleWith(const std::string& interfacename);
  2649.     void _buildMethodTable();
  2650.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  2651. };
  2652.  
  2653. }
  2654. #include "reference.h"
  2655. namespace Arts {
  2656. class ARTS_EXPORT CroppedDataHandle : public Arts::Object {
  2657. private:
  2658.     static Arts::Object_base* _Creator();
  2659.     CroppedDataHandle_base *_cache;
  2660.     inline CroppedDataHandle_base *_method_call() {
  2661.         _pool->checkcreate();
  2662.         if(_pool->base) {
  2663.             _cache=(CroppedDataHandle_base *)_pool->base->_cast(CroppedDataHandle_base::_IID);
  2664.             assert(_cache);
  2665.         }
  2666.         return _cache;
  2667.     }
  2668.  
  2669. protected:
  2670.     inline CroppedDataHandle(CroppedDataHandle_base* b) : Arts::Object(b), _cache(0) {}
  2671.  
  2672.  
  2673. public:
  2674.     typedef CroppedDataHandle_base _base_class;
  2675.  
  2676.     inline CroppedDataHandle() : Arts::Object(_Creator), _cache(0) {}
  2677.     inline CroppedDataHandle(const Arts::SubClass& s) :
  2678.         Arts::Object(CroppedDataHandle_base::_create(s.string())), _cache(0) {}
  2679.     inline CroppedDataHandle(const Arts::Reference &r) :
  2680.         Arts::Object(r.isString()?(CroppedDataHandle_base::_fromString(r.string())):(CroppedDataHandle_base::_fromReference(r.reference(),true))), _cache(0) {}
  2681.     inline CroppedDataHandle(const Arts::DynamicCast& c) : Arts::Object(CroppedDataHandle_base::_fromDynamicCast(c.object())), _cache(0) {}
  2682.     inline CroppedDataHandle(const CroppedDataHandle& target) : Arts::Object(target._pool), _cache(target._cache) {}
  2683.     inline CroppedDataHandle(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  2684.     inline static CroppedDataHandle null() {return CroppedDataHandle((CroppedDataHandle_base*)0);}
  2685.     inline static CroppedDataHandle _from_base(CroppedDataHandle_base* b) {return CroppedDataHandle(b);}
  2686.     inline CroppedDataHandle& operator=(const CroppedDataHandle& target) {
  2687.         if (_pool == target._pool) return *this;
  2688.         _pool->Dec();
  2689.         _pool = target._pool;
  2690.         _cache = target._cache;
  2691.         _pool->Inc();
  2692.         return *this;
  2693.     }
  2694.     inline operator Arts::DataHandle() const { return Arts::DataHandle(*_pool); }
  2695.     inline CroppedDataHandle_base* _base() {return _cache?_cache:_method_call();}
  2696.  
  2697.     inline long bitDepth();
  2698.     inline long channelCount();
  2699.     inline long valueCount();
  2700.     inline long errorNo();
  2701.     inline void init(Arts::DataHandle sourceHandle, long headCutValueCount, long tailCutValueCount);
  2702. };
  2703.  
  2704. class ARTS_EXPORT CutDataHandle_base : virtual public Arts::DataHandle_base {
  2705. public:
  2706.     static unsigned long _IID; // interface ID
  2707.  
  2708.     static CutDataHandle_base *_create(const std::string& subClass = "Arts::CutDataHandle");
  2709.     static CutDataHandle_base *_fromString(const std::string& objectref);
  2710.     static CutDataHandle_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  2711.  
  2712.     static CutDataHandle_base *_fromDynamicCast(const Arts::Object& object);
  2713.     inline CutDataHandle_base *_copy() {
  2714.         assert(_refCnt > 0);
  2715.         _refCnt++;
  2716.         return this;
  2717.     }
  2718.  
  2719.     virtual std::vector<std::string> _defaultPortsIn() const;
  2720.     virtual std::vector<std::string> _defaultPortsOut() const;
  2721.  
  2722.     void *_cast(unsigned long iid);
  2723.  
  2724.     virtual void init(Arts::DataHandle sourceHandle, long cutOffset, long cutValueCount) = 0;
  2725. };
  2726.  
  2727. class ARTS_EXPORT CutDataHandle_stub : virtual public CutDataHandle_base, virtual public Arts::DataHandle_stub {
  2728. protected:
  2729.     CutDataHandle_stub();
  2730.  
  2731. public:
  2732.     CutDataHandle_stub(Arts::Connection *connection, long objectID);
  2733.  
  2734.     void init(Arts::DataHandle sourceHandle, long cutOffset, long cutValueCount);
  2735. };
  2736.  
  2737. class ARTS_EXPORT CutDataHandle_skel : virtual public CutDataHandle_base, virtual public Arts::DataHandle_skel {
  2738. public:
  2739.     CutDataHandle_skel();
  2740.  
  2741.     static std::string _interfaceNameSkel();
  2742.     std::string _interfaceName();
  2743.     bool _isCompatibleWith(const std::string& interfacename);
  2744.     void _buildMethodTable();
  2745.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  2746. };
  2747.  
  2748. }
  2749. #include "reference.h"
  2750. namespace Arts {
  2751. class ARTS_EXPORT CutDataHandle : public Arts::Object {
  2752. private:
  2753.     static Arts::Object_base* _Creator();
  2754.     CutDataHandle_base *_cache;
  2755.     inline CutDataHandle_base *_method_call() {
  2756.         _pool->checkcreate();
  2757.         if(_pool->base) {
  2758.             _cache=(CutDataHandle_base *)_pool->base->_cast(CutDataHandle_base::_IID);
  2759.             assert(_cache);
  2760.         }
  2761.         return _cache;
  2762.     }
  2763.  
  2764. protected:
  2765.     inline CutDataHandle(CutDataHandle_base* b) : Arts::Object(b), _cache(0) {}
  2766.  
  2767.  
  2768. public:
  2769.     typedef CutDataHandle_base _base_class;
  2770.  
  2771.     inline CutDataHandle() : Arts::Object(_Creator), _cache(0) {}
  2772.     inline CutDataHandle(const Arts::SubClass& s) :
  2773.         Arts::Object(CutDataHandle_base::_create(s.string())), _cache(0) {}
  2774.     inline CutDataHandle(const Arts::Reference &r) :
  2775.         Arts::Object(r.isString()?(CutDataHandle_base::_fromString(r.string())):(CutDataHandle_base::_fromReference(r.reference(),true))), _cache(0) {}
  2776.     inline CutDataHandle(const Arts::DynamicCast& c) : Arts::Object(CutDataHandle_base::_fromDynamicCast(c.object())), _cache(0) {}
  2777.     inline CutDataHandle(const CutDataHandle& target) : Arts::Object(target._pool), _cache(target._cache) {}
  2778.     inline CutDataHandle(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  2779.     inline static CutDataHandle null() {return CutDataHandle((CutDataHandle_base*)0);}
  2780.     inline static CutDataHandle _from_base(CutDataHandle_base* b) {return CutDataHandle(b);}
  2781.     inline CutDataHandle& operator=(const CutDataHandle& target) {
  2782.         if (_pool == target._pool) return *this;
  2783.         _pool->Dec();
  2784.         _pool = target._pool;
  2785.         _cache = target._cache;
  2786.         _pool->Inc();
  2787.         return *this;
  2788.     }
  2789.     inline operator Arts::DataHandle() const { return Arts::DataHandle(*_pool); }
  2790.     inline CutDataHandle_base* _base() {return _cache?_cache:_method_call();}
  2791.  
  2792.     inline long bitDepth();
  2793.     inline long channelCount();
  2794.     inline long valueCount();
  2795.     inline long errorNo();
  2796.     inline void init(Arts::DataHandle sourceHandle, long cutOffset, long cutValueCount);
  2797. };
  2798.  
  2799. class ARTS_EXPORT DataHandlePlay_base : virtual public Arts::SynthModule_base {
  2800. public:
  2801.     static unsigned long _IID; // interface ID
  2802.  
  2803.     static DataHandlePlay_base *_create(const std::string& subClass = "Arts::DataHandlePlay");
  2804.     static DataHandlePlay_base *_fromString(const std::string& objectref);
  2805.     static DataHandlePlay_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  2806.  
  2807.     static DataHandlePlay_base *_fromDynamicCast(const Arts::Object& object);
  2808.     inline DataHandlePlay_base *_copy() {
  2809.         assert(_refCnt > 0);
  2810.         _refCnt++;
  2811.         return this;
  2812.     }
  2813.  
  2814.     virtual std::vector<std::string> _defaultPortsIn() const;
  2815.     virtual std::vector<std::string> _defaultPortsOut() const;
  2816.  
  2817.     void *_cast(unsigned long iid);
  2818.  
  2819.     virtual Arts::DataHandle handle() = 0;
  2820.     virtual void handle(Arts::DataHandle newValue) = 0;
  2821.     virtual float mixerFrequency() = 0;
  2822.     virtual void mixerFrequency(float newValue) = 0;
  2823.     virtual long channelIndex() = 0;
  2824.     virtual void channelIndex(long newValue) = 0;
  2825.     virtual float speed() = 0;
  2826.     virtual void speed(float newValue) = 0;
  2827.     virtual long pos() = 0;
  2828.     virtual void pos(long newValue) = 0;
  2829.     virtual bool finished() = 0;
  2830.     virtual bool paused() = 0;
  2831.     virtual void paused(bool newValue) = 0;
  2832.     virtual Arts::DataHandlePlay clone() = 0;
  2833. };
  2834.  
  2835. class ARTS_EXPORT DataHandlePlay_stub : virtual public DataHandlePlay_base, virtual public Arts::SynthModule_stub {
  2836. protected:
  2837.     DataHandlePlay_stub();
  2838.  
  2839. public:
  2840.     DataHandlePlay_stub(Arts::Connection *connection, long objectID);
  2841.  
  2842.     Arts::DataHandle handle();
  2843.     void handle(Arts::DataHandle newValue);
  2844.     float mixerFrequency();
  2845.     void mixerFrequency(float newValue);
  2846.     long channelIndex();
  2847.     void channelIndex(long newValue);
  2848.     float speed();
  2849.     void speed(float newValue);
  2850.     long pos();
  2851.     void pos(long newValue);
  2852.     bool finished();
  2853.     bool paused();
  2854.     void paused(bool newValue);
  2855.     Arts::DataHandlePlay clone();
  2856. };
  2857.  
  2858. class ARTS_EXPORT DataHandlePlay_skel : virtual public DataHandlePlay_base, virtual public Arts::SynthModule_skel {
  2859. protected:
  2860.     // variables for streams
  2861.     float *outvalue;                          // outgoing stream
  2862.  
  2863. protected:
  2864.     // emitters for change notifications
  2865.     inline void mixerFrequency_changed(float newValue) {
  2866.         _emit_changed("mixerFrequency_changed",newValue);
  2867.     }
  2868.     inline void channelIndex_changed(long newValue) {
  2869.         _emit_changed("channelIndex_changed",newValue);
  2870.     }
  2871.     inline void speed_changed(float newValue) {
  2872.         _emit_changed("speed_changed",newValue);
  2873.     }
  2874.     inline void pos_changed(long newValue) {
  2875.         _emit_changed("pos_changed",newValue);
  2876.     }
  2877.     inline void finished_changed(bool newValue) {
  2878.         _emit_changed("finished_changed",newValue);
  2879.     }
  2880.     inline void paused_changed(bool newValue) {
  2881.         _emit_changed("paused_changed",newValue);
  2882.     }
  2883.  
  2884. public:
  2885.     DataHandlePlay_skel();
  2886.  
  2887.     static std::string _interfaceNameSkel();
  2888.     std::string _interfaceName();
  2889.     bool _isCompatibleWith(const std::string& interfacename);
  2890.     void _buildMethodTable();
  2891.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  2892. };
  2893.  
  2894. }
  2895. #include "reference.h"
  2896. namespace Arts {
  2897. class ARTS_EXPORT DataHandlePlay : public Arts::Object {
  2898. private:
  2899.     static Arts::Object_base* _Creator();
  2900.     DataHandlePlay_base *_cache;
  2901.     inline DataHandlePlay_base *_method_call() {
  2902.         _pool->checkcreate();
  2903.         if(_pool->base) {
  2904.             _cache=(DataHandlePlay_base *)_pool->base->_cast(DataHandlePlay_base::_IID);
  2905.             assert(_cache);
  2906.         }
  2907.         return _cache;
  2908.     }
  2909.  
  2910. protected:
  2911.     inline DataHandlePlay(DataHandlePlay_base* b) : Arts::Object(b), _cache(0) {}
  2912.  
  2913.  
  2914. public:
  2915.     typedef DataHandlePlay_base _base_class;
  2916.  
  2917.     inline DataHandlePlay() : Arts::Object(_Creator), _cache(0) {}
  2918.     inline DataHandlePlay(const Arts::SubClass& s) :
  2919.         Arts::Object(DataHandlePlay_base::_create(s.string())), _cache(0) {}
  2920.     inline DataHandlePlay(const Arts::Reference &r) :
  2921.         Arts::Object(r.isString()?(DataHandlePlay_base::_fromString(r.string())):(DataHandlePlay_base::_fromReference(r.reference(),true))), _cache(0) {}
  2922.     inline DataHandlePlay(const Arts::DynamicCast& c) : Arts::Object(DataHandlePlay_base::_fromDynamicCast(c.object())), _cache(0) {}
  2923.     inline DataHandlePlay(const DataHandlePlay& target) : Arts::Object(target._pool), _cache(target._cache) {}
  2924.     inline DataHandlePlay(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  2925.     inline static DataHandlePlay null() {return DataHandlePlay((DataHandlePlay_base*)0);}
  2926.     inline static DataHandlePlay _from_base(DataHandlePlay_base* b) {return DataHandlePlay(b);}
  2927.     inline DataHandlePlay& operator=(const DataHandlePlay& target) {
  2928.         if (_pool == target._pool) return *this;
  2929.         _pool->Dec();
  2930.         _pool = target._pool;
  2931.         _cache = target._cache;
  2932.         _pool->Inc();
  2933.         return *this;
  2934.     }
  2935.     inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
  2936.     inline DataHandlePlay_base* _base() {return _cache?_cache:_method_call();}
  2937.  
  2938.     inline Arts::AutoSuspendState autoSuspend();
  2939.     inline void start();
  2940.     inline void stop();
  2941.     inline void streamInit();
  2942.     inline void streamStart();
  2943.     inline void streamEnd();
  2944.     inline Arts::DataHandle handle();
  2945.     inline void handle(Arts::DataHandle _newValue);
  2946.     inline float mixerFrequency();
  2947.     inline void mixerFrequency(float _newValue);
  2948.     inline long channelIndex();
  2949.     inline void channelIndex(long _newValue);
  2950.     inline float speed();
  2951.     inline void speed(float _newValue);
  2952.     inline long pos();
  2953.     inline void pos(long _newValue);
  2954.     inline bool finished();
  2955.     inline bool paused();
  2956.     inline void paused(bool _newValue);
  2957.     inline Arts::DataHandlePlay clone();
  2958. };
  2959.  
  2960. class ARTS_EXPORT WaveDataHandle_base : virtual public Arts::DataHandle_base {
  2961. public:
  2962.     static unsigned long _IID; // interface ID
  2963.  
  2964.     static WaveDataHandle_base *_create(const std::string& subClass = "Arts::WaveDataHandle");
  2965.     static WaveDataHandle_base *_fromString(const std::string& objectref);
  2966.     static WaveDataHandle_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  2967.  
  2968.     static WaveDataHandle_base *_fromDynamicCast(const Arts::Object& object);
  2969.     inline WaveDataHandle_base *_copy() {
  2970.         assert(_refCnt > 0);
  2971.         _refCnt++;
  2972.         return this;
  2973.     }
  2974.  
  2975.     virtual std::vector<std::string> _defaultPortsIn() const;
  2976.     virtual std::vector<std::string> _defaultPortsOut() const;
  2977.  
  2978.     void *_cast(unsigned long iid);
  2979.  
  2980.     virtual float mixerFrequency() = 0;
  2981.     virtual float oscillatorFrequency() = 0;
  2982.     virtual bool isLoaded() = 0;
  2983.     virtual bool load(const std::string& filename) = 0;
  2984.     virtual bool load(const std::string& filename, long waveIndex, long chunkIndex) = 0;
  2985.     virtual Arts::DataHandlePlay createPlayer() = 0;
  2986. };
  2987.  
  2988. class ARTS_EXPORT WaveDataHandle_stub : virtual public WaveDataHandle_base, virtual public Arts::DataHandle_stub {
  2989. protected:
  2990.     WaveDataHandle_stub();
  2991.  
  2992. public:
  2993.     WaveDataHandle_stub(Arts::Connection *connection, long objectID);
  2994.  
  2995.     float mixerFrequency();
  2996.     float oscillatorFrequency();
  2997.     bool isLoaded();
  2998.     bool load(const std::string& filename);
  2999.     bool load(const std::string& filename, long waveIndex, long chunkIndex);
  3000.     Arts::DataHandlePlay createPlayer();
  3001. };
  3002.  
  3003. class ARTS_EXPORT WaveDataHandle_skel : virtual public WaveDataHandle_base, virtual public Arts::DataHandle_skel {
  3004. protected:
  3005.     // emitters for change notifications
  3006.     inline void mixerFrequency_changed(float newValue) {
  3007.         _emit_changed("mixerFrequency_changed",newValue);
  3008.     }
  3009.     inline void oscillatorFrequency_changed(float newValue) {
  3010.         _emit_changed("oscillatorFrequency_changed",newValue);
  3011.     }
  3012.     inline void isLoaded_changed(bool newValue) {
  3013.         _emit_changed("isLoaded_changed",newValue);
  3014.     }
  3015.  
  3016. public:
  3017.     WaveDataHandle_skel();
  3018.  
  3019.     static std::string _interfaceNameSkel();
  3020.     std::string _interfaceName();
  3021.     bool _isCompatibleWith(const std::string& interfacename);
  3022.     void _buildMethodTable();
  3023.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  3024. };
  3025.  
  3026. }
  3027. #include "reference.h"
  3028. namespace Arts {
  3029. class ARTS_EXPORT WaveDataHandle : public Arts::Object {
  3030. private:
  3031.     static Arts::Object_base* _Creator();
  3032.     WaveDataHandle_base *_cache;
  3033.     inline WaveDataHandle_base *_method_call() {
  3034.         _pool->checkcreate();
  3035.         if(_pool->base) {
  3036.             _cache=(WaveDataHandle_base *)_pool->base->_cast(WaveDataHandle_base::_IID);
  3037.             assert(_cache);
  3038.         }
  3039.         return _cache;
  3040.     }
  3041.  
  3042. protected:
  3043.     inline WaveDataHandle(WaveDataHandle_base* b) : Arts::Object(b), _cache(0) {}
  3044.  
  3045.  
  3046. public:
  3047.     typedef WaveDataHandle_base _base_class;
  3048.  
  3049.     inline WaveDataHandle() : Arts::Object(_Creator), _cache(0) {}
  3050.     inline WaveDataHandle(const Arts::SubClass& s) :
  3051.         Arts::Object(WaveDataHandle_base::_create(s.string())), _cache(0) {}
  3052.     inline WaveDataHandle(const Arts::Reference &r) :
  3053.         Arts::Object(r.isString()?(WaveDataHandle_base::_fromString(r.string())):(WaveDataHandle_base::_fromReference(r.reference(),true))), _cache(0) {}
  3054.     inline WaveDataHandle(const Arts::DynamicCast& c) : Arts::Object(WaveDataHandle_base::_fromDynamicCast(c.object())), _cache(0) {}
  3055.     inline WaveDataHandle(const WaveDataHandle& target) : Arts::Object(target._pool), _cache(target._cache) {}
  3056.     inline WaveDataHandle(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  3057.     inline static WaveDataHandle null() {return WaveDataHandle((WaveDataHandle_base*)0);}
  3058.     inline static WaveDataHandle _from_base(WaveDataHandle_base* b) {return WaveDataHandle(b);}
  3059.     inline WaveDataHandle& operator=(const WaveDataHandle& target) {
  3060.         if (_pool == target._pool) return *this;
  3061.         _pool->Dec();
  3062.         _pool = target._pool;
  3063.         _cache = target._cache;
  3064.         _pool->Inc();
  3065.         return *this;
  3066.     }
  3067.     inline operator Arts::DataHandle() const { return Arts::DataHandle(*_pool); }
  3068.     inline WaveDataHandle_base* _base() {return _cache?_cache:_method_call();}
  3069.  
  3070.     inline long bitDepth();
  3071.     inline long channelCount();
  3072.     inline long valueCount();
  3073.     inline long errorNo();
  3074.     inline float mixerFrequency();
  3075.     inline float oscillatorFrequency();
  3076.     inline bool isLoaded();
  3077.     inline bool load(const std::string& filename);
  3078.     inline bool load(const std::string& filename, long waveIndex, long chunkIndex);
  3079.     inline Arts::DataHandlePlay createPlayer();
  3080. };
  3081.  
  3082. }
  3083. // Forward wrapper calls to _base classes:
  3084.  
  3085. inline Arts::AutoSuspendState Arts::SynthModule::autoSuspend()
  3086. {
  3087.     return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
  3088. }
  3089.  
  3090. inline void Arts::SynthModule::start()
  3091. {
  3092.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
  3093. }
  3094.  
  3095. inline void Arts::SynthModule::stop()
  3096. {
  3097.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
  3098. }
  3099.  
  3100. inline void Arts::SynthModule::streamInit()
  3101. {
  3102.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
  3103. }
  3104.  
  3105. inline void Arts::SynthModule::streamStart()
  3106. {
  3107.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
  3108. }
  3109.  
  3110. inline void Arts::SynthModule::streamEnd()
  3111. {
  3112.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
  3113. }
  3114.  
  3115. inline Arts::AutoSuspendState Arts::Synth_PLAY::autoSuspend()
  3116. {
  3117.     return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
  3118. }
  3119.  
  3120. inline void Arts::Synth_PLAY::start()
  3121. {
  3122.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
  3123. }
  3124.  
  3125. inline void Arts::Synth_PLAY::stop()
  3126. {
  3127.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
  3128. }
  3129.  
  3130. inline void Arts::Synth_PLAY::streamInit()
  3131. {
  3132.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
  3133. }
  3134.  
  3135. inline void Arts::Synth_PLAY::streamStart()
  3136. {
  3137.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
  3138. }
  3139.  
  3140. inline void Arts::Synth_PLAY::streamEnd()
  3141. {
  3142.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
  3143. }
  3144.  
  3145. inline Arts::AutoSuspendState Arts::Synth_RECORD::autoSuspend()
  3146. {
  3147.     return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
  3148. }
  3149.  
  3150. inline void Arts::Synth_RECORD::start()
  3151. {
  3152.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
  3153. }
  3154.  
  3155. inline void Arts::Synth_RECORD::stop()
  3156. {
  3157.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
  3158. }
  3159.  
  3160. inline void Arts::Synth_RECORD::streamInit()
  3161. {
  3162.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
  3163. }
  3164.  
  3165. inline void Arts::Synth_RECORD::streamStart()
  3166. {
  3167.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
  3168. }
  3169.  
  3170. inline void Arts::Synth_RECORD::streamEnd()
  3171. {
  3172.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
  3173. }
  3174.  
  3175. inline Arts::AutoSuspendState Arts::Synth_FREQUENCY::autoSuspend()
  3176. {
  3177.     return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
  3178. }
  3179.  
  3180. inline void Arts::Synth_FREQUENCY::start()
  3181. {
  3182.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
  3183. }
  3184.  
  3185. inline void Arts::Synth_FREQUENCY::stop()
  3186. {
  3187.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
  3188. }
  3189.  
  3190. inline void Arts::Synth_FREQUENCY::streamInit()
  3191. {
  3192.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
  3193. }
  3194.  
  3195. inline void Arts::Synth_FREQUENCY::streamStart()
  3196. {
  3197.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
  3198. }
  3199.  
  3200. inline void Arts::Synth_FREQUENCY::streamEnd()
  3201. {
  3202.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
  3203. }
  3204.  
  3205. inline Arts::AutoSuspendState Arts::Synth_WAVE_SIN::autoSuspend()
  3206. {
  3207.     return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
  3208. }
  3209.  
  3210. inline void Arts::Synth_WAVE_SIN::start()
  3211. {
  3212.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
  3213. }
  3214.  
  3215. inline void Arts::Synth_WAVE_SIN::stop()
  3216. {
  3217.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
  3218. }
  3219.  
  3220. inline void Arts::Synth_WAVE_SIN::streamInit()
  3221. {
  3222.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
  3223. }
  3224.  
  3225. inline void Arts::Synth_WAVE_SIN::streamStart()
  3226. {
  3227.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
  3228. }
  3229.  
  3230. inline void Arts::Synth_WAVE_SIN::streamEnd()
  3231. {
  3232.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
  3233. }
  3234.  
  3235. inline Arts::AutoSuspendState Arts::Synth_MULTI_ADD::autoSuspend()
  3236. {
  3237.     return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
  3238. }
  3239.  
  3240. inline void Arts::Synth_MULTI_ADD::start()
  3241. {
  3242.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
  3243. }
  3244.  
  3245. inline void Arts::Synth_MULTI_ADD::stop()
  3246. {
  3247.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
  3248. }
  3249.  
  3250. inline void Arts::Synth_MULTI_ADD::streamInit()
  3251. {
  3252.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
  3253. }
  3254.  
  3255. inline void Arts::Synth_MULTI_ADD::streamStart()
  3256. {
  3257.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
  3258. }
  3259.  
  3260. inline void Arts::Synth_MULTI_ADD::streamEnd()
  3261. {
  3262.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
  3263. }
  3264.  
  3265. inline Arts::AutoSuspendState Arts::Synth_ADD::autoSuspend()
  3266. {
  3267.     return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
  3268. }
  3269.  
  3270. inline void Arts::Synth_ADD::start()
  3271. {
  3272.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
  3273. }
  3274.  
  3275. inline void Arts::Synth_ADD::stop()
  3276. {
  3277.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
  3278. }
  3279.  
  3280. inline void Arts::Synth_ADD::streamInit()
  3281. {
  3282.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
  3283. }
  3284.  
  3285. inline void Arts::Synth_ADD::streamStart()
  3286. {
  3287.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
  3288. }
  3289.  
  3290. inline void Arts::Synth_ADD::streamEnd()
  3291. {
  3292.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
  3293. }
  3294.  
  3295. inline Arts::AutoSuspendState Arts::Synth_MUL::autoSuspend()
  3296. {
  3297.     return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
  3298. }
  3299.  
  3300. inline void Arts::Synth_MUL::start()
  3301. {
  3302.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
  3303. }
  3304.  
  3305. inline void Arts::Synth_MUL::stop()
  3306. {
  3307.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
  3308. }
  3309.  
  3310. inline void Arts::Synth_MUL::streamInit()
  3311. {
  3312.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
  3313. }
  3314.  
  3315. inline void Arts::Synth_MUL::streamStart()
  3316. {
  3317.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
  3318. }
  3319.  
  3320. inline void Arts::Synth_MUL::streamEnd()
  3321. {
  3322.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
  3323. }
  3324.  
  3325. inline Arts::AutoSuspendState Arts::Synth_PLAY_WAV::autoSuspend()
  3326. {
  3327.     return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
  3328. }
  3329.  
  3330. inline void Arts::Synth_PLAY_WAV::start()
  3331. {
  3332.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
  3333. }
  3334.  
  3335. inline void Arts::Synth_PLAY_WAV::stop()
  3336. {
  3337.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
  3338. }
  3339.  
  3340. inline void Arts::Synth_PLAY_WAV::streamInit()
  3341. {
  3342.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
  3343. }
  3344.  
  3345. inline void Arts::Synth_PLAY_WAV::streamStart()
  3346. {
  3347.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
  3348. }
  3349.  
  3350. inline void Arts::Synth_PLAY_WAV::streamEnd()
  3351. {
  3352.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
  3353. }
  3354.  
  3355. inline float Arts::Synth_PLAY_WAV::speed()
  3356. {
  3357.     return _cache?static_cast<Arts::Synth_PLAY_WAV_base*>(_cache)->speed():static_cast<Arts::Synth_PLAY_WAV_base*>(_method_call())->speed();
  3358. }
  3359.  
  3360. inline void Arts::Synth_PLAY_WAV::speed(float _newValue)
  3361. {
  3362.      _cache?static_cast<Arts::Synth_PLAY_WAV_base*>(_cache)->speed(_newValue):static_cast<Arts::Synth_PLAY_WAV_base*>(_method_call())->speed(_newValue);
  3363. }
  3364.  
  3365. inline std::string Arts::Synth_PLAY_WAV::filename()
  3366. {
  3367.     return _cache?static_cast<Arts::Synth_PLAY_WAV_base*>(_cache)->filename():static_cast<Arts::Synth_PLAY_WAV_base*>(_method_call())->filename();
  3368. }
  3369.  
  3370. inline void Arts::Synth_PLAY_WAV::filename(const std::string& _newValue)
  3371. {
  3372.      _cache?static_cast<Arts::Synth_PLAY_WAV_base*>(_cache)->filename(_newValue):static_cast<Arts::Synth_PLAY_WAV_base*>(_method_call())->filename(_newValue);
  3373. }
  3374.  
  3375. inline bool Arts::Synth_PLAY_WAV::finished()
  3376. {
  3377.     return _cache?static_cast<Arts::Synth_PLAY_WAV_base*>(_cache)->finished():static_cast<Arts::Synth_PLAY_WAV_base*>(_method_call())->finished();
  3378. }
  3379.  
  3380. inline Arts::AutoSuspendState Arts::Synth_BUS_UPLINK::autoSuspend()
  3381. {
  3382.     return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
  3383. }
  3384.  
  3385. inline void Arts::Synth_BUS_UPLINK::start()
  3386. {
  3387.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
  3388. }
  3389.  
  3390. inline void Arts::Synth_BUS_UPLINK::stop()
  3391. {
  3392.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
  3393. }
  3394.  
  3395. inline void Arts::Synth_BUS_UPLINK::streamInit()
  3396. {
  3397.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
  3398. }
  3399.  
  3400. inline void Arts::Synth_BUS_UPLINK::streamStart()
  3401. {
  3402.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
  3403. }
  3404.  
  3405. inline void Arts::Synth_BUS_UPLINK::streamEnd()
  3406. {
  3407.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
  3408. }
  3409.  
  3410. inline std::string Arts::Synth_BUS_UPLINK::busname()
  3411. {
  3412.     return _cache?static_cast<Arts::Synth_BUS_UPLINK_base*>(_cache)->busname():static_cast<Arts::Synth_BUS_UPLINK_base*>(_method_call())->busname();
  3413. }
  3414.  
  3415. inline void Arts::Synth_BUS_UPLINK::busname(const std::string& _newValue)
  3416. {
  3417.      _cache?static_cast<Arts::Synth_BUS_UPLINK_base*>(_cache)->busname(_newValue):static_cast<Arts::Synth_BUS_UPLINK_base*>(_method_call())->busname(_newValue);
  3418. }
  3419.  
  3420. inline Arts::AutoSuspendState Arts::Synth_BUS_DOWNLINK::autoSuspend()
  3421. {
  3422.     return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
  3423. }
  3424.  
  3425. inline void Arts::Synth_BUS_DOWNLINK::start()
  3426. {
  3427.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
  3428. }
  3429.  
  3430. inline void Arts::Synth_BUS_DOWNLINK::stop()
  3431. {
  3432.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
  3433. }
  3434.  
  3435. inline void Arts::Synth_BUS_DOWNLINK::streamInit()
  3436. {
  3437.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
  3438. }
  3439.  
  3440. inline void Arts::Synth_BUS_DOWNLINK::streamStart()
  3441. {
  3442.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
  3443. }
  3444.  
  3445. inline void Arts::Synth_BUS_DOWNLINK::streamEnd()
  3446. {
  3447.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
  3448. }
  3449.  
  3450. inline std::string Arts::Synth_BUS_DOWNLINK::busname()
  3451. {
  3452.     return _cache?static_cast<Arts::Synth_BUS_DOWNLINK_base*>(_cache)->busname():static_cast<Arts::Synth_BUS_DOWNLINK_base*>(_method_call())->busname();
  3453. }
  3454.  
  3455. inline void Arts::Synth_BUS_DOWNLINK::busname(const std::string& _newValue)
  3456. {
  3457.      _cache?static_cast<Arts::Synth_BUS_DOWNLINK_base*>(_cache)->busname(_newValue):static_cast<Arts::Synth_BUS_DOWNLINK_base*>(_method_call())->busname(_newValue);
  3458. }
  3459.  
  3460. inline Arts::AutoSuspendState Arts::ByteStreamToAudio::autoSuspend()
  3461. {
  3462.     return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
  3463. }
  3464.  
  3465. inline void Arts::ByteStreamToAudio::start()
  3466. {
  3467.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
  3468. }
  3469.  
  3470. inline void Arts::ByteStreamToAudio::stop()
  3471. {
  3472.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
  3473. }
  3474.  
  3475. inline void Arts::ByteStreamToAudio::streamInit()
  3476. {
  3477.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
  3478. }
  3479.  
  3480. inline void Arts::ByteStreamToAudio::streamStart()
  3481. {
  3482.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
  3483. }
  3484.  
  3485. inline void Arts::ByteStreamToAudio::streamEnd()
  3486. {
  3487.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
  3488. }
  3489.  
  3490. inline long Arts::ByteStreamToAudio::samplingRate()
  3491. {
  3492.     return _cache?static_cast<Arts::ByteStreamToAudio_base*>(_cache)->samplingRate():static_cast<Arts::ByteStreamToAudio_base*>(_method_call())->samplingRate();
  3493. }
  3494.  
  3495. inline void Arts::ByteStreamToAudio::samplingRate(long _newValue)
  3496. {
  3497.      _cache?static_cast<Arts::ByteStreamToAudio_base*>(_cache)->samplingRate(_newValue):static_cast<Arts::ByteStreamToAudio_base*>(_method_call())->samplingRate(_newValue);
  3498. }
  3499.  
  3500. inline long Arts::ByteStreamToAudio::channels()
  3501. {
  3502.     return _cache?static_cast<Arts::ByteStreamToAudio_base*>(_cache)->channels():static_cast<Arts::ByteStreamToAudio_base*>(_method_call())->channels();
  3503. }
  3504.  
  3505. inline void Arts::ByteStreamToAudio::channels(long _newValue)
  3506. {
  3507.      _cache?static_cast<Arts::ByteStreamToAudio_base*>(_cache)->channels(_newValue):static_cast<Arts::ByteStreamToAudio_base*>(_method_call())->channels(_newValue);
  3508. }
  3509.  
  3510. inline long Arts::ByteStreamToAudio::bits()
  3511. {
  3512.     return _cache?static_cast<Arts::ByteStreamToAudio_base*>(_cache)->bits():static_cast<Arts::ByteStreamToAudio_base*>(_method_call())->bits();
  3513. }
  3514.  
  3515. inline void Arts::ByteStreamToAudio::bits(long _newValue)
  3516. {
  3517.      _cache?static_cast<Arts::ByteStreamToAudio_base*>(_cache)->bits(_newValue):static_cast<Arts::ByteStreamToAudio_base*>(_method_call())->bits(_newValue);
  3518. }
  3519.  
  3520. inline bool Arts::ByteStreamToAudio::running()
  3521. {
  3522.     return _cache?static_cast<Arts::ByteStreamToAudio_base*>(_cache)->running():static_cast<Arts::ByteStreamToAudio_base*>(_method_call())->running();
  3523. }
  3524.  
  3525. inline Arts::AutoSuspendState Arts::AudioToByteStream::autoSuspend()
  3526. {
  3527.     return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
  3528. }
  3529.  
  3530. inline void Arts::AudioToByteStream::start()
  3531. {
  3532.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
  3533. }
  3534.  
  3535. inline void Arts::AudioToByteStream::stop()
  3536. {
  3537.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
  3538. }
  3539.  
  3540. inline void Arts::AudioToByteStream::streamInit()
  3541. {
  3542.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
  3543. }
  3544.  
  3545. inline void Arts::AudioToByteStream::streamStart()
  3546. {
  3547.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
  3548. }
  3549.  
  3550. inline void Arts::AudioToByteStream::streamEnd()
  3551. {
  3552.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
  3553. }
  3554.  
  3555. inline long Arts::AudioToByteStream::samplingRate()
  3556. {
  3557.     return _cache?static_cast<Arts::AudioToByteStream_base*>(_cache)->samplingRate():static_cast<Arts::AudioToByteStream_base*>(_method_call())->samplingRate();
  3558. }
  3559.  
  3560. inline void Arts::AudioToByteStream::samplingRate(long _newValue)
  3561. {
  3562.      _cache?static_cast<Arts::AudioToByteStream_base*>(_cache)->samplingRate(_newValue):static_cast<Arts::AudioToByteStream_base*>(_method_call())->samplingRate(_newValue);
  3563. }
  3564.  
  3565. inline long Arts::AudioToByteStream::channels()
  3566. {
  3567.     return _cache?static_cast<Arts::AudioToByteStream_base*>(_cache)->channels():static_cast<Arts::AudioToByteStream_base*>(_method_call())->channels();
  3568. }
  3569.  
  3570. inline void Arts::AudioToByteStream::channels(long _newValue)
  3571. {
  3572.      _cache?static_cast<Arts::AudioToByteStream_base*>(_cache)->channels(_newValue):static_cast<Arts::AudioToByteStream_base*>(_method_call())->channels(_newValue);
  3573. }
  3574.  
  3575. inline long Arts::AudioToByteStream::bits()
  3576. {
  3577.     return _cache?static_cast<Arts::AudioToByteStream_base*>(_cache)->bits():static_cast<Arts::AudioToByteStream_base*>(_method_call())->bits();
  3578. }
  3579.  
  3580. inline void Arts::AudioToByteStream::bits(long _newValue)
  3581. {
  3582.      _cache?static_cast<Arts::AudioToByteStream_base*>(_cache)->bits(_newValue):static_cast<Arts::AudioToByteStream_base*>(_method_call())->bits(_newValue);
  3583. }
  3584.  
  3585. inline Arts::AutoSuspendState Arts::StereoEffect::autoSuspend()
  3586. {
  3587.     return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
  3588. }
  3589.  
  3590. inline void Arts::StereoEffect::start()
  3591. {
  3592.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
  3593. }
  3594.  
  3595. inline void Arts::StereoEffect::stop()
  3596. {
  3597.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
  3598. }
  3599.  
  3600. inline void Arts::StereoEffect::streamInit()
  3601. {
  3602.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
  3603. }
  3604.  
  3605. inline void Arts::StereoEffect::streamStart()
  3606. {
  3607.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
  3608. }
  3609.  
  3610. inline void Arts::StereoEffect::streamEnd()
  3611. {
  3612.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
  3613. }
  3614.  
  3615. inline Arts::AutoSuspendState Arts::StereoVolumeControl::autoSuspend()
  3616. {
  3617.     return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
  3618. }
  3619.  
  3620. inline void Arts::StereoVolumeControl::start()
  3621. {
  3622.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
  3623. }
  3624.  
  3625. inline void Arts::StereoVolumeControl::stop()
  3626. {
  3627.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
  3628. }
  3629.  
  3630. inline void Arts::StereoVolumeControl::streamInit()
  3631. {
  3632.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
  3633. }
  3634.  
  3635. inline void Arts::StereoVolumeControl::streamStart()
  3636. {
  3637.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
  3638. }
  3639.  
  3640. inline void Arts::StereoVolumeControl::streamEnd()
  3641. {
  3642.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
  3643. }
  3644.  
  3645. inline float Arts::StereoVolumeControl::scaleFactor()
  3646. {
  3647.     return _cache?static_cast<Arts::StereoVolumeControl_base*>(_cache)->scaleFactor():static_cast<Arts::StereoVolumeControl_base*>(_method_call())->scaleFactor();
  3648. }
  3649.  
  3650. inline void Arts::StereoVolumeControl::scaleFactor(float _newValue)
  3651. {
  3652.      _cache?static_cast<Arts::StereoVolumeControl_base*>(_cache)->scaleFactor(_newValue):static_cast<Arts::StereoVolumeControl_base*>(_method_call())->scaleFactor(_newValue);
  3653. }
  3654.  
  3655. inline float Arts::StereoVolumeControl::currentVolumeLeft()
  3656. {
  3657.     return _cache?static_cast<Arts::StereoVolumeControl_base*>(_cache)->currentVolumeLeft():static_cast<Arts::StereoVolumeControl_base*>(_method_call())->currentVolumeLeft();
  3658. }
  3659.  
  3660. inline float Arts::StereoVolumeControl::currentVolumeRight()
  3661. {
  3662.     return _cache?static_cast<Arts::StereoVolumeControl_base*>(_cache)->currentVolumeRight():static_cast<Arts::StereoVolumeControl_base*>(_method_call())->currentVolumeRight();
  3663. }
  3664.  
  3665. inline Arts::AutoSuspendState Arts::StereoFFTScope::autoSuspend()
  3666. {
  3667.     return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
  3668. }
  3669.  
  3670. inline void Arts::StereoFFTScope::start()
  3671. {
  3672.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
  3673. }
  3674.  
  3675. inline void Arts::StereoFFTScope::stop()
  3676. {
  3677.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
  3678. }
  3679.  
  3680. inline void Arts::StereoFFTScope::streamInit()
  3681. {
  3682.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
  3683. }
  3684.  
  3685. inline void Arts::StereoFFTScope::streamStart()
  3686. {
  3687.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
  3688. }
  3689.  
  3690. inline void Arts::StereoFFTScope::streamEnd()
  3691. {
  3692.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
  3693. }
  3694.  
  3695. inline std::vector<float> * Arts::StereoFFTScope::scope()
  3696. {
  3697.     return _cache?static_cast<Arts::StereoFFTScope_base*>(_cache)->scope():static_cast<Arts::StereoFFTScope_base*>(_method_call())->scope();
  3698. }
  3699.  
  3700. inline Arts::AutoSuspendState Arts::StereoEffectStack::autoSuspend()
  3701. {
  3702.     return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
  3703. }
  3704.  
  3705. inline void Arts::StereoEffectStack::start()
  3706. {
  3707.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
  3708. }
  3709.  
  3710. inline void Arts::StereoEffectStack::stop()
  3711. {
  3712.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
  3713. }
  3714.  
  3715. inline void Arts::StereoEffectStack::streamInit()
  3716. {
  3717.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
  3718. }
  3719.  
  3720. inline void Arts::StereoEffectStack::streamStart()
  3721. {
  3722.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
  3723. }
  3724.  
  3725. inline void Arts::StereoEffectStack::streamEnd()
  3726. {
  3727.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
  3728. }
  3729.  
  3730. inline long Arts::StereoEffectStack::insertTop(Arts::StereoEffect effect, const std::string& name)
  3731. {
  3732.     return _cache?static_cast<Arts::StereoEffectStack_base*>(_cache)->insertTop(effect, name):static_cast<Arts::StereoEffectStack_base*>(_method_call())->insertTop(effect, name);
  3733. }
  3734.  
  3735. inline long Arts::StereoEffectStack::insertBottom(Arts::StereoEffect effect, const std::string& name)
  3736. {
  3737.     return _cache?static_cast<Arts::StereoEffectStack_base*>(_cache)->insertBottom(effect, name):static_cast<Arts::StereoEffectStack_base*>(_method_call())->insertBottom(effect, name);
  3738. }
  3739.  
  3740. inline void Arts::StereoEffectStack::remove(long ID)
  3741. {
  3742.      _cache?static_cast<Arts::StereoEffectStack_base*>(_cache)->remove(ID):static_cast<Arts::StereoEffectStack_base*>(_method_call())->remove(ID);
  3743. }
  3744.  
  3745. inline long Arts::AudioManagerClient::ID()
  3746. {
  3747.     return _cache?static_cast<Arts::AudioManagerClient_base*>(_cache)->ID():static_cast<Arts::AudioManagerClient_base*>(_method_call())->ID();
  3748. }
  3749.  
  3750. inline Arts::AudioManagerDirection Arts::AudioManagerClient::direction()
  3751. {
  3752.     return _cache?static_cast<Arts::AudioManagerClient_base*>(_cache)->direction():static_cast<Arts::AudioManagerClient_base*>(_method_call())->direction();
  3753. }
  3754.  
  3755. inline void Arts::AudioManagerClient::direction(Arts::AudioManagerDirection _newValue)
  3756. {
  3757.      _cache?static_cast<Arts::AudioManagerClient_base*>(_cache)->direction(_newValue):static_cast<Arts::AudioManagerClient_base*>(_method_call())->direction(_newValue);
  3758. }
  3759.  
  3760. inline std::string Arts::AudioManagerClient::title()
  3761. {
  3762.     return _cache?static_cast<Arts::AudioManagerClient_base*>(_cache)->title():static_cast<Arts::AudioManagerClient_base*>(_method_call())->title();
  3763. }
  3764.  
  3765. inline void Arts::AudioManagerClient::title(const std::string& _newValue)
  3766. {
  3767.      _cache?static_cast<Arts::AudioManagerClient_base*>(_cache)->title(_newValue):static_cast<Arts::AudioManagerClient_base*>(_method_call())->title(_newValue);
  3768. }
  3769.  
  3770. inline std::string Arts::AudioManagerClient::autoRestoreID()
  3771. {
  3772.     return _cache?static_cast<Arts::AudioManagerClient_base*>(_cache)->autoRestoreID():static_cast<Arts::AudioManagerClient_base*>(_method_call())->autoRestoreID();
  3773. }
  3774.  
  3775. inline void Arts::AudioManagerClient::autoRestoreID(const std::string& _newValue)
  3776. {
  3777.      _cache?static_cast<Arts::AudioManagerClient_base*>(_cache)->autoRestoreID(_newValue):static_cast<Arts::AudioManagerClient_base*>(_method_call())->autoRestoreID(_newValue);
  3778. }
  3779.  
  3780. inline Arts::AudioManagerClient::AudioManagerClient(Arts::AudioManagerDirection direction, const std::string& title, const std::string& autoRestoreID)
  3781.         : Arts::Object(AudioManagerClient_base::_create())
  3782. {
  3783.     static_cast<Arts::AudioManagerClient_base*>(_method_call())->constructor(direction, title, autoRestoreID);
  3784. }
  3785.  
  3786. inline std::vector<std::string> * Arts::AudioManager::destinations()
  3787. {
  3788.     return _cache?static_cast<Arts::AudioManager_base*>(_cache)->destinations():static_cast<Arts::AudioManager_base*>(_method_call())->destinations();
  3789. }
  3790.  
  3791. inline std::vector<Arts::AudioManagerInfo> * Arts::AudioManager::clients()
  3792. {
  3793.     return _cache?static_cast<Arts::AudioManager_base*>(_cache)->clients():static_cast<Arts::AudioManager_base*>(_method_call())->clients();
  3794. }
  3795.  
  3796. inline long Arts::AudioManager::changes()
  3797. {
  3798.     return _cache?static_cast<Arts::AudioManager_base*>(_cache)->changes():static_cast<Arts::AudioManager_base*>(_method_call())->changes();
  3799. }
  3800.  
  3801. inline void Arts::AudioManager::setDestination(long ID, const std::string& destination)
  3802. {
  3803.      _cache?static_cast<Arts::AudioManager_base*>(_cache)->setDestination(ID, destination):static_cast<Arts::AudioManager_base*>(_method_call())->setDestination(ID, destination);
  3804. }
  3805.  
  3806. inline Arts::AutoSuspendState Arts::Synth_AMAN_PLAY::autoSuspend()
  3807. {
  3808.     return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
  3809. }
  3810.  
  3811. inline void Arts::Synth_AMAN_PLAY::start()
  3812. {
  3813.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
  3814. }
  3815.  
  3816. inline void Arts::Synth_AMAN_PLAY::stop()
  3817. {
  3818.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
  3819. }
  3820.  
  3821. inline void Arts::Synth_AMAN_PLAY::streamInit()
  3822. {
  3823.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
  3824. }
  3825.  
  3826. inline void Arts::Synth_AMAN_PLAY::streamStart()
  3827. {
  3828.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
  3829. }
  3830.  
  3831. inline void Arts::Synth_AMAN_PLAY::streamEnd()
  3832. {
  3833.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
  3834. }
  3835.  
  3836. inline std::string Arts::Synth_AMAN_PLAY::title()
  3837. {
  3838.     return _cache?static_cast<Arts::Synth_AMAN_PLAY_base*>(_cache)->title():static_cast<Arts::Synth_AMAN_PLAY_base*>(_method_call())->title();
  3839. }
  3840.  
  3841. inline void Arts::Synth_AMAN_PLAY::title(const std::string& _newValue)
  3842. {
  3843.      _cache?static_cast<Arts::Synth_AMAN_PLAY_base*>(_cache)->title(_newValue):static_cast<Arts::Synth_AMAN_PLAY_base*>(_method_call())->title(_newValue);
  3844. }
  3845.  
  3846. inline std::string Arts::Synth_AMAN_PLAY::autoRestoreID()
  3847. {
  3848.     return _cache?static_cast<Arts::Synth_AMAN_PLAY_base*>(_cache)->autoRestoreID():static_cast<Arts::Synth_AMAN_PLAY_base*>(_method_call())->autoRestoreID();
  3849. }
  3850.  
  3851. inline void Arts::Synth_AMAN_PLAY::autoRestoreID(const std::string& _newValue)
  3852. {
  3853.      _cache?static_cast<Arts::Synth_AMAN_PLAY_base*>(_cache)->autoRestoreID(_newValue):static_cast<Arts::Synth_AMAN_PLAY_base*>(_method_call())->autoRestoreID(_newValue);
  3854. }
  3855.  
  3856. inline Arts::Synth_AMAN_PLAY::Synth_AMAN_PLAY(Arts::AudioManagerClient client)
  3857.         : Arts::Object(Synth_AMAN_PLAY_base::_create())
  3858. {
  3859.     static_cast<Arts::Synth_AMAN_PLAY_base*>(_method_call())->constructor(client);
  3860. }
  3861.  
  3862. inline Arts::AutoSuspendState Arts::Synth_AMAN_RECORD::autoSuspend()
  3863. {
  3864.     return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
  3865. }
  3866.  
  3867. inline void Arts::Synth_AMAN_RECORD::start()
  3868. {
  3869.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
  3870. }
  3871.  
  3872. inline void Arts::Synth_AMAN_RECORD::stop()
  3873. {
  3874.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
  3875. }
  3876.  
  3877. inline void Arts::Synth_AMAN_RECORD::streamInit()
  3878. {
  3879.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
  3880. }
  3881.  
  3882. inline void Arts::Synth_AMAN_RECORD::streamStart()
  3883. {
  3884.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
  3885. }
  3886.  
  3887. inline void Arts::Synth_AMAN_RECORD::streamEnd()
  3888. {
  3889.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
  3890. }
  3891.  
  3892. inline std::string Arts::Synth_AMAN_RECORD::title()
  3893. {
  3894.     return _cache?static_cast<Arts::Synth_AMAN_RECORD_base*>(_cache)->title():static_cast<Arts::Synth_AMAN_RECORD_base*>(_method_call())->title();
  3895. }
  3896.  
  3897. inline void Arts::Synth_AMAN_RECORD::title(const std::string& _newValue)
  3898. {
  3899.      _cache?static_cast<Arts::Synth_AMAN_RECORD_base*>(_cache)->title(_newValue):static_cast<Arts::Synth_AMAN_RECORD_base*>(_method_call())->title(_newValue);
  3900. }
  3901.  
  3902. inline std::string Arts::Synth_AMAN_RECORD::autoRestoreID()
  3903. {
  3904.     return _cache?static_cast<Arts::Synth_AMAN_RECORD_base*>(_cache)->autoRestoreID():static_cast<Arts::Synth_AMAN_RECORD_base*>(_method_call())->autoRestoreID();
  3905. }
  3906.  
  3907. inline void Arts::Synth_AMAN_RECORD::autoRestoreID(const std::string& _newValue)
  3908. {
  3909.      _cache?static_cast<Arts::Synth_AMAN_RECORD_base*>(_cache)->autoRestoreID(_newValue):static_cast<Arts::Synth_AMAN_RECORD_base*>(_method_call())->autoRestoreID(_newValue);
  3910. }
  3911.  
  3912. inline Arts::Synth_AMAN_RECORD::Synth_AMAN_RECORD(Arts::AudioManagerClient client)
  3913.         : Arts::Object(Synth_AMAN_RECORD_base::_create())
  3914. {
  3915.     static_cast<Arts::Synth_AMAN_RECORD_base*>(_method_call())->constructor(client);
  3916. }
  3917.  
  3918. inline long Arts::DataHandle::bitDepth()
  3919. {
  3920.     return _cache?static_cast<Arts::DataHandle_base*>(_cache)->bitDepth():static_cast<Arts::DataHandle_base*>(_method_call())->bitDepth();
  3921. }
  3922.  
  3923. inline long Arts::DataHandle::channelCount()
  3924. {
  3925.     return _cache?static_cast<Arts::DataHandle_base*>(_cache)->channelCount():static_cast<Arts::DataHandle_base*>(_method_call())->channelCount();
  3926. }
  3927.  
  3928. inline long Arts::DataHandle::valueCount()
  3929. {
  3930.     return _cache?static_cast<Arts::DataHandle_base*>(_cache)->valueCount():static_cast<Arts::DataHandle_base*>(_method_call())->valueCount();
  3931. }
  3932.  
  3933. inline long Arts::DataHandle::errorNo()
  3934. {
  3935.     return _cache?static_cast<Arts::DataHandle_base*>(_cache)->errorNo():static_cast<Arts::DataHandle_base*>(_method_call())->errorNo();
  3936. }
  3937.  
  3938. inline long Arts::ReversedDataHandle::bitDepth()
  3939. {
  3940.     return _cache?static_cast<Arts::DataHandle_base*>(_cache)->bitDepth():static_cast<Arts::DataHandle_base*>(_method_call())->bitDepth();
  3941. }
  3942.  
  3943. inline long Arts::ReversedDataHandle::channelCount()
  3944. {
  3945.     return _cache?static_cast<Arts::DataHandle_base*>(_cache)->channelCount():static_cast<Arts::DataHandle_base*>(_method_call())->channelCount();
  3946. }
  3947.  
  3948. inline long Arts::ReversedDataHandle::valueCount()
  3949. {
  3950.     return _cache?static_cast<Arts::DataHandle_base*>(_cache)->valueCount():static_cast<Arts::DataHandle_base*>(_method_call())->valueCount();
  3951. }
  3952.  
  3953. inline long Arts::ReversedDataHandle::errorNo()
  3954. {
  3955.     return _cache?static_cast<Arts::DataHandle_base*>(_cache)->errorNo():static_cast<Arts::DataHandle_base*>(_method_call())->errorNo();
  3956. }
  3957.  
  3958. inline void Arts::ReversedDataHandle::init(Arts::DataHandle sourceHandle)
  3959. {
  3960.      _cache?static_cast<Arts::ReversedDataHandle_base*>(_cache)->init(sourceHandle):static_cast<Arts::ReversedDataHandle_base*>(_method_call())->init(sourceHandle);
  3961. }
  3962.  
  3963. inline long Arts::CroppedDataHandle::bitDepth()
  3964. {
  3965.     return _cache?static_cast<Arts::DataHandle_base*>(_cache)->bitDepth():static_cast<Arts::DataHandle_base*>(_method_call())->bitDepth();
  3966. }
  3967.  
  3968. inline long Arts::CroppedDataHandle::channelCount()
  3969. {
  3970.     return _cache?static_cast<Arts::DataHandle_base*>(_cache)->channelCount():static_cast<Arts::DataHandle_base*>(_method_call())->channelCount();
  3971. }
  3972.  
  3973. inline long Arts::CroppedDataHandle::valueCount()
  3974. {
  3975.     return _cache?static_cast<Arts::DataHandle_base*>(_cache)->valueCount():static_cast<Arts::DataHandle_base*>(_method_call())->valueCount();
  3976. }
  3977.  
  3978. inline long Arts::CroppedDataHandle::errorNo()
  3979. {
  3980.     return _cache?static_cast<Arts::DataHandle_base*>(_cache)->errorNo():static_cast<Arts::DataHandle_base*>(_method_call())->errorNo();
  3981. }
  3982.  
  3983. inline void Arts::CroppedDataHandle::init(Arts::DataHandle sourceHandle, long headCutValueCount, long tailCutValueCount)
  3984. {
  3985.      _cache?static_cast<Arts::CroppedDataHandle_base*>(_cache)->init(sourceHandle, headCutValueCount, tailCutValueCount):static_cast<Arts::CroppedDataHandle_base*>(_method_call())->init(sourceHandle, headCutValueCount, tailCutValueCount);
  3986. }
  3987.  
  3988. inline long Arts::CutDataHandle::bitDepth()
  3989. {
  3990.     return _cache?static_cast<Arts::DataHandle_base*>(_cache)->bitDepth():static_cast<Arts::DataHandle_base*>(_method_call())->bitDepth();
  3991. }
  3992.  
  3993. inline long Arts::CutDataHandle::channelCount()
  3994. {
  3995.     return _cache?static_cast<Arts::DataHandle_base*>(_cache)->channelCount():static_cast<Arts::DataHandle_base*>(_method_call())->channelCount();
  3996. }
  3997.  
  3998. inline long Arts::CutDataHandle::valueCount()
  3999. {
  4000.     return _cache?static_cast<Arts::DataHandle_base*>(_cache)->valueCount():static_cast<Arts::DataHandle_base*>(_method_call())->valueCount();
  4001. }
  4002.  
  4003. inline long Arts::CutDataHandle::errorNo()
  4004. {
  4005.     return _cache?static_cast<Arts::DataHandle_base*>(_cache)->errorNo():static_cast<Arts::DataHandle_base*>(_method_call())->errorNo();
  4006. }
  4007.  
  4008. inline void Arts::CutDataHandle::init(Arts::DataHandle sourceHandle, long cutOffset, long cutValueCount)
  4009. {
  4010.      _cache?static_cast<Arts::CutDataHandle_base*>(_cache)->init(sourceHandle, cutOffset, cutValueCount):static_cast<Arts::CutDataHandle_base*>(_method_call())->init(sourceHandle, cutOffset, cutValueCount);
  4011. }
  4012.  
  4013. inline Arts::AutoSuspendState Arts::DataHandlePlay::autoSuspend()
  4014. {
  4015.     return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
  4016. }
  4017.  
  4018. inline void Arts::DataHandlePlay::start()
  4019. {
  4020.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
  4021. }
  4022.  
  4023. inline void Arts::DataHandlePlay::stop()
  4024. {
  4025.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
  4026. }
  4027.  
  4028. inline void Arts::DataHandlePlay::streamInit()
  4029. {
  4030.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
  4031. }
  4032.  
  4033. inline void Arts::DataHandlePlay::streamStart()
  4034. {
  4035.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
  4036. }
  4037.  
  4038. inline void Arts::DataHandlePlay::streamEnd()
  4039. {
  4040.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
  4041. }
  4042.  
  4043. inline Arts::DataHandle Arts::DataHandlePlay::handle()
  4044. {
  4045.     return _cache?static_cast<Arts::DataHandlePlay_base*>(_cache)->handle():static_cast<Arts::DataHandlePlay_base*>(_method_call())->handle();
  4046. }
  4047.  
  4048. inline void Arts::DataHandlePlay::handle(Arts::DataHandle _newValue)
  4049. {
  4050.      _cache?static_cast<Arts::DataHandlePlay_base*>(_cache)->handle(_newValue):static_cast<Arts::DataHandlePlay_base*>(_method_call())->handle(_newValue);
  4051. }
  4052.  
  4053. inline float Arts::DataHandlePlay::mixerFrequency()
  4054. {
  4055.     return _cache?static_cast<Arts::DataHandlePlay_base*>(_cache)->mixerFrequency():static_cast<Arts::DataHandlePlay_base*>(_method_call())->mixerFrequency();
  4056. }
  4057.  
  4058. inline void Arts::DataHandlePlay::mixerFrequency(float _newValue)
  4059. {
  4060.      _cache?static_cast<Arts::DataHandlePlay_base*>(_cache)->mixerFrequency(_newValue):static_cast<Arts::DataHandlePlay_base*>(_method_call())->mixerFrequency(_newValue);
  4061. }
  4062.  
  4063. inline long Arts::DataHandlePlay::channelIndex()
  4064. {
  4065.     return _cache?static_cast<Arts::DataHandlePlay_base*>(_cache)->channelIndex():static_cast<Arts::DataHandlePlay_base*>(_method_call())->channelIndex();
  4066. }
  4067.  
  4068. inline void Arts::DataHandlePlay::channelIndex(long _newValue)
  4069. {
  4070.      _cache?static_cast<Arts::DataHandlePlay_base*>(_cache)->channelIndex(_newValue):static_cast<Arts::DataHandlePlay_base*>(_method_call())->channelIndex(_newValue);
  4071. }
  4072.  
  4073. inline float Arts::DataHandlePlay::speed()
  4074. {
  4075.     return _cache?static_cast<Arts::DataHandlePlay_base*>(_cache)->speed():static_cast<Arts::DataHandlePlay_base*>(_method_call())->speed();
  4076. }
  4077.  
  4078. inline void Arts::DataHandlePlay::speed(float _newValue)
  4079. {
  4080.      _cache?static_cast<Arts::DataHandlePlay_base*>(_cache)->speed(_newValue):static_cast<Arts::DataHandlePlay_base*>(_method_call())->speed(_newValue);
  4081. }
  4082.  
  4083. inline long Arts::DataHandlePlay::pos()
  4084. {
  4085.     return _cache?static_cast<Arts::DataHandlePlay_base*>(_cache)->pos():static_cast<Arts::DataHandlePlay_base*>(_method_call())->pos();
  4086. }
  4087.  
  4088. inline void Arts::DataHandlePlay::pos(long _newValue)
  4089. {
  4090.      _cache?static_cast<Arts::DataHandlePlay_base*>(_cache)->pos(_newValue):static_cast<Arts::DataHandlePlay_base*>(_method_call())->pos(_newValue);
  4091. }
  4092.  
  4093. inline bool Arts::DataHandlePlay::finished()
  4094. {
  4095.     return _cache?static_cast<Arts::DataHandlePlay_base*>(_cache)->finished():static_cast<Arts::DataHandlePlay_base*>(_method_call())->finished();
  4096. }
  4097.  
  4098. inline bool Arts::DataHandlePlay::paused()
  4099. {
  4100.     return _cache?static_cast<Arts::DataHandlePlay_base*>(_cache)->paused():static_cast<Arts::DataHandlePlay_base*>(_method_call())->paused();
  4101. }
  4102.  
  4103. inline void Arts::DataHandlePlay::paused(bool _newValue)
  4104. {
  4105.      _cache?static_cast<Arts::DataHandlePlay_base*>(_cache)->paused(_newValue):static_cast<Arts::DataHandlePlay_base*>(_method_call())->paused(_newValue);
  4106. }
  4107.  
  4108. inline Arts::DataHandlePlay Arts::DataHandlePlay::clone()
  4109. {
  4110.     return _cache?static_cast<Arts::DataHandlePlay_base*>(_cache)->clone():static_cast<Arts::DataHandlePlay_base*>(_method_call())->clone();
  4111. }
  4112.  
  4113. inline long Arts::WaveDataHandle::bitDepth()
  4114. {
  4115.     return _cache?static_cast<Arts::DataHandle_base*>(_cache)->bitDepth():static_cast<Arts::DataHandle_base*>(_method_call())->bitDepth();
  4116. }
  4117.  
  4118. inline long Arts::WaveDataHandle::channelCount()
  4119. {
  4120.     return _cache?static_cast<Arts::DataHandle_base*>(_cache)->channelCount():static_cast<Arts::DataHandle_base*>(_method_call())->channelCount();
  4121. }
  4122.  
  4123. inline long Arts::WaveDataHandle::valueCount()
  4124. {
  4125.     return _cache?static_cast<Arts::DataHandle_base*>(_cache)->valueCount():static_cast<Arts::DataHandle_base*>(_method_call())->valueCount();
  4126. }
  4127.  
  4128. inline long Arts::WaveDataHandle::errorNo()
  4129. {
  4130.     return _cache?static_cast<Arts::DataHandle_base*>(_cache)->errorNo():static_cast<Arts::DataHandle_base*>(_method_call())->errorNo();
  4131. }
  4132.  
  4133. inline float Arts::WaveDataHandle::mixerFrequency()
  4134. {
  4135.     return _cache?static_cast<Arts::WaveDataHandle_base*>(_cache)->mixerFrequency():static_cast<Arts::WaveDataHandle_base*>(_method_call())->mixerFrequency();
  4136. }
  4137.  
  4138. inline float Arts::WaveDataHandle::oscillatorFrequency()
  4139. {
  4140.     return _cache?static_cast<Arts::WaveDataHandle_base*>(_cache)->oscillatorFrequency():static_cast<Arts::WaveDataHandle_base*>(_method_call())->oscillatorFrequency();
  4141. }
  4142.  
  4143. inline bool Arts::WaveDataHandle::isLoaded()
  4144. {
  4145.     return _cache?static_cast<Arts::WaveDataHandle_base*>(_cache)->isLoaded():static_cast<Arts::WaveDataHandle_base*>(_method_call())->isLoaded();
  4146. }
  4147.  
  4148. inline bool Arts::WaveDataHandle::load(const std::string& filename)
  4149. {
  4150.     return _cache?static_cast<Arts::WaveDataHandle_base*>(_cache)->load(filename):static_cast<Arts::WaveDataHandle_base*>(_method_call())->load(filename);
  4151. }
  4152.  
  4153. inline bool Arts::WaveDataHandle::load(const std::string& filename, long waveIndex, long chunkIndex)
  4154. {
  4155.     return _cache?static_cast<Arts::WaveDataHandle_base*>(_cache)->load(filename, waveIndex, chunkIndex):static_cast<Arts::WaveDataHandle_base*>(_method_call())->load(filename, waveIndex, chunkIndex);
  4156. }
  4157.  
  4158. inline Arts::DataHandlePlay Arts::WaveDataHandle::createPlayer()
  4159. {
  4160.     return _cache?static_cast<Arts::WaveDataHandle_base*>(_cache)->createPlayer():static_cast<Arts::WaveDataHandle_base*>(_method_call())->createPlayer();
  4161. }
  4162.  
  4163. #endif /* ARTSFLOW_H */
  4164.