Class: OpenZWave::RemoteManager::Processor

Inherits:
Object
  • Object
show all
Includes:
Thrift::Processor
Defined in:
lib/ansible/zwave/openzwave/ozw_remote_manager.rb

Instance Method Summary collapse

Instance Method Details

#process_ActivateScene(seqid, iprot, oprot) ⇒ Object 



2976
2977
2978
2979
2980
2981
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2976

def process_ActivateScene(seqid, iprot, oprot)
  args = read_args(iprot, ActivateScene_args)
  result = ActivateScene_result.new()
  result.success = @handler.ActivateScene(args._sceneId)
  write_result(result, oprot, 'ActivateScene', seqid)
end

#process_AddAssociation(seqid, iprot, oprot) ⇒ Object 



2703
2704
2705
2706
2707
2708
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2703

def process_AddAssociation(seqid, iprot, oprot)
  args = read_args(iprot, AddAssociation_args)
  result = AddAssociation_result.new()
  @handler.AddAssociation(args._homeId, args._nodeId, args._groupIdx, args._targetNodeId)
  write_result(result, oprot, 'AddAssociation', seqid)
end

#process_AddSceneValue_Bool(seqid, iprot, oprot) ⇒ Object 



2773
2774
2775
2776
2777
2778
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2773

def process_AddSceneValue_Bool(seqid, iprot, oprot)
  args = read_args(iprot, AddSceneValue_Bool_args)
  result = AddSceneValue_Bool_result.new()
  result.success = @handler.AddSceneValue_Bool(args._sceneId, args._valueId, args._value)
  write_result(result, oprot, 'AddSceneValue_Bool', seqid)
end

#process_AddSceneValue_Float(seqid, iprot, oprot) ⇒ Object 



2787
2788
2789
2790
2791
2792
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2787

def process_AddSceneValue_Float(seqid, iprot, oprot)
  args = read_args(iprot, AddSceneValue_Float_args)
  result = AddSceneValue_Float_result.new()
  result.success = @handler.AddSceneValue_Float(args._sceneId, args._valueId, args._value)
  write_result(result, oprot, 'AddSceneValue_Float', seqid)
end

#process_AddSceneValue_Int16(seqid, iprot, oprot) ⇒ Object 



2801
2802
2803
2804
2805
2806
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2801

def process_AddSceneValue_Int16(seqid, iprot, oprot)
  args = read_args(iprot, AddSceneValue_Int16_args)
  result = AddSceneValue_Int16_result.new()
  result.success = @handler.AddSceneValue_Int16(args._sceneId, args._valueId, args._value)
  write_result(result, oprot, 'AddSceneValue_Int16', seqid)
end

#process_AddSceneValue_Int32(seqid, iprot, oprot) ⇒ Object 



2794
2795
2796
2797
2798
2799
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2794

def process_AddSceneValue_Int32(seqid, iprot, oprot)
  args = read_args(iprot, AddSceneValue_Int32_args)
  result = AddSceneValue_Int32_result.new()
  result.success = @handler.AddSceneValue_Int32(args._sceneId, args._valueId, args._value)
  write_result(result, oprot, 'AddSceneValue_Int32', seqid)
end

#process_AddSceneValue_String(seqid, iprot, oprot) ⇒ Object 



2808
2809
2810
2811
2812
2813
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2808

def process_AddSceneValue_String(seqid, iprot, oprot)
  args = read_args(iprot, AddSceneValue_String_args)
  result = AddSceneValue_String_result.new()
  result.success = @handler.AddSceneValue_String(args._sceneId, args._valueId, args._value)
  write_result(result, oprot, 'AddSceneValue_String', seqid)
end

#process_AddSceneValue_Uint8(seqid, iprot, oprot) ⇒ Object 



2780
2781
2782
2783
2784
2785
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2780

def process_AddSceneValue_Uint8(seqid, iprot, oprot)
  args = read_args(iprot, AddSceneValue_Uint8_args)
  result = AddSceneValue_Uint8_result.new()
  result.success = @handler.AddSceneValue_Uint8(args._sceneId, args._valueId, args._value)
  write_result(result, oprot, 'AddSceneValue_Uint8', seqid)
end

#process_AddSceneValueListSelection_Int32(seqid, iprot, oprot) ⇒ Object 



2822
2823
2824
2825
2826
2827
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2822

def process_AddSceneValueListSelection_Int32(seqid, iprot, oprot)
  args = read_args(iprot, AddSceneValueListSelection_Int32_args)
  result = AddSceneValueListSelection_Int32_result.new()
  result.success = @handler.AddSceneValueListSelection_Int32(args._sceneId, args._valueId, args._value)
  write_result(result, oprot, 'AddSceneValueListSelection_Int32', seqid)
end

#process_AddSceneValueListSelection_String(seqid, iprot, oprot) ⇒ Object 



2815
2816
2817
2818
2819
2820
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2815

def process_AddSceneValueListSelection_String(seqid, iprot, oprot)
  args = read_args(iprot, AddSceneValueListSelection_String_args)
  result = AddSceneValueListSelection_String_result.new()
  result.success = @handler.AddSceneValueListSelection_String(args._sceneId, args._valueId, args._value)
  write_result(result, oprot, 'AddSceneValueListSelection_String', seqid)
end

#process_BeginControllerCommand(seqid, iprot, oprot) ⇒ Object 



2731
2732
2733
2734
2735
2736
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2731

def process_BeginControllerCommand(seqid, iprot, oprot)
  args = read_args(iprot, BeginControllerCommand_args)
  result = BeginControllerCommand_result.new()
  result.success = @handler.BeginControllerCommand(args._homeId, args._command, args._highPower, args._nodeId, args._arg)
  write_result(result, oprot, 'BeginControllerCommand', seqid)
end

#process_CancelControllerCommand(seqid, iprot, oprot) ⇒ Object 



2738
2739
2740
2741
2742
2743
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2738

def process_CancelControllerCommand(seqid, iprot, oprot)
  args = read_args(iprot, CancelControllerCommand_args)
  result = CancelControllerCommand_result.new()
  result.success = @handler.CancelControllerCommand(args._homeId)
  write_result(result, oprot, 'CancelControllerCommand', seqid)
end

#process_ClearSwitchPoints(seqid, iprot, oprot) ⇒ Object 



2626
2627
2628
2629
2630
2631
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2626

def process_ClearSwitchPoints(seqid, iprot, oprot)
  args = read_args(iprot, ClearSwitchPoints_args)
  result = ClearSwitchPoints_result.new()
  @handler.ClearSwitchPoints(args._id)
  write_result(result, oprot, 'ClearSwitchPoints', seqid)
end

#process_CreateScene(seqid, iprot, oprot) ⇒ Object 



2759
2760
2761
2762
2763
2764
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2759

def process_CreateScene(seqid, iprot, oprot)
  args = read_args(iprot, CreateScene_args)
  result = CreateScene_result.new()
  result.success = @handler.CreateScene()
  write_result(result, oprot, 'CreateScene', seqid)
end

#process_DisablePoll(seqid, iprot, oprot) ⇒ Object 



2129
2130
2131
2132
2133
2134
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2129

def process_DisablePoll(seqid, iprot, oprot)
  args = read_args(iprot, DisablePoll_args)
  result = DisablePoll_result.new()
  result.success = @handler.DisablePoll(args._valueId)
  write_result(result, oprot, 'DisablePoll', seqid)
end

#process_EnablePoll(seqid, iprot, oprot) ⇒ Object 



2122
2123
2124
2125
2126
2127
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2122

def process_EnablePoll(seqid, iprot, oprot)
  args = read_args(iprot, EnablePoll_args)
  result = EnablePoll_result.new()
  result.success = @handler.EnablePoll(args._valueId, args._intensity)
  write_result(result, oprot, 'EnablePoll', seqid)
end

#process_GetAllScenes(seqid, iprot, oprot) ⇒ Object 



2752
2753
2754
2755
2756
2757
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2752

def process_GetAllScenes(seqid, iprot, oprot)
  args = read_args(iprot, GetAllScenes_args)
  result = GetAllScenes_result.new()
  result.success = @handler.GetAllScenes()
  write_result(result, oprot, 'GetAllScenes', seqid)
end

#process_GetAssociations(seqid, iprot, oprot) ⇒ Object 



2682
2683
2684
2685
2686
2687
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2682

def process_GetAssociations(seqid, iprot, oprot)
  args = read_args(iprot, GetAssociations_args)
  result = GetAssociations_result.new()
  result.success = @handler.GetAssociations(args._homeId, args._nodeId, args._groupIdx)
  write_result(result, oprot, 'GetAssociations', seqid)
end

#process_GetControllerNodeId(seqid, iprot, oprot) ⇒ Object 



2052
2053
2054
2055
2056
2057
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2052

def process_GetControllerNodeId(seqid, iprot, oprot)
  args = read_args(iprot, GetControllerNodeId_args)
  result = GetControllerNodeId_result.new()
  result.success = @handler.GetControllerNodeId(args._homeId)
  write_result(result, oprot, 'GetControllerNodeId', seqid)
end

#process_GetDriverStatistics(seqid, iprot, oprot) ⇒ Object 



2983
2984
2985
2986
2987
2988
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2983

def process_GetDriverStatistics(seqid, iprot, oprot)
  args = read_args(iprot, GetDriverStatistics_args)
  result = GetDriverStatistics_result.new()
  result.success = @handler.GetDriverStatistics(args._homeId)
  write_result(result, oprot, 'GetDriverStatistics', seqid)
end

#process_GetGroupLabel(seqid, iprot, oprot) ⇒ Object 



2696
2697
2698
2699
2700
2701
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2696

def process_GetGroupLabel(seqid, iprot, oprot)
  args = read_args(iprot, GetGroupLabel_args)
  result = GetGroupLabel_result.new()
  result.success = @handler.GetGroupLabel(args._homeId, args._nodeId, args._groupIdx)
  write_result(result, oprot, 'GetGroupLabel', seqid)
end

#process_GetLibraryTypeName(seqid, iprot, oprot) ⇒ Object 



2087
2088
2089
2090
2091
2092
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2087

def process_GetLibraryTypeName(seqid, iprot, oprot)
  args = read_args(iprot, GetLibraryTypeName_args)
  result = GetLibraryTypeName_result.new()
  result.success = @handler.GetLibraryTypeName(args._homeId)
  write_result(result, oprot, 'GetLibraryTypeName', seqid)
end

#process_GetLibraryVersion(seqid, iprot, oprot) ⇒ Object 



2080
2081
2082
2083
2084
2085
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2080

def process_GetLibraryVersion(seqid, iprot, oprot)
  args = read_args(iprot, GetLibraryVersion_args)
  result = GetLibraryVersion_result.new()
  result.success = @handler.GetLibraryVersion(args._homeId)
  write_result(result, oprot, 'GetLibraryVersion', seqid)
end

#process_GetMaxAssociations(seqid, iprot, oprot) ⇒ Object 



2689
2690
2691
2692
2693
2694
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2689

def process_GetMaxAssociations(seqid, iprot, oprot)
  args = read_args(iprot, GetMaxAssociations_args)
  result = GetMaxAssociations_result.new()
  result.success = @handler.GetMaxAssociations(args._homeId, args._nodeId, args._groupIdx)
  write_result(result, oprot, 'GetMaxAssociations', seqid)
end

#process_GetNodeBasic(seqid, iprot, oprot) ⇒ Object 



2227
2228
2229
2230
2231
2232
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2227

def process_GetNodeBasic(seqid, iprot, oprot)
  args = read_args(iprot, GetNodeBasic_args)
  result = GetNodeBasic_result.new()
  result.success = @handler.GetNodeBasic(args._homeId, args._nodeId)
  write_result(result, oprot, 'GetNodeBasic', seqid)
end

#process_GetNodeClassInformation(seqid, iprot, oprot) ⇒ Object 



2367
2368
2369
2370
2371
2372
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2367

def process_GetNodeClassInformation(seqid, iprot, oprot)
  args = read_args(iprot, GetNodeClassInformation_args)
  result = GetNodeClassInformation_result.new()
  result.success = @handler.GetNodeClassInformation(args._homeId, args._nodeId, args._commandClassId)
  write_result(result, oprot, 'GetNodeClassInformation', seqid)
end

#process_GetNodeGeneric(seqid, iprot, oprot) ⇒ Object 



2234
2235
2236
2237
2238
2239
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2234

def process_GetNodeGeneric(seqid, iprot, oprot)
  args = read_args(iprot, GetNodeGeneric_args)
  result = GetNodeGeneric_result.new()
  result.success = @handler.GetNodeGeneric(args._homeId, args._nodeId)
  write_result(result, oprot, 'GetNodeGeneric', seqid)
end

#process_GetNodeLocation(seqid, iprot, oprot) ⇒ Object 



2283
2284
2285
2286
2287
2288
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2283

def process_GetNodeLocation(seqid, iprot, oprot)
  args = read_args(iprot, GetNodeLocation_args)
  result = GetNodeLocation_result.new()
  result.success = @handler.GetNodeLocation(args._homeId, args._nodeId)
  write_result(result, oprot, 'GetNodeLocation', seqid)
end

#process_GetNodeManufacturerId(seqid, iprot, oprot) ⇒ Object 



2290
2291
2292
2293
2294
2295
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2290

def process_GetNodeManufacturerId(seqid, iprot, oprot)
  args = read_args(iprot, GetNodeManufacturerId_args)
  result = GetNodeManufacturerId_result.new()
  result.success = @handler.GetNodeManufacturerId(args._homeId, args._nodeId)
  write_result(result, oprot, 'GetNodeManufacturerId', seqid)
end

#process_GetNodeManufacturerName(seqid, iprot, oprot) ⇒ Object 



2262
2263
2264
2265
2266
2267
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2262

def process_GetNodeManufacturerName(seqid, iprot, oprot)
  args = read_args(iprot, GetNodeManufacturerName_args)
  result = GetNodeManufacturerName_result.new()
  result.success = @handler.GetNodeManufacturerName(args._homeId, args._nodeId)
  write_result(result, oprot, 'GetNodeManufacturerName', seqid)
end

#process_GetNodeMaxBaudRate(seqid, iprot, oprot) ⇒ Object 



2206
2207
2208
2209
2210
2211
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2206

def process_GetNodeMaxBaudRate(seqid, iprot, oprot)
  args = read_args(iprot, GetNodeMaxBaudRate_args)
  result = GetNodeMaxBaudRate_result.new()
  result.success = @handler.GetNodeMaxBaudRate(args._homeId, args._nodeId)
  write_result(result, oprot, 'GetNodeMaxBaudRate', seqid)
end

#process_GetNodeName(seqid, iprot, oprot) ⇒ Object 



2276
2277
2278
2279
2280
2281
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2276

def process_GetNodeName(seqid, iprot, oprot)
  args = read_args(iprot, GetNodeName_args)
  result = GetNodeName_result.new()
  result.success = @handler.GetNodeName(args._homeId, args._nodeId)
  write_result(result, oprot, 'GetNodeName', seqid)
end

#process_GetNodeNeighbors(seqid, iprot, oprot) ⇒ Object 



2255
2256
2257
2258
2259
2260
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2255

def process_GetNodeNeighbors(seqid, iprot, oprot)
  args = read_args(iprot, GetNodeNeighbors_args)
  result = GetNodeNeighbors_result.new()
  result.success = @handler.GetNodeNeighbors(args._homeId, args._nodeId)
  write_result(result, oprot, 'GetNodeNeighbors', seqid)
end

#process_GetNodeProductId(seqid, iprot, oprot) ⇒ Object 



2304
2305
2306
2307
2308
2309
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2304

def process_GetNodeProductId(seqid, iprot, oprot)
  args = read_args(iprot, GetNodeProductId_args)
  result = GetNodeProductId_result.new()
  result.success = @handler.GetNodeProductId(args._homeId, args._nodeId)
  write_result(result, oprot, 'GetNodeProductId', seqid)
end

#process_GetNodeProductName(seqid, iprot, oprot) ⇒ Object 



2269
2270
2271
2272
2273
2274
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2269

def process_GetNodeProductName(seqid, iprot, oprot)
  args = read_args(iprot, GetNodeProductName_args)
  result = GetNodeProductName_result.new()
  result.success = @handler.GetNodeProductName(args._homeId, args._nodeId)
  write_result(result, oprot, 'GetNodeProductName', seqid)
end

#process_GetNodeProductType(seqid, iprot, oprot) ⇒ Object 



2297
2298
2299
2300
2301
2302
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2297

def process_GetNodeProductType(seqid, iprot, oprot)
  args = read_args(iprot, GetNodeProductType_args)
  result = GetNodeProductType_result.new()
  result.success = @handler.GetNodeProductType(args._homeId, args._nodeId)
  write_result(result, oprot, 'GetNodeProductType', seqid)
end

#process_GetNodeSecurity(seqid, iprot, oprot) ⇒ Object 



2220
2221
2222
2223
2224
2225
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2220

def process_GetNodeSecurity(seqid, iprot, oprot)
  args = read_args(iprot, GetNodeSecurity_args)
  result = GetNodeSecurity_result.new()
  result.success = @handler.GetNodeSecurity(args._homeId, args._nodeId)
  write_result(result, oprot, 'GetNodeSecurity', seqid)
end

#process_GetNodeSpecific(seqid, iprot, oprot) ⇒ Object 



2241
2242
2243
2244
2245
2246
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2241

def process_GetNodeSpecific(seqid, iprot, oprot)
  args = read_args(iprot, GetNodeSpecific_args)
  result = GetNodeSpecific_result.new()
  result.success = @handler.GetNodeSpecific(args._homeId, args._nodeId)
  write_result(result, oprot, 'GetNodeSpecific', seqid)
end

#process_GetNodeType(seqid, iprot, oprot) ⇒ Object 



2248
2249
2250
2251
2252
2253
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2248

def process_GetNodeType(seqid, iprot, oprot)
  args = read_args(iprot, GetNodeType_args)
  result = GetNodeType_result.new()
  result.success = @handler.GetNodeType(args._homeId, args._nodeId)
  write_result(result, oprot, 'GetNodeType', seqid)
end

#process_GetNodeVersion(seqid, iprot, oprot) ⇒ Object 



2213
2214
2215
2216
2217
2218
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2213

def process_GetNodeVersion(seqid, iprot, oprot)
  args = read_args(iprot, GetNodeVersion_args)
  result = GetNodeVersion_result.new()
  result.success = @handler.GetNodeVersion(args._homeId, args._nodeId)
  write_result(result, oprot, 'GetNodeVersion', seqid)
end

#process_GetNumGroups(seqid, iprot, oprot) ⇒ Object 



2675
2676
2677
2678
2679
2680
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2675

def process_GetNumGroups(seqid, iprot, oprot)
  args = read_args(iprot, GetNumGroups_args)
  result = GetNumGroups_result.new()
  result.success = @handler.GetNumGroups(args._homeId, args._nodeId)
  write_result(result, oprot, 'GetNumGroups', seqid)
end

#process_GetNumScenes(seqid, iprot, oprot) ⇒ Object 



2745
2746
2747
2748
2749
2750
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2745

def process_GetNumScenes(seqid, iprot, oprot)
  args = read_args(iprot, GetNumScenes_args)
  result = GetNumScenes_result.new()
  result.success = @handler.GetNumScenes()
  write_result(result, oprot, 'GetNumScenes', seqid)
end

#process_GetNumSwitchPoints(seqid, iprot, oprot) ⇒ Object 



2605
2606
2607
2608
2609
2610
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2605

def process_GetNumSwitchPoints(seqid, iprot, oprot)
  args = read_args(iprot, GetNumSwitchPoints_args)
  result = GetNumSwitchPoints_result.new()
  result.success = @handler.GetNumSwitchPoints(args._id)
  write_result(result, oprot, 'GetNumSwitchPoints', seqid)
end

#process_GetPollInterval(seqid, iprot, oprot) ⇒ Object 



2108
2109
2110
2111
2112
2113
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2108

def process_GetPollInterval(seqid, iprot, oprot)
  args = read_args(iprot, GetPollInterval_args)
  result = GetPollInterval_result.new()
  result.success = @handler.GetPollInterval()
  write_result(result, oprot, 'GetPollInterval', seqid)
end

#process_GetSceneLabel(seqid, iprot, oprot) ⇒ Object 



2955
2956
2957
2958
2959
2960
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2955

def process_GetSceneLabel(seqid, iprot, oprot)
  args = read_args(iprot, GetSceneLabel_args)
  result = GetSceneLabel_result.new()
  result.success = @handler.GetSceneLabel(args._sceneId)
  write_result(result, oprot, 'GetSceneLabel', seqid)
end

#process_GetSendQueueCount(seqid, iprot, oprot) ⇒ Object 



2094
2095
2096
2097
2098
2099
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2094

def process_GetSendQueueCount(seqid, iprot, oprot)
  args = read_args(iprot, GetSendQueueCount_args)
  result = GetSendQueueCount_result.new()
  result.success = @handler.GetSendQueueCount(args._homeId)
  write_result(result, oprot, 'GetSendQueueCount', seqid)
end

#process_GetSwitchPoint(seqid, iprot, oprot) ⇒ Object 



2633
2634
2635
2636
2637
2638
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2633

def process_GetSwitchPoint(seqid, iprot, oprot)
  args = read_args(iprot, GetSwitchPoint_args)
  result = GetSwitchPoint_result.new()
  result.success = @handler.GetSwitchPoint(args._id, args._idx)
  write_result(result, oprot, 'GetSwitchPoint', seqid)
end

#process_GetValueAsBool(seqid, iprot, oprot) ⇒ Object 



2458
2459
2460
2461
2462
2463
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2458

def process_GetValueAsBool(seqid, iprot, oprot)
  args = read_args(iprot, GetValueAsBool_args)
  result = GetValueAsBool_result.new()
  result.success = @handler.GetValueAsBool(args._id)
  write_result(result, oprot, 'GetValueAsBool', seqid)
end

#process_GetValueAsByte(seqid, iprot, oprot) ⇒ Object 



2465
2466
2467
2468
2469
2470
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2465

def process_GetValueAsByte(seqid, iprot, oprot)
  args = read_args(iprot, GetValueAsByte_args)
  result = GetValueAsByte_result.new()
  result.success = @handler.GetValueAsByte(args._id)
  write_result(result, oprot, 'GetValueAsByte', seqid)
end

#process_GetValueAsFloat(seqid, iprot, oprot) ⇒ Object 



2472
2473
2474
2475
2476
2477
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2472

def process_GetValueAsFloat(seqid, iprot, oprot)
  args = read_args(iprot, GetValueAsFloat_args)
  result = GetValueAsFloat_result.new()
  result.success = @handler.GetValueAsFloat(args._id)
  write_result(result, oprot, 'GetValueAsFloat', seqid)
end

#process_GetValueAsInt(seqid, iprot, oprot) ⇒ Object 



2479
2480
2481
2482
2483
2484
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2479

def process_GetValueAsInt(seqid, iprot, oprot)
  args = read_args(iprot, GetValueAsInt_args)
  result = GetValueAsInt_result.new()
  result.success = @handler.GetValueAsInt(args._id)
  write_result(result, oprot, 'GetValueAsInt', seqid)
end

#process_GetValueAsShort(seqid, iprot, oprot) ⇒ Object 



2486
2487
2488
2489
2490
2491
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2486

def process_GetValueAsShort(seqid, iprot, oprot)
  args = read_args(iprot, GetValueAsShort_args)
  result = GetValueAsShort_result.new()
  result.success = @handler.GetValueAsShort(args._id)
  write_result(result, oprot, 'GetValueAsShort', seqid)
end

#process_GetValueAsString(seqid, iprot, oprot) ⇒ Object 



2493
2494
2495
2496
2497
2498
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2493

def process_GetValueAsString(seqid, iprot, oprot)
  args = read_args(iprot, GetValueAsString_args)
  result = GetValueAsString_result.new()
  result.success = @handler.GetValueAsString(args._id)
  write_result(result, oprot, 'GetValueAsString', seqid)
end

#process_GetValueFloatPrecision(seqid, iprot, oprot) ⇒ Object 



2521
2522
2523
2524
2525
2526
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2521

def process_GetValueFloatPrecision(seqid, iprot, oprot)
  args = read_args(iprot, GetValueFloatPrecision_args)
  result = GetValueFloatPrecision_result.new()
  result.success = @handler.GetValueFloatPrecision(args._id)
  write_result(result, oprot, 'GetValueFloatPrecision', seqid)
end

#process_GetValueHelp(seqid, iprot, oprot) ⇒ Object 



2402
2403
2404
2405
2406
2407
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2402

def process_GetValueHelp(seqid, iprot, oprot)
  args = read_args(iprot, GetValueHelp_args)
  result = GetValueHelp_result.new()
  result.success = @handler.GetValueHelp(args._id)
  write_result(result, oprot, 'GetValueHelp', seqid)
end

#process_GetValueLabel(seqid, iprot, oprot) ⇒ Object 



2374
2375
2376
2377
2378
2379
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2374

def process_GetValueLabel(seqid, iprot, oprot)
  args = read_args(iprot, GetValueLabel_args)
  result = GetValueLabel_result.new()
  result.success = @handler.GetValueLabel(args._id)
  write_result(result, oprot, 'GetValueLabel', seqid)
end

#process_GetValueListItems(seqid, iprot, oprot) ⇒ Object 



2514
2515
2516
2517
2518
2519
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2514

def process_GetValueListItems(seqid, iprot, oprot)
  args = read_args(iprot, GetValueListItems_args)
  result = GetValueListItems_result.new()
  result.success = @handler.GetValueListItems(args._id)
  write_result(result, oprot, 'GetValueListItems', seqid)
end

#process_GetValueListSelection_Int32(seqid, iprot, oprot) ⇒ Object 



2507
2508
2509
2510
2511
2512
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2507

def process_GetValueListSelection_Int32(seqid, iprot, oprot)
  args = read_args(iprot, GetValueListSelection_Int32_args)
  result = GetValueListSelection_Int32_result.new()
  result.success = @handler.GetValueListSelection_Int32(args._id)
  write_result(result, oprot, 'GetValueListSelection_Int32', seqid)
end

#process_GetValueListSelection_String(seqid, iprot, oprot) ⇒ Object 



2500
2501
2502
2503
2504
2505
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2500

def process_GetValueListSelection_String(seqid, iprot, oprot)
  args = read_args(iprot, GetValueListSelection_String_args)
  result = GetValueListSelection_String_result.new()
  result.success = @handler.GetValueListSelection_String(args._id)
  write_result(result, oprot, 'GetValueListSelection_String', seqid)
end

#process_GetValueMax(seqid, iprot, oprot) ⇒ Object 



2423
2424
2425
2426
2427
2428
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2423

def process_GetValueMax(seqid, iprot, oprot)
  args = read_args(iprot, GetValueMax_args)
  result = GetValueMax_result.new()
  result.success = @handler.GetValueMax(args._id)
  write_result(result, oprot, 'GetValueMax', seqid)
end

#process_GetValueMin(seqid, iprot, oprot) ⇒ Object 



2416
2417
2418
2419
2420
2421
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2416

def process_GetValueMin(seqid, iprot, oprot)
  args = read_args(iprot, GetValueMin_args)
  result = GetValueMin_result.new()
  result.success = @handler.GetValueMin(args._id)
  write_result(result, oprot, 'GetValueMin', seqid)
end

#process_GetValueUnits(seqid, iprot, oprot) ⇒ Object 



2388
2389
2390
2391
2392
2393
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2388

def process_GetValueUnits(seqid, iprot, oprot)
  args = read_args(iprot, GetValueUnits_args)
  result = GetValueUnits_result.new()
  result.success = @handler.GetValueUnits(args._id)
  write_result(result, oprot, 'GetValueUnits', seqid)
end

#process_IsBridgeController(seqid, iprot, oprot) ⇒ Object 



2073
2074
2075
2076
2077
2078
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2073

def process_IsBridgeController(seqid, iprot, oprot)
  args = read_args(iprot, IsBridgeController_args)
  result = IsBridgeController_result.new()
  result.success = @handler.IsBridgeController(args._homeId)
  write_result(result, oprot, 'IsBridgeController', seqid)
end

#process_IsNodeBeamingDevice(seqid, iprot, oprot) ⇒ Object 



2185
2186
2187
2188
2189
2190
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2185

def process_IsNodeBeamingDevice(seqid, iprot, oprot)
  args = read_args(iprot, IsNodeBeamingDevice_args)
  result = IsNodeBeamingDevice_result.new()
  result.success = @handler.IsNodeBeamingDevice(args._homeId, args._nodeId)
  write_result(result, oprot, 'IsNodeBeamingDevice', seqid)
end

#process_IsNodeFrequentListeningDevice(seqid, iprot, oprot) ⇒ Object 



2178
2179
2180
2181
2182
2183
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2178

def process_IsNodeFrequentListeningDevice(seqid, iprot, oprot)
  args = read_args(iprot, IsNodeFrequentListeningDevice_args)
  result = IsNodeFrequentListeningDevice_result.new()
  result.success = @handler.IsNodeFrequentListeningDevice(args._homeId, args._nodeId)
  write_result(result, oprot, 'IsNodeFrequentListeningDevice', seqid)
end

#process_IsNodeInfoReceived(seqid, iprot, oprot) ⇒ Object 



2360
2361
2362
2363
2364
2365
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2360

def process_IsNodeInfoReceived(seqid, iprot, oprot)
  args = read_args(iprot, IsNodeInfoReceived_args)
  result = IsNodeInfoReceived_result.new()
  result.success = @handler.IsNodeInfoReceived(args._homeId, args._nodeId)
  write_result(result, oprot, 'IsNodeInfoReceived', seqid)
end

#process_IsNodeListeningDevice(seqid, iprot, oprot) ⇒ Object 



2171
2172
2173
2174
2175
2176
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2171

def process_IsNodeListeningDevice(seqid, iprot, oprot)
  args = read_args(iprot, IsNodeListeningDevice_args)
  result = IsNodeListeningDevice_result.new()
  result.success = @handler.IsNodeListeningDevice(args._homeId, args._nodeId)
  write_result(result, oprot, 'IsNodeListeningDevice', seqid)
end

#process_IsNodeRoutingDevice(seqid, iprot, oprot) ⇒ Object 



2192
2193
2194
2195
2196
2197
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2192

def process_IsNodeRoutingDevice(seqid, iprot, oprot)
  args = read_args(iprot, IsNodeRoutingDevice_args)
  result = IsNodeRoutingDevice_result.new()
  result.success = @handler.IsNodeRoutingDevice(args._homeId, args._nodeId)
  write_result(result, oprot, 'IsNodeRoutingDevice', seqid)
end

#process_IsNodeSecurityDevice(seqid, iprot, oprot) ⇒ Object 



2199
2200
2201
2202
2203
2204
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2199

def process_IsNodeSecurityDevice(seqid, iprot, oprot)
  args = read_args(iprot, IsNodeSecurityDevice_args)
  result = IsNodeSecurityDevice_result.new()
  result.success = @handler.IsNodeSecurityDevice(args._homeId, args._nodeId)
  write_result(result, oprot, 'IsNodeSecurityDevice', seqid)
end

#process_isPolled(seqid, iprot, oprot) ⇒ Object 



2136
2137
2138
2139
2140
2141
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2136

def process_isPolled(seqid, iprot, oprot)
  args = read_args(iprot, IsPolled_args)
  result = IsPolled_result.new()
  result.success = @handler.isPolled(args._valueId)
  write_result(result, oprot, 'isPolled', seqid)
end

#process_IsPrimaryController(seqid, iprot, oprot) ⇒ Object 



2059
2060
2061
2062
2063
2064
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2059

def process_IsPrimaryController(seqid, iprot, oprot)
  args = read_args(iprot, IsPrimaryController_args)
  result = IsPrimaryController_result.new()
  result.success = @handler.IsPrimaryController(args._homeId)
  write_result(result, oprot, 'IsPrimaryController', seqid)
end

#process_IsStaticUpdateController(seqid, iprot, oprot) ⇒ Object 



2066
2067
2068
2069
2070
2071
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2066

def process_IsStaticUpdateController(seqid, iprot, oprot)
  args = read_args(iprot, IsStaticUpdateController_args)
  result = IsStaticUpdateController_result.new()
  result.success = @handler.IsStaticUpdateController(args._homeId)
  write_result(result, oprot, 'IsStaticUpdateController', seqid)
end

#process_IsValuePolled(seqid, iprot, oprot) ⇒ Object 



2451
2452
2453
2454
2455
2456
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2451

def process_IsValuePolled(seqid, iprot, oprot)
  args = read_args(iprot, IsValuePolled_args)
  result = IsValuePolled_result.new()
  result.success = @handler.IsValuePolled(args._id)
  write_result(result, oprot, 'IsValuePolled', seqid)
end

#process_IsValueReadOnly(seqid, iprot, oprot) ⇒ Object 



2430
2431
2432
2433
2434
2435
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2430

def process_IsValueReadOnly(seqid, iprot, oprot)
  args = read_args(iprot, IsValueReadOnly_args)
  result = IsValueReadOnly_result.new()
  result.success = @handler.IsValueReadOnly(args._id)
  write_result(result, oprot, 'IsValueReadOnly', seqid)
end

#process_IsValueSet(seqid, iprot, oprot) ⇒ Object 



2444
2445
2446
2447
2448
2449
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2444

def process_IsValueSet(seqid, iprot, oprot)
  args = read_args(iprot, IsValueSet_args)
  result = IsValueSet_result.new()
  result.success = @handler.IsValueSet(args._id)
  write_result(result, oprot, 'IsValueSet', seqid)
end

#process_IsValueWriteOnly(seqid, iprot, oprot) ⇒ Object 



2437
2438
2439
2440
2441
2442
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2437

def process_IsValueWriteOnly(seqid, iprot, oprot)
  args = read_args(iprot, IsValueWriteOnly_args)
  result = IsValueWriteOnly_result.new()
  result.success = @handler.IsValueWriteOnly(args._id)
  write_result(result, oprot, 'IsValueWriteOnly', seqid)
end

#process_LogDriverStatistics(seqid, iprot, oprot) ⇒ Object 



2101
2102
2103
2104
2105
2106
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2101

def process_LogDriverStatistics(seqid, iprot, oprot)
  args = read_args(iprot, LogDriverStatistics_args)
  result = LogDriverStatistics_result.new()
  @handler.LogDriverStatistics(args._homeId)
  write_result(result, oprot, 'LogDriverStatistics', seqid)
end

#process_ping(seqid, iprot, oprot) ⇒ Object 



2997
2998
2999
3000
3001
3002
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2997

def process_ping(seqid, iprot, oprot)
  args = read_args(iprot, Ping_args)
  result = Ping_result.new()
  @handler.ping()
  write_result(result, oprot, 'ping', seqid)
end

#process_PressButton(seqid, iprot, oprot) ⇒ Object 



2591
2592
2593
2594
2595
2596
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2591

def process_PressButton(seqid, iprot, oprot)
  args = read_args(iprot, PressButton_args)
  result = PressButton_result.new()
  result.success = @handler.PressButton(args._id)
  write_result(result, oprot, 'PressButton', seqid)
end

#process_RefreshNodeInfo(seqid, iprot, oprot) ⇒ Object 



2150
2151
2152
2153
2154
2155
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2150

def process_RefreshNodeInfo(seqid, iprot, oprot)
  args = read_args(iprot, RefreshNodeInfo_args)
  result = RefreshNodeInfo_result.new()
  result.success = @handler.RefreshNodeInfo(args._homeId, args._nodeId)
  write_result(result, oprot, 'RefreshNodeInfo', seqid)
end

#process_RefreshValue(seqid, iprot, oprot) ⇒ Object 



2577
2578
2579
2580
2581
2582
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2577

def process_RefreshValue(seqid, iprot, oprot)
  args = read_args(iprot, RefreshValue_args)
  result = RefreshValue_result.new()
  result.success = @handler.RefreshValue(args._id)
  write_result(result, oprot, 'RefreshValue', seqid)
end

#process_ReleaseButton(seqid, iprot, oprot) ⇒ Object 



2598
2599
2600
2601
2602
2603
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2598

def process_ReleaseButton(seqid, iprot, oprot)
  args = read_args(iprot, ReleaseButton_args)
  result = ReleaseButton_result.new()
  result.success = @handler.ReleaseButton(args._id)
  write_result(result, oprot, 'ReleaseButton', seqid)
end

#process_RemoveAssociation(seqid, iprot, oprot) ⇒ Object 



2710
2711
2712
2713
2714
2715
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2710

def process_RemoveAssociation(seqid, iprot, oprot)
  args = read_args(iprot, RemoveAssociation_args)
  result = RemoveAssociation_result.new()
  @handler.RemoveAssociation(args._homeId, args._nodeId, args._groupIdx, args._targetNodeId)
  write_result(result, oprot, 'RemoveAssociation', seqid)
end

#process_RemoveScene(seqid, iprot, oprot) ⇒ Object 



2766
2767
2768
2769
2770
2771
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2766

def process_RemoveScene(seqid, iprot, oprot)
  args = read_args(iprot, RemoveScene_args)
  result = RemoveScene_result.new()
  result.success = @handler.RemoveScene(args._sceneId)
  write_result(result, oprot, 'RemoveScene', seqid)
end

#process_RemoveSceneValue(seqid, iprot, oprot) ⇒ Object 



2829
2830
2831
2832
2833
2834
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2829

def process_RemoveSceneValue(seqid, iprot, oprot)
  args = read_args(iprot, RemoveSceneValue_args)
  result = RemoveSceneValue_result.new()
  result.success = @handler.RemoveSceneValue(args._sceneId, args._valueId)
  write_result(result, oprot, 'RemoveSceneValue', seqid)
end

#process_RemoveSwitchPoint(seqid, iprot, oprot) ⇒ Object 



2619
2620
2621
2622
2623
2624
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2619

def process_RemoveSwitchPoint(seqid, iprot, oprot)
  args = read_args(iprot, RemoveSwitchPoint_args)
  result = RemoveSwitchPoint_result.new()
  result.success = @handler.RemoveSwitchPoint(args._id, args._hours, args._minutes)
  write_result(result, oprot, 'RemoveSwitchPoint', seqid)
end

#process_RequestAllConfigParams(seqid, iprot, oprot) ⇒ Object 



2668
2669
2670
2671
2672
2673
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2668

def process_RequestAllConfigParams(seqid, iprot, oprot)
  args = read_args(iprot, RequestAllConfigParams_args)
  result = RequestAllConfigParams_result.new()
  @handler.RequestAllConfigParams(args._homeId, args._nodeId)
  write_result(result, oprot, 'RequestAllConfigParams', seqid)
end

#process_RequestConfigParam(seqid, iprot, oprot) ⇒ Object 



2661
2662
2663
2664
2665
2666
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2661

def process_RequestConfigParam(seqid, iprot, oprot)
  args = read_args(iprot, RequestConfigParam_args)
  result = RequestConfigParam_result.new()
  @handler.RequestConfigParam(args._homeId, args._nodeId, args._param)
  write_result(result, oprot, 'RequestConfigParam', seqid)
end

#process_RequestNodeDynamic(seqid, iprot, oprot) ⇒ Object 



2164
2165
2166
2167
2168
2169
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2164

def process_RequestNodeDynamic(seqid, iprot, oprot)
  args = read_args(iprot, RequestNodeDynamic_args)
  result = RequestNodeDynamic_result.new()
  result.success = @handler.RequestNodeDynamic(args._homeId, args._nodeId)
  write_result(result, oprot, 'RequestNodeDynamic', seqid)
end

#process_RequestNodeState(seqid, iprot, oprot) ⇒ Object 



2157
2158
2159
2160
2161
2162
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2157

def process_RequestNodeState(seqid, iprot, oprot)
  args = read_args(iprot, RequestNodeState_args)
  result = RequestNodeState_result.new()
  result.success = @handler.RequestNodeState(args._homeId, args._nodeId)
  write_result(result, oprot, 'RequestNodeState', seqid)
end

#process_ResetController(seqid, iprot, oprot) ⇒ Object 



2717
2718
2719
2720
2721
2722
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2717

def process_ResetController(seqid, iprot, oprot)
  args = read_args(iprot, ResetController_args)
  result = ResetController_result.new()
  @handler.ResetController(args._homeId)
  write_result(result, oprot, 'ResetController', seqid)
end

#process_SceneExists(seqid, iprot, oprot) ⇒ Object 



2969
2970
2971
2972
2973
2974
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2969

def process_SceneExists(seqid, iprot, oprot)
  args = read_args(iprot, SceneExists_args)
  result = SceneExists_result.new()
  result.success = @handler.SceneExists(args._sceneId)
  write_result(result, oprot, 'SceneExists', seqid)
end

#process_SceneGetValueAsBool(seqid, iprot, oprot) ⇒ Object 



2843
2844
2845
2846
2847
2848
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2843

def process_SceneGetValueAsBool(seqid, iprot, oprot)
  args = read_args(iprot, SceneGetValueAsBool_args)
  result = SceneGetValueAsBool_result.new()
  result.success = @handler.SceneGetValueAsBool(args._sceneId, args._valueId)
  write_result(result, oprot, 'SceneGetValueAsBool', seqid)
end

#process_SceneGetValueAsByte(seqid, iprot, oprot) ⇒ Object 



2850
2851
2852
2853
2854
2855
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2850

def process_SceneGetValueAsByte(seqid, iprot, oprot)
  args = read_args(iprot, SceneGetValueAsByte_args)
  result = SceneGetValueAsByte_result.new()
  result.success = @handler.SceneGetValueAsByte(args._sceneId, args._valueId)
  write_result(result, oprot, 'SceneGetValueAsByte', seqid)
end

#process_SceneGetValueAsFloat(seqid, iprot, oprot) ⇒ Object 



2857
2858
2859
2860
2861
2862
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2857

def process_SceneGetValueAsFloat(seqid, iprot, oprot)
  args = read_args(iprot, SceneGetValueAsFloat_args)
  result = SceneGetValueAsFloat_result.new()
  result.success = @handler.SceneGetValueAsFloat(args._sceneId, args._valueId)
  write_result(result, oprot, 'SceneGetValueAsFloat', seqid)
end

#process_SceneGetValueAsInt(seqid, iprot, oprot) ⇒ Object 



2864
2865
2866
2867
2868
2869
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2864

def process_SceneGetValueAsInt(seqid, iprot, oprot)
  args = read_args(iprot, SceneGetValueAsInt_args)
  result = SceneGetValueAsInt_result.new()
  result.success = @handler.SceneGetValueAsInt(args._sceneId, args._valueId)
  write_result(result, oprot, 'SceneGetValueAsInt', seqid)
end

#process_SceneGetValueAsShort(seqid, iprot, oprot) ⇒ Object 



2871
2872
2873
2874
2875
2876
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2871

def process_SceneGetValueAsShort(seqid, iprot, oprot)
  args = read_args(iprot, SceneGetValueAsShort_args)
  result = SceneGetValueAsShort_result.new()
  result.success = @handler.SceneGetValueAsShort(args._sceneId, args._valueId)
  write_result(result, oprot, 'SceneGetValueAsShort', seqid)
end

#process_SceneGetValueAsString(seqid, iprot, oprot) ⇒ Object 



2878
2879
2880
2881
2882
2883
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2878

def process_SceneGetValueAsString(seqid, iprot, oprot)
  args = read_args(iprot, SceneGetValueAsString_args)
  result = SceneGetValueAsString_result.new()
  result.success = @handler.SceneGetValueAsString(args._sceneId, args._valueId)
  write_result(result, oprot, 'SceneGetValueAsString', seqid)
end

#process_SceneGetValueListSelection_Int32(seqid, iprot, oprot) ⇒ Object 



2892
2893
2894
2895
2896
2897
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2892

def process_SceneGetValueListSelection_Int32(seqid, iprot, oprot)
  args = read_args(iprot, SceneGetValueListSelection_Int32_args)
  result = SceneGetValueListSelection_Int32_result.new()
  result.success = @handler.SceneGetValueListSelection_Int32(args._sceneId, args._valueId)
  write_result(result, oprot, 'SceneGetValueListSelection_Int32', seqid)
end

#process_SceneGetValueListSelection_String(seqid, iprot, oprot) ⇒ Object 



2885
2886
2887
2888
2889
2890
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2885

def process_SceneGetValueListSelection_String(seqid, iprot, oprot)
  args = read_args(iprot, SceneGetValueListSelection_String_args)
  result = SceneGetValueListSelection_String_result.new()
  result.success = @handler.SceneGetValueListSelection_String(args._sceneId, args._valueId)
  write_result(result, oprot, 'SceneGetValueListSelection_String', seqid)
end

#process_SceneGetValues(seqid, iprot, oprot) ⇒ Object 



2836
2837
2838
2839
2840
2841
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2836

def process_SceneGetValues(seqid, iprot, oprot)
  args = read_args(iprot, SceneGetValues_args)
  result = SceneGetValues_result.new()
  result.success = @handler.SceneGetValues(args._sceneId)
  write_result(result, oprot, 'SceneGetValues', seqid)
end

#process_SendAllValues(seqid, iprot, oprot) ⇒ Object 



2990
2991
2992
2993
2994
2995
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2990

def process_SendAllValues(seqid, iprot, oprot)
  args = read_args(iprot, SendAllValues_args)
  result = SendAllValues_result.new()
  @handler.SendAllValues()
  write_result(result, oprot, 'SendAllValues', seqid)
end

#process_SetChangeVerified(seqid, iprot, oprot) ⇒ Object 



2584
2585
2586
2587
2588
2589
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2584

def process_SetChangeVerified(seqid, iprot, oprot)
  args = read_args(iprot, SetChangeVerified_args)
  result = SetChangeVerified_result.new()
  @handler.SetChangeVerified(args._id, args._verify)
  write_result(result, oprot, 'SetChangeVerified', seqid)
end

#process_SetConfigParam(seqid, iprot, oprot) ⇒ Object 



2654
2655
2656
2657
2658
2659
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2654

def process_SetConfigParam(seqid, iprot, oprot)
  args = read_args(iprot, SetConfigParam_args)
  result = SetConfigParam_result.new()
  result.success = @handler.SetConfigParam(args._homeId, args._nodeId, args._param, args._value, args._size)
  write_result(result, oprot, 'SetConfigParam', seqid)
end

#process_SetNodeLevel(seqid, iprot, oprot) ⇒ Object 



2353
2354
2355
2356
2357
2358
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2353

def process_SetNodeLevel(seqid, iprot, oprot)
  args = read_args(iprot, SetNodeLevel_args)
  result = SetNodeLevel_result.new()
  @handler.SetNodeLevel(args._homeId, args._nodeId, args._level)
  write_result(result, oprot, 'SetNodeLevel', seqid)
end

#process_SetNodeLocation(seqid, iprot, oprot) ⇒ Object 



2332
2333
2334
2335
2336
2337
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2332

def process_SetNodeLocation(seqid, iprot, oprot)
  args = read_args(iprot, SetNodeLocation_args)
  result = SetNodeLocation_result.new()
  @handler.SetNodeLocation(args._homeId, args._nodeId, args._location)
  write_result(result, oprot, 'SetNodeLocation', seqid)
end

#process_SetNodeManufacturerName(seqid, iprot, oprot) ⇒ Object 



2311
2312
2313
2314
2315
2316
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2311

def process_SetNodeManufacturerName(seqid, iprot, oprot)
  args = read_args(iprot, SetNodeManufacturerName_args)
  result = SetNodeManufacturerName_result.new()
  @handler.SetNodeManufacturerName(args._homeId, args._nodeId, args._manufacturerName)
  write_result(result, oprot, 'SetNodeManufacturerName', seqid)
end

#process_SetNodeName(seqid, iprot, oprot) ⇒ Object 



2325
2326
2327
2328
2329
2330
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2325

def process_SetNodeName(seqid, iprot, oprot)
  args = read_args(iprot, SetNodeName_args)
  result = SetNodeName_result.new()
  @handler.SetNodeName(args._homeId, args._nodeId, args._nodeName)
  write_result(result, oprot, 'SetNodeName', seqid)
end

#process_SetNodeOff(seqid, iprot, oprot) ⇒ Object 



2346
2347
2348
2349
2350
2351
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2346

def process_SetNodeOff(seqid, iprot, oprot)
  args = read_args(iprot, SetNodeOff_args)
  result = SetNodeOff_result.new()
  @handler.SetNodeOff(args._homeId, args._nodeId)
  write_result(result, oprot, 'SetNodeOff', seqid)
end

#process_SetNodeOn(seqid, iprot, oprot) ⇒ Object 



2339
2340
2341
2342
2343
2344
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2339

def process_SetNodeOn(seqid, iprot, oprot)
  args = read_args(iprot, SetNodeOn_args)
  result = SetNodeOn_result.new()
  @handler.SetNodeOn(args._homeId, args._nodeId)
  write_result(result, oprot, 'SetNodeOn', seqid)
end

#process_SetNodeProductName(seqid, iprot, oprot) ⇒ Object 



2318
2319
2320
2321
2322
2323
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2318

def process_SetNodeProductName(seqid, iprot, oprot)
  args = read_args(iprot, SetNodeProductName_args)
  result = SetNodeProductName_result.new()
  @handler.SetNodeProductName(args._homeId, args._nodeId, args._productName)
  write_result(result, oprot, 'SetNodeProductName', seqid)
end

#process_SetPollIntensity(seqid, iprot, oprot) ⇒ Object 



2143
2144
2145
2146
2147
2148
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2143

def process_SetPollIntensity(seqid, iprot, oprot)
  args = read_args(iprot, SetPollIntensity_args)
  result = SetPollIntensity_result.new()
  @handler.SetPollIntensity(args._valueId, args._intensity)
  write_result(result, oprot, 'SetPollIntensity', seqid)
end

#process_SetPollInterval(seqid, iprot, oprot) ⇒ Object 



2115
2116
2117
2118
2119
2120
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2115

def process_SetPollInterval(seqid, iprot, oprot)
  args = read_args(iprot, SetPollInterval_args)
  result = SetPollInterval_result.new()
  @handler.SetPollInterval(args._milliseconds, args._bIntervalBetweenPolls)
  write_result(result, oprot, 'SetPollInterval', seqid)
end

#process_SetSceneLabel(seqid, iprot, oprot) ⇒ Object 



2962
2963
2964
2965
2966
2967
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2962

def process_SetSceneLabel(seqid, iprot, oprot)
  args = read_args(iprot, SetSceneLabel_args)
  result = SetSceneLabel_result.new()
  @handler.SetSceneLabel(args._sceneId, args._value)
  write_result(result, oprot, 'SetSceneLabel', seqid)
end

#process_SetSceneValue_Bool(seqid, iprot, oprot) ⇒ Object 



2899
2900
2901
2902
2903
2904
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2899

def process_SetSceneValue_Bool(seqid, iprot, oprot)
  args = read_args(iprot, SetSceneValue_Bool_args)
  result = SetSceneValue_Bool_result.new()
  result.success = @handler.SetSceneValue_Bool(args._sceneId, args._valueId, args._value)
  write_result(result, oprot, 'SetSceneValue_Bool', seqid)
end

#process_SetSceneValue_Float(seqid, iprot, oprot) ⇒ Object 



2913
2914
2915
2916
2917
2918
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2913

def process_SetSceneValue_Float(seqid, iprot, oprot)
  args = read_args(iprot, SetSceneValue_Float_args)
  result = SetSceneValue_Float_result.new()
  result.success = @handler.SetSceneValue_Float(args._sceneId, args._valueId, args._value)
  write_result(result, oprot, 'SetSceneValue_Float', seqid)
end

#process_SetSceneValue_Int16(seqid, iprot, oprot) ⇒ Object 



2927
2928
2929
2930
2931
2932
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2927

def process_SetSceneValue_Int16(seqid, iprot, oprot)
  args = read_args(iprot, SetSceneValue_Int16_args)
  result = SetSceneValue_Int16_result.new()
  result.success = @handler.SetSceneValue_Int16(args._sceneId, args._valueId, args._value)
  write_result(result, oprot, 'SetSceneValue_Int16', seqid)
end

#process_SetSceneValue_Int32(seqid, iprot, oprot) ⇒ Object 



2920
2921
2922
2923
2924
2925
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2920

def process_SetSceneValue_Int32(seqid, iprot, oprot)
  args = read_args(iprot, SetSceneValue_Int32_args)
  result = SetSceneValue_Int32_result.new()
  result.success = @handler.SetSceneValue_Int32(args._sceneId, args._valueId, args._value)
  write_result(result, oprot, 'SetSceneValue_Int32', seqid)
end

#process_SetSceneValue_String(seqid, iprot, oprot) ⇒ Object 



2934
2935
2936
2937
2938
2939
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2934

def process_SetSceneValue_String(seqid, iprot, oprot)
  args = read_args(iprot, SetSceneValue_String_args)
  result = SetSceneValue_String_result.new()
  result.success = @handler.SetSceneValue_String(args._sceneId, args._valueId, args._value)
  write_result(result, oprot, 'SetSceneValue_String', seqid)
end

#process_SetSceneValue_Uint8(seqid, iprot, oprot) ⇒ Object 



2906
2907
2908
2909
2910
2911
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2906

def process_SetSceneValue_Uint8(seqid, iprot, oprot)
  args = read_args(iprot, SetSceneValue_Uint8_args)
  result = SetSceneValue_Uint8_result.new()
  result.success = @handler.SetSceneValue_Uint8(args._sceneId, args._valueId, args._value)
  write_result(result, oprot, 'SetSceneValue_Uint8', seqid)
end

#process_SetSceneValueListSelection_Int32(seqid, iprot, oprot) ⇒ Object 



2948
2949
2950
2951
2952
2953
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2948

def process_SetSceneValueListSelection_Int32(seqid, iprot, oprot)
  args = read_args(iprot, SetSceneValueListSelection_Int32_args)
  result = SetSceneValueListSelection_Int32_result.new()
  result.success = @handler.SetSceneValueListSelection_Int32(args._sceneId, args._valueId, args._value)
  write_result(result, oprot, 'SetSceneValueListSelection_Int32', seqid)
end

#process_SetSceneValueListSelection_String(seqid, iprot, oprot) ⇒ Object 



2941
2942
2943
2944
2945
2946
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2941

def process_SetSceneValueListSelection_String(seqid, iprot, oprot)
  args = read_args(iprot, SetSceneValueListSelection_String_args)
  result = SetSceneValueListSelection_String_result.new()
  result.success = @handler.SetSceneValueListSelection_String(args._sceneId, args._valueId, args._value)
  write_result(result, oprot, 'SetSceneValueListSelection_String', seqid)
end

#process_SetSwitchPoint(seqid, iprot, oprot) ⇒ Object 



2612
2613
2614
2615
2616
2617
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2612

def process_SetSwitchPoint(seqid, iprot, oprot)
  args = read_args(iprot, SetSwitchPoint_args)
  result = SetSwitchPoint_result.new()
  result.success = @handler.SetSwitchPoint(args._id, args._hours, args._minutes, args._setback)
  write_result(result, oprot, 'SetSwitchPoint', seqid)
end

#process_SetValue_Bool(seqid, iprot, oprot) ⇒ Object 



2528
2529
2530
2531
2532
2533
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2528

def process_SetValue_Bool(seqid, iprot, oprot)
  args = read_args(iprot, SetValue_Bool_args)
  result = SetValue_Bool_result.new()
  result.success = @handler.SetValue_Bool(args._id, args._value)
  write_result(result, oprot, 'SetValue_Bool', seqid)
end

#process_SetValue_Float(seqid, iprot, oprot) ⇒ Object 



2542
2543
2544
2545
2546
2547
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2542

def process_SetValue_Float(seqid, iprot, oprot)
  args = read_args(iprot, SetValue_Float_args)
  result = SetValue_Float_result.new()
  result.success = @handler.SetValue_Float(args._id, args._value)
  write_result(result, oprot, 'SetValue_Float', seqid)
end

#process_SetValue_Int16(seqid, iprot, oprot) ⇒ Object 



2556
2557
2558
2559
2560
2561
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2556

def process_SetValue_Int16(seqid, iprot, oprot)
  args = read_args(iprot, SetValue_Int16_args)
  result = SetValue_Int16_result.new()
  result.success = @handler.SetValue_Int16(args._id, args._value)
  write_result(result, oprot, 'SetValue_Int16', seqid)
end

#process_SetValue_Int32(seqid, iprot, oprot) ⇒ Object 



2549
2550
2551
2552
2553
2554
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2549

def process_SetValue_Int32(seqid, iprot, oprot)
  args = read_args(iprot, SetValue_Int32_args)
  result = SetValue_Int32_result.new()
  result.success = @handler.SetValue_Int32(args._id, args._value)
  write_result(result, oprot, 'SetValue_Int32', seqid)
end

#process_SetValue_String(seqid, iprot, oprot) ⇒ Object 



2563
2564
2565
2566
2567
2568
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2563

def process_SetValue_String(seqid, iprot, oprot)
  args = read_args(iprot, SetValue_String_args)
  result = SetValue_String_result.new()
  result.success = @handler.SetValue_String(args._id, args._value)
  write_result(result, oprot, 'SetValue_String', seqid)
end

#process_SetValue_UInt8(seqid, iprot, oprot) ⇒ Object 



2535
2536
2537
2538
2539
2540
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2535

def process_SetValue_UInt8(seqid, iprot, oprot)
  args = read_args(iprot, SetValue_UInt8_args)
  result = SetValue_UInt8_result.new()
  result.success = @handler.SetValue_UInt8(args._id, args._value)
  write_result(result, oprot, 'SetValue_UInt8', seqid)
end

#process_SetValueHelp(seqid, iprot, oprot) ⇒ Object 



2409
2410
2411
2412
2413
2414
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2409

def process_SetValueHelp(seqid, iprot, oprot)
  args = read_args(iprot, SetValueHelp_args)
  result = SetValueHelp_result.new()
  @handler.SetValueHelp(args._id, args._value)
  write_result(result, oprot, 'SetValueHelp', seqid)
end

#process_SetValueLabel(seqid, iprot, oprot) ⇒ Object 



2381
2382
2383
2384
2385
2386
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2381

def process_SetValueLabel(seqid, iprot, oprot)
  args = read_args(iprot, SetValueLabel_args)
  result = SetValueLabel_result.new()
  @handler.SetValueLabel(args._id, args._value)
  write_result(result, oprot, 'SetValueLabel', seqid)
end

#process_SetValueListSelection(seqid, iprot, oprot) ⇒ Object 



2570
2571
2572
2573
2574
2575
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2570

def process_SetValueListSelection(seqid, iprot, oprot)
  args = read_args(iprot, SetValueListSelection_args)
  result = SetValueListSelection_result.new()
  result.success = @handler.SetValueListSelection(args._id, args._selectedItem)
  write_result(result, oprot, 'SetValueListSelection', seqid)
end

#process_SetValueUnits(seqid, iprot, oprot) ⇒ Object 



2395
2396
2397
2398
2399
2400
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2395

def process_SetValueUnits(seqid, iprot, oprot)
  args = read_args(iprot, SetValueUnits_args)
  result = SetValueUnits_result.new()
  @handler.SetValueUnits(args._id, args._value)
  write_result(result, oprot, 'SetValueUnits', seqid)
end

#process_SoftReset(seqid, iprot, oprot) ⇒ Object 



2724
2725
2726
2727
2728
2729
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2724

def process_SoftReset(seqid, iprot, oprot)
  args = read_args(iprot, SoftReset_args)
  result = SoftReset_result.new()
  @handler.SoftReset(args._homeId)
  write_result(result, oprot, 'SoftReset', seqid)
end

#process_SwitchAllOff(seqid, iprot, oprot) ⇒ Object 



2647
2648
2649
2650
2651
2652
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2647

def process_SwitchAllOff(seqid, iprot, oprot)
  args = read_args(iprot, SwitchAllOff_args)
  result = SwitchAllOff_result.new()
  @handler.SwitchAllOff(args._homeId)
  write_result(result, oprot, 'SwitchAllOff', seqid)
end

#process_SwitchAllOn(seqid, iprot, oprot) ⇒ Object 



2640
2641
2642
2643
2644
2645
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2640

def process_SwitchAllOn(seqid, iprot, oprot)
  args = read_args(iprot, SwitchAllOn_args)
  result = SwitchAllOn_result.new()
  @handler.SwitchAllOn(args._homeId)
  write_result(result, oprot, 'SwitchAllOn', seqid)
end

#process_WriteConfig(seqid, iprot, oprot) ⇒ Object 



2045
2046
2047
2048
2049
2050
 
# File 'lib/ansible/zwave/openzwave/ozw_remote_manager.rb', line 2045

def process_WriteConfig(seqid, iprot, oprot)
  args = read_args(iprot, WriteConfig_args)
  result = WriteConfig_result.new()
  @handler.WriteConfig(args._homeId)
  write_result(result, oprot, 'WriteConfig', seqid)
end