Example #1
0
        private void AddNewColumnX(Root root)
        {
            var cx  = new ColumnX(root.Get <ColumnXRoot>(), true);
            var sto = Item as Store;

            // the data root implements undo/redo functionality
            ItemCreated.Record(root, cx);
            ItemLinked.Record(root, root.Get <Relation_Store_ColumnX>(), sto, cx);
        }
Example #2
0
 internal void AddEnumColumn(EnumX ex, ColumnX cx)
 {
     if (cx.HasEnumXRef && _relation_EnumX_ColumnX.TryGetParent(cx, out EnumX oldEx))
     {
         if (oldEx == ex)
         {
             return;
         }
         _relation_EnumX_ColumnX.RemoveLink(oldEx, cx);
     }
     _relation_EnumX_ColumnX.AppendLink(ex, cx);
 }
Example #3
0
        internal void CreateAllValTypeColumns(TableX tx)
        {
            var prop                   = Get <Property_ColumnX_ValueType>();
            var storeOf_ColumnX        = Get <ColumnXRoot>();
            var relation_Store_ColumnX = Get <Relation_Store_ColumnX>();

            for (int i = 0; i < (int)ValType.MaximumType; i++)
            {
                var cx = new ColumnX(storeOf_ColumnX);
                relation_Store_ColumnX.SetLink(tx, cx);
                prop.SetItemPropertyValue(cx, i);
            }
        }
Example #4
0
        internal static void ReadData(DataReader r, ColumnX cx, Item[] items)
        {
            var t = r.ReadByte();

            if (t > _createValue.Length)
            {
                throw new ArgumentException("Invalid Value Type");
            }

            var count = r.ReadInt32();

            if (count < 0)
            {
                throw new Exception($"Invalid row count {count}");
            }

            cx.Value = _createValue[t](r, count, items);
        }
Example #5
0
        internal bool CheckColumnTestValue(RowX row, ColumnX column)
        {
            switch (column.Value.ValType)
            {
            case ValType.Bool:
                column.Value.GetValue(row, out bool vBool);
                if (!vBool)
                {
                    return(false);
                }
                break;

            case ValType.IsArray:     //is bool array
                column.Value.GetValue(row, out bool[] vBools);
                if (8 != vBools.Length)
                {
                    return(false);
                }
                if (!vBools[0])
                {
                    return(false);
                }
                if (vBools[1])
                {
                    return(false);
                }
                if (!vBools[2])
                {
                    return(false);
                }
                if (vBools[3])
                {
                    return(false);
                }
                if (!vBools[4])
                {
                    return(false);
                }
                if (vBools[5])
                {
                    return(false);
                }
                if (!vBools[6])
                {
                    return(false);
                }
                if (vBools[7])
                {
                    return(false);
                }
                break;

            case ValType.Char:
                column.Value.GetValue(row, out int vChar);
                if ((int)'K' != vChar)
                {
                    return(false);
                }
                break;

            case ValType.CharArray:
                column.Value.GetValue(row, out string vChars);
                if ("W, h, i, t, e, -, D, o, g" != vChars)
                {
                    return(false);
                }
                break;

            case ValType.Byte:
                column.Value.GetValue(row, out int vByte);
                if (254 != vByte)
                {
                    return(false);
                }
                break;

            case ValType.ByteArray:
                column.Value.GetValue(row, out int[] vBytes);
                if (3 != vBytes.Length)
                {
                    return(false);
                }
                if (2 != vBytes[0])
                {
                    return(false);
                }
                if (5 != vBytes[1])
                {
                    return(false);
                }
                if (4 != vBytes[2])
                {
                    return(false);
                }
                break;

            case ValType.SByte:
                column.Value.GetValue(row, out int vSByte);
                if (-128 != vSByte)
                {
                    return(false);
                }
                break;

            case ValType.SByteArray:
                column.Value.GetValue(row, out int[] vSBytes);
                if (3 != vSBytes.Length)
                {
                    return(false);
                }
                if (-128 != vSBytes[0])
                {
                    return(false);
                }
                if (0 != vSBytes[1])
                {
                    return(false);
                }
                if (127 != vSBytes[2])
                {
                    return(false);
                }
                break;

            case ValType.Int16:
                column.Value.GetValue(row, out int vInt16);
                if (-32768 != vInt16)
                {
                    return(false);
                }
                break;

            case ValType.Int16Array:
                column.Value.GetValue(row, out int[] vInt16s);
                if (3 != vInt16s.Length)
                {
                    return(false);
                }
                if (-32768 != vInt16s[0])
                {
                    return(false);
                }
                if (0 != vInt16s[1])
                {
                    return(false);
                }
                if (32767 != vInt16s[2])
                {
                    return(false);
                }
                break;

            case ValType.UInt16:
                column.Value.GetValue(row, out int vUInt16);
                if (0xF0F0 != vUInt16)
                {
                    return(false);
                }
                break;

            case ValType.UInt16Array:
                column.Value.GetValue(row, out int[] vUInt16s);
                if (3 != vUInt16s.Length)
                {
                    return(false);
                }
                if (0xF0F0 != vUInt16s[0])
                {
                    return(false);
                }
                if (0 != vUInt16s[1])
                {
                    return(false);
                }
                if (0xF0F != vUInt16s[2])
                {
                    return(false);
                }
                break;

            case ValType.Int32:
                column.Value.GetValue(row, out int vInt32);
                if (-2147483648 != vInt32)
                {
                    return(false);
                }
                break;

            case ValType.Int32Array:
                column.Value.GetValue(row, out int[] vInt32s);
                if (3 != vInt32s.Length)
                {
                    return(false);
                }
                if (-2147483648 != vInt32s[0])
                {
                    return(false);
                }
                if (0 != vInt32s[1])
                {
                    return(false);
                }
                if (2147483647 != vInt32s[2])
                {
                    return(false);
                }
                break;

            case ValType.UInt32:
                column.Value.GetValue(row, out int vUInt32);
                if (0xF0F0F0F0 != (uint)vUInt32)
                {
                    return(false);
                }
                break;

            case ValType.UInt32Array:
                column.Value.GetValue(row, out int[] vUInt32s);
                if (3 != vUInt32s.Length)
                {
                    return(false);
                }
                if (0xF0F0F0F0 != (uint)vUInt32s[0])
                {
                    return(false);
                }
                if (0 != vUInt32s[1])
                {
                    return(false);
                }
                if (0x0F0F0F0F != vUInt32s[2])
                {
                    return(false);
                }
                break;

            case ValType.Int64:
                column.Value.GetValue(row, out long vInt64);
                if (-9223372036854775808 != vInt64)
                {
                    return(false);
                }
                break;

            case ValType.Int64Array:
                column.Value.GetValue(row, out long[] vInt64s);
                if (3 != vInt64s.Length)
                {
                    return(false);
                }
                if (-9223372036854775808 != vInt64s[0])
                {
                    return(false);
                }
                if (0 != vInt64s[1])
                {
                    return(false);
                }
                if (9223372036854775807 != vInt64s[2])
                {
                    return(false);
                }
                break;

            case ValType.UInt64:
                column.Value.GetValue(row, out long vUInt64);
                if (0xF0F0F0F0F0F0F0F0 != (ulong)vUInt64)
                {
                    return(false);
                }
                break;

            case ValType.UInt64Array:
                column.Value.GetValue(row, out long[] vUInt64s);
                if (3 != vUInt64s.Length)
                {
                    return(false);
                }
                if (0xF0F0F0F0F0F0F0F0 != (ulong)vUInt64s[0])
                {
                    return(false);
                }
                if (0 != vUInt64s[1])
                {
                    return(false);
                }
                if (0x0F0F0F0F0F0F0F0F != vUInt64s[2])
                {
                    return(false);
                }
                break;

            case ValType.Single:
                column.Value.GetValue(row, out double vSingle);
                if (-4.0E10 != vSingle)
                {
                    return(false);
                }
                break;

            case ValType.SingleArray:
                column.Value.GetValue(row, out double[] vSingles);
                if (3 != vSingles.Length)
                {
                    return(false);
                }
                if (-4.0E10 != vSingles[0])
                {
                    return(false);
                }
                if (0 != vSingles[1])
                {
                    return(false);
                }
                if (4.0E10 != vSingles[2])
                {
                    return(false);
                }
                break;

            case ValType.Double:
                column.Value.GetValue(row, out double vDouble);
                if (-1.7E308 != vDouble)
                {
                    return(false);
                }
                break;

            case ValType.DoubleArray:
                column.Value.GetValue(row, out double[] vDoubles);
                if (3 != vDoubles.Length)
                {
                    return(false);
                }
                if (-1.7E308 != vDoubles[0])
                {
                    return(false);
                }
                if (0 != vDoubles[1])
                {
                    return(false);
                }
                if (1.7E308 != vDoubles[2])
                {
                    return(false);
                }
                break;

            case ValType.Decimal:
                column.Value.GetValue(row, out double vDecimal);
                if (-5.100300456789 != vDecimal)
                {
                    return(false);
                }
                break;

            case ValType.DecimalArray:
                column.Value.GetValue(row, out double[] vDecimals);
                if (3 != vDecimals.Length)
                {
                    return(false);
                }
                if (-5.100300456789 != vDecimals[0])
                {
                    return(false);
                }
                if (0 != vDecimals[1])
                {
                    return(false);
                }
                if (5.100300456789 != vDecimals[2])
                {
                    return(false);
                }
                break;

            case ValType.DateTime:
                column.Value.GetValue(row, out DateTime vDateTime);
                if (DateTime.Parse("5/1/2008 8:30:52 AM") != vDateTime)
                {
                    return(false);
                }
                break;

            case ValType.DateTimeArray:
                column.Value.GetValue(row, out DateTime[] vDateTimes);
                if (2 != vDateTimes.Length)
                {
                    return(false);
                }
                if (DateTime.Parse("5/1/2008") != vDateTimes[0])
                {
                    return(false);
                }
                if (DateTime.Parse("6/2/2009") != vDateTimes[1])
                {
                    return(false);
                }
                break;

            case ValType.String:
                column.Value.GetValue(row, out string vString);
                if ("What is this?" != vString)
                {
                    return(false);
                }
                break;

            case ValType.StringArray:
                column.Value.GetValue(row, out string[] vStrings);
                var len = vStrings.Length;
                if (8 != len)
                {
                    return(false);
                }
                if ("Can't" != vStrings[0])
                {
                    return(false);
                }
                if ("create" != vStrings[1])
                {
                    return(false);
                }
                if ("a" != vStrings[2])
                {
                    return(false);
                }
                if ("string" != vStrings[3])
                {
                    return(false);
                }
                if ("array" != vStrings[4])
                {
                    return(false);
                }
                if ("from" != vStrings[5])
                {
                    return(false);
                }
                if ("a" != vStrings[6])
                {
                    return(false);
                }
                if ("string" != vStrings[7])
                {
                    return(false);
                }
                break;
            }
            return(true);
        }