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

#ifndef NOATUNARTS_H
#define NOATUNARTS_H

#include "common.h"

#include "arts_export.h"

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

namespace Noatun {
class Equalizer;
class EqualizerSSE;
class FFTScope;
class FFTScopeStereo;
class RawScope;
class RawScopeStereo;
class StereoEffectStack;
class StereoVolumeControl;
class StereoVolumeControlSSE;
class Listener;
class Session;

class ARTS_EXPORT Equalizer_base : virtual public Arts::StereoEffect_base {
public:
	static unsigned long _IID; // interface ID

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

	static Equalizer_base *_fromDynamicCast(const Arts::Object& object);
	inline 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 std::vector<float> * levelCenters() = 0;
	virtual void levelCenters(const std::vector<float>& newValue) = 0;
	virtual std::vector<float> * levelWidths() = 0;
	virtual void levelWidths(const std::vector<float>& newValue) = 0;
	virtual std::vector<float> * levels() = 0;
	virtual void levels(const std::vector<float>& newValue) = 0;
	virtual long bands() = 0;
	virtual void bands(long newValue) = 0;
	virtual long enabled() = 0;
	virtual void enabled(long newValue) = 0;
	virtual float preamp() = 0;
	virtual void preamp(float newValue) = 0;
	virtual void set(const std::vector<float>& levels, const std::vector<float>& centers, const std::vector<float>& widths) = 0;
};

class ARTS_EXPORT Equalizer_stub : virtual public Equalizer_base, virtual public Arts::StereoEffect_stub {
protected:
	Equalizer_stub();

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

	std::vector<float> * levelCenters();
	void levelCenters(const std::vector<float>& newValue);
	std::vector<float> * levelWidths();
	void levelWidths(const std::vector<float>& newValue);
	std::vector<float> * levels();
	void levels(const std::vector<float>& newValue);
	long bands();
	void bands(long newValue);
	long enabled();
	void enabled(long newValue);
	float preamp();
	void preamp(float newValue);
	void set(const std::vector<float>& levels, const std::vector<float>& centers, const std::vector<float>& widths);
};

class ARTS_EXPORT Equalizer_skel : virtual public Equalizer_base, virtual public Arts::StereoEffect_skel {
protected:
	// emitters for change notifications
	inline void levelCenters_changed(const std::vector<float>& newValue) {
		_emit_changed("levelCenters_changed",newValue);
	}
	inline void levelWidths_changed(const std::vector<float>& newValue) {
		_emit_changed("levelWidths_changed",newValue);
	}
	inline void levels_changed(const std::vector<float>& newValue) {
		_emit_changed("levels_changed",newValue);
	}
	inline void bands_changed(long newValue) {
		_emit_changed("bands_changed",newValue);
	}
	inline void enabled_changed(long newValue) {
		_emit_changed("enabled_changed",newValue);
	}
	inline void preamp_changed(float newValue) {
		_emit_changed("preamp_changed",newValue);
	}

public:
	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 Noatun {
class ARTS_EXPORT Equalizer : public Arts::Object {
private:
	static Arts::Object_base* _Creator();
	Equalizer_base *_cache;
	inline Equalizer_base *_method_call() {
		_pool->checkcreate();
		if(_pool->base) {
			_cache=(Equalizer_base *)_pool->base->_cast(Equalizer_base::_IID);
			assert(_cache);
		}
		return _cache;
	}

protected:
	inline Equalizer(Equalizer_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef Equalizer_base _base_class;

	inline Equalizer() : Arts::Object(_Creator), _cache(0) {}
	inline Equalizer(const Arts::SubClass& s) :
		Arts::Object(Equalizer_base::_create(s.string())), _cache(0) {}
	inline Equalizer(const Arts::Reference &r) :
		Arts::Object(r.isString()?(Equalizer_base::_fromString(r.string())):(Equalizer_base::_fromReference(r.reference(),true))), _cache(0) {}
	inline Equalizer(const Arts::DynamicCast& c) : Arts::Object(Equalizer_base::_fromDynamicCast(c.object())), _cache(0) {}
	inline Equalizer(const Equalizer& target) : Arts::Object(target._pool), _cache(target._cache) {}
	inline Equalizer(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
	inline static Equalizer null() {return Equalizer((Equalizer_base*)0);}
	inline static Equalizer _from_base(Equalizer_base* b) {return Equalizer(b);}
	inline Equalizer& operator=(const Equalizer& target) {
		if (_pool == target._pool) return *this;
		_pool->Dec();
		_pool = target._pool;
		_cache = target._cache;
		_pool->Inc();
		return *this;
	}
	inline operator Arts::StereoEffect() const { return Arts::StereoEffect(*_pool); }
	inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
	inline 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 std::vector<float> * levelCenters();
	inline void levelCenters(const std::vector<float>& _newValue);
	inline std::vector<float> * levelWidths();
	inline void levelWidths(const std::vector<float>& _newValue);
	inline std::vector<float> * levels();
	inline void levels(const std::vector<float>& _newValue);
	inline long bands();
	inline void bands(long _newValue);
	inline long enabled();
	inline void enabled(long _newValue);
	inline float preamp();
	inline void preamp(float _newValue);
	inline void set(const std::vector<float>& levels, const std::vector<float>& centers, const std::vector<float>& widths);
};

class ARTS_EXPORT EqualizerSSE_base : virtual public Arts::StereoEffect_base {
public:
	static unsigned long _IID; // interface ID

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

	static EqualizerSSE_base *_fromDynamicCast(const Arts::Object& object);
	inline EqualizerSSE_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::vector<float> * levelCenters() = 0;
	virtual void levelCenters(const std::vector<float>& newValue) = 0;
	virtual std::vector<float> * levelWidths() = 0;
	virtual void levelWidths(const std::vector<float>& newValue) = 0;
	virtual std::vector<float> * levels() = 0;
	virtual void levels(const std::vector<float>& newValue) = 0;
	virtual long bands() = 0;
	virtual void bands(long newValue) = 0;
	virtual long enabled() = 0;
	virtual void enabled(long newValue) = 0;
	virtual float preamp() = 0;
	virtual void preamp(float newValue) = 0;
	virtual void set(const std::vector<float>& levels, const std::vector<float>& centers, const std::vector<float>& widths) = 0;
};

class ARTS_EXPORT EqualizerSSE_stub : virtual public EqualizerSSE_base, virtual public Arts::StereoEffect_stub {
protected:
	EqualizerSSE_stub();

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

	std::vector<float> * levelCenters();
	void levelCenters(const std::vector<float>& newValue);
	std::vector<float> * levelWidths();
	void levelWidths(const std::vector<float>& newValue);
	std::vector<float> * levels();
	void levels(const std::vector<float>& newValue);
	long bands();
	void bands(long newValue);
	long enabled();
	void enabled(long newValue);
	float preamp();
	void preamp(float newValue);
	void set(const std::vector<float>& levels, const std::vector<float>& centers, const std::vector<float>& widths);
};

class ARTS_EXPORT EqualizerSSE_skel : virtual public EqualizerSSE_base, virtual public Arts::StereoEffect_skel {
protected:
	// emitters for change notifications
	inline void levelCenters_changed(const std::vector<float>& newValue) {
		_emit_changed("levelCenters_changed",newValue);
	}
	inline void levelWidths_changed(const std::vector<float>& newValue) {
		_emit_changed("levelWidths_changed",newValue);
	}
	inline void levels_changed(const std::vector<float>& newValue) {
		_emit_changed("levels_changed",newValue);
	}
	inline void bands_changed(long newValue) {
		_emit_changed("bands_changed",newValue);
	}
	inline void enabled_changed(long newValue) {
		_emit_changed("enabled_changed",newValue);
	}
	inline void preamp_changed(float newValue) {
		_emit_changed("preamp_changed",newValue);
	}

public:
	EqualizerSSE_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 Noatun {
class ARTS_EXPORT EqualizerSSE : public Arts::Object {
private:
	static Arts::Object_base* _Creator();
	EqualizerSSE_base *_cache;
	inline EqualizerSSE_base *_method_call() {
		_pool->checkcreate();
		if(_pool->base) {
			_cache=(EqualizerSSE_base *)_pool->base->_cast(EqualizerSSE_base::_IID);
			assert(_cache);
		}
		return _cache;
	}

protected:
	inline EqualizerSSE(EqualizerSSE_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef EqualizerSSE_base _base_class;

	inline EqualizerSSE() : Arts::Object(_Creator), _cache(0) {}
	inline EqualizerSSE(const Arts::SubClass& s) :
		Arts::Object(EqualizerSSE_base::_create(s.string())), _cache(0) {}
	inline EqualizerSSE(const Arts::Reference &r) :
		Arts::Object(r.isString()?(EqualizerSSE_base::_fromString(r.string())):(EqualizerSSE_base::_fromReference(r.reference(),true))), _cache(0) {}
	inline EqualizerSSE(const Arts::DynamicCast& c) : Arts::Object(EqualizerSSE_base::_fromDynamicCast(c.object())), _cache(0) {}
	inline EqualizerSSE(const EqualizerSSE& target) : Arts::Object(target._pool), _cache(target._cache) {}
	inline EqualizerSSE(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
	inline static EqualizerSSE null() {return EqualizerSSE((EqualizerSSE_base*)0);}
	inline static EqualizerSSE _from_base(EqualizerSSE_base* b) {return EqualizerSSE(b);}
	inline EqualizerSSE& operator=(const EqualizerSSE& target) {
		if (_pool == target._pool) return *this;
		_pool->Dec();
		_pool = target._pool;
		_cache = target._cache;
		_pool->Inc();
		return *this;
	}
	inline operator Arts::StereoEffect() const { return Arts::StereoEffect(*_pool); }
	inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
	inline EqualizerSSE_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::vector<float> * levelCenters();
	inline void levelCenters(const std::vector<float>& _newValue);
	inline std::vector<float> * levelWidths();
	inline void levelWidths(const std::vector<float>& _newValue);
	inline std::vector<float> * levels();
	inline void levels(const std::vector<float>& _newValue);
	inline long bands();
	inline void bands(long _newValue);
	inline long enabled();
	inline void enabled(long _newValue);
	inline float preamp();
	inline void preamp(float _newValue);
	inline void set(const std::vector<float>& levels, const std::vector<float>& centers, const std::vector<float>& widths);
};

class ARTS_EXPORT FFTScope_base : virtual public Arts::StereoEffect_base {
public:
	static unsigned long _IID; // interface ID

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

	static FFTScope_base *_fromDynamicCast(const Arts::Object& object);
	inline FFTScope_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 bandResolution() = 0;
	virtual void bandResolution(float newValue) = 0;
	virtual std::vector<float> * scope() = 0;
};

class ARTS_EXPORT FFTScope_stub : virtual public FFTScope_base, virtual public Arts::StereoEffect_stub {
protected:
	FFTScope_stub();

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

	float bandResolution();
	void bandResolution(float newValue);
	std::vector<float> * scope();
};

class ARTS_EXPORT FFTScope_skel : virtual public FFTScope_base, virtual public Arts::StereoEffect_skel {
protected:
	// emitters for change notifications
	inline void bandResolution_changed(float newValue) {
		_emit_changed("bandResolution_changed",newValue);
	}

public:
	FFTScope_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 Noatun {
class ARTS_EXPORT FFTScope : public Arts::Object {
private:
	static Arts::Object_base* _Creator();
	FFTScope_base *_cache;
	inline FFTScope_base *_method_call() {
		_pool->checkcreate();
		if(_pool->base) {
			_cache=(FFTScope_base *)_pool->base->_cast(FFTScope_base::_IID);
			assert(_cache);
		}
		return _cache;
	}

protected:
	inline FFTScope(FFTScope_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef FFTScope_base _base_class;

	inline FFTScope() : Arts::Object(_Creator), _cache(0) {}
	inline FFTScope(const Arts::SubClass& s) :
		Arts::Object(FFTScope_base::_create(s.string())), _cache(0) {}
	inline FFTScope(const Arts::Reference &r) :
		Arts::Object(r.isString()?(FFTScope_base::_fromString(r.string())):(FFTScope_base::_fromReference(r.reference(),true))), _cache(0) {}
	inline FFTScope(const Arts::DynamicCast& c) : Arts::Object(FFTScope_base::_fromDynamicCast(c.object())), _cache(0) {}
	inline FFTScope(const FFTScope& target) : Arts::Object(target._pool), _cache(target._cache) {}
	inline FFTScope(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
	inline static FFTScope null() {return FFTScope((FFTScope_base*)0);}
	inline static FFTScope _from_base(FFTScope_base* b) {return FFTScope(b);}
	inline FFTScope& operator=(const FFTScope& target) {
		if (_pool == target._pool) return *this;
		_pool->Dec();
		_pool = target._pool;
		_cache = target._cache;
		_pool->Inc();
		return *this;
	}
	inline operator Arts::StereoEffect() const { return Arts::StereoEffect(*_pool); }
	inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
	inline FFTScope_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 bandResolution();
	inline void bandResolution(float _newValue);
	inline std::vector<float> * scope();
};

class ARTS_EXPORT FFTScopeStereo_base : virtual public Arts::StereoEffect_base {
public:
	static unsigned long _IID; // interface ID

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

	static FFTScopeStereo_base *_fromDynamicCast(const Arts::Object& object);
	inline FFTScopeStereo_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 bandResolution() = 0;
	virtual void bandResolution(float newValue) = 0;
	virtual std::vector<float> * scopeRight() = 0;
	virtual std::vector<float> * scopeLeft() = 0;
};

class ARTS_EXPORT FFTScopeStereo_stub : virtual public FFTScopeStereo_base, virtual public Arts::StereoEffect_stub {
protected:
	FFTScopeStereo_stub();

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

	float bandResolution();
	void bandResolution(float newValue);
	std::vector<float> * scopeRight();
	std::vector<float> * scopeLeft();
};

class ARTS_EXPORT FFTScopeStereo_skel : virtual public FFTScopeStereo_base, virtual public Arts::StereoEffect_skel {
protected:
	// emitters for change notifications
	inline void bandResolution_changed(float newValue) {
		_emit_changed("bandResolution_changed",newValue);
	}

public:
	FFTScopeStereo_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 Noatun {
class ARTS_EXPORT FFTScopeStereo : public Arts::Object {
private:
	static Arts::Object_base* _Creator();
	FFTScopeStereo_base *_cache;
	inline FFTScopeStereo_base *_method_call() {
		_pool->checkcreate();
		if(_pool->base) {
			_cache=(FFTScopeStereo_base *)_pool->base->_cast(FFTScopeStereo_base::_IID);
			assert(_cache);
		}
		return _cache;
	}

protected:
	inline FFTScopeStereo(FFTScopeStereo_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef FFTScopeStereo_base _base_class;

	inline FFTScopeStereo() : Arts::Object(_Creator), _cache(0) {}
	inline FFTScopeStereo(const Arts::SubClass& s) :
		Arts::Object(FFTScopeStereo_base::_create(s.string())), _cache(0) {}
	inline FFTScopeStereo(const Arts::Reference &r) :
		Arts::Object(r.isString()?(FFTScopeStereo_base::_fromString(r.string())):(FFTScopeStereo_base::_fromReference(r.reference(),true))), _cache(0) {}
	inline FFTScopeStereo(const Arts::DynamicCast& c) : Arts::Object(FFTScopeStereo_base::_fromDynamicCast(c.object())), _cache(0) {}
	inline FFTScopeStereo(const FFTScopeStereo& target) : Arts::Object(target._pool), _cache(target._cache) {}
	inline FFTScopeStereo(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
	inline static FFTScopeStereo null() {return FFTScopeStereo((FFTScopeStereo_base*)0);}
	inline static FFTScopeStereo _from_base(FFTScopeStereo_base* b) {return FFTScopeStereo(b);}
	inline FFTScopeStereo& operator=(const FFTScopeStereo& target) {
		if (_pool == target._pool) return *this;
		_pool->Dec();
		_pool = target._pool;
		_cache = target._cache;
		_pool->Inc();
		return *this;
	}
	inline operator Arts::StereoEffect() const { return Arts::StereoEffect(*_pool); }
	inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
	inline FFTScopeStereo_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 bandResolution();
	inline void bandResolution(float _newValue);
	inline std::vector<float> * scopeRight();
	inline std::vector<float> * scopeLeft();
};

class ARTS_EXPORT RawScope_base : virtual public Arts::StereoEffect_base {
public:
	static unsigned long _IID; // interface ID

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

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

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

	void *_cast(unsigned long iid);

	virtual long buffer() = 0;
	virtual void buffer(long newValue) = 0;
	virtual std::vector<float> * scope() = 0;
};

class ARTS_EXPORT RawScope_stub : virtual public RawScope_base, virtual public Arts::StereoEffect_stub {
protected:
	RawScope_stub();

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

	long buffer();
	void buffer(long newValue);
	std::vector<float> * scope();
};

class ARTS_EXPORT RawScope_skel : virtual public RawScope_base, virtual public Arts::StereoEffect_skel {
protected:
	// emitters for change notifications
	inline void buffer_changed(long newValue) {
		_emit_changed("buffer_changed",newValue);
	}

public:
	RawScope_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 Noatun {
class ARTS_EXPORT RawScope : public Arts::Object {
private:
	static Arts::Object_base* _Creator();
	RawScope_base *_cache;
	inline RawScope_base *_method_call() {
		_pool->checkcreate();
		if(_pool->base) {
			_cache=(RawScope_base *)_pool->base->_cast(RawScope_base::_IID);
			assert(_cache);
		}
		return _cache;
	}

protected:
	inline RawScope(RawScope_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef RawScope_base _base_class;

	inline RawScope() : Arts::Object(_Creator), _cache(0) {}
	inline RawScope(const Arts::SubClass& s) :
		Arts::Object(RawScope_base::_create(s.string())), _cache(0) {}
	inline RawScope(const Arts::Reference &r) :
		Arts::Object(r.isString()?(RawScope_base::_fromString(r.string())):(RawScope_base::_fromReference(r.reference(),true))), _cache(0) {}
	inline RawScope(const Arts::DynamicCast& c) : Arts::Object(RawScope_base::_fromDynamicCast(c.object())), _cache(0) {}
	inline RawScope(const RawScope& target) : Arts::Object(target._pool), _cache(target._cache) {}
	inline RawScope(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
	inline static RawScope null() {return RawScope((RawScope_base*)0);}
	inline static RawScope _from_base(RawScope_base* b) {return RawScope(b);}
	inline RawScope& operator=(const RawScope& target) {
		if (_pool == target._pool) return *this;
		_pool->Dec();
		_pool = target._pool;
		_cache = target._cache;
		_pool->Inc();
		return *this;
	}
	inline operator Arts::StereoEffect() const { return Arts::StereoEffect(*_pool); }
	inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
	inline RawScope_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 long buffer();
	inline void buffer(long _newValue);
	inline std::vector<float> * scope();
};

class ARTS_EXPORT RawScopeStereo_base : virtual public Arts::StereoEffect_base {
public:
	static unsigned long _IID; // interface ID

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

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

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

	void *_cast(unsigned long iid);

	virtual long buffer() = 0;
	virtual void buffer(long newValue) = 0;
	virtual std::vector<float> * scopeLeft() = 0;
	virtual std::vector<float> * scopeRight() = 0;
};

class ARTS_EXPORT RawScopeStereo_stub : virtual public RawScopeStereo_base, virtual public Arts::StereoEffect_stub {
protected:
	RawScopeStereo_stub();

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

	long buffer();
	void buffer(long newValue);
	std::vector<float> * scopeLeft();
	std::vector<float> * scopeRight();
};

class ARTS_EXPORT RawScopeStereo_skel : virtual public RawScopeStereo_base, virtual public Arts::StereoEffect_skel {
protected:
	// emitters for change notifications
	inline void buffer_changed(long newValue) {
		_emit_changed("buffer_changed",newValue);
	}

public:
	RawScopeStereo_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 Noatun {
class ARTS_EXPORT RawScopeStereo : public Arts::Object {
private:
	static Arts::Object_base* _Creator();
	RawScopeStereo_base *_cache;
	inline RawScopeStereo_base *_method_call() {
		_pool->checkcreate();
		if(_pool->base) {
			_cache=(RawScopeStereo_base *)_pool->base->_cast(RawScopeStereo_base::_IID);
			assert(_cache);
		}
		return _cache;
	}

protected:
	inline RawScopeStereo(RawScopeStereo_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef RawScopeStereo_base _base_class;

	inline RawScopeStereo() : Arts::Object(_Creator), _cache(0) {}
	inline RawScopeStereo(const Arts::SubClass& s) :
		Arts::Object(RawScopeStereo_base::_create(s.string())), _cache(0) {}
	inline RawScopeStereo(const Arts::Reference &r) :
		Arts::Object(r.isString()?(RawScopeStereo_base::_fromString(r.string())):(RawScopeStereo_base::_fromReference(r.reference(),true))), _cache(0) {}
	inline RawScopeStereo(const Arts::DynamicCast& c) : Arts::Object(RawScopeStereo_base::_fromDynamicCast(c.object())), _cache(0) {}
	inline RawScopeStereo(const RawScopeStereo& target) : Arts::Object(target._pool), _cache(target._cache) {}
	inline RawScopeStereo(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
	inline static RawScopeStereo null() {return RawScopeStereo((RawScopeStereo_base*)0);}
	inline static RawScopeStereo _from_base(RawScopeStereo_base* b) {return RawScopeStereo(b);}
	inline RawScopeStereo& operator=(const RawScopeStereo& target) {
		if (_pool == target._pool) return *this;
		_pool->Dec();
		_pool = target._pool;
		_cache = target._cache;
		_pool->Inc();
		return *this;
	}
	inline operator Arts::StereoEffect() const { return Arts::StereoEffect(*_pool); }
	inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
	inline RawScopeStereo_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 long buffer();
	inline void buffer(long _newValue);
	inline std::vector<float> * scopeLeft();
	inline std::vector<float> * scopeRight();
};

class ARTS_EXPORT StereoEffectStack_base : virtual public Arts::StereoEffect_base {
public:
	static unsigned long _IID; // interface ID

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

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

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

	void *_cast(unsigned long iid);

	virtual long insertAfter(long after, Arts::StereoEffect effect, const std::string& name) = 0;
	virtual void move(long after, long item) = 0;
	virtual std::vector<long> * effectList() = 0;
	virtual long insertTop(Arts::StereoEffect effect, const std::string& name) = 0;
	virtual long insertBottom(Arts::StereoEffect effect, const std::string& name) = 0;
	virtual void remove(long ID) = 0;
};

class ARTS_EXPORT StereoEffectStack_stub : virtual public StereoEffectStack_base, virtual public Arts::StereoEffect_stub {
protected:
	StereoEffectStack_stub();

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

	long insertAfter(long after, Arts::StereoEffect effect, const std::string& name);
	void move(long after, long item);
	std::vector<long> * effectList();
	long insertTop(Arts::StereoEffect effect, const std::string& name);
	long insertBottom(Arts::StereoEffect effect, const std::string& name);
	void remove(long ID);
};

class ARTS_EXPORT StereoEffectStack_skel : virtual public StereoEffectStack_base, virtual public Arts::StereoEffect_skel {
public:
	StereoEffectStack_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 Noatun {
class ARTS_EXPORT StereoEffectStack : public Arts::Object {
private:
	static Arts::Object_base* _Creator();
	StereoEffectStack_base *_cache;
	inline StereoEffectStack_base *_method_call() {
		_pool->checkcreate();
		if(_pool->base) {
			_cache=(StereoEffectStack_base *)_pool->base->_cast(StereoEffectStack_base::_IID);
			assert(_cache);
		}
		return _cache;
	}

protected:
	inline StereoEffectStack(StereoEffectStack_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef StereoEffectStack_base _base_class;

	inline StereoEffectStack() : Arts::Object(_Creator), _cache(0) {}
	inline StereoEffectStack(const Arts::SubClass& s) :
		Arts::Object(StereoEffectStack_base::_create(s.string())), _cache(0) {}
	inline StereoEffectStack(const Arts::Reference &r) :
		Arts::Object(r.isString()?(StereoEffectStack_base::_fromString(r.string())):(StereoEffectStack_base::_fromReference(r.reference(),true))), _cache(0) {}
	inline StereoEffectStack(const Arts::DynamicCast& c) : Arts::Object(StereoEffectStack_base::_fromDynamicCast(c.object())), _cache(0) {}
	inline StereoEffectStack(const StereoEffectStack& target) : Arts::Object(target._pool), _cache(target._cache) {}
	inline StereoEffectStack(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
	inline static StereoEffectStack null() {return StereoEffectStack((StereoEffectStack_base*)0);}
	inline static StereoEffectStack _from_base(StereoEffectStack_base* b) {return StereoEffectStack(b);}
	inline StereoEffectStack& operator=(const StereoEffectStack& target) {
		if (_pool == target._pool) return *this;
		_pool->Dec();
		_pool = target._pool;
		_cache = target._cache;
		_pool->Inc();
		return *this;
	}
	inline operator Arts::StereoEffect() const { return Arts::StereoEffect(*_pool); }
	inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
	inline StereoEffectStack_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 long insertAfter(long after, Arts::StereoEffect effect, const std::string& name);
	inline void move(long after, long item);
	inline std::vector<long> * effectList();
	inline long insertTop(Arts::StereoEffect effect, const std::string& name);
	inline long insertBottom(Arts::StereoEffect effect, const std::string& name);
	inline void remove(long ID);
};

class ARTS_EXPORT StereoVolumeControl_base : virtual public Arts::StereoEffect_base {
public:
	static unsigned long _IID; // interface ID

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

	static StereoVolumeControl_base *_fromDynamicCast(const Arts::Object& object);
	inline StereoVolumeControl_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 percent() = 0;
	virtual void percent(float newValue) = 0;
};

class ARTS_EXPORT StereoVolumeControl_stub : virtual public StereoVolumeControl_base, virtual public Arts::StereoEffect_stub {
protected:
	StereoVolumeControl_stub();

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

	float percent();
	void percent(float newValue);
};

class ARTS_EXPORT StereoVolumeControl_skel : virtual public StereoVolumeControl_base, virtual public Arts::StereoEffect_skel {
protected:
	// emitters for change notifications
	inline void percent_changed(float newValue) {
		_emit_changed("percent_changed",newValue);
	}

public:
	StereoVolumeControl_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 Noatun {
class ARTS_EXPORT StereoVolumeControl : public Arts::Object {
private:
	static Arts::Object_base* _Creator();
	StereoVolumeControl_base *_cache;
	inline StereoVolumeControl_base *_method_call() {
		_pool->checkcreate();
		if(_pool->base) {
			_cache=(StereoVolumeControl_base *)_pool->base->_cast(StereoVolumeControl_base::_IID);
			assert(_cache);
		}
		return _cache;
	}

protected:
	inline StereoVolumeControl(StereoVolumeControl_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef StereoVolumeControl_base _base_class;

	inline StereoVolumeControl() : Arts::Object(_Creator), _cache(0) {}
	inline StereoVolumeControl(const Arts::SubClass& s) :
		Arts::Object(StereoVolumeControl_base::_create(s.string())), _cache(0) {}
	inline StereoVolumeControl(const Arts::Reference &r) :
		Arts::Object(r.isString()?(StereoVolumeControl_base::_fromString(r.string())):(StereoVolumeControl_base::_fromReference(r.reference(),true))), _cache(0) {}
	inline StereoVolumeControl(const Arts::DynamicCast& c) : Arts::Object(StereoVolumeControl_base::_fromDynamicCast(c.object())), _cache(0) {}
	inline StereoVolumeControl(const StereoVolumeControl& target) : Arts::Object(target._pool), _cache(target._cache) {}
	inline StereoVolumeControl(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
	inline static StereoVolumeControl null() {return StereoVolumeControl((StereoVolumeControl_base*)0);}
	inline static StereoVolumeControl _from_base(StereoVolumeControl_base* b) {return StereoVolumeControl(b);}
	inline StereoVolumeControl& operator=(const StereoVolumeControl& target) {
		if (_pool == target._pool) return *this;
		_pool->Dec();
		_pool = target._pool;
		_cache = target._cache;
		_pool->Inc();
		return *this;
	}
	inline operator Arts::StereoEffect() const { return Arts::StereoEffect(*_pool); }
	inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
	inline StereoVolumeControl_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 percent();
	inline void percent(float _newValue);
};

class ARTS_EXPORT StereoVolumeControlSSE_base : virtual public Arts::StereoEffect_base {
public:
	static unsigned long _IID; // interface ID

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

	static StereoVolumeControlSSE_base *_fromDynamicCast(const Arts::Object& object);
	inline StereoVolumeControlSSE_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 percent() = 0;
	virtual void percent(float newValue) = 0;
};

class ARTS_EXPORT StereoVolumeControlSSE_stub : virtual public StereoVolumeControlSSE_base, virtual public Arts::StereoEffect_stub {
protected:
	StereoVolumeControlSSE_stub();

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

	float percent();
	void percent(float newValue);
};

class ARTS_EXPORT StereoVolumeControlSSE_skel : virtual public StereoVolumeControlSSE_base, virtual public Arts::StereoEffect_skel {
protected:
	// emitters for change notifications
	inline void percent_changed(float newValue) {
		_emit_changed("percent_changed",newValue);
	}

public:
	StereoVolumeControlSSE_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 Noatun {
class ARTS_EXPORT StereoVolumeControlSSE : public Arts::Object {
private:
	static Arts::Object_base* _Creator();
	StereoVolumeControlSSE_base *_cache;
	inline StereoVolumeControlSSE_base *_method_call() {
		_pool->checkcreate();
		if(_pool->base) {
			_cache=(StereoVolumeControlSSE_base *)_pool->base->_cast(StereoVolumeControlSSE_base::_IID);
			assert(_cache);
		}
		return _cache;
	}

protected:
	inline StereoVolumeControlSSE(StereoVolumeControlSSE_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef StereoVolumeControlSSE_base _base_class;

	inline StereoVolumeControlSSE() : Arts::Object(_Creator), _cache(0) {}
	inline StereoVolumeControlSSE(const Arts::SubClass& s) :
		Arts::Object(StereoVolumeControlSSE_base::_create(s.string())), _cache(0) {}
	inline StereoVolumeControlSSE(const Arts::Reference &r) :
		Arts::Object(r.isString()?(StereoVolumeControlSSE_base::_fromString(r.string())):(StereoVolumeControlSSE_base::_fromReference(r.reference(),true))), _cache(0) {}
	inline StereoVolumeControlSSE(const Arts::DynamicCast& c) : Arts::Object(StereoVolumeControlSSE_base::_fromDynamicCast(c.object())), _cache(0) {}
	inline StereoVolumeControlSSE(const StereoVolumeControlSSE& target) : Arts::Object(target._pool), _cache(target._cache) {}
	inline StereoVolumeControlSSE(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
	inline static StereoVolumeControlSSE null() {return StereoVolumeControlSSE((StereoVolumeControlSSE_base*)0);}
	inline static StereoVolumeControlSSE _from_base(StereoVolumeControlSSE_base* b) {return StereoVolumeControlSSE(b);}
	inline StereoVolumeControlSSE& operator=(const StereoVolumeControlSSE& target) {
		if (_pool == target._pool) return *this;
		_pool->Dec();
		_pool = target._pool;
		_cache = target._cache;
		_pool->Inc();
		return *this;
	}
	inline operator Arts::StereoEffect() const { return Arts::StereoEffect(*_pool); }
	inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
	inline StereoVolumeControlSSE_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 percent();
	inline void percent(float _newValue);
};

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

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

	static Listener_base *_fromDynamicCast(const Arts::Object& object);
	inline Listener_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 message() = 0;
};

class ARTS_EXPORT Listener_stub : virtual public Listener_base, virtual public Arts::Object_stub {
protected:
	Listener_stub();

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

	void message();
};

class ARTS_EXPORT Listener_skel : virtual public Listener_base, virtual public Arts::Object_skel {
public:
	Listener_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 Noatun {
class ARTS_EXPORT Listener : public Arts::Object {
private:
	static Arts::Object_base* _Creator();
	Listener_base *_cache;
	inline Listener_base *_method_call() {
		_pool->checkcreate();
		if(_pool->base) {
			_cache=(Listener_base *)_pool->base->_cast(Listener_base::_IID);
			assert(_cache);
		}
		return _cache;
	}

protected:
	inline Listener(Listener_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef Listener_base _base_class;

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

	inline void message();
};

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

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

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

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

	void *_cast(unsigned long iid);

	virtual long pid() = 0;
	virtual void pid(long newValue) = 0;
	virtual void addListener(Noatun::Listener listener) = 0;
	virtual void removeListener(Noatun::Listener listener) = 0;
};

class ARTS_EXPORT Session_stub : virtual public Session_base, virtual public Arts::Object_stub {
protected:
	Session_stub();

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

	long pid();
	void pid(long newValue);
	void addListener(Noatun::Listener listener);
	void removeListener(Noatun::Listener listener);
};

class ARTS_EXPORT Session_skel : virtual public Session_base, virtual public Arts::Object_skel {
protected:
	// emitters for change notifications
	inline void pid_changed(long newValue) {
		_emit_changed("pid_changed",newValue);
	}

public:
	Session_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 Noatun {
class ARTS_EXPORT Session : public Arts::Object {
private:
	static Arts::Object_base* _Creator();
	Session_base *_cache;
	inline Session_base *_method_call() {
		_pool->checkcreate();
		if(_pool->base) {
			_cache=(Session_base *)_pool->base->_cast(Session_base::_IID);
			assert(_cache);
		}
		return _cache;
	}

protected:
	inline Session(Session_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef Session_base _base_class;

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

	inline long pid();
	inline void pid(long _newValue);
	inline void addListener(Noatun::Listener listener);
	inline void removeListener(Noatun::Listener listener);
};

}
// Forward wrapper calls to _base classes:

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

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

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

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

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

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

inline std::vector<float> * Noatun::Equalizer::levelCenters()
{
	return _cache?static_cast<Noatun::Equalizer_base*>(_cache)->levelCenters():static_cast<Noatun::Equalizer_base*>(_method_call())->levelCenters();
}

inline void Noatun::Equalizer::levelCenters(const std::vector<float>& _newValue)
{
	 _cache?static_cast<Noatun::Equalizer_base*>(_cache)->levelCenters(_newValue):static_cast<Noatun::Equalizer_base*>(_method_call())->levelCenters(_newValue);
}

inline std::vector<float> * Noatun::Equalizer::levelWidths()
{
	return _cache?static_cast<Noatun::Equalizer_base*>(_cache)->levelWidths():static_cast<Noatun::Equalizer_base*>(_method_call())->levelWidths();
}

inline void Noatun::Equalizer::levelWidths(const std::vector<float>& _newValue)
{
	 _cache?static_cast<Noatun::Equalizer_base*>(_cache)->levelWidths(_newValue):static_cast<Noatun::Equalizer_base*>(_method_call())->levelWidths(_newValue);
}

inline std::vector<float> * Noatun::Equalizer::levels()
{
	return _cache?static_cast<Noatun::Equalizer_base*>(_cache)->levels():static_cast<Noatun::Equalizer_base*>(_method_call())->levels();
}

inline void Noatun::Equalizer::levels(const std::vector<float>& _newValue)
{
	 _cache?static_cast<Noatun::Equalizer_base*>(_cache)->levels(_newValue):static_cast<Noatun::Equalizer_base*>(_method_call())->levels(_newValue);
}

inline long Noatun::Equalizer::bands()
{
	return _cache?static_cast<Noatun::Equalizer_base*>(_cache)->bands():static_cast<Noatun::Equalizer_base*>(_method_call())->bands();
}

inline void Noatun::Equalizer::bands(long _newValue)
{
	 _cache?static_cast<Noatun::Equalizer_base*>(_cache)->bands(_newValue):static_cast<Noatun::Equalizer_base*>(_method_call())->bands(_newValue);
}

inline long Noatun::Equalizer::enabled()
{
	return _cache?static_cast<Noatun::Equalizer_base*>(_cache)->enabled():static_cast<Noatun::Equalizer_base*>(_method_call())->enabled();
}

inline void Noatun::Equalizer::enabled(long _newValue)
{
	 _cache?static_cast<Noatun::Equalizer_base*>(_cache)->enabled(_newValue):static_cast<Noatun::Equalizer_base*>(_method_call())->enabled(_newValue);
}

inline float Noatun::Equalizer::preamp()
{
	return _cache?static_cast<Noatun::Equalizer_base*>(_cache)->preamp():static_cast<Noatun::Equalizer_base*>(_method_call())->preamp();
}

inline void Noatun::Equalizer::preamp(float _newValue)
{
	 _cache?static_cast<Noatun::Equalizer_base*>(_cache)->preamp(_newValue):static_cast<Noatun::Equalizer_base*>(_method_call())->preamp(_newValue);
}

inline void Noatun::Equalizer::set(const std::vector<float>& levels, const std::vector<float>& centers, const std::vector<float>& widths)
{
	 _cache?static_cast<Noatun::Equalizer_base*>(_cache)->set(levels, centers, widths):static_cast<Noatun::Equalizer_base*>(_method_call())->set(levels, centers, widths);
}

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

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

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

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

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

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

inline std::vector<float> * Noatun::EqualizerSSE::levelCenters()
{
	return _cache?static_cast<Noatun::EqualizerSSE_base*>(_cache)->levelCenters():static_cast<Noatun::EqualizerSSE_base*>(_method_call())->levelCenters();
}

inline void Noatun::EqualizerSSE::levelCenters(const std::vector<float>& _newValue)
{
	 _cache?static_cast<Noatun::EqualizerSSE_base*>(_cache)->levelCenters(_newValue):static_cast<Noatun::EqualizerSSE_base*>(_method_call())->levelCenters(_newValue);
}

inline std::vector<float> * Noatun::EqualizerSSE::levelWidths()
{
	return _cache?static_cast<Noatun::EqualizerSSE_base*>(_cache)->levelWidths():static_cast<Noatun::EqualizerSSE_base*>(_method_call())->levelWidths();
}

inline void Noatun::EqualizerSSE::levelWidths(const std::vector<float>& _newValue)
{
	 _cache?static_cast<Noatun::EqualizerSSE_base*>(_cache)->levelWidths(_newValue):static_cast<Noatun::EqualizerSSE_base*>(_method_call())->levelWidths(_newValue);
}

inline std::vector<float> * Noatun::EqualizerSSE::levels()
{
	return _cache?static_cast<Noatun::EqualizerSSE_base*>(_cache)->levels():static_cast<Noatun::EqualizerSSE_base*>(_method_call())->levels();
}

inline void Noatun::EqualizerSSE::levels(const std::vector<float>& _newValue)
{
	 _cache?static_cast<Noatun::EqualizerSSE_base*>(_cache)->levels(_newValue):static_cast<Noatun::EqualizerSSE_base*>(_method_call())->levels(_newValue);
}

inline long Noatun::EqualizerSSE::bands()
{
	return _cache?static_cast<Noatun::EqualizerSSE_base*>(_cache)->bands():static_cast<Noatun::EqualizerSSE_base*>(_method_call())->bands();
}

inline void Noatun::EqualizerSSE::bands(long _newValue)
{
	 _cache?static_cast<Noatun::EqualizerSSE_base*>(_cache)->bands(_newValue):static_cast<Noatun::EqualizerSSE_base*>(_method_call())->bands(_newValue);
}

inline long Noatun::EqualizerSSE::enabled()
{
	return _cache?static_cast<Noatun::EqualizerSSE_base*>(_cache)->enabled():static_cast<Noatun::EqualizerSSE_base*>(_method_call())->enabled();
}

inline void Noatun::EqualizerSSE::enabled(long _newValue)
{
	 _cache?static_cast<Noatun::EqualizerSSE_base*>(_cache)->enabled(_newValue):static_cast<Noatun::EqualizerSSE_base*>(_method_call())->enabled(_newValue);
}

inline float Noatun::EqualizerSSE::preamp()
{
	return _cache?static_cast<Noatun::EqualizerSSE_base*>(_cache)->preamp():static_cast<Noatun::EqualizerSSE_base*>(_method_call())->preamp();
}

inline void Noatun::EqualizerSSE::preamp(float _newValue)
{
	 _cache?static_cast<Noatun::EqualizerSSE_base*>(_cache)->preamp(_newValue):static_cast<Noatun::EqualizerSSE_base*>(_method_call())->preamp(_newValue);
}

inline void Noatun::EqualizerSSE::set(const std::vector<float>& levels, const std::vector<float>& centers, const std::vector<float>& widths)
{
	 _cache?static_cast<Noatun::EqualizerSSE_base*>(_cache)->set(levels, centers, widths):static_cast<Noatun::EqualizerSSE_base*>(_method_call())->set(levels, centers, widths);
}

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

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

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

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

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

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

inline float Noatun::FFTScope::bandResolution()
{
	return _cache?static_cast<Noatun::FFTScope_base*>(_cache)->bandResolution():static_cast<Noatun::FFTScope_base*>(_method_call())->bandResolution();
}

inline void Noatun::FFTScope::bandResolution(float _newValue)
{
	 _cache?static_cast<Noatun::FFTScope_base*>(_cache)->bandResolution(_newValue):static_cast<Noatun::FFTScope_base*>(_method_call())->bandResolution(_newValue);
}

inline std::vector<float> * Noatun::FFTScope::scope()
{
	return _cache?static_cast<Noatun::FFTScope_base*>(_cache)->scope():static_cast<Noatun::FFTScope_base*>(_method_call())->scope();
}

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

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

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

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

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

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

inline float Noatun::FFTScopeStereo::bandResolution()
{
	return _cache?static_cast<Noatun::FFTScopeStereo_base*>(_cache)->bandResolution():static_cast<Noatun::FFTScopeStereo_base*>(_method_call())->bandResolution();
}

inline void Noatun::FFTScopeStereo::bandResolution(float _newValue)
{
	 _cache?static_cast<Noatun::FFTScopeStereo_base*>(_cache)->bandResolution(_newValue):static_cast<Noatun::FFTScopeStereo_base*>(_method_call())->bandResolution(_newValue);
}

inline std::vector<float> * Noatun::FFTScopeStereo::scopeRight()
{
	return _cache?static_cast<Noatun::FFTScopeStereo_base*>(_cache)->scopeRight():static_cast<Noatun::FFTScopeStereo_base*>(_method_call())->scopeRight();
}

inline std::vector<float> * Noatun::FFTScopeStereo::scopeLeft()
{
	return _cache?static_cast<Noatun::FFTScopeStereo_base*>(_cache)->scopeLeft():static_cast<Noatun::FFTScopeStereo_base*>(_method_call())->scopeLeft();
}

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

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

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

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

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

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

inline long Noatun::RawScope::buffer()
{
	return _cache?static_cast<Noatun::RawScope_base*>(_cache)->buffer():static_cast<Noatun::RawScope_base*>(_method_call())->buffer();
}

inline void Noatun::RawScope::buffer(long _newValue)
{
	 _cache?static_cast<Noatun::RawScope_base*>(_cache)->buffer(_newValue):static_cast<Noatun::RawScope_base*>(_method_call())->buffer(_newValue);
}

inline std::vector<float> * Noatun::RawScope::scope()
{
	return _cache?static_cast<Noatun::RawScope_base*>(_cache)->scope():static_cast<Noatun::RawScope_base*>(_method_call())->scope();
}

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

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

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

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

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

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

inline long Noatun::RawScopeStereo::buffer()
{
	return _cache?static_cast<Noatun::RawScopeStereo_base*>(_cache)->buffer():static_cast<Noatun::RawScopeStereo_base*>(_method_call())->buffer();
}

inline void Noatun::RawScopeStereo::buffer(long _newValue)
{
	 _cache?static_cast<Noatun::RawScopeStereo_base*>(_cache)->buffer(_newValue):static_cast<Noatun::RawScopeStereo_base*>(_method_call())->buffer(_newValue);
}

inline std::vector<float> * Noatun::RawScopeStereo::scopeLeft()
{
	return _cache?static_cast<Noatun::RawScopeStereo_base*>(_cache)->scopeLeft():static_cast<Noatun::RawScopeStereo_base*>(_method_call())->scopeLeft();
}

inline std::vector<float> * Noatun::RawScopeStereo::scopeRight()
{
	return _cache?static_cast<Noatun::RawScopeStereo_base*>(_cache)->scopeRight():static_cast<Noatun::RawScopeStereo_base*>(_method_call())->scopeRight();
}

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

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

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

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

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

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

inline long Noatun::StereoEffectStack::insertAfter(long after, Arts::StereoEffect effect, const std::string& name)
{
	return _cache?static_cast<Noatun::StereoEffectStack_base*>(_cache)->insertAfter(after, effect, name):static_cast<Noatun::StereoEffectStack_base*>(_method_call())->insertAfter(after, effect, name);
}

inline void Noatun::StereoEffectStack::move(long after, long item)
{
	 _cache?static_cast<Noatun::StereoEffectStack_base*>(_cache)->move(after, item):static_cast<Noatun::StereoEffectStack_base*>(_method_call())->move(after, item);
}

inline std::vector<long> * Noatun::StereoEffectStack::effectList()
{
	return _cache?static_cast<Noatun::StereoEffectStack_base*>(_cache)->effectList():static_cast<Noatun::StereoEffectStack_base*>(_method_call())->effectList();
}

inline long Noatun::StereoEffectStack::insertTop(Arts::StereoEffect effect, const std::string& name)
{
	return _cache?static_cast<Noatun::StereoEffectStack_base*>(_cache)->insertTop(effect, name):static_cast<Noatun::StereoEffectStack_base*>(_method_call())->insertTop(effect, name);
}

inline long Noatun::StereoEffectStack::insertBottom(Arts::StereoEffect effect, const std::string& name)
{
	return _cache?static_cast<Noatun::StereoEffectStack_base*>(_cache)->insertBottom(effect, name):static_cast<Noatun::StereoEffectStack_base*>(_method_call())->insertBottom(effect, name);
}

inline void Noatun::StereoEffectStack::remove(long ID)
{
	 _cache?static_cast<Noatun::StereoEffectStack_base*>(_cache)->remove(ID):static_cast<Noatun::StereoEffectStack_base*>(_method_call())->remove(ID);
}

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

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

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

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

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

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

inline float Noatun::StereoVolumeControl::percent()
{
	return _cache?static_cast<Noatun::StereoVolumeControl_base*>(_cache)->percent():static_cast<Noatun::StereoVolumeControl_base*>(_method_call())->percent();
}

inline void Noatun::StereoVolumeControl::percent(float _newValue)
{
	 _cache?static_cast<Noatun::StereoVolumeControl_base*>(_cache)->percent(_newValue):static_cast<Noatun::StereoVolumeControl_base*>(_method_call())->percent(_newValue);
}

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

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

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

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

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

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

inline float Noatun::StereoVolumeControlSSE::percent()
{
	return _cache?static_cast<Noatun::StereoVolumeControlSSE_base*>(_cache)->percent():static_cast<Noatun::StereoVolumeControlSSE_base*>(_method_call())->percent();
}

inline void Noatun::StereoVolumeControlSSE::percent(float _newValue)
{
	 _cache?static_cast<Noatun::StereoVolumeControlSSE_base*>(_cache)->percent(_newValue):static_cast<Noatun::StereoVolumeControlSSE_base*>(_method_call())->percent(_newValue);
}

inline void Noatun::Listener::message()
{
	 _cache?static_cast<Noatun::Listener_base*>(_cache)->message():static_cast<Noatun::Listener_base*>(_method_call())->message();
}

inline long Noatun::Session::pid()
{
	return _cache?static_cast<Noatun::Session_base*>(_cache)->pid():static_cast<Noatun::Session_base*>(_method_call())->pid();
}

inline void Noatun::Session::pid(long _newValue)
{
	 _cache?static_cast<Noatun::Session_base*>(_cache)->pid(_newValue):static_cast<Noatun::Session_base*>(_method_call())->pid(_newValue);
}

inline void Noatun::Session::addListener(Noatun::Listener listener)
{
	 _cache?static_cast<Noatun::Session_base*>(_cache)->addListener(listener):static_cast<Noatun::Session_base*>(_method_call())->addListener(listener);
}

inline void Noatun::Session::removeListener(Noatun::Listener listener)
{
	 _cache?static_cast<Noatun::Session_base*>(_cache)->removeListener(listener):static_cast<Noatun::Session_base*>(_method_call())->removeListener(listener);
}

#endif /* NOATUNARTS_H */
