Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Browse files

Thrift-generated code (automatically generated)

  • Loading branch information...
commit 4ab8d4302f7933769ed8b936ee3f3011dd3895ff 1 parent 8603286
Elias Karakoulakis authored
View
34,103 gen-cpp/RemoteManager.cpp
34,103 additions, 0 deletions not shown
View
16,213 gen-cpp/RemoteManager.h
16,213 additions, 0 deletions not shown
View
955 gen-cpp/RemoteManager_server.cpp
@@ -0,0 +1,955 @@
+// Automatically generated OpenZWave::Manager_server wrapper
+// (c) 2011 Elias Karakoulakis <elias.karakoulakis@gmail.com>
+
+#include "RemoteManager.h"
+#include <protocol/TBinaryProtocol.h>
+#include <server/TSimpleServer.h>
+#include <transport/TServerSocket.h>
+#include <transport/TBufferTransports.h>
+
+using namespace ::apache::thrift;
+using namespace ::apache::thrift::protocol;
+using namespace ::apache::thrift::transport;
+using namespace ::apache::thrift::server;
+
+using boost::shared_ptr;
+
+using namespace OpenZWave;
+
+class RemoteManagerHandler : virtual public RemoteManagerIf {
+ public:
+ RemoteManagerHandler() {
+ // Your initialization goes here
+ }
+
+ void WriteConfig(const int32_t _homeId) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ mgr->WriteConfig((::uint32 const) _homeId);
+ g_criticalSection.unlock();
+ }
+
+ int8_t GetControllerNodeId(const int32_t _homeId) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ ::int8_t function_result = mgr->GetControllerNodeId((::uint32 const) _homeId);
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ bool IsPrimaryController(const int32_t _homeId) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ bool function_result = mgr->IsPrimaryController((::uint32 const) _homeId);
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ bool IsBridgeController(const int32_t _homeId) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ bool function_result = mgr->IsBridgeController((::uint32 const) _homeId);
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ void GetLibraryVersion(std::string& _return, const int32_t _homeId) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ mgr->GetLibraryVersion((::uint32 const) _homeId);
+ g_criticalSection.unlock();
+ }
+
+ void GetLibraryTypeName(std::string& _return, const int32_t _homeId) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ mgr->GetLibraryTypeName((::uint32 const) _homeId);
+ g_criticalSection.unlock();
+ }
+
+ int32_t GetSendQueueCount(const int32_t _homeId) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ ::int32_t function_result = mgr->GetSendQueueCount((::uint32 const) _homeId);
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ int32_t GetPollInterval() {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ ::int32_t function_result = mgr->GetPollInterval();
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ void SetPollInterval(const int32_t _seconds) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ mgr->SetPollInterval((::int32) _seconds);
+ g_criticalSection.unlock();
+ }
+
+ bool EnablePoll(const RemoteValueID _valueId) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ bool function_result = mgr->EnablePoll(*g_values[_valueId]);
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ bool DisablePoll(const RemoteValueID _valueId) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ bool function_result = mgr->DisablePoll(*g_values[_valueId]);
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ bool isPolled(const RemoteValueID _valueId) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ bool function_result = mgr->isPolled(*g_values[_valueId]);
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ bool RefreshNodeInfo(const int32_t _homeId, const int8_t _nodeId) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ bool function_result = mgr->RefreshNodeInfo((::uint32 const) _homeId, (::uint8 const) _nodeId);
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ bool RequestNodeState(const int32_t _homeId, const int8_t _nodeId) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ bool function_result = mgr->RequestNodeState((::uint32 const) _homeId, (::uint8 const) _nodeId);
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ bool RequestNodeDynamic(const int32_t _homeId, const int8_t _nodeId) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ bool function_result = mgr->RequestNodeDynamic((::uint32 const) _homeId, (::uint8 const) _nodeId);
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ bool IsNodeListeningDevice(const int32_t _homeId, const int8_t _nodeId) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ bool function_result = mgr->IsNodeListeningDevice((::uint32 const) _homeId, (::uint8 const) _nodeId);
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ bool IsNodeRoutingDevice(const int32_t _homeId, const int8_t _nodeId) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ bool function_result = mgr->IsNodeRoutingDevice((::uint32 const) _homeId, (::uint8 const) _nodeId);
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ int32_t GetNodeMaxBaudRate(const int32_t _homeId, const int8_t _nodeId) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ ::int32_t function_result = mgr->GetNodeMaxBaudRate((::uint32 const) _homeId, (::uint8 const) _nodeId);
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ int8_t GetNodeVersion(const int32_t _homeId, const int8_t _nodeId) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ ::int8_t function_result = mgr->GetNodeVersion((::uint32 const) _homeId, (::uint8 const) _nodeId);
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ int8_t GetNodeSecurity(const int32_t _homeId, const int8_t _nodeId) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ ::int8_t function_result = mgr->GetNodeSecurity((::uint32 const) _homeId, (::uint8 const) _nodeId);
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ int8_t GetNodeBasic(const int32_t _homeId, const int8_t _nodeId) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ ::int8_t function_result = mgr->GetNodeBasic((::uint32 const) _homeId, (::uint8 const) _nodeId);
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ int8_t GetNodeGeneric(const int32_t _homeId, const int8_t _nodeId) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ ::int8_t function_result = mgr->GetNodeGeneric((::uint32 const) _homeId, (::uint8 const) _nodeId);
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ int8_t GetNodeSpecific(const int32_t _homeId, const int8_t _nodeId) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ ::int8_t function_result = mgr->GetNodeSpecific((::uint32 const) _homeId, (::uint8 const) _nodeId);
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ void GetNodeType(std::string& _return, const int32_t _homeId, const int8_t _nodeId) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ mgr->GetNodeType((::uint32 const) _homeId, (::uint8 const) _nodeId);
+ g_criticalSection.unlock();
+ }
+
+ void GetNodeNeighbors(UInt32_ListByte& _return, const int32_t _homeId, const int8_t _nodeId) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ _return.retval = mgr->GetNodeNeighbors((::uint32 const) _homeId, (::uint8 const) _nodeId, (::uint8**) &_return.arg);
+ g_criticalSection.unlock();
+ }
+
+ void GetNodeManufacturerName(std::string& _return, const int32_t _homeId, const int8_t _nodeId) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ mgr->GetNodeManufacturerName((::uint32 const) _homeId, (::uint8 const) _nodeId);
+ g_criticalSection.unlock();
+ }
+
+ void GetNodeProductName(std::string& _return, const int32_t _homeId, const int8_t _nodeId) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ mgr->GetNodeProductName((::uint32 const) _homeId, (::uint8 const) _nodeId);
+ g_criticalSection.unlock();
+ }
+
+ void GetNodeName(std::string& _return, const int32_t _homeId, const int8_t _nodeId) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ mgr->GetNodeName((::uint32 const) _homeId, (::uint8 const) _nodeId);
+ g_criticalSection.unlock();
+ }
+
+ void GetNodeLocation(std::string& _return, const int32_t _homeId, const int8_t _nodeId) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ mgr->GetNodeLocation((::uint32 const) _homeId, (::uint8 const) _nodeId);
+ g_criticalSection.unlock();
+ }
+
+ void GetNodeManufacturerId(std::string& _return, const int32_t _homeId, const int8_t _nodeId) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ mgr->GetNodeManufacturerId((::uint32 const) _homeId, (::uint8 const) _nodeId);
+ g_criticalSection.unlock();
+ }
+
+ void GetNodeProductType(std::string& _return, const int32_t _homeId, const int8_t _nodeId) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ mgr->GetNodeProductType((::uint32 const) _homeId, (::uint8 const) _nodeId);
+ g_criticalSection.unlock();
+ }
+
+ void GetNodeProductId(std::string& _return, const int32_t _homeId, const int8_t _nodeId) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ mgr->GetNodeProductId((::uint32 const) _homeId, (::uint8 const) _nodeId);
+ g_criticalSection.unlock();
+ }
+
+ void SetNodeManufacturerName(const int32_t _homeId, const int8_t _nodeId, const std::string& _manufacturerName) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ mgr->SetNodeManufacturerName((::uint32 const) _homeId, (::uint8 const) _nodeId, (const std::string&) _manufacturerName);
+ g_criticalSection.unlock();
+ }
+
+ void SetNodeProductName(const int32_t _homeId, const int8_t _nodeId, const std::string& _productName) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ mgr->SetNodeProductName((::uint32 const) _homeId, (::uint8 const) _nodeId, (const std::string&) _productName);
+ g_criticalSection.unlock();
+ }
+
+ void SetNodeName(const int32_t _homeId, const int8_t _nodeId, const std::string& _nodeName) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ mgr->SetNodeName((::uint32 const) _homeId, (::uint8 const) _nodeId, (const std::string&) _nodeName);
+ g_criticalSection.unlock();
+ }
+
+ void SetNodeLocation(const int32_t _homeId, const int8_t _nodeId, const std::string& _location) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ mgr->SetNodeLocation((::uint32 const) _homeId, (::uint8 const) _nodeId, (const std::string&) _location);
+ g_criticalSection.unlock();
+ }
+
+ void SetNodeOn(const int32_t _homeId, const int8_t _nodeId) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ mgr->SetNodeOn((::uint32 const) _homeId, (::uint8 const) _nodeId);
+ g_criticalSection.unlock();
+ }
+
+ void SetNodeOff(const int32_t _homeId, const int8_t _nodeId) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ mgr->SetNodeOff((::uint32 const) _homeId, (::uint8 const) _nodeId);
+ g_criticalSection.unlock();
+ }
+
+ void SetNodeLevel(const int32_t _homeId, const int8_t _nodeId, const int8_t _level) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ mgr->SetNodeLevel((::uint32 const) _homeId, (::uint8 const) _nodeId, (::uint8 const) _level);
+ g_criticalSection.unlock();
+ }
+
+ bool IsNodeInfoReceived(const int32_t _homeId, const int8_t _nodeId) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ bool function_result = mgr->IsNodeInfoReceived((::uint32 const) _homeId, (::uint8 const) _nodeId);
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ void GetValueLabel(std::string& _return, const RemoteValueID _id) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ mgr->GetValueLabel(*g_values[_id]);
+ g_criticalSection.unlock();
+ }
+
+ void SetValueLabel(const RemoteValueID _id, const std::string& _value) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ mgr->SetValueLabel(*g_values[_id], (const std::string&) _value);
+ g_criticalSection.unlock();
+ }
+
+ void GetValueUnits(std::string& _return, const RemoteValueID _id) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ mgr->GetValueUnits(*g_values[_id]);
+ g_criticalSection.unlock();
+ }
+
+ void SetValueUnits(const RemoteValueID _id, const std::string& _value) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ mgr->SetValueUnits(*g_values[_id], (const std::string&) _value);
+ g_criticalSection.unlock();
+ }
+
+ void GetValueHelp(std::string& _return, const RemoteValueID _id) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ mgr->GetValueHelp(*g_values[_id]);
+ g_criticalSection.unlock();
+ }
+
+ void SetValueHelp(const RemoteValueID _id, const std::string& _value) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ mgr->SetValueHelp(*g_values[_id], (const std::string&) _value);
+ g_criticalSection.unlock();
+ }
+
+ int32_t GetValueMin(const RemoteValueID _id) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ ::int32_t function_result = mgr->GetValueMin(*g_values[_id]);
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ int32_t GetValueMax(const RemoteValueID _id) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ ::int32_t function_result = mgr->GetValueMax(*g_values[_id]);
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ bool IsValueReadOnly(const RemoteValueID _id) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ bool function_result = mgr->IsValueReadOnly(*g_values[_id]);
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ bool IsValueWriteOnly(const RemoteValueID _id) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ bool function_result = mgr->IsValueWriteOnly(*g_values[_id]);
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ bool IsValueSet(const RemoteValueID _id) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ bool function_result = mgr->IsValueSet(*g_values[_id]);
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ void GetValueAsBool(Bool_Bool& _return, const RemoteValueID _id) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ _return.retval = mgr->GetValueAsBool(*g_values[_id], (bool*) &_return.arg);
+ g_criticalSection.unlock();
+ }
+
+ void GetValueAsByte(Bool_UInt8& _return, const RemoteValueID _id) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ _return.retval = mgr->GetValueAsByte(*g_values[_id], (::uint8*) &_return.arg);
+ g_criticalSection.unlock();
+ }
+
+ void GetValueAsFloat(Bool_Float& _return, const RemoteValueID _id) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ _return.retval = mgr->GetValueAsFloat(*g_values[_id], (float*) &_return.arg);
+ g_criticalSection.unlock();
+ }
+
+ void GetValueAsInt(Bool_Int& _return, const RemoteValueID _id) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ _return.retval = mgr->GetValueAsInt(*g_values[_id], (::int32*) &_return.arg);
+ g_criticalSection.unlock();
+ }
+
+ void GetValueAsShort(Bool_Int16& _return, const RemoteValueID _id) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ _return.retval = mgr->GetValueAsShort(*g_values[_id], (::int16*) &_return.arg);
+ g_criticalSection.unlock();
+ }
+
+ void GetValueAsString(Bool_String& _return, const RemoteValueID _id) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ _return.retval = mgr->GetValueAsString(*g_values[_id], (std::string*) &_return.arg);
+ g_criticalSection.unlock();
+ }
+
+ void GetValueListSelection_String(Bool_String& _return, const RemoteValueID _id) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ _return.retval = mgr->GetValueListSelection(*g_values[_id], (std::string*) &_return.arg);
+ g_criticalSection.unlock();
+ }
+
+ void GetValueListSelection_Int32(Bool_Int& _return, const RemoteValueID _id) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ _return.retval = mgr->GetValueListSelection(*g_values[_id], (::int32*) &_return.arg);
+ g_criticalSection.unlock();
+ }
+
+ void GetValueListItems(Bool_ListString& _return, const RemoteValueID _id) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ _return.retval = mgr->GetValueListItems(*g_values[_id], (std::vector<std::string, std::allocator<std::string> >*) &_return.arg);
+ g_criticalSection.unlock();
+ }
+
+ void GetValueFloatPrecision(Bool_UInt8& _return, const RemoteValueID _id) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ _return.retval = mgr->GetValueFloatPrecision(*g_values[_id], (::uint8*) &_return.arg);
+ g_criticalSection.unlock();
+ }
+
+ bool SetValue_Bool(const RemoteValueID _id, const bool _value) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ bool function_result = mgr->SetValue(*g_values[_id], (bool const) _value);
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ bool SetValue_UInt8(const RemoteValueID _id, const int8_t _value) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ bool function_result = mgr->SetValue(*g_values[_id], (::uint8 const) _value);
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ bool SetValue_Float(const RemoteValueID _id, const double _value) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ bool function_result = mgr->SetValue(*g_values[_id], (float const) _value);
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ bool SetValue_Int32(const RemoteValueID _id, const int32_t _value) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ bool function_result = mgr->SetValue(*g_values[_id], (::int32 const) _value);
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ bool SetValue_Int16(const RemoteValueID _id, const int16_t _value) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ bool function_result = mgr->SetValue(*g_values[_id], (::int16 const) _value);
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ bool SetValue_String(const RemoteValueID _id, const std::string& _value) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ bool function_result = mgr->SetValue(*g_values[_id], (const std::string&) _value);
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ bool SetValueListSelection(const RemoteValueID _id, const std::string& _selectedItem) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ bool function_result = mgr->SetValueListSelection(*g_values[_id], (const std::string&) _selectedItem);
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ bool PressButton(const RemoteValueID _id) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ bool function_result = mgr->PressButton(*g_values[_id]);
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ bool ReleaseButton(const RemoteValueID _id) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ bool function_result = mgr->ReleaseButton(*g_values[_id]);
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ int8_t GetNumSwitchPoints(const RemoteValueID _id) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ ::int8_t function_result = mgr->GetNumSwitchPoints(*g_values[_id]);
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ bool SetSwitchPoint(const RemoteValueID _id, const int8_t _hours, const int8_t _minutes, const int8_t _setback) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ bool function_result = mgr->SetSwitchPoint(*g_values[_id], (::uint8 const) _hours, (::uint8 const) _minutes, (::int8 const) _setback);
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ bool RemoveSwitchPoint(const RemoteValueID _id, const int8_t _hours, const int8_t _minutes) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ bool function_result = mgr->RemoveSwitchPoint(*g_values[_id], (::uint8 const) _hours, (::uint8 const) _minutes);
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ void ClearSwitchPoints(const RemoteValueID _id) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ mgr->ClearSwitchPoints(*g_values[_id]);
+ g_criticalSection.unlock();
+ }
+
+ void GetSwitchPoint(GetSwitchPointReturnStruct& _return, const RemoteValueID _id, const int8_t _idx) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ _return = mgr->GetSwitchPoint(*g_values[_id], (::uint8 const) _idx, (::int8*) &_return, (::int8*) &_return, (::int8*) &_return);
+ g_criticalSection.unlock();
+ }
+
+ void SwitchAllOn(const int32_t _homeId) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ mgr->SwitchAllOn((::uint32 const) _homeId);
+ g_criticalSection.unlock();
+ }
+
+ void SwitchAllOff(const int32_t _homeId) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ mgr->SwitchAllOff((::uint32 const) _homeId);
+ g_criticalSection.unlock();
+ }
+
+ bool SetConfigParam(const int32_t _homeId, const int8_t _nodeId, const int8_t _param, const int32_t _value, const int8_t _size) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ bool function_result = mgr->SetConfigParam((::uint32 const) _homeId, (::uint8 const) _nodeId, (::uint8 const) _param, (::int32) _value, (::uint8 const) _size);
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ void RequestConfigParam(const int32_t _homeId, const int8_t _nodeId, const int8_t _param) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ mgr->RequestConfigParam((::uint32 const) _homeId, (::uint8 const) _nodeId, (::uint8 const) _param);
+ g_criticalSection.unlock();
+ }
+
+ void RequestAllConfigParams(const int32_t _homeId, const int8_t _nodeId) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ mgr->RequestAllConfigParams((::uint32 const) _homeId, (::uint8 const) _nodeId);
+ g_criticalSection.unlock();
+ }
+
+ int8_t GetNumGroups(const int32_t _homeId, const int8_t _nodeId) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ ::int8_t function_result = mgr->GetNumGroups((::uint32 const) _homeId, (::uint8 const) _nodeId);
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ void GetAssociations(std::vector<int8_t> & _return, const int32_t _homeId, const int8_t _nodeId, const int8_t _groupIdx) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ _return = mgr->GetAssociations((::uint32 const) _homeId, (::uint8 const) _nodeId, (::uint8 const) _groupIdx, (::uint8**) &_return);
+ g_criticalSection.unlock();
+ }
+
+ int8_t GetMaxAssociations(const int32_t _homeId, const int8_t _nodeId, const int8_t _groupIdx) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ ::int8_t function_result = mgr->GetMaxAssociations((::uint32 const) _homeId, (::uint8 const) _nodeId, (::uint8 const) _groupIdx);
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ void GetGroupLabel(std::string& _return, const int32_t _homeId, const int8_t _nodeId, const int8_t _groupIdx) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ mgr->GetGroupLabel((::uint32 const) _homeId, (::uint8 const) _nodeId, (::uint8 const) _groupIdx);
+ g_criticalSection.unlock();
+ }
+
+ void AddAssociation(const int32_t _homeId, const int8_t _nodeId, const int8_t _groupIdx, const int8_t _targetNodeId) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ mgr->AddAssociation((::uint32 const) _homeId, (::uint8 const) _nodeId, (::uint8 const) _groupIdx, (::uint8 const) _targetNodeId);
+ g_criticalSection.unlock();
+ }
+
+ void RemoveAssociation(const int32_t _homeId, const int8_t _nodeId, const int8_t _groupIdx, const int8_t _targetNodeId) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ mgr->RemoveAssociation((::uint32 const) _homeId, (::uint8 const) _nodeId, (::uint8 const) _groupIdx, (::uint8 const) _targetNodeId);
+ g_criticalSection.unlock();
+ }
+
+ void ResetController(const int32_t _homeId) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ mgr->ResetController((::uint32 const) _homeId);
+ g_criticalSection.unlock();
+ }
+
+ void SoftReset(const int32_t _homeId) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ mgr->SoftReset((::uint32 const) _homeId);
+ g_criticalSection.unlock();
+ }
+
+ int8_t GetNumScenes() {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ ::int8_t function_result = mgr->GetNumScenes();
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ void GetAllScenes(std::vector<int8_t> & _return) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ _return = mgr->GetAllScenes((::uint8**) &_return);
+ g_criticalSection.unlock();
+ }
+
+ int8_t CreateScene() {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ ::int8_t function_result = mgr->CreateScene();
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ bool RemoveScene(const int8_t _sceneId) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ bool function_result = mgr->RemoveScene((::uint8 const) _sceneId);
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ bool AddSceneValue_Bool(const int8_t _sceneId, const RemoteValueID _valueId, const bool _value) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ bool function_result = mgr->AddSceneValue((::uint8 const) _sceneId, *g_values[_valueId], (bool const) _value);
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ bool AddSceneValue_Uint8(const int8_t _sceneId, const RemoteValueID _valueId, const int8_t _value) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ bool function_result = mgr->AddSceneValue((::uint8 const) _sceneId, *g_values[_valueId], (::uint8 const) _value);
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ bool AddSceneValue_Float(const int8_t _sceneId, const RemoteValueID _valueId, const double _value) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ bool function_result = mgr->AddSceneValue((::uint8 const) _sceneId, *g_values[_valueId], (float const) _value);
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ bool AddSceneValue_Int32(const int8_t _sceneId, const RemoteValueID _valueId, const int32_t _value) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ bool function_result = mgr->AddSceneValue((::uint8 const) _sceneId, *g_values[_valueId], (::int32 const) _value);
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ bool AddSceneValue_Int16(const int8_t _sceneId, const RemoteValueID _valueId, const int16_t _value) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ bool function_result = mgr->AddSceneValue((::uint8 const) _sceneId, *g_values[_valueId], (::int16 const) _value);
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ bool AddSceneValue_String(const int8_t _sceneId, const RemoteValueID _valueId, const std::string& _value) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ bool function_result = mgr->AddSceneValue((::uint8 const) _sceneId, *g_values[_valueId], (const std::string&) _value);
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ bool AddSceneValueListSelection_String(const int8_t _sceneId, const RemoteValueID _valueId, const std::string& _value) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ bool function_result = mgr->AddSceneValueListSelection((::uint8 const) _sceneId, *g_values[_valueId], (const std::string&) _value);
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ bool AddSceneValueListSelection_Int32(const int8_t _sceneId, const RemoteValueID _valueId, const int32_t _value) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ bool function_result = mgr->AddSceneValueListSelection((::uint8 const) _sceneId, *g_values[_valueId], (::int32 const) _value);
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ bool RemoveSceneValue(const int8_t _sceneId, const RemoteValueID _valueId) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ bool function_result = mgr->RemoveSceneValue((::uint8 const) _sceneId, *g_values[_valueId]);
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ void SceneGetValues(std::vector<RemoteValueID> & _return, const int8_t _sceneId) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ _return = mgr->SceneGetValues((::uint8 const) _sceneId, (std::vector<OpenZWave::ValueID, std::allocator<OpenZWave::ValueID> >*) &_return);
+ g_criticalSection.unlock();
+ }
+
+ void SceneGetValueAsBool(Bool_Bool& _return, const int8_t _sceneId, const RemoteValueID _valueId) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ _return.retval = mgr->SceneGetValueAsBool((::uint8 const) _sceneId, *g_values[_valueId], (bool*) &_return.arg);
+ g_criticalSection.unlock();
+ }
+
+ void SceneGetValueAsByte(Bool_UInt8& _return, const int8_t _sceneId, const RemoteValueID _valueId) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ _return.retval = mgr->SceneGetValueAsByte((::uint8 const) _sceneId, *g_values[_valueId], (::uint8*) &_return.arg);
+ g_criticalSection.unlock();
+ }
+
+ void SceneGetValueAsFloat(Bool_Float& _return, const int8_t _sceneId, const RemoteValueID _valueId) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ _return.retval = mgr->SceneGetValueAsFloat((::uint8 const) _sceneId, *g_values[_valueId], (float*) &_return.arg);
+ g_criticalSection.unlock();
+ }
+
+ void SceneGetValueAsInt(Bool_Int& _return, const int8_t _sceneId, const RemoteValueID _valueId) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ _return.retval = mgr->SceneGetValueAsInt((::uint8 const) _sceneId, *g_values[_valueId], (::int32*) &_return.arg);
+ g_criticalSection.unlock();
+ }
+
+ void SceneGetValueAsShort(Bool_Int16& _return, const int8_t _sceneId, const RemoteValueID _valueId) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ _return.retval = mgr->SceneGetValueAsShort((::uint8 const) _sceneId, *g_values[_valueId], (::int16*) &_return.arg);
+ g_criticalSection.unlock();
+ }
+
+ void SceneGetValueAsString(Bool_String& _return, const int8_t _sceneId, const RemoteValueID _valueId) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ _return.retval = mgr->SceneGetValueAsString((::uint8 const) _sceneId, *g_values[_valueId], (std::string*) &_return.arg);
+ g_criticalSection.unlock();
+ }
+
+ void SceneGetValueListSelection_String(Bool_String& _return, const int8_t _sceneId, const RemoteValueID _valueId) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ _return.retval = mgr->SceneGetValueListSelection((::uint8 const) _sceneId, *g_values[_valueId], (std::string*) &_return.arg);
+ g_criticalSection.unlock();
+ }
+
+ void SceneGetValueListSelection_Int32(Bool_Int& _return, const int8_t _sceneId, const RemoteValueID _valueId) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ _return.retval = mgr->SceneGetValueListSelection((::uint8 const) _sceneId, *g_values[_valueId], (::int32*) &_return.arg);
+ g_criticalSection.unlock();
+ }
+
+ bool SetSceneValue_Bool(const int8_t _sceneId, const RemoteValueID _valueId, const bool _value) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ bool function_result = mgr->SetSceneValue((::uint8 const) _sceneId, *g_values[_valueId], (bool const) _value);
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ bool SetSceneValue_Uint8(const int8_t _sceneId, const RemoteValueID _valueId, const int8_t _value) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ bool function_result = mgr->SetSceneValue((::uint8 const) _sceneId, *g_values[_valueId], (::uint8 const) _value);
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ bool SetSceneValue_Float(const int8_t _sceneId, const RemoteValueID _valueId, const double _value) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ bool function_result = mgr->SetSceneValue((::uint8 const) _sceneId, *g_values[_valueId], (float const) _value);
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ bool SetSceneValue_Int32(const int8_t _sceneId, const RemoteValueID _valueId, const int32_t _value) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ bool function_result = mgr->SetSceneValue((::uint8 const) _sceneId, *g_values[_valueId], (::int32 const) _value);
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ bool SetSceneValue_Int16(const int8_t _sceneId, const RemoteValueID _valueId, const int16_t _value) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ bool function_result = mgr->SetSceneValue((::uint8 const) _sceneId, *g_values[_valueId], (::int16 const) _value);
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ bool SetSceneValue_String(const int8_t _sceneId, const RemoteValueID _valueId, const std::string& _value) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ bool function_result = mgr->SetSceneValue((::uint8 const) _sceneId, *g_values[_valueId], (const std::string&) _value);
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ bool SetSceneValueListSelection_String(const int8_t _sceneId, const RemoteValueID _valueId, const std::string& _value) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ bool function_result = mgr->SetSceneValueListSelection((::uint8 const) _sceneId, *g_values[_valueId], (const std::string&) _value);
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ bool SetSceneValueListSelection_Int32(const int8_t _sceneId, const RemoteValueID _valueId, const int32_t _value) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ bool function_result = mgr->SetSceneValueListSelection((::uint8 const) _sceneId, *g_values[_valueId], (::int32 const) _value);
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ void GetSceneLabel(std::string& _return, const int8_t _sceneId) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ mgr->GetSceneLabel((::uint8 const) _sceneId);
+ g_criticalSection.unlock();
+ }
+
+ void SetSceneLabel(const int8_t _sceneId, const std::string& _value) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ mgr->SetSceneLabel((::uint8 const) _sceneId, (const std::string&) _value);
+ g_criticalSection.unlock();
+ }
+
+ bool SceneExists(const int8_t _sceneId) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ bool function_result = mgr->SceneExists((::uint8 const) _sceneId);
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+ bool ActivateScene(const int8_t _sceneId) {
+ Manager* mgr = Manager::Get();
+ g_criticalSection.lock();
+ bool function_result = mgr->ActivateScene((::uint8 const) _sceneId);
+ g_criticalSection.unlock();
+ return(function_result);
+ }
+
+};
+
+int main(int argc, char **argv) {
+ int port = 9090;
+ shared_ptr<RemoteManagerHandler> handler(new RemoteManagerHandler());
+ shared_ptr<TProcessor> processor(new RemoteManagerProcessor(handler));
+ shared_ptr<TServerTransport> serverTransport(new TServerSocket(port));
+ shared_ptr<TTransportFactory> transportFactory(new TBufferedTransportFactory());
+ shared_ptr<TProtocolFactory> protocolFactory(new TBinaryProtocolFactory());
+
+ TSimpleServer server(processor, serverTransport, transportFactory, protocolFactory);
+ server.serve();
+ return 0;
+}
+
View
649 gen-cpp/RemoteManager_server.skeleton.cpp
@@ -0,0 +1,649 @@
+// This autogenerated skeleton file illustrates how to build a server.
+// You should copy it to another filename to avoid overwriting it.
+
+#include "RemoteManager.h"
+#include <protocol/TBinaryProtocol.h>
+#include <server/TSimpleServer.h>
+#include <transport/TServerSocket.h>
+#include <transport/TBufferTransports.h>
+
+using namespace ::apache::thrift;
+using namespace ::apache::thrift::protocol;
+using namespace ::apache::thrift::transport;
+using namespace ::apache::thrift::server;
+
+using boost::shared_ptr;
+
+using namespace OpenZWave;
+
+class RemoteManagerHandler : virtual public RemoteManagerIf {
+ public:
+ RemoteManagerHandler() {
+ // Your initialization goes here
+ }
+
+ void WriteConfig(const int32_t _homeId) {
+ // Your implementation goes here
+ printf("WriteConfig\n");
+ }
+
+ int8_t GetControllerNodeId(const int32_t _homeId) {
+ // Your implementation goes here
+ printf("GetControllerNodeId\n");
+ }
+
+ bool IsPrimaryController(const int32_t _homeId) {
+ // Your implementation goes here
+ printf("IsPrimaryController\n");
+ }
+
+ bool IsBridgeController(const int32_t _homeId) {
+ // Your implementation goes here
+ printf("IsBridgeController\n");
+ }
+
+ void GetLibraryVersion(std::string& _return, const int32_t _homeId) {
+ // Your implementation goes here
+ printf("GetLibraryVersion\n");
+ }
+
+ void GetLibraryTypeName(std::string& _return, const int32_t _homeId) {
+ // Your implementation goes here
+ printf("GetLibraryTypeName\n");
+ }
+
+ int32_t GetSendQueueCount(const int32_t _homeId) {
+ // Your implementation goes here
+ printf("GetSendQueueCount\n");
+ }
+
+ int32_t GetPollInterval() {
+ // Your implementation goes here
+ printf("GetPollInterval\n");
+ }
+
+ void SetPollInterval(const int32_t _seconds) {
+ // Your implementation goes here
+ printf("SetPollInterval\n");
+ }
+
+ bool EnablePoll(const RemoteValueID _valueId) {
+ // Your implementation goes here
+ printf("EnablePoll\n");
+ }
+
+ bool DisablePoll(const RemoteValueID _valueId) {
+ // Your implementation goes here
+ printf("DisablePoll\n");
+ }
+
+ bool isPolled(const RemoteValueID _valueId) {
+ // Your implementation goes here
+ printf("isPolled\n");
+ }
+
+ bool RefreshNodeInfo(const int32_t _homeId, const int8_t _nodeId) {
+ // Your implementation goes here
+ printf("RefreshNodeInfo\n");
+ }
+
+ bool RequestNodeState(const int32_t _homeId, const int8_t _nodeId) {
+ // Your implementation goes here
+ printf("RequestNodeState\n");
+ }
+
+ bool RequestNodeDynamic(const int32_t _homeId, const int8_t _nodeId) {
+ // Your implementation goes here
+ printf("RequestNodeDynamic\n");
+ }
+
+ bool IsNodeListeningDevice(const int32_t _homeId, const int8_t _nodeId) {
+ // Your implementation goes here
+ printf("IsNodeListeningDevice\n");
+ }
+
+ bool IsNodeRoutingDevice(const int32_t _homeId, const int8_t _nodeId) {
+ // Your implementation goes here
+ printf("IsNodeRoutingDevice\n");
+ }
+
+ int32_t GetNodeMaxBaudRate(const int32_t _homeId, const int8_t _nodeId) {
+ // Your implementation goes here
+ printf("GetNodeMaxBaudRate\n");
+ }
+
+ int8_t GetNodeVersion(const int32_t _homeId, const int8_t _nodeId) {
+ // Your implementation goes here
+ printf("GetNodeVersion\n");
+ }
+
+ int8_t GetNodeSecurity(const int32_t _homeId, const int8_t _nodeId) {
+ // Your implementation goes here
+ printf("GetNodeSecurity\n");
+ }
+
+ int8_t GetNodeBasic(const int32_t _homeId, const int8_t _nodeId) {
+ // Your implementation goes here
+ printf("GetNodeBasic\n");
+ }
+
+ int8_t GetNodeGeneric(const int32_t _homeId, const int8_t _nodeId) {
+ // Your implementation goes here
+ printf("GetNodeGeneric\n");
+ }
+
+ int8_t GetNodeSpecific(const int32_t _homeId, const int8_t _nodeId) {
+ // Your implementation goes here
+ printf("GetNodeSpecific\n");
+ }
+
+ void GetNodeType(std::string& _return, const int32_t _homeId, const int8_t _nodeId) {
+ // Your implementation goes here
+ printf("GetNodeType\n");
+ }
+
+ void GetNodeNeighbors(UInt32_ListByte& _return, const int32_t _homeId, const int8_t _nodeId) {
+ // Your implementation goes here
+ printf("GetNodeNeighbors\n");
+ }
+
+ void GetNodeManufacturerName(std::string& _return, const int32_t _homeId, const int8_t _nodeId) {
+ // Your implementation goes here
+ printf("GetNodeManufacturerName\n");
+ }
+
+ void GetNodeProductName(std::string& _return, const int32_t _homeId, const int8_t _nodeId) {
+ // Your implementation goes here
+ printf("GetNodeProductName\n");
+ }
+
+ void GetNodeName(std::string& _return, const int32_t _homeId, const int8_t _nodeId) {
+ // Your implementation goes here
+ printf("GetNodeName\n");
+ }
+
+ void GetNodeLocation(std::string& _return, const int32_t _homeId, const int8_t _nodeId) {
+ // Your implementation goes here
+ printf("GetNodeLocation\n");
+ }
+
+ void GetNodeManufacturerId(std::string& _return, const int32_t _homeId, const int8_t _nodeId) {
+ // Your implementation goes here
+ printf("GetNodeManufacturerId\n");
+ }
+
+ void GetNodeProductType(std::string& _return, const int32_t _homeId, const int8_t _nodeId) {
+ // Your implementation goes here
+ printf("GetNodeProductType\n");
+ }
+
+ void GetNodeProductId(std::string& _return, const int32_t _homeId, const int8_t _nodeId) {
+ // Your implementation goes here
+ printf("GetNodeProductId\n");
+ }
+
+ void SetNodeManufacturerName(const int32_t _homeId, const int8_t _nodeId, const std::string& _manufacturerName) {
+ // Your implementation goes here
+ printf("SetNodeManufacturerName\n");
+ }
+
+ void SetNodeProductName(const int32_t _homeId, const int8_t _nodeId, const std::string& _productName) {
+ // Your implementation goes here
+ printf("SetNodeProductName\n");
+ }
+
+ void SetNodeName(const int32_t _homeId, const int8_t _nodeId, const std::string& _nodeName) {
+ // Your implementation goes here
+ printf("SetNodeName\n");
+ }
+
+ void SetNodeLocation(const int32_t _homeId, const int8_t _nodeId, const std::string& _location) {
+ // Your implementation goes here
+ printf("SetNodeLocation\n");
+ }
+
+ void SetNodeOn(const int32_t _homeId, const int8_t _nodeId) {
+ // Your implementation goes here
+ printf("SetNodeOn\n");
+ }
+
+ void SetNodeOff(const int32_t _homeId, const int8_t _nodeId) {
+ // Your implementation goes here
+ printf("SetNodeOff\n");
+ }
+
+ void SetNodeLevel(const int32_t _homeId, const int8_t _nodeId, const int8_t _level) {
+ // Your implementation goes here
+ printf("SetNodeLevel\n");
+ }
+
+ bool IsNodeInfoReceived(const int32_t _homeId, const int8_t _nodeId) {
+ // Your implementation goes here
+ printf("IsNodeInfoReceived\n");
+ }
+
+ void GetValueLabel(std::string& _return, const RemoteValueID _id) {
+ // Your implementation goes here
+ printf("GetValueLabel\n");
+ }
+
+ void SetValueLabel(const RemoteValueID _id, const std::string& _value) {
+ // Your implementation goes here
+ printf("SetValueLabel\n");
+ }
+
+ void GetValueUnits(std::string& _return, const RemoteValueID _id) {
+ // Your implementation goes here
+ printf("GetValueUnits\n");
+ }
+
+ void SetValueUnits(const RemoteValueID _id, const std::string& _value) {
+ // Your implementation goes here
+ printf("SetValueUnits\n");
+ }
+
+ void GetValueHelp(std::string& _return, const RemoteValueID _id) {
+ // Your implementation goes here
+ printf("GetValueHelp\n");
+ }
+
+ void SetValueHelp(const RemoteValueID _id, const std::string& _value) {
+ // Your implementation goes here
+ printf("SetValueHelp\n");
+ }
+
+ int32_t GetValueMin(const RemoteValueID _id) {
+ // Your implementation goes here
+ printf("GetValueMin\n");
+ }
+
+ int32_t GetValueMax(const RemoteValueID _id) {
+ // Your implementation goes here
+ printf("GetValueMax\n");
+ }
+
+ bool IsValueReadOnly(const RemoteValueID _id) {
+ // Your implementation goes here
+ printf("IsValueReadOnly\n");
+ }
+
+ bool IsValueWriteOnly(const RemoteValueID _id) {
+ // Your implementation goes here
+ printf("IsValueWriteOnly\n");
+ }
+
+ bool IsValueSet(const RemoteValueID _id) {
+ // Your implementation goes here
+ printf("IsValueSet\n");
+ }
+
+ void GetValueAsBool(Bool_Bool& _return, const RemoteValueID _id) {
+ // Your implementation goes here
+ printf("GetValueAsBool\n");
+ }
+
+ void GetValueAsByte(Bool_UInt8& _return, const RemoteValueID _id) {
+ // Your implementation goes here
+ printf("GetValueAsByte\n");
+ }
+
+ void GetValueAsFloat(Bool_Float& _return, const RemoteValueID _id) {
+ // Your implementation goes here
+ printf("GetValueAsFloat\n");
+ }
+
+ void GetValueAsInt(Bool_Int& _return, const RemoteValueID _id) {
+ // Your implementation goes here
+ printf("GetValueAsInt\n");
+ }
+
+ void GetValueAsShort(Bool_Int16& _return, const RemoteValueID _id) {
+ // Your implementation goes here
+ printf("GetValueAsShort\n");
+ }
+
+ void GetValueAsString(Bool_String& _return, const RemoteValueID _id) {
+ // Your implementation goes here
+ printf("GetValueAsString\n");
+ }
+
+ void GetValueListSelection_String(Bool_String& _return, const RemoteValueID _id) {
+ // Your implementation goes here
+ printf("GetValueListSelection_String\n");
+ }
+
+ void GetValueListSelection_Int32(Bool_Int& _return, const RemoteValueID _id) {
+ // Your implementation goes here
+ printf("GetValueListSelection_Int32\n");
+ }
+
+ void GetValueListItems(Bool_ListString& _return, const RemoteValueID _id) {
+ // Your implementation goes here
+ printf("GetValueListItems\n");
+ }
+
+ void GetValueFloatPrecision(Bool_UInt8& _return, const RemoteValueID _id) {
+ // Your implementation goes here
+ printf("GetValueFloatPrecision\n");
+ }
+
+ bool SetValue_Bool(const RemoteValueID _id, const bool _value) {
+ // Your implementation goes here
+ printf("SetValue_Bool\n");
+ }
+
+ bool SetValue_UInt8(const RemoteValueID _id, const int8_t _value) {
+ // Your implementation goes here
+ printf("SetValue_UInt8\n");
+ }
+
+ bool SetValue_Float(const RemoteValueID _id, const double _value) {
+ // Your implementation goes here
+ printf("SetValue_Float\n");
+ }
+
+ bool SetValue_Int32(const RemoteValueID _id, const int32_t _value) {
+ // Your implementation goes here
+ printf("SetValue_Int32\n");
+ }
+
+ bool SetValue_Int16(const RemoteValueID _id, const int16_t _value) {
+ // Your implementation goes here
+ printf("SetValue_Int16\n");
+ }
+
+ bool SetValue_String(const RemoteValueID _id, const std::string& _value) {
+ // Your implementation goes here
+ printf("SetValue_String\n");
+ }
+
+ bool SetValueListSelection(const RemoteValueID _id, const std::string& _selectedItem) {
+ // Your implementation goes here
+ printf("SetValueListSelection\n");
+ }
+
+ bool PressButton(const RemoteValueID _id) {
+ // Your implementation goes here
+ printf("PressButton\n");
+ }
+
+ bool ReleaseButton(const RemoteValueID _id) {
+ // Your implementation goes here
+ printf("ReleaseButton\n");
+ }
+
+ int8_t GetNumSwitchPoints(const RemoteValueID _id) {
+ // Your implementation goes here
+ printf("GetNumSwitchPoints\n");
+ }
+
+ bool SetSwitchPoint(const RemoteValueID _id, const int8_t _hours, const int8_t _minutes, const int8_t _setback) {
+ // Your implementation goes here
+ printf("SetSwitchPoint\n");
+ }
+
+ bool RemoveSwitchPoint(const RemoteValueID _id, const int8_t _hours, const int8_t _minutes) {
+ // Your implementation goes here
+ printf("RemoveSwitchPoint\n");
+ }
+
+ void ClearSwitchPoints(const RemoteValueID _id) {
+ // Your implementation goes here
+ printf("ClearSwitchPoints\n");
+ }
+
+ void GetSwitchPoint(GetSwitchPointReturnStruct& _return, const RemoteValueID _id, const int8_t _idx) {
+ // Your implementation goes here
+ printf("GetSwitchPoint\n");
+ }
+
+ void SwitchAllOn(const int32_t _homeId) {
+ // Your implementation goes here
+ printf("SwitchAllOn\n");
+ }
+
+ void SwitchAllOff(const int32_t _homeId) {
+ // Your implementation goes here
+ printf("SwitchAllOff\n");
+ }
+
+ bool SetConfigParam(const int32_t _homeId, const int8_t _nodeId, const int8_t _param, const int32_t _value, const int8_t _size) {
+ // Your implementation goes here
+ printf("SetConfigParam\n");
+ }
+
+ void RequestConfigParam(const int32_t _homeId, const int8_t _nodeId, const int8_t _param) {
+ // Your implementation goes here
+ printf("RequestConfigParam\n");
+ }
+
+ void RequestAllConfigParams(const int32_t _homeId, const int8_t _nodeId) {
+ // Your implementation goes here
+ printf("RequestAllConfigParams\n");
+ }
+
+ int8_t GetNumGroups(const int32_t _homeId, const int8_t _nodeId) {
+ // Your implementation goes here
+ printf("GetNumGroups\n");
+ }
+
+ void GetAssociations(std::vector<int8_t> & _return, const int32_t _homeId, const int8_t _nodeId, const int8_t _groupIdx) {
+ // Your implementation goes here
+ printf("GetAssociations\n");
+ }
+
+ int8_t GetMaxAssociations(const int32_t _homeId, const int8_t _nodeId, const int8_t _groupIdx) {
+ // Your implementation goes here
+ printf("GetMaxAssociations\n");
+ }
+
+ void GetGroupLabel(std::string& _return, const int32_t _homeId, const int8_t _nodeId, const int8_t _groupIdx) {
+ // Your implementation goes here
+ printf("GetGroupLabel\n");
+ }
+
+ void AddAssociation(const int32_t _homeId, const int8_t _nodeId, const int8_t _groupIdx, const int8_t _targetNodeId) {
+ // Your implementation goes here
+ printf("AddAssociation\n");
+ }
+
+ void RemoveAssociation(const int32_t _homeId, const int8_t _nodeId, const int8_t _groupIdx, const int8_t _targetNodeId) {
+ // Your implementation goes here
+ printf("RemoveAssociation\n");
+ }
+
+ void ResetController(const int32_t _homeId) {
+ // Your implementation goes here
+ printf("ResetController\n");
+ }
+
+ void SoftReset(const int32_t _homeId) {
+ // Your implementation goes here
+ printf("SoftReset\n");
+ }
+
+ int8_t GetNumScenes() {
+ // Your implementation goes here
+ printf("GetNumScenes\n");
+ }
+
+ void GetAllScenes(std::vector<int8_t> & _return) {
+ // Your implementation goes here
+ printf("GetAllScenes\n");
+ }
+
+ int8_t CreateScene() {
+ // Your implementation goes here
+ printf("CreateScene\n");
+ }
+
+ bool RemoveScene(const int8_t _sceneId) {
+ // Your implementation goes here
+ printf("RemoveScene\n");
+ }
+
+ bool AddSceneValue_Bool(const int8_t _sceneId, const RemoteValueID _valueId, const bool _value) {
+ // Your implementation goes here
+ printf("AddSceneValue_Bool\n");
+ }
+
+ bool AddSceneValue_Uint8(const int8_t _sceneId, const RemoteValueID _valueId, const int8_t _value) {
+ // Your implementation goes here
+ printf("AddSceneValue_Uint8\n");
+ }
+
+ bool AddSceneValue_Float(const int8_t _sceneId, const RemoteValueID _valueId, const double _value) {
+ // Your implementation goes here
+ printf("AddSceneValue_Float\n");
+ }
+
+ bool AddSceneValue_Int32(const int8_t _sceneId, const RemoteValueID _valueId, const int32_t _value) {
+ // Your implementation goes here
+ printf("AddSceneValue_Int32\n");
+ }
+
+ bool AddSceneValue_Int16(const int8_t _sceneId, const RemoteValueID _valueId, const int16_t _value) {
+ // Your implementation goes here
+ printf("AddSceneValue_Int16\n");
+ }
+
+ bool AddSceneValue_String(const int8_t _sceneId, const RemoteValueID _valueId, const std::string& _value) {
+ // Your implementation goes here
+ printf("AddSceneValue_String\n");
+ }
+
+ bool AddSceneValueListSelection_String(const int8_t _sceneId, const RemoteValueID _valueId, const std::string& _value) {
+ // Your implementation goes here
+ printf("AddSceneValueListSelection_String\n");
+ }
+
+ bool AddSceneValueListSelection_Int32(const int8_t _sceneId, const RemoteValueID _valueId, const int32_t _value) {
+ // Your implementation goes here
+ printf("AddSceneValueListSelection_Int32\n");
+ }
+
+ bool RemoveSceneValue(const int8_t _sceneId, const RemoteValueID _valueId) {
+ // Your implementation goes here
+ printf("RemoveSceneValue\n");
+ }
+
+ void SceneGetValues(std::vector<RemoteValueID> & _return, const int8_t _sceneId) {
+ // Your implementation goes here
+ printf("SceneGetValues\n");
+ }
+
+ void SceneGetValueAsBool(Bool_Bool& _return, const int8_t _sceneId, const RemoteValueID _valueId) {
+ // Your implementation goes here
+ printf("SceneGetValueAsBool\n");
+ }
+
+ void SceneGetValueAsByte(Bool_UInt8& _return, const int8_t _sceneId, const RemoteValueID _valueId) {
+ // Your implementation goes here
+ printf("SceneGetValueAsByte\n");
+ }
+
+ void SceneGetValueAsFloat(Bool_Float& _return, const int8_t _sceneId, const RemoteValueID _valueId) {
+ // Your implementation goes here
+ printf("SceneGetValueAsFloat\n");
+ }
+
+ void SceneGetValueAsInt(Bool_Int& _return, const int8_t _sceneId, const RemoteValueID _valueId) {
+ // Your implementation goes here
+ printf("SceneGetValueAsInt\n");
+ }
+
+ void SceneGetValueAsShort(Bool_Int16& _return, const int8_t _sceneId, const RemoteValueID _valueId) {
+ // Your implementation goes here
+ printf("SceneGetValueAsShort\n");
+ }
+
+ void SceneGetValueAsString(Bool_String& _return, const int8_t _sceneId, const RemoteValueID _valueId) {
+ // Your implementation goes here
+ printf("SceneGetValueAsString\n");
+ }
+
+ void SceneGetValueListSelection_String(Bool_String& _return, const int8_t _sceneId, const RemoteValueID _valueId) {
+ // Your implementation goes here
+ printf("SceneGetValueListSelection_String\n");
+ }
+
+ void SceneGetValueListSelection_Int32(Bool_Int& _return, const int8_t _sceneId, const RemoteValueID _valueId) {
+ // Your implementation goes here
+ printf("SceneGetValueListSelection_Int32\n");
+ }
+
+ bool SetSceneValue_Bool(const int8_t _sceneId, const RemoteValueID _valueId, const bool _value) {
+ // Your implementation goes here
+ printf("SetSceneValue_Bool\n");
+ }
+
+ bool SetSceneValue_Uint8(const int8_t _sceneId, const RemoteValueID _valueId, const int8_t _value) {
+ // Your implementation goes here
+ printf("SetSceneValue_Uint8\n");
+ }
+
+ bool SetSceneValue_Float(const int8_t _sceneId, const RemoteValueID _valueId, const double _value) {
+ // Your implementation goes here
+ printf("SetSceneValue_Float\n");
+ }
+
+ bool SetSceneValue_Int32(const int8_t _sceneId, const RemoteValueID _valueId, const int32_t _value) {
+ // Your implementation goes here
+ printf("SetSceneValue_Int32\n");
+ }
+
+ bool SetSceneValue_Int16(const int8_t _sceneId, const RemoteValueID _valueId, const int16_t _value) {
+ // Your implementation goes here
+ printf("SetSceneValue_Int16\n");
+ }
+
+ bool SetSceneValue_String(const int8_t _sceneId, const RemoteValueID _valueId, const std::string& _value) {
+ // Your implementation goes here
+ printf("SetSceneValue_String\n");
+ }
+
+ bool SetSceneValueListSelection_String(const int8_t _sceneId, const RemoteValueID _valueId, const std::string& _value) {
+ // Your implementation goes here
+ printf("SetSceneValueListSelection_String\n");
+ }
+
+ bool SetSceneValueListSelection_Int32(const int8_t _sceneId, const RemoteValueID _valueId, const int32_t _value) {
+ // Your implementation goes here
+ printf("SetSceneValueListSelection_Int32\n");
+ }
+
+ void GetSceneLabel(std::string& _return, const int8_t _sceneId) {
+ // Your implementation goes here
+ printf("GetSceneLabel\n");
+ }
+
+ void SetSceneLabel(const int8_t _sceneId, const std::string& _value) {
+ // Your implementation goes here
+ printf("SetSceneLabel\n");
+ }
+
+ bool SceneExists(const int8_t _sceneId) {
+ // Your implementation goes here
+ printf("SceneExists\n");
+ }
+
+ bool ActivateScene(const int8_t _sceneId) {
+ // Your implementation goes here
+ printf("ActivateScene\n");
+ }
+
+};
+
+int main(int argc, char **argv) {
+ int port = 9090;
+ shared_ptr<RemoteManagerHandler> handler(new RemoteManagerHandler());
+ shared_ptr<TProcessor> processor(new RemoteManagerProcessor(handler));
+ shared_ptr<TServerTransport> serverTransport(new TServerSocket(port));
+ shared_ptr<TTransportFactory> transportFactory(new TBufferedTransportFactory());
+ shared_ptr<TProtocolFactory> protocolFactory(new TBinaryProtocolFactory());
+
+ TSimpleServer server(processor, serverTransport, transportFactory, protocolFactory);
+ server.serve();
+ return 0;
+}
+
View
16 gen-cpp/ozw_constants.cpp
@@ -0,0 +1,16 @@
+/**
+ * Autogenerated by Thrift Compiler (0.7.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ */
+#include "ozw_constants.h"
+
+namespace OpenZWave {
+
+const ozwConstants g_ozw_constants;
+
+ozwConstants::ozwConstants() {
+}
+
+} // namespace
+
View
23 gen-cpp/ozw_constants.h
@@ -0,0 +1,23 @@
+/**
+ * Autogenerated by Thrift Compiler (0.7.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ */
+#ifndef ozw_CONSTANTS_H
+#define ozw_CONSTANTS_H
+
+#include "ozw_types.h"
+
+namespace OpenZWave {
+
+class ozwConstants {
+ public:
+ ozwConstants();
+
+};
+
+extern const ozwConstants g_ozw_constants;
+
+} // namespace
+
+#endif
View
688 gen-cpp/ozw_types.cpp
@@ -0,0 +1,688 @@
+/**
+ * Autogenerated by Thrift Compiler (0.7.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ */
+#include "ozw_types.h"
+
+namespace OpenZWave {
+
+int _kRemoteValueGenreValues[] = {
+ RemoteValueGenre::ValueGenre_Basic,
+ RemoteValueGenre::ValueGenre_User,
+ RemoteValueGenre::ValueGenre_Config,
+ RemoteValueGenre::ValueGenre_System,
+ RemoteValueGenre::ValueGenre_Count
+};
+const char* _kRemoteValueGenreNames[] = {
+ "ValueGenre_Basic",
+ "ValueGenre_User",
+ "ValueGenre_Config",
+ "ValueGenre_System",
+ "ValueGenre_Count"
+};
+const std::map<int, const char*> _RemoteValueGenre_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(5, _kRemoteValueGenreValues, _kRemoteValueGenreNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
+
+int _kRemoteValueTypeValues[] = {
+ RemoteValueType::ValueType_Bool,
+ RemoteValueType::ValueType_Byte,
+ RemoteValueType::ValueType_Decimal,
+ RemoteValueType::ValueType_Int,
+ RemoteValueType::ValueType_List,
+ RemoteValueType::ValueType_Schedule,
+ RemoteValueType::ValueType_Short,
+ RemoteValueType::ValueType_String,
+ RemoteValueType::ValueType_Button,
+ RemoteValueType::ValueType_Max
+};
+const char* _kRemoteValueTypeNames[] = {
+ "ValueType_Bool",
+ "ValueType_Byte",
+ "ValueType_Decimal",
+ "ValueType_Int",
+ "ValueType_List",
+ "ValueType_Schedule",
+ "ValueType_Short",
+ "ValueType_String",
+ "ValueType_Button",
+ "ValueType_Max"
+};
+const std::map<int, const char*> _RemoteValueType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(10, _kRemoteValueTypeValues, _kRemoteValueTypeNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
+
+const char* GetSwitchPointReturnStruct::ascii_fingerprint = "0A77C25C826CC107FD266A55D263629B";
+const uint8_t GetSwitchPointReturnStruct::binary_fingerprint[16] = {0x0A,0x77,0xC2,0x5C,0x82,0x6C,0xC1,0x07,0xFD,0x26,0x6A,0x55,0xD2,0x63,0x62,0x9B};
+
+uint32_t GetSwitchPointReturnStruct::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_BYTE) {
+ xfer += iprot->readByte(this->o_hours);
+ this->__isset.o_hours = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_BYTE) {
+ xfer += iprot->readByte(this->o_minutes);
+ this->__isset.o_minutes = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_BYTE) {
+ xfer += iprot->readByte(this->o_setback);
+ this->__isset.o_setback = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t GetSwitchPointReturnStruct::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("GetSwitchPointReturnStruct");
+ xfer += oprot->writeFieldBegin("o_hours", ::apache::thrift::protocol::T_BYTE, 1);
+ xfer += oprot->writeByte(this->o_hours);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("o_minutes", ::apache::thrift::protocol::T_BYTE, 2);
+ xfer += oprot->writeByte(this->o_minutes);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("o_setback", ::apache::thrift::protocol::T_BYTE, 3);
+ xfer += oprot->writeByte(this->o_setback);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+const char* Bool_Bool::ascii_fingerprint = "403F0C4586060E367DA428DD09C59C9C";
+const uint8_t Bool_Bool::binary_fingerprint[16] = {0x40,0x3F,0x0C,0x45,0x86,0x06,0x0E,0x36,0x7D,0xA4,0x28,0xDD,0x09,0xC5,0x9C,0x9C};
+
+uint32_t Bool_Bool::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool(this->retval);
+ this->__isset.retval = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool(this->arg);
+ this->__isset.arg = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Bool_Bool::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Bool_Bool");
+ xfer += oprot->writeFieldBegin("retval", ::apache::thrift::protocol::T_BOOL, 1);
+ xfer += oprot->writeBool(this->retval);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("arg", ::apache::thrift::protocol::T_BOOL, 2);
+ xfer += oprot->writeBool(this->arg);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+const char* Bool_UInt8::ascii_fingerprint = "A65BD4DCABE29F39F7EDB1B158641972";
+const uint8_t Bool_UInt8::binary_fingerprint[16] = {0xA6,0x5B,0xD4,0xDC,0xAB,0xE2,0x9F,0x39,0xF7,0xED,0xB1,0xB1,0x58,0x64,0x19,0x72};
+
+uint32_t Bool_UInt8::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool(this->retval);
+ this->__isset.retval = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_BYTE) {
+ xfer += iprot->readByte(this->arg);
+ this->__isset.arg = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Bool_UInt8::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Bool_UInt8");
+ xfer += oprot->writeFieldBegin("retval", ::apache::thrift::protocol::T_BOOL, 1);
+ xfer += oprot->writeBool(this->retval);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("arg", ::apache::thrift::protocol::T_BYTE, 2);
+ xfer += oprot->writeByte(this->arg);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+const char* Bool_Float::ascii_fingerprint = "B799A8FF13E94F63DAEEFC9FBBD641CF";
+const uint8_t Bool_Float::binary_fingerprint[16] = {0xB7,0x99,0xA8,0xFF,0x13,0xE9,0x4F,0x63,0xDA,0xEE,0xFC,0x9F,0xBB,0xD6,0x41,0xCF};
+
+uint32_t Bool_Float::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool(this->retval);
+ this->__isset.retval = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_DOUBLE) {
+ xfer += iprot->readDouble(this->arg);
+ this->__isset.arg = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Bool_Float::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Bool_Float");
+ xfer += oprot->writeFieldBegin("retval", ::apache::thrift::protocol::T_BOOL, 1);
+ xfer += oprot->writeBool(this->retval);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("arg", ::apache::thrift::protocol::T_DOUBLE, 2);
+ xfer += oprot->writeDouble(this->arg);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+const char* Bool_Int::ascii_fingerprint = "88440F45A63E63607868B983E4E50558";
+const uint8_t Bool_Int::binary_fingerprint[16] = {0x88,0x44,0x0F,0x45,0xA6,0x3E,0x63,0x60,0x78,0x68,0xB9,0x83,0xE4,0xE5,0x05,0x58};
+
+uint32_t Bool_Int::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool(this->retval);
+ this->__isset.retval = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_I32) {
+ xfer += iprot->readI32(this->arg);
+ this->__isset.arg = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Bool_Int::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Bool_Int");
+ xfer += oprot->writeFieldBegin("retval", ::apache::thrift::protocol::T_BOOL, 1);
+ xfer += oprot->writeBool(this->retval);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("arg", ::apache::thrift::protocol::T_I32, 2);
+ xfer += oprot->writeI32(this->arg);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+const char* Bool_Int16::ascii_fingerprint = "4569DC9D7756C822FCF8EB7EFD6EF661";
+const uint8_t Bool_Int16::binary_fingerprint[16] = {0x45,0x69,0xDC,0x9D,0x77,0x56,0xC8,0x22,0xFC,0xF8,0xEB,0x7E,0xFD,0x6E,0xF6,0x61};
+
+uint32_t Bool_Int16::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool(this->retval);
+ this->__isset.retval = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_I16) {
+ xfer += iprot->readI16(this->arg);
+ this->__isset.arg = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Bool_Int16::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Bool_Int16");
+ xfer += oprot->writeFieldBegin("retval", ::apache::thrift::protocol::T_BOOL, 1);
+ xfer += oprot->writeBool(this->retval);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("arg", ::apache::thrift::protocol::T_I16, 2);
+ xfer += oprot->writeI16(this->arg);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+const char* Bool_String::ascii_fingerprint = "1767FFB0CB3D9275BC64B198AB3B8A8B";
+const uint8_t Bool_String::binary_fingerprint[16] = {0x17,0x67,0xFF,0xB0,0xCB,0x3D,0x92,0x75,0xBC,0x64,0xB1,0x98,0xAB,0x3B,0x8A,0x8B};
+
+uint32_t Bool_String::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool(this->retval);
+ this->__isset.retval = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->arg);
+ this->__isset.arg = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Bool_String::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Bool_String");
+ xfer += oprot->writeFieldBegin("retval", ::apache::thrift::protocol::T_BOOL, 1);
+ xfer += oprot->writeBool(this->retval);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("arg", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->arg);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+const char* Bool_ListString::ascii_fingerprint = "D41147785C488E7FFDCF1B17BF20AC0F";
+const uint8_t Bool_ListString::binary_fingerprint[16] = {0xD4,0x11,0x47,0x78,0x5C,0x48,0x8E,0x7F,0xFD,0xCF,0x1B,0x17,0xBF,0x20,0xAC,0x0F};
+
+uint32_t Bool_ListString::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool(this->retval);
+ this->__isset.retval = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->arg.clear();
+ uint32_t _size0;
+ ::apache::thrift::protocol::TType _etype3;
+ iprot->readListBegin(_etype3, _size0);
+ this->arg.resize(_size0);
+ uint32_t _i4;
+ for (_i4 = 0; _i4 < _size0; ++_i4)
+ {
+ xfer += iprot->readString(this->arg[_i4]);
+ }
+ iprot->readListEnd();
+ }
+ this->__isset.arg = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Bool_ListString::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Bool_ListString");
+ xfer += oprot->writeFieldBegin("retval", ::apache::thrift::protocol::T_BOOL, 1);
+ xfer += oprot->writeBool(this->retval);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("arg", ::apache::thrift::protocol::T_LIST, 2);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->arg.size()));
+ std::vector<std::string> ::const_iterator _iter5;
+ for (_iter5 = this->arg.begin(); _iter5 != this->arg.end(); ++_iter5)
+ {
+ xfer += oprot->writeString((*_iter5));
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+const char* UInt32_ListByte::ascii_fingerprint = "C69B8D458340D01227B2A605EFE33F77";
+const uint8_t UInt32_ListByte::binary_fingerprint[16] = {0xC6,0x9B,0x8D,0x45,0x83,0x40,0xD0,0x12,0x27,0xB2,0xA6,0x05,0xEF,0xE3,0x3F,0x77};
+
+uint32_t UInt32_ListByte::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_I32) {
+ xfer += iprot->readI32(this->retval);
+ this->__isset.retval = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->arg.clear();
+ uint32_t _size6;
+ ::apache::thrift::protocol::TType _etype9;
+ iprot->readListBegin(_etype9, _size6);
+ this->arg.resize(_size6);
+ uint32_t _i10;
+ for (_i10 = 0; _i10 < _size6; ++_i10)
+ {
+ xfer += iprot->readByte(this->arg[_i10]);
+ }
+ iprot->readListEnd();
+ }
+ this->__isset.arg = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t UInt32_ListByte::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("UInt32_ListByte");
+ xfer += oprot->writeFieldBegin("retval", ::apache::thrift::protocol::T_I32, 1);
+ xfer += oprot->writeI32(this->retval);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("arg", ::apache::thrift::protocol::T_LIST, 2);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_BYTE, static_cast<uint32_t>(this->arg.size()));
+ std::vector<int8_t> ::const_iterator _iter11;
+ for (_iter11 = this->arg.begin(); _iter11 != this->arg.end(); ++_iter11)
+ {
+ xfer += oprot->writeByte((*_iter11));
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+} // namespace
View
503 gen-cpp/ozw_types.h
@@ -0,0 +1,503 @@
+/**
+ * Autogenerated by Thrift Compiler (0.7.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ */
+#ifndef ozw_TYPES_H
+#define ozw_TYPES_H
+
+#include <Thrift.h>
+#include <TApplicationException.h>
+#include <protocol/TProtocol.h>
+#include <transport/TTransport.h>
+
+
+#include "Manager.h"
+#include "ValueID.h"
+#include "Options.h"
+
+namespace OpenZWave {
+
+struct RemoteValueGenre {
+ enum type {
+ ValueGenre_Basic = 0,
+ ValueGenre_User = 1,
+ ValueGenre_Config = 2,
+ ValueGenre_System = 3,
+ ValueGenre_Count = 4
+ };
+};
+
+extern const std::map<int, const char*> _RemoteValueGenre_VALUES_TO_NAMES;
+
+struct RemoteValueType {
+ enum type {
+ ValueType_Bool = 0,
+ ValueType_Byte = 1,
+ ValueType_Decimal = 2,
+ ValueType_Int = 3,
+ ValueType_List = 4,
+ ValueType_Schedule = 5,
+ ValueType_Short = 6,
+ ValueType_String = 7,
+ ValueType_Button = 8,
+ ValueType_Max = 8
+ };
+};
+
+extern const std::map<int, const char*> _RemoteValueType_VALUES_TO_NAMES;
+
+typedef int64_t RemoteValueID;
+
+typedef struct _GetSwitchPointReturnStruct__isset {
+ _GetSwitchPointReturnStruct__isset() : o_hours(false), o_minutes(false), o_setback(false) {}
+ bool o_hours;
+ bool o_minutes;
+ bool o_setback;
+} _GetSwitchPointReturnStruct__isset;
+
+class GetSwitchPointReturnStruct {
+ public:
+
+ static const char* ascii_fingerprint; // = "0A77C25C826CC107FD266A55D263629B";
+ static const uint8_t binary_fingerprint[16]; // = {0x0A,0x77,0xC2,0x5C,0x82,0x6C,0xC1,0x07,0xFD,0x26,0x6A,0x55,0xD2,0x63,0x62,0x9B};
+
+ GetSwitchPointReturnStruct() : o_hours(0), o_minutes(0), o_setback(0) {
+ }
+
+ virtual ~GetSwitchPointReturnStruct() throw() {}
+
+ int8_t o_hours;
+ int8_t o_minutes;
+ int8_t o_setback;
+
+ _GetSwitchPointReturnStruct__isset __isset;
+
+ void __set_o_hours(const int8_t val) {
+ o_hours = val;
+ }
+
+ void __set_o_minutes(const int8_t val) {
+ o_minutes = val;
+ }
+
+ void __set_o_setback(const int8_t val) {
+ o_setback = val;
+ }
+
+ bool operator == (const GetSwitchPointReturnStruct & rhs) const
+ {
+ if (!(o_hours == rhs.o_hours))
+ return false;
+ if (!(o_minutes == rhs.o_minutes))
+ return false;
+ if (!(o_setback == rhs.o_setback))
+ return false;
+ return true;
+ }
+ bool operator != (const GetSwitchPointReturnStruct &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const GetSwitchPointReturnStruct & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Bool_Bool__isset {
+ _Bool_Bool__isset() : retval(false), arg(false) {}
+ bool retval;
+ bool arg;
+} _Bool_Bool__isset;
+
+class Bool_Bool {
+ public:
+
+ static const char* ascii_fingerprint; // = "403F0C4586060E367DA428DD09C59C9C";
+ static const uint8_t binary_fingerprint[16]; // = {0x40,0x3F,0x0C,0x45,0x86,0x06,0x0E,0x36,0x7D,0xA4,0x28,0xDD,0x09,0xC5,0x9C,0x9C};
+
+ Bool_Bool() : retval(0), arg(0) {
+ }
+
+ virtual ~Bool_Bool() throw() {}
+
+ bool retval;
+ bool arg;
+
+ _Bool_Bool__isset __isset;
+
+ void __set_retval(const bool val) {
+ retval = val;
+ }
+
+ void __set_arg(const bool val) {
+ arg = val;
+ }
+
+ bool operator == (const Bool_Bool & rhs) const
+ {
+ if (!(retval == rhs.retval))
+ return false;
+ if (!(arg == rhs.arg))
+ return false;
+ return true;
+ }
+ bool operator != (const Bool_Bool &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Bool_Bool & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Bool_UInt8__isset {
+ _Bool_UInt8__isset() : retval(false), arg(false) {}
+ bool retval;
+ bool arg;
+} _Bool_UInt8__isset;
+
+class Bool_UInt8 {
+ public:
+
+ static const char* ascii_fingerprint; // = "A65BD4DCABE29F39F7EDB1B158641972";
+ static const uint8_t binary_fingerprint[16]; // = {0xA6,0x5B,0xD4,0xDC,0xAB,0xE2,0x9F,0x39,0xF7,0xED,0xB1,0xB1,0x58,0x64,0x19,0x72};
+
+ Bool_UInt8() : retval(0), arg(0) {
+ }
+
+ virtual ~Bool_UInt8() throw() {}
+
+ bool retval;
+ int8_t arg;
+
+ _Bool_UInt8__isset __isset;
+
+ void __set_retval(const bool val) {
+ retval = val;
+ }
+
+ void __set_arg(const int8_t val) {
+ arg = val;
+ }
+
+ bool operator == (const Bool_UInt8 & rhs) const
+ {
+ if (!(retval == rhs.retval))
+ return false;
+ if (!(arg == rhs.arg))
+ return false;
+ return true;
+ }
+ bool operator != (const Bool_UInt8 &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Bool_UInt8 & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Bool_Float__isset {
+ _Bool_Float__isset() : retval(false), arg(false) {}
+ bool retval;
+ bool arg;
+} _Bool_Float__isset;
+
+class Bool_Float {
+ public:
+
+ static const char* ascii_fingerprint; // = "B799A8FF13E94F63DAEEFC9FBBD641CF";
+ static const uint8_t binary_fingerprint[16]; // = {0xB7,0x99,0xA8,0xFF,0x13,0xE9,0x4F,0x63,0xDA,0xEE,0xFC,0x9F,0xBB,0xD6,0x41,0xCF};
+
+ Bool_Float() : retval(0), arg(0) {
+ }
+
+ virtual ~Bool_Float() throw() {}
+
+ bool retval;
+ double arg;
+
+ _Bool_Float__isset __isset;
+
+ void __set_retval(const bool val) {
+ retval = val;
+ }
+
+ void __set_arg(const double val) {
+ arg = val;
+ }
+
+ bool operator == (const Bool_Float & rhs) const
+ {
+ if (!(retval == rhs.retval))
+ return false;
+ if (!(arg == rhs.arg))
+ return false;
+ return true;
+ }
+ bool operator != (const Bool_Float &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Bool_Float & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Bool_Int__isset {
+ _Bool_Int__isset() : retval(false), arg(false) {}
+ bool retval;
+ bool arg;
+} _Bool_Int__isset;
+
+class Bool_Int {
+ public:
+
+ static const char* ascii_fingerprint; // = "88440F45A63E63607868B983E4E50558";
+ static const uint8_t binary_fingerprint[16]; // = {0x88,0x44,0x0F,0x45,0xA6,0x3E,0x63,0x60,0x78,0x68,0xB9,0x83,0xE4,0xE5,0x05,0x58};
+
+ Bool_Int() : retval(0), arg(0) {
+ }
+
+ virtual ~Bool_Int() throw() {}
+
+ bool retval;
+ int32_t arg;
+
+ _Bool_Int__isset __isset;
+
+ void __set_retval(const bool val) {
+ retval = val;
+ }
+
+ void __set_arg(const int32_t val) {
+ arg = val;
+ }
+
+ bool operator == (const Bool_Int & rhs) const
+ {
+ if (!(retval == rhs.retval))
+ return false;
+ if (!(arg == rhs.arg))
+ return false;
+ return true;
+ }
+ bool operator != (const Bool_Int &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Bool_Int & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Bool_Int16__isset {
+ _Bool_Int16__isset() : retval(false), arg(false) {}
+ bool retval;
+ bool arg;
+} _Bool_Int16__isset;
+
+class Bool_Int16 {
+ public:
+
+ static const char* ascii_fingerprint; // = "4569DC9D7756C822FCF8EB7EFD6EF661";
+ static const uint8_t binary_fingerprint[16]; // = {0x45,0x69,0xDC,0x9D,0x77,0x56,0xC8,0x22,0xFC,0xF8,0xEB,0x7E,0xFD,0x6E,0xF6,0x61};
+
+ Bool_Int16() : retval(0), arg(0) {
+ }
+
+ virtual ~Bool_Int16() throw() {}
+
+ bool retval;
+ int16_t arg;
+
+ _Bool_Int16__isset __isset;
+
+ void __set_retval(const bool val) {
+ retval = val;
+ }
+
+ void __set_arg(const int16_t val) {
+ arg = val;
+ }
+
+ bool operator == (const Bool_Int16 & rhs) const
+ {
+ if (!(retval == rhs.retval))
+ return false;
+ if (!(arg == rhs.arg))
+ return false;
+ return true;
+ }
+ bool operator != (const Bool_Int16 &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Bool_Int16 & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Bool_String__isset {
+ _Bool_String__isset() : retval(false), arg(false) {}
+ bool retval;
+ bool arg;
+} _Bool_String__isset;
+
+class Bool_String {
+ public:
+
+ static const char* ascii_fingerprint; // = "1767FFB0CB3D9275BC64B198AB3B8A8B";
+ static const uint8_t binary_fingerprint[16]; // = {0x17,0x67,0xFF,0xB0,0xCB,0x3D,0x92,0x75,0xBC,0x64,0xB1,0x98,0xAB,0x3B,0x8A,0x8B};