public ConfigurableColumn(ListStoreMapping mapping, IColumnInfo info, DataColumn column)
{
this.Mapping = mapping;
this.ColumnInfo = info;
this.DataColumn = column;
this.Reorderable = true;
this.Resizable = true;
this.MinWidth = 20;
this.FixedWidth = 80;
this.Sizing = TreeViewColumnSizing.Fixed;
this.Clickable = true;
this.SortIndicator = false;
this.SortOrder = SortType.Ascending;
if(this.ColumnInfo != null)
{
this.Title = this.ColumnInfo.Caption;
this.Visible = this.ColumnInfo.Visible;
}
else if (this.DataColumn != null)
{
this.Title = this.DataColumn.Caption;
}
CreateCellRenderers();
this.Mapping.ColumnsStore.AddNode(this);
this.AddNotification(NotifyChange);
this.WidthAdjustment = new Adjustment(80, 20, 1000, 1, 2, 0);
this.WidthAdjustment.Changed += delegate {
this.FixedWidth = (int)(this.WidthAdjustment.Value);
};
}
public static object ConvertFromTimestamp(IColumnInfo type_info, byte[] value, Type cSharpType)
{
if (cSharpType == null || cSharpType.Equals(typeof(DateTimeOffset)))
return BytesToDateTimeOffset(value, 0);
else
return BytesToDateTimeOffset(value, 0).DateTime;
}
public static byte[] InvConvertFromCustom(IColumnInfo type_info, object value)
{
CheckArgument<byte[]>(value);
return (byte[])value;
// CheckArgument<string>(value);
// return Encoding.UTF8.GetBytes((string)value);
}
public static byte[] InvConvertFromBoolean(IColumnInfo type_info, object value)
{
CheckArgument<bool>(value);
var buffer = new byte[1];
buffer[0] = ((bool)value) ? (byte)0x01 : (byte)0x00;
return buffer;
}
public ConfigurableColumn CreateColumn(IColumnInfo info, DataColumn column)
{
if(info != null)
{
if(!String.IsNullOrEmpty(info.FkReferenceTable))
return new LookupColumn(this, info, column);
}
if(column != null)
{
Type type = column.DataType;
if(type == typeof(DateTime))
return new DateTimeColumn(this, info, column);
else if(type == typeof(string))
return new StringColumn(this, info, column);
else if(type == typeof(bool))
return new CheckBoxColumn(this, info, column);
else if(type == typeof(Decimal))
return new DecimalColumn(this, info, column);
else if(type == typeof(Int64))
return new Int64Column(this, info, column);
else if(type == typeof(Int32))
return new Int64Column(this, info, column);
throw new Exception("Nelze vytvořit sloupeček pro typ " + type.ToString());
}
throw new Exception("Nelze vytvořit sloupeček");
}
public static byte[] InvConvertFromList(IColumnInfo type_info, object value)
{
var listType = GetTypeFromList(type_info);
CheckArgument(listType, value);
var list_typecode = (type_info as ListColumnInfo).ValueTypeCode;
var list_typeinfo = (type_info as ListColumnInfo).ValueTypeInfo;
List<byte[]> bufs = new List<byte[]>();
int cnt = 0;
int bsize = 2;
foreach (var obj in (value as IEnumerable))
{
var buf = TypeInterpreter.InvCqlConvert(obj, list_typecode, list_typeinfo);
bufs.Add(buf);
bsize += buf.Length;
cnt++;
}
var ret = new byte[bsize];
var cntbuf = Int16ToBytes((short)cnt);
int idx = 0;
Buffer.BlockCopy(cntbuf, 0, ret, 0, 2);
idx += 2;
foreach (var buf in bufs)
{
Buffer.BlockCopy(buf, 0, ret, idx, buf.Length);
idx += buf.Length;
}
return ret;
}
public ColumnMap(MemberInfo member, IColumnInfo columnInfo)
{
FieldName = member.Name;
ColumnInfo = columnInfo;
// If the column name is not specified, the field name will be used.
if (string.IsNullOrEmpty(columnInfo.Name))
columnInfo.Name = member.Name;
FieldType = ReflectionHelper.GetMemberType(member);
Type paramNetType = FieldType;
Converter = MapRepository.Instance.GetConverter(FieldType);
if (Converter != null)
{
paramNetType = Converter.DbType;
}
DBType = MapRepository.Instance.DbTypeBuilder.GetDbType(paramNetType);
Getter = MapRepository.Instance.ReflectionStrategy.BuildGetter(member.DeclaringType, FieldName);
Setter = MapRepository.Instance.ReflectionStrategy.BuildSetter(member.DeclaringType, FieldName);
if (member.MemberType == MemberTypes.Property)
{
PropertyInfo pi = (PropertyInfo)member;
CanRead = pi.CanRead;
CanWrite = pi.CanWrite;
}
else if (member.MemberType == MemberTypes.Field)
{
CanRead = true;
CanWrite = true;
}
}
public static byte[] InvConvertFromDouble(IColumnInfo type_info, object value)
{
CheckArgument<double>(value);
byte[] ret = BitConverter.GetBytes((double)value);
Array.Reverse(ret);
return ret;
}
public static object ConvertFromSet(IColumnInfo type_info, byte[] value, Type cSharpType)
{
if (type_info is SetColumnInfo)
{
var list_typecode = (type_info as SetColumnInfo).KeyTypeCode;
var list_typeinfo = (type_info as SetColumnInfo).KeyTypeInfo;
var value_type = TypeInterpreter.GetDefaultTypeFromCqlType(list_typecode, list_typeinfo);
int count = BytesToInt16(value, 0);
int idx = 2;
var openType = typeof(List<>);
var listType = openType.MakeGenericType(value_type);
object ret = Activator.CreateInstance(listType);
var addM = listType.GetMethod("Add");
for (int i = 0; i < count; i++)
{
var val_buf_len = BytesToInt16(value, idx);
idx += 2;
byte[] val_buf = new byte[val_buf_len];
Buffer.BlockCopy(value, idx, val_buf, 0, val_buf_len);
idx += val_buf_len;
addM.Invoke(ret, new object[] { TypeInterpreter.CqlConvert(val_buf, list_typecode, list_typeinfo) });
}
return ret;
}
throw new DriverInternalError("Invalid ColumnInfo");
}
public static object ConvertFromInet(IColumnInfo type_info, byte[] value, Type cSharpType)
{
if (value.Length == 4 || value.Length == 16)
{
var ip = new IPAddress(value);
return new IPEndPoint(ip, 0);
}
else
{
var length = value[0];
IPAddress ip;
int port;
var buf = new byte[length];
if (length == 4)
{
Buffer.BlockCopy(value, 1, buf, 0, 4);
ip = new IPAddress(buf);
port = BytesToInt32(buf, 1 + 4);
return new IPEndPoint(ip, port);
}
else if (length == 16)
{
Buffer.BlockCopy(value, 1, buf, 0, 16);
ip = new IPAddress(buf);
port = BytesToInt32(buf, 1 + 16);
return new IPEndPoint(ip, port);
}
}
throw new DriverInternalError("Invalid lenght of Inet Addr");
}
public static byte[] InvConvertFromVarint(IColumnInfo type_info, object value)
{
CheckArgument<BigInteger>(value);
var ret = ((BigInteger)value).ToByteArray();
Array.Reverse(ret);
return ret;
}
public static byte[] InvConvertFromTimestamp(IColumnInfo type_info, object value)
{
CheckArgument<DateTimeOffset, DateTime>(value);
if(value is DateTimeOffset)
return DateTimeOffsetToBytes((DateTimeOffset)value);
else
return DateTimeOffsetToBytes(new DateTimeOffset((DateTime)value));
}
public override object Deserialize(ushort protocolVersion, byte[] buffer, int offset, int length, IColumnInfo typeInfo)
{
DeserializationCounter++;
if (_fixedValue)
{
return Utils.SliceBuffer(buffer, offset, length);
}
return base.Deserialize(protocolVersion, buffer, offset, length, typeInfo);
}
public object Deserialize(ushort protocolVersion, byte[] buffer, int offset, int length, IColumnInfo typeInfo)
{
buffer = Utils.SliceBuffer(buffer, offset, length);
if (_reverse)
{
Array.Reverse(buffer);
}
return _adapter.ConvertFrom(buffer);
}
public string BuildPropertieStr(IColumnInfo column)
{
StringBuilder sb = new StringBuilder();
bool hasvalue = false;
sb.AppendFormat("this.Property(t => t.{0})", column.PascalName);
if (column.Identity)
{
hasvalue = true;
sb.Append("\r\n ");
sb.Append(".HasDatabaseGeneratedOption(DatabaseGeneratedOption.Identity)");
}
if (column.Computed)
{
hasvalue = true;
sb.Append("\r\n ");
sb.Append(".HasDatabaseGeneratedOption(DatabaseGeneratedOption.Computed)");
}
if (column.IsPrimaryKey)
{
if (!column.Identity)
{
hasvalue = true;
sb.Append("\r\n ");
sb.Append(".HasDatabaseGeneratedOption(DatabaseGeneratedOption.None)");
}
}
//if (!column.HasStringLength && column.Nullable)
// return string.Empty;
if (column.HasStringLength)
{
hasvalue = true;
sb.Append("\r\n ");
sb.AppendFormat(".HasMaxLength({0})", column.MaxLength);
}
if (!column.Nullable && !column.IsPrimaryKey && !column.Identity && !column.Computed)
{
hasvalue = true;
sb.Append("\r\n ");
sb.Append(".IsRequired()");
}
if(!hasvalue)
{
return string.Empty;
}
sb.Append(";");
return sb.ToString();
}
public static byte[] InvConvertFromInet(IColumnInfo type_info, object value)
{
CheckArgument<IPEndPoint>(value);
var addrbytes = (value as IPEndPoint).Address.GetAddressBytes();
var port = Int32ToBytes((value as IPEndPoint).Port);
var ret = new byte[addrbytes.Length + 4 + 1];
ret[0] = (byte)addrbytes.Length;
Buffer.BlockCopy(addrbytes, 0, ret, 1, addrbytes.Length);
Buffer.BlockCopy(port, 0, ret, 1 + addrbytes.Length, port.Length);
return ret;
}
public static Type GetDefaultTypeFromSet(IColumnInfo type_info)
{
if (type_info is SetColumnInfo)
{
var list_typecode = (type_info as SetColumnInfo).KeyTypeCode;
var list_typeinfo = (type_info as SetColumnInfo).KeyTypeInfo;
var value_type = TypeInterpreter.GetDefaultTypeFromCqlType(list_typecode, list_typeinfo);
var openType = typeof(IEnumerable<>);
var listType = openType.MakeGenericType(value_type);
return listType;
}
throw new DriverInternalError("Invalid ColumnInfo");
}
public static byte[] InvConvertFromDecimal(IColumnInfo type_info, object value)
{
CheckArgument<BigDecimal, decimal>(value);
byte[] ret = null;
if (value.GetType() == typeof(BigDecimal))
ret = ((BigDecimal)value).ToByteArray();
else
if (value.GetType() == typeof(decimal))
ret = (new BigDecimal((decimal)value)).ToByteArray();
Array.Reverse(ret);
return ret;
}
public static byte[] InvConvertFromMap(IColumnInfo type_info, object value)
{
var dicType = GetTypeFromList(type_info);
CheckArgument(dicType, value);
var key_typecode = (type_info as MapColumnInfo).KeyTypeCode;
var key_typeinfo = (type_info as MapColumnInfo).KeyTypeInfo;
var value_typecode = (type_info as MapColumnInfo).ValueTypeCode;
var value_typeinfo = (type_info as MapColumnInfo).ValueTypeInfo;
var key_type = TypeInterpreter.GetTypeFromCqlType(key_typecode, key_typeinfo);
var value_type = TypeInterpreter.GetTypeFromCqlType(value_typecode, value_typeinfo);
List<byte[]> bufs = new List<byte[]>();
int cnt = 0;
int bsize = 2;
var kvoType = typeof(KeyValuePair<,>);
var kvType =kvoType.MakeGenericType(key_type, value_type);
var key_prop = kvType.GetProperty("Key");
var value_prop = kvType.GetProperty("Value");
foreach (var kv in (value as IEnumerable))
{
{
var obj = key_prop.GetValue(kv, new object[] { });
var buf = TypeInterpreter.InvCqlConvert(obj, key_typecode, key_typeinfo);
bufs.Add(buf);
bsize += buf.Length;
}
{
var obj = value_prop.GetValue(kv, new object[] { });
var buf = TypeInterpreter.InvCqlConvert(obj, value_typecode, value_typeinfo);
bufs.Add(buf);
bsize += buf.Length;
}
cnt++;
}
var ret = new byte[bsize];
var cntbuf = Int16ToBytes((short)cnt); // short or ushort ?
int idx = 0;
Buffer.BlockCopy(cntbuf, 0, ret, 0, 2);
idx += 2;
foreach (var buf in bufs)
{
Buffer.BlockCopy(buf, 0, ret, idx, buf.Length);
idx += buf.Length;
}
return ret;
}
public LookupColumn(ListStoreMapping Mapping, IColumnInfo ColumnInfo, DataColumn DataColumn)
: base(Mapping, ColumnInfo, DataColumn)
{
ILookupInfo linfo = (ILookupInfo)this.ColumnInfo;
ds = ServerConnection.Instance.GetCachedDataSet(linfo.LookupTable);
string[] cols = linfo.FkListReplaceFormat.Split(
new char[] {',',';',' ',':','-','\'','"', '[', ']', '(', ')', '{', '}', '<', '>'}, StringSplitOptions.RemoveEmptyEntries);
format = linfo.FkListReplaceFormat;
for(int i = 0; i < cols.Length; i++)
{
int idx = ds.Tables[0].Columns.IndexOf(cols[i]);
if(idx >= 0)
format = format.Replace(cols[i], "{" + idx.ToString() + "}");
}
}
public static byte[] InvConvertFromTimestamp(IColumnInfo type_info, object value)
{
CheckArgument<DateTimeOffset, DateTime>(value);
if (value is DateTimeOffset)
return DateTimeOffsetToBytes((DateTimeOffset) value);
else
{
var dt = (DateTime)value;
// need to treat "Unspecified" as UTC (+0) not the default behavior of DateTimeOffset which treats as Local Timezone
// because we are about to do math against EPOCH which must align with UTC.
// If we don't, then the value saved will be shifted by the local timezone when retrieved back out as DateTime.
return DateTimeOffsetToBytes(dt.Kind == DateTimeKind.Unspecified
? new DateTimeOffset(dt,TimeSpan.Zero)
: new DateTimeOffset(dt));
}
}
public static Type GetDefaultTypeFromMap(IColumnInfo type_info)
{
if (type_info is MapColumnInfo)
{
var key_typecode = (type_info as MapColumnInfo).KeyTypeCode;
var key_typeinfo = (type_info as MapColumnInfo).KeyTypeInfo;
var value_typecode = (type_info as MapColumnInfo).ValueTypeCode;
var value_typeinfo = (type_info as MapColumnInfo).ValueTypeInfo;
var key_type = TypeInterpreter.GetDefaultTypeFromCqlType(key_typecode, key_typeinfo);
var value_type = TypeInterpreter.GetDefaultTypeFromCqlType(value_typecode, value_typeinfo);
var openType = typeof(IDictionary<,>);
var dicType = openType.MakeGenericType(key_type, value_type);
return dicType;
}
throw new DriverInternalError("Invalid ColumnInfo");
}
private Widget CreateWidget(DataColumn db_col, IColumnInfo colinfo, uint top)
{
string caption = colinfo.Caption;
Widget result;
if(colinfo.IsForeignKey)
{
Label label = new Label(caption);
label.UseUnderline = false;
content.Attach(label,0,1,top,top+1,AttachOptions.Shrink, AttachOptions.Shrink,3,0);
result = new ComboBox();
}
else if(db_col.DataType == typeof(bool))
{
result = new CheckButton(caption);
}
/*
else if(db_col.DataType == typeof(DateTime))
{
Label label = new Label(caption);
label.UseUnderline = false;
content.Attach(label,0,1,top,top+1,AttachOptions.Shrink, AttachOptions.Shrink,3,0);
Entry dateEntry = new Entry();
dateEntry.ButtonPressEvent += delegate {
// Gtk.Calendar calend = new Calendar();
// calend.ShowAll();
};
result = dateEntry;
}
*/
else
{
Label label = new Label(caption);
label.UseUnderline = false;
content.Attach(label,0,1,top,top+1,AttachOptions.Shrink, AttachOptions.Shrink,3,0);
result = new Entry();
}
content.Attach(result,1,2,top,top+1,AttachOptions.Expand | AttachOptions.Fill, AttachOptions.Expand | AttachOptions.Fill,3,0);
this.BindWidget(db_col, result, colinfo);
return result;
}
public static object ConvertFromMap(IColumnInfo type_info, byte[] value)
{
if (type_info is MapColumnInfo)
{
var key_typecode = (type_info as MapColumnInfo).KeyTypeCode;
var key_typeinfo = (type_info as MapColumnInfo).KeyTypeInfo;
var value_typecode = (type_info as MapColumnInfo).ValueTypeCode;
var value_typeinfo = (type_info as MapColumnInfo).ValueTypeInfo;
var key_type = TypeInterpreter.GetTypeFromCqlType(key_typecode, key_typeinfo);
var value_type = TypeInterpreter.GetTypeFromCqlType(value_typecode, value_typeinfo);
int count = BytesToInt16(value, 0);
int idx = 2;
var openType = typeof(SortedDictionary<,>);
var dicType = openType.MakeGenericType(key_type, value_type);
object ret = Activator.CreateInstance(dicType);
var addM = dicType.GetMethod("Add");
for (int i = 0; i < count; i++)
{
var key_buf_len = BytesToInt16(value, idx);
idx += 2;
byte[] key_buf = new byte[key_buf_len];
Buffer.BlockCopy(value, idx, key_buf, 0, key_buf_len);
idx += key_buf_len;
var value_buf_len = BytesToInt16(value, idx);
idx += 2;
byte[] value_buf = new byte[value_buf_len];
Buffer.BlockCopy(value, idx, value_buf, 0, value_buf_len);
idx += value_buf_len;
addM.Invoke(ret, new object[] {
TypeInterpreter.CqlConvert(key_buf, key_typecode, key_typeinfo),
TypeInterpreter.CqlConvert(value_buf, value_typecode, value_typeinfo)
});
}
return ret;
}
throw new DriverInternalError("Invalid ColumnInfo");
}
public ColumnViewModel(IColumnInfo columnInfo)
{
this.ColumnInfo = columnInfo;
}
public static Type GetDefaultTypeFromInet(IColumnInfo type_info)
{
return(typeof(IPAddress));
}
/// <summary>
/// Converts a value from CLR IPAddress to byte BE Byte array
/// </summary>
public static byte[] InvConvertFromInet(IColumnInfo type_info, object value)
{
CheckArgument <IPAddress>(value);
return((value as IPAddress).GetAddressBytes());
}
internal object Deserialize(byte[] buffer, int offset, int length, ColumnTypeCode typeCode, IColumnInfo typeInfo)
{
ITypeSerializer typeSerializer;
if (_primitiveDeserializers.TryGetValue(typeCode, out typeSerializer))
{
return(typeSerializer.Deserialize((byte)_protocolVersion, buffer, offset, length, typeInfo));
}
switch (typeCode)
{
case ColumnTypeCode.Custom:
{
if (_customDeserializers.Count == 0 || !_customDeserializers.TryGetValue(typeInfo, out typeSerializer))
{
// Use byte[] by default
typeSerializer = TypeSerializer.PrimitiveByteArraySerializer;
}
return(typeSerializer.Deserialize((byte)_protocolVersion, buffer, offset, length, typeInfo));
}
case ColumnTypeCode.Udt:
return(_udtSerializer.Deserialize((byte)_protocolVersion, buffer, offset, length, typeInfo));
case ColumnTypeCode.List:
case ColumnTypeCode.Set:
return(_collectionSerializer.Deserialize((byte)_protocolVersion, buffer, offset, length, typeInfo));
case ColumnTypeCode.Map:
return(_dictionarySerializer.Deserialize((byte)_protocolVersion, buffer, offset, length, typeInfo));
case ColumnTypeCode.Tuple:
return(_tupleSerializer.Deserialize((byte)_protocolVersion, buffer, offset, length, typeInfo));
}
//Unknown type, return the byte representation
return(buffer);
}
public override BigInteger Deserialize(ushort protocolVersion, byte[] buffer, int offset, int length, IColumnInfo typeInfo)
{
buffer = Utils.SliceBuffer(buffer, offset, length);
//Cassandra uses big endian encoding
Array.Reverse(buffer);
return(new BigInteger(buffer));
}
private List <DataEntity> GetDataEntitiesFromArray(ICluster cluster, string keyspace, string name, string prefix, ColumnTypeCode type, IColumnInfo columnInfo, DataContainer container, DataCollection dataCollection)
{
var entities = new List <DataEntity>();
TableColumn column = new TableColumn();
column.Name = name;
column.TypeCode = type;
column.TypeInfo = columnInfo;
AddEntityAndChildren(cluster, keyspace, column, prefix, container, dataCollection, entities);
return(entities);
}
public ColumnViewModel(IColumnInfo columnInfo)
{
this.ColumnInfo = columnInfo;
}
public override IStructuralEquatable Deserialize(ushort protocolVersion, byte[] buffer, int offset, int length, IColumnInfo typeInfo)
{
var tupleInfo = (TupleColumnInfo)typeInfo;
var tupleType = GetClrType(ColumnTypeCode.Tuple, tupleInfo);
var tupleValues = new object[tupleInfo.Elements.Count];
var maxOffset = offset + length;
for (var i = 0; i < tupleInfo.Elements.Count; i++)
{
var element = tupleInfo.Elements[i];
if (offset >= maxOffset)
{
break;
}
var itemLength = BeConverter.ToInt32(buffer, offset);
offset += 4;
if (itemLength < 0)
{
continue;
}
tupleValues[i] = DeserializeChild(protocolVersion, buffer, offset, itemLength, element.TypeCode, element.TypeInfo);
offset += itemLength;
}
return((IStructuralEquatable)Activator.CreateInstance(tupleType, tupleValues));
}
public object Deserialize(ushort protocolVersion, byte[] buffer, int offset, int length, IColumnInfo typeInfo)
{
buffer = Utils.SliceBuffer(buffer, offset, length);
if (_reverse)
{
Array.Reverse(buffer);
}
return(_adapter.ConvertFrom(buffer));
}
public static object ConvertFromUuid(IColumnInfo type_info, byte[] value)
{
return(new Guid(GuidShuffle(value)));
}
public static byte[] InvConvertFromUuid(IColumnInfo type_info, object value)
{
CheckArgument <Guid>(value);
return(GuidShuffle(((Guid)value).ToByteArray()));
}
public static Type GetTypeFromUuid(IColumnInfo type_info)
{
return(typeof(Guid));
}
public override long Deserialize(ushort protocolVersion, byte[] buffer, int offset, int length, IColumnInfo typeInfo)
{
return(BeConverter.ToInt64(buffer, offset));
}
public static Type GetTypeFromCustom(IColumnInfo type_info)
{
return typeof(string);
}
public override Polygon Deserialize(ushort protocolVersion, byte[] buffer, int offset, int length, IColumnInfo typeInfo)
{
if (buffer == null)
{
throw new ArgumentNullException("buffer");
}
if (length < 9)
{
throw new ArgumentException("A Polygon buffer should contain at least 9 bytes");
}
var isLe = IsLittleEndian(buffer, offset);
offset++;
var type = (GeometryType)EndianBitConverter.ToInt32(isLe, buffer, offset);
if (type != GeometryType.Polygon)
{
throw new ArgumentException("Binary representation was not a Polygon");
}
offset += 4;
var ringsLength = EndianBitConverter.ToInt32(isLe, buffer, offset);
offset += 4;
var ringsArray = new IList <Point> [ringsLength];
for (var ringIndex = 0; ringIndex < ringsLength; ringIndex++)
{
var pointsLength = EndianBitConverter.ToInt32(isLe, buffer, offset);
offset += 4;
if (buffer.Length < offset + pointsLength * 16)
{
throw new ArgumentException("Length of the buffer does not match");
}
var ring = new Point[pointsLength];
for (var i = 0; i < pointsLength; i++)
{
ring[i] = new Point(
EndianBitConverter.ToDouble(isLe, buffer, offset),
EndianBitConverter.ToDouble(isLe, buffer, offset + 8));
offset += 16;
}
ringsArray[ringIndex] = ring;
}
return(new Polygon(ringsArray));
}
public static Type GetDefaultTypeFromAscii(IColumnInfo type_info)
{
return(typeof(string));
}
public static Type GetDefaultTypeFromTimestamp(IColumnInfo type_info)
{
return(typeof(DateTimeOffset));
}
public static byte[] InvConvertFromAscii(IColumnInfo type_info, object value)
{
CheckArgument <string>(value);
return(Encoding.ASCII.GetBytes((string)value));
}
public override bool Deserialize(ushort protocolVersion, byte[] buffer, int offset, int length, IColumnInfo typeInfo)
{
return(buffer[offset] == 1);
}
public object Deserialize(ProtocolVersion version, byte[] buffer, int offset, int length, ColumnTypeCode typeCode, IColumnInfo typeInfo)
{
return(_genericSerializer.Deserialize(version, buffer, offset, length, typeCode, typeInfo));
}
public ColumnTypeCode GetCqlType(Type type, out IColumnInfo typeInfo)
{
typeInfo = null;
ITypeSerializer typeSerializer;
if (_primitiveSerializers.TryGetValue(type, out typeSerializer))
{
return(typeSerializer.CqlType);
}
if (_customSerializers.Count > 0 && _customSerializers.TryGetValue(type, out typeSerializer))
{
typeInfo = typeSerializer.TypeInfo;
return(typeSerializer.CqlType);
}
if (type.IsArray)
{
IColumnInfo valueTypeInfo;
ColumnTypeCode valueTypeCode = GetCqlType(type.GetElementType(), out valueTypeInfo);
typeInfo = new ListColumnInfo
{
ValueTypeCode = valueTypeCode,
ValueTypeInfo = valueTypeInfo
};
return(ColumnTypeCode.List);
}
if (type.GetTypeInfo().IsGenericType)
{
if (type.GetGenericTypeDefinition() == typeof(Nullable <>))
{
return(GetCqlType(type.GetTypeInfo().GetGenericArguments()[0], out typeInfo));
}
if (typeof(IEnumerable).GetTypeInfo().IsAssignableFrom(type))
{
IColumnInfo valueTypeInfo;
ColumnTypeCode valueTypeCode;
var interfaces = type.GetTypeInfo().GetInterfaces();
if (typeof(IDictionary).GetTypeInfo().IsAssignableFrom(type) &&
interfaces.Any(t => t.GetTypeInfo().IsGenericType&& t.GetGenericTypeDefinition() == typeof(IDictionary <,>)))
{
IColumnInfo keyTypeInfo;
var keyTypeCode = GetCqlType(type.GetTypeInfo().GetGenericArguments()[0], out keyTypeInfo);
valueTypeCode = GetCqlType(type.GetTypeInfo().GetGenericArguments()[1], out valueTypeInfo);
typeInfo = new MapColumnInfo
{
KeyTypeCode = keyTypeCode,
KeyTypeInfo = keyTypeInfo,
ValueTypeCode = valueTypeCode,
ValueTypeInfo = valueTypeInfo
};
return(ColumnTypeCode.Map);
}
if (interfaces.Any(t => t.GetTypeInfo().IsGenericType&& t.GetGenericTypeDefinition() == typeof(ISet <>)))
{
IColumnInfo keyTypeInfo;
var keyTypeCode = GetCqlType(type.GetTypeInfo().GetGenericArguments()[0], out keyTypeInfo);
typeInfo = new SetColumnInfo
{
KeyTypeCode = keyTypeCode,
KeyTypeInfo = keyTypeInfo
};
return(ColumnTypeCode.Set);
}
valueTypeCode = GetCqlType(type.GetTypeInfo().GetGenericArguments()[0], out valueTypeInfo);
typeInfo = new ListColumnInfo
{
ValueTypeCode = valueTypeCode,
ValueTypeInfo = valueTypeInfo
};
return(ColumnTypeCode.List);
}
if (typeof(IStructuralComparable).GetTypeInfo().IsAssignableFrom(type) && type.FullName.StartsWith("System.Tuple"))
{
typeInfo = new TupleColumnInfo
{
Elements = type.GetTypeInfo().GetGenericArguments().Select(t =>
{
IColumnInfo tupleSubTypeInfo;
var dataType = new ColumnDesc
{
TypeCode = GetCqlType(t, out tupleSubTypeInfo),
TypeInfo = tupleSubTypeInfo
};
return(dataType);
}).ToList()
};
return(ColumnTypeCode.Tuple);
}
}
//Determine if its a Udt type
var udtMap = _udtSerializer.GetUdtMap(type);
if (udtMap != null)
{
typeInfo = udtMap.Definition;
return(ColumnTypeCode.Udt);
}
throw new InvalidTypeException($"Unknown Cassandra target type for CLR type {type.FullName}");
}
/// <summary>
/// Reads from the internal stream, starting from offset, the amount of bytes defined by count and deserializes
/// the bytes.
/// </summary>
internal object ReadFromBytes(byte[] buffer, int offset, int length, ColumnTypeCode typeCode, IColumnInfo typeInfo)
{
_stream.Read(buffer, offset, length);
return(_serializer.Deserialize(buffer, 0, length, typeCode, typeInfo));
}
internal static object Deserialize(this ISerializer serializer, byte[] buffer, ColumnTypeCode typeCode, IColumnInfo typeInfo)
{
return(serializer.Deserialize(buffer, 0, buffer.Length, typeCode, typeInfo));
}
public override DateTimeOffset Deserialize(ushort protocolVersion, byte[] buffer, int offset, int length, IColumnInfo typeInfo)
{
return(Deserialize(buffer, offset));
}
public static Type GetDefaultTypeFromTimestamp(IColumnInfo type_info)
{
return typeof(DateTimeOffset);
}
public override object Deserialize(ushort protocolVersion, byte[] buffer, int offset, int length, IColumnInfo typeInfo)
{
DeserializationCounter++;
if (_fixedValue)
{
return(Utils.SliceBuffer(buffer, offset, length));
}
return(base.Deserialize(protocolVersion, buffer, offset, length, typeInfo));
}
public static Type GetTypeFromDouble(IColumnInfo type_info)
{
return typeof(double);
}
/// <summary>
/// Creates a new instance of the serializer for custom types.
/// </summary>
/// <param name="name">Fully qualified name of the custom type</param>
protected CustomTypeSerializer(string name)
{
_typeInfo = new CustomColumnInfo(name);
}
public static object ConvertFromDouble(IColumnInfo type_info, byte[] value)
{
var buffer = (byte[])value.Clone();
Array.Reverse(buffer);
return BitConverter.ToDouble(buffer, 0);
}
public override IEnumerable Deserialize(ushort protocolVersion, byte[] buffer, int offset, int length, IColumnInfo typeInfo)
{
ColumnTypeCode?childTypeCode = null;
IColumnInfo childTypeInfo = null;
var listInfo = typeInfo as ListColumnInfo;
if (listInfo != null)
{
childTypeCode = listInfo.ValueTypeCode;
childTypeInfo = listInfo.ValueTypeInfo;
}
var setInfo = typeInfo as SetColumnInfo;
if (setInfo != null)
{
childTypeCode = setInfo.KeyTypeCode;
childTypeInfo = setInfo.KeyTypeInfo;
}
if (childTypeCode == null)
{
throw new DriverInternalError(string.Format("CollectionSerializer can not deserialize CQL values of type {0}",
typeInfo == null ? "null" : typeInfo.GetType().FullName));
}
var count = DecodeCollectionLength((ProtocolVersion)protocolVersion, buffer, ref offset);
var childType = GetClrType(childTypeCode.Value, childTypeInfo);
var result = Array.CreateInstance(childType, count);
for (var i = 0; i < count; i++)
{
var itemLength = DecodeCollectionLength((ProtocolVersion)protocolVersion, buffer, ref offset);
result.SetValue(DeserializeChild(buffer, offset, itemLength, childTypeCode.Value, childTypeInfo), i);
offset += itemLength;
}
return(result);
}
public static object ConvertFromCustom(IColumnInfo type_info, byte[] value)
{
return Encoding.UTF8.GetString((byte[])value);
}
private static string GetTypeString(PocoColumn column, ColumnTypeCode typeCode, IColumnInfo typeInfo)
{
if (typeInfo == null)
{
//Is a single type
return(typeCode.ToString().ToLower());
}
string typeName = null;
var frozenKey = column != null && column.HasFrozenKey;
var frozenValue = column != null && column.HasFrozenValue;
if (typeInfo is MapColumnInfo)
{
var mapInfo = (MapColumnInfo)typeInfo;
typeName = "map<" +
WrapFrozen(frozenKey, GetTypeString(null, mapInfo.KeyTypeCode, mapInfo.KeyTypeInfo)) +
", " +
WrapFrozen(frozenValue, GetTypeString(null, mapInfo.ValueTypeCode, mapInfo.ValueTypeInfo)) +
">";
}
else if (typeInfo is SetColumnInfo)
{
var setInfo = (SetColumnInfo)typeInfo;
typeName = "set<" +
WrapFrozen(frozenKey, GetTypeString(null, setInfo.KeyTypeCode, setInfo.KeyTypeInfo)) +
">";
}
else if (typeInfo is ListColumnInfo)
{
var setInfo = (ListColumnInfo)typeInfo;
typeName = "list<" +
WrapFrozen(frozenValue, GetTypeString(null, setInfo.ValueTypeCode, setInfo.ValueTypeInfo)) +
">";
}
else if (typeInfo is TupleColumnInfo)
{
var tupleInfo = (TupleColumnInfo)typeInfo;
typeName = "tuple<" +
string.Join(", ", tupleInfo.Elements.Select(e => GetTypeString(null, e.TypeCode, e.TypeInfo))) +
">";
}
else if (typeInfo is UdtColumnInfo)
{
var udtInfo = (UdtColumnInfo)typeInfo;
// Escape keyspace and name from the UDT
typeName = string.Join(".", udtInfo.Name.Split('.').Select(k => "\"" + k + "\""));
}
if (typeName == null)
{
throw new NotSupportedException(string.Format("Type {0} is not supported", typeCode));
}
return(WrapFrozen(column != null && column.IsFrozen, typeName));
}
private IColumnInfo GetColumnInfo(FrameReader reader, ColumnTypeCode code)
{
ColumnTypeCode innercode;
switch (code)
{
case ColumnTypeCode.List:
innercode = (ColumnTypeCode)reader.ReadUInt16();
return(new ListColumnInfo
{
ValueTypeCode = innercode,
ValueTypeInfo = GetColumnInfo(reader, innercode)
});
case ColumnTypeCode.Map:
innercode = (ColumnTypeCode)reader.ReadUInt16();
IColumnInfo kci = GetColumnInfo(reader, innercode);
var vinnercode = (ColumnTypeCode)reader.ReadUInt16();
IColumnInfo vci = GetColumnInfo(reader, vinnercode);
return(new MapColumnInfo
{
KeyTypeCode = innercode,
KeyTypeInfo = kci,
ValueTypeCode = vinnercode,
ValueTypeInfo = vci
});
case ColumnTypeCode.Set:
innercode = (ColumnTypeCode)reader.ReadUInt16();
return(new SetColumnInfo
{
KeyTypeCode = innercode,
KeyTypeInfo = GetColumnInfo(reader, innercode)
});
case ColumnTypeCode.Custom:
return(new CustomColumnInfo {
CustomTypeName = reader.ReadString()
});
case ColumnTypeCode.Udt:
var udtInfo = new UdtColumnInfo(reader.ReadString() + "." + reader.ReadString());
var fieldLength = reader.ReadInt16();
for (var i = 0; i < fieldLength; i++)
{
var dataType = new ColumnDesc
{
Name = reader.ReadString(),
TypeCode = (ColumnTypeCode)reader.ReadUInt16(),
};
dataType.TypeInfo = GetColumnInfo(reader, dataType.TypeCode);
udtInfo.Fields.Add(dataType);
}
return(udtInfo);
case ColumnTypeCode.Tuple:
{
var tupleInfo = new TupleColumnInfo();
var elementLength = reader.ReadInt16();
for (var i = 0; i < elementLength; i++)
{
var dataType = new ColumnDesc
{
TypeCode = (ColumnTypeCode)reader.ReadUInt16(),
};
dataType.TypeInfo = GetColumnInfo(reader, dataType.TypeCode);
tupleInfo.Elements.Add(dataType);
}
return(tupleInfo);
}
default:
return(null);
}
}
public static Type GetTypeFromDouble(IColumnInfo type_info)
{
return(typeof(double));
}
public static object ConvertFromAscii(IColumnInfo type_info, byte[] value, Type cSharpType)
{
return(Encoding.ASCII.GetString((byte[])value));
}
public override object Deserialize(ushort protocolVersion, byte[] buffer, int offset, int length, IColumnInfo typeInfo)
{
var udtInfo = (UdtColumnInfo)typeInfo;
var map = GetUdtMap(udtInfo.Name);
if (map == null)
{
return(buffer);
}
var valuesList = new object[udtInfo.Fields.Count];
var maxOffset = offset + length;
for (var i = 0; i < udtInfo.Fields.Count; i++)
{
var field = udtInfo.Fields[i];
if (offset >= maxOffset)
{
break;
}
var itemLength = BeConverter.ToInt32(buffer, offset);
offset += 4;
if (itemLength < 0)
{
continue;
}
valuesList[i] = DeserializeChild(buffer, offset, itemLength, field.TypeCode, field.TypeInfo);
offset += itemLength;
}
return(map.ToObject(valuesList));
}
