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)); }