Class: Hypertable::ThriftGen::ClientService::Processor

Inherits:
Object
  • Object
show all
Includes:
Thrift::Processor
Defined in:
lib/hypertable/gen-rb/client_service.rb

Direct Known Subclasses

HqlService::Processor

Instance Method Summary collapse

Instance Method Details

#process_close_mutator(seqid, iprot, oprot) ⇒ Object 



960
961
962
963
964
965
966
967
968
969
 
# File 'lib/hypertable/gen-rb/client_service.rb', line 960

def process_close_mutator(seqid, iprot, oprot)
  args = read_args(iprot, Close_mutator_args)
  result = Close_mutator_result.new()
  begin
    @handler.close_mutator(args.mutator, args.flush)
  rescue Hypertable::ThriftGen::ClientException => e
    result.e = e
  end
  write_result(result, oprot, 'close_mutator', seqid)
end

#process_close_namespace(seqid, iprot, oprot) ⇒ Object 



722
723
724
725
726
727
728
729
730
731
 
# File 'lib/hypertable/gen-rb/client_service.rb', line 722

def process_close_namespace(seqid, iprot, oprot)
  args = read_args(iprot, Close_namespace_args)
  result = Close_namespace_result.new()
  begin
    @handler.close_namespace(args.ns)
  rescue Hypertable::ThriftGen::ClientException => e
    result.e = e
  end
  write_result(result, oprot, 'close_namespace', seqid)
end

#process_close_scanner(seqid, iprot, oprot) ⇒ Object 



744
745
746
747
748
749
750
751
752
753
 
# File 'lib/hypertable/gen-rb/client_service.rb', line 744

def process_close_scanner(seqid, iprot, oprot)
  args = read_args(iprot, Close_scanner_args)
  result = Close_scanner_result.new()
  begin
    @handler.close_scanner(args.scanner)
  rescue Hypertable::ThriftGen::ClientException => e
    result.e = e
  end
  write_result(result, oprot, 'close_scanner', seqid)
end

#process_create_namespace(seqid, iprot, oprot) ⇒ Object 



689
690
691
692
693
694
695
696
697
698
 
# File 'lib/hypertable/gen-rb/client_service.rb', line 689

def process_create_namespace(seqid, iprot, oprot)
  args = read_args(iprot, Create_namespace_args)
  result = Create_namespace_result.new()
  begin
    @handler.create_namespace(args.ns)
  rescue Hypertable::ThriftGen::ClientException => e
    result.e = e
  end
  write_result(result, oprot, 'create_namespace', seqid)
end

#process_create_table(seqid, iprot, oprot) ⇒ Object 



700
701
702
703
704
705
706
707
708
709
 
# File 'lib/hypertable/gen-rb/client_service.rb', line 700

def process_create_table(seqid, iprot, oprot)
  args = read_args(iprot, Create_table_args)
  result = Create_table_result.new()
  begin
    @handler.create_table(args.ns, args.table_name, args.schema)
  rescue Hypertable::ThriftGen::ClientException => e
    result.e = e
  end
  write_result(result, oprot, 'create_table', seqid)
end

#process_drop_namespace(seqid, iprot, oprot) ⇒ Object 



1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
 
# File 'lib/hypertable/gen-rb/client_service.rb', line 1125

def process_drop_namespace(seqid, iprot, oprot)
  args = read_args(iprot, Drop_namespace_args)
  result = Drop_namespace_result.new()
  begin
    @handler.drop_namespace(args.ns, args.if_exists)
  rescue Hypertable::ThriftGen::ClientException => e
    result.e = e
  end
  write_result(result, oprot, 'drop_namespace', seqid)
end

#process_drop_table(seqid, iprot, oprot) ⇒ Object 



1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
 
# File 'lib/hypertable/gen-rb/client_service.rb', line 1147

def process_drop_table(seqid, iprot, oprot)
  args = read_args(iprot, Drop_table_args)
  result = Drop_table_result.new()
  begin
    @handler.drop_table(args.ns, args.name, args.if_exists)
  rescue Hypertable::ThriftGen::ClientException => e
    result.e = e
  end
  write_result(result, oprot, 'drop_table', seqid)
end

#process_exists_namespace(seqid, iprot, oprot) ⇒ Object 



1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
 
# File 'lib/hypertable/gen-rb/client_service.rb', line 1037

def process_exists_namespace(seqid, iprot, oprot)
  args = read_args(iprot, Exists_namespace_args)
  result = Exists_namespace_result.new()
  begin
    result.success = @handler.exists_namespace(args.ns)
  rescue Hypertable::ThriftGen::ClientException => e
    result.e = e
  end
  write_result(result, oprot, 'exists_namespace', seqid)
end

#process_exists_table(seqid, iprot, oprot) ⇒ Object 



1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
 
# File 'lib/hypertable/gen-rb/client_service.rb', line 1048

def process_exists_table(seqid, iprot, oprot)
  args = read_args(iprot, Exists_table_args)
  result = Exists_table_result.new()
  begin
    result.success = @handler.exists_table(args.ns, args.name)
  rescue Hypertable::ThriftGen::ClientException => e
    result.e = e
  end
  write_result(result, oprot, 'exists_table', seqid)
end

#process_flush_mutator(seqid, iprot, oprot) ⇒ Object 



1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
 
# File 'lib/hypertable/gen-rb/client_service.rb', line 1026

def process_flush_mutator(seqid, iprot, oprot)
  args = read_args(iprot, Flush_mutator_args)
  result = Flush_mutator_result.new()
  begin
    @handler.flush_mutator(args.mutator)
  rescue Hypertable::ThriftGen::ClientException => e
    result.e = e
  end
  write_result(result, oprot, 'flush_mutator', seqid)
end

#process_get_cell(seqid, iprot, oprot) ⇒ Object 



850
851
852
853
854
855
856
857
858
859
 
# File 'lib/hypertable/gen-rb/client_service.rb', line 850

def process_get_cell(seqid, iprot, oprot)
  args = read_args(iprot, Get_cell_args)
  result = Get_cell_result.new()
  begin
    result.success = @handler.get_cell(args.ns, args.table_name, args.row, args.column)
  rescue Hypertable::ThriftGen::ClientException => e
    result.e = e
  end
  write_result(result, oprot, 'get_cell', seqid)
end

#process_get_cells(seqid, iprot, oprot) ⇒ Object 



861
862
863
864
865
866
867
868
869
870
 
# File 'lib/hypertable/gen-rb/client_service.rb', line 861

def process_get_cells(seqid, iprot, oprot)
  args = read_args(iprot, Get_cells_args)
  result = Get_cells_result.new()
  begin
    result.success = @handler.get_cells(args.ns, args.table_name, args.scan_spec)
  rescue Hypertable::ThriftGen::ClientException => e
    result.e = e
  end
  write_result(result, oprot, 'get_cells', seqid)
end

#process_get_cells_as_arrays(seqid, iprot, oprot) ⇒ Object 



872
873
874
875
876
877
878
879
880
881
 
# File 'lib/hypertable/gen-rb/client_service.rb', line 872

def process_get_cells_as_arrays(seqid, iprot, oprot)
  args = read_args(iprot, Get_cells_as_arrays_args)
  result = Get_cells_as_arrays_result.new()
  begin
    result.success = @handler.get_cells_as_arrays(args.ns, args.name, args.scan_spec)
  rescue Hypertable::ThriftGen::ClientException => e
    result.e = e
  end
  write_result(result, oprot, 'get_cells_as_arrays', seqid)
end

#process_get_cells_serialized(seqid, iprot, oprot) ⇒ Object 



883
884
885
886
887
888
889
890
891
892
 
# File 'lib/hypertable/gen-rb/client_service.rb', line 883

def process_get_cells_serialized(seqid, iprot, oprot)
  args = read_args(iprot, Get_cells_serialized_args)
  result = Get_cells_serialized_result.new()
  begin
    result.success = @handler.get_cells_serialized(args.ns, args.name, args.scan_spec)
  rescue Hypertable::ThriftGen::ClientException => e
    result.e = e
  end
  write_result(result, oprot, 'get_cells_serialized', seqid)
end

#process_get_listing(seqid, iprot, oprot) ⇒ Object 



1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
 
# File 'lib/hypertable/gen-rb/client_service.rb', line 1103

def process_get_listing(seqid, iprot, oprot)
  args = read_args(iprot, Get_listing_args)
  result = Get_listing_result.new()
  begin
    result.success = @handler.get_listing(args.ns)
  rescue Hypertable::ThriftGen::ClientException => e
    result.e = e
  end
  write_result(result, oprot, 'get_listing', seqid)
end

#process_get_row(seqid, iprot, oprot) ⇒ Object 



817
818
819
820
821
822
823
824
825
826
 
# File 'lib/hypertable/gen-rb/client_service.rb', line 817

def process_get_row(seqid, iprot, oprot)
  args = read_args(iprot, Get_row_args)
  result = Get_row_result.new()
  begin
    result.success = @handler.get_row(args.ns, args.table_name, args.row)
  rescue Hypertable::ThriftGen::ClientException => e
    result.e = e
  end
  write_result(result, oprot, 'get_row', seqid)
end

#process_get_row_as_arrays(seqid, iprot, oprot) ⇒ Object 



828
829
830
831
832
833
834
835
836
837
 
# File 'lib/hypertable/gen-rb/client_service.rb', line 828

def process_get_row_as_arrays(seqid, iprot, oprot)
  args = read_args(iprot, Get_row_as_arrays_args)
  result = Get_row_as_arrays_result.new()
  begin
    result.success = @handler.get_row_as_arrays(args.ns, args.name, args.row)
  rescue Hypertable::ThriftGen::ClientException => e
    result.e = e
  end
  write_result(result, oprot, 'get_row_as_arrays', seqid)
end

#process_get_row_serialized(seqid, iprot, oprot) ⇒ Object 



839
840
841
842
843
844
845
846
847
848
 
# File 'lib/hypertable/gen-rb/client_service.rb', line 839

def process_get_row_serialized(seqid, iprot, oprot)
  args = read_args(iprot, Get_row_serialized_args)
  result = Get_row_serialized_result.new()
  begin
    result.success = @handler.get_row_serialized(args.ns, args.table_name, args.row)
  rescue Hypertable::ThriftGen::ClientException => e
    result.e = e
  end
  write_result(result, oprot, 'get_row_serialized', seqid)
end

#process_get_schema(seqid, iprot, oprot) ⇒ Object 



1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
 
# File 'lib/hypertable/gen-rb/client_service.rb', line 1081

def process_get_schema(seqid, iprot, oprot)
  args = read_args(iprot, Get_schema_args)
  result = Get_schema_result.new()
  begin
    result.success = @handler.get_schema(args.ns, args.table_name)
  rescue Hypertable::ThriftGen::ClientException => e
    result.e = e
  end
  write_result(result, oprot, 'get_schema', seqid)
end

#process_get_schema_str(seqid, iprot, oprot) ⇒ Object 



1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
 
# File 'lib/hypertable/gen-rb/client_service.rb', line 1070

def process_get_schema_str(seqid, iprot, oprot)
  args = read_args(iprot, Get_schema_str_args)
  result = Get_schema_str_result.new()
  begin
    result.success = @handler.get_schema_str(args.ns, args.table_name)
  rescue Hypertable::ThriftGen::ClientException => e
    result.e = e
  end
  write_result(result, oprot, 'get_schema_str', seqid)
end

#process_get_table_id(seqid, iprot, oprot) ⇒ Object 



1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
 
# File 'lib/hypertable/gen-rb/client_service.rb', line 1059

def process_get_table_id(seqid, iprot, oprot)
  args = read_args(iprot, Get_table_id_args)
  result = Get_table_id_result.new()
  begin
    result.success = @handler.get_table_id(args.ns, args.table_name)
  rescue Hypertable::ThriftGen::ClientException => e
    result.e = e
  end
  write_result(result, oprot, 'get_table_id', seqid)
end

#process_get_table_splits(seqid, iprot, oprot) ⇒ Object 



1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
 
# File 'lib/hypertable/gen-rb/client_service.rb', line 1114

def process_get_table_splits(seqid, iprot, oprot)
  args = read_args(iprot, Get_table_splits_args)
  result = Get_table_splits_result.new()
  begin
    result.success = @handler.get_table_splits(args.ns, args.table_name)
  rescue Hypertable::ThriftGen::ClientException => e
    result.e = e
  end
  write_result(result, oprot, 'get_table_splits', seqid)
end

#process_get_tables(seqid, iprot, oprot) ⇒ Object 



1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
 
# File 'lib/hypertable/gen-rb/client_service.rb', line 1092

def process_get_tables(seqid, iprot, oprot)
  args = read_args(iprot, Get_tables_args)
  result = Get_tables_result.new()
  begin
    result.success = @handler.get_tables(args.ns)
  rescue Hypertable::ThriftGen::ClientException => e
    result.e = e
  end
  write_result(result, oprot, 'get_tables', seqid)
end

#process_next_cells(seqid, iprot, oprot) ⇒ Object 



755
756
757
758
759
760
761
762
763
764
 
# File 'lib/hypertable/gen-rb/client_service.rb', line 755

def process_next_cells(seqid, iprot, oprot)
  args = read_args(iprot, Next_cells_args)
  result = Next_cells_result.new()
  begin
    result.success = @handler.next_cells(args.scanner)
  rescue Hypertable::ThriftGen::ClientException => e
    result.e = e
  end
  write_result(result, oprot, 'next_cells', seqid)
end

#process_next_cells_as_arrays(seqid, iprot, oprot) ⇒ Object 



766
767
768
769
770
771
772
773
774
775
 
# File 'lib/hypertable/gen-rb/client_service.rb', line 766

def process_next_cells_as_arrays(seqid, iprot, oprot)
  args = read_args(iprot, Next_cells_as_arrays_args)
  result = Next_cells_as_arrays_result.new()
  begin
    result.success = @handler.next_cells_as_arrays(args.scanner)
  rescue Hypertable::ThriftGen::ClientException => e
    result.e = e
  end
  write_result(result, oprot, 'next_cells_as_arrays', seqid)
end

#process_next_cells_serialized(seqid, iprot, oprot) ⇒ Object 



777
778
779
780
781
782
 
# File 'lib/hypertable/gen-rb/client_service.rb', line 777

def process_next_cells_serialized(seqid, iprot, oprot)
  args = read_args(iprot, Next_cells_serialized_args)
  result = Next_cells_serialized_result.new()
  result.success = @handler.next_cells_serialized(args.scanner)
  write_result(result, oprot, 'next_cells_serialized', seqid)
end

#process_next_row(seqid, iprot, oprot) ⇒ Object 



784
785
786
787
788
789
790
791
792
793
 
# File 'lib/hypertable/gen-rb/client_service.rb', line 784

def process_next_row(seqid, iprot, oprot)
  args = read_args(iprot, Next_row_args)
  result = Next_row_result.new()
  begin
    result.success = @handler.next_row(args.scanner)
  rescue Hypertable::ThriftGen::ClientException => e
    result.e = e
  end
  write_result(result, oprot, 'next_row', seqid)
end

#process_next_row_as_arrays(seqid, iprot, oprot) ⇒ Object 



795
796
797
798
799
800
801
802
803
804
 
# File 'lib/hypertable/gen-rb/client_service.rb', line 795

def process_next_row_as_arrays(seqid, iprot, oprot)
  args = read_args(iprot, Next_row_as_arrays_args)
  result = Next_row_as_arrays_result.new()
  begin
    result.success = @handler.next_row_as_arrays(args.scanner)
  rescue Hypertable::ThriftGen::ClientException => e
    result.e = e
  end
  write_result(result, oprot, 'next_row_as_arrays', seqid)
end

#process_next_row_serialized(seqid, iprot, oprot) ⇒ Object 



806
807
808
809
810
811
812
813
814
815
 
# File 'lib/hypertable/gen-rb/client_service.rb', line 806

def process_next_row_serialized(seqid, iprot, oprot)
  args = read_args(iprot, Next_row_serialized_args)
  result = Next_row_serialized_result.new()
  begin
    result.success = @handler.next_row_serialized(args.scanner)
  rescue Hypertable::ThriftGen::ClientException => e
    result.e = e
  end
  write_result(result, oprot, 'next_row_serialized', seqid)
end

#process_offer_cell(seqid, iprot, oprot) ⇒ Object 



927
928
929
930
931
932
933
934
935
936
 
# File 'lib/hypertable/gen-rb/client_service.rb', line 927

def process_offer_cell(seqid, iprot, oprot)
  args = read_args(iprot, Offer_cell_args)
  result = Offer_cell_result.new()
  begin
    @handler.offer_cell(args.ns, args.table_name, args.mutate_spec, args.cell)
  rescue Hypertable::ThriftGen::ClientException => e
    result.e = e
  end
  write_result(result, oprot, 'offer_cell', seqid)
end

#process_offer_cell_as_array(seqid, iprot, oprot) ⇒ Object 



938
939
940
941
942
943
944
945
946
947
 
# File 'lib/hypertable/gen-rb/client_service.rb', line 938

def process_offer_cell_as_array(seqid, iprot, oprot)
  args = read_args(iprot, Offer_cell_as_array_args)
  result = Offer_cell_as_array_result.new()
  begin
    @handler.offer_cell_as_array(args.ns, args.table_name, args.mutate_spec, args.cell)
  rescue Hypertable::ThriftGen::ClientException => e
    result.e = e
  end
  write_result(result, oprot, 'offer_cell_as_array', seqid)
end

#process_offer_cells(seqid, iprot, oprot) ⇒ Object 



905
906
907
908
909
910
911
912
913
914
 
# File 'lib/hypertable/gen-rb/client_service.rb', line 905

def process_offer_cells(seqid, iprot, oprot)
  args = read_args(iprot, Offer_cells_args)
  result = Offer_cells_result.new()
  begin
    @handler.offer_cells(args.ns, args.table_name, args.mutate_spec, args.cells)
  rescue Hypertable::ThriftGen::ClientException => e
    result.e = e
  end
  write_result(result, oprot, 'offer_cells', seqid)
end

#process_offer_cells_as_arrays(seqid, iprot, oprot) ⇒ Object 



916
917
918
919
920
921
922
923
924
925
 
# File 'lib/hypertable/gen-rb/client_service.rb', line 916

def process_offer_cells_as_arrays(seqid, iprot, oprot)
  args = read_args(iprot, Offer_cells_as_arrays_args)
  result = Offer_cells_as_arrays_result.new()
  begin
    @handler.offer_cells_as_arrays(args.ns, args.table_name, args.mutate_spec, args.cells)
  rescue Hypertable::ThriftGen::ClientException => e
    result.e = e
  end
  write_result(result, oprot, 'offer_cells_as_arrays', seqid)
end

#process_open_mutator(seqid, iprot, oprot) ⇒ Object 



949
950
951
952
953
954
955
956
957
958
 
# File 'lib/hypertable/gen-rb/client_service.rb', line 949

def process_open_mutator(seqid, iprot, oprot)
  args = read_args(iprot, Open_mutator_args)
  result = Open_mutator_result.new()
  begin
    result.success = @handler.open_mutator(args.ns, args.table_name, args.flags, args.flush_interval)
  rescue Hypertable::ThriftGen::ClientException => e
    result.e = e
  end
  write_result(result, oprot, 'open_mutator', seqid)
end

#process_open_namespace(seqid, iprot, oprot) ⇒ Object 



711
712
713
714
715
716
717
718
719
720
 
# File 'lib/hypertable/gen-rb/client_service.rb', line 711

def process_open_namespace(seqid, iprot, oprot)
  args = read_args(iprot, Open_namespace_args)
  result = Open_namespace_result.new()
  begin
    result.success = @handler.open_namespace(args.ns)
  rescue Hypertable::ThriftGen::ClientException => e
    result.e = e
  end
  write_result(result, oprot, 'open_namespace', seqid)
end

#process_open_scanner(seqid, iprot, oprot) ⇒ Object 



733
734
735
736
737
738
739
740
741
742
 
# File 'lib/hypertable/gen-rb/client_service.rb', line 733

def process_open_scanner(seqid, iprot, oprot)
  args = read_args(iprot, Open_scanner_args)
  result = Open_scanner_result.new()
  begin
    result.success = @handler.open_scanner(args.ns, args.table_name, args.scan_spec, args.retry_table_not_found)
  rescue Hypertable::ThriftGen::ClientException => e
    result.e = e
  end
  write_result(result, oprot, 'open_scanner', seqid)
end

#process_refresh_shared_mutator(seqid, iprot, oprot) ⇒ Object 



894
895
896
897
898
899
900
901
902
903
 
# File 'lib/hypertable/gen-rb/client_service.rb', line 894

def process_refresh_shared_mutator(seqid, iprot, oprot)
  args = read_args(iprot, Refresh_shared_mutator_args)
  result = Refresh_shared_mutator_result.new()
  begin
    @handler.refresh_shared_mutator(args.ns, args.table_name, args.mutate_spec)
  rescue Hypertable::ThriftGen::ClientException => e
    result.e = e
  end
  write_result(result, oprot, 'refresh_shared_mutator', seqid)
end

#process_rename_table(seqid, iprot, oprot) ⇒ Object 



1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
 
# File 'lib/hypertable/gen-rb/client_service.rb', line 1136

def process_rename_table(seqid, iprot, oprot)
  args = read_args(iprot, Rename_table_args)
  result = Rename_table_result.new()
  begin
    @handler.rename_table(args.ns, args.name, args.new_name)
  rescue Hypertable::ThriftGen::ClientException => e
    result.e = e
  end
  write_result(result, oprot, 'rename_table', seqid)
end

#process_set_cell(seqid, iprot, oprot) ⇒ Object 



971
972
973
974
975
976
977
978
979
980
 
# File 'lib/hypertable/gen-rb/client_service.rb', line 971

def process_set_cell(seqid, iprot, oprot)
  args = read_args(iprot, Set_cell_args)
  result = Set_cell_result.new()
  begin
    @handler.set_cell(args.mutator, args.cell)
  rescue Hypertable::ThriftGen::ClientException => e
    result.e = e
  end
  write_result(result, oprot, 'set_cell', seqid)
end

#process_set_cell_as_array(seqid, iprot, oprot) ⇒ Object 



982
983
984
985
986
987
988
989
990
991
 
# File 'lib/hypertable/gen-rb/client_service.rb', line 982

def process_set_cell_as_array(seqid, iprot, oprot)
  args = read_args(iprot, Set_cell_as_array_args)
  result = Set_cell_as_array_result.new()
  begin
    @handler.set_cell_as_array(args.mutator, args.cell)
  rescue Hypertable::ThriftGen::ClientException => e
    result.e = e
  end
  write_result(result, oprot, 'set_cell_as_array', seqid)
end

#process_set_cells(seqid, iprot, oprot) ⇒ Object 



993
994
995
996
997
998
999
1000
1001
1002
 
# File 'lib/hypertable/gen-rb/client_service.rb', line 993

def process_set_cells(seqid, iprot, oprot)
  args = read_args(iprot, Set_cells_args)
  result = Set_cells_result.new()
  begin
    @handler.set_cells(args.mutator, args.cells)
  rescue Hypertable::ThriftGen::ClientException => e
    result.e = e
  end
  write_result(result, oprot, 'set_cells', seqid)
end

#process_set_cells_as_arrays(seqid, iprot, oprot) ⇒ Object 



1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
 
# File 'lib/hypertable/gen-rb/client_service.rb', line 1004

def process_set_cells_as_arrays(seqid, iprot, oprot)
  args = read_args(iprot, Set_cells_as_arrays_args)
  result = Set_cells_as_arrays_result.new()
  begin
    @handler.set_cells_as_arrays(args.mutator, args.cells)
  rescue Hypertable::ThriftGen::ClientException => e
    result.e = e
  end
  write_result(result, oprot, 'set_cells_as_arrays', seqid)
end

#process_set_cells_serialized(seqid, iprot, oprot) ⇒ Object 



1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
 
# File 'lib/hypertable/gen-rb/client_service.rb', line 1015

def process_set_cells_serialized(seqid, iprot, oprot)
  args = read_args(iprot, Set_cells_serialized_args)
  result = Set_cells_serialized_result.new()
  begin
    @handler.set_cells_serialized(args.mutator, args.cells, args.flush)
  rescue Hypertable::ThriftGen::ClientException => e
    result.e = e
  end
  write_result(result, oprot, 'set_cells_serialized', seqid)
end