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/artsmodulessynth.h

C/C++ Source or Header | 2008-10-24 | 200.8 KB | 5,732 lines

/* this file was generated by the MCOP idl compiler - DO NOT EDIT */

#ifndef ARTSMODULESSYNTH_H
#define ARTSMODULESSYNTH_H

#include "common.h"

#include "arts_export.h"

// includes of other idl definitions
#include "artsflow.h"
#include "artsmidi.h"

namespace Arts {
enum SynthOscWaveForm {soWaveSine = 0, soWaveTriangle = 1, soWaveSawRise = 2, soWaveSawFall = 3, soWavePeakRise = 4, soWavePeakFall = 5, soWaveMoogSaw = 6, soWaveSquare = 7, soWavePulseSaw = 8};
}
namespace Arts {
class Synth_DIV;
class Synth_XFADE;
class Synth_AUTOPANNER;
class Synth_DELAY;
class Synth_CDELAY;
class Synth_ENVELOPE_ADSR;
class Synth_PSCALE;
class Synth_TREMOLO;
class Synth_FX_CFLANGER;
class Synth_COMPRESSOR;
class Synth_PITCH_SHIFT;
class Synth_PITCH_SHIFT_FFT;
class Synth_SHELVE_CUTOFF;
class Synth_BRICKWALL_LIMITER;
class Synth_STD_EQUALIZER;
class Synth_RC;
class Synth_MOOG_VCF;
class Synth_ATAN_SATURATE;
class Synth_MIDI_TEST;
class Synth_SEQUENCE;
class Synth_SEQUENCE_FREQ;
class Synth_FM_SOURCE;
class Synth_WAVE_TRI;
class Synth_NOISE;
class Synth_WAVE_SQUARE;
class Synth_WAVE_SOFTSAW;
class Synth_WAVE_PULSE;
class Synth_OSC;
class Synth_PLAY_PAT;
class Synth_CAPTURE_WAV;
class Synth_NIL;
class Synth_DEBUG;
class Synth_DATA;
class Synth_MIDI_DEBUG;
class ObjectCache;
class MidiReleaseHelper;

class ARTS_EXPORT Synth_DIV_base : virtual public Arts::SynthModule_base {
public:
    static unsigned long _IID; // interface ID

    static Synth_DIV_base *_create(const std::string& subClass = "Arts::Synth_DIV");
    static Synth_DIV_base *_fromString(const std::string& objectref);
    static Synth_DIV_base *_fromReference(Arts::ObjectReference ref, bool needcopy);

    static Synth_DIV_base *_fromDynamicCast(const Arts::Object& object);
    inline Synth_DIV_base *_copy() {
        assert(_refCnt > 0);
        _refCnt++;
        return this;
    }

    virtual std::vector<std::string> _defaultPortsIn() const;
    virtual std::vector<std::string> _defaultPortsOut() const;

    void *_cast(unsigned long iid);

};

class ARTS_EXPORT Synth_DIV_stub : virtual public Synth_DIV_base, virtual public Arts::SynthModule_stub {
protected:
    Synth_DIV_stub();

public:
    Synth_DIV_stub(Arts::Connection *connection, long objectID);

};

class ARTS_EXPORT Synth_DIV_skel : virtual public Synth_DIV_base, virtual public Arts::SynthModule_skel {
protected:
    // variables for streams
    float *invalue1;                          // incoming stream
    float *invalue2;                          // incoming stream
    float *outvalue;                          // outgoing stream

public:
    Synth_DIV_skel();

    static std::string _interfaceNameSkel();
    std::string _interfaceName();
    bool _isCompatibleWith(const std::string& interfacename);
    void _buildMethodTable();
    void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
};

}
#include "reference.h"
namespace Arts {
class ARTS_EXPORT Synth_DIV : public Arts::Object {
private:
    static Arts::Object_base* _Creator();
    Synth_DIV_base *_cache;
    inline Synth_DIV_base *_method_call() {
        _pool->checkcreate();
        if(_pool->base) {
            _cache=(Synth_DIV_base *)_pool->base->_cast(Synth_DIV_base::_IID);
            assert(_cache);
        }
        return _cache;
    }

protected:
    inline Synth_DIV(Synth_DIV_base* b) : Arts::Object(b), _cache(0) {}


public:
    typedef Synth_DIV_base _base_class;

    inline Synth_DIV() : Arts::Object(_Creator), _cache(0) {}
    inline Synth_DIV(const Arts::SubClass& s) :
        Arts::Object(Synth_DIV_base::_create(s.string())), _cache(0) {}
    inline Synth_DIV(const Arts::Reference &r) :
        Arts::Object(r.isString()?(Synth_DIV_base::_fromString(r.string())):(Synth_DIV_base::_fromReference(r.reference(),true))), _cache(0) {}
    inline Synth_DIV(const Arts::DynamicCast& c) : Arts::Object(Synth_DIV_base::_fromDynamicCast(c.object())), _cache(0) {}
    inline Synth_DIV(const Synth_DIV& target) : Arts::Object(target._pool), _cache(target._cache) {}
    inline Synth_DIV(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
    inline static Synth_DIV null() {return Synth_DIV((Synth_DIV_base*)0);}
    inline static Synth_DIV _from_base(Synth_DIV_base* b) {return Synth_DIV(b);}
    inline Synth_DIV& operator=(const Synth_DIV& target) {
        if (_pool == target._pool) return *this;
        _pool->Dec();
        _pool = target._pool;
        _cache = target._cache;
        _pool->Inc();
        return *this;
    }
    inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
    inline Synth_DIV_base* _base() {return _cache?_cache:_method_call();}

    inline Arts::AutoSuspendState autoSuspend();
    inline void start();
    inline void stop();
    inline void streamInit();
    inline void streamStart();
    inline void streamEnd();
};

class ARTS_EXPORT Synth_XFADE_base : virtual public Arts::SynthModule_base {
public:
    static unsigned long _IID; // interface ID

    static Synth_XFADE_base *_create(const std::string& subClass = "Arts::Synth_XFADE");
    static Synth_XFADE_base *_fromString(const std::string& objectref);
    static Synth_XFADE_base *_fromReference(Arts::ObjectReference ref, bool needcopy);

    static Synth_XFADE_base *_fromDynamicCast(const Arts::Object& object);
    inline Synth_XFADE_base *_copy() {
        assert(_refCnt > 0);
        _refCnt++;
        return this;
    }

    virtual std::vector<std::string> _defaultPortsIn() const;
    virtual std::vector<std::string> _defaultPortsOut() const;

    void *_cast(unsigned long iid);

};

class ARTS_EXPORT Synth_XFADE_stub : virtual public Synth_XFADE_base, virtual public Arts::SynthModule_stub {
protected:
    Synth_XFADE_stub();

public:
    Synth_XFADE_stub(Arts::Connection *connection, long objectID);

};

class ARTS_EXPORT Synth_XFADE_skel : virtual public Synth_XFADE_base, virtual public Arts::SynthModule_skel {
protected:
    // variables for streams
    float *invalue1;                          // incoming stream
    float *invalue2;                          // incoming stream
    float *percentage;                        // incoming stream
    float *outvalue;                          // outgoing stream

public:
    Synth_XFADE_skel();

    static std::string _interfaceNameSkel();
    std::string _interfaceName();
    bool _isCompatibleWith(const std::string& interfacename);
    void _buildMethodTable();
    void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
};

}
#include "reference.h"
namespace Arts {
class ARTS_EXPORT Synth_XFADE : public Arts::Object {
private:
    static Arts::Object_base* _Creator();
    Synth_XFADE_base *_cache;
    inline Synth_XFADE_base *_method_call() {
        _pool->checkcreate();
        if(_pool->base) {
            _cache=(Synth_XFADE_base *)_pool->base->_cast(Synth_XFADE_base::_IID);
            assert(_cache);
        }
        return _cache;
    }

protected:
    inline Synth_XFADE(Synth_XFADE_base* b) : Arts::Object(b), _cache(0) {}


public:
    typedef Synth_XFADE_base _base_class;

    inline Synth_XFADE() : Arts::Object(_Creator), _cache(0) {}
    inline Synth_XFADE(const Arts::SubClass& s) :
        Arts::Object(Synth_XFADE_base::_create(s.string())), _cache(0) {}
    inline Synth_XFADE(const Arts::Reference &r) :
        Arts::Object(r.isString()?(Synth_XFADE_base::_fromString(r.string())):(Synth_XFADE_base::_fromReference(r.reference(),true))), _cache(0) {}
    inline Synth_XFADE(const Arts::DynamicCast& c) : Arts::Object(Synth_XFADE_base::_fromDynamicCast(c.object())), _cache(0) {}
    inline Synth_XFADE(const Synth_XFADE& target) : Arts::Object(target._pool), _cache(target._cache) {}
    inline Synth_XFADE(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
    inline static Synth_XFADE null() {return Synth_XFADE((Synth_XFADE_base*)0);}
    inline static Synth_XFADE _from_base(Synth_XFADE_base* b) {return Synth_XFADE(b);}
    inline Synth_XFADE& operator=(const Synth_XFADE& target) {
        if (_pool == target._pool) return *this;
        _pool->Dec();
        _pool = target._pool;
        _cache = target._cache;
        _pool->Inc();
        return *this;
    }
    inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
    inline Synth_XFADE_base* _base() {return _cache?_cache:_method_call();}

    inline Arts::AutoSuspendState autoSuspend();
    inline void start();
    inline void stop();
    inline void streamInit();
    inline void streamStart();
    inline void streamEnd();
};

class ARTS_EXPORT Synth_AUTOPANNER_base : virtual public Arts::SynthModule_base {
public:
    static unsigned long _IID; // interface ID

    static Synth_AUTOPANNER_base *_create(const std::string& subClass = "Arts::Synth_AUTOPANNER");
    static Synth_AUTOPANNER_base *_fromString(const std::string& objectref);
    static Synth_AUTOPANNER_base *_fromReference(Arts::ObjectReference ref, bool needcopy);

    static Synth_AUTOPANNER_base *_fromDynamicCast(const Arts::Object& object);
    inline Synth_AUTOPANNER_base *_copy() {
        assert(_refCnt > 0);
        _refCnt++;
        return this;
    }

    virtual std::vector<std::string> _defaultPortsIn() const;
    virtual std::vector<std::string> _defaultPortsOut() const;

    void *_cast(unsigned long iid);

};

class ARTS_EXPORT Synth_AUTOPANNER_stub : virtual public Synth_AUTOPANNER_base, virtual public Arts::SynthModule_stub {
protected:
    Synth_AUTOPANNER_stub();

public:
    Synth_AUTOPANNER_stub(Arts::Connection *connection, long objectID);

};

class ARTS_EXPORT Synth_AUTOPANNER_skel : virtual public Synth_AUTOPANNER_base, virtual public Arts::SynthModule_skel {
protected:
    // variables for streams
    float *invalue;                           // incoming stream
    float *inlfo;                             // incoming stream
    float *outvalue1;                         // outgoing stream
    float *outvalue2;                         // outgoing stream

public:
    Synth_AUTOPANNER_skel();

    static std::string _interfaceNameSkel();
    std::string _interfaceName();
    bool _isCompatibleWith(const std::string& interfacename);
    void _buildMethodTable();
    void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
};

}
#include "reference.h"
namespace Arts {
class ARTS_EXPORT Synth_AUTOPANNER : public Arts::Object {
private:
    static Arts::Object_base* _Creator();
    Synth_AUTOPANNER_base *_cache;
    inline Synth_AUTOPANNER_base *_method_call() {
        _pool->checkcreate();
        if(_pool->base) {
            _cache=(Synth_AUTOPANNER_base *)_pool->base->_cast(Synth_AUTOPANNER_base::_IID);
            assert(_cache);
        }
        return _cache;
    }

protected:
    inline Synth_AUTOPANNER(Synth_AUTOPANNER_base* b) : Arts::Object(b), _cache(0) {}


public:
    typedef Synth_AUTOPANNER_base _base_class;

    inline Synth_AUTOPANNER() : Arts::Object(_Creator), _cache(0) {}
    inline Synth_AUTOPANNER(const Arts::SubClass& s) :
        Arts::Object(Synth_AUTOPANNER_base::_create(s.string())), _cache(0) {}
    inline Synth_AUTOPANNER(const Arts::Reference &r) :
        Arts::Object(r.isString()?(Synth_AUTOPANNER_base::_fromString(r.string())):(Synth_AUTOPANNER_base::_fromReference(r.reference(),true))), _cache(0) {}
    inline Synth_AUTOPANNER(const Arts::DynamicCast& c) : Arts::Object(Synth_AUTOPANNER_base::_fromDynamicCast(c.object())), _cache(0) {}
    inline Synth_AUTOPANNER(const Synth_AUTOPANNER& target) : Arts::Object(target._pool), _cache(target._cache) {}
    inline Synth_AUTOPANNER(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
    inline static Synth_AUTOPANNER null() {return Synth_AUTOPANNER((Synth_AUTOPANNER_base*)0);}
    inline static Synth_AUTOPANNER _from_base(Synth_AUTOPANNER_base* b) {return Synth_AUTOPANNER(b);}
    inline Synth_AUTOPANNER& operator=(const Synth_AUTOPANNER& target) {
        if (_pool == target._pool) return *this;
        _pool->Dec();
        _pool = target._pool;
        _cache = target._cache;
        _pool->Inc();
        return *this;
    }
    inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
    inline Synth_AUTOPANNER_base* _base() {return _cache?_cache:_method_call();}

    inline Arts::AutoSuspendState autoSuspend();
    inline void start();
    inline void stop();
    inline void streamInit();
    inline void streamStart();
    inline void streamEnd();
};

class ARTS_EXPORT Synth_DELAY_base : virtual public Arts::SynthModule_base {
public:
    static unsigned long _IID; // interface ID

    static Synth_DELAY_base *_create(const std::string& subClass = "Arts::Synth_DELAY");
    static Synth_DELAY_base *_fromString(const std::string& objectref);
    static Synth_DELAY_base *_fromReference(Arts::ObjectReference ref, bool needcopy);

    static Synth_DELAY_base *_fromDynamicCast(const Arts::Object& object);
    inline Synth_DELAY_base *_copy() {
        assert(_refCnt > 0);
        _refCnt++;
        return this;
    }

    virtual std::vector<std::string> _defaultPortsIn() const;
    virtual std::vector<std::string> _defaultPortsOut() const;

    void *_cast(unsigned long iid);

    virtual float maxdelay() = 0;
    virtual void maxdelay(float newValue) = 0;
};

class ARTS_EXPORT Synth_DELAY_stub : virtual public Synth_DELAY_base, virtual public Arts::SynthModule_stub {
protected:
    Synth_DELAY_stub();

public:
    Synth_DELAY_stub(Arts::Connection *connection, long objectID);

    float maxdelay();
    void maxdelay(float newValue);
};

class ARTS_EXPORT Synth_DELAY_skel : virtual public Synth_DELAY_base, virtual public Arts::SynthModule_skel {
protected:
    // variables for streams
    float *invalue;                           // incoming stream
    float *time;                              // incoming stream
    float *outvalue;                          // outgoing stream

protected:
    // emitters for change notifications
    inline void maxdelay_changed(float newValue) {
        _emit_changed("maxdelay_changed",newValue);
    }

public:
    Synth_DELAY_skel();

    static std::string _interfaceNameSkel();
    std::string _interfaceName();
    bool _isCompatibleWith(const std::string& interfacename);
    void _buildMethodTable();
    void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
};

}
#include "reference.h"
namespace Arts {
class ARTS_EXPORT Synth_DELAY : public Arts::Object {
private:
    static Arts::Object_base* _Creator();
    Synth_DELAY_base *_cache;
    inline Synth_DELAY_base *_method_call() {
        _pool->checkcreate();
        if(_pool->base) {
            _cache=(Synth_DELAY_base *)_pool->base->_cast(Synth_DELAY_base::_IID);
            assert(_cache);
        }
        return _cache;
    }

protected:
    inline Synth_DELAY(Synth_DELAY_base* b) : Arts::Object(b), _cache(0) {}


public:
    typedef Synth_DELAY_base _base_class;

    inline Synth_DELAY() : Arts::Object(_Creator), _cache(0) {}
    inline Synth_DELAY(const Arts::SubClass& s) :
        Arts::Object(Synth_DELAY_base::_create(s.string())), _cache(0) {}
    inline Synth_DELAY(const Arts::Reference &r) :
        Arts::Object(r.isString()?(Synth_DELAY_base::_fromString(r.string())):(Synth_DELAY_base::_fromReference(r.reference(),true))), _cache(0) {}
    inline Synth_DELAY(const Arts::DynamicCast& c) : Arts::Object(Synth_DELAY_base::_fromDynamicCast(c.object())), _cache(0) {}
    inline Synth_DELAY(const Synth_DELAY& target) : Arts::Object(target._pool), _cache(target._cache) {}
    inline Synth_DELAY(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
    inline static Synth_DELAY null() {return Synth_DELAY((Synth_DELAY_base*)0);}
    inline static Synth_DELAY _from_base(Synth_DELAY_base* b) {return Synth_DELAY(b);}
    inline Synth_DELAY& operator=(const Synth_DELAY& target) {
        if (_pool == target._pool) return *this;
        _pool->Dec();
        _pool = target._pool;
        _cache = target._cache;
        _pool->Inc();
        return *this;
    }
    inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
    inline Synth_DELAY_base* _base() {return _cache?_cache:_method_call();}

    inline Arts::AutoSuspendState autoSuspend();
    inline void start();
    inline void stop();
    inline void streamInit();
    inline void streamStart();
    inline void streamEnd();
    inline float maxdelay();
    inline void maxdelay(float _newValue);
};

class ARTS_EXPORT Synth_CDELAY_base : virtual public Arts::SynthModule_base {
public:
    static unsigned long _IID; // interface ID

    static Synth_CDELAY_base *_create(const std::string& subClass = "Arts::Synth_CDELAY");
    static Synth_CDELAY_base *_fromString(const std::string& objectref);
    static Synth_CDELAY_base *_fromReference(Arts::ObjectReference ref, bool needcopy);

    static Synth_CDELAY_base *_fromDynamicCast(const Arts::Object& object);
    inline Synth_CDELAY_base *_copy() {
        assert(_refCnt > 0);
        _refCnt++;
        return this;
    }

    virtual std::vector<std::string> _defaultPortsIn() const;
    virtual std::vector<std::string> _defaultPortsOut() const;

    void *_cast(unsigned long iid);

    virtual float time() = 0;
    virtual void time(float newValue) = 0;
};

class ARTS_EXPORT Synth_CDELAY_stub : virtual public Synth_CDELAY_base, virtual public Arts::SynthModule_stub {
protected:
    Synth_CDELAY_stub();

public:
    Synth_CDELAY_stub(Arts::Connection *connection, long objectID);

    float time();
    void time(float newValue);
};

class ARTS_EXPORT Synth_CDELAY_skel : virtual public Synth_CDELAY_base, virtual public Arts::SynthModule_skel {
protected:
    // variables for streams
    float *invalue;                           // incoming stream
    float *outvalue;                          // outgoing stream

protected:
    // emitters for change notifications
    inline void time_changed(float newValue) {
        _emit_changed("time_changed",newValue);
    }

public:
    Synth_CDELAY_skel();

    static std::string _interfaceNameSkel();
    std::string _interfaceName();
    bool _isCompatibleWith(const std::string& interfacename);
    void _buildMethodTable();
    void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
};

}
#include "reference.h"
namespace Arts {
class ARTS_EXPORT Synth_CDELAY : public Arts::Object {
private:
    static Arts::Object_base* _Creator();
    Synth_CDELAY_base *_cache;
    inline Synth_CDELAY_base *_method_call() {
        _pool->checkcreate();
        if(_pool->base) {
            _cache=(Synth_CDELAY_base *)_pool->base->_cast(Synth_CDELAY_base::_IID);
            assert(_cache);
        }
        return _cache;
    }

protected:
    inline Synth_CDELAY(Synth_CDELAY_base* b) : Arts::Object(b), _cache(0) {}


public:
    typedef Synth_CDELAY_base _base_class;

    inline Synth_CDELAY() : Arts::Object(_Creator), _cache(0) {}
    inline Synth_CDELAY(const Arts::SubClass& s) :
        Arts::Object(Synth_CDELAY_base::_create(s.string())), _cache(0) {}
    inline Synth_CDELAY(const Arts::Reference &r) :
        Arts::Object(r.isString()?(Synth_CDELAY_base::_fromString(r.string())):(Synth_CDELAY_base::_fromReference(r.reference(),true))), _cache(0) {}
    inline Synth_CDELAY(const Arts::DynamicCast& c) : Arts::Object(Synth_CDELAY_base::_fromDynamicCast(c.object())), _cache(0) {}
    inline Synth_CDELAY(const Synth_CDELAY& target) : Arts::Object(target._pool), _cache(target._cache) {}
    inline Synth_CDELAY(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
    inline static Synth_CDELAY null() {return Synth_CDELAY((Synth_CDELAY_base*)0);}
    inline static Synth_CDELAY _from_base(Synth_CDELAY_base* b) {return Synth_CDELAY(b);}
    inline Synth_CDELAY& operator=(const Synth_CDELAY& target) {
        if (_pool == target._pool) return *this;
        _pool->Dec();
        _pool = target._pool;
        _cache = target._cache;
        _pool->Inc();
        return *this;
    }
    inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
    inline Synth_CDELAY_base* _base() {return _cache?_cache:_method_call();}

    inline Arts::AutoSuspendState autoSuspend();
    inline void start();
    inline void stop();
    inline void streamInit();
    inline void streamStart();
    inline void streamEnd();
    inline float time();
    inline void time(float _newValue);
};

class ARTS_EXPORT Synth_ENVELOPE_ADSR_base : virtual public Arts::SynthModule_base {
public:
    static unsigned long _IID; // interface ID

    static Synth_ENVELOPE_ADSR_base *_create(const std::string& subClass = "Arts::Synth_ENVELOPE_ADSR");
    static Synth_ENVELOPE_ADSR_base *_fromString(const std::string& objectref);
    static Synth_ENVELOPE_ADSR_base *_fromReference(Arts::ObjectReference ref, bool needcopy);

    static Synth_ENVELOPE_ADSR_base *_fromDynamicCast(const Arts::Object& object);
    inline Synth_ENVELOPE_ADSR_base *_copy() {
        assert(_refCnt > 0);
        _refCnt++;
        return this;
    }

    virtual std::vector<std::string> _defaultPortsIn() const;
    virtual std::vector<std::string> _defaultPortsOut() const;

    void *_cast(unsigned long iid);

};

class ARTS_EXPORT Synth_ENVELOPE_ADSR_stub : virtual public Synth_ENVELOPE_ADSR_base, virtual public Arts::SynthModule_stub {
protected:
    Synth_ENVELOPE_ADSR_stub();

public:
    Synth_ENVELOPE_ADSR_stub(Arts::Connection *connection, long objectID);

};

class ARTS_EXPORT Synth_ENVELOPE_ADSR_skel : virtual public Synth_ENVELOPE_ADSR_base, virtual public Arts::SynthModule_skel {
protected:
    // variables for streams
    float *active;                            // incoming stream
    float *invalue;                           // incoming stream
    float *attack;                            // incoming stream
    float *decay;                             // incoming stream
    float *sustain;                           // incoming stream
    float *release;                           // incoming stream
    float *outvalue;                          // outgoing stream
    float *done;                              // outgoing stream

public:
    Synth_ENVELOPE_ADSR_skel();

    static std::string _interfaceNameSkel();
    std::string _interfaceName();
    bool _isCompatibleWith(const std::string& interfacename);
    void _buildMethodTable();
    void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
};

}
#include "reference.h"
namespace Arts {
class ARTS_EXPORT Synth_ENVELOPE_ADSR : public Arts::Object {
private:
    static Arts::Object_base* _Creator();
    Synth_ENVELOPE_ADSR_base *_cache;
    inline Synth_ENVELOPE_ADSR_base *_method_call() {
        _pool->checkcreate();
        if(_pool->base) {
            _cache=(Synth_ENVELOPE_ADSR_base *)_pool->base->_cast(Synth_ENVELOPE_ADSR_base::_IID);
            assert(_cache);
        }
        return _cache;
    }

protected:
    inline Synth_ENVELOPE_ADSR(Synth_ENVELOPE_ADSR_base* b) : Arts::Object(b), _cache(0) {}


public:
    typedef Synth_ENVELOPE_ADSR_base _base_class;

    inline Synth_ENVELOPE_ADSR() : Arts::Object(_Creator), _cache(0) {}
    inline Synth_ENVELOPE_ADSR(const Arts::SubClass& s) :
        Arts::Object(Synth_ENVELOPE_ADSR_base::_create(s.string())), _cache(0) {}
    inline Synth_ENVELOPE_ADSR(const Arts::Reference &r) :
        Arts::Object(r.isString()?(Synth_ENVELOPE_ADSR_base::_fromString(r.string())):(Synth_ENVELOPE_ADSR_base::_fromReference(r.reference(),true))), _cache(0) {}
    inline Synth_ENVELOPE_ADSR(const Arts::DynamicCast& c) : Arts::Object(Synth_ENVELOPE_ADSR_base::_fromDynamicCast(c.object())), _cache(0) {}
    inline Synth_ENVELOPE_ADSR(const Synth_ENVELOPE_ADSR& target) : Arts::Object(target._pool), _cache(target._cache) {}
    inline Synth_ENVELOPE_ADSR(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
    inline static Synth_ENVELOPE_ADSR null() {return Synth_ENVELOPE_ADSR((Synth_ENVELOPE_ADSR_base*)0);}
    inline static Synth_ENVELOPE_ADSR _from_base(Synth_ENVELOPE_ADSR_base* b) {return Synth_ENVELOPE_ADSR(b);}
    inline Synth_ENVELOPE_ADSR& operator=(const Synth_ENVELOPE_ADSR& target) {
        if (_pool == target._pool) return *this;
        _pool->Dec();
        _pool = target._pool;
        _cache = target._cache;
        _pool->Inc();
        return *this;
    }
    inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
    inline Synth_ENVELOPE_ADSR_base* _base() {return _cache?_cache:_method_call();}

    inline Arts::AutoSuspendState autoSuspend();
    inline void start();
    inline void stop();
    inline void streamInit();
    inline void streamStart();
    inline void streamEnd();
};

class ARTS_EXPORT Synth_PSCALE_base : virtual public Arts::SynthModule_base {
public:
    static unsigned long _IID; // interface ID

    static Synth_PSCALE_base *_create(const std::string& subClass = "Arts::Synth_PSCALE");
    static Synth_PSCALE_base *_fromString(const std::string& objectref);
    static Synth_PSCALE_base *_fromReference(Arts::ObjectReference ref, bool needcopy);

    static Synth_PSCALE_base *_fromDynamicCast(const Arts::Object& object);
    inline Synth_PSCALE_base *_copy() {
        assert(_refCnt > 0);
        _refCnt++;
        return this;
    }

    virtual std::vector<std::string> _defaultPortsIn() const;
    virtual std::vector<std::string> _defaultPortsOut() const;

    void *_cast(unsigned long iid);

    virtual float top() = 0;
    virtual void top(float newValue) = 0;
};

class ARTS_EXPORT Synth_PSCALE_stub : virtual public Synth_PSCALE_base, virtual public Arts::SynthModule_stub {
protected:
    Synth_PSCALE_stub();

public:
    Synth_PSCALE_stub(Arts::Connection *connection, long objectID);

    float top();
    void top(float newValue);
};

class ARTS_EXPORT Synth_PSCALE_skel : virtual public Synth_PSCALE_base, virtual public Arts::SynthModule_skel {
protected:
    // variables for streams
    float *invalue;                           // incoming stream
    float *pos;                               // incoming stream
    float *outvalue;                          // outgoing stream

protected:
    // emitters for change notifications
    inline void top_changed(float newValue) {
        _emit_changed("top_changed",newValue);
    }

public:
    Synth_PSCALE_skel();

    static std::string _interfaceNameSkel();
    std::string _interfaceName();
    bool _isCompatibleWith(const std::string& interfacename);
    void _buildMethodTable();
    void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
};

}
#include "reference.h"
namespace Arts {
class ARTS_EXPORT Synth_PSCALE : public Arts::Object {
private:
    static Arts::Object_base* _Creator();
    Synth_PSCALE_base *_cache;
    inline Synth_PSCALE_base *_method_call() {
        _pool->checkcreate();
        if(_pool->base) {
            _cache=(Synth_PSCALE_base *)_pool->base->_cast(Synth_PSCALE_base::_IID);
            assert(_cache);
        }
        return _cache;
    }

protected:
    inline Synth_PSCALE(Synth_PSCALE_base* b) : Arts::Object(b), _cache(0) {}


public:
    typedef Synth_PSCALE_base _base_class;

    inline Synth_PSCALE() : Arts::Object(_Creator), _cache(0) {}
    inline Synth_PSCALE(const Arts::SubClass& s) :
        Arts::Object(Synth_PSCALE_base::_create(s.string())), _cache(0) {}
    inline Synth_PSCALE(const Arts::Reference &r) :
        Arts::Object(r.isString()?(Synth_PSCALE_base::_fromString(r.string())):(Synth_PSCALE_base::_fromReference(r.reference(),true))), _cache(0) {}
    inline Synth_PSCALE(const Arts::DynamicCast& c) : Arts::Object(Synth_PSCALE_base::_fromDynamicCast(c.object())), _cache(0) {}
    inline Synth_PSCALE(const Synth_PSCALE& target) : Arts::Object(target._pool), _cache(target._cache) {}
    inline Synth_PSCALE(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
    inline static Synth_PSCALE null() {return Synth_PSCALE((Synth_PSCALE_base*)0);}
    inline static Synth_PSCALE _from_base(Synth_PSCALE_base* b) {return Synth_PSCALE(b);}
    inline Synth_PSCALE& operator=(const Synth_PSCALE& target) {
        if (_pool == target._pool) return *this;
        _pool->Dec();
        _pool = target._pool;
        _cache = target._cache;
        _pool->Inc();
        return *this;
    }
    inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
    inline Synth_PSCALE_base* _base() {return _cache?_cache:_method_call();}

    inline Arts::AutoSuspendState autoSuspend();
    inline void start();
    inline void stop();
    inline void streamInit();
    inline void streamStart();
    inline void streamEnd();
    inline float top();
    inline void top(float _newValue);
};

class ARTS_EXPORT Synth_TREMOLO_base : virtual public Arts::SynthModule_base {
public:
    static unsigned long _IID; // interface ID

    static Synth_TREMOLO_base *_create(const std::string& subClass = "Arts::Synth_TREMOLO");
    static Synth_TREMOLO_base *_fromString(const std::string& objectref);
    static Synth_TREMOLO_base *_fromReference(Arts::ObjectReference ref, bool needcopy);

    static Synth_TREMOLO_base *_fromDynamicCast(const Arts::Object& object);
    inline Synth_TREMOLO_base *_copy() {
        assert(_refCnt > 0);
        _refCnt++;
        return this;
    }

    virtual std::vector<std::string> _defaultPortsIn() const;
    virtual std::vector<std::string> _defaultPortsOut() const;

    void *_cast(unsigned long iid);

};

class ARTS_EXPORT Synth_TREMOLO_stub : virtual public Synth_TREMOLO_base, virtual public Arts::SynthModule_stub {
protected:
    Synth_TREMOLO_stub();

public:
    Synth_TREMOLO_stub(Arts::Connection *connection, long objectID);

};

class ARTS_EXPORT Synth_TREMOLO_skel : virtual public Synth_TREMOLO_base, virtual public Arts::SynthModule_skel {
protected:
    // variables for streams
    float *invalue;                           // incoming stream
    float *inlfo;                             // incoming stream
    float *outvalue;                          // outgoing stream

public:
    Synth_TREMOLO_skel();

    static std::string _interfaceNameSkel();
    std::string _interfaceName();
    bool _isCompatibleWith(const std::string& interfacename);
    void _buildMethodTable();
    void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
};

}
#include "reference.h"
namespace Arts {
class ARTS_EXPORT Synth_TREMOLO : public Arts::Object {
private:
    static Arts::Object_base* _Creator();
    Synth_TREMOLO_base *_cache;
    inline Synth_TREMOLO_base *_method_call() {
        _pool->checkcreate();
        if(_pool->base) {
            _cache=(Synth_TREMOLO_base *)_pool->base->_cast(Synth_TREMOLO_base::_IID);
            assert(_cache);
        }
        return _cache;
    }

protected:
    inline Synth_TREMOLO(Synth_TREMOLO_base* b) : Arts::Object(b), _cache(0) {}


public:
    typedef Synth_TREMOLO_base _base_class;

    inline Synth_TREMOLO() : Arts::Object(_Creator), _cache(0) {}
    inline Synth_TREMOLO(const Arts::SubClass& s) :
        Arts::Object(Synth_TREMOLO_base::_create(s.string())), _cache(0) {}
    inline Synth_TREMOLO(const Arts::Reference &r) :
        Arts::Object(r.isString()?(Synth_TREMOLO_base::_fromString(r.string())):(Synth_TREMOLO_base::_fromReference(r.reference(),true))), _cache(0) {}
    inline Synth_TREMOLO(const Arts::DynamicCast& c) : Arts::Object(Synth_TREMOLO_base::_fromDynamicCast(c.object())), _cache(0) {}
    inline Synth_TREMOLO(const Synth_TREMOLO& target) : Arts::Object(target._pool), _cache(target._cache) {}
    inline Synth_TREMOLO(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
    inline static Synth_TREMOLO null() {return Synth_TREMOLO((Synth_TREMOLO_base*)0);}
    inline static Synth_TREMOLO _from_base(Synth_TREMOLO_base* b) {return Synth_TREMOLO(b);}
    inline Synth_TREMOLO& operator=(const Synth_TREMOLO& target) {
        if (_pool == target._pool) return *this;
        _pool->Dec();
        _pool = target._pool;
        _cache = target._cache;
        _pool->Inc();
        return *this;
    }
    inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
    inline Synth_TREMOLO_base* _base() {return _cache?_cache:_method_call();}

    inline Arts::AutoSuspendState autoSuspend();
    inline void start();
    inline void stop();
    inline void streamInit();
    inline void streamStart();
    inline void streamEnd();
};

class ARTS_EXPORT Synth_FX_CFLANGER_base : virtual public Arts::SynthModule_base {
public:
    static unsigned long _IID; // interface ID

    static Synth_FX_CFLANGER_base *_create(const std::string& subClass = "Arts::Synth_FX_CFLANGER");
    static Synth_FX_CFLANGER_base *_fromString(const std::string& objectref);
    static Synth_FX_CFLANGER_base *_fromReference(Arts::ObjectReference ref, bool needcopy);

    static Synth_FX_CFLANGER_base *_fromDynamicCast(const Arts::Object& object);
    inline Synth_FX_CFLANGER_base *_copy() {
        assert(_refCnt > 0);
        _refCnt++;
        return this;
    }

    virtual std::vector<std::string> _defaultPortsIn() const;
    virtual std::vector<std::string> _defaultPortsOut() const;

    void *_cast(unsigned long iid);

    virtual float mintime() = 0;
    virtual void mintime(float newValue) = 0;
    virtual float maxtime() = 0;
    virtual void maxtime(float newValue) = 0;
};

class ARTS_EXPORT Synth_FX_CFLANGER_stub : virtual public Synth_FX_CFLANGER_base, virtual public Arts::SynthModule_stub {
protected:
    Synth_FX_CFLANGER_stub();

public:
    Synth_FX_CFLANGER_stub(Arts::Connection *connection, long objectID);

    float mintime();
    void mintime(float newValue);
    float maxtime();
    void maxtime(float newValue);
};

class ARTS_EXPORT Synth_FX_CFLANGER_skel : virtual public Synth_FX_CFLANGER_base, virtual public Arts::SynthModule_skel {
protected:
    // variables for streams
    float *invalue;                           // incoming stream
    float *lfo;                               // incoming stream
    float *outvalue;                          // outgoing stream

protected:
    // emitters for change notifications
    inline void mintime_changed(float newValue) {
        _emit_changed("mintime_changed",newValue);
    }
    inline void maxtime_changed(float newValue) {
        _emit_changed("maxtime_changed",newValue);
    }

public:
    Synth_FX_CFLANGER_skel();

    static std::string _interfaceNameSkel();
    std::string _interfaceName();
    bool _isCompatibleWith(const std::string& interfacename);
    void _buildMethodTable();
    void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
};

}
#include "reference.h"
namespace Arts {
class ARTS_EXPORT Synth_FX_CFLANGER : public Arts::Object {
private:
    static Arts::Object_base* _Creator();
    Synth_FX_CFLANGER_base *_cache;
    inline Synth_FX_CFLANGER_base *_method_call() {
        _pool->checkcreate();
        if(_pool->base) {
            _cache=(Synth_FX_CFLANGER_base *)_pool->base->_cast(Synth_FX_CFLANGER_base::_IID);
            assert(_cache);
        }
        return _cache;
    }

protected:
    inline Synth_FX_CFLANGER(Synth_FX_CFLANGER_base* b) : Arts::Object(b), _cache(0) {}


public:
    typedef Synth_FX_CFLANGER_base _base_class;

    inline Synth_FX_CFLANGER() : Arts::Object(_Creator), _cache(0) {}
    inline Synth_FX_CFLANGER(const Arts::SubClass& s) :
        Arts::Object(Synth_FX_CFLANGER_base::_create(s.string())), _cache(0) {}
    inline Synth_FX_CFLANGER(const Arts::Reference &r) :
        Arts::Object(r.isString()?(Synth_FX_CFLANGER_base::_fromString(r.string())):(Synth_FX_CFLANGER_base::_fromReference(r.reference(),true))), _cache(0) {}
    inline Synth_FX_CFLANGER(const Arts::DynamicCast& c) : Arts::Object(Synth_FX_CFLANGER_base::_fromDynamicCast(c.object())), _cache(0) {}
    inline Synth_FX_CFLANGER(const Synth_FX_CFLANGER& target) : Arts::Object(target._pool), _cache(target._cache) {}
    inline Synth_FX_CFLANGER(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
    inline static Synth_FX_CFLANGER null() {return Synth_FX_CFLANGER((Synth_FX_CFLANGER_base*)0);}
    inline static Synth_FX_CFLANGER _from_base(Synth_FX_CFLANGER_base* b) {return Synth_FX_CFLANGER(b);}
    inline Synth_FX_CFLANGER& operator=(const Synth_FX_CFLANGER& target) {
        if (_pool == target._pool) return *this;
        _pool->Dec();
        _pool = target._pool;
        _cache = target._cache;
        _pool->Inc();
        return *this;
    }
    inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
    inline Synth_FX_CFLANGER_base* _base() {return _cache?_cache:_method_call();}

    inline Arts::AutoSuspendState autoSuspend();
    inline void start();
    inline void stop();
    inline void streamInit();
    inline void streamStart();
    inline void streamEnd();
    inline float mintime();
    inline void mintime(float _newValue);
    inline float maxtime();
    inline void maxtime(float _newValue);
};

class ARTS_EXPORT Synth_COMPRESSOR_base : virtual public Arts::SynthModule_base {
public:
    static unsigned long _IID; // interface ID

    static Synth_COMPRESSOR_base *_create(const std::string& subClass = "Arts::Synth_COMPRESSOR");
    static Synth_COMPRESSOR_base *_fromString(const std::string& objectref);
    static Synth_COMPRESSOR_base *_fromReference(Arts::ObjectReference ref, bool needcopy);

    static Synth_COMPRESSOR_base *_fromDynamicCast(const Arts::Object& object);
    inline Synth_COMPRESSOR_base *_copy() {
        assert(_refCnt > 0);
        _refCnt++;
        return this;
    }

    virtual std::vector<std::string> _defaultPortsIn() const;
    virtual std::vector<std::string> _defaultPortsOut() const;

    void *_cast(unsigned long iid);

    virtual float attack() = 0;
    virtual void attack(float newValue) = 0;
    virtual float release() = 0;
    virtual void release(float newValue) = 0;
    virtual float threshold() = 0;
    virtual void threshold(float newValue) = 0;
    virtual float ratio() = 0;
    virtual void ratio(float newValue) = 0;
    virtual float output() = 0;
    virtual void output(float newValue) = 0;
};

class ARTS_EXPORT Synth_COMPRESSOR_stub : virtual public Synth_COMPRESSOR_base, virtual public Arts::SynthModule_stub {
protected:
    Synth_COMPRESSOR_stub();

public:
    Synth_COMPRESSOR_stub(Arts::Connection *connection, long objectID);

    float attack();
    void attack(float newValue);
    float release();
    void release(float newValue);
    float threshold();
    void threshold(float newValue);
    float ratio();
    void ratio(float newValue);
    float output();
    void output(float newValue);
};

class ARTS_EXPORT Synth_COMPRESSOR_skel : virtual public Synth_COMPRESSOR_base, virtual public Arts::SynthModule_skel {
protected:
    // variables for streams
    float *invalue;                           // incoming stream
    float *outvalue;                          // outgoing stream

protected:
    // emitters for change notifications
    inline void attack_changed(float newValue) {
        _emit_changed("attack_changed",newValue);
    }
    inline void release_changed(float newValue) {
        _emit_changed("release_changed",newValue);
    }
    inline void threshold_changed(float newValue) {
        _emit_changed("threshold_changed",newValue);
    }
    inline void ratio_changed(float newValue) {
        _emit_changed("ratio_changed",newValue);
    }
    inline void output_changed(float newValue) {
        _emit_changed("output_changed",newValue);
    }

public:
    Synth_COMPRESSOR_skel();

    static std::string _interfaceNameSkel();
    std::string _interfaceName();
    bool _isCompatibleWith(const std::string& interfacename);
    void _buildMethodTable();
    void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
};

}
#include "reference.h"
namespace Arts {
class ARTS_EXPORT Synth_COMPRESSOR : public Arts::Object {
private:
    static Arts::Object_base* _Creator();
    Synth_COMPRESSOR_base *_cache;
    inline Synth_COMPRESSOR_base *_method_call() {
        _pool->checkcreate();
        if(_pool->base) {
            _cache=(Synth_COMPRESSOR_base *)_pool->base->_cast(Synth_COMPRESSOR_base::_IID);
            assert(_cache);
        }
        return _cache;
    }

protected:
    inline Synth_COMPRESSOR(Synth_COMPRESSOR_base* b) : Arts::Object(b), _cache(0) {}


public:
    typedef Synth_COMPRESSOR_base _base_class;

    inline Synth_COMPRESSOR() : Arts::Object(_Creator), _cache(0) {}
    inline Synth_COMPRESSOR(const Arts::SubClass& s) :
        Arts::Object(Synth_COMPRESSOR_base::_create(s.string())), _cache(0) {}
    inline Synth_COMPRESSOR(const Arts::Reference &r) :
        Arts::Object(r.isString()?(Synth_COMPRESSOR_base::_fromString(r.string())):(Synth_COMPRESSOR_base::_fromReference(r.reference(),true))), _cache(0) {}
    inline Synth_COMPRESSOR(const Arts::DynamicCast& c) : Arts::Object(Synth_COMPRESSOR_base::_fromDynamicCast(c.object())), _cache(0) {}
    inline Synth_COMPRESSOR(const Synth_COMPRESSOR& target) : Arts::Object(target._pool), _cache(target._cache) {}
    inline Synth_COMPRESSOR(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
    inline static Synth_COMPRESSOR null() {return Synth_COMPRESSOR((Synth_COMPRESSOR_base*)0);}
    inline static Synth_COMPRESSOR _from_base(Synth_COMPRESSOR_base* b) {return Synth_COMPRESSOR(b);}
    inline Synth_COMPRESSOR& operator=(const Synth_COMPRESSOR& target) {
        if (_pool == target._pool) return *this;
        _pool->Dec();
        _pool = target._pool;
        _cache = target._cache;
        _pool->Inc();
        return *this;
    }
    inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
    inline Synth_COMPRESSOR_base* _base() {return _cache?_cache:_method_call();}

    inline Arts::AutoSuspendState autoSuspend();
    inline void start();
    inline void stop();
    inline void streamInit();
    inline void streamStart();
    inline void streamEnd();
    inline float attack();
    inline void attack(float _newValue);
    inline float release();
    inline void release(float _newValue);
    inline float threshold();
    inline void threshold(float _newValue);
    inline float ratio();
    inline void ratio(float _newValue);
    inline float output();
    inline void output(float _newValue);
};

class ARTS_EXPORT Synth_PITCH_SHIFT_base : virtual public Arts::SynthModule_base {
public:
    static unsigned long _IID; // interface ID

    static Synth_PITCH_SHIFT_base *_create(const std::string& subClass = "Arts::Synth_PITCH_SHIFT");
    static Synth_PITCH_SHIFT_base *_fromString(const std::string& objectref);
    static Synth_PITCH_SHIFT_base *_fromReference(Arts::ObjectReference ref, bool needcopy);

    static Synth_PITCH_SHIFT_base *_fromDynamicCast(const Arts::Object& object);
    inline Synth_PITCH_SHIFT_base *_copy() {
        assert(_refCnt > 0);
        _refCnt++;
        return this;
    }

    virtual std::vector<std::string> _defaultPortsIn() const;
    virtual std::vector<std::string> _defaultPortsOut() const;

    void *_cast(unsigned long iid);

    virtual float speed() = 0;
    virtual void speed(float newValue) = 0;
    virtual float frequency() = 0;
    virtual void frequency(float newValue) = 0;
};

class ARTS_EXPORT Synth_PITCH_SHIFT_stub : virtual public Synth_PITCH_SHIFT_base, virtual public Arts::SynthModule_stub {
protected:
    Synth_PITCH_SHIFT_stub();

public:
    Synth_PITCH_SHIFT_stub(Arts::Connection *connection, long objectID);

    float speed();
    void speed(float newValue);
    float frequency();
    void frequency(float newValue);
};

class ARTS_EXPORT Synth_PITCH_SHIFT_skel : virtual public Synth_PITCH_SHIFT_base, virtual public Arts::SynthModule_skel {
protected:
    // variables for streams
    float *invalue;                           // incoming stream
    float *outvalue;                          // outgoing stream

protected:
    // emitters for change notifications
    inline void speed_changed(float newValue) {
        _emit_changed("speed_changed",newValue);
    }
    inline void frequency_changed(float newValue) {
        _emit_changed("frequency_changed",newValue);
    }

public:
    Synth_PITCH_SHIFT_skel();

    static std::string _interfaceNameSkel();
    std::string _interfaceName();
    bool _isCompatibleWith(const std::string& interfacename);
    void _buildMethodTable();
    void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
};

}
#include "reference.h"
namespace Arts {
class ARTS_EXPORT Synth_PITCH_SHIFT : public Arts::Object {
private:
    static Arts::Object_base* _Creator();
    Synth_PITCH_SHIFT_base *_cache;
    inline Synth_PITCH_SHIFT_base *_method_call() {
        _pool->checkcreate();
        if(_pool->base) {
            _cache=(Synth_PITCH_SHIFT_base *)_pool->base->_cast(Synth_PITCH_SHIFT_base::_IID);
            assert(_cache);
        }
        return _cache;
    }

protected:
    inline Synth_PITCH_SHIFT(Synth_PITCH_SHIFT_base* b) : Arts::Object(b), _cache(0) {}


public:
    typedef Synth_PITCH_SHIFT_base _base_class;

    inline Synth_PITCH_SHIFT() : Arts::Object(_Creator), _cache(0) {}
    inline Synth_PITCH_SHIFT(const Arts::SubClass& s) :
        Arts::Object(Synth_PITCH_SHIFT_base::_create(s.string())), _cache(0) {}
    inline Synth_PITCH_SHIFT(const Arts::Reference &r) :
        Arts::Object(r.isString()?(Synth_PITCH_SHIFT_base::_fromString(r.string())):(Synth_PITCH_SHIFT_base::_fromReference(r.reference(),true))), _cache(0) {}
    inline Synth_PITCH_SHIFT(const Arts::DynamicCast& c) : Arts::Object(Synth_PITCH_SHIFT_base::_fromDynamicCast(c.object())), _cache(0) {}
    inline Synth_PITCH_SHIFT(const Synth_PITCH_SHIFT& target) : Arts::Object(target._pool), _cache(target._cache) {}
    inline Synth_PITCH_SHIFT(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
    inline static Synth_PITCH_SHIFT null() {return Synth_PITCH_SHIFT((Synth_PITCH_SHIFT_base*)0);}
    inline static Synth_PITCH_SHIFT _from_base(Synth_PITCH_SHIFT_base* b) {return Synth_PITCH_SHIFT(b);}
    inline Synth_PITCH_SHIFT& operator=(const Synth_PITCH_SHIFT& target) {
        if (_pool == target._pool) return *this;
        _pool->Dec();
        _pool = target._pool;
        _cache = target._cache;
        _pool->Inc();
        return *this;
    }
    inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
    inline Synth_PITCH_SHIFT_base* _base() {return _cache?_cache:_method_call();}

    inline Arts::AutoSuspendState autoSuspend();
    inline void start();
    inline void stop();
    inline void streamInit();
    inline void streamStart();
    inline void streamEnd();
    inline float speed();
    inline void speed(float _newValue);
    inline float frequency();
    inline void frequency(float _newValue);
};

class ARTS_EXPORT Synth_PITCH_SHIFT_FFT_base : virtual public Arts::SynthModule_base {
public:
    static unsigned long _IID; // interface ID

    static Synth_PITCH_SHIFT_FFT_base *_create(const std::string& subClass = "Arts::Synth_PITCH_SHIFT_FFT");
    static Synth_PITCH_SHIFT_FFT_base *_fromString(const std::string& objectref);
    static Synth_PITCH_SHIFT_FFT_base *_fromReference(Arts::ObjectReference ref, bool needcopy);

    static Synth_PITCH_SHIFT_FFT_base *_fromDynamicCast(const Arts::Object& object);
    inline Synth_PITCH_SHIFT_FFT_base *_copy() {
        assert(_refCnt > 0);
        _refCnt++;
        return this;
    }

    virtual std::vector<std::string> _defaultPortsIn() const;
    virtual std::vector<std::string> _defaultPortsOut() const;

    void *_cast(unsigned long iid);

    virtual float speed() = 0;
    virtual void speed(float newValue) = 0;
    virtual float scaleFactor() = 0;
    virtual void scaleFactor(float newValue) = 0;
    virtual long frameSize() = 0;
    virtual void frameSize(long newValue) = 0;
    virtual long oversample() = 0;
    virtual void oversample(long newValue) = 0;
};

class ARTS_EXPORT Synth_PITCH_SHIFT_FFT_stub : virtual public Synth_PITCH_SHIFT_FFT_base, virtual public Arts::SynthModule_stub {
protected:
    Synth_PITCH_SHIFT_FFT_stub();

public:
    Synth_PITCH_SHIFT_FFT_stub(Arts::Connection *connection, long objectID);

    float speed();
    void speed(float newValue);
    float scaleFactor();
    void scaleFactor(float newValue);
    long frameSize();
    void frameSize(long newValue);
    long oversample();
    void oversample(long newValue);
};

class ARTS_EXPORT Synth_PITCH_SHIFT_FFT_skel : virtual public Synth_PITCH_SHIFT_FFT_base, virtual public Arts::SynthModule_skel {
protected:
    // variables for streams
    float *inStream;                          // incoming stream
    float *outStream;                         // outgoing stream

protected:
    // emitters for change notifications
    inline void speed_changed(float newValue) {
        _emit_changed("speed_changed",newValue);
    }
    inline void scaleFactor_changed(float newValue) {
        _emit_changed("scaleFactor_changed",newValue);
    }
    inline void frameSize_changed(long newValue) {
        _emit_changed("frameSize_changed",newValue);
    }
    inline void oversample_changed(long newValue) {
        _emit_changed("oversample_changed",newValue);
    }

public:
    Synth_PITCH_SHIFT_FFT_skel();

    static std::string _interfaceNameSkel();
    std::string _interfaceName();
    bool _isCompatibleWith(const std::string& interfacename);
    void _buildMethodTable();
    void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
};

}
#include "reference.h"
namespace Arts {
class ARTS_EXPORT Synth_PITCH_SHIFT_FFT : public Arts::Object {
private:
    static Arts::Object_base* _Creator();
    Synth_PITCH_SHIFT_FFT_base *_cache;
    inline Synth_PITCH_SHIFT_FFT_base *_method_call() {
        _pool->checkcreate();
        if(_pool->base) {
            _cache=(Synth_PITCH_SHIFT_FFT_base *)_pool->base->_cast(Synth_PITCH_SHIFT_FFT_base::_IID);
            assert(_cache);
        }
        return _cache;
    }

protected:
    inline Synth_PITCH_SHIFT_FFT(Synth_PITCH_SHIFT_FFT_base* b) : Arts::Object(b), _cache(0) {}


public:
    typedef Synth_PITCH_SHIFT_FFT_base _base_class;

    inline Synth_PITCH_SHIFT_FFT() : Arts::Object(_Creator), _cache(0) {}
    inline Synth_PITCH_SHIFT_FFT(const Arts::SubClass& s) :
        Arts::Object(Synth_PITCH_SHIFT_FFT_base::_create(s.string())), _cache(0) {}
    inline Synth_PITCH_SHIFT_FFT(const Arts::Reference &r) :
        Arts::Object(r.isString()?(Synth_PITCH_SHIFT_FFT_base::_fromString(r.string())):(Synth_PITCH_SHIFT_FFT_base::_fromReference(r.reference(),true))), _cache(0) {}
    inline Synth_PITCH_SHIFT_FFT(const Arts::DynamicCast& c) : Arts::Object(Synth_PITCH_SHIFT_FFT_base::_fromDynamicCast(c.object())), _cache(0) {}
    inline Synth_PITCH_SHIFT_FFT(const Synth_PITCH_SHIFT_FFT& target) : Arts::Object(target._pool), _cache(target._cache) {}
    inline Synth_PITCH_SHIFT_FFT(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
    inline static Synth_PITCH_SHIFT_FFT null() {return Synth_PITCH_SHIFT_FFT((Synth_PITCH_SHIFT_FFT_base*)0);}
    inline static Synth_PITCH_SHIFT_FFT _from_base(Synth_PITCH_SHIFT_FFT_base* b) {return Synth_PITCH_SHIFT_FFT(b);}
    inline Synth_PITCH_SHIFT_FFT& operator=(const Synth_PITCH_SHIFT_FFT& target) {
        if (_pool == target._pool) return *this;
        _pool->Dec();
        _pool = target._pool;
        _cache = target._cache;
        _pool->Inc();
        return *this;
    }
    inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
    inline Synth_PITCH_SHIFT_FFT_base* _base() {return _cache?_cache:_method_call();}

    inline Arts::AutoSuspendState autoSuspend();
    inline void start();
    inline void stop();
    inline void streamInit();
    inline void streamStart();
    inline void streamEnd();
    inline float speed();
    inline void speed(float _newValue);
    inline float scaleFactor();
    inline void scaleFactor(float _newValue);
    inline long frameSize();
    inline void frameSize(long _newValue);
    inline long oversample();
    inline void oversample(long _newValue);
};

class ARTS_EXPORT Synth_SHELVE_CUTOFF_base : virtual public Arts::SynthModule_base {
public:
    static unsigned long _IID; // interface ID

    static Synth_SHELVE_CUTOFF_base *_create(const std::string& subClass = "Arts::Synth_SHELVE_CUTOFF");
    static Synth_SHELVE_CUTOFF_base *_fromString(const std::string& objectref);
    static Synth_SHELVE_CUTOFF_base *_fromReference(Arts::ObjectReference ref, bool needcopy);

    static Synth_SHELVE_CUTOFF_base *_fromDynamicCast(const Arts::Object& object);
    inline Synth_SHELVE_CUTOFF_base *_copy() {
        assert(_refCnt > 0);
        _refCnt++;
        return this;
    }

    virtual std::vector<std::string> _defaultPortsIn() const;
    virtual std::vector<std::string> _defaultPortsOut() const;

    void *_cast(unsigned long iid);

};

class ARTS_EXPORT Synth_SHELVE_CUTOFF_stub : virtual public Synth_SHELVE_CUTOFF_base, virtual public Arts::SynthModule_stub {
protected:
    Synth_SHELVE_CUTOFF_stub();

public:
    Synth_SHELVE_CUTOFF_stub(Arts::Connection *connection, long objectID);

};

class ARTS_EXPORT Synth_SHELVE_CUTOFF_skel : virtual public Synth_SHELVE_CUTOFF_base, virtual public Arts::SynthModule_skel {
protected:
    // variables for streams
    float *invalue;                           // incoming stream
    float *frequency;                         // incoming stream
    float *outvalue;                          // outgoing stream

public:
    Synth_SHELVE_CUTOFF_skel();

    static std::string _interfaceNameSkel();
    std::string _interfaceName();
    bool _isCompatibleWith(const std::string& interfacename);
    void _buildMethodTable();
    void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
};

}
#include "reference.h"
namespace Arts {
class ARTS_EXPORT Synth_SHELVE_CUTOFF : public Arts::Object {
private:
    static Arts::Object_base* _Creator();
    Synth_SHELVE_CUTOFF_base *_cache;
    inline Synth_SHELVE_CUTOFF_base *_method_call() {
        _pool->checkcreate();
        if(_pool->base) {
            _cache=(Synth_SHELVE_CUTOFF_base *)_pool->base->_cast(Synth_SHELVE_CUTOFF_base::_IID);
            assert(_cache);
        }
        return _cache;
    }

protected:
    inline Synth_SHELVE_CUTOFF(Synth_SHELVE_CUTOFF_base* b) : Arts::Object(b), _cache(0) {}


public:
    typedef Synth_SHELVE_CUTOFF_base _base_class;

    inline Synth_SHELVE_CUTOFF() : Arts::Object(_Creator), _cache(0) {}
    inline Synth_SHELVE_CUTOFF(const Arts::SubClass& s) :
        Arts::Object(Synth_SHELVE_CUTOFF_base::_create(s.string())), _cache(0) {}
    inline Synth_SHELVE_CUTOFF(const Arts::Reference &r) :
        Arts::Object(r.isString()?(Synth_SHELVE_CUTOFF_base::_fromString(r.string())):(Synth_SHELVE_CUTOFF_base::_fromReference(r.reference(),true))), _cache(0) {}
    inline Synth_SHELVE_CUTOFF(const Arts::DynamicCast& c) : Arts::Object(Synth_SHELVE_CUTOFF_base::_fromDynamicCast(c.object())), _cache(0) {}
    inline Synth_SHELVE_CUTOFF(const Synth_SHELVE_CUTOFF& target) : Arts::Object(target._pool), _cache(target._cache) {}
    inline Synth_SHELVE_CUTOFF(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
    inline static Synth_SHELVE_CUTOFF null() {return Synth_SHELVE_CUTOFF((Synth_SHELVE_CUTOFF_base*)0);}
    inline static Synth_SHELVE_CUTOFF _from_base(Synth_SHELVE_CUTOFF_base* b) {return Synth_SHELVE_CUTOFF(b);}
    inline Synth_SHELVE_CUTOFF& operator=(const Synth_SHELVE_CUTOFF& target) {
        if (_pool == target._pool) return *this;
        _pool->Dec();
        _pool = target._pool;
        _cache = target._cache;
        _pool->Inc();
        return *this;
    }
    inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
    inline Synth_SHELVE_CUTOFF_base* _base() {return _cache?_cache:_method_call();}

    inline Arts::AutoSuspendState autoSuspend();
    inline void start();
    inline void stop();
    inline void streamInit();
    inline void streamStart();
    inline void streamEnd();
};

class ARTS_EXPORT Synth_BRICKWALL_LIMITER_base : virtual public Arts::SynthModule_base {
public:
    static unsigned long _IID; // interface ID

    static Synth_BRICKWALL_LIMITER_base *_create(const std::string& subClass = "Arts::Synth_BRICKWALL_LIMITER");
    static Synth_BRICKWALL_LIMITER_base *_fromString(const std::string& objectref);
    static Synth_BRICKWALL_LIMITER_base *_fromReference(Arts::ObjectReference ref, bool needcopy);

    static Synth_BRICKWALL_LIMITER_base *_fromDynamicCast(const Arts::Object& object);
    inline Synth_BRICKWALL_LIMITER_base *_copy() {
        assert(_refCnt > 0);
        _refCnt++;
        return this;
    }

    virtual std::vector<std::string> _defaultPortsIn() const;
    virtual std::vector<std::string> _defaultPortsOut() const;

    void *_cast(unsigned long iid);

};

class ARTS_EXPORT Synth_BRICKWALL_LIMITER_stub : virtual public Synth_BRICKWALL_LIMITER_base, virtual public Arts::SynthModule_stub {
protected:
    Synth_BRICKWALL_LIMITER_stub();

public:
    Synth_BRICKWALL_LIMITER_stub(Arts::Connection *connection, long objectID);

};

class ARTS_EXPORT Synth_BRICKWALL_LIMITER_skel : virtual public Synth_BRICKWALL_LIMITER_base, virtual public Arts::SynthModule_skel {
protected:
    // variables for streams
    float *invalue;                           // incoming stream
    float *outvalue;                          // outgoing stream

public:
    Synth_BRICKWALL_LIMITER_skel();

    static std::string _interfaceNameSkel();
    std::string _interfaceName();
    bool _isCompatibleWith(const std::string& interfacename);
    void _buildMethodTable();
    void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
};

}
#include "reference.h"
namespace Arts {
class ARTS_EXPORT Synth_BRICKWALL_LIMITER : public Arts::Object {
private:
    static Arts::Object_base* _Creator();
    Synth_BRICKWALL_LIMITER_base *_cache;
    inline Synth_BRICKWALL_LIMITER_base *_method_call() {
        _pool->checkcreate();
        if(_pool->base) {
            _cache=(Synth_BRICKWALL_LIMITER_base *)_pool->base->_cast(Synth_BRICKWALL_LIMITER_base::_IID);
            assert(_cache);
        }
        return _cache;
    }

protected:
    inline Synth_BRICKWALL_LIMITER(Synth_BRICKWALL_LIMITER_base* b) : Arts::Object(b), _cache(0) {}


public:
    typedef Synth_BRICKWALL_LIMITER_base _base_class;

    inline Synth_BRICKWALL_LIMITER() : Arts::Object(_Creator), _cache(0) {}
    inline Synth_BRICKWALL_LIMITER(const Arts::SubClass& s) :
        Arts::Object(Synth_BRICKWALL_LIMITER_base::_create(s.string())), _cache(0) {}
    inline Synth_BRICKWALL_LIMITER(const Arts::Reference &r) :
        Arts::Object(r.isString()?(Synth_BRICKWALL_LIMITER_base::_fromString(r.string())):(Synth_BRICKWALL_LIMITER_base::_fromReference(r.reference(),true))), _cache(0) {}
    inline Synth_BRICKWALL_LIMITER(const Arts::DynamicCast& c) : Arts::Object(Synth_BRICKWALL_LIMITER_base::_fromDynamicCast(c.object())), _cache(0) {}
    inline Synth_BRICKWALL_LIMITER(const Synth_BRICKWALL_LIMITER& target) : Arts::Object(target._pool), _cache(target._cache) {}
    inline Synth_BRICKWALL_LIMITER(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
    inline static Synth_BRICKWALL_LIMITER null() {return Synth_BRICKWALL_LIMITER((Synth_BRICKWALL_LIMITER_base*)0);}
    inline static Synth_BRICKWALL_LIMITER _from_base(Synth_BRICKWALL_LIMITER_base* b) {return Synth_BRICKWALL_LIMITER(b);}
    inline Synth_BRICKWALL_LIMITER& operator=(const Synth_BRICKWALL_LIMITER& target) {
        if (_pool == target._pool) return *this;
        _pool->Dec();
        _pool = target._pool;
        _cache = target._cache;
        _pool->Inc();
        return *this;
    }
    inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
    inline Synth_BRICKWALL_LIMITER_base* _base() {return _cache?_cache:_method_call();}

    inline Arts::AutoSuspendState autoSuspend();
    inline void start();
    inline void stop();
    inline void streamInit();
    inline void streamStart();
    inline void streamEnd();
};

class ARTS_EXPORT Synth_STD_EQUALIZER_base : virtual public Arts::SynthModule_base {
public:
    static unsigned long _IID; // interface ID

    static Synth_STD_EQUALIZER_base *_create(const std::string& subClass = "Arts::Synth_STD_EQUALIZER");
    static Synth_STD_EQUALIZER_base *_fromString(const std::string& objectref);
    static Synth_STD_EQUALIZER_base *_fromReference(Arts::ObjectReference ref, bool needcopy);

    static Synth_STD_EQUALIZER_base *_fromDynamicCast(const Arts::Object& object);
    inline Synth_STD_EQUALIZER_base *_copy() {
        assert(_refCnt > 0);
        _refCnt++;
        return this;
    }

    virtual std::vector<std::string> _defaultPortsIn() const;
    virtual std::vector<std::string> _defaultPortsOut() const;

    void *_cast(unsigned long iid);

    virtual float low() = 0;
    virtual void low(float newValue) = 0;
    virtual float mid() = 0;
    virtual void mid(float newValue) = 0;
    virtual float high() = 0;
    virtual void high(float newValue) = 0;
    virtual float frequency() = 0;
    virtual void frequency(float newValue) = 0;
    virtual float q() = 0;
    virtual void q(float newValue) = 0;
};

class ARTS_EXPORT Synth_STD_EQUALIZER_stub : virtual public Synth_STD_EQUALIZER_base, virtual public Arts::SynthModule_stub {
protected:
    Synth_STD_EQUALIZER_stub();

public:
    Synth_STD_EQUALIZER_stub(Arts::Connection *connection, long objectID);

    float low();
    void low(float newValue);
    float mid();
    void mid(float newValue);
    float high();
    void high(float newValue);
    float frequency();
    void frequency(float newValue);
    float q();
    void q(float newValue);
};

class ARTS_EXPORT Synth_STD_EQUALIZER_skel : virtual public Synth_STD_EQUALIZER_base, virtual public Arts::SynthModule_skel {
protected:
    // variables for streams
    float *invalue;                           // incoming stream
    float *outvalue;                          // outgoing stream

protected:
    // emitters for change notifications
    inline void low_changed(float newValue) {
        _emit_changed("low_changed",newValue);
    }
    inline void mid_changed(float newValue) {
        _emit_changed("mid_changed",newValue);
    }
    inline void high_changed(float newValue) {
        _emit_changed("high_changed",newValue);
    }
    inline void frequency_changed(float newValue) {
        _emit_changed("frequency_changed",newValue);
    }
    inline void q_changed(float newValue) {
        _emit_changed("q_changed",newValue);
    }

public:
    Synth_STD_EQUALIZER_skel();

    static std::string _interfaceNameSkel();
    std::string _interfaceName();
    bool _isCompatibleWith(const std::string& interfacename);
    void _buildMethodTable();
    void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
};

}
#include "reference.h"
namespace Arts {
class ARTS_EXPORT Synth_STD_EQUALIZER : public Arts::Object {
private:
    static Arts::Object_base* _Creator();
    Synth_STD_EQUALIZER_base *_cache;
    inline Synth_STD_EQUALIZER_base *_method_call() {
        _pool->checkcreate();
        if(_pool->base) {
            _cache=(Synth_STD_EQUALIZER_base *)_pool->base->_cast(Synth_STD_EQUALIZER_base::_IID);
            assert(_cache);
        }
        return _cache;
    }

protected:
    inline Synth_STD_EQUALIZER(Synth_STD_EQUALIZER_base* b) : Arts::Object(b), _cache(0) {}


public:
    typedef Synth_STD_EQUALIZER_base _base_class;

    inline Synth_STD_EQUALIZER() : Arts::Object(_Creator), _cache(0) {}
    inline Synth_STD_EQUALIZER(const Arts::SubClass& s) :
        Arts::Object(Synth_STD_EQUALIZER_base::_create(s.string())), _cache(0) {}
    inline Synth_STD_EQUALIZER(const Arts::Reference &r) :
        Arts::Object(r.isString()?(Synth_STD_EQUALIZER_base::_fromString(r.string())):(Synth_STD_EQUALIZER_base::_fromReference(r.reference(),true))), _cache(0) {}
    inline Synth_STD_EQUALIZER(const Arts::DynamicCast& c) : Arts::Object(Synth_STD_EQUALIZER_base::_fromDynamicCast(c.object())), _cache(0) {}
    inline Synth_STD_EQUALIZER(const Synth_STD_EQUALIZER& target) : Arts::Object(target._pool), _cache(target._cache) {}
    inline Synth_STD_EQUALIZER(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
    inline static Synth_STD_EQUALIZER null() {return Synth_STD_EQUALIZER((Synth_STD_EQUALIZER_base*)0);}
    inline static Synth_STD_EQUALIZER _from_base(Synth_STD_EQUALIZER_base* b) {return Synth_STD_EQUALIZER(b);}
    inline Synth_STD_EQUALIZER& operator=(const Synth_STD_EQUALIZER& target) {
        if (_pool == target._pool) return *this;
        _pool->Dec();
        _pool = target._pool;
        _cache = target._cache;
        _pool->Inc();
        return *this;
    }
    inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
    inline Synth_STD_EQUALIZER_base* _base() {return _cache?_cache:_method_call();}

    inline Arts::AutoSuspendState autoSuspend();
    inline void start();
    inline void stop();
    inline void streamInit();
    inline void streamStart();
    inline void streamEnd();
    inline float low();
    inline void low(float _newValue);
    inline float mid();
    inline void mid(float _newValue);
    inline float high();
    inline void high(float _newValue);
    inline float frequency();
    inline void frequency(float _newValue);
    inline float q();
    inline void q(float _newValue);
};

class ARTS_EXPORT Synth_RC_base : virtual public Arts::SynthModule_base {
public:
    static unsigned long _IID; // interface ID

    static Synth_RC_base *_create(const std::string& subClass = "Arts::Synth_RC");
    static Synth_RC_base *_fromString(const std::string& objectref);
    static Synth_RC_base *_fromReference(Arts::ObjectReference ref, bool needcopy);

    static Synth_RC_base *_fromDynamicCast(const Arts::Object& object);
    inline Synth_RC_base *_copy() {
        assert(_refCnt > 0);
        _refCnt++;
        return this;
    }

    virtual std::vector<std::string> _defaultPortsIn() const;
    virtual std::vector<std::string> _defaultPortsOut() const;

    void *_cast(unsigned long iid);

    virtual float b() = 0;
    virtual void b(float newValue) = 0;
    virtual float f() = 0;
    virtual void f(float newValue) = 0;
};

class ARTS_EXPORT Synth_RC_stub : virtual public Synth_RC_base, virtual public Arts::SynthModule_stub {
protected:
    Synth_RC_stub();

public:
    Synth_RC_stub(Arts::Connection *connection, long objectID);

    float b();
    void b(float newValue);
    float f();
    void f(float newValue);
};

class ARTS_EXPORT Synth_RC_skel : virtual public Synth_RC_base, virtual public Arts::SynthModule_skel {
protected:
    // variables for streams
    float *invalue;                           // incoming stream
    float *outvalue;                          // outgoing stream

protected:
    // emitters for change notifications
    inline void b_changed(float newValue) {
        _emit_changed("b_changed",newValue);
    }
    inline void f_changed(float newValue) {
        _emit_changed("f_changed",newValue);
    }

public:
    Synth_RC_skel();

    static std::string _interfaceNameSkel();
    std::string _interfaceName();
    bool _isCompatibleWith(const std::string& interfacename);
    void _buildMethodTable();
    void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
};

}
#include "reference.h"
namespace Arts {
class ARTS_EXPORT Synth_RC : public Arts::Object {
private:
    static Arts::Object_base* _Creator();
    Synth_RC_base *_cache;
    inline Synth_RC_base *_method_call() {
        _pool->checkcreate();
        if(_pool->base) {
            _cache=(Synth_RC_base *)_pool->base->_cast(Synth_RC_base::_IID);
            assert(_cache);
        }
        return _cache;
    }

protected:
    inline Synth_RC(Synth_RC_base* b) : Arts::Object(b), _cache(0) {}


public:
    typedef Synth_RC_base _base_class;

    inline Synth_RC() : Arts::Object(_Creator), _cache(0) {}
    inline Synth_RC(const Arts::SubClass& s) :
        Arts::Object(Synth_RC_base::_create(s.string())), _cache(0) {}
    inline Synth_RC(const Arts::Reference &r) :
        Arts::Object(r.isString()?(Synth_RC_base::_fromString(r.string())):(Synth_RC_base::_fromReference(r.reference(),true))), _cache(0) {}
    inline Synth_RC(const Arts::DynamicCast& c) : Arts::Object(Synth_RC_base::_fromDynamicCast(c.object())), _cache(0) {}
    inline Synth_RC(const Synth_RC& target) : Arts::Object(target._pool), _cache(target._cache) {}
    inline Synth_RC(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
    inline static Synth_RC null() {return Synth_RC((Synth_RC_base*)0);}
    inline static Synth_RC _from_base(Synth_RC_base* b) {return Synth_RC(b);}
    inline Synth_RC& operator=(const Synth_RC& target) {
        if (_pool == target._pool) return *this;
        _pool->Dec();
        _pool = target._pool;
        _cache = target._cache;
        _pool->Inc();
        return *this;
    }
    inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
    inline Synth_RC_base* _base() {return _cache?_cache:_method_call();}

    inline Arts::AutoSuspendState autoSuspend();
    inline void start();
    inline void stop();
    inline void streamInit();
    inline void streamStart();
    inline void streamEnd();
    inline float b();
    inline void b(float _newValue);
    inline float f();
    inline void f(float _newValue);
};

class ARTS_EXPORT Synth_MOOG_VCF_base : virtual public Arts::SynthModule_base {
public:
    static unsigned long _IID; // interface ID

    static Synth_MOOG_VCF_base *_create(const std::string& subClass = "Arts::Synth_MOOG_VCF");
    static Synth_MOOG_VCF_base *_fromString(const std::string& objectref);
    static Synth_MOOG_VCF_base *_fromReference(Arts::ObjectReference ref, bool needcopy);

    static Synth_MOOG_VCF_base *_fromDynamicCast(const Arts::Object& object);
    inline Synth_MOOG_VCF_base *_copy() {
        assert(_refCnt > 0);
        _refCnt++;
        return this;
    }

    virtual std::vector<std::string> _defaultPortsIn() const;
    virtual std::vector<std::string> _defaultPortsOut() const;

    void *_cast(unsigned long iid);

    virtual float frequency() = 0;
    virtual void frequency(float newValue) = 0;
    virtual float resonance() = 0;
    virtual void resonance(float newValue) = 0;
};

class ARTS_EXPORT Synth_MOOG_VCF_stub : virtual public Synth_MOOG_VCF_base, virtual public Arts::SynthModule_stub {
protected:
    Synth_MOOG_VCF_stub();

public:
    Synth_MOOG_VCF_stub(Arts::Connection *connection, long objectID);

    float frequency();
    void frequency(float newValue);
    float resonance();
    void resonance(float newValue);
};

class ARTS_EXPORT Synth_MOOG_VCF_skel : virtual public Synth_MOOG_VCF_base, virtual public Arts::SynthModule_skel {
protected:
    // variables for streams
    float *invalue;                           // incoming stream
    float *outvalue;                          // outgoing stream

protected:
    // emitters for change notifications
    inline void frequency_changed(float newValue) {
        _emit_changed("frequency_changed",newValue);
    }
    inline void resonance_changed(float newValue) {
        _emit_changed("resonance_changed",newValue);
    }

public:
    Synth_MOOG_VCF_skel();

    static std::string _interfaceNameSkel();
    std::string _interfaceName();
    bool _isCompatibleWith(const std::string& interfacename);
    void _buildMethodTable();
    void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
};

}
#include "reference.h"
namespace Arts {
class ARTS_EXPORT Synth_MOOG_VCF : public Arts::Object {
private:
    static Arts::Object_base* _Creator();
    Synth_MOOG_VCF_base *_cache;
    inline Synth_MOOG_VCF_base *_method_call() {
        _pool->checkcreate();
        if(_pool->base) {
            _cache=(Synth_MOOG_VCF_base *)_pool->base->_cast(Synth_MOOG_VCF_base::_IID);
            assert(_cache);
        }
        return _cache;
    }

protected:
    inline Synth_MOOG_VCF(Synth_MOOG_VCF_base* b) : Arts::Object(b), _cache(0) {}


public:
    typedef Synth_MOOG_VCF_base _base_class;

    inline Synth_MOOG_VCF() : Arts::Object(_Creator), _cache(0) {}
    inline Synth_MOOG_VCF(const Arts::SubClass& s) :
        Arts::Object(Synth_MOOG_VCF_base::_create(s.string())), _cache(0) {}
    inline Synth_MOOG_VCF(const Arts::Reference &r) :
        Arts::Object(r.isString()?(Synth_MOOG_VCF_base::_fromString(r.string())):(Synth_MOOG_VCF_base::_fromReference(r.reference(),true))), _cache(0) {}
    inline Synth_MOOG_VCF(const Arts::DynamicCast& c) : Arts::Object(Synth_MOOG_VCF_base::_fromDynamicCast(c.object())), _cache(0) {}
    inline Synth_MOOG_VCF(const Synth_MOOG_VCF& target) : Arts::Object(target._pool), _cache(target._cache) {}
    inline Synth_MOOG_VCF(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
    inline static Synth_MOOG_VCF null() {return Synth_MOOG_VCF((Synth_MOOG_VCF_base*)0);}
    inline static Synth_MOOG_VCF _from_base(Synth_MOOG_VCF_base* b) {return Synth_MOOG_VCF(b);}
    inline Synth_MOOG_VCF& operator=(const Synth_MOOG_VCF& target) {
        if (_pool == target._pool) return *this;
        _pool->Dec();
        _pool = target._pool;
        _cache = target._cache;
        _pool->Inc();
        return *this;
    }
    inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
    inline Synth_MOOG_VCF_base* _base() {return _cache?_cache:_method_call();}

    inline Arts::AutoSuspendState autoSuspend();
    inline void start();
    inline void stop();
    inline void streamInit();
    inline void streamStart();
    inline void streamEnd();
    inline float frequency();
    inline void frequency(float _newValue);
    inline float resonance();
    inline void resonance(float _newValue);
};

class ARTS_EXPORT Synth_ATAN_SATURATE_base : virtual public Arts::SynthModule_base {
public:
    static unsigned long _IID; // interface ID

    static Synth_ATAN_SATURATE_base *_create(const std::string& subClass = "Arts::Synth_ATAN_SATURATE");
    static Synth_ATAN_SATURATE_base *_fromString(const std::string& objectref);
    static Synth_ATAN_SATURATE_base *_fromReference(Arts::ObjectReference ref, bool needcopy);

    static Synth_ATAN_SATURATE_base *_fromDynamicCast(const Arts::Object& object);
    inline Synth_ATAN_SATURATE_base *_copy() {
        assert(_refCnt > 0);
        _refCnt++;
        return this;
    }

    virtual std::vector<std::string> _defaultPortsIn() const;
    virtual std::vector<std::string> _defaultPortsOut() const;

    void *_cast(unsigned long iid);

    virtual float inscale() = 0;
    virtual void inscale(float newValue) = 0;
};

class ARTS_EXPORT Synth_ATAN_SATURATE_stub : virtual public Synth_ATAN_SATURATE_base, virtual public Arts::SynthModule_stub {
protected:
    Synth_ATAN_SATURATE_stub();

public:
    Synth_ATAN_SATURATE_stub(Arts::Connection *connection, long objectID);

    float inscale();
    void inscale(float newValue);
};

class ARTS_EXPORT Synth_ATAN_SATURATE_skel : virtual public Synth_ATAN_SATURATE_base, virtual public Arts::SynthModule_skel {
protected:
    // variables for streams
    float *invalue;                           // incoming stream
    float *outvalue;                          // outgoing stream

protected:
    // emitters for change notifications
    inline void inscale_changed(float newValue) {
        _emit_changed("inscale_changed",newValue);
    }

public:
    Synth_ATAN_SATURATE_skel();

    static std::string _interfaceNameSkel();
    std::string _interfaceName();
    bool _isCompatibleWith(const std::string& interfacename);
    void _buildMethodTable();
    void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
};

}
#include "reference.h"
namespace Arts {
class ARTS_EXPORT Synth_ATAN_SATURATE : public Arts::Object {
private:
    static Arts::Object_base* _Creator();
    Synth_ATAN_SATURATE_base *_cache;
    inline Synth_ATAN_SATURATE_base *_method_call() {
        _pool->checkcreate();
        if(_pool->base) {
            _cache=(Synth_ATAN_SATURATE_base *)_pool->base->_cast(Synth_ATAN_SATURATE_base::_IID);
            assert(_cache);
        }
        return _cache;
    }

protected:
    inline Synth_ATAN_SATURATE(Synth_ATAN_SATURATE_base* b) : Arts::Object(b), _cache(0) {}


public:
    typedef Synth_ATAN_SATURATE_base _base_class;

    inline Synth_ATAN_SATURATE() : Arts::Object(_Creator), _cache(0) {}
    inline Synth_ATAN_SATURATE(const Arts::SubClass& s) :
        Arts::Object(Synth_ATAN_SATURATE_base::_create(s.string())), _cache(0) {}
    inline Synth_ATAN_SATURATE(const Arts::Reference &r) :
        Arts::Object(r.isString()?(Synth_ATAN_SATURATE_base::_fromString(r.string())):(Synth_ATAN_SATURATE_base::_fromReference(r.reference(),true))), _cache(0) {}
    inline Synth_ATAN_SATURATE(const Arts::DynamicCast& c) : Arts::Object(Synth_ATAN_SATURATE_base::_fromDynamicCast(c.object())), _cache(0) {}
    inline Synth_ATAN_SATURATE(const Synth_ATAN_SATURATE& target) : Arts::Object(target._pool), _cache(target._cache) {}
    inline Synth_ATAN_SATURATE(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
    inline static Synth_ATAN_SATURATE null() {return Synth_ATAN_SATURATE((Synth_ATAN_SATURATE_base*)0);}
    inline static Synth_ATAN_SATURATE _from_base(Synth_ATAN_SATURATE_base* b) {return Synth_ATAN_SATURATE(b);}
    inline Synth_ATAN_SATURATE& operator=(const Synth_ATAN_SATURATE& target) {
        if (_pool == target._pool) return *this;
        _pool->Dec();
        _pool = target._pool;
        _cache = target._cache;
        _pool->Inc();
        return *this;
    }
    inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
    inline Synth_ATAN_SATURATE_base* _base() {return _cache?_cache:_method_call();}

    inline Arts::AutoSuspendState autoSuspend();
    inline void start();
    inline void stop();
    inline void streamInit();
    inline void streamStart();
    inline void streamEnd();
    inline float inscale();
    inline void inscale(float _newValue);
};

class ARTS_EXPORT Synth_MIDI_TEST_base : virtual public Arts::SynthModule_base,
    virtual public Arts::MidiPort_base {
public:
    static unsigned long _IID; // interface ID

    static Synth_MIDI_TEST_base *_create(const std::string& subClass = "Arts::Synth_MIDI_TEST");
    static Synth_MIDI_TEST_base *_fromString(const std::string& objectref);
    static Synth_MIDI_TEST_base *_fromReference(Arts::ObjectReference ref, bool needcopy);

    static Synth_MIDI_TEST_base *_fromDynamicCast(const Arts::Object& object);
    inline Synth_MIDI_TEST_base *_copy() {
        assert(_refCnt > 0);
        _refCnt++;
        return this;
    }

    virtual std::vector<std::string> _defaultPortsIn() const;
    virtual std::vector<std::string> _defaultPortsOut() const;

    void *_cast(unsigned long iid);

    virtual std::string filename() = 0;
    virtual void filename(const std::string& newValue) = 0;
    virtual std::string busname() = 0;
    virtual void busname(const std::string& newValue) = 0;
};

class ARTS_EXPORT Synth_MIDI_TEST_stub : virtual public Synth_MIDI_TEST_base, virtual public Arts::SynthModule_stub,
    virtual public Arts::MidiPort_stub {
protected:
    Synth_MIDI_TEST_stub();

public:
    Synth_MIDI_TEST_stub(Arts::Connection *connection, long objectID);

    std::string filename();
    void filename(const std::string& newValue);
    std::string busname();
    void busname(const std::string& newValue);
};

class ARTS_EXPORT Synth_MIDI_TEST_skel : virtual public Synth_MIDI_TEST_base, virtual public Arts::SynthModule_skel,
    virtual public Arts::MidiPort_skel {
protected:
    // emitters for change notifications
    inline void filename_changed(const std::string& newValue) {
        _emit_changed("filename_changed",newValue);
    }
    inline void busname_changed(const std::string& newValue) {
        _emit_changed("busname_changed",newValue);
    }

public:
    Synth_MIDI_TEST_skel();

    static std::string _interfaceNameSkel();
    std::string _interfaceName();
    bool _isCompatibleWith(const std::string& interfacename);
    void _buildMethodTable();
    void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
};

}
#include "reference.h"
namespace Arts {
class ARTS_EXPORT Synth_MIDI_TEST : public Arts::Object {
private:
    static Arts::Object_base* _Creator();
    Synth_MIDI_TEST_base *_cache;
    inline Synth_MIDI_TEST_base *_method_call() {
        _pool->checkcreate();
        if(_pool->base) {
            _cache=(Synth_MIDI_TEST_base *)_pool->base->_cast(Synth_MIDI_TEST_base::_IID);
            assert(_cache);
        }
        return _cache;
    }

protected:
    inline Synth_MIDI_TEST(Synth_MIDI_TEST_base* b) : Arts::Object(b), _cache(0) {}


public:
    typedef Synth_MIDI_TEST_base _base_class;

    inline Synth_MIDI_TEST() : Arts::Object(_Creator), _cache(0) {}
    inline Synth_MIDI_TEST(const Arts::SubClass& s) :
        Arts::Object(Synth_MIDI_TEST_base::_create(s.string())), _cache(0) {}
    inline Synth_MIDI_TEST(const Arts::Reference &r) :
        Arts::Object(r.isString()?(Synth_MIDI_TEST_base::_fromString(r.string())):(Synth_MIDI_TEST_base::_fromReference(r.reference(),true))), _cache(0) {}
    inline Synth_MIDI_TEST(const Arts::DynamicCast& c) : Arts::Object(Synth_MIDI_TEST_base::_fromDynamicCast(c.object())), _cache(0) {}
    inline Synth_MIDI_TEST(const Synth_MIDI_TEST& target) : Arts::Object(target._pool), _cache(target._cache) {}
    inline Synth_MIDI_TEST(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
    inline static Synth_MIDI_TEST null() {return Synth_MIDI_TEST((Synth_MIDI_TEST_base*)0);}
    inline static Synth_MIDI_TEST _from_base(Synth_MIDI_TEST_base* b) {return Synth_MIDI_TEST(b);}
    inline Synth_MIDI_TEST& operator=(const Synth_MIDI_TEST& target) {
        if (_pool == target._pool) return *this;
        _pool->Dec();
        _pool = target._pool;
        _cache = target._cache;
        _pool->Inc();
        return *this;
    }
    inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
    inline operator Arts::MidiPort() const { return Arts::MidiPort(*_pool); }
    inline Synth_MIDI_TEST_base* _base() {return _cache?_cache:_method_call();}

    inline Arts::AutoSuspendState autoSuspend();
    inline void start();
    inline void stop();
    inline void streamInit();
    inline void streamStart();
    inline void streamEnd();
    inline Arts::TimeStamp time();
    inline Arts::TimeStamp playTime();
    inline void processCommand(const Arts::MidiCommand& command);
    inline void processEvent(const Arts::MidiEvent& event);
    inline std::string filename();
    inline void filename(const std::string& _newValue);
    inline std::string busname();
    inline void busname(const std::string& _newValue);
};

class ARTS_EXPORT Synth_SEQUENCE_base : virtual public Arts::SynthModule_base {
public:
    static unsigned long _IID; // interface ID

    static Synth_SEQUENCE_base *_create(const std::string& subClass = "Arts::Synth_SEQUENCE");
    static Synth_SEQUENCE_base *_fromString(const std::string& objectref);
    static Synth_SEQUENCE_base *_fromReference(Arts::ObjectReference ref, bool needcopy);

    static Synth_SEQUENCE_base *_fromDynamicCast(const Arts::Object& object);
    inline Synth_SEQUENCE_base *_copy() {
        assert(_refCnt > 0);
        _refCnt++;
        return this;
    }

    virtual std::vector<std::string> _defaultPortsIn() const;
    virtual std::vector<std::string> _defaultPortsOut() const;

    void *_cast(unsigned long iid);

    virtual float speed() = 0;
    virtual void speed(float newValue) = 0;
    virtual std::string seq() = 0;
    virtual void seq(const std::string& newValue) = 0;
};

class ARTS_EXPORT Synth_SEQUENCE_stub : virtual public Synth_SEQUENCE_base, virtual public Arts::SynthModule_stub {
protected:
    Synth_SEQUENCE_stub();

public:
    Synth_SEQUENCE_stub(Arts::Connection *connection, long objectID);

    float speed();
    void speed(float newValue);
    std::string seq();
    void seq(const std::string& newValue);
};

class ARTS_EXPORT Synth_SEQUENCE_skel : virtual public Synth_SEQUENCE_base, virtual public Arts::SynthModule_skel {
protected:
    // variables for streams
    float *frequency;                         // outgoing stream
    float *pos;                               // outgoing stream

protected:
    // emitters for change notifications
    inline void speed_changed(float newValue) {
        _emit_changed("speed_changed",newValue);
    }
    inline void seq_changed(const std::string& newValue) {
        _emit_changed("seq_changed",newValue);
    }

public:
    Synth_SEQUENCE_skel();

    static std::string _interfaceNameSkel();
    std::string _interfaceName();
    bool _isCompatibleWith(const std::string& interfacename);
    void _buildMethodTable();
    void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
};

}
#include "reference.h"
namespace Arts {
class ARTS_EXPORT Synth_SEQUENCE : public Arts::Object {
private:
    static Arts::Object_base* _Creator();
    Synth_SEQUENCE_base *_cache;
    inline Synth_SEQUENCE_base *_method_call() {
        _pool->checkcreate();
        if(_pool->base) {
            _cache=(Synth_SEQUENCE_base *)_pool->base->_cast(Synth_SEQUENCE_base::_IID);
            assert(_cache);
        }
        return _cache;
    }

protected:
    inline Synth_SEQUENCE(Synth_SEQUENCE_base* b) : Arts::Object(b), _cache(0) {}


public:
    typedef Synth_SEQUENCE_base _base_class;

    inline Synth_SEQUENCE() : Arts::Object(_Creator), _cache(0) {}
    inline Synth_SEQUENCE(const Arts::SubClass& s) :
        Arts::Object(Synth_SEQUENCE_base::_create(s.string())), _cache(0) {}
    inline Synth_SEQUENCE(const Arts::Reference &r) :
        Arts::Object(r.isString()?(Synth_SEQUENCE_base::_fromString(r.string())):(Synth_SEQUENCE_base::_fromReference(r.reference(),true))), _cache(0) {}
    inline Synth_SEQUENCE(const Arts::DynamicCast& c) : Arts::Object(Synth_SEQUENCE_base::_fromDynamicCast(c.object())), _cache(0) {}
    inline Synth_SEQUENCE(const Synth_SEQUENCE& target) : Arts::Object(target._pool), _cache(target._cache) {}
    inline Synth_SEQUENCE(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
    inline static Synth_SEQUENCE null() {return Synth_SEQUENCE((Synth_SEQUENCE_base*)0);}
    inline static Synth_SEQUENCE _from_base(Synth_SEQUENCE_base* b) {return Synth_SEQUENCE(b);}
    inline Synth_SEQUENCE& operator=(const Synth_SEQUENCE& target) {
        if (_pool == target._pool) return *this;
        _pool->Dec();
        _pool = target._pool;
        _cache = target._cache;
        _pool->Inc();
        return *this;
    }
    inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
    inline Synth_SEQUENCE_base* _base() {return _cache?_cache:_method_call();}

    inline Arts::AutoSuspendState autoSuspend();
    inline void start();
    inline void stop();
    inline void streamInit();
    inline void streamStart();
    inline void streamEnd();
    inline float speed();
    inline void speed(float _newValue);
    inline std::string seq();
    inline void seq(const std::string& _newValue);
};

class ARTS_EXPORT Synth_SEQUENCE_FREQ_base : virtual public Arts::SynthModule_base {
public:
    static unsigned long _IID; // interface ID

    static Synth_SEQUENCE_FREQ_base *_create(const std::string& subClass = "Arts::Synth_SEQUENCE_FREQ");
    static Synth_SEQUENCE_FREQ_base *_fromString(const std::string& objectref);
    static Synth_SEQUENCE_FREQ_base *_fromReference(Arts::ObjectReference ref, bool needcopy);

    static Synth_SEQUENCE_FREQ_base *_fromDynamicCast(const Arts::Object& object);
    inline Synth_SEQUENCE_FREQ_base *_copy() {
        assert(_refCnt > 0);
        _refCnt++;
        return this;
    }

    virtual std::vector<std::string> _defaultPortsIn() const;
    virtual std::vector<std::string> _defaultPortsOut() const;

    void *_cast(unsigned long iid);

    virtual float speed() = 0;
    virtual void speed(float newValue) = 0;
    virtual std::string seq() = 0;
    virtual void seq(const std::string& newValue) = 0;
};

class ARTS_EXPORT Synth_SEQUENCE_FREQ_stub : virtual public Synth_SEQUENCE_FREQ_base, virtual public Arts::SynthModule_stub {
protected:
    Synth_SEQUENCE_FREQ_stub();

public:
    Synth_SEQUENCE_FREQ_stub(Arts::Connection *connection, long objectID);

    float speed();
    void speed(float newValue);
    std::string seq();
    void seq(const std::string& newValue);
};

class ARTS_EXPORT Synth_SEQUENCE_FREQ_skel : virtual public Synth_SEQUENCE_FREQ_base, virtual public Arts::SynthModule_skel {
protected:
    // variables for streams
    float *frequency;                         // outgoing stream
    float *pos;                               // outgoing stream

protected:
    // emitters for change notifications
    inline void speed_changed(float newValue) {
        _emit_changed("speed_changed",newValue);
    }
    inline void seq_changed(const std::string& newValue) {
        _emit_changed("seq_changed",newValue);
    }

public:
    Synth_SEQUENCE_FREQ_skel();

    static std::string _interfaceNameSkel();
    std::string _interfaceName();
    bool _isCompatibleWith(const std::string& interfacename);
    void _buildMethodTable();
    void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
};

}
#include "reference.h"
namespace Arts {
class ARTS_EXPORT Synth_SEQUENCE_FREQ : public Arts::Object {
private:
    static Arts::Object_base* _Creator();
    Synth_SEQUENCE_FREQ_base *_cache;
    inline Synth_SEQUENCE_FREQ_base *_method_call() {
        _pool->checkcreate();
        if(_pool->base) {
            _cache=(Synth_SEQUENCE_FREQ_base *)_pool->base->_cast(Synth_SEQUENCE_FREQ_base::_IID);
            assert(_cache);
        }
        return _cache;
    }

protected:
    inline Synth_SEQUENCE_FREQ(Synth_SEQUENCE_FREQ_base* b) : Arts::Object(b), _cache(0) {}


public:
    typedef Synth_SEQUENCE_FREQ_base _base_class;

    inline Synth_SEQUENCE_FREQ() : Arts::Object(_Creator), _cache(0) {}
    inline Synth_SEQUENCE_FREQ(const Arts::SubClass& s) :
        Arts::Object(Synth_SEQUENCE_FREQ_base::_create(s.string())), _cache(0) {}
    inline Synth_SEQUENCE_FREQ(const Arts::Reference &r) :
        Arts::Object(r.isString()?(Synth_SEQUENCE_FREQ_base::_fromString(r.string())):(Synth_SEQUENCE_FREQ_base::_fromReference(r.reference(),true))), _cache(0) {}
    inline Synth_SEQUENCE_FREQ(const Arts::DynamicCast& c) : Arts::Object(Synth_SEQUENCE_FREQ_base::_fromDynamicCast(c.object())), _cache(0) {}
    inline Synth_SEQUENCE_FREQ(const Synth_SEQUENCE_FREQ& target) : Arts::Object(target._pool), _cache(target._cache) {}
    inline Synth_SEQUENCE_FREQ(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
    inline static Synth_SEQUENCE_FREQ null() {return Synth_SEQUENCE_FREQ((Synth_SEQUENCE_FREQ_base*)0);}
    inline static Synth_SEQUENCE_FREQ _from_base(Synth_SEQUENCE_FREQ_base* b) {return Synth_SEQUENCE_FREQ(b);}
    inline Synth_SEQUENCE_FREQ& operator=(const Synth_SEQUENCE_FREQ& target) {
        if (_pool == target._pool) return *this;
        _pool->Dec();
        _pool = target._pool;
        _cache = target._cache;
        _pool->Inc();
        return *this;
    }
    inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
    inline Synth_SEQUENCE_FREQ_base* _base() {return _cache?_cache:_method_call();}

    inline Arts::AutoSuspendState autoSuspend();
    inline void start();
    inline void stop();
    inline void streamInit();
    inline void streamStart();
    inline void streamEnd();
    inline float speed();
    inline void speed(float _newValue);
    inline std::string seq();
    inline void seq(const std::string& _newValue);
};

class ARTS_EXPORT Synth_FM_SOURCE_base : virtual public Arts::SynthModule_base {
public:
    static unsigned long _IID; // interface ID

    static Synth_FM_SOURCE_base *_create(const std::string& subClass = "Arts::Synth_FM_SOURCE");
    static Synth_FM_SOURCE_base *_fromString(const std::string& objectref);
    static Synth_FM_SOURCE_base *_fromReference(Arts::ObjectReference ref, bool needcopy);

    static Synth_FM_SOURCE_base *_fromDynamicCast(const Arts::Object& object);
    inline Synth_FM_SOURCE_base *_copy() {
        assert(_refCnt > 0);
        _refCnt++;
        return this;
    }

    virtual std::vector<std::string> _defaultPortsIn() const;
    virtual std::vector<std::string> _defaultPortsOut() const;

    void *_cast(unsigned long iid);

};

class ARTS_EXPORT Synth_FM_SOURCE_stub : virtual public Synth_FM_SOURCE_base, virtual public Arts::SynthModule_stub {
protected:
    Synth_FM_SOURCE_stub();

public:
    Synth_FM_SOURCE_stub(Arts::Connection *connection, long objectID);

};

class ARTS_EXPORT Synth_FM_SOURCE_skel : virtual public Synth_FM_SOURCE_base, virtual public Arts::SynthModule_skel {
protected:
    // variables for streams
    float *frequency;                         // incoming stream
    float *modulator;                         // incoming stream
    float *modlevel;                          // incoming stream
    float *pos;                               // outgoing stream

public:
    Synth_FM_SOURCE_skel();

    static std::string _interfaceNameSkel();
    std::string _interfaceName();
    bool _isCompatibleWith(const std::string& interfacename);
    void _buildMethodTable();
    void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
};

}
#include "reference.h"
namespace Arts {
class ARTS_EXPORT Synth_FM_SOURCE : public Arts::Object {
private:
    static Arts::Object_base* _Creator();
    Synth_FM_SOURCE_base *_cache;
    inline Synth_FM_SOURCE_base *_method_call() {
        _pool->checkcreate();
        if(_pool->base) {
            _cache=(Synth_FM_SOURCE_base *)_pool->base->_cast(Synth_FM_SOURCE_base::_IID);
            assert(_cache);
        }
        return _cache;
    }

protected:
    inline Synth_FM_SOURCE(Synth_FM_SOURCE_base* b) : Arts::Object(b), _cache(0) {}


public:
    typedef Synth_FM_SOURCE_base _base_class;

    inline Synth_FM_SOURCE() : Arts::Object(_Creator), _cache(0) {}
    inline Synth_FM_SOURCE(const Arts::SubClass& s) :
        Arts::Object(Synth_FM_SOURCE_base::_create(s.string())), _cache(0) {}
    inline Synth_FM_SOURCE(const Arts::Reference &r) :
        Arts::Object(r.isString()?(Synth_FM_SOURCE_base::_fromString(r.string())):(Synth_FM_SOURCE_base::_fromReference(r.reference(),true))), _cache(0) {}
    inline Synth_FM_SOURCE(const Arts::DynamicCast& c) : Arts::Object(Synth_FM_SOURCE_base::_fromDynamicCast(c.object())), _cache(0) {}
    inline Synth_FM_SOURCE(const Synth_FM_SOURCE& target) : Arts::Object(target._pool), _cache(target._cache) {}
    inline Synth_FM_SOURCE(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
    inline static Synth_FM_SOURCE null() {return Synth_FM_SOURCE((Synth_FM_SOURCE_base*)0);}
    inline static Synth_FM_SOURCE _from_base(Synth_FM_SOURCE_base* b) {return Synth_FM_SOURCE(b);}
    inline Synth_FM_SOURCE& operator=(const Synth_FM_SOURCE& target) {
        if (_pool == target._pool) return *this;
        _pool->Dec();
        _pool = target._pool;
        _cache = target._cache;
        _pool->Inc();
        return *this;
    }
    inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
    inline Synth_FM_SOURCE_base* _base() {return _cache?_cache:_method_call();}

    inline Arts::AutoSuspendState autoSuspend();
    inline void start();
    inline void stop();
    inline void streamInit();
    inline void streamStart();
    inline void streamEnd();
};

class ARTS_EXPORT Synth_WAVE_TRI_base : virtual public Arts::SynthModule_base {
public:
    static unsigned long _IID; // interface ID

    static Synth_WAVE_TRI_base *_create(const std::string& subClass = "Arts::Synth_WAVE_TRI");
    static Synth_WAVE_TRI_base *_fromString(const std::string& objectref);
    static Synth_WAVE_TRI_base *_fromReference(Arts::ObjectReference ref, bool needcopy);

    static Synth_WAVE_TRI_base *_fromDynamicCast(const Arts::Object& object);
    inline Synth_WAVE_TRI_base *_copy() {
        assert(_refCnt > 0);
        _refCnt++;
        return this;
    }

    virtual std::vector<std::string> _defaultPortsIn() const;
    virtual std::vector<std::string> _defaultPortsOut() const;

    void *_cast(unsigned long iid);

};

class ARTS_EXPORT Synth_WAVE_TRI_stub : virtual public Synth_WAVE_TRI_base, virtual public Arts::SynthModule_stub {
protected:
    Synth_WAVE_TRI_stub();

public:
    Synth_WAVE_TRI_stub(Arts::Connection *connection, long objectID);

};

class ARTS_EXPORT Synth_WAVE_TRI_skel : virtual public Synth_WAVE_TRI_base, virtual public Arts::SynthModule_skel {
protected:
    // variables for streams
    float *pos;                               // incoming stream
    float *outvalue;                          // outgoing stream

public:
    Synth_WAVE_TRI_skel();

    static std::string _interfaceNameSkel();
    std::string _interfaceName();
    bool _isCompatibleWith(const std::string& interfacename);
    void _buildMethodTable();
    void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
};

}
#include "reference.h"
namespace Arts {
class ARTS_EXPORT Synth_WAVE_TRI : public Arts::Object {
private:
    static Arts::Object_base* _Creator();
    Synth_WAVE_TRI_base *_cache;
    inline Synth_WAVE_TRI_base *_method_call() {
        _pool->checkcreate();
        if(_pool->base) {
            _cache=(Synth_WAVE_TRI_base *)_pool->base->_cast(Synth_WAVE_TRI_base::_IID);
            assert(_cache);
        }
        return _cache;
    }

protected:
    inline Synth_WAVE_TRI(Synth_WAVE_TRI_base* b) : Arts::Object(b), _cache(0) {}


public:
    typedef Synth_WAVE_TRI_base _base_class;

    inline Synth_WAVE_TRI() : Arts::Object(_Creator), _cache(0) {}
    inline Synth_WAVE_TRI(const Arts::SubClass& s) :
        Arts::Object(Synth_WAVE_TRI_base::_create(s.string())), _cache(0) {}
    inline Synth_WAVE_TRI(const Arts::Reference &r) :
        Arts::Object(r.isString()?(Synth_WAVE_TRI_base::_fromString(r.string())):(Synth_WAVE_TRI_base::_fromReference(r.reference(),true))), _cache(0) {}
    inline Synth_WAVE_TRI(const Arts::DynamicCast& c) : Arts::Object(Synth_WAVE_TRI_base::_fromDynamicCast(c.object())), _cache(0) {}
    inline Synth_WAVE_TRI(const Synth_WAVE_TRI& target) : Arts::Object(target._pool), _cache(target._cache) {}
    inline Synth_WAVE_TRI(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
    inline static Synth_WAVE_TRI null() {return Synth_WAVE_TRI((Synth_WAVE_TRI_base*)0);}
    inline static Synth_WAVE_TRI _from_base(Synth_WAVE_TRI_base* b) {return Synth_WAVE_TRI(b);}
    inline Synth_WAVE_TRI& operator=(const Synth_WAVE_TRI& target) {
        if (_pool == target._pool) return *this;
        _pool->Dec();
        _pool = target._pool;
        _cache = target._cache;
        _pool->Inc();
        return *this;
    }
    inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
    inline Synth_WAVE_TRI_base* _base() {return _cache?_cache:_method_call();}

    inline Arts::AutoSuspendState autoSuspend();
    inline void start();
    inline void stop();
    inline void streamInit();
    inline void streamStart();
    inline void streamEnd();
};

class ARTS_EXPORT Synth_NOISE_base : virtual public Arts::SynthModule_base {
public:
    static unsigned long _IID; // interface ID

    static Synth_NOISE_base *_create(const std::string& subClass = "Arts::Synth_NOISE");
    static Synth_NOISE_base *_fromString(const std::string& objectref);
    static Synth_NOISE_base *_fromReference(Arts::ObjectReference ref, bool needcopy);

    static Synth_NOISE_base *_fromDynamicCast(const Arts::Object& object);
    inline Synth_NOISE_base *_copy() {
        assert(_refCnt > 0);
        _refCnt++;
        return this;
    }

    virtual std::vector<std::string> _defaultPortsIn() const;
    virtual std::vector<std::string> _defaultPortsOut() const;

    void *_cast(unsigned long iid);

};

class ARTS_EXPORT Synth_NOISE_stub : virtual public Synth_NOISE_base, virtual public Arts::SynthModule_stub {
protected:
    Synth_NOISE_stub();

public:
    Synth_NOISE_stub(Arts::Connection *connection, long objectID);

};

class ARTS_EXPORT Synth_NOISE_skel : virtual public Synth_NOISE_base, virtual public Arts::SynthModule_skel {
protected:
    // variables for streams
    float *outvalue;                          // outgoing stream

public:
    Synth_NOISE_skel();

    static std::string _interfaceNameSkel();
    std::string _interfaceName();
    bool _isCompatibleWith(const std::string& interfacename);
    void _buildMethodTable();
    void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
};

}
#include "reference.h"
namespace Arts {
class ARTS_EXPORT Synth_NOISE : public Arts::Object {
private:
    static Arts::Object_base* _Creator();
    Synth_NOISE_base *_cache;
    inline Synth_NOISE_base *_method_call() {
        _pool->checkcreate();
        if(_pool->base) {
            _cache=(Synth_NOISE_base *)_pool->base->_cast(Synth_NOISE_base::_IID);
            assert(_cache);
        }
        return _cache;
    }

protected:
    inline Synth_NOISE(Synth_NOISE_base* b) : Arts::Object(b), _cache(0) {}


public:
    typedef Synth_NOISE_base _base_class;

    inline Synth_NOISE() : Arts::Object(_Creator), _cache(0) {}
    inline Synth_NOISE(const Arts::SubClass& s) :
        Arts::Object(Synth_NOISE_base::_create(s.string())), _cache(0) {}
    inline Synth_NOISE(const Arts::Reference &r) :
        Arts::Object(r.isString()?(Synth_NOISE_base::_fromString(r.string())):(Synth_NOISE_base::_fromReference(r.reference(),true))), _cache(0) {}
    inline Synth_NOISE(const Arts::DynamicCast& c) : Arts::Object(Synth_NOISE_base::_fromDynamicCast(c.object())), _cache(0) {}
    inline Synth_NOISE(const Synth_NOISE& target) : Arts::Object(target._pool), _cache(target._cache) {}
    inline Synth_NOISE(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
    inline static Synth_NOISE null() {return Synth_NOISE((Synth_NOISE_base*)0);}
    inline static Synth_NOISE _from_base(Synth_NOISE_base* b) {return Synth_NOISE(b);}
    inline Synth_NOISE& operator=(const Synth_NOISE& target) {
        if (_pool == target._pool) return *this;
        _pool->Dec();
        _pool = target._pool;
        _cache = target._cache;
        _pool->Inc();
        return *this;
    }
    inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
    inline Synth_NOISE_base* _base() {return _cache?_cache:_method_call();}

    inline Arts::AutoSuspendState autoSuspend();
    inline void start();
    inline void stop();
    inline void streamInit();
    inline void streamStart();
    inline void streamEnd();
};

class ARTS_EXPORT Synth_WAVE_SQUARE_base : virtual public Arts::SynthModule_base {
public:
    static unsigned long _IID; // interface ID

    static Synth_WAVE_SQUARE_base *_create(const std::string& subClass = "Arts::Synth_WAVE_SQUARE");
    static Synth_WAVE_SQUARE_base *_fromString(const std::string& objectref);
    static Synth_WAVE_SQUARE_base *_fromReference(Arts::ObjectReference ref, bool needcopy);

    static Synth_WAVE_SQUARE_base *_fromDynamicCast(const Arts::Object& object);
    inline Synth_WAVE_SQUARE_base *_copy() {
        assert(_refCnt > 0);
        _refCnt++;
        return this;
    }

    virtual std::vector<std::string> _defaultPortsIn() const;
    virtual std::vector<std::string> _defaultPortsOut() const;

    void *_cast(unsigned long iid);

};

class ARTS_EXPORT Synth_WAVE_SQUARE_stub : virtual public Synth_WAVE_SQUARE_base, virtual public Arts::SynthModule_stub {
protected:
    Synth_WAVE_SQUARE_stub();

public:
    Synth_WAVE_SQUARE_stub(Arts::Connection *connection, long objectID);

};

class ARTS_EXPORT Synth_WAVE_SQUARE_skel : virtual public Synth_WAVE_SQUARE_base, virtual public Arts::SynthModule_skel {
protected:
    // variables for streams
    float *pos;                               // incoming stream
    float *outvalue;                          // outgoing stream

public:
    Synth_WAVE_SQUARE_skel();

    static std::string _interfaceNameSkel();
    std::string _interfaceName();
    bool _isCompatibleWith(const std::string& interfacename);
    void _buildMethodTable();
    void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
};

}
#include "reference.h"
namespace Arts {
class ARTS_EXPORT Synth_WAVE_SQUARE : public Arts::Object {
private:
    static Arts::Object_base* _Creator();
    Synth_WAVE_SQUARE_base *_cache;
    inline Synth_WAVE_SQUARE_base *_method_call() {
        _pool->checkcreate();
        if(_pool->base) {
            _cache=(Synth_WAVE_SQUARE_base *)_pool->base->_cast(Synth_WAVE_SQUARE_base::_IID);
            assert(_cache);
        }
        return _cache;
    }

protected:
    inline Synth_WAVE_SQUARE(Synth_WAVE_SQUARE_base* b) : Arts::Object(b), _cache(0) {}


public:
    typedef Synth_WAVE_SQUARE_base _base_class;

    inline Synth_WAVE_SQUARE() : Arts::Object(_Creator), _cache(0) {}
    inline Synth_WAVE_SQUARE(const Arts::SubClass& s) :
        Arts::Object(Synth_WAVE_SQUARE_base::_create(s.string())), _cache(0) {}
    inline Synth_WAVE_SQUARE(const Arts::Reference &r) :
        Arts::Object(r.isString()?(Synth_WAVE_SQUARE_base::_fromString(r.string())):(Synth_WAVE_SQUARE_base::_fromReference(r.reference(),true))), _cache(0) {}
    inline Synth_WAVE_SQUARE(const Arts::DynamicCast& c) : Arts::Object(Synth_WAVE_SQUARE_base::_fromDynamicCast(c.object())), _cache(0) {}
    inline Synth_WAVE_SQUARE(const Synth_WAVE_SQUARE& target) : Arts::Object(target._pool), _cache(target._cache) {}
    inline Synth_WAVE_SQUARE(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
    inline static Synth_WAVE_SQUARE null() {return Synth_WAVE_SQUARE((Synth_WAVE_SQUARE_base*)0);}
    inline static Synth_WAVE_SQUARE _from_base(Synth_WAVE_SQUARE_base* b) {return Synth_WAVE_SQUARE(b);}
    inline Synth_WAVE_SQUARE& operator=(const Synth_WAVE_SQUARE& target) {
        if (_pool == target._pool) return *this;
        _pool->Dec();
        _pool = target._pool;
        _cache = target._cache;
        _pool->Inc();
        return *this;
    }
    inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
    inline Synth_WAVE_SQUARE_base* _base() {return _cache?_cache:_method_call();}

    inline Arts::AutoSuspendState autoSuspend();
    inline void start();
    inline void stop();
    inline void streamInit();
    inline void streamStart();
    inline void streamEnd();
};

class ARTS_EXPORT Synth_WAVE_SOFTSAW_base : virtual public Arts::SynthModule_base {
public:
    static unsigned long _IID; // interface ID

    static Synth_WAVE_SOFTSAW_base *_create(const std::string& subClass = "Arts::Synth_WAVE_SOFTSAW");
    static Synth_WAVE_SOFTSAW_base *_fromString(const std::string& objectref);
    static Synth_WAVE_SOFTSAW_base *_fromReference(Arts::ObjectReference ref, bool needcopy);

    static Synth_WAVE_SOFTSAW_base *_fromDynamicCast(const Arts::Object& object);
    inline Synth_WAVE_SOFTSAW_base *_copy() {
        assert(_refCnt > 0);
        _refCnt++;
        return this;
    }

    virtual std::vector<std::string> _defaultPortsIn() const;
    virtual std::vector<std::string> _defaultPortsOut() const;

    void *_cast(unsigned long iid);

};

class ARTS_EXPORT Synth_WAVE_SOFTSAW_stub : virtual public Synth_WAVE_SOFTSAW_base, virtual public Arts::SynthModule_stub {
protected:
    Synth_WAVE_SOFTSAW_stub();

public:
    Synth_WAVE_SOFTSAW_stub(Arts::Connection *connection, long objectID);

};

class ARTS_EXPORT Synth_WAVE_SOFTSAW_skel : virtual public Synth_WAVE_SOFTSAW_base, virtual public Arts::SynthModule_skel {
protected:
    // variables for streams
    float *pos;                               // incoming stream
    float *outvalue;                          // outgoing stream

public:
    Synth_WAVE_SOFTSAW_skel();

    static std::string _interfaceNameSkel();
    std::string _interfaceName();
    bool _isCompatibleWith(const std::string& interfacename);
    void _buildMethodTable();
    void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
};

}
#include "reference.h"
namespace Arts {
class ARTS_EXPORT Synth_WAVE_SOFTSAW : public Arts::Object {
private:
    static Arts::Object_base* _Creator();
    Synth_WAVE_SOFTSAW_base *_cache;
    inline Synth_WAVE_SOFTSAW_base *_method_call() {
        _pool->checkcreate();
        if(_pool->base) {
            _cache=(Synth_WAVE_SOFTSAW_base *)_pool->base->_cast(Synth_WAVE_SOFTSAW_base::_IID);
            assert(_cache);
        }
        return _cache;
    }

protected:
    inline Synth_WAVE_SOFTSAW(Synth_WAVE_SOFTSAW_base* b) : Arts::Object(b), _cache(0) {}


public:
    typedef Synth_WAVE_SOFTSAW_base _base_class;

    inline Synth_WAVE_SOFTSAW() : Arts::Object(_Creator), _cache(0) {}
    inline Synth_WAVE_SOFTSAW(const Arts::SubClass& s) :
        Arts::Object(Synth_WAVE_SOFTSAW_base::_create(s.string())), _cache(0) {}
    inline Synth_WAVE_SOFTSAW(const Arts::Reference &r) :
        Arts::Object(r.isString()?(Synth_WAVE_SOFTSAW_base::_fromString(r.string())):(Synth_WAVE_SOFTSAW_base::_fromReference(r.reference(),true))), _cache(0) {}
    inline Synth_WAVE_SOFTSAW(const Arts::DynamicCast& c) : Arts::Object(Synth_WAVE_SOFTSAW_base::_fromDynamicCast(c.object())), _cache(0) {}
    inline Synth_WAVE_SOFTSAW(const Synth_WAVE_SOFTSAW& target) : Arts::Object(target._pool), _cache(target._cache) {}
    inline Synth_WAVE_SOFTSAW(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
    inline static Synth_WAVE_SOFTSAW null() {return Synth_WAVE_SOFTSAW((Synth_WAVE_SOFTSAW_base*)0);}
    inline static Synth_WAVE_SOFTSAW _from_base(Synth_WAVE_SOFTSAW_base* b) {return Synth_WAVE_SOFTSAW(b);}
    inline Synth_WAVE_SOFTSAW& operator=(const Synth_WAVE_SOFTSAW& target) {
        if (_pool == target._pool) return *this;
        _pool->Dec();
        _pool = target._pool;
        _cache = target._cache;
        _pool->Inc();
        return *this;
    }
    inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
    inline Synth_WAVE_SOFTSAW_base* _base() {return _cache?_cache:_method_call();}

    inline Arts::AutoSuspendState autoSuspend();
    inline void start();
    inline void stop();
    inline void streamInit();
    inline void streamStart();
    inline void streamEnd();
};

class ARTS_EXPORT Synth_WAVE_PULSE_base : virtual public Arts::SynthModule_base {
public:
    static unsigned long _IID; // interface ID

    static Synth_WAVE_PULSE_base *_create(const std::string& subClass = "Arts::Synth_WAVE_PULSE");
    static Synth_WAVE_PULSE_base *_fromString(const std::string& objectref);
    static Synth_WAVE_PULSE_base *_fromReference(Arts::ObjectReference ref, bool needcopy);

    static Synth_WAVE_PULSE_base *_fromDynamicCast(const Arts::Object& object);
    inline Synth_WAVE_PULSE_base *_copy() {
        assert(_refCnt > 0);
        _refCnt++;
        return this;
    }

    virtual std::vector<std::string> _defaultPortsIn() const;
    virtual std::vector<std::string> _defaultPortsOut() const;

    void *_cast(unsigned long iid);

    virtual float dutycycle() = 0;
    virtual void dutycycle(float newValue) = 0;
};

class ARTS_EXPORT Synth_WAVE_PULSE_stub : virtual public Synth_WAVE_PULSE_base, virtual public Arts::SynthModule_stub {
protected:
    Synth_WAVE_PULSE_stub();

public:
    Synth_WAVE_PULSE_stub(Arts::Connection *connection, long objectID);

    float dutycycle();
    void dutycycle(float newValue);
};

class ARTS_EXPORT Synth_WAVE_PULSE_skel : virtual public Synth_WAVE_PULSE_base, virtual public Arts::SynthModule_skel {
protected:
    // variables for streams
    float *pos;                               // incoming stream
    float *outvalue;                          // outgoing stream

protected:
    // emitters for change notifications
    inline void dutycycle_changed(float newValue) {
        _emit_changed("dutycycle_changed",newValue);
    }

public:
    Synth_WAVE_PULSE_skel();

    static std::string _interfaceNameSkel();
    std::string _interfaceName();
    bool _isCompatibleWith(const std::string& interfacename);
    void _buildMethodTable();
    void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
};

}
#include "reference.h"
namespace Arts {
class ARTS_EXPORT Synth_WAVE_PULSE : public Arts::Object {
private:
    static Arts::Object_base* _Creator();
    Synth_WAVE_PULSE_base *_cache;
    inline Synth_WAVE_PULSE_base *_method_call() {
        _pool->checkcreate();
        if(_pool->base) {
            _cache=(Synth_WAVE_PULSE_base *)_pool->base->_cast(Synth_WAVE_PULSE_base::_IID);
            assert(_cache);
        }
        return _cache;
    }

protected:
    inline Synth_WAVE_PULSE(Synth_WAVE_PULSE_base* b) : Arts::Object(b), _cache(0) {}


public:
    typedef Synth_WAVE_PULSE_base _base_class;

    inline Synth_WAVE_PULSE() : Arts::Object(_Creator), _cache(0) {}
    inline Synth_WAVE_PULSE(const Arts::SubClass& s) :
        Arts::Object(Synth_WAVE_PULSE_base::_create(s.string())), _cache(0) {}
    inline Synth_WAVE_PULSE(const Arts::Reference &r) :
        Arts::Object(r.isString()?(Synth_WAVE_PULSE_base::_fromString(r.string())):(Synth_WAVE_PULSE_base::_fromReference(r.reference(),true))), _cache(0) {}
    inline Synth_WAVE_PULSE(const Arts::DynamicCast& c) : Arts::Object(Synth_WAVE_PULSE_base::_fromDynamicCast(c.object())), _cache(0) {}
    inline Synth_WAVE_PULSE(const Synth_WAVE_PULSE& target) : Arts::Object(target._pool), _cache(target._cache) {}
    inline Synth_WAVE_PULSE(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
    inline static Synth_WAVE_PULSE null() {return Synth_WAVE_PULSE((Synth_WAVE_PULSE_base*)0);}
    inline static Synth_WAVE_PULSE _from_base(Synth_WAVE_PULSE_base* b) {return Synth_WAVE_PULSE(b);}
    inline Synth_WAVE_PULSE& operator=(const Synth_WAVE_PULSE& target) {
        if (_pool == target._pool) return *this;
        _pool->Dec();
        _pool = target._pool;
        _cache = target._cache;
        _pool->Inc();
        return *this;
    }
    inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
    inline Synth_WAVE_PULSE_base* _base() {return _cache?_cache:_method_call();}

    inline Arts::AutoSuspendState autoSuspend();
    inline void start();
    inline void stop();
    inline void streamInit();
    inline void streamStart();
    inline void streamEnd();
    inline float dutycycle();
    inline void dutycycle(float _newValue);
};

class ARTS_EXPORT Synth_OSC_base : virtual public Arts::SynthModule_base {
public:
    static unsigned long _IID; // interface ID

    static Synth_OSC_base *_create(const std::string& subClass = "Arts::Synth_OSC");
    static Synth_OSC_base *_fromString(const std::string& objectref);
    static Synth_OSC_base *_fromReference(Arts::ObjectReference ref, bool needcopy);

    static Synth_OSC_base *_fromDynamicCast(const Arts::Object& object);
    inline Synth_OSC_base *_copy() {
        assert(_refCnt > 0);
        _refCnt++;
        return this;
    }

    virtual std::vector<std::string> _defaultPortsIn() const;
    virtual std::vector<std::string> _defaultPortsOut() const;

    void *_cast(unsigned long iid);

    virtual Arts::SynthOscWaveForm waveForm() = 0;
    virtual void waveForm(Arts::SynthOscWaveForm newValue) = 0;
    virtual bool fmExponential() = 0;
    virtual void fmExponential(bool newValue) = 0;
    virtual float fmStrength() = 0;
    virtual void fmStrength(float newValue) = 0;
    virtual float fmSelfStrength() = 0;
    virtual void fmSelfStrength(float newValue) = 0;
    virtual float phase() = 0;
    virtual void phase(float newValue) = 0;
    virtual float frequency() = 0;
    virtual void frequency(float newValue) = 0;
    virtual long fineTune() = 0;
    virtual void fineTune(long newValue) = 0;
    virtual float pulseWidth() = 0;
    virtual void pulseWidth(float newValue) = 0;
    virtual float pulseModStrength() = 0;
    virtual void pulseModStrength(float newValue) = 0;
};

class ARTS_EXPORT Synth_OSC_stub : virtual public Synth_OSC_base, virtual public Arts::SynthModule_stub {
protected:
    Synth_OSC_stub();

public:
    Synth_OSC_stub(Arts::Connection *connection, long objectID);

    Arts::SynthOscWaveForm waveForm();
    void waveForm(Arts::SynthOscWaveForm newValue);
    bool fmExponential();
    void fmExponential(bool newValue);
    float fmStrength();
    void fmStrength(float newValue);
    float fmSelfStrength();
    void fmSelfStrength(float newValue);
    float phase();
    void phase(float newValue);
    float frequency();
    void frequency(float newValue);
    long fineTune();
    void fineTune(long newValue);
    float pulseWidth();
    void pulseWidth(float newValue);
    float pulseModStrength();
    void pulseModStrength(float newValue);
};

class ARTS_EXPORT Synth_OSC_skel : virtual public Synth_OSC_base, virtual public Arts::SynthModule_skel {
protected:
    // variables for streams
    float *infrequency;                       // incoming stream
    float *modulation;                        // incoming stream
    float *inpwm;                             // incoming stream
    float *insync;                            // incoming stream
    float *outvalue;                          // outgoing stream
    float *outsync;                           // outgoing stream

protected:
    // emitters for change notifications
    inline void waveForm_changed(Arts::SynthOscWaveForm newValue) {
        _emit_changed("waveForm_changed",newValue);
    }
    inline void fmExponential_changed(bool newValue) {
        _emit_changed("fmExponential_changed",newValue);
    }
    inline void fmStrength_changed(float newValue) {
        _emit_changed("fmStrength_changed",newValue);
    }
    inline void fmSelfStrength_changed(float newValue) {
        _emit_changed("fmSelfStrength_changed",newValue);
    }
    inline void phase_changed(float newValue) {
        _emit_changed("phase_changed",newValue);
    }
    inline void frequency_changed(float newValue) {
        _emit_changed("frequency_changed",newValue);
    }
    inline void fineTune_changed(long newValue) {
        _emit_changed("fineTune_changed",newValue);
    }
    inline void pulseWidth_changed(float newValue) {
        _emit_changed("pulseWidth_changed",newValue);
    }
    inline void pulseModStrength_changed(float newValue) {
        _emit_changed("pulseModStrength_changed",newValue);
    }

public:
    Synth_OSC_skel();

    static std::string _interfaceNameSkel();
    std::string _interfaceName();
    bool _isCompatibleWith(const std::string& interfacename);
    void _buildMethodTable();
    void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
};

}
#include "reference.h"
namespace Arts {
class ARTS_EXPORT Synth_OSC : public Arts::Object {
private:
    static Arts::Object_base* _Creator();
    Synth_OSC_base *_cache;
    inline Synth_OSC_base *_method_call() {
        _pool->checkcreate();
        if(_pool->base) {
            _cache=(Synth_OSC_base *)_pool->base->_cast(Synth_OSC_base::_IID);
            assert(_cache);
        }
        return _cache;
    }

protected:
    inline Synth_OSC(Synth_OSC_base* b) : Arts::Object(b), _cache(0) {}


public:
    typedef Synth_OSC_base _base_class;

    inline Synth_OSC() : Arts::Object(_Creator), _cache(0) {}
    inline Synth_OSC(const Arts::SubClass& s) :
        Arts::Object(Synth_OSC_base::_create(s.string())), _cache(0) {}
    inline Synth_OSC(const Arts::Reference &r) :
        Arts::Object(r.isString()?(Synth_OSC_base::_fromString(r.string())):(Synth_OSC_base::_fromReference(r.reference(),true))), _cache(0) {}
    inline Synth_OSC(const Arts::DynamicCast& c) : Arts::Object(Synth_OSC_base::_fromDynamicCast(c.object())), _cache(0) {}
    inline Synth_OSC(const Synth_OSC& target) : Arts::Object(target._pool), _cache(target._cache) {}
    inline Synth_OSC(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
    inline static Synth_OSC null() {return Synth_OSC((Synth_OSC_base*)0);}
    inline static Synth_OSC _from_base(Synth_OSC_base* b) {return Synth_OSC(b);}
    inline Synth_OSC& operator=(const Synth_OSC& target) {
        if (_pool == target._pool) return *this;
        _pool->Dec();
        _pool = target._pool;
        _cache = target._cache;
        _pool->Inc();
        return *this;
    }
    inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
    inline Synth_OSC_base* _base() {return _cache?_cache:_method_call();}

    inline Arts::AutoSuspendState autoSuspend();
    inline void start();
    inline void stop();
    inline void streamInit();
    inline void streamStart();
    inline void streamEnd();
    inline Arts::SynthOscWaveForm waveForm();
    inline void waveForm(Arts::SynthOscWaveForm _newValue);
    inline bool fmExponential();
    inline void fmExponential(bool _newValue);
    inline float fmStrength();
    inline void fmStrength(float _newValue);
    inline float fmSelfStrength();
    inline void fmSelfStrength(float _newValue);
    inline float phase();
    inline void phase(float _newValue);
    inline float frequency();
    inline void frequency(float _newValue);
    inline long fineTune();
    inline void fineTune(long _newValue);
    inline float pulseWidth();
    inline void pulseWidth(float _newValue);
    inline float pulseModStrength();
    inline void pulseModStrength(float _newValue);
};

class ARTS_EXPORT Synth_PLAY_PAT_base : virtual public Arts::SynthModule_base {
public:
    static unsigned long _IID; // interface ID

    static Synth_PLAY_PAT_base *_create(const std::string& subClass = "Arts::Synth_PLAY_PAT");
    static Synth_PLAY_PAT_base *_fromString(const std::string& objectref);
    static Synth_PLAY_PAT_base *_fromReference(Arts::ObjectReference ref, bool needcopy);

    static Synth_PLAY_PAT_base *_fromDynamicCast(const Arts::Object& object);
    inline Synth_PLAY_PAT_base *_copy() {
        assert(_refCnt > 0);
        _refCnt++;
        return this;
    }

    virtual std::vector<std::string> _defaultPortsIn() const;
    virtual std::vector<std::string> _defaultPortsOut() const;

    void *_cast(unsigned long iid);

    virtual std::string filename() = 0;
    virtual void filename(const std::string& newValue) = 0;
};

class ARTS_EXPORT Synth_PLAY_PAT_stub : virtual public Synth_PLAY_PAT_base, virtual public Arts::SynthModule_stub {
protected:
    Synth_PLAY_PAT_stub();

public:
    Synth_PLAY_PAT_stub(Arts::Connection *connection, long objectID);

    std::string filename();
    void filename(const std::string& newValue);
};

class ARTS_EXPORT Synth_PLAY_PAT_skel : virtual public Synth_PLAY_PAT_base, virtual public Arts::SynthModule_skel {
protected:
    // variables for streams
    float *frequency;                         // incoming stream
    float *outvalue;                          // outgoing stream

protected:
    // emitters for change notifications
    inline void filename_changed(const std::string& newValue) {
        _emit_changed("filename_changed",newValue);
    }

public:
    Synth_PLAY_PAT_skel();

    static std::string _interfaceNameSkel();
    std::string _interfaceName();
    bool _isCompatibleWith(const std::string& interfacename);
    void _buildMethodTable();
    void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
};

}
#include "reference.h"
namespace Arts {
class ARTS_EXPORT Synth_PLAY_PAT : public Arts::Object {
private:
    static Arts::Object_base* _Creator();
    Synth_PLAY_PAT_base *_cache;
    inline Synth_PLAY_PAT_base *_method_call() {
        _pool->checkcreate();
        if(_pool->base) {
            _cache=(Synth_PLAY_PAT_base *)_pool->base->_cast(Synth_PLAY_PAT_base::_IID);
            assert(_cache);
        }
        return _cache;
    }

protected:
    inline Synth_PLAY_PAT(Synth_PLAY_PAT_base* b) : Arts::Object(b), _cache(0) {}


public:
    typedef Synth_PLAY_PAT_base _base_class;

    inline Synth_PLAY_PAT() : Arts::Object(_Creator), _cache(0) {}
    inline Synth_PLAY_PAT(const Arts::SubClass& s) :
        Arts::Object(Synth_PLAY_PAT_base::_create(s.string())), _cache(0) {}
    inline Synth_PLAY_PAT(const Arts::Reference &r) :
        Arts::Object(r.isString()?(Synth_PLAY_PAT_base::_fromString(r.string())):(Synth_PLAY_PAT_base::_fromReference(r.reference(),true))), _cache(0) {}
    inline Synth_PLAY_PAT(const Arts::DynamicCast& c) : Arts::Object(Synth_PLAY_PAT_base::_fromDynamicCast(c.object())), _cache(0) {}
    inline Synth_PLAY_PAT(const Synth_PLAY_PAT& target) : Arts::Object(target._pool), _cache(target._cache) {}
    inline Synth_PLAY_PAT(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
    inline static Synth_PLAY_PAT null() {return Synth_PLAY_PAT((Synth_PLAY_PAT_base*)0);}
    inline static Synth_PLAY_PAT _from_base(Synth_PLAY_PAT_base* b) {return Synth_PLAY_PAT(b);}
    inline Synth_PLAY_PAT& operator=(const Synth_PLAY_PAT& target) {
        if (_pool == target._pool) return *this;
        _pool->Dec();
        _pool = target._pool;
        _cache = target._cache;
        _pool->Inc();
        return *this;
    }
    inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
    inline Synth_PLAY_PAT_base* _base() {return _cache?_cache:_method_call();}

    inline Arts::AutoSuspendState autoSuspend();
    inline void start();
    inline void stop();
    inline void streamInit();
    inline void streamStart();
    inline void streamEnd();
    inline std::string filename();
    inline void filename(const std::string& _newValue);
};

class ARTS_EXPORT Synth_CAPTURE_WAV_base : virtual public Arts::SynthModule_base {
public:
    static unsigned long _IID; // interface ID

    static Synth_CAPTURE_WAV_base *_create(const std::string& subClass = "Arts::Synth_CAPTURE_WAV");
    static Synth_CAPTURE_WAV_base *_fromString(const std::string& objectref);
    static Synth_CAPTURE_WAV_base *_fromReference(Arts::ObjectReference ref, bool needcopy);

    static Synth_CAPTURE_WAV_base *_fromDynamicCast(const Arts::Object& object);
    inline Synth_CAPTURE_WAV_base *_copy() {
        assert(_refCnt > 0);
        _refCnt++;
        return this;
    }

    virtual std::vector<std::string> _defaultPortsIn() const;
    virtual std::vector<std::string> _defaultPortsOut() const;

    void *_cast(unsigned long iid);

    virtual std::string filename() = 0;
    virtual void filename(const std::string& newValue) = 0;
};

class ARTS_EXPORT Synth_CAPTURE_WAV_stub : virtual public Synth_CAPTURE_WAV_base, virtual public Arts::SynthModule_stub {
protected:
    Synth_CAPTURE_WAV_stub();

public:
    Synth_CAPTURE_WAV_stub(Arts::Connection *connection, long objectID);

    std::string filename();
    void filename(const std::string& newValue);
};

class ARTS_EXPORT Synth_CAPTURE_WAV_skel : virtual public Synth_CAPTURE_WAV_base, virtual public Arts::SynthModule_skel {
protected:
    // variables for streams
    float *left;                              // incoming stream
    float *right;                             // incoming stream

protected:
    // emitters for change notifications
    inline void filename_changed(const std::string& newValue) {
        _emit_changed("filename_changed",newValue);
    }

public:
    Synth_CAPTURE_WAV_skel();

    static std::string _interfaceNameSkel();
    std::string _interfaceName();
    bool _isCompatibleWith(const std::string& interfacename);
    void _buildMethodTable();
    void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
};

}
#include "reference.h"
namespace Arts {
class ARTS_EXPORT Synth_CAPTURE_WAV : public Arts::Object {
private:
    static Arts::Object_base* _Creator();
    Synth_CAPTURE_WAV_base *_cache;
    inline Synth_CAPTURE_WAV_base *_method_call() {
        _pool->checkcreate();
        if(_pool->base) {
            _cache=(Synth_CAPTURE_WAV_base *)_pool->base->_cast(Synth_CAPTURE_WAV_base::_IID);
            assert(_cache);
        }
        return _cache;
    }

protected:
    inline Synth_CAPTURE_WAV(Synth_CAPTURE_WAV_base* b) : Arts::Object(b), _cache(0) {}


public:
    typedef Synth_CAPTURE_WAV_base _base_class;

    inline Synth_CAPTURE_WAV() : Arts::Object(_Creator), _cache(0) {}
    inline Synth_CAPTURE_WAV(const Arts::SubClass& s) :
        Arts::Object(Synth_CAPTURE_WAV_base::_create(s.string())), _cache(0) {}
    inline Synth_CAPTURE_WAV(const Arts::Reference &r) :
        Arts::Object(r.isString()?(Synth_CAPTURE_WAV_base::_fromString(r.string())):(Synth_CAPTURE_WAV_base::_fromReference(r.reference(),true))), _cache(0) {}
    inline Synth_CAPTURE_WAV(const Arts::DynamicCast& c) : Arts::Object(Synth_CAPTURE_WAV_base::_fromDynamicCast(c.object())), _cache(0) {}
    inline Synth_CAPTURE_WAV(const Synth_CAPTURE_WAV& target) : Arts::Object(target._pool), _cache(target._cache) {}
    inline Synth_CAPTURE_WAV(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
    inline static Synth_CAPTURE_WAV null() {return Synth_CAPTURE_WAV((Synth_CAPTURE_WAV_base*)0);}
    inline static Synth_CAPTURE_WAV _from_base(Synth_CAPTURE_WAV_base* b) {return Synth_CAPTURE_WAV(b);}
    inline Synth_CAPTURE_WAV& operator=(const Synth_CAPTURE_WAV& target) {
        if (_pool == target._pool) return *this;
        _pool->Dec();
        _pool = target._pool;
        _cache = target._cache;
        _pool->Inc();
        return *this;
    }
    inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
    inline Synth_CAPTURE_WAV_base* _base() {return _cache?_cache:_method_call();}

    inline Arts::AutoSuspendState autoSuspend();
    inline void start();
    inline void stop();
    inline void streamInit();
    inline void streamStart();
    inline void streamEnd();
    inline std::string filename();
    inline void filename(const std::string& _newValue);
};

class ARTS_EXPORT Synth_NIL_base : virtual public Arts::SynthModule_base {
public:
    static unsigned long _IID; // interface ID

    static Synth_NIL_base *_create(const std::string& subClass = "Arts::Synth_NIL");
    static Synth_NIL_base *_fromString(const std::string& objectref);
    static Synth_NIL_base *_fromReference(Arts::ObjectReference ref, bool needcopy);

    static Synth_NIL_base *_fromDynamicCast(const Arts::Object& object);
    inline Synth_NIL_base *_copy() {
        assert(_refCnt > 0);
        _refCnt++;
        return this;
    }

    virtual std::vector<std::string> _defaultPortsIn() const;
    virtual std::vector<std::string> _defaultPortsOut() const;

    void *_cast(unsigned long iid);

};

class ARTS_EXPORT Synth_NIL_stub : virtual public Synth_NIL_base, virtual public Arts::SynthModule_stub {
protected:
    Synth_NIL_stub();

public:
    Synth_NIL_stub(Arts::Connection *connection, long objectID);

};

class ARTS_EXPORT Synth_NIL_skel : virtual public Synth_NIL_base, virtual public Arts::SynthModule_skel {
public:
    Synth_NIL_skel();

    static std::string _interfaceNameSkel();
    std::string _interfaceName();
    bool _isCompatibleWith(const std::string& interfacename);
    void _buildMethodTable();
    void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
};

}
#include "reference.h"
namespace Arts {
class ARTS_EXPORT Synth_NIL : public Arts::Object {
private:
    static Arts::Object_base* _Creator();
    Synth_NIL_base *_cache;
    inline Synth_NIL_base *_method_call() {
        _pool->checkcreate();
        if(_pool->base) {
            _cache=(Synth_NIL_base *)_pool->base->_cast(Synth_NIL_base::_IID);
            assert(_cache);
        }
        return _cache;
    }

protected:
    inline Synth_NIL(Synth_NIL_base* b) : Arts::Object(b), _cache(0) {}


public:
    typedef Synth_NIL_base _base_class;

    inline Synth_NIL() : Arts::Object(_Creator), _cache(0) {}
    inline Synth_NIL(const Arts::SubClass& s) :
        Arts::Object(Synth_NIL_base::_create(s.string())), _cache(0) {}
    inline Synth_NIL(const Arts::Reference &r) :
        Arts::Object(r.isString()?(Synth_NIL_base::_fromString(r.string())):(Synth_NIL_base::_fromReference(r.reference(),true))), _cache(0) {}
    inline Synth_NIL(const Arts::DynamicCast& c) : Arts::Object(Synth_NIL_base::_fromDynamicCast(c.object())), _cache(0) {}
    inline Synth_NIL(const Synth_NIL& target) : Arts::Object(target._pool), _cache(target._cache) {}
    inline Synth_NIL(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
    inline static Synth_NIL null() {return Synth_NIL((Synth_NIL_base*)0);}
    inline static Synth_NIL _from_base(Synth_NIL_base* b) {return Synth_NIL(b);}
    inline Synth_NIL& operator=(const Synth_NIL& target) {
        if (_pool == target._pool) return *this;
        _pool->Dec();
        _pool = target._pool;
        _cache = target._cache;
        _pool->Inc();
        return *this;
    }
    inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
    inline Synth_NIL_base* _base() {return _cache?_cache:_method_call();}

    inline Arts::AutoSuspendState autoSuspend();
    inline void start();
    inline void stop();
    inline void streamInit();
    inline void streamStart();
    inline void streamEnd();
};

class ARTS_EXPORT Synth_DEBUG_base : virtual public Arts::SynthModule_base {
public:
    static unsigned long _IID; // interface ID

    static Synth_DEBUG_base *_create(const std::string& subClass = "Arts::Synth_DEBUG");
    static Synth_DEBUG_base *_fromString(const std::string& objectref);
    static Synth_DEBUG_base *_fromReference(Arts::ObjectReference ref, bool needcopy);

    static Synth_DEBUG_base *_fromDynamicCast(const Arts::Object& object);
    inline Synth_DEBUG_base *_copy() {
        assert(_refCnt > 0);
        _refCnt++;
        return this;
    }

    virtual std::vector<std::string> _defaultPortsIn() const;
    virtual std::vector<std::string> _defaultPortsOut() const;

    void *_cast(unsigned long iid);

    virtual std::string comment() = 0;
    virtual void comment(const std::string& newValue) = 0;
};

class ARTS_EXPORT Synth_DEBUG_stub : virtual public Synth_DEBUG_base, virtual public Arts::SynthModule_stub {
protected:
    Synth_DEBUG_stub();

public:
    Synth_DEBUG_stub(Arts::Connection *connection, long objectID);

    std::string comment();
    void comment(const std::string& newValue);
};

class ARTS_EXPORT Synth_DEBUG_skel : virtual public Synth_DEBUG_base, virtual public Arts::SynthModule_skel {
protected:
    // variables for streams
    float *invalue;                           // incoming stream

protected:
    // emitters for change notifications
    inline void comment_changed(const std::string& newValue) {
        _emit_changed("comment_changed",newValue);
    }

public:
    Synth_DEBUG_skel();

    static std::string _interfaceNameSkel();
    std::string _interfaceName();
    bool _isCompatibleWith(const std::string& interfacename);
    void _buildMethodTable();
    void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
};

}
#include "reference.h"
namespace Arts {
class ARTS_EXPORT Synth_DEBUG : public Arts::Object {
private:
    static Arts::Object_base* _Creator();
    Synth_DEBUG_base *_cache;
    inline Synth_DEBUG_base *_method_call() {
        _pool->checkcreate();
        if(_pool->base) {
            _cache=(Synth_DEBUG_base *)_pool->base->_cast(Synth_DEBUG_base::_IID);
            assert(_cache);
        }
        return _cache;
    }

protected:
    inline Synth_DEBUG(Synth_DEBUG_base* b) : Arts::Object(b), _cache(0) {}


public:
    typedef Synth_DEBUG_base _base_class;

    inline Synth_DEBUG() : Arts::Object(_Creator), _cache(0) {}
    inline Synth_DEBUG(const Arts::SubClass& s) :
        Arts::Object(Synth_DEBUG_base::_create(s.string())), _cache(0) {}
    inline Synth_DEBUG(const Arts::Reference &r) :
        Arts::Object(r.isString()?(Synth_DEBUG_base::_fromString(r.string())):(Synth_DEBUG_base::_fromReference(r.reference(),true))), _cache(0) {}
    inline Synth_DEBUG(const Arts::DynamicCast& c) : Arts::Object(Synth_DEBUG_base::_fromDynamicCast(c.object())), _cache(0) {}
    inline Synth_DEBUG(const Synth_DEBUG& target) : Arts::Object(target._pool), _cache(target._cache) {}
    inline Synth_DEBUG(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
    inline static Synth_DEBUG null() {return Synth_DEBUG((Synth_DEBUG_base*)0);}
    inline static Synth_DEBUG _from_base(Synth_DEBUG_base* b) {return Synth_DEBUG(b);}
    inline Synth_DEBUG& operator=(const Synth_DEBUG& target) {
        if (_pool == target._pool) return *this;
        _pool->Dec();
        _pool = target._pool;
        _cache = target._cache;
        _pool->Inc();
        return *this;
    }
    inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
    inline Synth_DEBUG_base* _base() {return _cache?_cache:_method_call();}

    inline Arts::AutoSuspendState autoSuspend();
    inline void start();
    inline void stop();
    inline void streamInit();
    inline void streamStart();
    inline void streamEnd();
    inline std::string comment();
    inline void comment(const std::string& _newValue);
};

class ARTS_EXPORT Synth_DATA_base : virtual public Arts::SynthModule_base {
public:
    static unsigned long _IID; // interface ID

    static Synth_DATA_base *_create(const std::string& subClass = "Arts::Synth_DATA");
    static Synth_DATA_base *_fromString(const std::string& objectref);
    static Synth_DATA_base *_fromReference(Arts::ObjectReference ref, bool needcopy);

    static Synth_DATA_base *_fromDynamicCast(const Arts::Object& object);
    inline Synth_DATA_base *_copy() {
        assert(_refCnt > 0);
        _refCnt++;
        return this;
    }

    virtual std::vector<std::string> _defaultPortsIn() const;
    virtual std::vector<std::string> _defaultPortsOut() const;

    void *_cast(unsigned long iid);

    virtual float value() = 0;
    virtual void value(float newValue) = 0;
};

class ARTS_EXPORT Synth_DATA_stub : virtual public Synth_DATA_base, virtual public Arts::SynthModule_stub {
protected:
    Synth_DATA_stub();

public:
    Synth_DATA_stub(Arts::Connection *connection, long objectID);

    float value();
    void value(float newValue);
};

class ARTS_EXPORT Synth_DATA_skel : virtual public Synth_DATA_base, virtual public Arts::SynthModule_skel {
protected:
    // variables for streams
    float *outvalue;                          // outgoing stream

protected:
    // emitters for change notifications
    inline void value_changed(float newValue) {
        _emit_changed("value_changed",newValue);
    }

public:
    Synth_DATA_skel();

    static std::string _interfaceNameSkel();
    std::string _interfaceName();
    bool _isCompatibleWith(const std::string& interfacename);
    void _buildMethodTable();
    void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
};

}
#include "reference.h"
namespace Arts {
class ARTS_EXPORT Synth_DATA : public Arts::Object {
private:
    static Arts::Object_base* _Creator();
    Synth_DATA_base *_cache;
    inline Synth_DATA_base *_method_call() {
        _pool->checkcreate();
        if(_pool->base) {
            _cache=(Synth_DATA_base *)_pool->base->_cast(Synth_DATA_base::_IID);
            assert(_cache);
        }
        return _cache;
    }

protected:
    inline Synth_DATA(Synth_DATA_base* b) : Arts::Object(b), _cache(0) {}


public:
    typedef Synth_DATA_base _base_class;

    inline Synth_DATA() : Arts::Object(_Creator), _cache(0) {}
    inline Synth_DATA(const Arts::SubClass& s) :
        Arts::Object(Synth_DATA_base::_create(s.string())), _cache(0) {}
    inline Synth_DATA(const Arts::Reference &r) :
        Arts::Object(r.isString()?(Synth_DATA_base::_fromString(r.string())):(Synth_DATA_base::_fromReference(r.reference(),true))), _cache(0) {}
    inline Synth_DATA(const Arts::DynamicCast& c) : Arts::Object(Synth_DATA_base::_fromDynamicCast(c.object())), _cache(0) {}
    inline Synth_DATA(const Synth_DATA& target) : Arts::Object(target._pool), _cache(target._cache) {}
    inline Synth_DATA(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
    inline static Synth_DATA null() {return Synth_DATA((Synth_DATA_base*)0);}
    inline static Synth_DATA _from_base(Synth_DATA_base* b) {return Synth_DATA(b);}
    inline Synth_DATA& operator=(const Synth_DATA& target) {
        if (_pool == target._pool) return *this;
        _pool->Dec();
        _pool = target._pool;
        _cache = target._cache;
        _pool->Inc();
        return *this;
    }
    inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
    inline Synth_DATA_base* _base() {return _cache?_cache:_method_call();}

    inline Arts::AutoSuspendState autoSuspend();
    inline void start();
    inline void stop();
    inline void streamInit();
    inline void streamStart();
    inline void streamEnd();
    inline float value();
    inline void value(float _newValue);
};

class ARTS_EXPORT Synth_MIDI_DEBUG_base : virtual public Arts::SynthModule_base,
    virtual public Arts::MidiPort_base {
public:
    static unsigned long _IID; // interface ID

    static Synth_MIDI_DEBUG_base *_create(const std::string& subClass = "Arts::Synth_MIDI_DEBUG");
    static Synth_MIDI_DEBUG_base *_fromString(const std::string& objectref);
    static Synth_MIDI_DEBUG_base *_fromReference(Arts::ObjectReference ref, bool needcopy);

    static Synth_MIDI_DEBUG_base *_fromDynamicCast(const Arts::Object& object);
    inline Synth_MIDI_DEBUG_base *_copy() {
        assert(_refCnt > 0);
        _refCnt++;
        return this;
    }

    virtual std::vector<std::string> _defaultPortsIn() const;
    virtual std::vector<std::string> _defaultPortsOut() const;

    void *_cast(unsigned long iid);

};

class ARTS_EXPORT Synth_MIDI_DEBUG_stub : virtual public Synth_MIDI_DEBUG_base, virtual public Arts::SynthModule_stub,
    virtual public Arts::MidiPort_stub {
protected:
    Synth_MIDI_DEBUG_stub();

public:
    Synth_MIDI_DEBUG_stub(Arts::Connection *connection, long objectID);

};

class ARTS_EXPORT Synth_MIDI_DEBUG_skel : virtual public Synth_MIDI_DEBUG_base, virtual public Arts::SynthModule_skel,
    virtual public Arts::MidiPort_skel {
public:
    Synth_MIDI_DEBUG_skel();

    static std::string _interfaceNameSkel();
    std::string _interfaceName();
    bool _isCompatibleWith(const std::string& interfacename);
    void _buildMethodTable();
    void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
};

}
#include "reference.h"
namespace Arts {
class ARTS_EXPORT Synth_MIDI_DEBUG : public Arts::Object {
private:
    static Arts::Object_base* _Creator();
    Synth_MIDI_DEBUG_base *_cache;
    inline Synth_MIDI_DEBUG_base *_method_call() {
        _pool->checkcreate();
        if(_pool->base) {
            _cache=(Synth_MIDI_DEBUG_base *)_pool->base->_cast(Synth_MIDI_DEBUG_base::_IID);
            assert(_cache);
        }
        return _cache;
    }

protected:
    inline Synth_MIDI_DEBUG(Synth_MIDI_DEBUG_base* b) : Arts::Object(b), _cache(0) {}


public:
    typedef Synth_MIDI_DEBUG_base _base_class;

    inline Synth_MIDI_DEBUG() : Arts::Object(_Creator), _cache(0) {}
    inline Synth_MIDI_DEBUG(const Arts::SubClass& s) :
        Arts::Object(Synth_MIDI_DEBUG_base::_create(s.string())), _cache(0) {}
    inline Synth_MIDI_DEBUG(const Arts::Reference &r) :
        Arts::Object(r.isString()?(Synth_MIDI_DEBUG_base::_fromString(r.string())):(Synth_MIDI_DEBUG_base::_fromReference(r.reference(),true))), _cache(0) {}
    inline Synth_MIDI_DEBUG(const Arts::DynamicCast& c) : Arts::Object(Synth_MIDI_DEBUG_base::_fromDynamicCast(c.object())), _cache(0) {}
    inline Synth_MIDI_DEBUG(const Synth_MIDI_DEBUG& target) : Arts::Object(target._pool), _cache(target._cache) {}
    inline Synth_MIDI_DEBUG(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
    inline static Synth_MIDI_DEBUG null() {return Synth_MIDI_DEBUG((Synth_MIDI_DEBUG_base*)0);}
    inline static Synth_MIDI_DEBUG _from_base(Synth_MIDI_DEBUG_base* b) {return Synth_MIDI_DEBUG(b);}
    inline Synth_MIDI_DEBUG& operator=(const Synth_MIDI_DEBUG& target) {
        if (_pool == target._pool) return *this;
        _pool->Dec();
        _pool = target._pool;
        _cache = target._cache;
        _pool->Inc();
        return *this;
    }
    inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
    inline operator Arts::MidiPort() const { return Arts::MidiPort(*_pool); }
    inline Synth_MIDI_DEBUG_base* _base() {return _cache?_cache:_method_call();}

    inline Arts::AutoSuspendState autoSuspend();
    inline void start();
    inline void stop();
    inline void streamInit();
    inline void streamStart();
    inline void streamEnd();
    inline Arts::TimeStamp time();
    inline Arts::TimeStamp playTime();
    inline void processCommand(const Arts::MidiCommand& command);
    inline void processEvent(const Arts::MidiEvent& event);
};

class ARTS_EXPORT ObjectCache_base : virtual public Arts::Object_base {
public:
    static unsigned long _IID; // interface ID

    static ObjectCache_base *_create(const std::string& subClass = "Arts::ObjectCache");
    static ObjectCache_base *_fromString(const std::string& objectref);
    static ObjectCache_base *_fromReference(Arts::ObjectReference ref, bool needcopy);

    static ObjectCache_base *_fromDynamicCast(const Arts::Object& object);
    inline ObjectCache_base *_copy() {
        assert(_refCnt > 0);
        _refCnt++;
        return this;
    }

    virtual std::vector<std::string> _defaultPortsIn() const;
    virtual std::vector<std::string> _defaultPortsOut() const;

    void *_cast(unsigned long iid);

    virtual void put(Arts::Object obj, const std::string& name) = 0;
    virtual Arts::Object get(const std::string& name) = 0;
};

class ARTS_EXPORT ObjectCache_stub : virtual public ObjectCache_base, virtual public Arts::Object_stub {
protected:
    ObjectCache_stub();

public:
    ObjectCache_stub(Arts::Connection *connection, long objectID);

    void put(Arts::Object obj, const std::string& name);
    Arts::Object get(const std::string& name);
};

class ARTS_EXPORT ObjectCache_skel : virtual public ObjectCache_base, virtual public Arts::Object_skel {
public:
    ObjectCache_skel();

    static std::string _interfaceNameSkel();
    std::string _interfaceName();
    bool _isCompatibleWith(const std::string& interfacename);
    void _buildMethodTable();
    void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
};

}
#include "reference.h"
namespace Arts {
class ARTS_EXPORT ObjectCache : public Arts::Object {
private:
    static Arts::Object_base* _Creator();
    ObjectCache_base *_cache;
    inline ObjectCache_base *_method_call() {
        _pool->checkcreate();
        if(_pool->base) {
            _cache=(ObjectCache_base *)_pool->base->_cast(ObjectCache_base::_IID);
            assert(_cache);
        }
        return _cache;
    }

protected:
    inline ObjectCache(ObjectCache_base* b) : Arts::Object(b), _cache(0) {}


public:
    typedef ObjectCache_base _base_class;

    inline ObjectCache() : Arts::Object(_Creator), _cache(0) {}
    inline ObjectCache(const Arts::SubClass& s) :
        Arts::Object(ObjectCache_base::_create(s.string())), _cache(0) {}
    inline ObjectCache(const Arts::Reference &r) :
        Arts::Object(r.isString()?(ObjectCache_base::_fromString(r.string())):(ObjectCache_base::_fromReference(r.reference(),true))), _cache(0) {}
    inline ObjectCache(const Arts::DynamicCast& c) : Arts::Object(ObjectCache_base::_fromDynamicCast(c.object())), _cache(0) {}
    inline ObjectCache(const ObjectCache& target) : Arts::Object(target._pool), _cache(target._cache) {}
    inline ObjectCache(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
    inline static ObjectCache null() {return ObjectCache((ObjectCache_base*)0);}
    inline static ObjectCache _from_base(ObjectCache_base* b) {return ObjectCache(b);}
    inline ObjectCache& operator=(const ObjectCache& target) {
        if (_pool == target._pool) return *this;
        _pool->Dec();
        _pool = target._pool;
        _cache = target._cache;
        _pool->Inc();
        return *this;
    }
    inline ObjectCache_base* _base() {return _cache?_cache:_method_call();}

    inline void put(Arts::Object obj, const std::string& name);
    inline Arts::Object get(const std::string& name);
};

class ARTS_EXPORT MidiReleaseHelper_base : virtual public Arts::SynthModule_base {
public:
    static unsigned long _IID; // interface ID

    static MidiReleaseHelper_base *_create(const std::string& subClass = "Arts::MidiReleaseHelper");
    static MidiReleaseHelper_base *_fromString(const std::string& objectref);
    static MidiReleaseHelper_base *_fromReference(Arts::ObjectReference ref, bool needcopy);

    static MidiReleaseHelper_base *_fromDynamicCast(const Arts::Object& object);
    inline MidiReleaseHelper_base *_copy() {
        assert(_refCnt > 0);
        _refCnt++;
        return this;
    }

    virtual std::vector<std::string> _defaultPortsIn() const;
    virtual std::vector<std::string> _defaultPortsOut() const;

    void *_cast(unsigned long iid);

    virtual Arts::SynthModule voice() = 0;
    virtual void voice(Arts::SynthModule newValue) = 0;
    virtual std::string name() = 0;
    virtual void name(const std::string& newValue) = 0;
    virtual Arts::ObjectCache cache() = 0;
    virtual void cache(Arts::ObjectCache newValue) = 0;
    virtual bool terminate() = 0;
};

class ARTS_EXPORT MidiReleaseHelper_stub : virtual public MidiReleaseHelper_base, virtual public Arts::SynthModule_stub {
protected:
    MidiReleaseHelper_stub();

public:
    MidiReleaseHelper_stub(Arts::Connection *connection, long objectID);

    Arts::SynthModule voice();
    void voice(Arts::SynthModule newValue);
    std::string name();
    void name(const std::string& newValue);
    Arts::ObjectCache cache();
    void cache(Arts::ObjectCache newValue);
    bool terminate();
};

class ARTS_EXPORT MidiReleaseHelper_skel : virtual public MidiReleaseHelper_base, virtual public Arts::SynthModule_skel {
protected:
    // variables for streams
    float *done;                              // incoming stream

protected:
    // emitters for change notifications
    inline void name_changed(const std::string& newValue) {
        _emit_changed("name_changed",newValue);
    }

public:
    MidiReleaseHelper_skel();

    static std::string _interfaceNameSkel();
    std::string _interfaceName();
    bool _isCompatibleWith(const std::string& interfacename);
    void _buildMethodTable();
    void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
};

}
#include "reference.h"
namespace Arts {
class ARTS_EXPORT MidiReleaseHelper : public Arts::Object {
private:
    static Arts::Object_base* _Creator();
    MidiReleaseHelper_base *_cache;
    inline MidiReleaseHelper_base *_method_call() {
        _pool->checkcreate();
        if(_pool->base) {
            _cache=(MidiReleaseHelper_base *)_pool->base->_cast(MidiReleaseHelper_base::_IID);
            assert(_cache);
        }
        return _cache;
    }

protected:
    inline MidiReleaseHelper(MidiReleaseHelper_base* b) : Arts::Object(b), _cache(0) {}


public:
    typedef MidiReleaseHelper_base _base_class;

    inline MidiReleaseHelper() : Arts::Object(_Creator), _cache(0) {}
    inline MidiReleaseHelper(const Arts::SubClass& s) :
        Arts::Object(MidiReleaseHelper_base::_create(s.string())), _cache(0) {}
    inline MidiReleaseHelper(const Arts::Reference &r) :
        Arts::Object(r.isString()?(MidiReleaseHelper_base::_fromString(r.string())):(MidiReleaseHelper_base::_fromReference(r.reference(),true))), _cache(0) {}
    inline MidiReleaseHelper(const Arts::DynamicCast& c) : Arts::Object(MidiReleaseHelper_base::_fromDynamicCast(c.object())), _cache(0) {}
    inline MidiReleaseHelper(const MidiReleaseHelper& target) : Arts::Object(target._pool), _cache(target._cache) {}
    inline MidiReleaseHelper(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
    inline static MidiReleaseHelper null() {return MidiReleaseHelper((MidiReleaseHelper_base*)0);}
    inline static MidiReleaseHelper _from_base(MidiReleaseHelper_base* b) {return MidiReleaseHelper(b);}
    inline MidiReleaseHelper& operator=(const MidiReleaseHelper& target) {
        if (_pool == target._pool) return *this;
        _pool->Dec();
        _pool = target._pool;
        _cache = target._cache;
        _pool->Inc();
        return *this;
    }
    inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
    inline MidiReleaseHelper_base* _base() {return _cache?_cache:_method_call();}

    inline Arts::AutoSuspendState autoSuspend();
    inline void start();
    inline void stop();
    inline void streamInit();
    inline void streamStart();
    inline void streamEnd();
    inline Arts::SynthModule voice();
    inline void voice(Arts::SynthModule _newValue);
    inline std::string name();
    inline void name(const std::string& _newValue);
    inline Arts::ObjectCache cache();
    inline void cache(Arts::ObjectCache _newValue);
    inline bool terminate();
};

}
// Forward wrapper calls to _base classes:

inline Arts::AutoSuspendState Arts::Synth_DIV::autoSuspend()
{
    return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
}

inline void Arts::Synth_DIV::start()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
}

inline void Arts::Synth_DIV::stop()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
}

inline void Arts::Synth_DIV::streamInit()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
}

inline void Arts::Synth_DIV::streamStart()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
}

inline void Arts::Synth_DIV::streamEnd()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
}

inline Arts::AutoSuspendState Arts::Synth_XFADE::autoSuspend()
{
    return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
}

inline void Arts::Synth_XFADE::start()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
}

inline void Arts::Synth_XFADE::stop()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
}

inline void Arts::Synth_XFADE::streamInit()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
}

inline void Arts::Synth_XFADE::streamStart()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
}

inline void Arts::Synth_XFADE::streamEnd()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
}

inline Arts::AutoSuspendState Arts::Synth_AUTOPANNER::autoSuspend()
{
    return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
}

inline void Arts::Synth_AUTOPANNER::start()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
}

inline void Arts::Synth_AUTOPANNER::stop()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
}

inline void Arts::Synth_AUTOPANNER::streamInit()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
}

inline void Arts::Synth_AUTOPANNER::streamStart()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
}

inline void Arts::Synth_AUTOPANNER::streamEnd()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
}

inline Arts::AutoSuspendState Arts::Synth_DELAY::autoSuspend()
{
    return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
}

inline void Arts::Synth_DELAY::start()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
}

inline void Arts::Synth_DELAY::stop()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
}

inline void Arts::Synth_DELAY::streamInit()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
}

inline void Arts::Synth_DELAY::streamStart()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
}

inline void Arts::Synth_DELAY::streamEnd()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
}

inline float Arts::Synth_DELAY::maxdelay()
{
    return _cache?static_cast<Arts::Synth_DELAY_base*>(_cache)->maxdelay():static_cast<Arts::Synth_DELAY_base*>(_method_call())->maxdelay();
}

inline void Arts::Synth_DELAY::maxdelay(float _newValue)
{
     _cache?static_cast<Arts::Synth_DELAY_base*>(_cache)->maxdelay(_newValue):static_cast<Arts::Synth_DELAY_base*>(_method_call())->maxdelay(_newValue);
}

inline Arts::AutoSuspendState Arts::Synth_CDELAY::autoSuspend()
{
    return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
}

inline void Arts::Synth_CDELAY::start()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
}

inline void Arts::Synth_CDELAY::stop()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
}

inline void Arts::Synth_CDELAY::streamInit()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
}

inline void Arts::Synth_CDELAY::streamStart()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
}

inline void Arts::Synth_CDELAY::streamEnd()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
}

inline float Arts::Synth_CDELAY::time()
{
    return _cache?static_cast<Arts::Synth_CDELAY_base*>(_cache)->time():static_cast<Arts::Synth_CDELAY_base*>(_method_call())->time();
}

inline void Arts::Synth_CDELAY::time(float _newValue)
{
     _cache?static_cast<Arts::Synth_CDELAY_base*>(_cache)->time(_newValue):static_cast<Arts::Synth_CDELAY_base*>(_method_call())->time(_newValue);
}

inline Arts::AutoSuspendState Arts::Synth_ENVELOPE_ADSR::autoSuspend()
{
    return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
}

inline void Arts::Synth_ENVELOPE_ADSR::start()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
}

inline void Arts::Synth_ENVELOPE_ADSR::stop()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
}

inline void Arts::Synth_ENVELOPE_ADSR::streamInit()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
}

inline void Arts::Synth_ENVELOPE_ADSR::streamStart()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
}

inline void Arts::Synth_ENVELOPE_ADSR::streamEnd()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
}

inline Arts::AutoSuspendState Arts::Synth_PSCALE::autoSuspend()
{
    return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
}

inline void Arts::Synth_PSCALE::start()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
}

inline void Arts::Synth_PSCALE::stop()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
}

inline void Arts::Synth_PSCALE::streamInit()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
}

inline void Arts::Synth_PSCALE::streamStart()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
}

inline void Arts::Synth_PSCALE::streamEnd()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
}

inline float Arts::Synth_PSCALE::top()
{
    return _cache?static_cast<Arts::Synth_PSCALE_base*>(_cache)->top():static_cast<Arts::Synth_PSCALE_base*>(_method_call())->top();
}

inline void Arts::Synth_PSCALE::top(float _newValue)
{
     _cache?static_cast<Arts::Synth_PSCALE_base*>(_cache)->top(_newValue):static_cast<Arts::Synth_PSCALE_base*>(_method_call())->top(_newValue);
}

inline Arts::AutoSuspendState Arts::Synth_TREMOLO::autoSuspend()
{
    return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
}

inline void Arts::Synth_TREMOLO::start()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
}

inline void Arts::Synth_TREMOLO::stop()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
}

inline void Arts::Synth_TREMOLO::streamInit()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
}

inline void Arts::Synth_TREMOLO::streamStart()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
}

inline void Arts::Synth_TREMOLO::streamEnd()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
}

inline Arts::AutoSuspendState Arts::Synth_FX_CFLANGER::autoSuspend()
{
    return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
}

inline void Arts::Synth_FX_CFLANGER::start()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
}

inline void Arts::Synth_FX_CFLANGER::stop()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
}

inline void Arts::Synth_FX_CFLANGER::streamInit()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
}

inline void Arts::Synth_FX_CFLANGER::streamStart()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
}

inline void Arts::Synth_FX_CFLANGER::streamEnd()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
}

inline float Arts::Synth_FX_CFLANGER::mintime()
{
    return _cache?static_cast<Arts::Synth_FX_CFLANGER_base*>(_cache)->mintime():static_cast<Arts::Synth_FX_CFLANGER_base*>(_method_call())->mintime();
}

inline void Arts::Synth_FX_CFLANGER::mintime(float _newValue)
{
     _cache?static_cast<Arts::Synth_FX_CFLANGER_base*>(_cache)->mintime(_newValue):static_cast<Arts::Synth_FX_CFLANGER_base*>(_method_call())->mintime(_newValue);
}

inline float Arts::Synth_FX_CFLANGER::maxtime()
{
    return _cache?static_cast<Arts::Synth_FX_CFLANGER_base*>(_cache)->maxtime():static_cast<Arts::Synth_FX_CFLANGER_base*>(_method_call())->maxtime();
}

inline void Arts::Synth_FX_CFLANGER::maxtime(float _newValue)
{
     _cache?static_cast<Arts::Synth_FX_CFLANGER_base*>(_cache)->maxtime(_newValue):static_cast<Arts::Synth_FX_CFLANGER_base*>(_method_call())->maxtime(_newValue);
}

inline Arts::AutoSuspendState Arts::Synth_COMPRESSOR::autoSuspend()
{
    return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
}

inline void Arts::Synth_COMPRESSOR::start()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
}

inline void Arts::Synth_COMPRESSOR::stop()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
}

inline void Arts::Synth_COMPRESSOR::streamInit()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
}

inline void Arts::Synth_COMPRESSOR::streamStart()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
}

inline void Arts::Synth_COMPRESSOR::streamEnd()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
}

inline float Arts::Synth_COMPRESSOR::attack()
{
    return _cache?static_cast<Arts::Synth_COMPRESSOR_base*>(_cache)->attack():static_cast<Arts::Synth_COMPRESSOR_base*>(_method_call())->attack();
}

inline void Arts::Synth_COMPRESSOR::attack(float _newValue)
{
     _cache?static_cast<Arts::Synth_COMPRESSOR_base*>(_cache)->attack(_newValue):static_cast<Arts::Synth_COMPRESSOR_base*>(_method_call())->attack(_newValue);
}

inline float Arts::Synth_COMPRESSOR::release()
{
    return _cache?static_cast<Arts::Synth_COMPRESSOR_base*>(_cache)->release():static_cast<Arts::Synth_COMPRESSOR_base*>(_method_call())->release();
}

inline void Arts::Synth_COMPRESSOR::release(float _newValue)
{
     _cache?static_cast<Arts::Synth_COMPRESSOR_base*>(_cache)->release(_newValue):static_cast<Arts::Synth_COMPRESSOR_base*>(_method_call())->release(_newValue);
}

inline float Arts::Synth_COMPRESSOR::threshold()
{
    return _cache?static_cast<Arts::Synth_COMPRESSOR_base*>(_cache)->threshold():static_cast<Arts::Synth_COMPRESSOR_base*>(_method_call())->threshold();
}

inline void Arts::Synth_COMPRESSOR::threshold(float _newValue)
{
     _cache?static_cast<Arts::Synth_COMPRESSOR_base*>(_cache)->threshold(_newValue):static_cast<Arts::Synth_COMPRESSOR_base*>(_method_call())->threshold(_newValue);
}

inline float Arts::Synth_COMPRESSOR::ratio()
{
    return _cache?static_cast<Arts::Synth_COMPRESSOR_base*>(_cache)->ratio():static_cast<Arts::Synth_COMPRESSOR_base*>(_method_call())->ratio();
}

inline void Arts::Synth_COMPRESSOR::ratio(float _newValue)
{
     _cache?static_cast<Arts::Synth_COMPRESSOR_base*>(_cache)->ratio(_newValue):static_cast<Arts::Synth_COMPRESSOR_base*>(_method_call())->ratio(_newValue);
}

inline float Arts::Synth_COMPRESSOR::output()
{
    return _cache?static_cast<Arts::Synth_COMPRESSOR_base*>(_cache)->output():static_cast<Arts::Synth_COMPRESSOR_base*>(_method_call())->output();
}

inline void Arts::Synth_COMPRESSOR::output(float _newValue)
{
     _cache?static_cast<Arts::Synth_COMPRESSOR_base*>(_cache)->output(_newValue):static_cast<Arts::Synth_COMPRESSOR_base*>(_method_call())->output(_newValue);
}

inline Arts::AutoSuspendState Arts::Synth_PITCH_SHIFT::autoSuspend()
{
    return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
}

inline void Arts::Synth_PITCH_SHIFT::start()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
}

inline void Arts::Synth_PITCH_SHIFT::stop()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
}

inline void Arts::Synth_PITCH_SHIFT::streamInit()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
}

inline void Arts::Synth_PITCH_SHIFT::streamStart()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
}

inline void Arts::Synth_PITCH_SHIFT::streamEnd()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
}

inline float Arts::Synth_PITCH_SHIFT::speed()
{
    return _cache?static_cast<Arts::Synth_PITCH_SHIFT_base*>(_cache)->speed():static_cast<Arts::Synth_PITCH_SHIFT_base*>(_method_call())->speed();
}

inline void Arts::Synth_PITCH_SHIFT::speed(float _newValue)
{
     _cache?static_cast<Arts::Synth_PITCH_SHIFT_base*>(_cache)->speed(_newValue):static_cast<Arts::Synth_PITCH_SHIFT_base*>(_method_call())->speed(_newValue);
}

inline float Arts::Synth_PITCH_SHIFT::frequency()
{
    return _cache?static_cast<Arts::Synth_PITCH_SHIFT_base*>(_cache)->frequency():static_cast<Arts::Synth_PITCH_SHIFT_base*>(_method_call())->frequency();
}

inline void Arts::Synth_PITCH_SHIFT::frequency(float _newValue)
{
     _cache?static_cast<Arts::Synth_PITCH_SHIFT_base*>(_cache)->frequency(_newValue):static_cast<Arts::Synth_PITCH_SHIFT_base*>(_method_call())->frequency(_newValue);
}

inline Arts::AutoSuspendState Arts::Synth_PITCH_SHIFT_FFT::autoSuspend()
{
    return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
}

inline void Arts::Synth_PITCH_SHIFT_FFT::start()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
}

inline void Arts::Synth_PITCH_SHIFT_FFT::stop()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
}

inline void Arts::Synth_PITCH_SHIFT_FFT::streamInit()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
}

inline void Arts::Synth_PITCH_SHIFT_FFT::streamStart()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
}

inline void Arts::Synth_PITCH_SHIFT_FFT::streamEnd()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
}

inline float Arts::Synth_PITCH_SHIFT_FFT::speed()
{
    return _cache?static_cast<Arts::Synth_PITCH_SHIFT_FFT_base*>(_cache)->speed():static_cast<Arts::Synth_PITCH_SHIFT_FFT_base*>(_method_call())->speed();
}

inline void Arts::Synth_PITCH_SHIFT_FFT::speed(float _newValue)
{
     _cache?static_cast<Arts::Synth_PITCH_SHIFT_FFT_base*>(_cache)->speed(_newValue):static_cast<Arts::Synth_PITCH_SHIFT_FFT_base*>(_method_call())->speed(_newValue);
}

inline float Arts::Synth_PITCH_SHIFT_FFT::scaleFactor()
{
    return _cache?static_cast<Arts::Synth_PITCH_SHIFT_FFT_base*>(_cache)->scaleFactor():static_cast<Arts::Synth_PITCH_SHIFT_FFT_base*>(_method_call())->scaleFactor();
}

inline void Arts::Synth_PITCH_SHIFT_FFT::scaleFactor(float _newValue)
{
     _cache?static_cast<Arts::Synth_PITCH_SHIFT_FFT_base*>(_cache)->scaleFactor(_newValue):static_cast<Arts::Synth_PITCH_SHIFT_FFT_base*>(_method_call())->scaleFactor(_newValue);
}

inline long Arts::Synth_PITCH_SHIFT_FFT::frameSize()
{
    return _cache?static_cast<Arts::Synth_PITCH_SHIFT_FFT_base*>(_cache)->frameSize():static_cast<Arts::Synth_PITCH_SHIFT_FFT_base*>(_method_call())->frameSize();
}

inline void Arts::Synth_PITCH_SHIFT_FFT::frameSize(long _newValue)
{
     _cache?static_cast<Arts::Synth_PITCH_SHIFT_FFT_base*>(_cache)->frameSize(_newValue):static_cast<Arts::Synth_PITCH_SHIFT_FFT_base*>(_method_call())->frameSize(_newValue);
}

inline long Arts::Synth_PITCH_SHIFT_FFT::oversample()
{
    return _cache?static_cast<Arts::Synth_PITCH_SHIFT_FFT_base*>(_cache)->oversample():static_cast<Arts::Synth_PITCH_SHIFT_FFT_base*>(_method_call())->oversample();
}

inline void Arts::Synth_PITCH_SHIFT_FFT::oversample(long _newValue)
{
     _cache?static_cast<Arts::Synth_PITCH_SHIFT_FFT_base*>(_cache)->oversample(_newValue):static_cast<Arts::Synth_PITCH_SHIFT_FFT_base*>(_method_call())->oversample(_newValue);
}

inline Arts::AutoSuspendState Arts::Synth_SHELVE_CUTOFF::autoSuspend()
{
    return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
}

inline void Arts::Synth_SHELVE_CUTOFF::start()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
}

inline void Arts::Synth_SHELVE_CUTOFF::stop()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
}

inline void Arts::Synth_SHELVE_CUTOFF::streamInit()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
}

inline void Arts::Synth_SHELVE_CUTOFF::streamStart()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
}

inline void Arts::Synth_SHELVE_CUTOFF::streamEnd()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
}

inline Arts::AutoSuspendState Arts::Synth_BRICKWALL_LIMITER::autoSuspend()
{
    return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
}

inline void Arts::Synth_BRICKWALL_LIMITER::start()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
}

inline void Arts::Synth_BRICKWALL_LIMITER::stop()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
}

inline void Arts::Synth_BRICKWALL_LIMITER::streamInit()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
}

inline void Arts::Synth_BRICKWALL_LIMITER::streamStart()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
}

inline void Arts::Synth_BRICKWALL_LIMITER::streamEnd()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
}

inline Arts::AutoSuspendState Arts::Synth_STD_EQUALIZER::autoSuspend()
{
    return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
}

inline void Arts::Synth_STD_EQUALIZER::start()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
}

inline void Arts::Synth_STD_EQUALIZER::stop()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
}

inline void Arts::Synth_STD_EQUALIZER::streamInit()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
}

inline void Arts::Synth_STD_EQUALIZER::streamStart()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
}

inline void Arts::Synth_STD_EQUALIZER::streamEnd()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
}

inline float Arts::Synth_STD_EQUALIZER::low()
{
    return _cache?static_cast<Arts::Synth_STD_EQUALIZER_base*>(_cache)->low():static_cast<Arts::Synth_STD_EQUALIZER_base*>(_method_call())->low();
}

inline void Arts::Synth_STD_EQUALIZER::low(float _newValue)
{
     _cache?static_cast<Arts::Synth_STD_EQUALIZER_base*>(_cache)->low(_newValue):static_cast<Arts::Synth_STD_EQUALIZER_base*>(_method_call())->low(_newValue);
}

inline float Arts::Synth_STD_EQUALIZER::mid()
{
    return _cache?static_cast<Arts::Synth_STD_EQUALIZER_base*>(_cache)->mid():static_cast<Arts::Synth_STD_EQUALIZER_base*>(_method_call())->mid();
}

inline void Arts::Synth_STD_EQUALIZER::mid(float _newValue)
{
     _cache?static_cast<Arts::Synth_STD_EQUALIZER_base*>(_cache)->mid(_newValue):static_cast<Arts::Synth_STD_EQUALIZER_base*>(_method_call())->mid(_newValue);
}

inline float Arts::Synth_STD_EQUALIZER::high()
{
    return _cache?static_cast<Arts::Synth_STD_EQUALIZER_base*>(_cache)->high():static_cast<Arts::Synth_STD_EQUALIZER_base*>(_method_call())->high();
}

inline void Arts::Synth_STD_EQUALIZER::high(float _newValue)
{
     _cache?static_cast<Arts::Synth_STD_EQUALIZER_base*>(_cache)->high(_newValue):static_cast<Arts::Synth_STD_EQUALIZER_base*>(_method_call())->high(_newValue);
}

inline float Arts::Synth_STD_EQUALIZER::frequency()
{
    return _cache?static_cast<Arts::Synth_STD_EQUALIZER_base*>(_cache)->frequency():static_cast<Arts::Synth_STD_EQUALIZER_base*>(_method_call())->frequency();
}

inline void Arts::Synth_STD_EQUALIZER::frequency(float _newValue)
{
     _cache?static_cast<Arts::Synth_STD_EQUALIZER_base*>(_cache)->frequency(_newValue):static_cast<Arts::Synth_STD_EQUALIZER_base*>(_method_call())->frequency(_newValue);
}

inline float Arts::Synth_STD_EQUALIZER::q()
{
    return _cache?static_cast<Arts::Synth_STD_EQUALIZER_base*>(_cache)->q():static_cast<Arts::Synth_STD_EQUALIZER_base*>(_method_call())->q();
}

inline void Arts::Synth_STD_EQUALIZER::q(float _newValue)
{
     _cache?static_cast<Arts::Synth_STD_EQUALIZER_base*>(_cache)->q(_newValue):static_cast<Arts::Synth_STD_EQUALIZER_base*>(_method_call())->q(_newValue);
}

inline Arts::AutoSuspendState Arts::Synth_RC::autoSuspend()
{
    return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
}

inline void Arts::Synth_RC::start()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
}

inline void Arts::Synth_RC::stop()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
}

inline void Arts::Synth_RC::streamInit()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
}

inline void Arts::Synth_RC::streamStart()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
}

inline void Arts::Synth_RC::streamEnd()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
}

inline float Arts::Synth_RC::b()
{
    return _cache?static_cast<Arts::Synth_RC_base*>(_cache)->b():static_cast<Arts::Synth_RC_base*>(_method_call())->b();
}

inline void Arts::Synth_RC::b(float _newValue)
{
     _cache?static_cast<Arts::Synth_RC_base*>(_cache)->b(_newValue):static_cast<Arts::Synth_RC_base*>(_method_call())->b(_newValue);
}

inline float Arts::Synth_RC::f()
{
    return _cache?static_cast<Arts::Synth_RC_base*>(_cache)->f():static_cast<Arts::Synth_RC_base*>(_method_call())->f();
}

inline void Arts::Synth_RC::f(float _newValue)
{
     _cache?static_cast<Arts::Synth_RC_base*>(_cache)->f(_newValue):static_cast<Arts::Synth_RC_base*>(_method_call())->f(_newValue);
}

inline Arts::AutoSuspendState Arts::Synth_MOOG_VCF::autoSuspend()
{
    return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
}

inline void Arts::Synth_MOOG_VCF::start()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
}

inline void Arts::Synth_MOOG_VCF::stop()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
}

inline void Arts::Synth_MOOG_VCF::streamInit()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
}

inline void Arts::Synth_MOOG_VCF::streamStart()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
}

inline void Arts::Synth_MOOG_VCF::streamEnd()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
}

inline float Arts::Synth_MOOG_VCF::frequency()
{
    return _cache?static_cast<Arts::Synth_MOOG_VCF_base*>(_cache)->frequency():static_cast<Arts::Synth_MOOG_VCF_base*>(_method_call())->frequency();
}

inline void Arts::Synth_MOOG_VCF::frequency(float _newValue)
{
     _cache?static_cast<Arts::Synth_MOOG_VCF_base*>(_cache)->frequency(_newValue):static_cast<Arts::Synth_MOOG_VCF_base*>(_method_call())->frequency(_newValue);
}

inline float Arts::Synth_MOOG_VCF::resonance()
{
    return _cache?static_cast<Arts::Synth_MOOG_VCF_base*>(_cache)->resonance():static_cast<Arts::Synth_MOOG_VCF_base*>(_method_call())->resonance();
}

inline void Arts::Synth_MOOG_VCF::resonance(float _newValue)
{
     _cache?static_cast<Arts::Synth_MOOG_VCF_base*>(_cache)->resonance(_newValue):static_cast<Arts::Synth_MOOG_VCF_base*>(_method_call())->resonance(_newValue);
}

inline Arts::AutoSuspendState Arts::Synth_ATAN_SATURATE::autoSuspend()
{
    return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
}

inline void Arts::Synth_ATAN_SATURATE::start()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
}

inline void Arts::Synth_ATAN_SATURATE::stop()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
}

inline void Arts::Synth_ATAN_SATURATE::streamInit()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
}

inline void Arts::Synth_ATAN_SATURATE::streamStart()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
}

inline void Arts::Synth_ATAN_SATURATE::streamEnd()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
}

inline float Arts::Synth_ATAN_SATURATE::inscale()
{
    return _cache?static_cast<Arts::Synth_ATAN_SATURATE_base*>(_cache)->inscale():static_cast<Arts::Synth_ATAN_SATURATE_base*>(_method_call())->inscale();
}

inline void Arts::Synth_ATAN_SATURATE::inscale(float _newValue)
{
     _cache?static_cast<Arts::Synth_ATAN_SATURATE_base*>(_cache)->inscale(_newValue):static_cast<Arts::Synth_ATAN_SATURATE_base*>(_method_call())->inscale(_newValue);
}

inline Arts::AutoSuspendState Arts::Synth_MIDI_TEST::autoSuspend()
{
    return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
}

inline void Arts::Synth_MIDI_TEST::start()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
}

inline void Arts::Synth_MIDI_TEST::stop()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
}

inline void Arts::Synth_MIDI_TEST::streamInit()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
}

inline void Arts::Synth_MIDI_TEST::streamStart()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
}

inline void Arts::Synth_MIDI_TEST::streamEnd()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
}

inline Arts::TimeStamp Arts::Synth_MIDI_TEST::time()
{
    return _cache?static_cast<Arts::MidiPort_base*>(_cache)->time():static_cast<Arts::MidiPort_base*>(_method_call())->time();
}

inline Arts::TimeStamp Arts::Synth_MIDI_TEST::playTime()
{
    return _cache?static_cast<Arts::MidiPort_base*>(_cache)->playTime():static_cast<Arts::MidiPort_base*>(_method_call())->playTime();
}

inline void Arts::Synth_MIDI_TEST::processCommand(const Arts::MidiCommand& command)
{
     _cache?static_cast<Arts::MidiPort_base*>(_cache)->processCommand(command):static_cast<Arts::MidiPort_base*>(_method_call())->processCommand(command);
}

inline void Arts::Synth_MIDI_TEST::processEvent(const Arts::MidiEvent& event)
{
     _cache?static_cast<Arts::MidiPort_base*>(_cache)->processEvent(event):static_cast<Arts::MidiPort_base*>(_method_call())->processEvent(event);
}

inline std::string Arts::Synth_MIDI_TEST::filename()
{
    return _cache?static_cast<Arts::Synth_MIDI_TEST_base*>(_cache)->filename():static_cast<Arts::Synth_MIDI_TEST_base*>(_method_call())->filename();
}

inline void Arts::Synth_MIDI_TEST::filename(const std::string& _newValue)
{
     _cache?static_cast<Arts::Synth_MIDI_TEST_base*>(_cache)->filename(_newValue):static_cast<Arts::Synth_MIDI_TEST_base*>(_method_call())->filename(_newValue);
}

inline std::string Arts::Synth_MIDI_TEST::busname()
{
    return _cache?static_cast<Arts::Synth_MIDI_TEST_base*>(_cache)->busname():static_cast<Arts::Synth_MIDI_TEST_base*>(_method_call())->busname();
}

inline void Arts::Synth_MIDI_TEST::busname(const std::string& _newValue)
{
     _cache?static_cast<Arts::Synth_MIDI_TEST_base*>(_cache)->busname(_newValue):static_cast<Arts::Synth_MIDI_TEST_base*>(_method_call())->busname(_newValue);
}

inline Arts::AutoSuspendState Arts::Synth_SEQUENCE::autoSuspend()
{
    return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
}

inline void Arts::Synth_SEQUENCE::start()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
}

inline void Arts::Synth_SEQUENCE::stop()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
}

inline void Arts::Synth_SEQUENCE::streamInit()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
}

inline void Arts::Synth_SEQUENCE::streamStart()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
}

inline void Arts::Synth_SEQUENCE::streamEnd()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
}

inline float Arts::Synth_SEQUENCE::speed()
{
    return _cache?static_cast<Arts::Synth_SEQUENCE_base*>(_cache)->speed():static_cast<Arts::Synth_SEQUENCE_base*>(_method_call())->speed();
}

inline void Arts::Synth_SEQUENCE::speed(float _newValue)
{
     _cache?static_cast<Arts::Synth_SEQUENCE_base*>(_cache)->speed(_newValue):static_cast<Arts::Synth_SEQUENCE_base*>(_method_call())->speed(_newValue);
}

inline std::string Arts::Synth_SEQUENCE::seq()
{
    return _cache?static_cast<Arts::Synth_SEQUENCE_base*>(_cache)->seq():static_cast<Arts::Synth_SEQUENCE_base*>(_method_call())->seq();
}

inline void Arts::Synth_SEQUENCE::seq(const std::string& _newValue)
{
     _cache?static_cast<Arts::Synth_SEQUENCE_base*>(_cache)->seq(_newValue):static_cast<Arts::Synth_SEQUENCE_base*>(_method_call())->seq(_newValue);
}

inline Arts::AutoSuspendState Arts::Synth_SEQUENCE_FREQ::autoSuspend()
{
    return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
}

inline void Arts::Synth_SEQUENCE_FREQ::start()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
}

inline void Arts::Synth_SEQUENCE_FREQ::stop()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
}

inline void Arts::Synth_SEQUENCE_FREQ::streamInit()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
}

inline void Arts::Synth_SEQUENCE_FREQ::streamStart()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
}

inline void Arts::Synth_SEQUENCE_FREQ::streamEnd()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
}

inline float Arts::Synth_SEQUENCE_FREQ::speed()
{
    return _cache?static_cast<Arts::Synth_SEQUENCE_FREQ_base*>(_cache)->speed():static_cast<Arts::Synth_SEQUENCE_FREQ_base*>(_method_call())->speed();
}

inline void Arts::Synth_SEQUENCE_FREQ::speed(float _newValue)
{
     _cache?static_cast<Arts::Synth_SEQUENCE_FREQ_base*>(_cache)->speed(_newValue):static_cast<Arts::Synth_SEQUENCE_FREQ_base*>(_method_call())->speed(_newValue);
}

inline std::string Arts::Synth_SEQUENCE_FREQ::seq()
{
    return _cache?static_cast<Arts::Synth_SEQUENCE_FREQ_base*>(_cache)->seq():static_cast<Arts::Synth_SEQUENCE_FREQ_base*>(_method_call())->seq();
}

inline void Arts::Synth_SEQUENCE_FREQ::seq(const std::string& _newValue)
{
     _cache?static_cast<Arts::Synth_SEQUENCE_FREQ_base*>(_cache)->seq(_newValue):static_cast<Arts::Synth_SEQUENCE_FREQ_base*>(_method_call())->seq(_newValue);
}

inline Arts::AutoSuspendState Arts::Synth_FM_SOURCE::autoSuspend()
{
    return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
}

inline void Arts::Synth_FM_SOURCE::start()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
}

inline void Arts::Synth_FM_SOURCE::stop()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
}

inline void Arts::Synth_FM_SOURCE::streamInit()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
}

inline void Arts::Synth_FM_SOURCE::streamStart()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
}

inline void Arts::Synth_FM_SOURCE::streamEnd()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
}

inline Arts::AutoSuspendState Arts::Synth_WAVE_TRI::autoSuspend()
{
    return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
}

inline void Arts::Synth_WAVE_TRI::start()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
}

inline void Arts::Synth_WAVE_TRI::stop()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
}

inline void Arts::Synth_WAVE_TRI::streamInit()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
}

inline void Arts::Synth_WAVE_TRI::streamStart()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
}

inline void Arts::Synth_WAVE_TRI::streamEnd()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
}

inline Arts::AutoSuspendState Arts::Synth_NOISE::autoSuspend()
{
    return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
}

inline void Arts::Synth_NOISE::start()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
}

inline void Arts::Synth_NOISE::stop()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
}

inline void Arts::Synth_NOISE::streamInit()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
}

inline void Arts::Synth_NOISE::streamStart()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
}

inline void Arts::Synth_NOISE::streamEnd()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
}

inline Arts::AutoSuspendState Arts::Synth_WAVE_SQUARE::autoSuspend()
{
    return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
}

inline void Arts::Synth_WAVE_SQUARE::start()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
}

inline void Arts::Synth_WAVE_SQUARE::stop()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
}

inline void Arts::Synth_WAVE_SQUARE::streamInit()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
}

inline void Arts::Synth_WAVE_SQUARE::streamStart()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
}

inline void Arts::Synth_WAVE_SQUARE::streamEnd()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
}

inline Arts::AutoSuspendState Arts::Synth_WAVE_SOFTSAW::autoSuspend()
{
    return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
}

inline void Arts::Synth_WAVE_SOFTSAW::start()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
}

inline void Arts::Synth_WAVE_SOFTSAW::stop()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
}

inline void Arts::Synth_WAVE_SOFTSAW::streamInit()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
}

inline void Arts::Synth_WAVE_SOFTSAW::streamStart()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
}

inline void Arts::Synth_WAVE_SOFTSAW::streamEnd()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
}

inline Arts::AutoSuspendState Arts::Synth_WAVE_PULSE::autoSuspend()
{
    return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
}

inline void Arts::Synth_WAVE_PULSE::start()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
}

inline void Arts::Synth_WAVE_PULSE::stop()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
}

inline void Arts::Synth_WAVE_PULSE::streamInit()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
}

inline void Arts::Synth_WAVE_PULSE::streamStart()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
}

inline void Arts::Synth_WAVE_PULSE::streamEnd()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
}

inline float Arts::Synth_WAVE_PULSE::dutycycle()
{
    return _cache?static_cast<Arts::Synth_WAVE_PULSE_base*>(_cache)->dutycycle():static_cast<Arts::Synth_WAVE_PULSE_base*>(_method_call())->dutycycle();
}

inline void Arts::Synth_WAVE_PULSE::dutycycle(float _newValue)
{
     _cache?static_cast<Arts::Synth_WAVE_PULSE_base*>(_cache)->dutycycle(_newValue):static_cast<Arts::Synth_WAVE_PULSE_base*>(_method_call())->dutycycle(_newValue);
}

inline Arts::AutoSuspendState Arts::Synth_OSC::autoSuspend()
{
    return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
}

inline void Arts::Synth_OSC::start()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
}

inline void Arts::Synth_OSC::stop()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
}

inline void Arts::Synth_OSC::streamInit()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
}

inline void Arts::Synth_OSC::streamStart()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
}

inline void Arts::Synth_OSC::streamEnd()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
}

inline Arts::SynthOscWaveForm Arts::Synth_OSC::waveForm()
{
    return _cache?static_cast<Arts::Synth_OSC_base*>(_cache)->waveForm():static_cast<Arts::Synth_OSC_base*>(_method_call())->waveForm();
}

inline void Arts::Synth_OSC::waveForm(Arts::SynthOscWaveForm _newValue)
{
     _cache?static_cast<Arts::Synth_OSC_base*>(_cache)->waveForm(_newValue):static_cast<Arts::Synth_OSC_base*>(_method_call())->waveForm(_newValue);
}

inline bool Arts::Synth_OSC::fmExponential()
{
    return _cache?static_cast<Arts::Synth_OSC_base*>(_cache)->fmExponential():static_cast<Arts::Synth_OSC_base*>(_method_call())->fmExponential();
}

inline void Arts::Synth_OSC::fmExponential(bool _newValue)
{
     _cache?static_cast<Arts::Synth_OSC_base*>(_cache)->fmExponential(_newValue):static_cast<Arts::Synth_OSC_base*>(_method_call())->fmExponential(_newValue);
}

inline float Arts::Synth_OSC::fmStrength()
{
    return _cache?static_cast<Arts::Synth_OSC_base*>(_cache)->fmStrength():static_cast<Arts::Synth_OSC_base*>(_method_call())->fmStrength();
}

inline void Arts::Synth_OSC::fmStrength(float _newValue)
{
     _cache?static_cast<Arts::Synth_OSC_base*>(_cache)->fmStrength(_newValue):static_cast<Arts::Synth_OSC_base*>(_method_call())->fmStrength(_newValue);
}

inline float Arts::Synth_OSC::fmSelfStrength()
{
    return _cache?static_cast<Arts::Synth_OSC_base*>(_cache)->fmSelfStrength():static_cast<Arts::Synth_OSC_base*>(_method_call())->fmSelfStrength();
}

inline void Arts::Synth_OSC::fmSelfStrength(float _newValue)
{
     _cache?static_cast<Arts::Synth_OSC_base*>(_cache)->fmSelfStrength(_newValue):static_cast<Arts::Synth_OSC_base*>(_method_call())->fmSelfStrength(_newValue);
}

inline float Arts::Synth_OSC::phase()
{
    return _cache?static_cast<Arts::Synth_OSC_base*>(_cache)->phase():static_cast<Arts::Synth_OSC_base*>(_method_call())->phase();
}

inline void Arts::Synth_OSC::phase(float _newValue)
{
     _cache?static_cast<Arts::Synth_OSC_base*>(_cache)->phase(_newValue):static_cast<Arts::Synth_OSC_base*>(_method_call())->phase(_newValue);
}

inline float Arts::Synth_OSC::frequency()
{
    return _cache?static_cast<Arts::Synth_OSC_base*>(_cache)->frequency():static_cast<Arts::Synth_OSC_base*>(_method_call())->frequency();
}

inline void Arts::Synth_OSC::frequency(float _newValue)
{
     _cache?static_cast<Arts::Synth_OSC_base*>(_cache)->frequency(_newValue):static_cast<Arts::Synth_OSC_base*>(_method_call())->frequency(_newValue);
}

inline long Arts::Synth_OSC::fineTune()
{
    return _cache?static_cast<Arts::Synth_OSC_base*>(_cache)->fineTune():static_cast<Arts::Synth_OSC_base*>(_method_call())->fineTune();
}

inline void Arts::Synth_OSC::fineTune(long _newValue)
{
     _cache?static_cast<Arts::Synth_OSC_base*>(_cache)->fineTune(_newValue):static_cast<Arts::Synth_OSC_base*>(_method_call())->fineTune(_newValue);
}

inline float Arts::Synth_OSC::pulseWidth()
{
    return _cache?static_cast<Arts::Synth_OSC_base*>(_cache)->pulseWidth():static_cast<Arts::Synth_OSC_base*>(_method_call())->pulseWidth();
}

inline void Arts::Synth_OSC::pulseWidth(float _newValue)
{
     _cache?static_cast<Arts::Synth_OSC_base*>(_cache)->pulseWidth(_newValue):static_cast<Arts::Synth_OSC_base*>(_method_call())->pulseWidth(_newValue);
}

inline float Arts::Synth_OSC::pulseModStrength()
{
    return _cache?static_cast<Arts::Synth_OSC_base*>(_cache)->pulseModStrength():static_cast<Arts::Synth_OSC_base*>(_method_call())->pulseModStrength();
}

inline void Arts::Synth_OSC::pulseModStrength(float _newValue)
{
     _cache?static_cast<Arts::Synth_OSC_base*>(_cache)->pulseModStrength(_newValue):static_cast<Arts::Synth_OSC_base*>(_method_call())->pulseModStrength(_newValue);
}

inline Arts::AutoSuspendState Arts::Synth_PLAY_PAT::autoSuspend()
{
    return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
}

inline void Arts::Synth_PLAY_PAT::start()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
}

inline void Arts::Synth_PLAY_PAT::stop()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
}

inline void Arts::Synth_PLAY_PAT::streamInit()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
}

inline void Arts::Synth_PLAY_PAT::streamStart()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
}

inline void Arts::Synth_PLAY_PAT::streamEnd()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
}

inline std::string Arts::Synth_PLAY_PAT::filename()
{
    return _cache?static_cast<Arts::Synth_PLAY_PAT_base*>(_cache)->filename():static_cast<Arts::Synth_PLAY_PAT_base*>(_method_call())->filename();
}

inline void Arts::Synth_PLAY_PAT::filename(const std::string& _newValue)
{
     _cache?static_cast<Arts::Synth_PLAY_PAT_base*>(_cache)->filename(_newValue):static_cast<Arts::Synth_PLAY_PAT_base*>(_method_call())->filename(_newValue);
}

inline Arts::AutoSuspendState Arts::Synth_CAPTURE_WAV::autoSuspend()
{
    return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
}

inline void Arts::Synth_CAPTURE_WAV::start()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
}

inline void Arts::Synth_CAPTURE_WAV::stop()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
}

inline void Arts::Synth_CAPTURE_WAV::streamInit()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
}

inline void Arts::Synth_CAPTURE_WAV::streamStart()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
}

inline void Arts::Synth_CAPTURE_WAV::streamEnd()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
}

inline std::string Arts::Synth_CAPTURE_WAV::filename()
{
    return _cache?static_cast<Arts::Synth_CAPTURE_WAV_base*>(_cache)->filename():static_cast<Arts::Synth_CAPTURE_WAV_base*>(_method_call())->filename();
}

inline void Arts::Synth_CAPTURE_WAV::filename(const std::string& _newValue)
{
     _cache?static_cast<Arts::Synth_CAPTURE_WAV_base*>(_cache)->filename(_newValue):static_cast<Arts::Synth_CAPTURE_WAV_base*>(_method_call())->filename(_newValue);
}

inline Arts::AutoSuspendState Arts::Synth_NIL::autoSuspend()
{
    return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
}

inline void Arts::Synth_NIL::start()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
}

inline void Arts::Synth_NIL::stop()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
}

inline void Arts::Synth_NIL::streamInit()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
}

inline void Arts::Synth_NIL::streamStart()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
}

inline void Arts::Synth_NIL::streamEnd()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
}

inline Arts::AutoSuspendState Arts::Synth_DEBUG::autoSuspend()
{
    return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
}

inline void Arts::Synth_DEBUG::start()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
}

inline void Arts::Synth_DEBUG::stop()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
}

inline void Arts::Synth_DEBUG::streamInit()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
}

inline void Arts::Synth_DEBUG::streamStart()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
}

inline void Arts::Synth_DEBUG::streamEnd()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
}

inline std::string Arts::Synth_DEBUG::comment()
{
    return _cache?static_cast<Arts::Synth_DEBUG_base*>(_cache)->comment():static_cast<Arts::Synth_DEBUG_base*>(_method_call())->comment();
}

inline void Arts::Synth_DEBUG::comment(const std::string& _newValue)
{
     _cache?static_cast<Arts::Synth_DEBUG_base*>(_cache)->comment(_newValue):static_cast<Arts::Synth_DEBUG_base*>(_method_call())->comment(_newValue);
}

inline Arts::AutoSuspendState Arts::Synth_DATA::autoSuspend()
{
    return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
}

inline void Arts::Synth_DATA::start()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
}

inline void Arts::Synth_DATA::stop()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
}

inline void Arts::Synth_DATA::streamInit()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
}

inline void Arts::Synth_DATA::streamStart()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
}

inline void Arts::Synth_DATA::streamEnd()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
}

inline float Arts::Synth_DATA::value()
{
    return _cache?static_cast<Arts::Synth_DATA_base*>(_cache)->value():static_cast<Arts::Synth_DATA_base*>(_method_call())->value();
}

inline void Arts::Synth_DATA::value(float _newValue)
{
     _cache?static_cast<Arts::Synth_DATA_base*>(_cache)->value(_newValue):static_cast<Arts::Synth_DATA_base*>(_method_call())->value(_newValue);
}

inline Arts::AutoSuspendState Arts::Synth_MIDI_DEBUG::autoSuspend()
{
    return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
}

inline void Arts::Synth_MIDI_DEBUG::start()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
}

inline void Arts::Synth_MIDI_DEBUG::stop()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
}

inline void Arts::Synth_MIDI_DEBUG::streamInit()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
}

inline void Arts::Synth_MIDI_DEBUG::streamStart()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
}

inline void Arts::Synth_MIDI_DEBUG::streamEnd()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
}

inline Arts::TimeStamp Arts::Synth_MIDI_DEBUG::time()
{
    return _cache?static_cast<Arts::MidiPort_base*>(_cache)->time():static_cast<Arts::MidiPort_base*>(_method_call())->time();
}

inline Arts::TimeStamp Arts::Synth_MIDI_DEBUG::playTime()
{
    return _cache?static_cast<Arts::MidiPort_base*>(_cache)->playTime():static_cast<Arts::MidiPort_base*>(_method_call())->playTime();
}

inline void Arts::Synth_MIDI_DEBUG::processCommand(const Arts::MidiCommand& command)
{
     _cache?static_cast<Arts::MidiPort_base*>(_cache)->processCommand(command):static_cast<Arts::MidiPort_base*>(_method_call())->processCommand(command);
}

inline void Arts::Synth_MIDI_DEBUG::processEvent(const Arts::MidiEvent& event)
{
     _cache?static_cast<Arts::MidiPort_base*>(_cache)->processEvent(event):static_cast<Arts::MidiPort_base*>(_method_call())->processEvent(event);
}

inline void Arts::ObjectCache::put(Arts::Object obj, const std::string& name)
{
     _cache?static_cast<Arts::ObjectCache_base*>(_cache)->put(obj, name):static_cast<Arts::ObjectCache_base*>(_method_call())->put(obj, name);
}

inline Arts::Object Arts::ObjectCache::get(const std::string& name)
{
    return _cache?static_cast<Arts::ObjectCache_base*>(_cache)->get(name):static_cast<Arts::ObjectCache_base*>(_method_call())->get(name);
}

inline Arts::AutoSuspendState Arts::MidiReleaseHelper::autoSuspend()
{
    return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
}

inline void Arts::MidiReleaseHelper::start()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
}

inline void Arts::MidiReleaseHelper::stop()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
}

inline void Arts::MidiReleaseHelper::streamInit()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
}

inline void Arts::MidiReleaseHelper::streamStart()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
}

inline void Arts::MidiReleaseHelper::streamEnd()
{
     _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
}

inline Arts::SynthModule Arts::MidiReleaseHelper::voice()
{
    return _cache?static_cast<Arts::MidiReleaseHelper_base*>(_cache)->voice():static_cast<Arts::MidiReleaseHelper_base*>(_method_call())->voice();
}

inline void Arts::MidiReleaseHelper::voice(Arts::SynthModule _newValue)
{
     _cache?static_cast<Arts::MidiReleaseHelper_base*>(_cache)->voice(_newValue):static_cast<Arts::MidiReleaseHelper_base*>(_method_call())->voice(_newValue);
}

inline std::string Arts::MidiReleaseHelper::name()
{
    return _cache?static_cast<Arts::MidiReleaseHelper_base*>(_cache)->name():static_cast<Arts::MidiReleaseHelper_base*>(_method_call())->name();
}

inline void Arts::MidiReleaseHelper::name(const std::string& _newValue)
{
     _cache?static_cast<Arts::MidiReleaseHelper_base*>(_cache)->name(_newValue):static_cast<Arts::MidiReleaseHelper_base*>(_method_call())->name(_newValue);
}

inline Arts::ObjectCache Arts::MidiReleaseHelper::cache()
{
    return _cache?static_cast<Arts::MidiReleaseHelper_base*>(_cache)->cache():static_cast<Arts::MidiReleaseHelper_base*>(_method_call())->cache();
}

inline void Arts::MidiReleaseHelper::cache(Arts::ObjectCache _newValue)
{
     _cache?static_cast<Arts::MidiReleaseHelper_base*>(_cache)->cache(_newValue):static_cast<Arts::MidiReleaseHelper_base*>(_method_call())->cache(_newValue);
}

inline bool Arts::MidiReleaseHelper::terminate()
{
    return _cache?static_cast<Arts::MidiReleaseHelper_base*>(_cache)->terminate():static_cast<Arts::MidiReleaseHelper_base*>(_method_call())->terminate();
}

#endif /* ARTSMODULESSYNTH_H */