
/*
 *	This file was automatically generated by dbusxx-xml2cpp; DO NOT EDIT!
 */

#ifndef __dbusxx__support_dbus_controlserver_glue_h__ADAPTOR_MARSHAL_H
#define __dbusxx__support_dbus_controlserver_glue_h__ADAPTOR_MARSHAL_H

#include <dbus-c++/dbus.h>
#include <cassert>

namespace org {
namespace ffado {
namespace Control {
namespace Element {

class Element_adaptor
: public ::DBus::InterfaceAdaptor
{
public:

    Element_adaptor()
    : ::DBus::InterfaceAdaptor("org.ffado.Control.Element.Element")
    {
        register_method(Element_adaptor, getId, _getId_stub);
        register_method(Element_adaptor, getName, _getName_stub);
        register_method(Element_adaptor, getLabel, _getLabel_stub);
        register_method(Element_adaptor, getDescription, _getDescription_stub);
        register_method(Element_adaptor, canChangeValue, _canChangeValue_stub);
        register_method(Element_adaptor, getVerboseLevel, _getVerboseLevel_stub);
        register_method(Element_adaptor, setVerboseLevel, _setVerboseLevel_stub);
    }

    ::DBus::IntrospectedInterface *introspect() const 
    {
        static ::DBus::IntrospectedArgument getId_args[] = 
        {
            { "id", "t", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument getName_args[] = 
        {
            { "name", "s", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument getLabel_args[] = 
        {
            { "label", "s", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument getDescription_args[] = 
        {
            { "description", "s", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument canChangeValue_args[] = 
        {
            { "can_change", "b", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument getVerboseLevel_args[] = 
        {
            { "level", "i", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument setVerboseLevel_args[] = 
        {
            { "level", "i", true },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedMethod Element_adaptor_methods[] = 
        {
            { "getId", getId_args },
            { "getName", getName_args },
            { "getLabel", getLabel_args },
            { "getDescription", getDescription_args },
            { "canChangeValue", canChangeValue_args },
            { "getVerboseLevel", getVerboseLevel_args },
            { "setVerboseLevel", setVerboseLevel_args },
            { 0, 0 }
        };
        static ::DBus::IntrospectedMethod Element_adaptor_signals[] = 
        {
            { 0, 0 }
        };
        static ::DBus::IntrospectedProperty Element_adaptor_properties[] = 
        {
            { 0, 0, 0, 0 }
        };
        static ::DBus::IntrospectedInterface Element_adaptor_interface = 
        {
            "org.ffado.Control.Element.Element",
            Element_adaptor_methods,
            Element_adaptor_signals,
            Element_adaptor_properties
        };
        return &Element_adaptor_interface;
    }

public:

    /* properties exposed by this interface, use
     * property() and property(value) to get and set a particular property
     */

public:

    /* methods exported by this interface,
     * you will have to implement them in your ObjectAdaptor
     */
    virtual uint64_t getId() = 0;
    virtual std::string getName() = 0;
    virtual std::string getLabel() = 0;
    virtual std::string getDescription() = 0;
    virtual bool canChangeValue() = 0;
    virtual int32_t getVerboseLevel() = 0;
    virtual void setVerboseLevel(const int32_t& level) = 0;

public:

    /* signal emitters for this interface
     */

private:

    /* unmarshalers (to unpack the DBus message before calling the actual interface method)
     */
    ::DBus::Message _getId_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        uint64_t argout1 = getId();
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
    ::DBus::Message _getName_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        std::string argout1 = getName();
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
    ::DBus::Message _getLabel_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        std::string argout1 = getLabel();
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
    ::DBus::Message _getDescription_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        std::string argout1 = getDescription();
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
    ::DBus::Message _canChangeValue_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        bool argout1 = canChangeValue();
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
    ::DBus::Message _getVerboseLevel_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        int32_t argout1 = getVerboseLevel();
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
    ::DBus::Message _setVerboseLevel_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        int32_t argin1; ri >> argin1;
        setVerboseLevel(argin1);
        ::DBus::ReturnMessage reply(call);
        return reply;
    }
};

} } } } 
namespace org {
namespace ffado {
namespace Control {
namespace Element {

class Container_adaptor
: public ::DBus::InterfaceAdaptor
{
public:

    Container_adaptor()
    : ::DBus::InterfaceAdaptor("org.ffado.Control.Element.Container")
    {
        register_method(Container_adaptor, getNbElements, _getNbElements_stub);
        register_method(Container_adaptor, getElementName, _getElementName_stub);
    }

    ::DBus::IntrospectedInterface *introspect() const 
    {
        static ::DBus::IntrospectedArgument getNbElements_args[] = 
        {
            { "count", "i", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument getElementName_args[] = 
        {
            { "id", "i", true },
            { "name", "s", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument Destroyed_args[] = 
        {
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument Updated_args[] = 
        {
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument PreUpdate_args[] = 
        {
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument PostUpdate_args[] = 
        {
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedMethod Container_adaptor_methods[] = 
        {
            { "getNbElements", getNbElements_args },
            { "getElementName", getElementName_args },
            { 0, 0 }
        };
        static ::DBus::IntrospectedMethod Container_adaptor_signals[] = 
        {
            { "Destroyed", Destroyed_args },
            { "Updated", Updated_args },
            { "PreUpdate", PreUpdate_args },
            { "PostUpdate", PostUpdate_args },
            { 0, 0 }
        };
        static ::DBus::IntrospectedProperty Container_adaptor_properties[] = 
        {
            { 0, 0, 0, 0 }
        };
        static ::DBus::IntrospectedInterface Container_adaptor_interface = 
        {
            "org.ffado.Control.Element.Container",
            Container_adaptor_methods,
            Container_adaptor_signals,
            Container_adaptor_properties
        };
        return &Container_adaptor_interface;
    }

public:

    /* properties exposed by this interface, use
     * property() and property(value) to get and set a particular property
     */

public:

    /* methods exported by this interface,
     * you will have to implement them in your ObjectAdaptor
     */
    virtual int32_t getNbElements() = 0;
    virtual std::string getElementName(const int32_t& id) = 0;

public:

    /* signal emitters for this interface
     */
    void Destroyed()
    {
        ::DBus::SignalMessage sig("Destroyed");
        emit_signal(sig);
    }
    void Updated()
    {
        ::DBus::SignalMessage sig("Updated");
        emit_signal(sig);
    }
    void PreUpdate()
    {
        ::DBus::SignalMessage sig("PreUpdate");
        emit_signal(sig);
    }
    void PostUpdate()
    {
        ::DBus::SignalMessage sig("PostUpdate");
        emit_signal(sig);
    }

private:

    /* unmarshalers (to unpack the DBus message before calling the actual interface method)
     */
    ::DBus::Message _getNbElements_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        int32_t argout1 = getNbElements();
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
    ::DBus::Message _getElementName_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        int32_t argin1; ri >> argin1;
        std::string argout1 = getElementName(argin1);
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
};

} } } } 
namespace org {
namespace ffado {
namespace Control {
namespace Element {

class ConfigRomX_adaptor
: public ::DBus::InterfaceAdaptor
{
public:

    ConfigRomX_adaptor()
    : ::DBus::InterfaceAdaptor("org.ffado.Control.Element.ConfigRomX")
    {
        register_method(ConfigRomX_adaptor, getGUID, _getGUID_stub);
        register_method(ConfigRomX_adaptor, getVendorName, _getVendorName_stub);
        register_method(ConfigRomX_adaptor, getModelName, _getModelName_stub);
        register_method(ConfigRomX_adaptor, getVendorId, _getVendorId_stub);
        register_method(ConfigRomX_adaptor, getModelId, _getModelId_stub);
        register_method(ConfigRomX_adaptor, getUnitVersion, _getUnitVersion_stub);
    }

    ::DBus::IntrospectedInterface *introspect() const 
    {
        static ::DBus::IntrospectedArgument getGUID_args[] = 
        {
            { "guid", "s", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument getVendorName_args[] = 
        {
            { "vendorname", "s", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument getModelName_args[] = 
        {
            { "modelname", "s", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument getVendorId_args[] = 
        {
            { "vendorid", "i", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument getModelId_args[] = 
        {
            { "modelid", "i", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument getUnitVersion_args[] = 
        {
            { "unitversion", "i", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedMethod ConfigRomX_adaptor_methods[] = 
        {
            { "getGUID", getGUID_args },
            { "getVendorName", getVendorName_args },
            { "getModelName", getModelName_args },
            { "getVendorId", getVendorId_args },
            { "getModelId", getModelId_args },
            { "getUnitVersion", getUnitVersion_args },
            { 0, 0 }
        };
        static ::DBus::IntrospectedMethod ConfigRomX_adaptor_signals[] = 
        {
            { 0, 0 }
        };
        static ::DBus::IntrospectedProperty ConfigRomX_adaptor_properties[] = 
        {
            { 0, 0, 0, 0 }
        };
        static ::DBus::IntrospectedInterface ConfigRomX_adaptor_interface = 
        {
            "org.ffado.Control.Element.ConfigRomX",
            ConfigRomX_adaptor_methods,
            ConfigRomX_adaptor_signals,
            ConfigRomX_adaptor_properties
        };
        return &ConfigRomX_adaptor_interface;
    }

public:

    /* properties exposed by this interface, use
     * property() and property(value) to get and set a particular property
     */

public:

    /* methods exported by this interface,
     * you will have to implement them in your ObjectAdaptor
     */
    virtual std::string getGUID() = 0;
    virtual std::string getVendorName() = 0;
    virtual std::string getModelName() = 0;
    virtual int32_t getVendorId() = 0;
    virtual int32_t getModelId() = 0;
    virtual int32_t getUnitVersion() = 0;

public:

    /* signal emitters for this interface
     */

private:

    /* unmarshalers (to unpack the DBus message before calling the actual interface method)
     */
    ::DBus::Message _getGUID_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        std::string argout1 = getGUID();
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
    ::DBus::Message _getVendorName_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        std::string argout1 = getVendorName();
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
    ::DBus::Message _getModelName_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        std::string argout1 = getModelName();
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
    ::DBus::Message _getVendorId_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        int32_t argout1 = getVendorId();
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
    ::DBus::Message _getModelId_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        int32_t argout1 = getModelId();
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
    ::DBus::Message _getUnitVersion_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        int32_t argout1 = getUnitVersion();
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
};

} } } } 
namespace org {
namespace ffado {
namespace Control {
namespace Element {

class Continuous_adaptor
: public ::DBus::InterfaceAdaptor
{
public:

    Continuous_adaptor()
    : ::DBus::InterfaceAdaptor("org.ffado.Control.Element.Continuous")
    {
        register_method(Continuous_adaptor, setValue, _setValue_stub);
        register_method(Continuous_adaptor, getValue, _getValue_stub);
        register_method(Continuous_adaptor, getMinimum, _getMinimum_stub);
        register_method(Continuous_adaptor, getMaximum, _getMaximum_stub);
        register_method(Continuous_adaptor, setValueIdx, _setValueIdx_stub);
        register_method(Continuous_adaptor, getValueIdx, _getValueIdx_stub);
    }

    ::DBus::IntrospectedInterface *introspect() const 
    {
        static ::DBus::IntrospectedArgument setValue_args[] = 
        {
            { "value", "d", true },
            { "value", "d", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument getValue_args[] = 
        {
            { "value", "d", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument getMinimum_args[] = 
        {
            { "value", "d", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument getMaximum_args[] = 
        {
            { "value", "d", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument setValueIdx_args[] = 
        {
            { "idx", "i", true },
            { "value", "d", true },
            { "value", "d", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument getValueIdx_args[] = 
        {
            { "idx", "i", true },
            { "value", "d", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedMethod Continuous_adaptor_methods[] = 
        {
            { "setValue", setValue_args },
            { "getValue", getValue_args },
            { "getMinimum", getMinimum_args },
            { "getMaximum", getMaximum_args },
            { "setValueIdx", setValueIdx_args },
            { "getValueIdx", getValueIdx_args },
            { 0, 0 }
        };
        static ::DBus::IntrospectedMethod Continuous_adaptor_signals[] = 
        {
            { 0, 0 }
        };
        static ::DBus::IntrospectedProperty Continuous_adaptor_properties[] = 
        {
            { 0, 0, 0, 0 }
        };
        static ::DBus::IntrospectedInterface Continuous_adaptor_interface = 
        {
            "org.ffado.Control.Element.Continuous",
            Continuous_adaptor_methods,
            Continuous_adaptor_signals,
            Continuous_adaptor_properties
        };
        return &Continuous_adaptor_interface;
    }

public:

    /* properties exposed by this interface, use
     * property() and property(value) to get and set a particular property
     */

public:

    /* methods exported by this interface,
     * you will have to implement them in your ObjectAdaptor
     */
    virtual double setValue(const double& value) = 0;
    virtual double getValue() = 0;
    virtual double getMinimum() = 0;
    virtual double getMaximum() = 0;
    virtual double setValueIdx(const int32_t& idx, const double& value) = 0;
    virtual double getValueIdx(const int32_t& idx) = 0;

public:

    /* signal emitters for this interface
     */

private:

    /* unmarshalers (to unpack the DBus message before calling the actual interface method)
     */
    ::DBus::Message _setValue_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        double argin1; ri >> argin1;
        double argout1 = setValue(argin1);
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
    ::DBus::Message _getValue_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        double argout1 = getValue();
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
    ::DBus::Message _getMinimum_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        double argout1 = getMinimum();
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
    ::DBus::Message _getMaximum_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        double argout1 = getMaximum();
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
    ::DBus::Message _setValueIdx_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        int32_t argin1; ri >> argin1;
        double argin2; ri >> argin2;
        double argout1 = setValueIdx(argin1, argin2);
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
    ::DBus::Message _getValueIdx_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        int32_t argin1; ri >> argin1;
        double argout1 = getValueIdx(argin1);
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
};

} } } } 
namespace org {
namespace ffado {
namespace Control {
namespace Element {

class Discrete_adaptor
: public ::DBus::InterfaceAdaptor
{
public:

    Discrete_adaptor()
    : ::DBus::InterfaceAdaptor("org.ffado.Control.Element.Discrete")
    {
        register_method(Discrete_adaptor, setValue, _setValue_stub);
        register_method(Discrete_adaptor, getValue, _getValue_stub);
        register_method(Discrete_adaptor, setValueIdx, _setValueIdx_stub);
        register_method(Discrete_adaptor, getValueIdx, _getValueIdx_stub);
    }

    ::DBus::IntrospectedInterface *introspect() const 
    {
        static ::DBus::IntrospectedArgument setValue_args[] = 
        {
            { "value", "i", true },
            { "value", "i", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument getValue_args[] = 
        {
            { "value", "i", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument setValueIdx_args[] = 
        {
            { "idx", "i", true },
            { "value", "i", true },
            { "value", "i", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument getValueIdx_args[] = 
        {
            { "idx", "i", true },
            { "value", "i", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedMethod Discrete_adaptor_methods[] = 
        {
            { "setValue", setValue_args },
            { "getValue", getValue_args },
            { "setValueIdx", setValueIdx_args },
            { "getValueIdx", getValueIdx_args },
            { 0, 0 }
        };
        static ::DBus::IntrospectedMethod Discrete_adaptor_signals[] = 
        {
            { 0, 0 }
        };
        static ::DBus::IntrospectedProperty Discrete_adaptor_properties[] = 
        {
            { 0, 0, 0, 0 }
        };
        static ::DBus::IntrospectedInterface Discrete_adaptor_interface = 
        {
            "org.ffado.Control.Element.Discrete",
            Discrete_adaptor_methods,
            Discrete_adaptor_signals,
            Discrete_adaptor_properties
        };
        return &Discrete_adaptor_interface;
    }

public:

    /* properties exposed by this interface, use
     * property() and property(value) to get and set a particular property
     */

public:

    /* methods exported by this interface,
     * you will have to implement them in your ObjectAdaptor
     */
    virtual int32_t setValue(const int32_t& value) = 0;
    virtual int32_t getValue() = 0;
    virtual int32_t setValueIdx(const int32_t& idx, const int32_t& value) = 0;
    virtual int32_t getValueIdx(const int32_t& idx) = 0;

public:

    /* signal emitters for this interface
     */

private:

    /* unmarshalers (to unpack the DBus message before calling the actual interface method)
     */
    ::DBus::Message _setValue_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        int32_t argin1; ri >> argin1;
        int32_t argout1 = setValue(argin1);
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
    ::DBus::Message _getValue_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        int32_t argout1 = getValue();
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
    ::DBus::Message _setValueIdx_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        int32_t argin1; ri >> argin1;
        int32_t argin2; ri >> argin2;
        int32_t argout1 = setValueIdx(argin1, argin2);
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
    ::DBus::Message _getValueIdx_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        int32_t argin1; ri >> argin1;
        int32_t argout1 = getValueIdx(argin1);
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
};

} } } } 
namespace org {
namespace ffado {
namespace Control {
namespace Element {

class Text_adaptor
: public ::DBus::InterfaceAdaptor
{
public:

    Text_adaptor()
    : ::DBus::InterfaceAdaptor("org.ffado.Control.Element.Text")
    {
        register_method(Text_adaptor, setValue, _setValue_stub);
        register_method(Text_adaptor, getValue, _getValue_stub);
    }

    ::DBus::IntrospectedInterface *introspect() const 
    {
        static ::DBus::IntrospectedArgument setValue_args[] = 
        {
            { "value", "s", true },
            { "value", "s", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument getValue_args[] = 
        {
            { "value", "s", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedMethod Text_adaptor_methods[] = 
        {
            { "setValue", setValue_args },
            { "getValue", getValue_args },
            { 0, 0 }
        };
        static ::DBus::IntrospectedMethod Text_adaptor_signals[] = 
        {
            { 0, 0 }
        };
        static ::DBus::IntrospectedProperty Text_adaptor_properties[] = 
        {
            { 0, 0, 0, 0 }
        };
        static ::DBus::IntrospectedInterface Text_adaptor_interface = 
        {
            "org.ffado.Control.Element.Text",
            Text_adaptor_methods,
            Text_adaptor_signals,
            Text_adaptor_properties
        };
        return &Text_adaptor_interface;
    }

public:

    /* properties exposed by this interface, use
     * property() and property(value) to get and set a particular property
     */

public:

    /* methods exported by this interface,
     * you will have to implement them in your ObjectAdaptor
     */
    virtual std::string setValue(const std::string& value) = 0;
    virtual std::string getValue() = 0;

public:

    /* signal emitters for this interface
     */

private:

    /* unmarshalers (to unpack the DBus message before calling the actual interface method)
     */
    ::DBus::Message _setValue_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        std::string argin1; ri >> argin1;
        std::string argout1 = setValue(argin1);
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
    ::DBus::Message _getValue_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        std::string argout1 = getValue();
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
};

} } } } 
namespace org {
namespace ffado {
namespace Control {
namespace Element {

class Register_adaptor
: public ::DBus::InterfaceAdaptor
{
public:

    Register_adaptor()
    : ::DBus::InterfaceAdaptor("org.ffado.Control.Element.Register")
    {
        register_method(Register_adaptor, setValue, _setValue_stub);
        register_method(Register_adaptor, getValue, _getValue_stub);
    }

    ::DBus::IntrospectedInterface *introspect() const 
    {
        static ::DBus::IntrospectedArgument setValue_args[] = 
        {
            { "address", "t", true },
            { "value", "t", true },
            { "value", "t", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument getValue_args[] = 
        {
            { "address", "t", true },
            { "value", "t", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedMethod Register_adaptor_methods[] = 
        {
            { "setValue", setValue_args },
            { "getValue", getValue_args },
            { 0, 0 }
        };
        static ::DBus::IntrospectedMethod Register_adaptor_signals[] = 
        {
            { 0, 0 }
        };
        static ::DBus::IntrospectedProperty Register_adaptor_properties[] = 
        {
            { 0, 0, 0, 0 }
        };
        static ::DBus::IntrospectedInterface Register_adaptor_interface = 
        {
            "org.ffado.Control.Element.Register",
            Register_adaptor_methods,
            Register_adaptor_signals,
            Register_adaptor_properties
        };
        return &Register_adaptor_interface;
    }

public:

    /* properties exposed by this interface, use
     * property() and property(value) to get and set a particular property
     */

public:

    /* methods exported by this interface,
     * you will have to implement them in your ObjectAdaptor
     */
    virtual uint64_t setValue(const uint64_t& address, const uint64_t& value) = 0;
    virtual uint64_t getValue(const uint64_t& address) = 0;

public:

    /* signal emitters for this interface
     */

private:

    /* unmarshalers (to unpack the DBus message before calling the actual interface method)
     */
    ::DBus::Message _setValue_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        uint64_t argin1; ri >> argin1;
        uint64_t argin2; ri >> argin2;
        uint64_t argout1 = setValue(argin1, argin2);
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
    ::DBus::Message _getValue_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        uint64_t argin1; ri >> argin1;
        uint64_t argout1 = getValue(argin1);
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
};

} } } } 
namespace org {
namespace ffado {
namespace Control {
namespace Element {

class Enum_adaptor
: public ::DBus::InterfaceAdaptor
{
public:

    Enum_adaptor()
    : ::DBus::InterfaceAdaptor("org.ffado.Control.Element.Enum")
    {
        register_method(Enum_adaptor, select, _select_stub);
        register_method(Enum_adaptor, selected, _selected_stub);
        register_method(Enum_adaptor, count, _count_stub);
        register_method(Enum_adaptor, getEnumLabel, _getEnumLabel_stub);
        register_method(Enum_adaptor, devConfigChanged, _devConfigChanged_stub);
    }

    ::DBus::IntrospectedInterface *introspect() const 
    {
        static ::DBus::IntrospectedArgument select_args[] = 
        {
            { "idx", "i", true },
            { "success", "i", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument selected_args[] = 
        {
            { "idx", "i", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument count_args[] = 
        {
            { "count", "i", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument getEnumLabel_args[] = 
        {
            { "idx", "i", true },
            { "label", "s", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument devConfigChanged_args[] = 
        {
            { "id", "i", true },
            { "update", "b", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedMethod Enum_adaptor_methods[] = 
        {
            { "select", select_args },
            { "selected", selected_args },
            { "count", count_args },
            { "getEnumLabel", getEnumLabel_args },
            { "devConfigChanged", devConfigChanged_args },
            { 0, 0 }
        };
        static ::DBus::IntrospectedMethod Enum_adaptor_signals[] = 
        {
            { 0, 0 }
        };
        static ::DBus::IntrospectedProperty Enum_adaptor_properties[] = 
        {
            { 0, 0, 0, 0 }
        };
        static ::DBus::IntrospectedInterface Enum_adaptor_interface = 
        {
            "org.ffado.Control.Element.Enum",
            Enum_adaptor_methods,
            Enum_adaptor_signals,
            Enum_adaptor_properties
        };
        return &Enum_adaptor_interface;
    }

public:

    /* properties exposed by this interface, use
     * property() and property(value) to get and set a particular property
     */

public:

    /* methods exported by this interface,
     * you will have to implement them in your ObjectAdaptor
     */
    virtual int32_t select(const int32_t& idx) = 0;
    virtual int32_t selected() = 0;
    virtual int32_t count() = 0;
    virtual std::string getEnumLabel(const int32_t& idx) = 0;
    virtual bool devConfigChanged(const int32_t& id) = 0;

public:

    /* signal emitters for this interface
     */

private:

    /* unmarshalers (to unpack the DBus message before calling the actual interface method)
     */
    ::DBus::Message _select_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        int32_t argin1; ri >> argin1;
        int32_t argout1 = select(argin1);
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
    ::DBus::Message _selected_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        int32_t argout1 = selected();
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
    ::DBus::Message _count_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        int32_t argout1 = count();
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
    ::DBus::Message _getEnumLabel_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        int32_t argin1; ri >> argin1;
        std::string argout1 = getEnumLabel(argin1);
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
    ::DBus::Message _devConfigChanged_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        int32_t argin1; ri >> argin1;
        bool argout1 = devConfigChanged(argin1);
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
};

} } } } 
namespace org {
namespace ffado {
namespace Control {
namespace Element {

class AttributeEnum_adaptor
: public ::DBus::InterfaceAdaptor
{
public:

    AttributeEnum_adaptor()
    : ::DBus::InterfaceAdaptor("org.ffado.Control.Element.AttributeEnum")
    {
        register_method(AttributeEnum_adaptor, select, _select_stub);
        register_method(AttributeEnum_adaptor, selected, _selected_stub);
        register_method(AttributeEnum_adaptor, count, _count_stub);
        register_method(AttributeEnum_adaptor, attributeCount, _attributeCount_stub);
        register_method(AttributeEnum_adaptor, getEnumLabel, _getEnumLabel_stub);
        register_method(AttributeEnum_adaptor, getAttributeValue, _getAttributeValue_stub);
        register_method(AttributeEnum_adaptor, getAttributeName, _getAttributeName_stub);
    }

    ::DBus::IntrospectedInterface *introspect() const 
    {
        static ::DBus::IntrospectedArgument select_args[] = 
        {
            { "idx", "i", true },
            { "success", "i", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument selected_args[] = 
        {
            { "idx", "i", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument count_args[] = 
        {
            { "count", "i", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument attributeCount_args[] = 
        {
            { "count", "i", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument getEnumLabel_args[] = 
        {
            { "idx", "i", true },
            { "label", "s", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument getAttributeValue_args[] = 
        {
            { "idx", "i", true },
            { "value", "s", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument getAttributeName_args[] = 
        {
            { "idx", "i", true },
            { "name", "s", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedMethod AttributeEnum_adaptor_methods[] = 
        {
            { "select", select_args },
            { "selected", selected_args },
            { "count", count_args },
            { "attributeCount", attributeCount_args },
            { "getEnumLabel", getEnumLabel_args },
            { "getAttributeValue", getAttributeValue_args },
            { "getAttributeName", getAttributeName_args },
            { 0, 0 }
        };
        static ::DBus::IntrospectedMethod AttributeEnum_adaptor_signals[] = 
        {
            { 0, 0 }
        };
        static ::DBus::IntrospectedProperty AttributeEnum_adaptor_properties[] = 
        {
            { 0, 0, 0, 0 }
        };
        static ::DBus::IntrospectedInterface AttributeEnum_adaptor_interface = 
        {
            "org.ffado.Control.Element.AttributeEnum",
            AttributeEnum_adaptor_methods,
            AttributeEnum_adaptor_signals,
            AttributeEnum_adaptor_properties
        };
        return &AttributeEnum_adaptor_interface;
    }

public:

    /* properties exposed by this interface, use
     * property() and property(value) to get and set a particular property
     */

public:

    /* methods exported by this interface,
     * you will have to implement them in your ObjectAdaptor
     */
    virtual int32_t select(const int32_t& idx) = 0;
    virtual int32_t selected() = 0;
    virtual int32_t count() = 0;
    virtual int32_t attributeCount() = 0;
    virtual std::string getEnumLabel(const int32_t& idx) = 0;
    virtual std::string getAttributeValue(const int32_t& idx) = 0;
    virtual std::string getAttributeName(const int32_t& idx) = 0;

public:

    /* signal emitters for this interface
     */

private:

    /* unmarshalers (to unpack the DBus message before calling the actual interface method)
     */
    ::DBus::Message _select_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        int32_t argin1; ri >> argin1;
        int32_t argout1 = select(argin1);
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
    ::DBus::Message _selected_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        int32_t argout1 = selected();
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
    ::DBus::Message _count_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        int32_t argout1 = count();
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
    ::DBus::Message _attributeCount_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        int32_t argout1 = attributeCount();
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
    ::DBus::Message _getEnumLabel_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        int32_t argin1; ri >> argin1;
        std::string argout1 = getEnumLabel(argin1);
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
    ::DBus::Message _getAttributeValue_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        int32_t argin1; ri >> argin1;
        std::string argout1 = getAttributeValue(argin1);
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
    ::DBus::Message _getAttributeName_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        int32_t argin1; ri >> argin1;
        std::string argout1 = getAttributeName(argin1);
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
};

} } } } 
namespace org {
namespace ffado {
namespace Control {
namespace Element {

class MatrixMixer_adaptor
: public ::DBus::InterfaceAdaptor
{
public:

    MatrixMixer_adaptor()
    : ::DBus::InterfaceAdaptor("org.ffado.Control.Element.MatrixMixer")
    {
        register_method(MatrixMixer_adaptor, setValue, _setValue_stub);
        register_method(MatrixMixer_adaptor, getValue, _getValue_stub);
        register_method(MatrixMixer_adaptor, canWrite, _canWrite_stub);
        register_method(MatrixMixer_adaptor, getRowCount, _getRowCount_stub);
        register_method(MatrixMixer_adaptor, getColCount, _getColCount_stub);
        register_method(MatrixMixer_adaptor, hasNames, _hasNames_stub);
        register_method(MatrixMixer_adaptor, getRowName, _getRowName_stub);
        register_method(MatrixMixer_adaptor, getColName, _getColName_stub);
        register_method(MatrixMixer_adaptor, setRowName, _setRowName_stub);
        register_method(MatrixMixer_adaptor, setColName, _setColName_stub);
        register_method(MatrixMixer_adaptor, canConnect, _canConnect_stub);
        register_method(MatrixMixer_adaptor, availableConnectionsForRow, _availableConnectionsForRow_stub);
        register_method(MatrixMixer_adaptor, availableConnectionsForCol, _availableConnectionsForCol_stub);
        register_method(MatrixMixer_adaptor, connectRowTo, _connectRowTo_stub);
        register_method(MatrixMixer_adaptor, connectColTo, _connectColTo_stub);
    }

    ::DBus::IntrospectedInterface *introspect() const 
    {
        static ::DBus::IntrospectedArgument setValue_args[] = 
        {
            { "row", "i", true },
            { "col", "i", true },
            { "value", "d", true },
            { "value", "d", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument getValue_args[] = 
        {
            { "row", "i", true },
            { "col", "i", true },
            { "value", "d", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument canWrite_args[] = 
        {
            { "row", "i", true },
            { "col", "i", true },
            { "value", "i", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument getRowCount_args[] = 
        {
            { "nbrows", "i", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument getColCount_args[] = 
        {
            { "nbrows", "i", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument hasNames_args[] = 
        {
            { "value", "b", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument getRowName_args[] = 
        {
            { "row", "i", true },
            { "rowname", "s", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument getColName_args[] = 
        {
            { "col", "i", true },
            { "colname", "s", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument setRowName_args[] = 
        {
            { "row", "i", true },
            { "rowname", "s", true },
            { "value", "b", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument setColName_args[] = 
        {
            { "col", "i", true },
            { "colname", "s", true },
            { "value", "b", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument canConnect_args[] = 
        {
            { "value", "b", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument availableConnectionsForRow_args[] = 
        {
            { "row", "i", true },
            { "value", "as", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument availableConnectionsForCol_args[] = 
        {
            { "col", "i", true },
            { "value", "as", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument connectRowTo_args[] = 
        {
            { "row", "i", true },
            { "target", "s", true },
            { "value", "b", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument connectColTo_args[] = 
        {
            { "col", "i", true },
            { "target", "s", true },
            { "value", "b", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedMethod MatrixMixer_adaptor_methods[] = 
        {
            { "setValue", setValue_args },
            { "getValue", getValue_args },
            { "canWrite", canWrite_args },
            { "getRowCount", getRowCount_args },
            { "getColCount", getColCount_args },
            { "hasNames", hasNames_args },
            { "getRowName", getRowName_args },
            { "getColName", getColName_args },
            { "setRowName", setRowName_args },
            { "setColName", setColName_args },
            { "canConnect", canConnect_args },
            { "availableConnectionsForRow", availableConnectionsForRow_args },
            { "availableConnectionsForCol", availableConnectionsForCol_args },
            { "connectRowTo", connectRowTo_args },
            { "connectColTo", connectColTo_args },
            { 0, 0 }
        };
        static ::DBus::IntrospectedMethod MatrixMixer_adaptor_signals[] = 
        {
            { 0, 0 }
        };
        static ::DBus::IntrospectedProperty MatrixMixer_adaptor_properties[] = 
        {
            { 0, 0, 0, 0 }
        };
        static ::DBus::IntrospectedInterface MatrixMixer_adaptor_interface = 
        {
            "org.ffado.Control.Element.MatrixMixer",
            MatrixMixer_adaptor_methods,
            MatrixMixer_adaptor_signals,
            MatrixMixer_adaptor_properties
        };
        return &MatrixMixer_adaptor_interface;
    }

public:

    /* properties exposed by this interface, use
     * property() and property(value) to get and set a particular property
     */

public:

    /* methods exported by this interface,
     * you will have to implement them in your ObjectAdaptor
     */
    virtual double setValue(const int32_t& row, const int32_t& col, const double& value) = 0;
    virtual double getValue(const int32_t& row, const int32_t& col) = 0;
    virtual int32_t canWrite(const int32_t& row, const int32_t& col) = 0;
    virtual int32_t getRowCount() = 0;
    virtual int32_t getColCount() = 0;
    virtual bool hasNames() = 0;
    virtual std::string getRowName(const int32_t& row) = 0;
    virtual std::string getColName(const int32_t& col) = 0;
    virtual bool setRowName(const int32_t& row, const std::string& rowname) = 0;
    virtual bool setColName(const int32_t& col, const std::string& colname) = 0;
    virtual bool canConnect() = 0;
    virtual std::vector< std::string > availableConnectionsForRow(const int32_t& row) = 0;
    virtual std::vector< std::string > availableConnectionsForCol(const int32_t& col) = 0;
    virtual bool connectRowTo(const int32_t& row, const std::string& target) = 0;
    virtual bool connectColTo(const int32_t& col, const std::string& target) = 0;

public:

    /* signal emitters for this interface
     */

private:

    /* unmarshalers (to unpack the DBus message before calling the actual interface method)
     */
    ::DBus::Message _setValue_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        int32_t argin1; ri >> argin1;
        int32_t argin2; ri >> argin2;
        double argin3; ri >> argin3;
        double argout1 = setValue(argin1, argin2, argin3);
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
    ::DBus::Message _getValue_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        int32_t argin1; ri >> argin1;
        int32_t argin2; ri >> argin2;
        double argout1 = getValue(argin1, argin2);
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
    ::DBus::Message _canWrite_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        int32_t argin1; ri >> argin1;
        int32_t argin2; ri >> argin2;
        int32_t argout1 = canWrite(argin1, argin2);
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
    ::DBus::Message _getRowCount_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        int32_t argout1 = getRowCount();
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
    ::DBus::Message _getColCount_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        int32_t argout1 = getColCount();
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
    ::DBus::Message _hasNames_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        bool argout1 = hasNames();
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
    ::DBus::Message _getRowName_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        int32_t argin1; ri >> argin1;
        std::string argout1 = getRowName(argin1);
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
    ::DBus::Message _getColName_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        int32_t argin1; ri >> argin1;
        std::string argout1 = getColName(argin1);
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
    ::DBus::Message _setRowName_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        int32_t argin1; ri >> argin1;
        std::string argin2; ri >> argin2;
        bool argout1 = setRowName(argin1, argin2);
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
    ::DBus::Message _setColName_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        int32_t argin1; ri >> argin1;
        std::string argin2; ri >> argin2;
        bool argout1 = setColName(argin1, argin2);
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
    ::DBus::Message _canConnect_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        bool argout1 = canConnect();
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
    ::DBus::Message _availableConnectionsForRow_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        int32_t argin1; ri >> argin1;
        std::vector< std::string > argout1 = availableConnectionsForRow(argin1);
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
    ::DBus::Message _availableConnectionsForCol_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        int32_t argin1; ri >> argin1;
        std::vector< std::string > argout1 = availableConnectionsForCol(argin1);
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
    ::DBus::Message _connectRowTo_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        int32_t argin1; ri >> argin1;
        std::string argin2; ri >> argin2;
        bool argout1 = connectRowTo(argin1, argin2);
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
    ::DBus::Message _connectColTo_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        int32_t argin1; ri >> argin1;
        std::string argin2; ri >> argin2;
        bool argout1 = connectColTo(argin1, argin2);
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
};

} } } } 
namespace org {
namespace ffado {
namespace Control {
namespace Element {

class CrossbarRouter_adaptor
: public ::DBus::InterfaceAdaptor
{
public:

    CrossbarRouter_adaptor()
    : ::DBus::InterfaceAdaptor("org.ffado.Control.Element.CrossbarRouter")
    {
        register_method(CrossbarRouter_adaptor, getSourceNames, _getSourceNames_stub);
        register_method(CrossbarRouter_adaptor, getDestinationNames, _getDestinationNames_stub);
        register_method(CrossbarRouter_adaptor, getSourceForDestination, _getSourceForDestination_stub);
        register_method(CrossbarRouter_adaptor, getDestinationsForSource, _getDestinationsForSource_stub);
        register_method(CrossbarRouter_adaptor, canConnect, _canConnect_stub);
        register_method(CrossbarRouter_adaptor, setConnectionState, _setConnectionState_stub);
        register_method(CrossbarRouter_adaptor, getConnectionState, _getConnectionState_stub);
        register_method(CrossbarRouter_adaptor, clearAllConnections, _clearAllConnections_stub);
        register_method(CrossbarRouter_adaptor, hasPeakMetering, _hasPeakMetering_stub);
        register_method(CrossbarRouter_adaptor, getPeakValue, _getPeakValue_stub);
        register_method(CrossbarRouter_adaptor, getPeakValues, _getPeakValues_stub);
    }

    ::DBus::IntrospectedInterface *introspect() const 
    {
        static ::DBus::IntrospectedArgument getSourceNames_args[] = 
        {
            { "sourcenames", "as", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument getDestinationNames_args[] = 
        {
            { "destinationnames", "as", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument getSourceForDestination_args[] = 
        {
            { "dstid", "s", true },
            { "srcid", "s", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument getDestinationsForSource_args[] = 
        {
            { "srcid", "s", true },
            { "dstids", "as", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument canConnect_args[] = 
        {
            { "srcid", "s", true },
            { "dstid", "s", true },
            { "canconnect", "b", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument setConnectionState_args[] = 
        {
            { "srcid", "s", true },
            { "dstid", "s", true },
            { "state", "b", true },
            { "result", "b", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument getConnectionState_args[] = 
        {
            { "srcid", "s", true },
            { "dstid", "s", true },
            { "state", "b", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument clearAllConnections_args[] = 
        {
            { "state", "b", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument hasPeakMetering_args[] = 
        {
            { "hasmetering", "b", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument getPeakValue_args[] = 
        {
            { "dstid", "s", true },
            { "value", "d", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument getPeakValues_args[] = 
        {
            { "values", "a(sd)", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedMethod CrossbarRouter_adaptor_methods[] = 
        {
            { "getSourceNames", getSourceNames_args },
            { "getDestinationNames", getDestinationNames_args },
            { "getSourceForDestination", getSourceForDestination_args },
            { "getDestinationsForSource", getDestinationsForSource_args },
            { "canConnect", canConnect_args },
            { "setConnectionState", setConnectionState_args },
            { "getConnectionState", getConnectionState_args },
            { "clearAllConnections", clearAllConnections_args },
            { "hasPeakMetering", hasPeakMetering_args },
            { "getPeakValue", getPeakValue_args },
            { "getPeakValues", getPeakValues_args },
            { 0, 0 }
        };
        static ::DBus::IntrospectedMethod CrossbarRouter_adaptor_signals[] = 
        {
            { 0, 0 }
        };
        static ::DBus::IntrospectedProperty CrossbarRouter_adaptor_properties[] = 
        {
            { 0, 0, 0, 0 }
        };
        static ::DBus::IntrospectedInterface CrossbarRouter_adaptor_interface = 
        {
            "org.ffado.Control.Element.CrossbarRouter",
            CrossbarRouter_adaptor_methods,
            CrossbarRouter_adaptor_signals,
            CrossbarRouter_adaptor_properties
        };
        return &CrossbarRouter_adaptor_interface;
    }

public:

    /* properties exposed by this interface, use
     * property() and property(value) to get and set a particular property
     */

public:

    /* methods exported by this interface,
     * you will have to implement them in your ObjectAdaptor
     */
    virtual std::vector< std::string > getSourceNames() = 0;
    virtual std::vector< std::string > getDestinationNames() = 0;
    virtual std::string getSourceForDestination(const std::string& dstid) = 0;
    virtual std::vector< std::string > getDestinationsForSource(const std::string& srcid) = 0;
    virtual bool canConnect(const std::string& srcid, const std::string& dstid) = 0;
    virtual bool setConnectionState(const std::string& srcid, const std::string& dstid, const bool& state) = 0;
    virtual bool getConnectionState(const std::string& srcid, const std::string& dstid) = 0;
    virtual bool clearAllConnections() = 0;
    virtual bool hasPeakMetering() = 0;
    virtual double getPeakValue(const std::string& dstid) = 0;
    virtual std::vector< ::DBus::Struct< std::string, double > > getPeakValues() = 0;

public:

    /* signal emitters for this interface
     */

private:

    /* unmarshalers (to unpack the DBus message before calling the actual interface method)
     */
    ::DBus::Message _getSourceNames_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        std::vector< std::string > argout1 = getSourceNames();
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
    ::DBus::Message _getDestinationNames_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        std::vector< std::string > argout1 = getDestinationNames();
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
    ::DBus::Message _getSourceForDestination_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        std::string argin1; ri >> argin1;
        std::string argout1 = getSourceForDestination(argin1);
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
    ::DBus::Message _getDestinationsForSource_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        std::string argin1; ri >> argin1;
        std::vector< std::string > argout1 = getDestinationsForSource(argin1);
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
    ::DBus::Message _canConnect_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        std::string argin1; ri >> argin1;
        std::string argin2; ri >> argin2;
        bool argout1 = canConnect(argin1, argin2);
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
    ::DBus::Message _setConnectionState_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        std::string argin1; ri >> argin1;
        std::string argin2; ri >> argin2;
        bool argin3; ri >> argin3;
        bool argout1 = setConnectionState(argin1, argin2, argin3);
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
    ::DBus::Message _getConnectionState_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        std::string argin1; ri >> argin1;
        std::string argin2; ri >> argin2;
        bool argout1 = getConnectionState(argin1, argin2);
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
    ::DBus::Message _clearAllConnections_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        bool argout1 = clearAllConnections();
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
    ::DBus::Message _hasPeakMetering_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        bool argout1 = hasPeakMetering();
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
    ::DBus::Message _getPeakValue_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        std::string argin1; ri >> argin1;
        double argout1 = getPeakValue(argin1);
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
    ::DBus::Message _getPeakValues_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        std::vector< ::DBus::Struct< std::string, double > > argout1 = getPeakValues();
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
};

} } } } 
namespace org {
namespace ffado {
namespace Control {
namespace Element {

class Boolean_adaptor
: public ::DBus::InterfaceAdaptor
{
public:

    Boolean_adaptor()
    : ::DBus::InterfaceAdaptor("org.ffado.Control.Element.Boolean")
    {
        register_method(Boolean_adaptor, select, _select_stub);
        register_method(Boolean_adaptor, selected, _selected_stub);
        register_method(Boolean_adaptor, getBooleanLabel, _getBooleanLabel_stub);
    }

    ::DBus::IntrospectedInterface *introspect() const 
    {
        static ::DBus::IntrospectedArgument select_args[] = 
        {
            { "value", "b", true },
            { "success", "b", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument selected_args[] = 
        {
            { "value", "b", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument getBooleanLabel_args[] = 
        {
            { "value", "b", true },
            { "label", "s", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedMethod Boolean_adaptor_methods[] = 
        {
            { "select", select_args },
            { "selected", selected_args },
            { "getBooleanLabel", getBooleanLabel_args },
            { 0, 0 }
        };
        static ::DBus::IntrospectedMethod Boolean_adaptor_signals[] = 
        {
            { 0, 0 }
        };
        static ::DBus::IntrospectedProperty Boolean_adaptor_properties[] = 
        {
            { 0, 0, 0, 0 }
        };
        static ::DBus::IntrospectedInterface Boolean_adaptor_interface = 
        {
            "org.ffado.Control.Element.Boolean",
            Boolean_adaptor_methods,
            Boolean_adaptor_signals,
            Boolean_adaptor_properties
        };
        return &Boolean_adaptor_interface;
    }

public:

    /* properties exposed by this interface, use
     * property() and property(value) to get and set a particular property
     */

public:

    /* methods exported by this interface,
     * you will have to implement them in your ObjectAdaptor
     */
    virtual bool select(const bool& value) = 0;
    virtual bool selected() = 0;
    virtual std::string getBooleanLabel(const bool& value) = 0;

public:

    /* signal emitters for this interface
     */

private:

    /* unmarshalers (to unpack the DBus message before calling the actual interface method)
     */
    ::DBus::Message _select_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        bool argin1; ri >> argin1;
        bool argout1 = select(argin1);
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
    ::DBus::Message _selected_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        bool argout1 = selected();
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
    ::DBus::Message _getBooleanLabel_stub(const ::DBus::CallMessage &call)
    {
        ::DBus::MessageIter ri = call.reader();

        bool argin1; ri >> argin1;
        std::string argout1 = getBooleanLabel(argin1);
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;
        return reply;
    }
};

} } } } 
#endif //__dbusxx__support_dbus_controlserver_glue_h__ADAPTOR_MARSHAL_H
