public void Read (TProtocol iprot)
{
bool isset_name = false;
bool isset_options = 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.ReadString();
isset_name = true;
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Map) {
{
Options = new Dictionary<string, string>();
TMap _map50 = iprot.ReadMapBegin();
for( int _i51 = 0; _i51 < _map50.Count; ++_i51)
{
string _key52;
string _val53;
_key52 = iprot.ReadString();
_val53 = iprot.ReadString();
Options[_key52] = _val53;
}
iprot.ReadMapEnd();
}
isset_options = 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_options)
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
public void Read (TProtocol iprot)
{
bool isset_start_token = false;
bool isset_end_token = false;
bool isset_row_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) {
Start_token = iprot.ReadString();
isset_start_token = true;
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String) {
End_token = iprot.ReadString();
isset_end_token = true;
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.I64) {
Row_count = iprot.ReadI64();
isset_row_count = true;
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
if (!isset_start_token)
throw new TProtocolException(TProtocolException.INVALID_DATA);
if (!isset_end_token)
throw new TProtocolException(TProtocolException.INVALID_DATA);
if (!isset_row_count)
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) {
Why = 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)
{
bool isset_why = 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) {
Why = iprot.ReadString();
isset_why = true;
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
if (!isset_why)
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 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;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
public void Read (TProtocol iprot)
{
bool isset_credentials = 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) {
{
Credentials = new Dictionary<string, string>();
TMap _map40 = iprot.ReadMapBegin();
for( int _i41 = 0; _i41 < _map40.Count; ++_i41)
{
string _key42;
string _val43;
_key42 = iprot.ReadString();
_val43 = iprot.ReadString();
Credentials[_key42] = _val43;
}
iprot.ReadMapEnd();
}
isset_credentials = true;
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
if (!isset_credentials)
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.Map) {
{
Credentials = new Dictionary<string, string>();
TMap _map36 = iprot.ReadMapBegin();
for( int _i37 = 0; _i37 < _map36.Count; ++_i37)
{
string _key38;
string _val39;
_key38 = iprot.ReadString();
_val39 = iprot.ReadString();
Credentials[_key38] = _val39;
}
iprot.ReadMapEnd();
}
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
public static TApplicationException Read(TProtocol iprot)
{
TField field;
string message = null;
ExceptionType type = ExceptionType.Unknown;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.String)
{
message = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.I32)
{
type = (ExceptionType)iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
return new TApplicationException(type, message);
}
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.String) {
Success = iprot.ReadString();
} 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) {
Sde = new SchemaDisagreementException();
Sde.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<string, string>();
TMap _map203 = iprot.ReadMapBegin();
for( int _i204 = 0; _i204 < _map203.Count; ++_i204)
{
string _key205;
string _val206;
_key205 = iprot.ReadString();
_val206 = iprot.ReadString();
Success[_key205] = _val206;
}
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;
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.List) {
{
Success = new List<string>();
TList _list208 = iprot.ReadListBegin();
for( int _i209 = 0; _i209 < _list208.Count; ++_i209)
{
string _elem210 = null;
_elem210 = iprot.ReadString();
Success.Add(_elem210);
}
iprot.ReadListEnd();
}
} 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;
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) {
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 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<string, List<string>>();
TMap _map182 = iprot.ReadMapBegin();
for( int _i183 = 0; _i183 < _map182.Count; ++_i183)
{
string _key184;
List<string> _val185;
_key184 = iprot.ReadString();
{
_val185 = new List<string>();
TList _list186 = iprot.ReadListBegin();
for( int _i187 = 0; _i187 < _list186.Count; ++_i187)
{
string _elem188 = null;
_elem188 = iprot.ReadString();
_val185.Add(_elem188);
}
iprot.ReadListEnd();
}
Success[_key184] = _val185;
}
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;
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 0:
if (field.Type == TType.Map) {
{
Success = new Dictionary<string, List<string>>();
TMap _map161 = iprot.ReadMapBegin();
for( int _i162 = 0; _i162 < _map161.Count; ++_i162)
{
string _key163;
List<string> _val164;
_key163 = iprot.ReadString();
{
_val164 = new List<string>();
TList _list165 = iprot.ReadListBegin();
for( int _i166 = 0; _i166 < _list165.Count; ++_i166)
{
string _elem167 = null;
_elem167 = iprot.ReadString();
_val164.Add(_elem167);
}
iprot.ReadListEnd();
}
Success[_key163] = _val164;
}
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;
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) {
Start_token = iprot.ReadString();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String) {
End_token = iprot.ReadString();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.List) {
{
Endpoints = new List<string>();
TList _list24 = iprot.ReadListBegin();
for( int _i25 = 0; _i25 < _list24.Count; ++_i25)
{
string _elem26 = null;
_elem26 = iprot.ReadString();
Endpoints.Add(_elem26);
}
iprot.ReadListEnd();
}
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.List) {
{
Rpc_endpoints = new List<string>();
TList _list27 = iprot.ReadListBegin();
for( int _i28 = 0; _i28 < _list27.Count; ++_i28)
{
string _elem29 = null;
_elem29 = iprot.ReadString();
Rpc_endpoints.Add(_elem29);
}
iprot.ReadListEnd();
}
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.List) {
{
Endpoint_details = new List<EndpointDetails>();
TList _list30 = iprot.ReadListBegin();
for( int _i31 = 0; _i31 < _list30.Count; ++_i31)
{
EndpointDetails _elem32 = new EndpointDetails();
_elem32 = new EndpointDetails();
_elem32.Read(iprot);
Endpoint_details.Add(_elem32);
}
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_name_types = false;
bool isset_value_types = false;
bool isset_default_name_type = false;
bool isset_default_value_type = 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) {
{
Name_types = new Dictionary<byte[], string>();
TMap _map86 = iprot.ReadMapBegin();
for( int _i87 = 0; _i87 < _map86.Count; ++_i87)
{
byte[] _key88;
string _val89;
_key88 = iprot.ReadBinary();
_val89 = iprot.ReadString();
Name_types[_key88] = _val89;
}
iprot.ReadMapEnd();
}
isset_name_types = true;
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Map) {
{
Value_types = new Dictionary<byte[], string>();
TMap _map90 = iprot.ReadMapBegin();
for( int _i91 = 0; _i91 < _map90.Count; ++_i91)
{
byte[] _key92;
string _val93;
_key92 = iprot.ReadBinary();
_val93 = iprot.ReadString();
Value_types[_key92] = _val93;
}
iprot.ReadMapEnd();
}
isset_value_types = true;
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String) {
Default_name_type = iprot.ReadString();
isset_default_name_type = true;
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.String) {
Default_value_type = iprot.ReadString();
isset_default_value_type = true;
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
if (!isset_name_types)
throw new TProtocolException(TProtocolException.INVALID_DATA);
if (!isset_value_types)
throw new TProtocolException(TProtocolException.INVALID_DATA);
if (!isset_default_name_type)
throw new TProtocolException(TProtocolException.INVALID_DATA);
if (!isset_default_value_type)
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.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.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 _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();
}
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) {
Column_family = iprot.ReadString();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Struct) {
Range = new KeyRange();
Range.Read(iprot);
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String) {
Start_column = iprot.ReadBinary();
} 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)
{
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) {
CfName = iprot.ReadString();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String) {
Start_token = iprot.ReadString();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String) {
End_token = iprot.ReadString();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.I32) {
Keys_per_split = 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_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)
{
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) {
Validation_class = iprot.ReadString();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.I32) {
Index_type = (IndexType)iprot.ReadI32();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.String) {
Index_name = iprot.ReadString();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.Map) {
{
Index_options = new Dictionary<string, string>();
TMap _map41 = iprot.ReadMapBegin();
for( int _i42 = 0; _i42 < _map41.Count; ++_i42)
{
string _key43;
string _val44;
_key43 = iprot.ReadString();
_val44 = iprot.ReadString();
Index_options[_key43] = _val44;
}
iprot.ReadMapEnd();
}
} 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)
{
bool isset_itemId = 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.I32) {
ItemId = iprot.ReadI32();
isset_itemId = 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;
case 3:
if (field.Type == TType.List) {
{
Variable_types = new List<string>();
TList _list100 = iprot.ReadListBegin();
for( int _i101 = 0; _i101 < _list100.Count; ++_i101)
{
string _elem102 = null;
_elem102 = iprot.ReadString();
Variable_types.Add(_elem102);
}
iprot.ReadListEnd();
}
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.List) {
{
Variable_names = new List<string>();
TList _list103 = iprot.ReadListBegin();
for( int _i104 = 0; _i104 < _list103.Count; ++_i104)
{
string _elem105 = null;
_elem105 = iprot.ReadString();
Variable_names.Add(_elem105);
}
iprot.ReadListEnd();
}
} 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_count)
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)
{
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.I32) {
ItemId = iprot.ReadI32();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.I32) {
Count = iprot.ReadI32();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.List) {
{
Variable_types = new List<string>();
TList _list87 = iprot.ReadListBegin();
for( int _i88 = 0; _i88 < _list87.Count; ++_i88)
{
string _elem89 = null;
_elem89 = iprot.ReadString();
Variable_types.Add(_elem89);
}
iprot.ReadListEnd();
}
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.List) {
{
Variable_names = new List<string>();
TList _list90 = iprot.ReadListBegin();
for( int _i91 = 0; _i91 < _list90.Count; ++_i91)
{
string _elem92 = null;
_elem92 = iprot.ReadString();
Variable_names.Add(_elem92);
}
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)
{
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.ReadString();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String) {
Strategy_class = iprot.ReadString();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.Map) {
{
Strategy_options = new Dictionary<string, string>();
TMap _map60 = iprot.ReadMapBegin();
for( int _i61 = 0; _i61 < _map60.Count; ++_i61)
{
string _key62;
string _val63;
_key62 = iprot.ReadString();
_val63 = iprot.ReadString();
Strategy_options[_key62] = _val63;
}
iprot.ReadMapEnd();
}
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.I32) {
Replication_factor = iprot.ReadI32();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.List) {
{
Cf_defs = new List<CfDef>();
TList _list64 = iprot.ReadListBegin();
for( int _i65 = 0; _i65 < _list64.Count; ++_i65)
{
CfDef _elem66 = new CfDef();
_elem66 = new CfDef();
_elem66.Read(iprot);
Cf_defs.Add(_elem66);
}
iprot.ReadListEnd();
}
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.Bool) {
Durable_writes = iprot.ReadBool();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
