public void Read (TProtocol iprot)
{
bool isset_column_name = false;
bool isset_op = false;
bool isset_value = false;
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop) {
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.String) {
Column_name = iprot.ReadBinary();
isset_column_name = true;
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.I32) {
Op = (IndexOperator)iprot.ReadI32();
isset_op = true;
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String) {
Value = iprot.ReadBinary();
isset_value = true;
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
if (!isset_column_name)
throw new TProtocolException(TProtocolException.INVALID_DATA);
if (!isset_op)
throw new TProtocolException(TProtocolException.INVALID_DATA);
if (!isset_value)
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
public void Read (TProtocol iprot)
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop) {
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.String) {
Key = iprot.ReadBinary();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.I32) {
Count = iprot.ReadI32();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
public void Read (TProtocol iprot)
{
bool isset_name = false;
bool isset_columns = false;
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop) {
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.String) {
Name = iprot.ReadBinary();
isset_name = true;
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.List) {
{
Columns = new List<CounterColumn>();
TList _list4 = iprot.ReadListBegin();
for( int _i5 = 0; _i5 < _list4.Count; ++_i5)
{
CounterColumn _elem6 = new CounterColumn();
_elem6 = new CounterColumn();
_elem6.Read(iprot);
Columns.Add(_elem6);
}
iprot.ReadListEnd();
}
isset_columns = true;
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
if (!isset_name)
throw new TProtocolException(TProtocolException.INVALID_DATA);
if (!isset_columns)
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
public void Read (TProtocol iprot)
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop) {
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.String) {
Key = iprot.ReadBinary();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.List) {
{
Columns = new List<ColumnOrSuperColumn>();
TList _list20 = iprot.ReadListBegin();
for( int _i21 = 0; _i21 < _list20.Count; ++_i21)
{
ColumnOrSuperColumn _elem22 = new ColumnOrSuperColumn();
_elem22 = new ColumnOrSuperColumn();
_elem22.Read(iprot);
Columns.Add(_elem22);
}
iprot.ReadListEnd();
}
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
public void Read (TProtocol iprot)
{
bool isset_key = false;
bool isset_count = false;
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop) {
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.String) {
Key = iprot.ReadBinary();
isset_key = true;
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.I32) {
Count = iprot.ReadI32();
isset_count = true;
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
if (!isset_key)
throw new TProtocolException(TProtocolException.INVALID_DATA);
if (!isset_count)
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
public void Read (TProtocol iprot)
{
bool isset_column_family = false;
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop) {
break;
}
switch (field.ID)
{
case 3:
if (field.Type == TType.String) {
Column_family = iprot.ReadString();
isset_column_family = true;
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.String) {
Super_column = iprot.ReadBinary();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
if (!isset_column_family)
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
public void Read (TProtocol iprot)
{
bool isset_mutation_map = false;
bool isset_consistency_level = false;
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop) {
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.Map) {
{
Mutation_map = new Dictionary<byte[], Dictionary<string, List<Mutation>>>();
TMap _map168 = iprot.ReadMapBegin();
for( int _i169 = 0; _i169 < _map168.Count; ++_i169)
{
byte[] _key170;
Dictionary<string, List<Mutation>> _val171;
_key170 = iprot.ReadBinary();
{
_val171 = new Dictionary<string, List<Mutation>>();
TMap _map172 = iprot.ReadMapBegin();
for( int _i173 = 0; _i173 < _map172.Count; ++_i173)
{
string _key174;
List<Mutation> _val175;
_key174 = iprot.ReadString();
{
_val175 = new List<Mutation>();
TList _list176 = iprot.ReadListBegin();
for( int _i177 = 0; _i177 < _list176.Count; ++_i177)
{
Mutation _elem178 = new Mutation();
_elem178 = new Mutation();
_elem178.Read(iprot);
_val175.Add(_elem178);
}
iprot.ReadListEnd();
}
_val171[_key174] = _val175;
}
iprot.ReadMapEnd();
}
Mutation_map[_key170] = _val171;
}
iprot.ReadMapEnd();
}
isset_mutation_map = true;
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.I32) {
Consistency_level = (ConsistencyLevel)iprot.ReadI32();
isset_consistency_level = true;
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
if (!isset_mutation_map)
throw new TProtocolException(TProtocolException.INVALID_DATA);
if (!isset_consistency_level)
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
public void Read (TProtocol iprot)
{
bool isset_key = false;
bool isset_path = false;
bool isset_consistency_level = false;
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop) {
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.String) {
Key = iprot.ReadBinary();
isset_key = true;
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Struct) {
Path = new ColumnPath();
Path.Read(iprot);
isset_path = true;
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.I32) {
Consistency_level = (ConsistencyLevel)iprot.ReadI32();
isset_consistency_level = true;
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
if (!isset_key)
throw new TProtocolException(TProtocolException.INVALID_DATA);
if (!isset_path)
throw new TProtocolException(TProtocolException.INVALID_DATA);
if (!isset_consistency_level)
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
public void Read (TProtocol iprot)
{
bool isset_column_family = false;
bool isset_range = false;
bool isset_start_column = false;
bool isset_consistency_level = false;
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop) {
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.String) {
Column_family = iprot.ReadString();
isset_column_family = true;
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Struct) {
Range = new KeyRange();
Range.Read(iprot);
isset_range = true;
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String) {
Start_column = iprot.ReadBinary();
isset_start_column = true;
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.I32) {
Consistency_level = (ConsistencyLevel)iprot.ReadI32();
isset_consistency_level = true;
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
if (!isset_column_family)
throw new TProtocolException(TProtocolException.INVALID_DATA);
if (!isset_range)
throw new TProtocolException(TProtocolException.INVALID_DATA);
if (!isset_start_column)
throw new TProtocolException(TProtocolException.INVALID_DATA);
if (!isset_consistency_level)
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
public void Read (TProtocol iprot)
{
bool isset_keys = false;
bool isset_column_parent = false;
bool isset_predicate = false;
bool isset_consistency_level = false;
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop) {
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.List) {
{
Keys = new List<byte[]>();
TList _list125 = iprot.ReadListBegin();
for( int _i126 = 0; _i126 < _list125.Count; ++_i126)
{
byte[] _elem127 = null;
_elem127 = iprot.ReadBinary();
Keys.Add(_elem127);
}
iprot.ReadListEnd();
}
isset_keys = true;
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Struct) {
Column_parent = new ColumnParent();
Column_parent.Read(iprot);
isset_column_parent = true;
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.Struct) {
Predicate = new SlicePredicate();
Predicate.Read(iprot);
isset_predicate = true;
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.I32) {
Consistency_level = (ConsistencyLevel)iprot.ReadI32();
isset_consistency_level = true;
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
if (!isset_keys)
throw new TProtocolException(TProtocolException.INVALID_DATA);
if (!isset_column_parent)
throw new TProtocolException(TProtocolException.INVALID_DATA);
if (!isset_predicate)
throw new TProtocolException(TProtocolException.INVALID_DATA);
if (!isset_consistency_level)
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
public void Read (TProtocol iprot)
{
bool isset_itemId = false;
bool isset_values = false;
bool isset_consistency = false;
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop) {
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.I32) {
ItemId = iprot.ReadI32();
isset_itemId = true;
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.List) {
{
Values = new List<byte[]>();
TList _list220 = iprot.ReadListBegin();
for( int _i221 = 0; _i221 < _list220.Count; ++_i221)
{
byte[] _elem222 = null;
_elem222 = iprot.ReadBinary();
Values.Add(_elem222);
}
iprot.ReadListEnd();
}
isset_values = true;
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.I32) {
Consistency = (ConsistencyLevel)iprot.ReadI32();
isset_consistency = true;
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
if (!isset_itemId)
throw new TProtocolException(TProtocolException.INVALID_DATA);
if (!isset_values)
throw new TProtocolException(TProtocolException.INVALID_DATA);
if (!isset_consistency)
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
public void Read (TProtocol iprot)
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop) {
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.String) {
Start_key = iprot.ReadBinary();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String) {
End_key = iprot.ReadBinary();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String) {
Start_token = iprot.ReadString();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.String) {
End_token = iprot.ReadString();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.List) {
{
Row_filter = new List<IndexExpression>();
TList _list16 = iprot.ReadListBegin();
for( int _i17 = 0; _i17 < _list16.Count; ++_i17)
{
IndexExpression _elem18 = new IndexExpression();
_elem18 = new IndexExpression();
_elem18.Read(iprot);
Row_filter.Add(_elem18);
}
iprot.ReadListEnd();
}
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.I32) {
Count = iprot.ReadI32();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
public static void Skip(TProtocol prot, TType type)
{
switch (type)
{
case TType.Bool:
prot.ReadBool();
break;
case TType.Byte:
prot.ReadByte();
break;
case TType.I16:
prot.ReadI16();
break;
case TType.I32:
prot.ReadI32();
break;
case TType.I64:
prot.ReadI64();
break;
case TType.Double:
prot.ReadDouble();
break;
case TType.String:
// Don't try to decode the string, just skip it.
prot.ReadBinary();
break;
case TType.Struct:
prot.ReadStructBegin();
while (true)
{
TField field = prot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
Skip(prot, field.Type);
prot.ReadFieldEnd();
}
prot.ReadStructEnd();
break;
case TType.Map:
TMap map = prot.ReadMapBegin();
for (int i = 0; i < map.Count; i++)
{
Skip(prot, map.KeyType);
Skip(prot, map.ValueType);
}
prot.ReadMapEnd();
break;
case TType.Set:
TSet set = prot.ReadSetBegin();
for (int i = 0; i < set.Count; i++)
{
Skip(prot, set.ElementType);
}
prot.ReadSetEnd();
break;
case TType.List:
TList list = prot.ReadListBegin();
for (int i = 0; i < list.Count; i++)
{
Skip(prot, list.ElementType);
}
prot.ReadListEnd();
break;
}
}
public void Read (TProtocol iprot)
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop) {
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.String) {
Keyspace = iprot.ReadString();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String) {
Name = iprot.ReadString();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String) {
Column_type = iprot.ReadString();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.String) {
Comparator_type = iprot.ReadString();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.String) {
Subcomparator_type = iprot.ReadString();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.String) {
Comment = iprot.ReadString();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 12:
if (field.Type == TType.Double) {
Read_repair_chance = iprot.ReadDouble();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 13:
if (field.Type == TType.List) {
{
Column_metadata = new List<ColumnDef>();
TList _list46 = iprot.ReadListBegin();
for( int _i47 = 0; _i47 < _list46.Count; ++_i47)
{
ColumnDef _elem48 = new ColumnDef();
_elem48 = new ColumnDef();
_elem48.Read(iprot);
Column_metadata.Add(_elem48);
}
iprot.ReadListEnd();
}
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 14:
if (field.Type == TType.I32) {
Gc_grace_seconds = iprot.ReadI32();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 15:
if (field.Type == TType.String) {
Default_validation_class = iprot.ReadString();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 16:
if (field.Type == TType.I32) {
Id = iprot.ReadI32();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 17:
if (field.Type == TType.I32) {
Min_compaction_threshold = iprot.ReadI32();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 18:
if (field.Type == TType.I32) {
Max_compaction_threshold = iprot.ReadI32();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 24:
if (field.Type == TType.Bool) {
Replicate_on_write = iprot.ReadBool();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 26:
if (field.Type == TType.String) {
Key_validation_class = iprot.ReadString();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 28:
if (field.Type == TType.String) {
Key_alias = iprot.ReadBinary();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 29:
if (field.Type == TType.String) {
Compaction_strategy = iprot.ReadString();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 30:
if (field.Type == TType.Map) {
{
Compaction_strategy_options = new Dictionary<string, string>();
TMap _map49 = iprot.ReadMapBegin();
for( int _i50 = 0; _i50 < _map49.Count; ++_i50)
{
string _key51;
string _val52;
_key51 = iprot.ReadString();
_val52 = iprot.ReadString();
Compaction_strategy_options[_key51] = _val52;
}
iprot.ReadMapEnd();
}
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 32:
if (field.Type == TType.Map) {
{
Compression_options = new Dictionary<string, string>();
TMap _map53 = iprot.ReadMapBegin();
for( int _i54 = 0; _i54 < _map53.Count; ++_i54)
{
string _key55;
string _val56;
_key55 = iprot.ReadString();
_val56 = iprot.ReadString();
Compression_options[_key55] = _val56;
}
iprot.ReadMapEnd();
}
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 33:
if (field.Type == TType.Double) {
Bloom_filter_fp_chance = iprot.ReadDouble();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 34:
if (field.Type == TType.String) {
Caching = iprot.ReadString();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 37:
if (field.Type == TType.Double) {
Dclocal_read_repair_chance = iprot.ReadDouble();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.Double) {
Row_cache_size = iprot.ReadDouble();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.Double) {
Key_cache_size = iprot.ReadDouble();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 19:
if (field.Type == TType.I32) {
Row_cache_save_period_in_seconds = iprot.ReadI32();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 20:
if (field.Type == TType.I32) {
Key_cache_save_period_in_seconds = iprot.ReadI32();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 21:
if (field.Type == TType.I32) {
Memtable_flush_after_mins = iprot.ReadI32();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 22:
if (field.Type == TType.I32) {
Memtable_throughput_in_mb = iprot.ReadI32();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 23:
if (field.Type == TType.Double) {
Memtable_operations_in_millions = iprot.ReadDouble();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 25:
if (field.Type == TType.Double) {
Merge_shards_chance = iprot.ReadDouble();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 27:
if (field.Type == TType.String) {
Row_cache_provider = iprot.ReadString();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 31:
if (field.Type == TType.I32) {
Row_cache_keys_to_save = iprot.ReadI32();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
public void Read (TProtocol iprot)
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop) {
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.Map) {
{
Name_types = new Dictionary<byte[], string>();
TMap _map73 = iprot.ReadMapBegin();
for( int _i74 = 0; _i74 < _map73.Count; ++_i74)
{
byte[] _key75;
string _val76;
_key75 = iprot.ReadBinary();
_val76 = iprot.ReadString();
Name_types[_key75] = _val76;
}
iprot.ReadMapEnd();
}
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Map) {
{
Value_types = new Dictionary<byte[], string>();
TMap _map77 = iprot.ReadMapBegin();
for( int _i78 = 0; _i78 < _map77.Count; ++_i78)
{
byte[] _key79;
string _val80;
_key79 = iprot.ReadBinary();
_val80 = iprot.ReadString();
Value_types[_key79] = _val80;
}
iprot.ReadMapEnd();
}
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String) {
Default_name_type = iprot.ReadString();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.String) {
Default_value_type = iprot.ReadString();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
public void Read (TProtocol iprot)
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop) {
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.Map) {
{
Mutation_map = new Dictionary<byte[], Dictionary<string, List<Mutation>>>();
TMap _map147 = iprot.ReadMapBegin();
for( int _i148 = 0; _i148 < _map147.Count; ++_i148)
{
byte[] _key149;
Dictionary<string, List<Mutation>> _val150;
_key149 = iprot.ReadBinary();
{
_val150 = new Dictionary<string, List<Mutation>>();
TMap _map151 = iprot.ReadMapBegin();
for( int _i152 = 0; _i152 < _map151.Count; ++_i152)
{
string _key153;
List<Mutation> _val154;
_key153 = iprot.ReadString();
{
_val154 = new List<Mutation>();
TList _list155 = iprot.ReadListBegin();
for( int _i156 = 0; _i156 < _list155.Count; ++_i156)
{
Mutation _elem157 = new Mutation();
_elem157 = new Mutation();
_elem157.Read(iprot);
_val154.Add(_elem157);
}
iprot.ReadListEnd();
}
_val150[_key153] = _val154;
}
iprot.ReadMapEnd();
}
Mutation_map[_key149] = _val150;
}
iprot.ReadMapEnd();
}
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.I32) {
Consistency_level = (ConsistencyLevel)iprot.ReadI32();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
public void Read (TProtocol iprot)
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop) {
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.String) {
Name = iprot.ReadBinary();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String) {
Value = iprot.ReadBinary();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.I64) {
Timestamp = iprot.ReadI64();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.I32) {
Ttl = iprot.ReadI32();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
public void Read (TProtocol iprot)
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop) {
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.List) {
{
Expressions = new List<IndexExpression>();
TList _list12 = iprot.ReadListBegin();
for( int _i13 = 0; _i13 < _list12.Count; ++_i13)
{
IndexExpression _elem14 = new IndexExpression();
_elem14 = new IndexExpression();
_elem14.Read(iprot);
Expressions.Add(_elem14);
}
iprot.ReadListEnd();
}
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String) {
Start_key = iprot.ReadBinary();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.I32) {
Count = iprot.ReadI32();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
public void Read (TProtocol iprot)
{
bool isset_query = false;
bool isset_compression = false;
bool isset_consistency = false;
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop) {
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.String) {
Query = iprot.ReadBinary();
isset_query = true;
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.I32) {
Compression = (Compression)iprot.ReadI32();
isset_compression = true;
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.I32) {
Consistency = (ConsistencyLevel)iprot.ReadI32();
isset_consistency = true;
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
if (!isset_query)
throw new TProtocolException(TProtocolException.INVALID_DATA);
if (!isset_compression)
throw new TProtocolException(TProtocolException.INVALID_DATA);
if (!isset_consistency)
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
public void Read (TProtocol iprot)
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop) {
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.I64) {
Timestamp = iprot.ReadI64();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String) {
Super_column = iprot.ReadBinary();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.Struct) {
Predicate = new SlicePredicate();
Predicate.Read(iprot);
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
public void Read (TProtocol iprot)
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop) {
break;
}
switch (field.ID)
{
case 0:
if (field.Type == TType.Map) {
{
Success = new Dictionary<byte[], List<ColumnOrSuperColumn>>();
TMap _map116 = iprot.ReadMapBegin();
for( int _i117 = 0; _i117 < _map116.Count; ++_i117)
{
byte[] _key118;
List<ColumnOrSuperColumn> _val119;
_key118 = iprot.ReadBinary();
{
_val119 = new List<ColumnOrSuperColumn>();
TList _list120 = iprot.ReadListBegin();
for( int _i121 = 0; _i121 < _list120.Count; ++_i121)
{
ColumnOrSuperColumn _elem122 = new ColumnOrSuperColumn();
_elem122 = new ColumnOrSuperColumn();
_elem122.Read(iprot);
_val119.Add(_elem122);
}
iprot.ReadListEnd();
}
Success[_key118] = _val119;
}
iprot.ReadMapEnd();
}
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 1:
if (field.Type == TType.Struct) {
Ire = new InvalidRequestException();
Ire.Read(iprot);
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Struct) {
Ue = new UnavailableException();
Ue.Read(iprot);
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.Struct) {
Te = new TimedOutException();
Te.Read(iprot);
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
public void Read (TProtocol iprot)
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop) {
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.I32) {
ItemId = iprot.ReadI32();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.List) {
{
Values = new List<byte[]>();
TList _list195 = iprot.ReadListBegin();
for( int _i196 = 0; _i196 < _list195.Count; ++_i196)
{
byte[] _elem197 = null;
_elem197 = iprot.ReadBinary();
Values.Add(_elem197);
}
iprot.ReadListEnd();
}
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.I32) {
Consistency = (ConsistencyLevel)iprot.ReadI32();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
public void Read (TProtocol iprot)
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop) {
break;
}
switch (field.ID)
{
case 0:
if (field.Type == TType.Map) {
{
Success = new Dictionary<byte[], int>();
TMap _map129 = iprot.ReadMapBegin();
for( int _i130 = 0; _i130 < _map129.Count; ++_i130)
{
byte[] _key131;
int _val132;
_key131 = iprot.ReadBinary();
_val132 = iprot.ReadI32();
Success[_key131] = _val132;
}
iprot.ReadMapEnd();
}
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 1:
if (field.Type == TType.Struct) {
Ire = new InvalidRequestException();
Ire.Read(iprot);
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Struct) {
Ue = new UnavailableException();
Ue.Read(iprot);
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.Struct) {
Te = new TimedOutException();
Te.Read(iprot);
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
public void Read (TProtocol iprot)
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop) {
break;
}
switch (field.ID)
{
case 0:
if (field.Type == TType.Map) {
{
Success = new Dictionary<byte[], List<ColumnOrSuperColumn>>();
TMap _map103 = iprot.ReadMapBegin();
for( int _i104 = 0; _i104 < _map103.Count; ++_i104)
{
byte[] _key105;
List<ColumnOrSuperColumn> _val106;
_key105 = iprot.ReadBinary();
{
_val106 = new List<ColumnOrSuperColumn>();
TList _list107 = iprot.ReadListBegin();
for( int _i108 = 0; _i108 < _list107.Count; ++_i108)
{
ColumnOrSuperColumn _elem109 = new ColumnOrSuperColumn();
_elem109 = new ColumnOrSuperColumn();
_elem109.Read(iprot);
_val106.Add(_elem109);
}
iprot.ReadListEnd();
}
Success[_key105] = _val106;
}
iprot.ReadMapEnd();
}
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 1:
if (field.Type == TType.Struct) {
Ire = new InvalidRequestException();
Ire.Read(iprot);
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Struct) {
Ue = new UnavailableException();
Ue.Read(iprot);
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.Struct) {
Te = new TimedOutException();
Te.Read(iprot);
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
public void Read (TProtocol iprot)
{
bool isset_key = false;
bool isset_column_family = false;
bool isset_serial_consistency_level = false;
bool isset_commit_consistency_level = false;
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop) {
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.String) {
Key = iprot.ReadBinary();
isset_key = true;
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String) {
Column_family = iprot.ReadString();
isset_column_family = true;
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.List) {
{
Expected = new List<Column>();
TList _list146 = iprot.ReadListBegin();
for( int _i147 = 0; _i147 < _list146.Count; ++_i147)
{
Column _elem148 = new Column();
_elem148 = new Column();
_elem148.Read(iprot);
Expected.Add(_elem148);
}
iprot.ReadListEnd();
}
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.List) {
{
Updates = new List<Column>();
TList _list149 = iprot.ReadListBegin();
for( int _i150 = 0; _i150 < _list149.Count; ++_i150)
{
Column _elem151 = new Column();
_elem151 = new Column();
_elem151.Read(iprot);
Updates.Add(_elem151);
}
iprot.ReadListEnd();
}
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.I32) {
Serial_consistency_level = (ConsistencyLevel)iprot.ReadI32();
isset_serial_consistency_level = true;
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.I32) {
Commit_consistency_level = (ConsistencyLevel)iprot.ReadI32();
isset_commit_consistency_level = true;
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
if (!isset_key)
throw new TProtocolException(TProtocolException.INVALID_DATA);
if (!isset_column_family)
throw new TProtocolException(TProtocolException.INVALID_DATA);
if (!isset_serial_consistency_level)
throw new TProtocolException(TProtocolException.INVALID_DATA);
if (!isset_commit_consistency_level)
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
public void Read (TProtocol iprot)
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop) {
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.List) {
{
Keys = new List<byte[]>();
TList _list112 = iprot.ReadListBegin();
for( int _i113 = 0; _i113 < _list112.Count; ++_i113)
{
byte[] _elem114 = null;
_elem114 = iprot.ReadBinary();
Keys.Add(_elem114);
}
iprot.ReadListEnd();
}
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Struct) {
Column_parent = new ColumnParent();
Column_parent.Read(iprot);
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.Struct) {
Predicate = new SlicePredicate();
Predicate.Read(iprot);
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.I32) {
Consistency_level = (ConsistencyLevel)iprot.ReadI32();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
public void Read (TProtocol iprot)
{
bool isset_mutation_map = false;
bool isset_consistency_level = false;
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop) {
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.Map) {
{
Mutation_map = new Dictionary<byte[], Dictionary<string, List<Mutation>>>();
TMap _map154 = iprot.ReadMapBegin();
for( int _i155 = 0; _i155 < _map154.Count; ++_i155)
{
byte[] _key156;
Dictionary<string, List<Mutation>> _val157;
_key156 = iprot.ReadBinary();
{
_val157 = new Dictionary<string, List<Mutation>>();
TMap _map158 = iprot.ReadMapBegin();
for( int _i159 = 0; _i159 < _map158.Count; ++_i159)
{
string _key160;
List<Mutation> _val161;
_key160 = iprot.ReadString();
{
_val161 = new List<Mutation>();
TList _list162 = iprot.ReadListBegin();
for( int _i163 = 0; _i163 < _list162.Count; ++_i163)
{
Mutation _elem164 = new Mutation();
_elem164 = new Mutation();
_elem164.Read(iprot);
_val161.Add(_elem164);
}
iprot.ReadListEnd();
}
_val157[_key160] = _val161;
}
iprot.ReadMapEnd();
}
Mutation_map[_key156] = _val157;
}
iprot.ReadMapEnd();
}
isset_mutation_map = true;
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.I32) {
Consistency_level = (ConsistencyLevel)iprot.ReadI32();
isset_consistency_level = true;
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
if (!isset_mutation_map)
throw new TProtocolException(TProtocolException.INVALID_DATA);
if (!isset_consistency_level)
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
public void Read (TProtocol iprot)
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop) {
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.String) {
Key = iprot.ReadBinary();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Struct) {
Path = new ColumnPath();
Path.Read(iprot);
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.I32) {
Consistency_level = (ConsistencyLevel)iprot.ReadI32();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
public void Read (TProtocol iprot)
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop) {
break;
}
switch (field.ID)
{
case 3:
if (field.Type == TType.String) {
Column_family = iprot.ReadString();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.String) {
Super_column = iprot.ReadBinary();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.String) {
Column = iprot.ReadBinary();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
public void Read (TProtocol iprot)
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop) {
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.Map) {
{
Mutation_map = new Dictionary<byte[], Dictionary<string, List<Mutation>>>();
TMap _map133 = iprot.ReadMapBegin();
for( int _i134 = 0; _i134 < _map133.Count; ++_i134)
{
byte[] _key135;
Dictionary<string, List<Mutation>> _val136;
_key135 = iprot.ReadBinary();
{
_val136 = new Dictionary<string, List<Mutation>>();
TMap _map137 = iprot.ReadMapBegin();
for( int _i138 = 0; _i138 < _map137.Count; ++_i138)
{
string _key139;
List<Mutation> _val140;
_key139 = iprot.ReadString();
{
_val140 = new List<Mutation>();
TList _list141 = iprot.ReadListBegin();
for( int _i142 = 0; _i142 < _list141.Count; ++_i142)
{
Mutation _elem143 = new Mutation();
_elem143 = new Mutation();
_elem143.Read(iprot);
_val140.Add(_elem143);
}
iprot.ReadListEnd();
}
_val136[_key139] = _val140;
}
iprot.ReadMapEnd();
}
Mutation_map[_key135] = _val136;
}
iprot.ReadMapEnd();
}
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.I32) {
Consistency_level = (ConsistencyLevel)iprot.ReadI32();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}