예제 #1
0
        public override Dictionary <TKey, TValue> ConvertFromInternal(object value)
        {
            if (value is byte[])
            {
                var components = new Dictionary <TKey, TValue>();

                var keyTypeHint   = typeof(TKey);
                var valueTypeHint = typeof(TValue);

                using (var bytes = new MemoryStream((byte[])value))
                {
                    // number of key / value pairs
                    var numEntriesBytes = new byte[2];
                    if (bytes.Read(numEntriesBytes, 0, 2) <= 0)
                    {
                        return(components);
                    }

                    var nEntries = BitConverter.ToUInt16(numEntriesBytes, 0);
                    for (var i = 0; i < nEntries; i++)
                    {
                        //get the length of the key
                        var keyLengthBytes = new byte[2];
                        bytes.Read(keyLengthBytes, 0, 2);
                        var keyLength = BitConverter.ToUInt16(keyLengthBytes, 0);

                        //read the content of the key into a buffer
                        var keyBuffer = new byte[keyLength];
                        bytes.Read(keyBuffer, 0, keyLength);
                        var entryKey = CassandraObject.GetCassandraObjectFromDatabaseByteArray(keyBuffer, keyTypeHint);

                        //get the length of the value
                        var valueLengthBytes = new byte[2];
                        bytes.Read(valueLengthBytes, 0, 2);
                        var valueLength = BitConverter.ToUInt16(valueLengthBytes, 0);

                        //read the content of the key into a buffer
                        var valueBuffer = new byte[valueLength];
                        bytes.Read(valueBuffer, 0, valueLength);
                        var entryValue = CassandraObject.GetCassandraObjectFromDatabaseByteArray(valueBuffer, valueTypeHint);

                        components.Add((TKey)entryKey, (TValue)entryValue);
                    }
                }

                return(components);
            }

            if (value.GetType().GetInterfaces().Contains(typeof(IEnumerable <object>)))
            {
                return(new Dictionary <TKey, TValue>(((IEnumerable <object>)value).Cast <KeyValuePair <TKey, TValue> >().ToDictionary(k => k.Key, v => v.Value)));
            }

            if (value.GetType().GetInterfaces().Contains(typeof(IEnumerable <KeyValuePair <TKey, TValue> >)))
            {
                return(new Dictionary <TKey, TValue>(((IEnumerable <KeyValuePair <TKey, TValue> >)value).ToDictionary(k => k.Key, v => v.Value)));
            }

            return(null);
        }
예제 #2
0
        private static T ConvertTo <T>(CassandraObject type)
        {
            if (type == null)
            {
                return(default(T));
            }

            return(type.GetValue <T>());
        }
예제 #3
0
        public static ListType <T> From <TIn>(List <TIn> obj)
        {
            //Check to make sure we can convert
            if (ComponentType.CreateInstance().CanConvertFrom(typeof(TIn)))
            {
                return(new ListType <T>(obj.Select(o => (T)CassandraObject.GetCassandraObjectFromObject(o, typeof(T)))));
            }

            throw new ArgumentException(string.Format("can't convert list of type {0} to ListType of type {1}", typeof(TIn), typeof(T)));
        }
예제 #4
0
        public static MapType <TKey, TValue> From <TKeyIn, TValueIn>(IDictionary <TKeyIn, TValueIn> obj)
        {
            //Check to make sure we can convert
            if (KeyType.CreateInstance().CanConvertFrom(typeof(TKeyIn)) && ValueType.CreateInstance().CanConvertFrom(typeof(TValueIn)))
            {
                return(new MapType <TKey, TValue>(obj.ToDictionary(
                                                      k => (TKey)CassandraObject.GetCassandraObjectFromObject(k.Key, KeyType),
                                                      v => (TValue)CassandraObject.GetCassandraObjectFromObject(v.Value, ValueType))));
            }

            throw new ArgumentException(string.Format("can't convert IDictionary of type {0},{1} to MapType of type {2},{3}", typeof(TKeyIn), typeof(TValueIn), typeof(TKey), typeof(TValue)));
        }
예제 #5
0
        public void CassandraType_Cast()
        {
            // arrange
            var expected = new CassandraObject[] { (AsciiType)"string1", (LongType)300 };

            // act
            CompositeType   actualType = expected;
            CassandraObject actual     = actualType;

            // assert
            Assert.True(expected.SequenceEqual((CassandraObject[])actual));
        }
예제 #6
0
        public void CassandraType_Cast()
        {
            // arrange
            BigInteger  expected   = 100;
            IntegerType actualType = expected;

            // act
            CassandraObject actual = actualType;

            // assert
            Assert.Equal(expected, (BigInteger)actual);
        }
예제 #7
0
        public void CassandraType_Cast()
        {
            // arrange
            Guid         expected   = guid;
            TimeUUIDType actualType = expected;

            // act
            CassandraObject actual = actualType;

            // assert
            Assert.Equal(expected, (Guid)actual);
        }
예제 #8
0
        public void CassandraType_Cast()
        {
            // arranage
            string   expected   = "The quick brown fox jumps over the lazy dog.";
            UTF8Type actualType = expected;

            // act
            CassandraObject actual = actualType;

            // assert
            Assert.Equal(expected, (string)actual);
        }
예제 #9
0
        public void CassandraType_Cast()
        {
            //arrange
            var expected = _setType;

            //act
            SetType <UTF8Type> actualType = expected;
            CassandraObject    actual     = actualType;

            //assert
            Assert.True(expected.SequenceEqual((CassandraObject[])actual));
        }
예제 #10
0
        public void CassandraType_Cast()
        {
            //arrange
            var expected = _mapType;

            //act
            MapType <LongType, UUIDType> actualType = expected;
            CassandraObject actual = actualType;

            //assert
            Assert.True(expected.SequenceEqual(actual.GetValue <Dictionary <LongType, UUIDType> >()));
        }
예제 #11
0
        public void CassandraType_Cast()
        {
            // arranage
            long        expected   = 100L;
            IntegerType actualType = expected;

            // act
            CassandraObject actual = actualType;

            // assert
            Assert.Equal(expected, (long)actual);
        }
예제 #12
0
        public void CassandraType_Cast()
        {
            // arrange
            BigDecimal  expected   = bigDecimal;
            DecimalType actualType = expected;

            // act
            CassandraObject actual = actualType;

            // assert
            Assert.Equal(expected, (BigDecimal)actual);
        }
예제 #13
0
        public void JavaBytes_To_CompositeType()
        {
            // arrange
            var expected = new CassandraObject[] { (BytesType)_compositeType[0].GetValue <string>(), (BytesType)_compositeType[1].GetValue <long>() };

            // act
            var actual = new CompositeType();

            actual.SetValueFromBigEndian(_javaByteOrder);

            // assert
            Assert.True(expected.SequenceEqual((CassandraObject[])actual));
        }
예제 #14
0
        public void Implicit_ByteArray_Cast()
        {
            // arrange
            var expected = new CassandraObject[] { (AsciiType)"string1", (LongType)300 };

            byte[] bytes = GetBytes(expected);

            // act
            CompositeType actual = bytes;

            // assert
            Assert.True(expected.SequenceEqual(actual));
        }
예제 #15
0
        public void CassandraType_Cast()
        {
            // arrange
            byte[]    expected   = new byte[] { 0, 32, 0, 16, 0, 0, 64, 128 };
            BytesType actualType = expected;

            // act
            CassandraObject actualCassandraType = actualType;

            byte[] actual = actualCassandraType;

            // assert
            Assert.True(expected.SequenceEqual(actual));
        }
예제 #16
0
        public override Dictionary <TKey, TValue> FromBigEndian(byte[] value)
        {
            var components = new Dictionary <TKey, TValue>();

            var keyTypeHint   = typeof(TKey);
            var valueTypeHint = typeof(TValue);

            if (value == null)
            {
                return(components);
            }
            using (var bytes = new MemoryStream((byte[])value))
            {
                // number of key / value pairs
                var numEntriesBytes = new byte[2];
                if (bytes.Read(numEntriesBytes, 0, 2) <= 0)
                {
                    return(components);
                }

                var nEntries = BitConverter.ToUInt16(ConvertEndian(numEntriesBytes), 0);
                for (var i = 0; i < nEntries; i++)
                {
                    //get the length of the key
                    var keyLengthBytes = new byte[2];
                    bytes.Read(keyLengthBytes, 0, 2);
                    var keyLength = BitConverter.ToUInt16(ConvertEndian(keyLengthBytes), 0);

                    //read the content of the key into a buffer
                    var keyBuffer = new byte[keyLength];
                    bytes.Read(keyBuffer, 0, keyLength);
                    var entryKey = CassandraObject.GetCassandraObjectFromDatabaseByteArray(keyBuffer, keyTypeHint);

                    //get the length of the value
                    var valueLengthBytes = new byte[2];
                    bytes.Read(valueLengthBytes, 0, 2);
                    var valueLength = BitConverter.ToUInt16(ConvertEndian(valueLengthBytes), 0);

                    //read the content of the key into a buffer
                    var valueBuffer = new byte[valueLength];
                    bytes.Read(valueBuffer, 0, valueLength);
                    var entryValue = CassandraObject.GetCassandraObjectFromDatabaseByteArray(valueBuffer, valueTypeHint);

                    components.Add((TKey)entryKey, (TValue)entryValue);
                }
            }

            return(components);
        }
        public static CassandraType GetCassandraType(CassandraObject obj)
        {
            var typeName      = obj.GetType().Name;
            var cassandraType = (CassandraType)null;

            switch (typeName.ToLower())
            {
            case "asciitype": cassandraType = AsciiType; break;

            case "booleantype": cassandraType = BooleanType; break;

            case "bytestype": cassandraType = BytesType; break;

            case "datetype": cassandraType = DateType; break;

            case "decimaltype": cassandraType = DecimalType; break;

            case "doubletype": cassandraType = DoubleType; break;

            case "floattype": cassandraType = FloatType; break;

            case "int32type": cassandraType = Int32Type; break;

            case "integertype": cassandraType = IntegerType; break;

            case "lexicaluuidtype": cassandraType = LexicalUUIDType; break;

            case "longtype": cassandraType = LongType; break;

            case "timeuuidtype": cassandraType = TimeUUIDType; break;

            case "utf8type": cassandraType = UTF8Type; break;

            case "uuidtype": cassandraType = UUIDType; break;

            case "emptytype": cassandraType = EmptyType; break;

            case "inetaddresstype": cassandraType = InetAddressType; break;

            // these need work
            //case "compositetype": cassandraType = CompositeType; break;
            //case "dynamiccompositetype": cassandraType = DynamicCompositeType; break;
            //case "countercolumntype": cassandraType = CounterColumnType; break;
            //case "reversedtype": cassandraType = ReversedType; break;
            default: throw new CassandraException("Type '" + typeName + "' not found.");
            }

            return(cassandraType);
        }
예제 #18
0
        public override List <T> ConvertFromInternal(object value)
        {
            if (value is byte[])
            {
                var components = new List <T>();

                var typeHint = typeof(T);

                using (var bytes = new MemoryStream((byte[])value))
                {
                    // number of elements
                    var numElementsBytes = new byte[2];
                    if (bytes.Read(numElementsBytes, 0, 2) <= 0)
                    {
                        return(components);
                    }

                    var nElements = BitConverter.ToUInt16(numElementsBytes, 0);
                    for (var i = 0; i < nElements; i++)
                    {
                        //get the length of this element
                        var elementLengthBytes = new byte[2];
                        bytes.Read(elementLengthBytes, 0, 2);
                        var elementLength = BitConverter.ToUInt16(elementLengthBytes, 0);

                        //read the content of the element into a buffer
                        var buffer = new byte[elementLength];
                        bytes.Read(buffer, 0, elementLength);
                        var component = CassandraObject.GetCassandraObjectFromDatabaseByteArray(buffer, typeHint);
                        components.Add((T)component);
                    }
                }

                return(components);
            }

            if (value.GetType().GetInterfaces().Contains(typeof(IEnumerable <object>)))
            {
                return(new List <T>(((IEnumerable <object>)value).Cast <T>()));
            }

            if (value.GetType().GetInterfaces().Contains(typeof(IEnumerable <T>)))
            {
                return(new List <T>((IEnumerable <T>)value));
            }

            return(null);
        }
예제 #19
0
        public void Explicit_Dictionary_Cast()
        {
            //arrange
            Dictionary <string, int> expected = new Dictionary <string, int>()
            {
                { "item1", 1 }, { "item2", 2 }, { "item3", 3 }
            };

            //act
            MapType <UTF8Type, IntegerType> actualType = MapType <UTF8Type, IntegerType> .From(expected);

            CassandraObject actual = actualType;

            //assert
            Assert.True(expected.SequenceEqual(actual.GetValue <Dictionary <string, int> >()));
        }
예제 #20
0
        public void Explicit_List_Cast()
        {
            //arrange
            List <int> expected = new List <int>()
            {
                1, 2, 3
            };
            SetType <IntegerType> actualType = SetType <IntegerType> .From(expected);

            //act
            CassandraObject actual       = actualType;
            var             actualValues = actual.GetValue <List <object> >();

            //assert
            Assert.True(expected.SequenceEqual(actualValues.Select(Convert.ToInt32)));
        }
예제 #21
0
        public override List <T> FromBigEndian(byte[] value)
        {
            var components = new List <T>();

            var typeHint = typeof(T);

            if (value == null)
            {
                return(components);
            }
            using (var bytes = new MemoryStream(value))
            {
                // number of elements
                var numElementsBytes = new byte[2];
                if (bytes.Read(numElementsBytes, 0, 2) <= 0)
                {
                    return(components);
                }

                var nElements = BitConverter.ToUInt16(ConvertEndian(numElementsBytes), 0);
                for (var i = 0; i < nElements; i++)
                {
                    //get the length of this element
                    var elementLengthBytes = new byte[2];
                    bytes.Read(elementLengthBytes, 0, 2);
                    var elementLength = BitConverter.ToUInt16(ConvertEndian(elementLengthBytes), 0);

                    //read the content of the element into a buffer
                    var buffer = new byte[elementLength];
                    bytes.Read(buffer, 0, elementLength);
                    var component = CassandraObject.GetCassandraObjectFromDatabaseByteArray(buffer, typeHint);
                    components.Add((T)component);
                }
            }

            return(components);
        }