text: /**
   * Autogenerated by Thrift Compiler (0.13.0)
   *
   * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
   *  @generated
   */
  #ifndef MSynchronizableScene_H
  #define MSynchronizableScene_H
  
  #include <thrift/TDispatchProcessor.h>
  #include <thrift/async/TConcurrentClientSyncInfo.h>
  #include <memory>
  #include "services_types.h"
  #include "MMIServiceBase.h"
  
  namespace MMIStandard {
  
  #ifdef _MSC_VER
    #pragma warning( push )
    #pragma warning (disable : 4250 ) //inheriting methods via dominance 
  #endif
  
  class MSynchronizableSceneIf : virtual public MMIServiceBaseIf {
   public:
    virtual ~MSynchronizableSceneIf() {}
    virtual void ApplyUpdates( ::MMIStandard::MBoolResponse& _return, const  ::MMIStandard::MSceneUpdate& sceneUpdates) = 0;
    virtual void ApplyManipulations( ::MMIStandard::MBoolResponse& _return, const std::vector< ::MMIStandard::MSceneManipulation> & sceneManipulations) = 0;
  };
  
  class MSynchronizableSceneIfFactory : virtual public MMIServiceBaseIfFactory {
   public:
    typedef MSynchronizableSceneIf Handler;
  
    virtual ~MSynchronizableSceneIfFactory() {}
  
    virtual MSynchronizableSceneIf* getHandler(const ::apache::thrift::TConnectionInfo& connInfo) = 0;
    virtual void releaseHandler(MMIServiceBaseIf* /* handler */) = 0;
  };
  
  class MSynchronizableSceneIfSingletonFactory : virtual public MSynchronizableSceneIfFactory {
   public:
    MSynchronizableSceneIfSingletonFactory(const ::std::shared_ptr<MSynchronizableSceneIf>& iface) : iface_(iface) {}
    virtual ~MSynchronizableSceneIfSingletonFactory() {}
  
    virtual MSynchronizableSceneIf* getHandler(const ::apache::thrift::TConnectionInfo&) {
      return iface_.get();
    }
    virtual void releaseHandler(MMIServiceBaseIf* /* handler */) {}
  
   protected:
    ::std::shared_ptr<MSynchronizableSceneIf> iface_;
  };
  
  class MSynchronizableSceneNull : virtual public MSynchronizableSceneIf , virtual public MMIServiceBaseNull {
   public:
    virtual ~MSynchronizableSceneNull() {}
    void ApplyUpdates( ::MMIStandard::MBoolResponse& /* _return */, const  ::MMIStandard::MSceneUpdate& /* sceneUpdates */) {
      return;
    }
    void ApplyManipulations( ::MMIStandard::MBoolResponse& /* _return */, const std::vector< ::MMIStandard::MSceneManipulation> & /* sceneManipulations */) {
      return;
    }
  };
  
  typedef struct _MSynchronizableScene_ApplyUpdates_args__isset {
    _MSynchronizableScene_ApplyUpdates_args__isset() : sceneUpdates(false) {}
    bool sceneUpdates :1;
  } _MSynchronizableScene_ApplyUpdates_args__isset;
  
  class MSynchronizableScene_ApplyUpdates_args {
   public:
  
    MSynchronizableScene_ApplyUpdates_args(const MSynchronizableScene_ApplyUpdates_args&);
    MSynchronizableScene_ApplyUpdates_args& operator=(const MSynchronizableScene_ApplyUpdates_args&);
    MSynchronizableScene_ApplyUpdates_args() {
    }
  
    virtual ~MSynchronizableScene_ApplyUpdates_args() noexcept;
     ::MMIStandard::MSceneUpdate sceneUpdates;
  
    _MSynchronizableScene_ApplyUpdates_args__isset __isset;
  
    void __set_sceneUpdates(const  ::MMIStandard::MSceneUpdate& val);
  
    bool operator == (const MSynchronizableScene_ApplyUpdates_args & rhs) const
    {
      if (!(sceneUpdates == rhs.sceneUpdates))
        return false;
      return true;
    }
    bool operator != (const MSynchronizableScene_ApplyUpdates_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const MSynchronizableScene_ApplyUpdates_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class MSynchronizableScene_ApplyUpdates_pargs {
   public:
  
  
    virtual ~MSynchronizableScene_ApplyUpdates_pargs() noexcept;
    const  ::MMIStandard::MSceneUpdate* sceneUpdates;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _MSynchronizableScene_ApplyUpdates_result__isset {
    _MSynchronizableScene_ApplyUpdates_result__isset() : success(false) {}
    bool success :1;
  } _MSynchronizableScene_ApplyUpdates_result__isset;
  
  class MSynchronizableScene_ApplyUpdates_result {
   public:
  
    MSynchronizableScene_ApplyUpdates_result(const MSynchronizableScene_ApplyUpdates_result&);
    MSynchronizableScene_ApplyUpdates_result& operator=(const MSynchronizableScene_ApplyUpdates_result&);
    MSynchronizableScene_ApplyUpdates_result() {
    }
  
    virtual ~MSynchronizableScene_ApplyUpdates_result() noexcept;
     ::MMIStandard::MBoolResponse success;
  
    _MSynchronizableScene_ApplyUpdates_result__isset __isset;
  
    void __set_success(const  ::MMIStandard::MBoolResponse& val);
  
    bool operator == (const MSynchronizableScene_ApplyUpdates_result & rhs) const
    {
      if (!(success == rhs.success))
        return false;
      return true;
    }
    bool operator != (const MSynchronizableScene_ApplyUpdates_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const MSynchronizableScene_ApplyUpdates_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _MSynchronizableScene_ApplyUpdates_presult__isset {
    _MSynchronizableScene_ApplyUpdates_presult__isset() : success(false) {}
    bool success :1;
  } _MSynchronizableScene_ApplyUpdates_presult__isset;
  
  class MSynchronizableScene_ApplyUpdates_presult {
   public:
  
  
    virtual ~MSynchronizableScene_ApplyUpdates_presult() noexcept;
     ::MMIStandard::MBoolResponse* success;
  
    _MSynchronizableScene_ApplyUpdates_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _MSynchronizableScene_ApplyManipulations_args__isset {
    _MSynchronizableScene_ApplyManipulations_args__isset() : sceneManipulations(false) {}
    bool sceneManipulations :1;
  } _MSynchronizableScene_ApplyManipulations_args__isset;
  
  class MSynchronizableScene_ApplyManipulations_args {
   public:
  
    MSynchronizableScene_ApplyManipulations_args(const MSynchronizableScene_ApplyManipulations_args&);
    MSynchronizableScene_ApplyManipulations_args& operator=(const MSynchronizableScene_ApplyManipulations_args&);
    MSynchronizableScene_ApplyManipulations_args() {
    }
  
    virtual ~MSynchronizableScene_ApplyManipulations_args() noexcept;
    std::vector< ::MMIStandard::MSceneManipulation>  sceneManipulations;
  
    _MSynchronizableScene_ApplyManipulations_args__isset __isset;
  
    void __set_sceneManipulations(const std::vector< ::MMIStandard::MSceneManipulation> & val);
  
    bool operator == (const MSynchronizableScene_ApplyManipulations_args & rhs) const
    {
      if (!(sceneManipulations == rhs.sceneManipulations))
        return false;
      return true;
    }
    bool operator != (const MSynchronizableScene_ApplyManipulations_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const MSynchronizableScene_ApplyManipulations_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class MSynchronizableScene_ApplyManipulations_pargs {
   public:
  
  
    virtual ~MSynchronizableScene_ApplyManipulations_pargs() noexcept;
    const std::vector< ::MMIStandard::MSceneManipulation> * sceneManipulations;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _MSynchronizableScene_ApplyManipulations_result__isset {
    _MSynchronizableScene_ApplyManipulations_result__isset() : success(false) {}
    bool success :1;
  } _MSynchronizableScene_ApplyManipulations_result__isset;
  
  class MSynchronizableScene_ApplyManipulations_result {
   public:
  
    MSynchronizableScene_ApplyManipulations_result(const MSynchronizableScene_ApplyManipulations_result&);
    MSynchronizableScene_ApplyManipulations_result& operator=(const MSynchronizableScene_ApplyManipulations_result&);
    MSynchronizableScene_ApplyManipulations_result() {
    }
  
    virtual ~MSynchronizableScene_ApplyManipulations_result() noexcept;
     ::MMIStandard::MBoolResponse success;
  
    _MSynchronizableScene_ApplyManipulations_result__isset __isset;
  
    void __set_success(const  ::MMIStandard::MBoolResponse& val);
  
    bool operator == (const MSynchronizableScene_ApplyManipulations_result & rhs) const
    {
      if (!(success == rhs.success))
        return false;
      return true;
    }
    bool operator != (const MSynchronizableScene_ApplyManipulations_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const MSynchronizableScene_ApplyManipulations_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _MSynchronizableScene_ApplyManipulations_presult__isset {
    _MSynchronizableScene_ApplyManipulations_presult__isset() : success(false) {}
    bool success :1;
  } _MSynchronizableScene_ApplyManipulations_presult__isset;
  
  class MSynchronizableScene_ApplyManipulations_presult {
   public:
  
  
    virtual ~MSynchronizableScene_ApplyManipulations_presult() noexcept;
     ::MMIStandard::MBoolResponse* success;
  
    _MSynchronizableScene_ApplyManipulations_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  class MSynchronizableSceneClient : virtual public MSynchronizableSceneIf, public MMIServiceBaseClient {
   public:
    MSynchronizableSceneClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) :
      MMIServiceBaseClient(prot, prot) {}
    MSynchronizableSceneClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) :    MMIServiceBaseClient(iprot, oprot) {}
    std::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() {
      return piprot_;
    }
    std::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() {
      return poprot_;
    }
    void ApplyUpdates( ::MMIStandard::MBoolResponse& _return, const  ::MMIStandard::MSceneUpdate& sceneUpdates);
    void send_ApplyUpdates(const  ::MMIStandard::MSceneUpdate& sceneUpdates);
    void recv_ApplyUpdates( ::MMIStandard::MBoolResponse& _return);
    void ApplyManipulations( ::MMIStandard::MBoolResponse& _return, const std::vector< ::MMIStandard::MSceneManipulation> & sceneManipulations);
    void send_ApplyManipulations(const std::vector< ::MMIStandard::MSceneManipulation> & sceneManipulations);
    void recv_ApplyManipulations( ::MMIStandard::MBoolResponse& _return);
  };
  
  class MSynchronizableSceneProcessor : public MMIServiceBaseProcessor {
   protected:
    ::std::shared_ptr<MSynchronizableSceneIf> iface_;
    virtual bool dispatchCall(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, const std::string& fname, int32_t seqid, void* callContext);
   private:
    typedef  void (MSynchronizableSceneProcessor::*ProcessFunction)(int32_t, ::apache::thrift::protocol::TProtocol*, ::apache::thrift::protocol::TProtocol*, void*);
    typedef std::map<std::string, ProcessFunction> ProcessMap;
    ProcessMap processMap_;
    void process_ApplyUpdates(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_ApplyManipulations(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
   public:
    MSynchronizableSceneProcessor(::std::shared_ptr<MSynchronizableSceneIf> iface) :
      MMIServiceBaseProcessor(iface),
      iface_(iface) {
      processMap_["ApplyUpdates"] = &MSynchronizableSceneProcessor::process_ApplyUpdates;
      processMap_["ApplyManipulations"] = &MSynchronizableSceneProcessor::process_ApplyManipulations;
    }
  
    virtual ~MSynchronizableSceneProcessor() {}
  };
  
  class MSynchronizableSceneProcessorFactory : public ::apache::thrift::TProcessorFactory {
   public:
    MSynchronizableSceneProcessorFactory(const ::std::shared_ptr< MSynchronizableSceneIfFactory >& handlerFactory) :
        handlerFactory_(handlerFactory) {}
  
    ::std::shared_ptr< ::apache::thrift::TProcessor > getProcessor(const ::apache::thrift::TConnectionInfo& connInfo);
  
   protected:
    ::std::shared_ptr< MSynchronizableSceneIfFactory > handlerFactory_;
  };
  
  class MSynchronizableSceneMultiface : virtual public MSynchronizableSceneIf, public MMIServiceBaseMultiface {
   public:
    MSynchronizableSceneMultiface(std::vector<std::shared_ptr<MSynchronizableSceneIf> >& ifaces) : ifaces_(ifaces) {
      std::vector<std::shared_ptr<MSynchronizableSceneIf> >::iterator iter;
      for (iter = ifaces.begin(); iter != ifaces.end(); ++iter) {
        MMIServiceBaseMultiface::add(*iter);
      }
    }
    virtual ~MSynchronizableSceneMultiface() {}
   protected:
    std::vector<std::shared_ptr<MSynchronizableSceneIf> > ifaces_;
    MSynchronizableSceneMultiface() {}
    void add(::std::shared_ptr<MSynchronizableSceneIf> iface) {
      MMIServiceBaseMultiface::add(iface);
      ifaces_.push_back(iface);
    }
   public:
    void ApplyUpdates( ::MMIStandard::MBoolResponse& _return, const  ::MMIStandard::MSceneUpdate& sceneUpdates) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->ApplyUpdates(_return, sceneUpdates);
      }
      ifaces_[i]->ApplyUpdates(_return, sceneUpdates);
      return;
    }
  
    void ApplyManipulations( ::MMIStandard::MBoolResponse& _return, const std::vector< ::MMIStandard::MSceneManipulation> & sceneManipulations) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->ApplyManipulations(_return, sceneManipulations);
      }
      ifaces_[i]->ApplyManipulations(_return, sceneManipulations);
      return;
    }
  
  };
  
  // The 'concurrent' client is a thread safe client that correctly handles
  // out of order responses.  It is slower than the regular client, so should
  // only be used when you need to share a connection among multiple threads
  class MSynchronizableSceneConcurrentClient : virtual public MSynchronizableSceneIf, public MMIServiceBaseConcurrentClient {
   public:
    MSynchronizableSceneConcurrentClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot, std::shared_ptr<::apache::thrift::async::TConcurrentClientSyncInfo> sync) :
      MMIServiceBaseConcurrentClient(prot, prot, sync) {}
    MSynchronizableSceneConcurrentClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot, std::shared_ptr<::apache::thrift::async::TConcurrentClientSyncInfo> sync) :    MMIServiceBaseConcurrentClient(iprot, oprot, sync) {}
    std::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() {
      return piprot_;
    }
    std::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() {
      return poprot_;
    }
    void ApplyUpdates( ::MMIStandard::MBoolResponse& _return, const  ::MMIStandard::MSceneUpdate& sceneUpdates);
    int32_t send_ApplyUpdates(const  ::MMIStandard::MSceneUpdate& sceneUpdates);
    void recv_ApplyUpdates( ::MMIStandard::MBoolResponse& _return, const int32_t seqid);
    void ApplyManipulations( ::MMIStandard::MBoolResponse& _return, const std::vector< ::MMIStandard::MSceneManipulation> & sceneManipulations);
    int32_t send_ApplyManipulations(const std::vector< ::MMIStandard::MSceneManipulation> & sceneManipulations);
    void recv_ApplyManipulations( ::MMIStandard::MBoolResponse& _return, const int32_t seqid);
  };
  
  #ifdef _MSC_VER
    #pragma warning( pop )
  #endif
  
  } // namespace
  
  #endif
  