Ejemplo n.º 1
0
        internal void CreateRowAssigTestValues(TableX tx)
        {
            var rx = new RowX(tx);

            if (Get <Relation_Store_ColumnX>().TryGetChildren(tx, out IList <ColumnX> colums))
            {
                foreach (var col in colums)
                {
                    col.Value.SetValue(rx, AllValTypeValueStrings[(int)col.Value.ValType]);
                }
            }
        }
Ejemplo n.º 2
0
        public void ReadData(DataReader r, Item[] items)
        {
            var N = r.ReadInt32();

            if (N < 1)
            {
                throw new Exception($"Invalid count {N}");
            }

            var fv = r.ReadByte();

            if (fv == 1)
            {
                for (int i = 0; i < N; i++)
                {
                    var index = r.ReadInt32();
                    if (index < 0 || index >= items.Length)
                    {
                        throw new Exception($"Invalid index {index}");
                    }

                    var tx = new TableX(this);
                    items[index] = tx;

                    var b = r.ReadByte();
                    if ((b & B1) != 0)
                    {
                        tx.SetState(r.ReadUInt16());
                    }
                    if ((b & B2) != 0)
                    {
                        tx.Name = Value.ReadString(r);
                    }
                    if ((b & B3) != 0)
                    {
                        tx.Summary = Value.ReadString(r);
                    }
                    if ((b & B4) != 0)
                    {
                        tx.Description = Value.ReadString(r);
                    }

                    var rxCount = r.ReadInt32();
                    if (rxCount < 0)
                    {
                        throw new Exception($"Invalid row count {rxCount}");
                    }
                    if (rxCount > 0)
                    {
                        tx.SetCapacity(rxCount);
                    }

                    for (int j = 0; j < rxCount; j++)
                    {
                        var index2 = r.ReadInt32();
                        if (index2 < 0 || index2 >= items.Length)
                        {
                            throw new Exception($"Invalid row index {index2}");
                        }

                        items[index2] = new RowX(tx);
                    }
                }
            }
            else
            {
                throw new Exception($"ViewXDomain ReadData, unknown format version: {fv}");
            }
        }
Ejemplo n.º 3
0
 internal string GetRowXSummaryId(RowX rx) => _relation_Store_SummaryProperty.TryGetChild(rx.Owner, out Property p) ? p.Value.GetString(rx) : string.Empty;
Ejemplo n.º 4
0
        internal string GetRowXNameId(RowX rx)
        {
            var text = _relation_Store_NameProperty.TryGetChild(rx.Owner, out Property p) ? p.Value.GetString(rx) : string.Empty;

            return(string.IsNullOrWhiteSpace(text) ? rx.GetIndexId() : text);
        }
Ejemplo n.º 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);
        }