PluginRoutingInterfaceCAPI/src-gen/org/genivi/am/RoutingControlObserverProxy.h

   1 /*
   2 * This file was generated by the CommonAPI Generators.
   3 *
   4 * This file was generated by the CommonAPI Generators.
   5 *
   6 * This file was generated by the CommonAPI Generators.
   7 *
   8 * Copyright (C) 2012, BMW AG
   9 *
  10 * This file is part of GENIVI Project AudioManager.
  11 *
  12 * Contributions are licensed to the GENIVI Alliance under one or more
  13 * Contribution License Agreements.
  14 *
  15 * \copyright
  16 * This Source Code Form is subject to the terms of the
  17 * Mozilla Public License, v. 2.0. If a  copy of the MPL was not distributed with
  18 * this file, You can obtain one at http://mozilla.org/MPL/2.0/.
  19 *
  20 *
  21 * \author Aleksandar Donchev, aleksander.donchev@partner.bmw.de BMW 2013
  22 * \author Christian Linke christian.linke@bmw.de BMW 2013
  23 *
  24 * For further information see http://www.genivi.org/.
  25 */
  26 #ifndef ORG_GENIVI_AM_Routing_Control_Observer_PROXY_H_
  27 #define ORG_GENIVI_AM_Routing_Control_Observer_PROXY_H_
  28
  29 #include "RoutingControlObserverProxyBase.h"
  30
  31 #define COMMONAPI_INTERNAL_COMPILATION
  32
  33 #include <CommonAPI/AttributeExtension.h>
  34 #include <CommonAPI/Factory.h>
  35
  36 #undef COMMONAPI_INTERNAL_COMPILATION
  37
  38 namespace org {
  39 namespace genivi {
  40 namespace am {
  41
  42 template <typename ... _AttributeExtensions>
  43 class RoutingControlObserverProxy: virtual public RoutingControlObserver, virtual public RoutingControlObserverProxyBase, public _AttributeExtensions... {
  44  public:
  45     RoutingControlObserverProxy(std::shared_ptr<CommonAPI::Proxy> delegate);
  46     ~RoutingControlObserverProxy();
  47
  48     /// Returns the wrapper class that provides access to the attribute RoutingReady.
  49     virtual RoutingReadyAttribute& getRoutingReadyAttribute() {
  50         return delegate_->getRoutingReadyAttribute();
  51     }
  52
  53
  54
  55
  56     /**
  57      * Calls ackConnect with synchronous semantics.
  58      *
  59      * All const parameters are input parameters to this method.
  60      * The CallStatus will be filled when the method returns and indicate either
  61      * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
  62      * will be set.
  63      * Synchronous calls are not supported (will block indefinitely) when mainloop integration is used.
  64      */
  65     virtual void ackConnect(const am_Handle_s& handle, const am_connectionID_t& connectionID, const am_Error_e& error, CommonAPI::CallStatus& callStatus);
  66     /**
  67      * Calls ackConnect with asynchronous semantics.
  68      *
  69      * The provided callback will be called when the reply to this call arrives or
  70      * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
  71      * or which type of error has occurred. In case of any error, ONLY the CallStatus
  72      * will have a defined value.
  73      * The std::future returned by this method will be fulfilled at arrival of the reply.
  74      * It will provide the same value for CallStatus as will be handed to the callback.
  75      */
  76     virtual std::future<CommonAPI::CallStatus> ackConnectAsync(const am_Handle_s& handle, const am_connectionID_t& connectionID, const am_Error_e& error, AckConnectAsyncCallback callback);
  77
  78     /**
  79      * Calls ackDisconnect with synchronous semantics.
  80      *
  81      * All const parameters are input parameters to this method.
  82      * The CallStatus will be filled when the method returns and indicate either
  83      * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
  84      * will be set.
  85      * Synchronous calls are not supported (will block indefinitely) when mainloop integration is used.
  86      */
  87     virtual void ackDisconnect(const am_Handle_s& handle, const am_connectionID_t& connectionID, const am_Error_e& error, CommonAPI::CallStatus& callStatus);
  88     /**
  89      * Calls ackDisconnect with asynchronous semantics.
  90      *
  91      * The provided callback will be called when the reply to this call arrives or
  92      * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
  93      * or which type of error has occurred. In case of any error, ONLY the CallStatus
  94      * will have a defined value.
  95      * The std::future returned by this method will be fulfilled at arrival of the reply.
  96      * It will provide the same value for CallStatus as will be handed to the callback.
  97      */
  98     virtual std::future<CommonAPI::CallStatus> ackDisconnectAsync(const am_Handle_s& handle, const am_connectionID_t& connectionID, const am_Error_e& error, AckDisconnectAsyncCallback callback);
  99
 100     /**
 101      * Calls ackSetSinkVolumeChange with synchronous semantics.
 102      *
 103      * All const parameters are input parameters to this method.
 104      * The CallStatus will be filled when the method returns and indicate either
 105      * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
 106      * will be set.
 107      * Synchronous calls are not supported (will block indefinitely) when mainloop integration is used.
 108      */
 109     virtual void ackSetSinkVolumeChange(const am_Handle_s& handle, const am_volume_t& volume, const am_Error_e& error, CommonAPI::CallStatus& callStatus);
 110     /**
 111      * Calls ackSetSinkVolumeChange with asynchronous semantics.
 112      *
 113      * The provided callback will be called when the reply to this call arrives or
 114      * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
 115      * or which type of error has occurred. In case of any error, ONLY the CallStatus
 116      * will have a defined value.
 117      * The std::future returned by this method will be fulfilled at arrival of the reply.
 118      * It will provide the same value for CallStatus as will be handed to the callback.
 119      */
 120     virtual std::future<CommonAPI::CallStatus> ackSetSinkVolumeChangeAsync(const am_Handle_s& handle, const am_volume_t& volume, const am_Error_e& error, AckSetSinkVolumeChangeAsyncCallback callback);
 121
 122     /**
 123      * Calls ackSetSourceVolumeChange with synchronous semantics.
 124      *
 125      * All const parameters are input parameters to this method.
 126      * The CallStatus will be filled when the method returns and indicate either
 127      * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
 128      * will be set.
 129      * Synchronous calls are not supported (will block indefinitely) when mainloop integration is used.
 130      */
 131     virtual void ackSetSourceVolumeChange(const am_Handle_s& handle, const am_volume_t& volume, const am_Error_e& error, CommonAPI::CallStatus& callStatus);
 132     /**
 133      * Calls ackSetSourceVolumeChange with asynchronous semantics.
 134      *
 135      * The provided callback will be called when the reply to this call arrives or
 136      * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
 137      * or which type of error has occurred. In case of any error, ONLY the CallStatus
 138      * will have a defined value.
 139      * The std::future returned by this method will be fulfilled at arrival of the reply.
 140      * It will provide the same value for CallStatus as will be handed to the callback.
 141      */
 142     virtual std::future<CommonAPI::CallStatus> ackSetSourceVolumeChangeAsync(const am_Handle_s& handle, const am_volume_t& volume, const am_Error_e& error, AckSetSourceVolumeChangeAsyncCallback callback);
 143
 144     /**
 145      * Calls ackSetSourceState with synchronous semantics.
 146      *
 147      * All const parameters are input parameters to this method.
 148      * The CallStatus will be filled when the method returns and indicate either
 149      * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
 150      * will be set.
 151      * Synchronous calls are not supported (will block indefinitely) when mainloop integration is used.
 152      */
 153     virtual void ackSetSourceState(const am_Handle_s& handle, const am_Error_e& error, CommonAPI::CallStatus& callStatus);
 154     /**
 155      * Calls ackSetSourceState with asynchronous semantics.
 156      *
 157      * The provided callback will be called when the reply to this call arrives or
 158      * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
 159      * or which type of error has occurred. In case of any error, ONLY the CallStatus
 160      * will have a defined value.
 161      * The std::future returned by this method will be fulfilled at arrival of the reply.
 162      * It will provide the same value for CallStatus as will be handed to the callback.
 163      */
 164     virtual std::future<CommonAPI::CallStatus> ackSetSourceStateAsync(const am_Handle_s& handle, const am_Error_e& error, AckSetSourceStateAsyncCallback callback);
 165
 166     /**
 167      * Calls ackSetSinkSoundProperties with synchronous semantics.
 168      *
 169      * All const parameters are input parameters to this method.
 170      * The CallStatus will be filled when the method returns and indicate either
 171      * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
 172      * will be set.
 173      * Synchronous calls are not supported (will block indefinitely) when mainloop integration is used.
 174      */
 175     virtual void ackSetSinkSoundProperties(const am_Handle_s& handle, const am_Error_e& error, CommonAPI::CallStatus& callStatus);
 176     /**
 177      * Calls ackSetSinkSoundProperties with asynchronous semantics.
 178      *
 179      * The provided callback will be called when the reply to this call arrives or
 180      * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
 181      * or which type of error has occurred. In case of any error, ONLY the CallStatus
 182      * will have a defined value.
 183      * The std::future returned by this method will be fulfilled at arrival of the reply.
 184      * It will provide the same value for CallStatus as will be handed to the callback.
 185      */
 186     virtual std::future<CommonAPI::CallStatus> ackSetSinkSoundPropertiesAsync(const am_Handle_s& handle, const am_Error_e& error, AckSetSinkSoundPropertiesAsyncCallback callback);
 187
 188     /**
 189      * Calls ackSetSinkSoundProperty with synchronous semantics.
 190      *
 191      * All const parameters are input parameters to this method.
 192      * The CallStatus will be filled when the method returns and indicate either
 193      * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
 194      * will be set.
 195      * Synchronous calls are not supported (will block indefinitely) when mainloop integration is used.
 196      */
 197     virtual void ackSetSinkSoundProperty(const am_Handle_s& handle, const am_Error_e& error, CommonAPI::CallStatus& callStatus);
 198     /**
 199      * Calls ackSetSinkSoundProperty with asynchronous semantics.
 200      *
 201      * The provided callback will be called when the reply to this call arrives or
 202      * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
 203      * or which type of error has occurred. In case of any error, ONLY the CallStatus
 204      * will have a defined value.
 205      * The std::future returned by this method will be fulfilled at arrival of the reply.
 206      * It will provide the same value for CallStatus as will be handed to the callback.
 207      */
 208     virtual std::future<CommonAPI::CallStatus> ackSetSinkSoundPropertyAsync(const am_Handle_s& handle, const am_Error_e& error, AckSetSinkSoundPropertyAsyncCallback callback);
 209
 210     /**
 211      * Calls ackSetSourceSoundProperties with synchronous semantics.
 212      *
 213      * All const parameters are input parameters to this method.
 214      * The CallStatus will be filled when the method returns and indicate either
 215      * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
 216      * will be set.
 217      * Synchronous calls are not supported (will block indefinitely) when mainloop integration is used.
 218      */
 219     virtual void ackSetSourceSoundProperties(const am_Handle_s& handle, const am_Error_e& error, CommonAPI::CallStatus& callStatus);
 220     /**
 221      * Calls ackSetSourceSoundProperties with asynchronous semantics.
 222      *
 223      * The provided callback will be called when the reply to this call arrives or
 224      * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
 225      * or which type of error has occurred. In case of any error, ONLY the CallStatus
 226      * will have a defined value.
 227      * The std::future returned by this method will be fulfilled at arrival of the reply.
 228      * It will provide the same value for CallStatus as will be handed to the callback.
 229      */
 230     virtual std::future<CommonAPI::CallStatus> ackSetSourceSoundPropertiesAsync(const am_Handle_s& handle, const am_Error_e& error, AckSetSourceSoundPropertiesAsyncCallback callback);
 231
 232     /**
 233      * Calls ackSetSourceSoundProperty with synchronous semantics.
 234      *
 235      * All const parameters are input parameters to this method.
 236      * The CallStatus will be filled when the method returns and indicate either
 237      * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
 238      * will be set.
 239      * Synchronous calls are not supported (will block indefinitely) when mainloop integration is used.
 240      */
 241     virtual void ackSetSourceSoundProperty(const am_Handle_s& handle, const am_Error_e& error, CommonAPI::CallStatus& callStatus);
 242     /**
 243      * Calls ackSetSourceSoundProperty with asynchronous semantics.
 244      *
 245      * The provided callback will be called when the reply to this call arrives or
 246      * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
 247      * or which type of error has occurred. In case of any error, ONLY the CallStatus
 248      * will have a defined value.
 249      * The std::future returned by this method will be fulfilled at arrival of the reply.
 250      * It will provide the same value for CallStatus as will be handed to the callback.
 251      */
 252     virtual std::future<CommonAPI::CallStatus> ackSetSourceSoundPropertyAsync(const am_Handle_s& handle, const am_Error_e& error, AckSetSourceSoundPropertyAsyncCallback callback);
 253
 254     /**
 255      * Calls ackCrossFading with synchronous semantics.
 256      *
 257      * All const parameters are input parameters to this method.
 258      * The CallStatus will be filled when the method returns and indicate either
 259      * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
 260      * will be set.
 261      * Synchronous calls are not supported (will block indefinitely) when mainloop integration is used.
 262      */
 263     virtual void ackCrossFading(const am_Handle_s& handle, const am_HotSink_e& hotSink, const am_Error_e& error, CommonAPI::CallStatus& callStatus);
 264     /**
 265      * Calls ackCrossFading with asynchronous semantics.
 266      *
 267      * The provided callback will be called when the reply to this call arrives or
 268      * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
 269      * or which type of error has occurred. In case of any error, ONLY the CallStatus
 270      * will have a defined value.
 271      * The std::future returned by this method will be fulfilled at arrival of the reply.
 272      * It will provide the same value for CallStatus as will be handed to the callback.
 273      */
 274     virtual std::future<CommonAPI::CallStatus> ackCrossFadingAsync(const am_Handle_s& handle, const am_HotSink_e& hotSink, const am_Error_e& error, AckCrossFadingAsyncCallback callback);
 275
 276     /**
 277      * Calls ackSourceVolumeTick with synchronous semantics.
 278      *
 279      * All const parameters are input parameters to this method.
 280      * The CallStatus will be filled when the method returns and indicate either
 281      * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
 282      * will be set.
 283      * Synchronous calls are not supported (will block indefinitely) when mainloop integration is used.
 284      */
 285     virtual void ackSourceVolumeTick(const am_Handle_s& handle, const am_sourceID_t& sourceID, const am_volume_t& volume, CommonAPI::CallStatus& callStatus);
 286     /**
 287      * Calls ackSourceVolumeTick with asynchronous semantics.
 288      *
 289      * The provided callback will be called when the reply to this call arrives or
 290      * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
 291      * or which type of error has occurred. In case of any error, ONLY the CallStatus
 292      * will have a defined value.
 293      * The std::future returned by this method will be fulfilled at arrival of the reply.
 294      * It will provide the same value for CallStatus as will be handed to the callback.
 295      */
 296     virtual std::future<CommonAPI::CallStatus> ackSourceVolumeTickAsync(const am_Handle_s& handle, const am_sourceID_t& sourceID, const am_volume_t& volume, AckSourceVolumeTickAsyncCallback callback);
 297
 298     /**
 299      * Calls ackSinkVolumeTick with synchronous semantics.
 300      *
 301      * All const parameters are input parameters to this method.
 302      * The CallStatus will be filled when the method returns and indicate either
 303      * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
 304      * will be set.
 305      * Synchronous calls are not supported (will block indefinitely) when mainloop integration is used.
 306      */
 307     virtual void ackSinkVolumeTick(const am_Handle_s& handle, const am_sinkID_t& sinkID, const am_volume_t& volume, CommonAPI::CallStatus& callStatus);
 308     /**
 309      * Calls ackSinkVolumeTick with asynchronous semantics.
 310      *
 311      * The provided callback will be called when the reply to this call arrives or
 312      * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
 313      * or which type of error has occurred. In case of any error, ONLY the CallStatus
 314      * will have a defined value.
 315      * The std::future returned by this method will be fulfilled at arrival of the reply.
 316      * It will provide the same value for CallStatus as will be handed to the callback.
 317      */
 318     virtual std::future<CommonAPI::CallStatus> ackSinkVolumeTickAsync(const am_Handle_s& handle, const am_sinkID_t& sinkID, const am_volume_t& volume, AckSinkVolumeTickAsyncCallback callback);
 319
 320     /**
 321      * Calls peekDomain with synchronous semantics.
 322      *
 323      * All const parameters are input parameters to this method.
 324      * All non-const parameters will be filled with the returned values.
 325      * The CallStatus will be filled when the method returns and indicate either
 326      * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
 327      * will be set.
 328      * Synchronous calls are not supported (will block indefinitely) when mainloop integration is used.
 329      */
 330     virtual void peekDomain(const std::string& name, CommonAPI::CallStatus& callStatus, am_domainID_t& domainID, am_Error_e& error);
 331     /**
 332      * Calls peekDomain with asynchronous semantics.
 333      *
 334      * The provided callback will be called when the reply to this call arrives or
 335      * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
 336      * or which type of error has occurred. In case of any error, ONLY the CallStatus
 337      * will have a defined value.
 338      * The std::future returned by this method will be fulfilled at arrival of the reply.
 339      * It will provide the same value for CallStatus as will be handed to the callback.
 340      */
 341     virtual std::future<CommonAPI::CallStatus> peekDomainAsync(const std::string& name, PeekDomainAsyncCallback callback);
 342
 343     /**
 344      * Calls registerDomain with synchronous semantics.
 345      *
 346      * All const parameters are input parameters to this method.
 347      * All non-const parameters will be filled with the returned values.
 348      * The CallStatus will be filled when the method returns and indicate either
 349      * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
 350      * will be set.
 351      * Synchronous calls are not supported (will block indefinitely) when mainloop integration is used.
 352      */
 353     virtual void registerDomain(const am_Domain_s& domainData, const std::string& returnBusname, const std::string& returnInterface, CommonAPI::CallStatus& callStatus, am_domainID_t& domainID, am_Error_e& error);
 354     /**
 355      * Calls registerDomain with asynchronous semantics.
 356      *
 357      * The provided callback will be called when the reply to this call arrives or
 358      * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
 359      * or which type of error has occurred. In case of any error, ONLY the CallStatus
 360      * will have a defined value.
 361      * The std::future returned by this method will be fulfilled at arrival of the reply.
 362      * It will provide the same value for CallStatus as will be handed to the callback.
 363      */
 364     virtual std::future<CommonAPI::CallStatus> registerDomainAsync(const am_Domain_s& domainData, const std::string& returnBusname, const std::string& returnInterface, RegisterDomainAsyncCallback callback);
 365
 366     /**
 367      * Calls deregisterDomain with synchronous semantics.
 368      *
 369      * All const parameters are input parameters to this method.
 370      * All non-const parameters will be filled with the returned values.
 371      * The CallStatus will be filled when the method returns and indicate either
 372      * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
 373      * will be set.
 374      * Synchronous calls are not supported (will block indefinitely) when mainloop integration is used.
 375      */
 376     virtual void deregisterDomain(const am_domainID_t& domainID, CommonAPI::CallStatus& callStatus, am_Error_e& error);
 377     /**
 378      * Calls deregisterDomain with asynchronous semantics.
 379      *
 380      * The provided callback will be called when the reply to this call arrives or
 381      * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
 382      * or which type of error has occurred. In case of any error, ONLY the CallStatus
 383      * will have a defined value.
 384      * The std::future returned by this method will be fulfilled at arrival of the reply.
 385      * It will provide the same value for CallStatus as will be handed to the callback.
 386      */
 387     virtual std::future<CommonAPI::CallStatus> deregisterDomainAsync(const am_domainID_t& domainID, DeregisterDomainAsyncCallback callback);
 388
 389     /**
 390      * Calls registerGateway with synchronous semantics.
 391      *
 392      * All const parameters are input parameters to this method.
 393      * All non-const parameters will be filled with the returned values.
 394      * The CallStatus will be filled when the method returns and indicate either
 395      * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
 396      * will be set.
 397      * Synchronous calls are not supported (will block indefinitely) when mainloop integration is used.
 398      */
 399     virtual void registerGateway(const am_Gateway_s& gatewayData, CommonAPI::CallStatus& callStatus, am_gatewayID_t& gatewayID, am_Error_e& error);
 400     /**
 401      * Calls registerGateway with asynchronous semantics.
 402      *
 403      * The provided callback will be called when the reply to this call arrives or
 404      * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
 405      * or which type of error has occurred. In case of any error, ONLY the CallStatus
 406      * will have a defined value.
 407      * The std::future returned by this method will be fulfilled at arrival of the reply.
 408      * It will provide the same value for CallStatus as will be handed to the callback.
 409      */
 410     virtual std::future<CommonAPI::CallStatus> registerGatewayAsync(const am_Gateway_s& gatewayData, RegisterGatewayAsyncCallback callback);
 411
 412     /**
 413      * Calls deregisterGateway with synchronous semantics.
 414      *
 415      * All const parameters are input parameters to this method.
 416      * All non-const parameters will be filled with the returned values.
 417      * The CallStatus will be filled when the method returns and indicate either
 418      * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
 419      * will be set.
 420      * Synchronous calls are not supported (will block indefinitely) when mainloop integration is used.
 421      */
 422     virtual void deregisterGateway(const am_gatewayID_t& gatewayID, CommonAPI::CallStatus& callStatus, am_Error_e& error);
 423     /**
 424      * Calls deregisterGateway with asynchronous semantics.
 425      *
 426      * The provided callback will be called when the reply to this call arrives or
 427      * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
 428      * or which type of error has occurred. In case of any error, ONLY the CallStatus
 429      * will have a defined value.
 430      * The std::future returned by this method will be fulfilled at arrival of the reply.
 431      * It will provide the same value for CallStatus as will be handed to the callback.
 432      */
 433     virtual std::future<CommonAPI::CallStatus> deregisterGatewayAsync(const am_gatewayID_t& gatewayID, DeregisterGatewayAsyncCallback callback);
 434
 435     /**
 436      * Calls peekSink with synchronous semantics.
 437      *
 438      * All const parameters are input parameters to this method.
 439      * All non-const parameters will be filled with the returned values.
 440      * The CallStatus will be filled when the method returns and indicate either
 441      * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
 442      * will be set.
 443      * Synchronous calls are not supported (will block indefinitely) when mainloop integration is used.
 444      */
 445     virtual void peekSink(const std::string& name, CommonAPI::CallStatus& callStatus, am_sinkID_t& sinkID, am_Error_e& error);
 446     /**
 447      * Calls peekSink with asynchronous semantics.
 448      *
 449      * The provided callback will be called when the reply to this call arrives or
 450      * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
 451      * or which type of error has occurred. In case of any error, ONLY the CallStatus
 452      * will have a defined value.
 453      * The std::future returned by this method will be fulfilled at arrival of the reply.
 454      * It will provide the same value for CallStatus as will be handed to the callback.
 455      */
 456     virtual std::future<CommonAPI::CallStatus> peekSinkAsync(const std::string& name, PeekSinkAsyncCallback callback);
 457
 458     /**
 459      * Calls registerSink with synchronous semantics.
 460      *
 461      * All const parameters are input parameters to this method.
 462      * All non-const parameters will be filled with the returned values.
 463      * The CallStatus will be filled when the method returns and indicate either
 464      * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
 465      * will be set.
 466      * Synchronous calls are not supported (will block indefinitely) when mainloop integration is used.
 467      */
 468     virtual void registerSink(const am_Sink_s& sinkData, CommonAPI::CallStatus& callStatus, am_sinkID_t& sinkID, am_Error_e& error);
 469     /**
 470      * Calls registerSink with asynchronous semantics.
 471      *
 472      * The provided callback will be called when the reply to this call arrives or
 473      * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
 474      * or which type of error has occurred. In case of any error, ONLY the CallStatus
 475      * will have a defined value.
 476      * The std::future returned by this method will be fulfilled at arrival of the reply.
 477      * It will provide the same value for CallStatus as will be handed to the callback.
 478      */
 479     virtual std::future<CommonAPI::CallStatus> registerSinkAsync(const am_Sink_s& sinkData, RegisterSinkAsyncCallback callback);
 480
 481     /**
 482      * Calls deregisterSink with synchronous semantics.
 483      *
 484      * All const parameters are input parameters to this method.
 485      * All non-const parameters will be filled with the returned values.
 486      * The CallStatus will be filled when the method returns and indicate either
 487      * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
 488      * will be set.
 489      * Synchronous calls are not supported (will block indefinitely) when mainloop integration is used.
 490      */
 491     virtual void deregisterSink(const am_sinkID_t& sinkID, CommonAPI::CallStatus& callStatus, am_Error_e& error);
 492     /**
 493      * Calls deregisterSink with asynchronous semantics.
 494      *
 495      * The provided callback will be called when the reply to this call arrives or
 496      * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
 497      * or which type of error has occurred. In case of any error, ONLY the CallStatus
 498      * will have a defined value.
 499      * The std::future returned by this method will be fulfilled at arrival of the reply.
 500      * It will provide the same value for CallStatus as will be handed to the callback.
 501      */
 502     virtual std::future<CommonAPI::CallStatus> deregisterSinkAsync(const am_sinkID_t& sinkID, DeregisterSinkAsyncCallback callback);
 503
 504     /**
 505      * Calls peekSource with synchronous semantics.
 506      *
 507      * All const parameters are input parameters to this method.
 508      * All non-const parameters will be filled with the returned values.
 509      * The CallStatus will be filled when the method returns and indicate either
 510      * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
 511      * will be set.
 512      * Synchronous calls are not supported (will block indefinitely) when mainloop integration is used.
 513      */
 514     virtual void peekSource(const std::string& name, CommonAPI::CallStatus& callStatus, am_sourceID_t& sourceID, am_Error_e& error);
 515     /**
 516      * Calls peekSource with asynchronous semantics.
 517      *
 518      * The provided callback will be called when the reply to this call arrives or
 519      * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
 520      * or which type of error has occurred. In case of any error, ONLY the CallStatus
 521      * will have a defined value.
 522      * The std::future returned by this method will be fulfilled at arrival of the reply.
 523      * It will provide the same value for CallStatus as will be handed to the callback.
 524      */
 525     virtual std::future<CommonAPI::CallStatus> peekSourceAsync(const std::string& name, PeekSourceAsyncCallback callback);
 526
 527     /**
 528      * Calls registerSource with synchronous semantics.
 529      *
 530      * All const parameters are input parameters to this method.
 531      * All non-const parameters will be filled with the returned values.
 532      * The CallStatus will be filled when the method returns and indicate either
 533      * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
 534      * will be set.
 535      * Synchronous calls are not supported (will block indefinitely) when mainloop integration is used.
 536      */
 537     virtual void registerSource(const am_Source_s& sourceData, CommonAPI::CallStatus& callStatus, am_sourceID_t& sourceID, am_Error_e& error);
 538     /**
 539      * Calls registerSource with asynchronous semantics.
 540      *
 541      * The provided callback will be called when the reply to this call arrives or
 542      * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
 543      * or which type of error has occurred. In case of any error, ONLY the CallStatus
 544      * will have a defined value.
 545      * The std::future returned by this method will be fulfilled at arrival of the reply.
 546      * It will provide the same value for CallStatus as will be handed to the callback.
 547      */
 548     virtual std::future<CommonAPI::CallStatus> registerSourceAsync(const am_Source_s& sourceData, RegisterSourceAsyncCallback callback);
 549
 550     /**
 551      * Calls deregisterSource with synchronous semantics.
 552      *
 553      * All const parameters are input parameters to this method.
 554      * All non-const parameters will be filled with the returned values.
 555      * The CallStatus will be filled when the method returns and indicate either
 556      * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
 557      * will be set.
 558      * Synchronous calls are not supported (will block indefinitely) when mainloop integration is used.
 559      */
 560     virtual void deregisterSource(const am_sourceID_t& sourceID, CommonAPI::CallStatus& callStatus, am_Error_e& error);
 561     /**
 562      * Calls deregisterSource with asynchronous semantics.
 563      *
 564      * The provided callback will be called when the reply to this call arrives or
 565      * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
 566      * or which type of error has occurred. In case of any error, ONLY the CallStatus
 567      * will have a defined value.
 568      * The std::future returned by this method will be fulfilled at arrival of the reply.
 569      * It will provide the same value for CallStatus as will be handed to the callback.
 570      */
 571     virtual std::future<CommonAPI::CallStatus> deregisterSourceAsync(const am_sourceID_t& sourceID, DeregisterSourceAsyncCallback callback);
 572
 573     /**
 574      * Calls registerCrossfader with synchronous semantics.
 575      *
 576      * All const parameters are input parameters to this method.
 577      * All non-const parameters will be filled with the returned values.
 578      * The CallStatus will be filled when the method returns and indicate either
 579      * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
 580      * will be set.
 581      * Synchronous calls are not supported (will block indefinitely) when mainloop integration is used.
 582      */
 583     virtual void registerCrossfader(const am_Crossfader_s& crossfaderData, CommonAPI::CallStatus& callStatus, am_crossfaderID_t& crossfaderID, am_Error_e& error);
 584     /**
 585      * Calls registerCrossfader with asynchronous semantics.
 586      *
 587      * The provided callback will be called when the reply to this call arrives or
 588      * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
 589      * or which type of error has occurred. In case of any error, ONLY the CallStatus
 590      * will have a defined value.
 591      * The std::future returned by this method will be fulfilled at arrival of the reply.
 592      * It will provide the same value for CallStatus as will be handed to the callback.
 593      */
 594     virtual std::future<CommonAPI::CallStatus> registerCrossfaderAsync(const am_Crossfader_s& crossfaderData, RegisterCrossfaderAsyncCallback callback);
 595
 596     /**
 597      * Calls deregisterCrossfader with synchronous semantics.
 598      *
 599      * All const parameters are input parameters to this method.
 600      * All non-const parameters will be filled with the returned values.
 601      * The CallStatus will be filled when the method returns and indicate either
 602      * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
 603      * will be set.
 604      * Synchronous calls are not supported (will block indefinitely) when mainloop integration is used.
 605      */
 606     virtual void deregisterCrossfader(const am_crossfaderID_t& crossfaderID, CommonAPI::CallStatus& callStatus, am_Error_e& error);
 607     /**
 608      * Calls deregisterCrossfader with asynchronous semantics.
 609      *
 610      * The provided callback will be called when the reply to this call arrives or
 611      * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
 612      * or which type of error has occurred. In case of any error, ONLY the CallStatus
 613      * will have a defined value.
 614      * The std::future returned by this method will be fulfilled at arrival of the reply.
 615      * It will provide the same value for CallStatus as will be handed to the callback.
 616      */
 617     virtual std::future<CommonAPI::CallStatus> deregisterCrossfaderAsync(const am_crossfaderID_t& crossfaderID, DeregisterCrossfaderAsyncCallback callback);
 618
 619     /**
 620      * Calls peekSourceClassID with synchronous semantics.
 621      *
 622      * All const parameters are input parameters to this method.
 623      * All non-const parameters will be filled with the returned values.
 624      * The CallStatus will be filled when the method returns and indicate either
 625      * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
 626      * will be set.
 627      * Synchronous calls are not supported (will block indefinitely) when mainloop integration is used.
 628      */
 629     virtual void peekSourceClassID(const std::string& name, CommonAPI::CallStatus& callStatus, am_sourceClass_t& sourceClassID, am_Error_e& error);
 630     /**
 631      * Calls peekSourceClassID with asynchronous semantics.
 632      *
 633      * The provided callback will be called when the reply to this call arrives or
 634      * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
 635      * or which type of error has occurred. In case of any error, ONLY the CallStatus
 636      * will have a defined value.
 637      * The std::future returned by this method will be fulfilled at arrival of the reply.
 638      * It will provide the same value for CallStatus as will be handed to the callback.
 639      */
 640     virtual std::future<CommonAPI::CallStatus> peekSourceClassIDAsync(const std::string& name, PeekSourceClassIDAsyncCallback callback);
 641
 642     /**
 643      * Calls peekSinkClassID with synchronous semantics.
 644      *
 645      * All const parameters are input parameters to this method.
 646      * All non-const parameters will be filled with the returned values.
 647      * The CallStatus will be filled when the method returns and indicate either
 648      * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
 649      * will be set.
 650      * Synchronous calls are not supported (will block indefinitely) when mainloop integration is used.
 651      */
 652     virtual void peekSinkClassID(const std::string& name, CommonAPI::CallStatus& callStatus, am_sinkClass_t& sinkClassID, am_Error_e& error);
 653     /**
 654      * Calls peekSinkClassID with asynchronous semantics.
 655      *
 656      * The provided callback will be called when the reply to this call arrives or
 657      * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
 658      * or which type of error has occurred. In case of any error, ONLY the CallStatus
 659      * will have a defined value.
 660      * The std::future returned by this method will be fulfilled at arrival of the reply.
 661      * It will provide the same value for CallStatus as will be handed to the callback.
 662      */
 663     virtual std::future<CommonAPI::CallStatus> peekSinkClassIDAsync(const std::string& name, PeekSinkClassIDAsyncCallback callback);
 664
 665     /**
 666      * Calls hookInterruptStatusChange with synchronous semantics.
 667      *
 668      * All const parameters are input parameters to this method.
 669      * The CallStatus will be filled when the method returns and indicate either
 670      * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
 671      * will be set.
 672      * Synchronous calls are not supported (will block indefinitely) when mainloop integration is used.
 673      */
 674     virtual void hookInterruptStatusChange(const am_sourceID_t& sourceID, const am_InterruptState_e& interruptState, CommonAPI::CallStatus& callStatus);
 675     /**
 676      * Calls hookInterruptStatusChange with asynchronous semantics.
 677      *
 678      * The provided callback will be called when the reply to this call arrives or
 679      * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
 680      * or which type of error has occurred. In case of any error, ONLY the CallStatus
 681      * will have a defined value.
 682      * The std::future returned by this method will be fulfilled at arrival of the reply.
 683      * It will provide the same value for CallStatus as will be handed to the callback.
 684      */
 685     virtual std::future<CommonAPI::CallStatus> hookInterruptStatusChangeAsync(const am_sourceID_t& sourceID, const am_InterruptState_e& interruptState, HookInterruptStatusChangeAsyncCallback callback);
 686
 687     /**
 688      * Calls hookDomainRegistrationComplete with synchronous semantics.
 689      *
 690      * All const parameters are input parameters to this method.
 691      * The CallStatus will be filled when the method returns and indicate either
 692      * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
 693      * will be set.
 694      * Synchronous calls are not supported (will block indefinitely) when mainloop integration is used.
 695      */
 696     virtual void hookDomainRegistrationComplete(const am_domainID_t& domainID, CommonAPI::CallStatus& callStatus);
 697     /**
 698      * Calls hookDomainRegistrationComplete with asynchronous semantics.
 699      *
 700      * The provided callback will be called when the reply to this call arrives or
 701      * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
 702      * or which type of error has occurred. In case of any error, ONLY the CallStatus
 703      * will have a defined value.
 704      * The std::future returned by this method will be fulfilled at arrival of the reply.
 705      * It will provide the same value for CallStatus as will be handed to the callback.
 706      */
 707     virtual std::future<CommonAPI::CallStatus> hookDomainRegistrationCompleteAsync(const am_domainID_t& domainID, HookDomainRegistrationCompleteAsyncCallback callback);
 708
 709     /**
 710      * Calls hookSinkAvailablityStatusChange with synchronous semantics.
 711      *
 712      * All const parameters are input parameters to this method.
 713      * The CallStatus will be filled when the method returns and indicate either
 714      * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
 715      * will be set.
 716      * Synchronous calls are not supported (will block indefinitely) when mainloop integration is used.
 717      */
 718     virtual void hookSinkAvailablityStatusChange(const am_sinkID_t& sinkID, const am_Availability_s& availability, CommonAPI::CallStatus& callStatus);
 719     /**
 720      * Calls hookSinkAvailablityStatusChange with asynchronous semantics.
 721      *
 722      * The provided callback will be called when the reply to this call arrives or
 723      * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
 724      * or which type of error has occurred. In case of any error, ONLY the CallStatus
 725      * will have a defined value.
 726      * The std::future returned by this method will be fulfilled at arrival of the reply.
 727      * It will provide the same value for CallStatus as will be handed to the callback.
 728      */
 729     virtual std::future<CommonAPI::CallStatus> hookSinkAvailablityStatusChangeAsync(const am_sinkID_t& sinkID, const am_Availability_s& availability, HookSinkAvailablityStatusChangeAsyncCallback callback);
 730
 731     /**
 732      * Calls hookSourceAvailablityStatusChange with synchronous semantics.
 733      *
 734      * All const parameters are input parameters to this method.
 735      * The CallStatus will be filled when the method returns and indicate either
 736      * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
 737      * will be set.
 738      * Synchronous calls are not supported (will block indefinitely) when mainloop integration is used.
 739      */
 740     virtual void hookSourceAvailablityStatusChange(const am_sourceID_t& sourceID, const am_Availability_s& availability, CommonAPI::CallStatus& callStatus);
 741     /**
 742      * Calls hookSourceAvailablityStatusChange with asynchronous semantics.
 743      *
 744      * The provided callback will be called when the reply to this call arrives or
 745      * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
 746      * or which type of error has occurred. In case of any error, ONLY the CallStatus
 747      * will have a defined value.
 748      * The std::future returned by this method will be fulfilled at arrival of the reply.
 749      * It will provide the same value for CallStatus as will be handed to the callback.
 750      */
 751     virtual std::future<CommonAPI::CallStatus> hookSourceAvailablityStatusChangeAsync(const am_sourceID_t& sourceID, const am_Availability_s& availability, HookSourceAvailablityStatusChangeAsyncCallback callback);
 752
 753     /**
 754      * Calls hookDomainStateChange with synchronous semantics.
 755      *
 756      * All const parameters are input parameters to this method.
 757      * The CallStatus will be filled when the method returns and indicate either
 758      * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
 759      * will be set.
 760      * Synchronous calls are not supported (will block indefinitely) when mainloop integration is used.
 761      */
 762     virtual void hookDomainStateChange(const am_domainID_t& domainID, const am_DomainState_e& domainState, CommonAPI::CallStatus& callStatus);
 763     /**
 764      * Calls hookDomainStateChange with asynchronous semantics.
 765      *
 766      * The provided callback will be called when the reply to this call arrives or
 767      * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
 768      * or which type of error has occurred. In case of any error, ONLY the CallStatus
 769      * will have a defined value.
 770      * The std::future returned by this method will be fulfilled at arrival of the reply.
 771      * It will provide the same value for CallStatus as will be handed to the callback.
 772      */
 773     virtual std::future<CommonAPI::CallStatus> hookDomainStateChangeAsync(const am_domainID_t& domainID, const am_DomainState_e& domainState, HookDomainStateChangeAsyncCallback callback);
 774
 775     /**
 776      * Calls hookTimingInformationChanged with synchronous semantics.
 777      *
 778      * All const parameters are input parameters to this method.
 779      * The CallStatus will be filled when the method returns and indicate either
 780      * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
 781      * will be set.
 782      * Synchronous calls are not supported (will block indefinitely) when mainloop integration is used.
 783      */
 784     virtual void hookTimingInformationChanged(const am_connectionID_t& connectionID, const am_timeSync_t& delay, CommonAPI::CallStatus& callStatus);
 785     /**
 786      * Calls hookTimingInformationChanged with asynchronous semantics.
 787      *
 788      * The provided callback will be called when the reply to this call arrives or
 789      * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
 790      * or which type of error has occurred. In case of any error, ONLY the CallStatus
 791      * will have a defined value.
 792      * The std::future returned by this method will be fulfilled at arrival of the reply.
 793      * It will provide the same value for CallStatus as will be handed to the callback.
 794      */
 795     virtual std::future<CommonAPI::CallStatus> hookTimingInformationChangedAsync(const am_connectionID_t& connectionID, const am_timeSync_t& delay, HookTimingInformationChangedAsyncCallback callback);
 796
 797     /**
 798      * Calls sendChangedData with synchronous semantics.
 799      *
 800      * All const parameters are input parameters to this method.
 801      * The CallStatus will be filled when the method returns and indicate either
 802      * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
 803      * will be set.
 804      * Synchronous calls are not supported (will block indefinitely) when mainloop integration is used.
 805      */
 806     virtual void sendChangedData(const am_EarlyData_L& earlyData, CommonAPI::CallStatus& callStatus);
 807     /**
 808      * Calls sendChangedData with asynchronous semantics.
 809      *
 810      * The provided callback will be called when the reply to this call arrives or
 811      * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
 812      * or which type of error has occurred. In case of any error, ONLY the CallStatus
 813      * will have a defined value.
 814      * The std::future returned by this method will be fulfilled at arrival of the reply.
 815      * It will provide the same value for CallStatus as will be handed to the callback.
 816      */
 817     virtual std::future<CommonAPI::CallStatus> sendChangedDataAsync(const am_EarlyData_L& earlyData, SendChangedDataAsyncCallback callback);
 818
 819     /**
 820      * Calls updateGateway with synchronous semantics.
 821      *
 822      * All const parameters are input parameters to this method.
 823      * All non-const parameters will be filled with the returned values.
 824      * The CallStatus will be filled when the method returns and indicate either
 825      * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
 826      * will be set.
 827      * Synchronous calls are not supported (will block indefinitely) when mainloop integration is used.
 828      */
 829     virtual void updateGateway(const am_gatewayID_t& gatewayID, const am_ConnectionFormat_L& listSourceFormats, const am_ConnectionFormat_L& listSinkFormats, const am_Convertion_L& convertionMatrix, CommonAPI::CallStatus& callStatus, am_Error_e& error);
 830     /**
 831      * Calls updateGateway with asynchronous semantics.
 832      *
 833      * The provided callback will be called when the reply to this call arrives or
 834      * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
 835      * or which type of error has occurred. In case of any error, ONLY the CallStatus
 836      * will have a defined value.
 837      * The std::future returned by this method will be fulfilled at arrival of the reply.
 838      * It will provide the same value for CallStatus as will be handed to the callback.
 839      */
 840     virtual std::future<CommonAPI::CallStatus> updateGatewayAsync(const am_gatewayID_t& gatewayID, const am_ConnectionFormat_L& listSourceFormats, const am_ConnectionFormat_L& listSinkFormats, const am_Convertion_L& convertionMatrix, UpdateGatewayAsyncCallback callback);
 841
 842     /**
 843      * Calls updateSink with synchronous semantics.
 844      *
 845      * All const parameters are input parameters to this method.
 846      * All non-const parameters will be filled with the returned values.
 847      * The CallStatus will be filled when the method returns and indicate either
 848      * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
 849      * will be set.
 850      * Synchronous calls are not supported (will block indefinitely) when mainloop integration is used.
 851      */
 852     virtual void updateSink(const am_sinkID_t& sinkID, const am_sinkClass_t& sinkClassID, const am_SoundProperty_L& listSoundProperties, const am_ConnectionFormat_L& listConnectionFormats, const am_MainSoundProperty_L& listMainSoundProperties, CommonAPI::CallStatus& callStatus, am_Error_e& error);
 853     /**
 854      * Calls updateSink with asynchronous semantics.
 855      *
 856      * The provided callback will be called when the reply to this call arrives or
 857      * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
 858      * or which type of error has occurred. In case of any error, ONLY the CallStatus
 859      * will have a defined value.
 860      * The std::future returned by this method will be fulfilled at arrival of the reply.
 861      * It will provide the same value for CallStatus as will be handed to the callback.
 862      */
 863     virtual std::future<CommonAPI::CallStatus> updateSinkAsync(const am_sinkID_t& sinkID, const am_sinkClass_t& sinkClassID, const am_SoundProperty_L& listSoundProperties, const am_ConnectionFormat_L& listConnectionFormats, const am_MainSoundProperty_L& listMainSoundProperties, UpdateSinkAsyncCallback callback);
 864
 865     /**
 866      * Calls updateSource with synchronous semantics.
 867      *
 868      * All const parameters are input parameters to this method.
 869      * All non-const parameters will be filled with the returned values.
 870      * The CallStatus will be filled when the method returns and indicate either
 871      * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
 872      * will be set.
 873      * Synchronous calls are not supported (will block indefinitely) when mainloop integration is used.
 874      */
 875     virtual void updateSource(const am_sourceID_t& sourceID, const am_sourceClass_t& sourceClassID, const am_SoundProperty_L& listSoundProperties, const am_ConnectionFormat_L& listConnectionFormats, const am_MainSoundProperty_L& listMainSoundProperties, CommonAPI::CallStatus& callStatus, am_Error_e& error);
 876     /**
 877      * Calls updateSource with asynchronous semantics.
 878      *
 879      * The provided callback will be called when the reply to this call arrives or
 880      * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
 881      * or which type of error has occurred. In case of any error, ONLY the CallStatus
 882      * will have a defined value.
 883      * The std::future returned by this method will be fulfilled at arrival of the reply.
 884      * It will provide the same value for CallStatus as will be handed to the callback.
 885      */
 886     virtual std::future<CommonAPI::CallStatus> updateSourceAsync(const am_sourceID_t& sourceID, const am_sourceClass_t& sourceClassID, const am_SoundProperty_L& listSoundProperties, const am_ConnectionFormat_L& listConnectionFormats, const am_MainSoundProperty_L& listMainSoundProperties, UpdateSourceAsyncCallback callback);
 887
 888     /**
 889      * Calls ackSetVolumes with synchronous semantics.
 890      *
 891      * All const parameters are input parameters to this method.
 892      * The CallStatus will be filled when the method returns and indicate either
 893      * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
 894      * will be set.
 895      * Synchronous calls are not supported (will block indefinitely) when mainloop integration is used.
 896      */
 897     virtual void ackSetVolumes(const am_Handle_s& handle, const am_Volumes_L& listvolumes, const am_Error_e& error, CommonAPI::CallStatus& callStatus);
 898     /**
 899      * Calls ackSetVolumes with asynchronous semantics.
 900      *
 901      * The provided callback will be called when the reply to this call arrives or
 902      * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
 903      * or which type of error has occurred. In case of any error, ONLY the CallStatus
 904      * will have a defined value.
 905      * The std::future returned by this method will be fulfilled at arrival of the reply.
 906      * It will provide the same value for CallStatus as will be handed to the callback.
 907      */
 908     virtual std::future<CommonAPI::CallStatus> ackSetVolumesAsync(const am_Handle_s& handle, const am_Volumes_L& listvolumes, const am_Error_e& error, AckSetVolumesAsyncCallback callback);
 909
 910     /**
 911      * Calls ackSinkNotificationConfiguration with synchronous semantics.
 912      *
 913      * All const parameters are input parameters to this method.
 914      * The CallStatus will be filled when the method returns and indicate either
 915      * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
 916      * will be set.
 917      * Synchronous calls are not supported (will block indefinitely) when mainloop integration is used.
 918      */
 919     virtual void ackSinkNotificationConfiguration(const am_Handle_s& handle, const am_Error_e& error, CommonAPI::CallStatus& callStatus);
 920     /**
 921      * Calls ackSinkNotificationConfiguration with asynchronous semantics.
 922      *
 923      * The provided callback will be called when the reply to this call arrives or
 924      * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
 925      * or which type of error has occurred. In case of any error, ONLY the CallStatus
 926      * will have a defined value.
 927      * The std::future returned by this method will be fulfilled at arrival of the reply.
 928      * It will provide the same value for CallStatus as will be handed to the callback.
 929      */
 930     virtual std::future<CommonAPI::CallStatus> ackSinkNotificationConfigurationAsync(const am_Handle_s& handle, const am_Error_e& error, AckSinkNotificationConfigurationAsyncCallback callback);
 931
 932     /**
 933      * Calls ackSourceNotificationConfiguration with synchronous semantics.
 934      *
 935      * All const parameters are input parameters to this method.
 936      * The CallStatus will be filled when the method returns and indicate either
 937      * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
 938      * will be set.
 939      * Synchronous calls are not supported (will block indefinitely) when mainloop integration is used.
 940      */
 941     virtual void ackSourceNotificationConfiguration(const am_Handle_s& handle, const am_Error_e& error, CommonAPI::CallStatus& callStatus);
 942     /**
 943      * Calls ackSourceNotificationConfiguration with asynchronous semantics.
 944      *
 945      * The provided callback will be called when the reply to this call arrives or
 946      * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
 947      * or which type of error has occurred. In case of any error, ONLY the CallStatus
 948      * will have a defined value.
 949      * The std::future returned by this method will be fulfilled at arrival of the reply.
 950      * It will provide the same value for CallStatus as will be handed to the callback.
 951      */
 952     virtual std::future<CommonAPI::CallStatus> ackSourceNotificationConfigurationAsync(const am_Handle_s& handle, const am_Error_e& error, AckSourceNotificationConfigurationAsyncCallback callback);
 953
 954     /**
 955      * Calls hookSinkNotificationDataChange with synchronous semantics.
 956      *
 957      * All const parameters are input parameters to this method.
 958      * The CallStatus will be filled when the method returns and indicate either
 959      * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
 960      * will be set.
 961      * Synchronous calls are not supported (will block indefinitely) when mainloop integration is used.
 962      */
 963     virtual void hookSinkNotificationDataChange(const am_sinkID_t& sinkID, const am_NotificationPayload_s& payload, CommonAPI::CallStatus& callStatus);
 964     /**
 965      * Calls hookSinkNotificationDataChange with asynchronous semantics.
 966      *
 967      * The provided callback will be called when the reply to this call arrives or
 968      * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
 969      * or which type of error has occurred. In case of any error, ONLY the CallStatus
 970      * will have a defined value.
 971      * The std::future returned by this method will be fulfilled at arrival of the reply.
 972      * It will provide the same value for CallStatus as will be handed to the callback.
 973      */
 974     virtual std::future<CommonAPI::CallStatus> hookSinkNotificationDataChangeAsync(const am_sinkID_t& sinkID, const am_NotificationPayload_s& payload, HookSinkNotificationDataChangeAsyncCallback callback);
 975
 976     /**
 977      * Calls hookSourceNotificationDataChange with synchronous semantics.
 978      *
 979      * All const parameters are input parameters to this method.
 980      * The CallStatus will be filled when the method returns and indicate either
 981      * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
 982      * will be set.
 983      * Synchronous calls are not supported (will block indefinitely) when mainloop integration is used.
 984      */
 985     virtual void hookSourceNotificationDataChange(const am_sourceID_t& sourceID, const am_NotificationPayload_s& payload, CommonAPI::CallStatus& callStatus);
 986     /**
 987      * Calls hookSourceNotificationDataChange with asynchronous semantics.
 988      *
 989      * The provided callback will be called when the reply to this call arrives or
 990      * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
 991      * or which type of error has occurred. In case of any error, ONLY the CallStatus
 992      * will have a defined value.
 993      * The std::future returned by this method will be fulfilled at arrival of the reply.
 994      * It will provide the same value for CallStatus as will be handed to the callback.
 995      */
 996     virtual std::future<CommonAPI::CallStatus> hookSourceNotificationDataChangeAsync(const am_sourceID_t& sourceID, const am_NotificationPayload_s& payload, HookSourceNotificationDataChangeAsyncCallback callback);
 997
 998     /**
 999      * Calls confirmRoutingRundown with synchronous semantics.
1000      *
1001      * All const parameters are input parameters to this method.
1002      * The CallStatus will be filled when the method returns and indicate either
1003      * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus
1004      * will be set.
1005      * Synchronous calls are not supported (will block indefinitely) when mainloop integration is used.
1006      */
1007     virtual void confirmRoutingRundown(const std::string& domainName, CommonAPI::CallStatus& callStatus);
1008     /**
1009      * Calls confirmRoutingRundown with asynchronous semantics.
1010      *
1011      * The provided callback will be called when the reply to this call arrives or
1012      * an error occurs during the call. The CallStatus will indicate either "SUCCESS"
1013      * or which type of error has occurred. In case of any error, ONLY the CallStatus
1014      * will have a defined value.
1015      * The std::future returned by this method will be fulfilled at arrival of the reply.
1016      * It will provide the same value for CallStatus as will be handed to the callback.
1017      */
1018     virtual std::future<CommonAPI::CallStatus> confirmRoutingRundownAsync(const std::string& domainName, ConfirmRoutingRundownAsyncCallback callback);
1019
1020     /// Returns the CommonAPI address of the remote partner this proxy communicates with.
1021     virtual std::string getAddress() const;
1022
1023     /// Returns the domain of the remote partner this proxy communicates with.
1024     virtual const std::string& getDomain() const;
1025
1026     /// Returns the service ID of the remote partner this proxy communicates with.
1027     virtual const std::string& getServiceId() const;
1028
1029     /// Returns the instance ID of the remote partner this proxy communicates with.
1030     virtual const std::string& getInstanceId() const;
1031
1032     /// Returns true if the remote partner for this proxy is available.
1033     virtual bool isAvailable() const;
1034
1035     /**
1036      * Returns the wrapper class that is used to (de-)register for notifications about
1037      * the availability of the remote partner of this proxy.
1038      */
1039     virtual CommonAPI::ProxyStatusEvent& getProxyStatusEvent();
1040
1041     /**
1042      * Returns the wrapper class that is used to access version information of the remote
1043      * partner of this proxy.
1044      */
1045     virtual CommonAPI::InterfaceVersionAttribute& getInterfaceVersionAttribute();
1046
1047  private:
1048     std::shared_ptr<RoutingControlObserverProxyBase> delegate_;
1049 };
1050
1051 namespace RoutingControlObserverExtensions {
1052     template <template <typename > class _ExtensionType>
1053     class RoutingReadyAttributeExtension {
1054      public:
1055         typedef _ExtensionType<RoutingControlObserverProxyBase::RoutingReadyAttribute> extension_type;
1056
1057         static_assert(std::is_base_of<typename CommonAPI::AttributeExtension<RoutingControlObserverProxyBase::RoutingReadyAttribute>, extension_type>::value,
1058                       "Not CommonAPI Attribute Extension!");
1059
1060         RoutingReadyAttributeExtension(RoutingControlObserverProxyBase& proxy): attributeExtension_(proxy.getRoutingReadyAttribute()) {
1061         }
1062
1063         inline extension_type& getRoutingReadyAttributeExtension() {
1064             return attributeExtension_;
1065         }
1066
1067      private:
1068         extension_type attributeExtension_;
1069     };
1070
1071 } // namespace RoutingControlObserverExtensions
1072
1073 //
1074 // RoutingControlObserverProxy Implementation
1075 //
1076 template <typename ... _AttributeExtensions>
1077 RoutingControlObserverProxy<_AttributeExtensions...>::RoutingControlObserverProxy(std::shared_ptr<CommonAPI::Proxy> delegate):
1078         delegate_(std::dynamic_pointer_cast<RoutingControlObserverProxyBase>(delegate)),
1079         _AttributeExtensions(*(std::dynamic_pointer_cast<RoutingControlObserverProxyBase>(delegate)))... {
1080 }
1081
1082 template <typename ... _AttributeExtensions>
1083 RoutingControlObserverProxy<_AttributeExtensions...>::~RoutingControlObserverProxy() {
1084 }
1085
1086 template <typename ... _AttributeExtensions>
1087 void RoutingControlObserverProxy<_AttributeExtensions...>::ackConnect(const am_Handle_s& handle, const am_connectionID_t& connectionID, const am_Error_e& error, CommonAPI::CallStatus& callStatus) {
1088     delegate_->ackConnect(handle, connectionID, error, callStatus);
1089 }
1090
1091 template <typename ... _AttributeExtensions>
1092 std::future<CommonAPI::CallStatus> RoutingControlObserverProxy<_AttributeExtensions...>::ackConnectAsync(const am_Handle_s& handle, const am_connectionID_t& connectionID, const am_Error_e& error, AckConnectAsyncCallback callback) {
1093     return delegate_->ackConnectAsync(handle, connectionID, error, callback);
1094 }
1095
1096 template <typename ... _AttributeExtensions>
1097 void RoutingControlObserverProxy<_AttributeExtensions...>::ackDisconnect(const am_Handle_s& handle, const am_connectionID_t& connectionID, const am_Error_e& error, CommonAPI::CallStatus& callStatus) {
1098     delegate_->ackDisconnect(handle, connectionID, error, callStatus);
1099 }
1100
1101 template <typename ... _AttributeExtensions>
1102 std::future<CommonAPI::CallStatus> RoutingControlObserverProxy<_AttributeExtensions...>::ackDisconnectAsync(const am_Handle_s& handle, const am_connectionID_t& connectionID, const am_Error_e& error, AckDisconnectAsyncCallback callback) {
1103     return delegate_->ackDisconnectAsync(handle, connectionID, error, callback);
1104 }
1105
1106 template <typename ... _AttributeExtensions>
1107 void RoutingControlObserverProxy<_AttributeExtensions...>::ackSetSinkVolumeChange(const am_Handle_s& handle, const am_volume_t& volume, const am_Error_e& error, CommonAPI::CallStatus& callStatus) {
1108     delegate_->ackSetSinkVolumeChange(handle, volume, error, callStatus);
1109 }
1110
1111 template <typename ... _AttributeExtensions>
1112 std::future<CommonAPI::CallStatus> RoutingControlObserverProxy<_AttributeExtensions...>::ackSetSinkVolumeChangeAsync(const am_Handle_s& handle, const am_volume_t& volume, const am_Error_e& error, AckSetSinkVolumeChangeAsyncCallback callback) {
1113     return delegate_->ackSetSinkVolumeChangeAsync(handle, volume, error, callback);
1114 }
1115
1116 template <typename ... _AttributeExtensions>
1117 void RoutingControlObserverProxy<_AttributeExtensions...>::ackSetSourceVolumeChange(const am_Handle_s& handle, const am_volume_t& volume, const am_Error_e& error, CommonAPI::CallStatus& callStatus) {
1118     delegate_->ackSetSourceVolumeChange(handle, volume, error, callStatus);
1119 }
1120
1121 template <typename ... _AttributeExtensions>
1122 std::future<CommonAPI::CallStatus> RoutingControlObserverProxy<_AttributeExtensions...>::ackSetSourceVolumeChangeAsync(const am_Handle_s& handle, const am_volume_t& volume, const am_Error_e& error, AckSetSourceVolumeChangeAsyncCallback callback) {
1123     return delegate_->ackSetSourceVolumeChangeAsync(handle, volume, error, callback);
1124 }
1125
1126 template <typename ... _AttributeExtensions>
1127 void RoutingControlObserverProxy<_AttributeExtensions...>::ackSetSourceState(const am_Handle_s& handle, const am_Error_e& error, CommonAPI::CallStatus& callStatus) {
1128     delegate_->ackSetSourceState(handle, error, callStatus);
1129 }
1130
1131 template <typename ... _AttributeExtensions>
1132 std::future<CommonAPI::CallStatus> RoutingControlObserverProxy<_AttributeExtensions...>::ackSetSourceStateAsync(const am_Handle_s& handle, const am_Error_e& error, AckSetSourceStateAsyncCallback callback) {
1133     return delegate_->ackSetSourceStateAsync(handle, error, callback);
1134 }
1135
1136 template <typename ... _AttributeExtensions>
1137 void RoutingControlObserverProxy<_AttributeExtensions...>::ackSetSinkSoundProperties(const am_Handle_s& handle, const am_Error_e& error, CommonAPI::CallStatus& callStatus) {
1138     delegate_->ackSetSinkSoundProperties(handle, error, callStatus);
1139 }
1140
1141 template <typename ... _AttributeExtensions>
1142 std::future<CommonAPI::CallStatus> RoutingControlObserverProxy<_AttributeExtensions...>::ackSetSinkSoundPropertiesAsync(const am_Handle_s& handle, const am_Error_e& error, AckSetSinkSoundPropertiesAsyncCallback callback) {
1143     return delegate_->ackSetSinkSoundPropertiesAsync(handle, error, callback);
1144 }
1145
1146 template <typename ... _AttributeExtensions>
1147 void RoutingControlObserverProxy<_AttributeExtensions...>::ackSetSinkSoundProperty(const am_Handle_s& handle, const am_Error_e& error, CommonAPI::CallStatus& callStatus) {
1148     delegate_->ackSetSinkSoundProperty(handle, error, callStatus);
1149 }
1150
1151 template <typename ... _AttributeExtensions>
1152 std::future<CommonAPI::CallStatus> RoutingControlObserverProxy<_AttributeExtensions...>::ackSetSinkSoundPropertyAsync(const am_Handle_s& handle, const am_Error_e& error, AckSetSinkSoundPropertyAsyncCallback callback) {
1153     return delegate_->ackSetSinkSoundPropertyAsync(handle, error, callback);
1154 }
1155
1156 template <typename ... _AttributeExtensions>
1157 void RoutingControlObserverProxy<_AttributeExtensions...>::ackSetSourceSoundProperties(const am_Handle_s& handle, const am_Error_e& error, CommonAPI::CallStatus& callStatus) {
1158     delegate_->ackSetSourceSoundProperties(handle, error, callStatus);
1159 }
1160
1161 template <typename ... _AttributeExtensions>
1162 std::future<CommonAPI::CallStatus> RoutingControlObserverProxy<_AttributeExtensions...>::ackSetSourceSoundPropertiesAsync(const am_Handle_s& handle, const am_Error_e& error, AckSetSourceSoundPropertiesAsyncCallback callback) {
1163     return delegate_->ackSetSourceSoundPropertiesAsync(handle, error, callback);
1164 }
1165
1166 template <typename ... _AttributeExtensions>
1167 void RoutingControlObserverProxy<_AttributeExtensions...>::ackSetSourceSoundProperty(const am_Handle_s& handle, const am_Error_e& error, CommonAPI::CallStatus& callStatus) {
1168     delegate_->ackSetSourceSoundProperty(handle, error, callStatus);
1169 }
1170
1171 template <typename ... _AttributeExtensions>
1172 std::future<CommonAPI::CallStatus> RoutingControlObserverProxy<_AttributeExtensions...>::ackSetSourceSoundPropertyAsync(const am_Handle_s& handle, const am_Error_e& error, AckSetSourceSoundPropertyAsyncCallback callback) {
1173     return delegate_->ackSetSourceSoundPropertyAsync(handle, error, callback);
1174 }
1175
1176 template <typename ... _AttributeExtensions>
1177 void RoutingControlObserverProxy<_AttributeExtensions...>::ackCrossFading(const am_Handle_s& handle, const am_HotSink_e& hotSink, const am_Error_e& error, CommonAPI::CallStatus& callStatus) {
1178     delegate_->ackCrossFading(handle, hotSink, error, callStatus);
1179 }
1180
1181 template <typename ... _AttributeExtensions>
1182 std::future<CommonAPI::CallStatus> RoutingControlObserverProxy<_AttributeExtensions...>::ackCrossFadingAsync(const am_Handle_s& handle, const am_HotSink_e& hotSink, const am_Error_e& error, AckCrossFadingAsyncCallback callback) {
1183     return delegate_->ackCrossFadingAsync(handle, hotSink, error, callback);
1184 }
1185
1186 template <typename ... _AttributeExtensions>
1187 void RoutingControlObserverProxy<_AttributeExtensions...>::ackSourceVolumeTick(const am_Handle_s& handle, const am_sourceID_t& sourceID, const am_volume_t& volume, CommonAPI::CallStatus& callStatus) {
1188     delegate_->ackSourceVolumeTick(handle, sourceID, volume, callStatus);
1189 }
1190
1191 template <typename ... _AttributeExtensions>
1192 std::future<CommonAPI::CallStatus> RoutingControlObserverProxy<_AttributeExtensions...>::ackSourceVolumeTickAsync(const am_Handle_s& handle, const am_sourceID_t& sourceID, const am_volume_t& volume, AckSourceVolumeTickAsyncCallback callback) {
1193     return delegate_->ackSourceVolumeTickAsync(handle, sourceID, volume, callback);
1194 }
1195
1196 template <typename ... _AttributeExtensions>
1197 void RoutingControlObserverProxy<_AttributeExtensions...>::ackSinkVolumeTick(const am_Handle_s& handle, const am_sinkID_t& sinkID, const am_volume_t& volume, CommonAPI::CallStatus& callStatus) {
1198     delegate_->ackSinkVolumeTick(handle, sinkID, volume, callStatus);
1199 }
1200
1201 template <typename ... _AttributeExtensions>
1202 std::future<CommonAPI::CallStatus> RoutingControlObserverProxy<_AttributeExtensions...>::ackSinkVolumeTickAsync(const am_Handle_s& handle, const am_sinkID_t& sinkID, const am_volume_t& volume, AckSinkVolumeTickAsyncCallback callback) {
1203     return delegate_->ackSinkVolumeTickAsync(handle, sinkID, volume, callback);
1204 }
1205
1206 template <typename ... _AttributeExtensions>
1207 void RoutingControlObserverProxy<_AttributeExtensions...>::peekDomain(const std::string& name, CommonAPI::CallStatus& callStatus, am_domainID_t& domainID, am_Error_e& error) {
1208     delegate_->peekDomain(name, callStatus, domainID, error);
1209 }
1210
1211 template <typename ... _AttributeExtensions>
1212 std::future<CommonAPI::CallStatus> RoutingControlObserverProxy<_AttributeExtensions...>::peekDomainAsync(const std::string& name, PeekDomainAsyncCallback callback) {
1213     return delegate_->peekDomainAsync(name, callback);
1214 }
1215
1216 template <typename ... _AttributeExtensions>
1217 void RoutingControlObserverProxy<_AttributeExtensions...>::registerDomain(const am_Domain_s& domainData, const std::string& returnBusname, const std::string& returnInterface, CommonAPI::CallStatus& callStatus, am_domainID_t& domainID, am_Error_e& error) {
1218     delegate_->registerDomain(domainData, returnBusname, returnInterface, callStatus, domainID, error);
1219 }
1220
1221 template <typename ... _AttributeExtensions>
1222 std::future<CommonAPI::CallStatus> RoutingControlObserverProxy<_AttributeExtensions...>::registerDomainAsync(const am_Domain_s& domainData, const std::string& returnBusname, const std::string& returnInterface, RegisterDomainAsyncCallback callback) {
1223     return delegate_->registerDomainAsync(domainData, returnBusname, returnInterface, callback);
1224 }
1225
1226 template <typename ... _AttributeExtensions>
1227 void RoutingControlObserverProxy<_AttributeExtensions...>::deregisterDomain(const am_domainID_t& domainID, CommonAPI::CallStatus& callStatus, am_Error_e& error) {
1228     delegate_->deregisterDomain(domainID, callStatus, error);
1229 }
1230
1231 template <typename ... _AttributeExtensions>
1232 std::future<CommonAPI::CallStatus> RoutingControlObserverProxy<_AttributeExtensions...>::deregisterDomainAsync(const am_domainID_t& domainID, DeregisterDomainAsyncCallback callback) {
1233     return delegate_->deregisterDomainAsync(domainID, callback);
1234 }
1235
1236 template <typename ... _AttributeExtensions>
1237 void RoutingControlObserverProxy<_AttributeExtensions...>::registerGateway(const am_Gateway_s& gatewayData, CommonAPI::CallStatus& callStatus, am_gatewayID_t& gatewayID, am_Error_e& error) {
1238     delegate_->registerGateway(gatewayData, callStatus, gatewayID, error);
1239 }
1240
1241 template <typename ... _AttributeExtensions>
1242 std::future<CommonAPI::CallStatus> RoutingControlObserverProxy<_AttributeExtensions...>::registerGatewayAsync(const am_Gateway_s& gatewayData, RegisterGatewayAsyncCallback callback) {
1243     return delegate_->registerGatewayAsync(gatewayData, callback);
1244 }
1245
1246 template <typename ... _AttributeExtensions>
1247 void RoutingControlObserverProxy<_AttributeExtensions...>::deregisterGateway(const am_gatewayID_t& gatewayID, CommonAPI::CallStatus& callStatus, am_Error_e& error) {
1248     delegate_->deregisterGateway(gatewayID, callStatus, error);
1249 }
1250
1251 template <typename ... _AttributeExtensions>
1252 std::future<CommonAPI::CallStatus> RoutingControlObserverProxy<_AttributeExtensions...>::deregisterGatewayAsync(const am_gatewayID_t& gatewayID, DeregisterGatewayAsyncCallback callback) {
1253     return delegate_->deregisterGatewayAsync(gatewayID, callback);
1254 }
1255
1256 template <typename ... _AttributeExtensions>
1257 void RoutingControlObserverProxy<_AttributeExtensions...>::peekSink(const std::string& name, CommonAPI::CallStatus& callStatus, am_sinkID_t& sinkID, am_Error_e& error) {
1258     delegate_->peekSink(name, callStatus, sinkID, error);
1259 }
1260
1261 template <typename ... _AttributeExtensions>
1262 std::future<CommonAPI::CallStatus> RoutingControlObserverProxy<_AttributeExtensions...>::peekSinkAsync(const std::string& name, PeekSinkAsyncCallback callback) {
1263     return delegate_->peekSinkAsync(name, callback);
1264 }
1265
1266 template <typename ... _AttributeExtensions>
1267 void RoutingControlObserverProxy<_AttributeExtensions...>::registerSink(const am_Sink_s& sinkData, CommonAPI::CallStatus& callStatus, am_sinkID_t& sinkID, am_Error_e& error) {
1268     delegate_->registerSink(sinkData, callStatus, sinkID, error);
1269 }
1270
1271 template <typename ... _AttributeExtensions>
1272 std::future<CommonAPI::CallStatus> RoutingControlObserverProxy<_AttributeExtensions...>::registerSinkAsync(const am_Sink_s& sinkData, RegisterSinkAsyncCallback callback) {
1273     return delegate_->registerSinkAsync(sinkData, callback);
1274 }
1275
1276 template <typename ... _AttributeExtensions>
1277 void RoutingControlObserverProxy<_AttributeExtensions...>::deregisterSink(const am_sinkID_t& sinkID, CommonAPI::CallStatus& callStatus, am_Error_e& error) {
1278     delegate_->deregisterSink(sinkID, callStatus, error);
1279 }
1280
1281 template <typename ... _AttributeExtensions>
1282 std::future<CommonAPI::CallStatus> RoutingControlObserverProxy<_AttributeExtensions...>::deregisterSinkAsync(const am_sinkID_t& sinkID, DeregisterSinkAsyncCallback callback) {
1283     return delegate_->deregisterSinkAsync(sinkID, callback);
1284 }
1285
1286 template <typename ... _AttributeExtensions>
1287 void RoutingControlObserverProxy<_AttributeExtensions...>::peekSource(const std::string& name, CommonAPI::CallStatus& callStatus, am_sourceID_t& sourceID, am_Error_e& error) {
1288     delegate_->peekSource(name, callStatus, sourceID, error);
1289 }
1290
1291 template <typename ... _AttributeExtensions>
1292 std::future<CommonAPI::CallStatus> RoutingControlObserverProxy<_AttributeExtensions...>::peekSourceAsync(const std::string& name, PeekSourceAsyncCallback callback) {
1293     return delegate_->peekSourceAsync(name, callback);
1294 }
1295
1296 template <typename ... _AttributeExtensions>
1297 void RoutingControlObserverProxy<_AttributeExtensions...>::registerSource(const am_Source_s& sourceData, CommonAPI::CallStatus& callStatus, am_sourceID_t& sourceID, am_Error_e& error) {
1298     delegate_->registerSource(sourceData, callStatus, sourceID, error);
1299 }
1300
1301 template <typename ... _AttributeExtensions>
1302 std::future<CommonAPI::CallStatus> RoutingControlObserverProxy<_AttributeExtensions...>::registerSourceAsync(const am_Source_s& sourceData, RegisterSourceAsyncCallback callback) {
1303     return delegate_->registerSourceAsync(sourceData, callback);
1304 }
1305
1306 template <typename ... _AttributeExtensions>
1307 void RoutingControlObserverProxy<_AttributeExtensions...>::deregisterSource(const am_sourceID_t& sourceID, CommonAPI::CallStatus& callStatus, am_Error_e& error) {
1308     delegate_->deregisterSource(sourceID, callStatus, error);
1309 }
1310
1311 template <typename ... _AttributeExtensions>
1312 std::future<CommonAPI::CallStatus> RoutingControlObserverProxy<_AttributeExtensions...>::deregisterSourceAsync(const am_sourceID_t& sourceID, DeregisterSourceAsyncCallback callback) {
1313     return delegate_->deregisterSourceAsync(sourceID, callback);
1314 }
1315
1316 template <typename ... _AttributeExtensions>
1317 void RoutingControlObserverProxy<_AttributeExtensions...>::registerCrossfader(const am_Crossfader_s& crossfaderData, CommonAPI::CallStatus& callStatus, am_crossfaderID_t& crossfaderID, am_Error_e& error) {
1318     delegate_->registerCrossfader(crossfaderData, callStatus, crossfaderID, error);
1319 }
1320
1321 template <typename ... _AttributeExtensions>
1322 std::future<CommonAPI::CallStatus> RoutingControlObserverProxy<_AttributeExtensions...>::registerCrossfaderAsync(const am_Crossfader_s& crossfaderData, RegisterCrossfaderAsyncCallback callback) {
1323     return delegate_->registerCrossfaderAsync(crossfaderData, callback);
1324 }
1325
1326 template <typename ... _AttributeExtensions>
1327 void RoutingControlObserverProxy<_AttributeExtensions...>::deregisterCrossfader(const am_crossfaderID_t& crossfaderID, CommonAPI::CallStatus& callStatus, am_Error_e& error) {
1328     delegate_->deregisterCrossfader(crossfaderID, callStatus, error);
1329 }
1330
1331 template <typename ... _AttributeExtensions>
1332 std::future<CommonAPI::CallStatus> RoutingControlObserverProxy<_AttributeExtensions...>::deregisterCrossfaderAsync(const am_crossfaderID_t& crossfaderID, DeregisterCrossfaderAsyncCallback callback) {
1333     return delegate_->deregisterCrossfaderAsync(crossfaderID, callback);
1334 }
1335
1336 template <typename ... _AttributeExtensions>
1337 void RoutingControlObserverProxy<_AttributeExtensions...>::peekSourceClassID(const std::string& name, CommonAPI::CallStatus& callStatus, am_sourceClass_t& sourceClassID, am_Error_e& error) {
1338     delegate_->peekSourceClassID(name, callStatus, sourceClassID, error);
1339 }
1340
1341 template <typename ... _AttributeExtensions>
1342 std::future<CommonAPI::CallStatus> RoutingControlObserverProxy<_AttributeExtensions...>::peekSourceClassIDAsync(const std::string& name, PeekSourceClassIDAsyncCallback callback) {
1343     return delegate_->peekSourceClassIDAsync(name, callback);
1344 }
1345
1346 template <typename ... _AttributeExtensions>
1347 void RoutingControlObserverProxy<_AttributeExtensions...>::peekSinkClassID(const std::string& name, CommonAPI::CallStatus& callStatus, am_sinkClass_t& sinkClassID, am_Error_e& error) {
1348     delegate_->peekSinkClassID(name, callStatus, sinkClassID, error);
1349 }
1350
1351 template <typename ... _AttributeExtensions>
1352 std::future<CommonAPI::CallStatus> RoutingControlObserverProxy<_AttributeExtensions...>::peekSinkClassIDAsync(const std::string& name, PeekSinkClassIDAsyncCallback callback) {
1353     return delegate_->peekSinkClassIDAsync(name, callback);
1354 }
1355
1356 template <typename ... _AttributeExtensions>
1357 void RoutingControlObserverProxy<_AttributeExtensions...>::hookInterruptStatusChange(const am_sourceID_t& sourceID, const am_InterruptState_e& interruptState, CommonAPI::CallStatus& callStatus) {
1358     delegate_->hookInterruptStatusChange(sourceID, interruptState, callStatus);
1359 }
1360
1361 template <typename ... _AttributeExtensions>
1362 std::future<CommonAPI::CallStatus> RoutingControlObserverProxy<_AttributeExtensions...>::hookInterruptStatusChangeAsync(const am_sourceID_t& sourceID, const am_InterruptState_e& interruptState, HookInterruptStatusChangeAsyncCallback callback) {
1363     return delegate_->hookInterruptStatusChangeAsync(sourceID, interruptState, callback);
1364 }
1365
1366 template <typename ... _AttributeExtensions>
1367 void RoutingControlObserverProxy<_AttributeExtensions...>::hookDomainRegistrationComplete(const am_domainID_t& domainID, CommonAPI::CallStatus& callStatus) {
1368     delegate_->hookDomainRegistrationComplete(domainID, callStatus);
1369 }
1370
1371 template <typename ... _AttributeExtensions>
1372 std::future<CommonAPI::CallStatus> RoutingControlObserverProxy<_AttributeExtensions...>::hookDomainRegistrationCompleteAsync(const am_domainID_t& domainID, HookDomainRegistrationCompleteAsyncCallback callback) {
1373     return delegate_->hookDomainRegistrationCompleteAsync(domainID, callback);
1374 }
1375
1376 template <typename ... _AttributeExtensions>
1377 void RoutingControlObserverProxy<_AttributeExtensions...>::hookSinkAvailablityStatusChange(const am_sinkID_t& sinkID, const am_Availability_s& availability, CommonAPI::CallStatus& callStatus) {
1378     delegate_->hookSinkAvailablityStatusChange(sinkID, availability, callStatus);
1379 }
1380
1381 template <typename ... _AttributeExtensions>
1382 std::future<CommonAPI::CallStatus> RoutingControlObserverProxy<_AttributeExtensions...>::hookSinkAvailablityStatusChangeAsync(const am_sinkID_t& sinkID, const am_Availability_s& availability, HookSinkAvailablityStatusChangeAsyncCallback callback) {
1383     return delegate_->hookSinkAvailablityStatusChangeAsync(sinkID, availability, callback);
1384 }
1385
1386 template <typename ... _AttributeExtensions>
1387 void RoutingControlObserverProxy<_AttributeExtensions...>::hookSourceAvailablityStatusChange(const am_sourceID_t& sourceID, const am_Availability_s& availability, CommonAPI::CallStatus& callStatus) {
1388     delegate_->hookSourceAvailablityStatusChange(sourceID, availability, callStatus);
1389 }
1390
1391 template <typename ... _AttributeExtensions>
1392 std::future<CommonAPI::CallStatus> RoutingControlObserverProxy<_AttributeExtensions...>::hookSourceAvailablityStatusChangeAsync(const am_sourceID_t& sourceID, const am_Availability_s& availability, HookSourceAvailablityStatusChangeAsyncCallback callback) {
1393     return delegate_->hookSourceAvailablityStatusChangeAsync(sourceID, availability, callback);
1394 }
1395
1396 template <typename ... _AttributeExtensions>
1397 void RoutingControlObserverProxy<_AttributeExtensions...>::hookDomainStateChange(const am_domainID_t& domainID, const am_DomainState_e& domainState, CommonAPI::CallStatus& callStatus) {
1398     delegate_->hookDomainStateChange(domainID, domainState, callStatus);
1399 }
1400
1401 template <typename ... _AttributeExtensions>
1402 std::future<CommonAPI::CallStatus> RoutingControlObserverProxy<_AttributeExtensions...>::hookDomainStateChangeAsync(const am_domainID_t& domainID, const am_DomainState_e& domainState, HookDomainStateChangeAsyncCallback callback) {
1403     return delegate_->hookDomainStateChangeAsync(domainID, domainState, callback);
1404 }
1405
1406 template <typename ... _AttributeExtensions>
1407 void RoutingControlObserverProxy<_AttributeExtensions...>::hookTimingInformationChanged(const am_connectionID_t& connectionID, const am_timeSync_t& delay, CommonAPI::CallStatus& callStatus) {
1408     delegate_->hookTimingInformationChanged(connectionID, delay, callStatus);
1409 }
1410
1411 template <typename ... _AttributeExtensions>
1412 std::future<CommonAPI::CallStatus> RoutingControlObserverProxy<_AttributeExtensions...>::hookTimingInformationChangedAsync(const am_connectionID_t& connectionID, const am_timeSync_t& delay, HookTimingInformationChangedAsyncCallback callback) {
1413     return delegate_->hookTimingInformationChangedAsync(connectionID, delay, callback);
1414 }
1415
1416 template <typename ... _AttributeExtensions>
1417 void RoutingControlObserverProxy<_AttributeExtensions...>::sendChangedData(const am_EarlyData_L& earlyData, CommonAPI::CallStatus& callStatus) {
1418     delegate_->sendChangedData(earlyData, callStatus);
1419 }
1420
1421 template <typename ... _AttributeExtensions>
1422 std::future<CommonAPI::CallStatus> RoutingControlObserverProxy<_AttributeExtensions...>::sendChangedDataAsync(const am_EarlyData_L& earlyData, SendChangedDataAsyncCallback callback) {
1423     return delegate_->sendChangedDataAsync(earlyData, callback);
1424 }
1425
1426 template <typename ... _AttributeExtensions>
1427 void RoutingControlObserverProxy<_AttributeExtensions...>::updateGateway(const am_gatewayID_t& gatewayID, const am_ConnectionFormat_L& listSourceFormats, const am_ConnectionFormat_L& listSinkFormats, const am_Convertion_L& convertionMatrix, CommonAPI::CallStatus& callStatus, am_Error_e& error) {
1428     delegate_->updateGateway(gatewayID, listSourceFormats, listSinkFormats, convertionMatrix, callStatus, error);
1429 }
1430
1431 template <typename ... _AttributeExtensions>
1432 std::future<CommonAPI::CallStatus> RoutingControlObserverProxy<_AttributeExtensions...>::updateGatewayAsync(const am_gatewayID_t& gatewayID, const am_ConnectionFormat_L& listSourceFormats, const am_ConnectionFormat_L& listSinkFormats, const am_Convertion_L& convertionMatrix, UpdateGatewayAsyncCallback callback) {
1433     return delegate_->updateGatewayAsync(gatewayID, listSourceFormats, listSinkFormats, convertionMatrix, callback);
1434 }
1435
1436 template <typename ... _AttributeExtensions>
1437 void RoutingControlObserverProxy<_AttributeExtensions...>::updateSink(const am_sinkID_t& sinkID, const am_sinkClass_t& sinkClassID, const am_SoundProperty_L& listSoundProperties, const am_ConnectionFormat_L& listConnectionFormats, const am_MainSoundProperty_L& listMainSoundProperties, CommonAPI::CallStatus& callStatus, am_Error_e& error) {
1438     delegate_->updateSink(sinkID, sinkClassID, listSoundProperties, listConnectionFormats, listMainSoundProperties, callStatus, error);
1439 }
1440
1441 template <typename ... _AttributeExtensions>
1442 std::future<CommonAPI::CallStatus> RoutingControlObserverProxy<_AttributeExtensions...>::updateSinkAsync(const am_sinkID_t& sinkID, const am_sinkClass_t& sinkClassID, const am_SoundProperty_L& listSoundProperties, const am_ConnectionFormat_L& listConnectionFormats, const am_MainSoundProperty_L& listMainSoundProperties, UpdateSinkAsyncCallback callback) {
1443     return delegate_->updateSinkAsync(sinkID, sinkClassID, listSoundProperties, listConnectionFormats, listMainSoundProperties, callback);
1444 }
1445
1446 template <typename ... _AttributeExtensions>
1447 void RoutingControlObserverProxy<_AttributeExtensions...>::updateSource(const am_sourceID_t& sourceID, const am_sourceClass_t& sourceClassID, const am_SoundProperty_L& listSoundProperties, const am_ConnectionFormat_L& listConnectionFormats, const am_MainSoundProperty_L& listMainSoundProperties, CommonAPI::CallStatus& callStatus, am_Error_e& error) {
1448     delegate_->updateSource(sourceID, sourceClassID, listSoundProperties, listConnectionFormats, listMainSoundProperties, callStatus, error);
1449 }
1450
1451 template <typename ... _AttributeExtensions>
1452 std::future<CommonAPI::CallStatus> RoutingControlObserverProxy<_AttributeExtensions...>::updateSourceAsync(const am_sourceID_t& sourceID, const am_sourceClass_t& sourceClassID, const am_SoundProperty_L& listSoundProperties, const am_ConnectionFormat_L& listConnectionFormats, const am_MainSoundProperty_L& listMainSoundProperties, UpdateSourceAsyncCallback callback) {
1453     return delegate_->updateSourceAsync(sourceID, sourceClassID, listSoundProperties, listConnectionFormats, listMainSoundProperties, callback);
1454 }
1455
1456 template <typename ... _AttributeExtensions>
1457 void RoutingControlObserverProxy<_AttributeExtensions...>::ackSetVolumes(const am_Handle_s& handle, const am_Volumes_L& listvolumes, const am_Error_e& error, CommonAPI::CallStatus& callStatus) {
1458     delegate_->ackSetVolumes(handle, listvolumes, error, callStatus);
1459 }
1460
1461 template <typename ... _AttributeExtensions>
1462 std::future<CommonAPI::CallStatus> RoutingControlObserverProxy<_AttributeExtensions...>::ackSetVolumesAsync(const am_Handle_s& handle, const am_Volumes_L& listvolumes, const am_Error_e& error, AckSetVolumesAsyncCallback callback) {
1463     return delegate_->ackSetVolumesAsync(handle, listvolumes, error, callback);
1464 }
1465
1466 template <typename ... _AttributeExtensions>
1467 void RoutingControlObserverProxy<_AttributeExtensions...>::ackSinkNotificationConfiguration(const am_Handle_s& handle, const am_Error_e& error, CommonAPI::CallStatus& callStatus) {
1468     delegate_->ackSinkNotificationConfiguration(handle, error, callStatus);
1469 }
1470
1471 template <typename ... _AttributeExtensions>
1472 std::future<CommonAPI::CallStatus> RoutingControlObserverProxy<_AttributeExtensions...>::ackSinkNotificationConfigurationAsync(const am_Handle_s& handle, const am_Error_e& error, AckSinkNotificationConfigurationAsyncCallback callback) {
1473     return delegate_->ackSinkNotificationConfigurationAsync(handle, error, callback);
1474 }
1475
1476 template <typename ... _AttributeExtensions>
1477 void RoutingControlObserverProxy<_AttributeExtensions...>::ackSourceNotificationConfiguration(const am_Handle_s& handle, const am_Error_e& error, CommonAPI::CallStatus& callStatus) {
1478     delegate_->ackSourceNotificationConfiguration(handle, error, callStatus);
1479 }
1480
1481 template <typename ... _AttributeExtensions>
1482 std::future<CommonAPI::CallStatus> RoutingControlObserverProxy<_AttributeExtensions...>::ackSourceNotificationConfigurationAsync(const am_Handle_s& handle, const am_Error_e& error, AckSourceNotificationConfigurationAsyncCallback callback) {
1483     return delegate_->ackSourceNotificationConfigurationAsync(handle, error, callback);
1484 }
1485
1486 template <typename ... _AttributeExtensions>
1487 void RoutingControlObserverProxy<_AttributeExtensions...>::hookSinkNotificationDataChange(const am_sinkID_t& sinkID, const am_NotificationPayload_s& payload, CommonAPI::CallStatus& callStatus) {
1488     delegate_->hookSinkNotificationDataChange(sinkID, payload, callStatus);
1489 }
1490
1491 template <typename ... _AttributeExtensions>
1492 std::future<CommonAPI::CallStatus> RoutingControlObserverProxy<_AttributeExtensions...>::hookSinkNotificationDataChangeAsync(const am_sinkID_t& sinkID, const am_NotificationPayload_s& payload, HookSinkNotificationDataChangeAsyncCallback callback) {
1493     return delegate_->hookSinkNotificationDataChangeAsync(sinkID, payload, callback);
1494 }
1495
1496 template <typename ... _AttributeExtensions>
1497 void RoutingControlObserverProxy<_AttributeExtensions...>::hookSourceNotificationDataChange(const am_sourceID_t& sourceID, const am_NotificationPayload_s& payload, CommonAPI::CallStatus& callStatus) {
1498     delegate_->hookSourceNotificationDataChange(sourceID, payload, callStatus);
1499 }
1500
1501 template <typename ... _AttributeExtensions>
1502 std::future<CommonAPI::CallStatus> RoutingControlObserverProxy<_AttributeExtensions...>::hookSourceNotificationDataChangeAsync(const am_sourceID_t& sourceID, const am_NotificationPayload_s& payload, HookSourceNotificationDataChangeAsyncCallback callback) {
1503     return delegate_->hookSourceNotificationDataChangeAsync(sourceID, payload, callback);
1504 }
1505
1506 template <typename ... _AttributeExtensions>
1507 void RoutingControlObserverProxy<_AttributeExtensions...>::confirmRoutingRundown(const std::string& domainName, CommonAPI::CallStatus& callStatus) {
1508     delegate_->confirmRoutingRundown(domainName, callStatus);
1509 }
1510
1511 template <typename ... _AttributeExtensions>
1512 std::future<CommonAPI::CallStatus> RoutingControlObserverProxy<_AttributeExtensions...>::confirmRoutingRundownAsync(const std::string& domainName, ConfirmRoutingRundownAsyncCallback callback) {
1513     return delegate_->confirmRoutingRundownAsync(domainName, callback);
1514 }
1515
1516
1517 template <typename ... _AttributeExtensions>
1518 std::string RoutingControlObserverProxy<_AttributeExtensions...>::getAddress() const {
1519     return delegate_->getAddress();
1520 }
1521
1522 template <typename ... _AttributeExtensions>
1523 const std::string& RoutingControlObserverProxy<_AttributeExtensions...>::getDomain() const {
1524     return delegate_->getDomain();
1525 }
1526
1527 template <typename ... _AttributeExtensions>
1528 const std::string& RoutingControlObserverProxy<_AttributeExtensions...>::getServiceId() const {
1529     return delegate_->getServiceId();
1530 }
1531
1532 template <typename ... _AttributeExtensions>
1533 const std::string& RoutingControlObserverProxy<_AttributeExtensions...>::getInstanceId() const {
1534     return delegate_->getInstanceId();
1535 }
1536
1537 template <typename ... _AttributeExtensions>
1538 bool RoutingControlObserverProxy<_AttributeExtensions...>::isAvailable() const {
1539     return delegate_->isAvailable();
1540 }
1541
1542 template <typename ... _AttributeExtensions>
1543 CommonAPI::ProxyStatusEvent& RoutingControlObserverProxy<_AttributeExtensions...>::getProxyStatusEvent() {
1544     return delegate_->getProxyStatusEvent();
1545 }
1546
1547 template <typename ... _AttributeExtensions>
1548 CommonAPI::InterfaceVersionAttribute& RoutingControlObserverProxy<_AttributeExtensions...>::getInterfaceVersionAttribute() {
1549     return delegate_->getInterfaceVersionAttribute();
1550 }
1551
1552 } // namespace am
1553 } // namespace genivi
1554 } // namespace org
1555
1556 namespace CommonAPI {
1557 template<template<typename > class _AttributeExtension>
1558 struct DefaultAttributeProxyFactoryHelper<org::genivi::am::RoutingControlObserverProxy,
1559     _AttributeExtension> {
1560     typedef typename org::genivi::am::RoutingControlObserverProxy<
1561             org::genivi::am::RoutingControlObserverExtensions::RoutingReadyAttributeExtension<_AttributeExtension>
1562     > class_t;
1563 };
1564 }
1565
1566
1567 #endif // ORG_GENIVI_AM_Routing_Control_Observer_PROXY_H_