Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Browse files

SendAllValues(), auto patch management

  • Loading branch information...
commit 205116aa26698dcbc001aed19555f1bd80718c04 1 parent 67efa38
Elias Karakoulakis authored
View
1  gen-cocoa/ozw.h
@@ -606,6 +606,7 @@ enum OpenZWaveRemoteValueType {
- (void) SetSceneLabel: (uint8_t) _sceneId : (NSString *) _value; // throws TException
- (BOOL) SceneExists: (uint8_t) _sceneId; // throws TException
- (BOOL) ActivateScene: (uint8_t) _sceneId; // throws TException
+- (void) SendAllValues; // throws TException
@end
@interface OpenZWaveRemoteManagerClient : NSObject <OpenZWaveRemoteManager> {
View
175 gen-cocoa/ozw.m
@@ -38607,6 +38607,125 @@ - (NSString *) description {
@end
+@interface OpenZWaveSendAllValues_args : NSObject <NSCoding> {
+}
+
+
+- (void) read: (id <TProtocol>) inProtocol;
+- (void) write: (id <TProtocol>) outProtocol;
+
+@end
+
+@implementation OpenZWaveSendAllValues_args
+
+- (id) initWithCoder: (NSCoder *) decoder
+{
+ self = [super init];
+ return self;
+}
+
+- (void) encodeWithCoder: (NSCoder *) encoder
+{
+}
+
+- (void) read: (id <TProtocol>) inProtocol
+{
+ NSString * fieldName;
+ int fieldType;
+ int fieldID;
+
+ [inProtocol readStructBeginReturningName: NULL];
+ while (true)
+ {
+ [inProtocol readFieldBeginReturningName: &fieldName type: &fieldType fieldID: &fieldID];
+ if (fieldType == TType_STOP) {
+ break;
+ }
+ switch (fieldID)
+ {
+ default:
+ [TProtocolUtil skipType: fieldType onProtocol: inProtocol];
+ break;
+ }
+ [inProtocol readFieldEnd];
+ }
+ [inProtocol readStructEnd];
+}
+
+- (void) write: (id <TProtocol>) outProtocol {
+ [outProtocol writeStructBeginWithName: @"SendAllValues_args"];
+ [outProtocol writeFieldStop];
+ [outProtocol writeStructEnd];
+}
+
+- (NSString *) description {
+ NSMutableString * ms = [NSMutableString stringWithString: @"SendAllValues_args("];
+ [ms appendString: @")"];
+ return [NSString stringWithString: ms];
+}
+
+@end
+
+@interface OpenZWaveSendAllValues_result : NSObject <NSCoding> {
+}
+
+
+- (void) read: (id <TProtocol>) inProtocol;
+- (void) write: (id <TProtocol>) outProtocol;
+
+@end
+
+@implementation OpenZWaveSendAllValues_result
+
+- (id) initWithCoder: (NSCoder *) decoder
+{
+ self = [super init];
+ return self;
+}
+
+- (void) encodeWithCoder: (NSCoder *) encoder
+{
+}
+
+- (void) read: (id <TProtocol>) inProtocol
+{
+ NSString * fieldName;
+ int fieldType;
+ int fieldID;
+
+ [inProtocol readStructBeginReturningName: NULL];
+ while (true)
+ {
+ [inProtocol readFieldBeginReturningName: &fieldName type: &fieldType fieldID: &fieldID];
+ if (fieldType == TType_STOP) {
+ break;
+ }
+ switch (fieldID)
+ {
+ default:
+ [TProtocolUtil skipType: fieldType onProtocol: inProtocol];
+ break;
+ }
+ [inProtocol readFieldEnd];
+ }
+ [inProtocol readStructEnd];
+}
+
+- (void) write: (id <TProtocol>) outProtocol {
+ [outProtocol writeStructBeginWithName: @"SendAllValues_result"];
+
+ [outProtocol writeFieldStop];
+ [outProtocol writeStructEnd];
+}
+
+- (NSString *) description {
+ NSMutableString * ms = [NSMutableString stringWithString: @"SendAllValues_result("];
+ [ms appendString: @")"];
+ return [NSString stringWithString: ms];
+}
+
+@end
+
@implementation OpenZWaveRemoteManagerClient
- (id) initWithProtocol: (id <TProtocol>) protocol
{
@@ -43733,6 +43852,37 @@ - (BOOL) ActivateScene: (uint8_t) _sceneId
return [self recv_ActivateScene];
}
+- (void) send_SendAllValues
+{
+ [outProtocol writeMessageBeginWithName: @"SendAllValues" type: TMessageType_CALL sequenceID: 0];
+ [outProtocol writeStructBeginWithName: @"SendAllValues_args"];
+ [outProtocol writeFieldStop];
+ [outProtocol writeStructEnd];
+ [outProtocol writeMessageEnd];
+ [[outProtocol transport] flush];
+}
+
+- (void) recv_SendAllValues
+{
+ int msgType = 0;
+ [inProtocol readMessageBeginReturningName: nil type: &msgType sequenceID: NULL];
+ if (msgType == TMessageType_EXCEPTION) {
+ TApplicationException * x = [TApplicationException read: inProtocol];
+ [inProtocol readMessageEnd];
+ @throw x;
+ }
+ OpenZWaveSendAllValues_result * result = [[[OpenZWaveSendAllValues_result alloc] init] autorelease];
+ [result read: inProtocol];
+ [inProtocol readMessageEnd];
+ return;
+}
+
+- (void) SendAllValues
+{
+ [self send_SendAllValues];
+ [self recv_SendAllValues];
+}
+
@end
@implementation OpenZWaveRemoteManagerProcessor
@@ -44737,6 +44887,14 @@ - (id) initWithRemoteManager: (id <OpenZWaveRemoteManager>) service
[invocation retainArguments];
[mMethodMap setValue: invocation forKey: @"ActivateScene"];
}
+ {
+ SEL s = @selector(process_SendAllValues_withSequenceID:inProtocol:outProtocol:);
+ NSMethodSignature * sig = [self methodSignatureForSelector: s];
+ NSInvocation * invocation = [NSInvocation invocationWithMethodSignature: sig];
+ [invocation setSelector: s];
+ [invocation retainArguments];
+ [mMethodMap setValue: invocation forKey: @"SendAllValues"];
+ }
return self;
}
@@ -46886,6 +47044,23 @@ - (void) process_ActivateScene_withSequenceID: (int32_t) seqID inProtocol: (id<T
[args release];
}
+- (void) process_SendAllValues_withSequenceID: (int32_t) seqID inProtocol: (id<TProtocol>) inProtocol outProtocol: (id<TProtocol>) outProtocol
+{
+ OpenZWaveSendAllValues_args * args = [[OpenZWaveSendAllValues_args alloc] init];
+ [args read: inProtocol];
+ [inProtocol readMessageEnd];
+ OpenZWaveSendAllValues_result * result = [[OpenZWaveSendAllValues_result alloc] init];
+ [mService SendAllValues];
+ [outProtocol writeMessageBeginWithName: @"SendAllValues"
+ type: TMessageType_REPLY
+ sequenceID: seqID];
+ [result write: outProtocol];
+ [outProtocol writeMessageEnd];
+ [[outProtocol transport] flush];
+ [result release];
+ [args release];
+}
+
- (void) dealloc
{
[mService release];
View
228 gen-cpp/RemoteManager.cpp
@@ -20663,6 +20663,129 @@ uint32_t RemoteManager_ActivateScene_presult::read(::apache::thrift::protocol::T
return xfer;
}
+uint32_t RemoteManager_SendAllValues_args::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)
+ {
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t RemoteManager_SendAllValues_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("RemoteManager_SendAllValues_args");
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t RemoteManager_SendAllValues_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("RemoteManager_SendAllValues_pargs");
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t RemoteManager_SendAllValues_result::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)
+ {
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t RemoteManager_SendAllValues_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+ uint32_t xfer = 0;
+
+ xfer += oprot->writeStructBegin("RemoteManager_SendAllValues_result");
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t RemoteManager_SendAllValues_presult::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)
+ {
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
void RemoteManagerClient::WriteConfig(const int32_t _homeId)
{
send_WriteConfig(_homeId);
@@ -27854,6 +27977,58 @@ bool RemoteManagerClient::recv_ActivateScene()
throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "ActivateScene failed: unknown result");
}
+void RemoteManagerClient::SendAllValues()
+{
+ send_SendAllValues();
+ recv_SendAllValues();
+}
+
+void RemoteManagerClient::send_SendAllValues()
+{
+ int32_t cseqid = 0;
+ oprot_->writeMessageBegin("SendAllValues", ::apache::thrift::protocol::T_CALL, cseqid);
+
+ RemoteManager_SendAllValues_pargs args;
+ args.write(oprot_);
+
+ oprot_->writeMessageEnd();
+ oprot_->getTransport()->writeEnd();
+ oprot_->getTransport()->flush();
+}
+
+void RemoteManagerClient::recv_SendAllValues()
+{
+
+ int32_t rseqid = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TMessageType mtype;
+
+ iprot_->readMessageBegin(fname, mtype, rseqid);
+ if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+ ::apache::thrift::TApplicationException x;
+ x.read(iprot_);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ throw x;
+ }
+ if (mtype != ::apache::thrift::protocol::T_REPLY) {
+ iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ }
+ if (fname.compare("SendAllValues") != 0) {
+ iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ }
+ RemoteManager_SendAllValues_presult result;
+ result.read(iprot_);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+
+ return;
+}
+
bool RemoteManagerProcessor::process(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot, void* callContext) {
::apache::thrift::protocol::TProtocol* iprot = piprot.get();
@@ -34573,5 +34748,58 @@ void RemoteManagerProcessor::process_ActivateScene(int32_t seqid, ::apache::thri
}
}
+void RemoteManagerProcessor::process_SendAllValues(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
+{
+ void* ctx = NULL;
+ if (eventHandler_.get() != NULL) {
+ ctx = eventHandler_->getContext("RemoteManager.SendAllValues", callContext);
+ }
+ ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "RemoteManager.SendAllValues");
+
+ if (eventHandler_.get() != NULL) {
+ eventHandler_->preRead(ctx, "RemoteManager.SendAllValues");
+ }
+
+ RemoteManager_SendAllValues_args args;
+ args.read(iprot);
+ iprot->readMessageEnd();
+ uint32_t bytes = iprot->getTransport()->readEnd();
+
+ if (eventHandler_.get() != NULL) {
+ eventHandler_->postRead(ctx, "RemoteManager.SendAllValues", bytes);
+ }
+
+ RemoteManager_SendAllValues_result result;
+ try {
+ iface_->SendAllValues();
+ } catch (const std::exception& e) {
+ if (eventHandler_.get() != NULL) {
+ eventHandler_->handlerError(ctx, "RemoteManager.SendAllValues");
+ }
+
+ ::apache::thrift::TApplicationException x(e.what());
+ oprot->writeMessageBegin("SendAllValues", ::apache::thrift::protocol::T_EXCEPTION, seqid);
+ x.write(oprot);
+ oprot->writeMessageEnd();
+ oprot->getTransport()->writeEnd();
+ oprot->getTransport()->flush();
+ return;
+ }
+
+ if (eventHandler_.get() != NULL) {
+ eventHandler_->preWrite(ctx, "RemoteManager.SendAllValues");
+ }
+
+ oprot->writeMessageBegin("SendAllValues", ::apache::thrift::protocol::T_REPLY, seqid);
+ result.write(oprot);
+ oprot->writeMessageEnd();
+ bytes = oprot->getTransport()->writeEnd();
+ oprot->getTransport()->flush();
+
+ if (eventHandler_.get() != NULL) {
+ eventHandler_->postWrite(ctx, "RemoteManager.SendAllValues", bytes);
+ }
+}
+
} // namespace
View
90 gen-cpp/RemoteManager.h
@@ -138,6 +138,7 @@ class RemoteManagerIf {
virtual void SetSceneLabel(const int8_t _sceneId, const std::string& _value) = 0;
virtual bool SceneExists(const int8_t _sceneId) = 0;
virtual bool ActivateScene(const int8_t _sceneId) = 0;
+ virtual void SendAllValues() = 0;
};
class RemoteManagerNull : virtual public RemoteManagerIf {
@@ -578,6 +579,9 @@ class RemoteManagerNull : virtual public RemoteManagerIf {
bool _return = false;
return _return;
}
+ void SendAllValues() {
+ return;
+ }
};
typedef struct _RemoteManager_WriteConfig_args__isset {
@@ -14493,6 +14497,80 @@ class RemoteManager_ActivateScene_presult {
};
+
+class RemoteManager_SendAllValues_args {
+ public:
+
+ RemoteManager_SendAllValues_args() {
+ }
+
+ virtual ~RemoteManager_SendAllValues_args() throw() {}
+
+
+ bool operator == (const RemoteManager_SendAllValues_args & /* rhs */) const
+ {
+ return true;
+ }
+ bool operator != (const RemoteManager_SendAllValues_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const RemoteManager_SendAllValues_args & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class RemoteManager_SendAllValues_pargs {
+ public:
+
+
+ virtual ~RemoteManager_SendAllValues_pargs() throw() {}
+
+
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class RemoteManager_SendAllValues_result {
+ public:
+
+ RemoteManager_SendAllValues_result() {
+ }
+
+ virtual ~RemoteManager_SendAllValues_result() throw() {}
+
+
+ bool operator == (const RemoteManager_SendAllValues_result & /* rhs */) const
+ {
+ return true;
+ }
+ bool operator != (const RemoteManager_SendAllValues_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const RemoteManager_SendAllValues_result & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class RemoteManager_SendAllValues_presult {
+ public:
+
+
+ virtual ~RemoteManager_SendAllValues_presult() throw() {}
+
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
class RemoteManagerClient : virtual public RemoteManagerIf {
public:
RemoteManagerClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) :
@@ -14885,6 +14963,9 @@ class RemoteManagerClient : virtual public RemoteManagerIf {
bool ActivateScene(const int8_t _sceneId);
void send_ActivateScene(const int8_t _sceneId);
bool recv_ActivateScene();
+ void SendAllValues();
+ void send_SendAllValues();
+ void recv_SendAllValues();
protected:
boost::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_;
boost::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_;
@@ -15022,6 +15103,7 @@ class RemoteManagerProcessor : virtual public ::apache::thrift::TProcessor {
void process_SetSceneLabel(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
void process_SceneExists(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
void process_ActivateScene(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+ void process_SendAllValues(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
public:
RemoteManagerProcessor(boost::shared_ptr<RemoteManagerIf> iface) :
iface_(iface) {
@@ -15149,6 +15231,7 @@ class RemoteManagerProcessor : virtual public ::apache::thrift::TProcessor {
processMap_["SetSceneLabel"] = &RemoteManagerProcessor::process_SetSceneLabel;
processMap_["SceneExists"] = &RemoteManagerProcessor::process_SceneExists;
processMap_["ActivateScene"] = &RemoteManagerProcessor::process_ActivateScene;
+ processMap_["SendAllValues"] = &RemoteManagerProcessor::process_SendAllValues;
}
virtual bool process(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot, void* callContext);
@@ -16482,6 +16565,13 @@ class RemoteManagerMultiface : virtual public RemoteManagerIf {
}
}
+ void SendAllValues() {
+ size_t sz = ifaces_.size();
+ for (size_t i = 0; i < sz; ++i) {
+ ifaces_[i]->SendAllValues();
+ }
+ }
+
};
} // namespace
View
4 gen-cpp/RemoteManager_server.cpp
@@ -970,6 +970,10 @@ class RemoteManagerHandler : virtual public RemoteManagerIf {
return(function_result);
}
+ void SendAllValues() {
+ send_all_values();
+ }
+
};
// int main(int argc, char **argv) {
View
53 gen-cpp/RemoteManager_server.cpp.patch
@@ -0,0 +1,53 @@
+220a221
+> uint8* arr;
+223c224
+< _return.retval = mgr->GetNodeNeighbors((::uint32 const) _homeId, (::uint8 const) _nodeId, (::uint8**) &_return._nodeNeighbors);
+---
+> _return.retval = mgr->GetNodeNeighbors((::uint32 const) _homeId, (::uint8 const) _nodeId, (::uint8**) &arr);
+224a226,229
+> if (_return.retval > 0) {
+> for (int i=0; i<_return.retval; i++) _return._nodeNeighbors.push_back(arr[i]);
+> delete arr;
+> }
+646a652
+> uint8* o_associations;
+649c655
+< _return.retval = mgr->GetAssociations((::uint32 const) _homeId, (::uint8 const) _nodeId, (::uint8 const) _groupIdx, (::uint8**) &_return.o_associations);
+---
+> _return.retval = mgr->GetAssociations((::uint32 const) _homeId, (::uint8 const) _nodeId, (::uint8 const) _groupIdx, (::uint8**) &o_associations);
+650a657,660
+> if (_return.retval > 0) {
+> for (int i=0; i<_return.retval; i++) _return.o_associations.push_back(o_associations[i]);
+> delete o_associations;
+> }
+704a715
+> uint8* _sceneIds;
+707c718
+< _return.retval = mgr->GetAllScenes((::uint8**) &_return._sceneIds);
+---
+> _return.retval = mgr->GetAllScenes((::uint8**) &_sceneIds);
+709c720,724
+< }
+---
+> if (_return.retval>0) {
+> for (int i=0; i<_return.retval; i++) _return._sceneIds.push_back(_sceneIds[i]);
+> delete(_sceneIds);
+> }
+> }
+799a815
+> std::vector<OpenZWave::ValueID> o_values;
+802c818
+< _return.retval = mgr->SceneGetValues((::uint8 const) _sceneId, _return.o_value.toValueID());
+---
+> _return.retval = mgr->SceneGetValues((::uint8 const) _sceneId, &o_values);
+803a820
+> for (int i=0; i< _return.retval; i++) _return.o_value.push_back(RemoteValueID(o_values[i]));
+957,958c974
+< // Your implementation goes here
+< printf("SendAllValues\n");
+---
+> send_all_values();
+960c976
+<
+---
+>
View
4 gen-cpp/RemoteManager_server.preserve.cpp
@@ -970,6 +970,10 @@ class RemoteManagerHandler : virtual public RemoteManagerIf {
return(function_result);
}
+ void SendAllValues() {
+ send_all_values();
+ }
+
};
// int main(int argc, char **argv) {
View
5 gen-cpp/RemoteManager_server.skeleton.cpp
@@ -642,6 +642,11 @@ class RemoteManagerHandler : virtual public RemoteManagerIf {
printf("ActivateScene\n");
}
+ void SendAllValues() {
+ // Your implementation goes here
+ printf("SendAllValues\n");
+ }
+
};
int main(int argc, char **argv) {
View
29 gen-cpp/ozw_types.h
@@ -79,20 +79,6 @@ class RemoteValueID {
_RemoteValueID__isset __isset;
-// ekarak: constructor from ValueID
- RemoteValueID(ValueID vid) :
- _homeId ((int32_t) vid.GetHomeId()),
- _nodeId ((int8_t) vid.GetNodeId()),
- _genre ((RemoteValueGenre::type) vid.GetGenre()),
- _commandClassId((int8_t) vid.GetCommandClassId()),
- _instance ((int8_t) vid.GetInstance()),
- _valueIndex((int8_t) vid.GetIndex()),
- _type ((RemoteValueType::type) vid.GetType()) { }
-// ekarak: converter to ValueID
-ValueID toValueID() const {
- return ValueID((uint32)_homeId, (uint8)_nodeId, (ValueID::ValueGenre)_genre, (uint8)_commandClassId, (uint8)_instance, (uint8)_valueIndex, (ValueID::ValueType)_type);
-}
-
void __set__homeId(const int32_t val) {
_homeId = val;
}
@@ -148,6 +134,21 @@ ValueID toValueID() const {
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+ // ekarak: constructor from ValueID
+ RemoteValueID(ValueID vid) :
+ _homeId ((int32_t) vid.GetHomeId()),
+ _nodeId ((int8_t) vid.GetNodeId()),
+ _genre ((RemoteValueGenre::type) vid.GetGenre()),
+ _commandClassId((int8_t) vid.GetCommandClassId()),
+ _instance ((int8_t) vid.GetInstance()),
+ _valueIndex((int8_t) vid.GetIndex()),
+ _type ((RemoteValueType::type) vid.GetType()) { }
+// ekarak: converter to ValueID
+ValueID toValueID() const {
+ return ValueID((uint32)_homeId, (uint8)_nodeId, (ValueID::ValueGenre)_genre, (uint8)_commandClassId, (uint8)_instance, (uint8)_valueIndex, (ValueID::ValueType)_type);
+}
+
+
};
typedef struct _GetSwitchPointReturnStruct__isset {
View
16 gen-cpp/ozw_types.h.patch
@@ -0,0 +1,16 @@
+136a137,151
+> // ekarak: constructor from ValueID
+> RemoteValueID(ValueID vid) :
+> _homeId ((int32_t) vid.GetHomeId()),
+> _nodeId ((int8_t) vid.GetNodeId()),
+> _genre ((RemoteValueGenre::type) vid.GetGenre()),
+> _commandClassId((int8_t) vid.GetCommandClassId()),
+> _instance ((int8_t) vid.GetInstance()),
+> _valueIndex((int8_t) vid.GetIndex()),
+> _type ((RemoteValueType::type) vid.GetType()) { }
+> // ekarak: converter to ValueID
+> ValueID toValueID() const {
+> return ValueID((uint32)_homeId, (uint8)_nodeId, (ValueID::ValueGenre)_genre, (uint8)_commandClassId, (uint8)_instance, (uint8)_valueIndex, (ValueID::ValueType)_type);
+> }
+>
+>
View
817 gen-cpp/ozw_types.preserve.h
@@ -0,0 +1,817 @@
+/**
+ * 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 struct _RemoteValueID__isset {
+ _RemoteValueID__isset() : _homeId(false), _nodeId(false), _genre(false), _commandClassId(false), _instance(false), _valueIndex(false), _type(false) {}
+ bool _homeId;
+ bool _nodeId;
+ bool _genre;
+ bool _commandClassId;
+ bool _instance;
+ bool _valueIndex;
+ bool _type;
+} _RemoteValueID__isset;
+
+class RemoteValueID {
+ public:
+
+ static const char* ascii_fingerprint; // = "A30F44ED1C2FF443554DFCCDE82F70EE";
+ static const uint8_t binary_fingerprint[16]; // = {0xA3,0x0F,0x44,0xED,0x1C,0x2F,0xF4,0x43,0x55,0x4D,0xFC,0xCD,0xE8,0x2F,0x70,0xEE};
+
+ RemoteValueID() : _homeId(0), _nodeId(0), _commandClassId(0), _instance(0), _valueIndex(0) {
+ }
+
+ virtual ~RemoteValueID() throw() {}
+
+ int32_t _homeId;
+ int8_t _nodeId;
+ RemoteValueGenre::type _genre;
+ int8_t _commandClassId;
+ int8_t _instance;
+ int8_t _valueIndex;
+ RemoteValueType::type _type;
+
+ _RemoteValueID__isset __isset;
+
+ void __set__homeId(const int32_t val) {
+ _homeId = val;
+ }
+
+ void __set__nodeId(const int8_t val) {
+ _nodeId = val;
+ }
+
+ void __set__genre(const RemoteValueGenre::type val) {
+ _genre = val;
+ }
+
+ void __set__commandClassId(const int8_t val) {
+ _commandClassId = val;
+ }
+
+ void __set__instance(const int8_t val) {
+ _instance = val;
+ }
+
+ void __set__valueIndex(const int8_t val) {
+ _valueIndex = val;
+ }
+
+ void __set__type(const RemoteValueType::type val) {
+ _type = val;
+ }
+
+ bool operator == (const RemoteValueID & rhs) const
+ {
+ if (!(_homeId == rhs._homeId))
+ return false;
+ if (!(_nodeId == rhs._nodeId))
+ return false;
+ if (!(_genre == rhs._genre))
+ return false;
+ if (!(_commandClassId == rhs._commandClassId))
+ return false;
+ if (!(_instance == rhs._instance))
+ return false;
+ if (!(_valueIndex == rhs._valueIndex))
+ return false;
+ if (!(_type == rhs._type))
+ return false;
+ return true;
+ }
+ bool operator != (const RemoteValueID &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const RemoteValueID & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+ // ekarak: constructor from ValueID
+ RemoteValueID(ValueID vid) :
+ _homeId ((int32_t) vid.GetHomeId()),
+ _nodeId ((int8_t) vid.GetNodeId()),
+ _genre ((RemoteValueGenre::type) vid.GetGenre()),
+ _commandClassId((int8_t) vid.GetCommandClassId()),
+ _instance ((int8_t) vid.GetInstance()),
+ _valueIndex((int8_t) vid.GetIndex()),
+ _type ((RemoteValueType::type) vid.GetType()) { }
+// ekarak: converter to ValueID
+ValueID toValueID() const {
+ return ValueID((uint32)_homeId, (uint8)_nodeId, (ValueID::ValueGenre)_genre, (uint8)_commandClassId, (uint8)_instance, (uint8)_valueIndex, (ValueID::ValueType)_type);
+}
+
+
+};
+
+typedef struct _GetSwitchPointReturnStruct__isset {
+ _GetSwitchPointReturnStruct__isset() : retval(false), o_hours(false), o_minutes(false), o_setback(false) {}
+ bool retval;
+ bool o_hours;
+ bool o_minutes;
+ bool o_setback;
+} _GetSwitchPointReturnStruct__isset;
+
+class GetSwitchPointReturnStruct {
+ public:
+
+ static const char* ascii_fingerprint; // = "D02F029A9CC8B0BD109ADDA9910FC412";
+ static const uint8_t binary_fingerprint[16]; // = {0xD0,0x2F,0x02,0x9A,0x9C,0xC8,0xB0,0xBD,0x10,0x9A,0xDD,0xA9,0x91,0x0F,0xC4,0x12};
+
+ GetSwitchPointReturnStruct() : retval(0), o_hours(0), o_minutes(0), o_setback(0) {
+ }
+
+ virtual ~GetSwitchPointReturnStruct() throw() {}
+
+ bool retval;
+ int8_t o_hours;
+ int8_t o_minutes;
+ int8_t o_setback;
+
+ _GetSwitchPointReturnStruct__isset __isset;
+
+ void __set_retval(const bool val) {
+ retval = val;
+ }
+
+ 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 (!(retval == rhs.retval))
+ return false;
+ 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), o_value(false) {}
+ bool retval;
+ bool o_value;
+} _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), o_value(0) {
+ }
+
+ virtual ~Bool_Bool() throw() {}
+
+ bool retval;
+ bool o_value;
+
+ _Bool_Bool__isset __isset;
+
+ void __set_retval(const bool val) {
+ retval = val;
+ }
+
+ void __set_o_value(const bool val) {
+ o_value = val;
+ }
+
+ bool operator == (const Bool_Bool & rhs) const
+ {
+ if (!(retval == rhs.retval))
+ return false;
+ if (!(o_value == rhs.o_value))
+ 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), o_value(false) {}
+ bool retval;
+ bool o_value;
+} _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), o_value(0) {
+ }
+
+ virtual ~Bool_UInt8() throw() {}
+
+ bool retval;
+ int8_t o_value;
+
+ _Bool_UInt8__isset __isset;
+
+ void __set_retval(const bool val) {
+ retval = val;
+ }
+
+ void __set_o_value(const int8_t val) {
+ o_value = val;
+ }
+
+ bool operator == (const Bool_UInt8 & rhs) const
+ {
+ if (!(retval == rhs.retval))
+ return false;
+ if (!(o_value == rhs.o_value))
+ 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), o_value(false) {}
+ bool retval;
+ bool o_value;
+} _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), o_value(0) {
+ }
+
+ virtual ~Bool_Float() throw() {}
+
+ bool retval;
+ double o_value;
+
+ _Bool_Float__isset __isset;
+
+ void __set_retval(const bool val) {
+ retval = val;
+ }
+
+ void __set_o_value(const double val) {
+ o_value = val;
+ }
+
+ bool operator == (const Bool_Float & rhs) const
+ {
+ if (!(retval == rhs.retval))
+ return false;
+ if (!(o_value == rhs.o_value))
+ 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), o_value(false) {}
+ bool retval;
+ bool o_value;
+} _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), o_value(0) {
+ }
+
+ virtual ~Bool_Int() throw() {}
+
+ bool retval;
+ int32_t o_value;
+
+ _Bool_Int__isset __isset;
+
+ void __set_retval(const bool val) {
+ retval = val;
+ }
+
+ void __set_o_value(const int32_t val) {
+ o_value = val;
+ }
+
+ bool operator == (const Bool_Int & rhs) const
+ {
+ if (!(retval == rhs.retval))
+ return false;
+ if (!(o_value == rhs.o_value))
+ 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), o_value(false) {}
+ bool retval;
+ bool o_value;
+} _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), o_value(0) {
+ }
+
+ virtual ~Bool_Int16() throw() {}
+
+ bool retval;
+ int16_t o_value;
+
+ _Bool_Int16__isset __isset;
+
+ void __set_retval(const bool val) {
+ retval = val;
+ }
+
+ void __set_o_value(const int16_t val) {
+ o_value = val;
+ }
+
+ bool operator == (const Bool_Int16 & rhs) const
+ {
+ if (!(retval == rhs.retval))
+ return false;
+ if (!(o_value == rhs.o_value))
+ 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), o_value(false) {}
+ bool retval;
+ bool o_value;
+} _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};
+
+ Bool_String() : retval(0), o_value("") {
+ }
+
+ virtual ~Bool_String() throw() {}
+
+ bool retval;
+ std::string o_value;
+
+ _Bool_String__isset __isset;
+
+ void __set_retval(const bool val) {
+ retval = val;
+ }
+
+ void __set_o_value(const std::string& val) {
+ o_value = val;
+ }
+
+ bool operator == (const Bool_String & rhs) const
+ {
+ if (!(retval == rhs.retval))
+ return false;
+ if (!(o_value == rhs.o_value))
+ return false;
+ return true;
+ }
+ bool operator != (const Bool_String &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Bool_String & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Bool_ListString__isset {
+ _Bool_ListString__isset() : retval(false), o_value(false) {}
+ bool retval;
+ bool o_value;
+} _Bool_ListString__isset;
+
+class Bool_ListString {
+ public:
+
+ static const char* ascii_fingerprint; // = "D41147785C488E7FFDCF1B17BF20AC0F";
+ static const uint8_t binary_fingerprint[16]; // = {0xD4,0x11,0x47,0x78,0x5C,0x48,0x8E,0x7F,0xFD,0xCF,0x1B,0x17,0xBF,0x20,0xAC,0x0F};
+
+ Bool_ListString() : retval(0) {
+ }
+
+ virtual ~Bool_ListString() throw() {}
+
+ bool retval;
+ std::vector<std::string> o_value;
+
+ _Bool_ListString__isset __isset;
+
+ void __set_retval(const bool val) {
+ retval = val;
+ }
+
+ void __set_o_value(const std::vector<std::string> & val) {
+ o_value = val;
+ }
+
+ bool operator == (const Bool_ListString & rhs) const
+ {
+ if (!(retval == rhs.retval))
+ return false;
+ if (!(o_value == rhs.o_value))
+ return false;
+ return true;
+ }
+ bool operator != (const Bool_ListString &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Bool_ListString & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _UInt32_ListByte__isset {
+ _UInt32_ListByte__isset() : retval(false), _nodeNeighbors(false) {}
+ bool retval;
+ bool _nodeNeighbors;
+} _UInt32_ListByte__isset;
+
+class UInt32_ListByte {
+ public:
+
+ static const char* ascii_fingerprint; // = "C69B8D458340D01227B2A605EFE33F77";
+ static const uint8_t binary_fingerprint[16]; // = {0xC6,0x9B,0x8D,0x45,0x83,0x40,0xD0,0x12,0x27,0xB2,0xA6,0x05,0xEF,0xE3,0x3F,0x77};
+
+ UInt32_ListByte() : retval(0) {
+ }
+
+ virtual ~UInt32_ListByte() throw() {}
+
+ int32_t retval;
+ std::vector<int8_t> _nodeNeighbors;
+
+ _UInt32_ListByte__isset __isset;
+
+ void __set_retval(const int32_t val) {
+ retval = val;
+ }
+
+ void __set__nodeNeighbors(const std::vector<int8_t> & val) {
+ _nodeNeighbors = val;
+ }
+
+ bool operator == (const UInt32_ListByte & rhs) const
+ {
+ if (!(retval == rhs.retval))
+ return false;
+ if (!(_nodeNeighbors == rhs._nodeNeighbors))
+ return false;
+ return true;
+ }
+ bool operator != (const UInt32_ListByte &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const UInt32_ListByte & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Bool_GetNodeClassInformation__isset {
+ _Bool_GetNodeClassInformation__isset() : retval(false), _className(false), _classVersion(false) {}
+ bool retval;
+ bool _className;
+ bool _classVersion;
+} _Bool_GetNodeClassInformation__isset;
+
+class Bool_GetNodeClassInformation {
+ public:
+
+ static const char* ascii_fingerprint; // = "E35E3BAE8348A954A88C096C7A63DF4B";
+ static const uint8_t binary_fingerprint[16]; // = {0xE3,0x5E,0x3B,0xAE,0x83,0x48,0xA9,0x54,0xA8,0x8C,0x09,0x6C,0x7A,0x63,0xDF,0x4B};
+
+ Bool_GetNodeClassInformation() : retval(0), _className(""), _classVersion(0) {
+ }
+
+ virtual ~Bool_GetNodeClassInformation() throw() {}
+
+ bool retval;
+ std::string _className;
+ int8_t _classVersion;
+
+ _Bool_GetNodeClassInformation__isset __isset;
+
+ void __set_retval(const bool val) {
+ retval = val;
+ }
+
+ void __set__className(const std::string& val) {
+ _className = val;
+ }
+
+ void __set__classVersion(const int8_t val) {
+ _classVersion = val;
+ }
+
+ bool operator == (const Bool_GetNodeClassInformation & rhs) const
+ {
+ if (!(retval == rhs.retval))
+ return false;
+ if (!(_className == rhs._className))
+ return false;
+ if (!(_classVersion == rhs._classVersion))
+ return false;
+ return true;
+ }
+ bool operator != (const Bool_GetNodeClassInformation &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Bool_GetNodeClassInformation & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _GetAssociationsReturnStruct__isset {
+ _GetAssociationsReturnStruct__isset() : retval(false), o_associations(false) {}
+ bool retval;
+ bool o_associations;
+} _GetAssociationsReturnStruct__isset;
+
+class GetAssociationsReturnStruct {
+ public:
+
+ static const char* ascii_fingerprint; // = "C69B8D458340D01227B2A605EFE33F77";
+ static const uint8_t binary_fingerprint[16]; // = {0xC6,0x9B,0x8D,0x45,0x83,0x40,0xD0,0x12,0x27,0xB2,0xA6,0x05,0xEF,0xE3,0x3F,0x77};
+
+ GetAssociationsReturnStruct() : retval(0) {
+ }
+
+ virtual ~GetAssociationsReturnStruct() throw() {}
+
+ int32_t retval;
+ std::vector<int8_t> o_associations;
+
+ _GetAssociationsReturnStruct__isset __isset;
+
+ void __set_retval(const int32_t val) {
+ retval = val;
+ }
+
+ void __set_o_associations(const std::vector<int8_t> & val) {
+ o_associations = val;
+ }
+
+ bool operator == (const GetAssociationsReturnStruct & rhs) const
+ {
+ if (!(retval == rhs.retval))
+ return false;
+ if (!(o_associations == rhs.o_associations))
+ return false;
+ return true;
+ }
+ bool operator != (const GetAssociationsReturnStruct &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const GetAssociationsReturnStruct & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _GetAllScenesReturnStruct__isset {
+ _GetAllScenesReturnStruct__isset() : retval(false), _sceneIds(false) {}
+ bool retval;
+ bool _sceneIds;
+} _GetAllScenesReturnStruct__isset;
+
+class GetAllScenesReturnStruct {
+ public:
+
+ static const char* ascii_fingerprint; // = "E9315D11ED9B3ADE4F14971EFD87F639";
+ static const uint8_t binary_fingerprint[16]; // = {0xE9,0x31,0x5D,0x11,0xED,0x9B,0x3A,0xDE,0x4F,0x14,0x97,0x1E,0xFD,0x87,0xF6,0x39};
+
+ GetAllScenesReturnStruct() : retval(0) {
+ }
+
+ virtual ~GetAllScenesReturnStruct() throw() {}
+
+ int8_t retval;
+ std::vector<int8_t> _sceneIds;
+
+ _GetAllScenesReturnStruct__isset __isset;
+
+ void __set_retval(const int8_t val) {
+ retval = val;
+ }
+
+ void __set__sceneIds(const std::vector<int8_t> & val) {
+ _sceneIds = val;
+ }
+
+ bool operator == (const GetAllScenesReturnStruct & rhs) const
+ {
+ if (!(retval == rhs.retval))
+ return false;
+ if (!(_sceneIds == rhs._sceneIds))
+ return false;
+ return true;
+ }
+ bool operator != (const GetAllScenesReturnStruct &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const GetAllScenesReturnStruct & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _SceneGetValuesReturnStruct__isset {
+ _SceneGetValuesReturnStruct__isset() : retval(false), o_value(false) {}
+ bool retval;
+ bool o_value;
+} _SceneGetValuesReturnStruct__isset;
+
+class SceneGetValuesReturnStruct {
+ public:
+
+ static const char* ascii_fingerprint; // = "B185F1A76BEB4E1D6BC486700DAD2A95";
+ static const uint8_t binary_fingerprint[16]; // = {0xB1,0x85,0xF1,0xA7,0x6B,0xEB,0x4E,0x1D,0x6B,0xC4,0x86,0x70,0x0D,0xAD,0x2A,0x95};
+
+ SceneGetValuesReturnStruct() : retval(0) {
+ }
+
+ virtual ~SceneGetValuesReturnStruct() throw() {}
+
+ int32_t retval;
+ std::vector<RemoteValueID> o_value;
+
+ _SceneGetValuesReturnStruct__isset __isset;
+
+ void __set_retval(const int32_t val) {
+ retval = val;
+ }
+
+ void __set_o_value(const std::vector<RemoteValueID> & val) {
+ o_value = val;
+ }
+
+ bool operator == (const SceneGetValuesReturnStruct & rhs) const
+ {
+ if (!(retval == rhs.retval))
+ return false;
+ if (!(o_value == rhs.o_value))
+ return false;
+ return true;
+ }
+ bool operator != (const SceneGetValuesReturnStruct &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const SceneGetValuesReturnStruct & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+} // namespace
+
+#endif
View
133 gen-csharp/OpenZWave/RemoteManager.cs
@@ -140,6 +140,7 @@ public interface Iface {
void SetSceneLabel(byte _sceneId, string _value);
bool SceneExists(byte _sceneId);
bool ActivateScene(byte _sceneId);
+ void SendAllValues();
}
public class Client : Iface {
@@ -4302,6 +4303,35 @@ public bool recv_ActivateScene()
throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "ActivateScene failed: unknown result");
}
+ public void SendAllValues()
+ {
+ send_SendAllValues();
+ recv_SendAllValues();
+ }
+
+ public void send_SendAllValues()
+ {
+ oprot_.WriteMessageBegin(new TMessage("SendAllValues", TMessageType.Call, seqid_));
+ SendAllValues_args args = new SendAllValues_args();
+ args.Write(oprot_);
+ oprot_.WriteMessageEnd();
+ oprot_.Transport.Flush();
+ }
+
+ public void recv_SendAllValues()
+ {
+ TMessage msg = iprot_.ReadMessageBegin();
+ if (msg.Type == TMessageType.Exception) {
+ TApplicationException x = TApplicationException.Read(iprot_);
+ iprot_.ReadMessageEnd();
+ throw x;
+ }
+ SendAllValues_result result = new SendAllValues_result();
+ result.Read(iprot_);
+ iprot_.ReadMessageEnd();
+ return;
+ }
+
}
public class Processor : TProcessor {
public Processor(Iface iface)
@@ -4431,6 +4461,7 @@ public Processor(Iface iface)
processMap_["SetSceneLabel"] = SetSceneLabel_Process;
processMap_["SceneExists"] = SceneExists_Process;
processMap_["ActivateScene"] = ActivateScene_Process;
+ processMap_["SendAllValues"] = SendAllValues_Process;
}
protected delegate void ProcessFunction(int seqid, TProtocol iprot, TProtocol oprot);
@@ -6075,6 +6106,19 @@ public void ActivateScene_Process(int seqid, TProtocol iprot, TProtocol oprot)
oprot.Transport.Flush();
}
+ public void SendAllValues_Process(int seqid, TProtocol iprot, TProtocol oprot)
+ {
+ SendAllValues_args args = new SendAllValues_args();
+ args.Read(iprot);
+ iprot.ReadMessageEnd();
+ SendAllValues_result result = new SendAllValues_result();
+ iface_.SendAllValues();
+ oprot.WriteMessageBegin(new TMessage("SendAllValues", TMessageType.Reply, seqid));
+ result.Write(oprot);
+ oprot.WriteMessageEnd();
+ oprot.Transport.Flush();
+ }
+
}
@@ -29553,5 +29597,94 @@ public void Read (TProtocol iprot)
}
+
+ [Serializable]
+ public partial class SendAllValues_args : TBase
+ {
+
+ public SendAllValues_args() {
+ }
+
+ public void Read (TProtocol iprot)
+ {
+ TField field;
+ iprot.ReadStructBegin();
+ while (true)
+ {
+ field = iprot.ReadFieldBegin();
+ if (field.Type == TType.Stop) {
+ break;
+ }
+ switch (field.ID)
+ {
+ default:
+ TProtocolUtil.Skip(iprot, field.Type);
+ break;
+ }
+ iprot.ReadFieldEnd();
+ }
+ iprot.ReadStructEnd();
+ }
+
+ public void Write(TProtocol oprot) {
+ TStruct struc = new TStruct("SendAllValues_args");
+ oprot.WriteStructBegin(struc);
+ oprot.WriteFieldStop();
+ oprot.WriteStructEnd();
+ }
+
+ public override string ToString() {
+ StringBuilder sb = new StringBuilder("SendAllValues_args(");
+ sb.Append(")");
+ return sb.ToString();
+ }
+
+ }
+
+
+ [Serializable]
+ public partial class SendAllValues_result : TBase
+ {
+
+ public SendAllValues_result() {
+ }
+
+ public void Read (TProtocol iprot)
+ {
+ TField field;
+ iprot.ReadStructBegin();
+ while (true)
+ {
+ field = iprot.ReadFieldBegin();
+ if (field.Type == TType.Stop) {
+ break;
+ }
+ switch (field.ID)
+ {
+ default:
+ TProtocolUtil.Skip(iprot, field.Type);
+ break;
+ }
+ iprot.ReadFieldEnd();
+ }
+ iprot.ReadStructEnd();
+ }
+
+ public void Write(TProtocol oprot) {
+ TStruct struc = new TStruct("SendAllValues_result");
+ oprot.WriteStructBegin(struc);
+
+ oprot.WriteFieldStop();
+ oprot.WriteStructEnd();
+ }
+
+ public override string ToString() {
+ StringBuilder sb = new StringBuilder("SendAllValues_result(");
+ sb.Append(")");
+ return sb.ToString();
+ }
+
+ }
+
}
}
View
9 gen-erl/remoteManager_thrift.erl
@@ -1130,5 +1130,14 @@ function_info('ActivateScene', reply_type) ->
function_info('ActivateScene', exceptions) ->
{struct, []}
;
+% SendAllValues(This)
+function_info('SendAllValues', params_type) ->
+ {struct, []}
+;
+function_info('SendAllValues', reply_type) ->
+ {struct, []};
+function_info('SendAllValues', exceptions) ->
+ {struct, []}
+;
function_info(_Func, _Info) -> no_function.
View
4,981 gen-go/OpenZWave/RemoteManager.go
2,629 additions, 2,352 deletions not shown
View
1,823 gen-go/OpenZWave/RemoteManager/RemoteManager-remote.go
916 additions, 907 deletions not shown
View
472 gen-java/OpenZWave/RemoteManager.java
@@ -1598,6 +1598,8 @@
*/
public boolean ActivateScene(byte _sceneId) throws org.apache.thrift.TException;
+ public void SendAllValues() throws org.apache.thrift.TException;
+
}
public interface AsyncIface {
@@ -1850,6 +1852,8 @@
public void ActivateScene(byte _sceneId, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.ActivateScene_call> resultHandler) throws org.apache.thrift.TException;
+ public void SendAllValues(org.apache.thrift.async.AsyncMethodCallback<AsyncClient.SendAllValues_call> resultHandler) throws org.apache.thrift.TException;
+
}
public static class Client extends org.apache.thrift.TServiceClient implements Iface {
@@ -4767,6 +4771,25 @@ public boolean recv_ActivateScene() throws org.apache.thrift.TException
throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "ActivateScene failed: unknown result");
}
+ public void SendAllValues() throws org.apache.thrift.TException
+ {
+ send_SendAllValues();
+ recv_SendAllValues();
+ }
+
+ public void send_SendAllValues() throws org.apache.thrift.TException
+ {
+ SendAllValues_args args = new SendAllValues_args();
+ sendBase("SendAllValues", args);
+ }
+
+ public void recv_SendAllValues() throws org.apache.thrift.TException
+ {
+ SendAllValues_result result = new SendAllValues_result();
+ receiveBase(result, "SendAllValues");
+ return;
+ }
+
}
public static class AsyncClient extends org.apache.thrift.async.TAsyncClient implements AsyncIface {
public static class Factory implements org.apache.thrift.async.TAsyncClientFactory<AsyncClient> {
@@ -9080,6 +9103,35 @@ public boolean getResult() throws org.apache.thrift.TException {
}
}
+ public void SendAllValues(org.apache.thrift.async.AsyncMethodCallback<SendAllValues_call> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ SendAllValues_call method_call = new SendAllValues_call(resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class SendAllValues_call extends org.apache.thrift.async.TAsyncMethodCall {
+ public SendAllValues_call(org.apache.thrift.async.AsyncMethodCallback<SendAllValues_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ }
+
+ public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+ prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("SendAllValues", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ SendAllValues_args args = new SendAllValues_args();
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public void getResult() throws org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ (new Client(prot)).recv_SendAllValues();
+ }
+ }
+
}
public static class Processor<I extends Iface> extends org.apache.thrift.TBaseProcessor implements org.apache.thrift.TProcessor {
@@ -9217,6 +9269,7 @@ protected Processor(I iface, Map<String, org.apache.thrift.ProcessFunction<I, ?
processMap.put("SetSceneLabel", new SetSceneLabel());
processMap.put("SceneExists", new SceneExists());
processMap.put("ActivateScene", new ActivateScene());
+ processMap.put("SendAllValues", new SendAllValues());
return processMap;
}
@@ -11267,6 +11320,22 @@ protected ActivateScene_result getResult(I iface, ActivateScene_args args) throw
}
}
+ private static class SendAllValues<I extends Iface> extends org.apache.thrift.ProcessFunction<I, SendAllValues_args> {
+ public SendAllValues() {
+ super("SendAllValues");
+ }
+
+ protected SendAllValues_args getEmptyArgsInstance() {
+ return new SendAllValues_args();
+ }
+
+ protected SendAllValues_result getResult(I iface, SendAllValues_args args) throws org.apache.thrift.TException {
+ SendAllValues_result result = new SendAllValues_result();
+ iface.SendAllValues();
+ return result;
+ }
+ }
+
}
public static class WriteConfig_args implements org.apache.thrift.TBase<WriteConfig_args, WriteConfig_args._Fields>, java.io.Serializable, Cloneable {
@@ -91987,4 +92056,407 @@ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException
}
+ public static class SendAllValues_args implements org.apache.thrift.TBase<SendAllValues_args, SendAllValues_args._Fields>, java.io.Serializable, Cloneable {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("SendAllValues_args");
+
+
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+;
+
+ private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
+
+ static {
+ for (_Fields field : EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ public static _Fields findByName(String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final String _fieldName;
+
+ _Fields(short thriftId, String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public String getFieldName() {
+ return _fieldName;
+ }
+ }
+ public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ metaDataMap = Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(SendAllValues_args.class, metaDataMap);
+ }
+
+ public SendAllValues_args() {
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public SendAllValues_args(SendAllValues_args other) {
+ }
+
+ public SendAllValues_args deepCopy() {
+ return new SendAllValues_args(this);
+ }
+
+ @Override
+ public void clear() {
+ }
+
+ public void setFieldValue(_Fields field, Object value) {
+ switch (field) {
+ }
+ }
+
+ public Object getFieldValue(_Fields field) {
+ switch (field) {
+ }
+ throw new IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new IllegalArgumentException();
+ }
+
+ switch (field) {
+ }
+ throw new IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(Object that) {
+ if (that == null)
+ return false;
+ if (that instanceof SendAllValues_args)
+ return this.equals((SendAllValues_args)that);
+ return false;
+ }
+
+ public boolean equals(SendAllValues_args that) {
+ if (that == null)
+ return false;
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ return 0;
+ }
+
+ public int compareTo(SendAllValues_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+ SendAllValues_args typedOther = (SendAllValues_args)other;
+
+ return 0;
+ }
+
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField field;
+ iprot.readStructBegin();
+ while (true)
+ {
+ field = iprot.readFieldBegin();
+ if (field.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (field.id) {
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ @Override
+ public String toString() {
+ StringBuilder sb = new StringBuilder("SendAllValues_args(");
+ boolean first = true;
+
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ }
+
+ public static class SendAllValues_result implements org.apache.thrift.TBase<SendAllValues_result, SendAllValues_result._Fields>, java.io.Serializable, Cloneable {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("SendAllValues_result");
+
+
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+;
+
+ private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
+
+ static {
+ for (_Fields field : EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ public static _Fields findByName(String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final String _fieldName;
+
+ _Fields(short thriftId, String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public String getFieldName() {
+ return _fieldName;
+ }
+ }
+ public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ metaDataMap = Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(SendAllValues_result.class, metaDataMap);
+ }
+
+ public SendAllValues_result() {
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public SendAllValues_result(SendAllValues_result other) {
+ }
+
+ public SendAllValues_result deepCopy() {
+ return new SendAllValues_result(this);
+ }
+
+ @Override
+ public void clear() {
+ }
+
+ public void setFieldValue(_Fields field, Object value) {
+ switch (field) {
+ }
+ }
+
+ public Object getFieldValue(_Fields field) {
+ switch (field) {
+ }
+ throw new IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new IllegalArgumentException();
+ }
+
+ switch (field) {
+ }
+ throw new IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(Object that) {
+ if (that == null)
+ return false;
+ if (that instanceof SendAllValues_result)
+ return this.equals((SendAllValues_result)that);
+ return false;
+ }
+
+ public boolean equals(SendAllValues_result that) {
+ if (that == null)
+ return false;
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ return 0;
+ }
+
+ public int compareTo(SendAllValues_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+ SendAllValues_result typedOther = (SendAllValues_result)other;
+
+ return 0;
+ }
+
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField field;
+ iprot.readStructBegin();
+ while (true)
+ {
+ field = iprot.readFieldBegin();
+ if (field.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (field.id) {
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+
+ // check for required fields of primitive type, which can't be checked in the validate method
+ validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ oprot.writeStructBegin(STRUCT_DESC);
+
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ @Override
+ public String toString() {
+ StringBuilder sb = new StringBuilder("SendAllValues_result(");
+ boolean first = true;
+
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ }
+
}
View
86 gen-js/RemoteManager.js
@@ -14165,6 +14165,62 @@ OpenZWave.RemoteManager_ActivateScene_result.prototype.write = function(output)
return;
};
+OpenZWave.RemoteManager_SendAllValues_args = function(args) {
+};
+OpenZWave.RemoteManager_SendAllValues_args.prototype = {};
+OpenZWave.RemoteManager_SendAllValues_args.prototype.read = function(input) {
+ input.readStructBegin();
+ while (true)
+ {
+ var ret = input.readFieldBegin();
+ var fname = ret.fname;
+ var ftype = ret.ftype;
+ var fid = ret.fid;
+ if (ftype == Thrift.Type.STOP) {
+ break;
+ }
+ input.skip(ftype);
+ input.readFieldEnd();
+ }
+ input.readStructEnd();
+ return;
+};
+
+OpenZWave.RemoteManager_SendAllValues_args.prototype.write = function(output) {
+ output.writeStructBegin('RemoteManager_SendAllValues_args');
+ output.writeFieldStop();
+ output.writeStructEnd();
+ return;
+};
+
+OpenZWave.RemoteManager_SendAllValues_result = function(args) {
+};
+OpenZWave.RemoteManager_SendAllValues_result.prototype = {};
+OpenZWave.RemoteManager_SendAllValues_result.prototype.read = function(input) {
+ input.readStructBegin();
+ while (true)
+ {
+ var ret = input.readFieldBegin();
+ var fname = ret.fname;
+ var ftype = ret.ftype;
+ var fid = ret.fid;
+ if (ftype == Thrift.Type.STOP) {
+ break;
+ }
+ input.skip(ftype);
+ input.readFieldEnd();
+ }
+ input.readStructEnd();
+ return;
+};