Пример #1
0
        private Func <Node, ColumnVal> GetColumnReader(EntityDef e, VariableDef c)
        {
            String  TypeName;
            Boolean IsOptional;

            if (c.Type.OnTypeRef)
            {
                TypeName   = c.Type.TypeRef.Value;
                IsOptional = false;
            }
            else if (c.Type.OnOptional)
            {
                TypeName   = c.Type.Optional.Value;
                IsOptional = true;
            }
            else if (c.Type.OnList)
            {
                var ElementTypeName = c.Type.List.Value;
                if (!ElementTypeName.Equals("Byte", StringComparison.OrdinalIgnoreCase))
                {
                    throw new InvalidOperationException("InvalidColumnListType: List<{0}>".Formats(ElementTypeName));
                }

                TypeName   = "Binary";
                IsOptional = false;
            }
            else
            {
                throw new InvalidOperationException();
            }
            Dictionary <String, Int64> EnumParser = null;

            if (EnumUnderlyingTypes.ContainsKey(TypeName))
            {
                EnumParser = EnumParsers[TypeName];
                TypeName   = EnumUnderlyingTypes[TypeName];
            }

            Func <Node, ColumnVal> Reader;

            if (!IsOptional)
            {
                if (TypeName.Equals("Boolean", StringComparison.OrdinalIgnoreCase))
                {
                    Reader = TreeRow =>
                    {
                        var cvs = TreeRow.Stem.Children.Where(col => col.OnStem && col.Stem.Name.Equals(c.Name, StringComparison.OrdinalIgnoreCase)).ToList();
                        if (cvs.Count != 1)
                        {
                            throw new InvalidOperationException(String.Format("InvalidData: {0}.{1}", e.Name, c.Name));
                        }
                        var cv = cvs.Single().Stem.Children.Single().Leaf;
                        try
                        {
                            var v = Boolean.Parse(cv);
                            return(ColumnVal.CreatePrimitive(PrimitiveVal.CreateBooleanValue(v)));
                        }
                        catch (FormatException)
                        {
                            throw new InvalidOperationException(String.Format("InvalidData: {0}.{1} '{2}'", e.Name, c.Name, cv));
                        }
                    };
                }
                else if (TypeName.Equals("String", StringComparison.OrdinalIgnoreCase))
                {
                    Reader = TreeRow =>
                    {
                        var cvs = TreeRow.Stem.Children.Where(col => col.OnStem && col.Stem.Name.Equals(c.Name, StringComparison.OrdinalIgnoreCase)).ToList();
                        if (cvs.Count != 1)
                        {
                            throw new InvalidOperationException(String.Format("InvalidData: {0}.{1}", e.Name, c.Name));
                        }
                        var cv = cvs.Single().Stem.Children.Single().Leaf;
                        var v  = cv;
                        return(ColumnVal.CreatePrimitive(PrimitiveVal.CreateStringValue(v)));
                    };
                }
                else if (TypeName.Equals("Int", StringComparison.OrdinalIgnoreCase))
                {
                    if (EnumParser != null)
                    {
                        Reader = TreeRow =>
                        {
                            var cvs = TreeRow.Stem.Children.Where(col => col.OnStem && col.Stem.Name.Equals(c.Name, StringComparison.OrdinalIgnoreCase)).ToList();
                            if (cvs.Count != 1)
                            {
                                throw new InvalidOperationException(String.Format("InvalidData: {0}.{1}", e.Name, c.Name));
                            }
                            var cv = cvs.Single().Stem.Children.Single().Leaf;
                            if (EnumParser.ContainsKey(cv))
                            {
                                var v = (int)(EnumParser[cv]);
                                return(ColumnVal.CreatePrimitive(PrimitiveVal.CreateIntValue(v)));
                            }
                            else
                            {
                                try
                                {
                                    var v = NumericStrings.InvariantParseInt32(cv);
                                    return(ColumnVal.CreatePrimitive(PrimitiveVal.CreateIntValue(v)));
                                }
                                catch (FormatException)
                                {
                                    throw new InvalidOperationException(String.Format("InvalidData: {0}.{1} '{2}'", e.Name, c.Name, cv));
                                }
                            }
                        };
                    }
                    else
                    {
                        Reader = TreeRow =>
                        {
                            var cvs = TreeRow.Stem.Children.Where(col => col.OnStem && col.Stem.Name.Equals(c.Name, StringComparison.OrdinalIgnoreCase)).ToList();
                            if (cvs.Count != 1)
                            {
                                throw new InvalidOperationException(String.Format("InvalidData: {0}.{1}", e.Name, c.Name));
                            }
                            var cv = cvs.Single().Stem.Children.Single().Leaf;
                            try
                            {
                                var v = NumericStrings.InvariantParseInt32(cv);
                                return(ColumnVal.CreatePrimitive(PrimitiveVal.CreateIntValue(v)));
                            }
                            catch (FormatException)
                            {
                                throw new InvalidOperationException(String.Format("InvalidData: {0}.{1} '{2}'", e.Name, c.Name, cv));
                            }
                        };
                    }
                }
                else if (TypeName.Equals("Int64", StringComparison.OrdinalIgnoreCase))
                {
                    if (EnumParser != null)
                    {
                        Reader = TreeRow =>
                        {
                            var cvs = TreeRow.Stem.Children.Where(col => col.OnStem && col.Stem.Name.Equals(c.Name, StringComparison.OrdinalIgnoreCase)).ToList();
                            if (cvs.Count != 1)
                            {
                                throw new InvalidOperationException(String.Format("InvalidData: {0}.{1}", e.Name, c.Name));
                            }
                            var cv = cvs.Single().Stem.Children.Single().Leaf;
                            if (EnumParser.ContainsKey(cv))
                            {
                                var v = (Int64)(EnumParser[cv]);
                                return(ColumnVal.CreatePrimitive(PrimitiveVal.CreateInt64Value(v)));
                            }
                            else
                            {
                                try
                                {
                                    var v = NumericStrings.InvariantParseInt64(cv);
                                    return(ColumnVal.CreatePrimitive(PrimitiveVal.CreateInt64Value(v)));
                                }
                                catch (FormatException)
                                {
                                    throw new InvalidOperationException(String.Format("InvalidData: {0}.{1} '{2}'", e.Name, c.Name, cv));
                                }
                            }
                        };
                    }
                    else
                    {
                        Reader = TreeRow =>
                        {
                            var cvs = TreeRow.Stem.Children.Where(col => col.OnStem && col.Stem.Name.Equals(c.Name, StringComparison.OrdinalIgnoreCase)).ToList();
                            if (cvs.Count != 1)
                            {
                                throw new InvalidOperationException(String.Format("InvalidData: {0}.{1}", e.Name, c.Name));
                            }
                            var cv = cvs.Single().Stem.Children.Single().Leaf;
                            try
                            {
                                var v = NumericStrings.InvariantParseInt64(cv);
                                return(ColumnVal.CreatePrimitive(PrimitiveVal.CreateInt64Value(v)));
                            }
                            catch (FormatException)
                            {
                                throw new InvalidOperationException(String.Format("InvalidData: {0}.{1} '{2}'", e.Name, c.Name, cv));
                            }
                        };
                    }
                }
                else if (TypeName.Equals("Real", StringComparison.OrdinalIgnoreCase))
                {
                    Reader = TreeRow =>
                    {
                        var cvs = TreeRow.Stem.Children.Where(col => col.OnStem && col.Stem.Name.Equals(c.Name, StringComparison.OrdinalIgnoreCase)).ToList();
                        if (cvs.Count != 1)
                        {
                            throw new InvalidOperationException(String.Format("InvalidData: {0}.{1}", e.Name, c.Name));
                        }
                        var cv = cvs.Single().Stem.Children.Single().Leaf;
                        try
                        {
                            var v = NumericStrings.InvariantParseFloat64(cv);
                            return(ColumnVal.CreatePrimitive(PrimitiveVal.CreateRealValue(v)));
                        }
                        catch (FormatException)
                        {
                            throw new InvalidOperationException(String.Format("InvalidData: {0}.{1} '{2}'", e.Name, c.Name, cv));
                        }
                    };
                }
                else if (TypeName.Equals("Binary", StringComparison.OrdinalIgnoreCase))
                {
                    Reader = TreeRow =>
                    {
                        var cvs = TreeRow.Stem.Children.Where(col => col.OnStem && col.Stem.Name.Equals(c.Name, StringComparison.OrdinalIgnoreCase)).ToList();
                        if (cvs.Count != 1)
                        {
                            throw new InvalidOperationException(String.Format("InvalidData: {0}.{1}", e.Name, c.Name));
                        }
                        var cv = cvs.Single().Stem.Children.Single().Leaf;
                        try
                        {
                            var v = Regex.Split(cv.Trim(" \t\r\n".ToCharArray()), "( |\t|\r|\n)+", RegexOptions.ExplicitCapture).Where(s => s != "").Select(s => Byte.Parse(s, System.Globalization.NumberStyles.HexNumber)).ToList();
                            return(ColumnVal.CreatePrimitive(PrimitiveVal.CreateBinaryValue(v)));
                        }
                        catch (FormatException)
                        {
                            throw new InvalidOperationException(String.Format("InvalidData: {0}.{1} '{2}'", e.Name, c.Name, cv));
                        }
                    };
                }
                else
                {
                    throw new InvalidOperationException("InvalidType: {0}".Formats(TypeName));
                }
            }
            else
            {
                if (TypeName.Equals("Boolean", StringComparison.OrdinalIgnoreCase))
                {
                    Reader = TreeRow =>
                    {
                        var cvs = TreeRow.Stem.Children.Where(col => col.OnStem && col.Stem.Name.Equals(c.Name, StringComparison.OrdinalIgnoreCase)).ToList();
                        if (cvs.Count != 1)
                        {
                            throw new InvalidOperationException(String.Format("InvalidData: {0}.{1}", e.Name, c.Name));
                        }
                        var cv = cvs.Single().Stem.Children.Single().Leaf;
                        if ((cv == null) || (cv == "-"))
                        {
                            return(ColumnVal.CreateOptional(Optional <PrimitiveVal> .Empty));
                        }
                        try
                        {
                            var v = Boolean.Parse(cv);
                            return(ColumnVal.CreateOptional(PrimitiveVal.CreateBooleanValue(v)));
                        }
                        catch (FormatException)
                        {
                            throw new InvalidOperationException(String.Format("InvalidData: {0}.{1} '{2}'", e.Name, c.Name, cv));
                        }
                    };
                }
                else if (TypeName.Equals("String", StringComparison.OrdinalIgnoreCase))
                {
                    Reader = TreeRow =>
                    {
                        var cvs = TreeRow.Stem.Children.Where(col => col.OnStem && col.Stem.Name.Equals(c.Name, StringComparison.OrdinalIgnoreCase)).ToList();
                        if (cvs.Count != 1)
                        {
                            throw new InvalidOperationException(String.Format("InvalidData: {0}.{1}", e.Name, c.Name));
                        }
                        var cv = cvs.Single().Stem.Children.Single().Leaf;
                        if ((cv == null) || (cv == "-"))
                        {
                            return(ColumnVal.CreateOptional(Optional <PrimitiveVal> .Empty));
                        }
                        var v = cv;
                        return(ColumnVal.CreateOptional(PrimitiveVal.CreateStringValue(v)));
                    };
                }
                else if (TypeName.Equals("Int", StringComparison.OrdinalIgnoreCase))
                {
                    if (EnumParser != null)
                    {
                        Reader = TreeRow =>
                        {
                            var cvs = TreeRow.Stem.Children.Where(col => col.OnStem && col.Stem.Name.Equals(c.Name, StringComparison.OrdinalIgnoreCase)).ToList();
                            if (cvs.Count != 1)
                            {
                                throw new InvalidOperationException(String.Format("InvalidData: {0}.{1}", e.Name, c.Name));
                            }
                            var cv = cvs.Single().Stem.Children.Single().Leaf;
                            if ((cv == null) || (cv == "-"))
                            {
                                return(ColumnVal.CreateOptional(Optional <PrimitiveVal> .Empty));
                            }
                            if (EnumParser.ContainsKey(cv))
                            {
                                var v = (int)(EnumParser[cv]);
                                return(ColumnVal.CreateOptional(PrimitiveVal.CreateIntValue(v)));
                            }
                            else
                            {
                                try
                                {
                                    var v = NumericStrings.InvariantParseInt32(cv);
                                    return(ColumnVal.CreateOptional(PrimitiveVal.CreateIntValue(v)));
                                }
                                catch (FormatException)
                                {
                                    throw new InvalidOperationException(String.Format("InvalidData: {0}.{1} '{2}'", e.Name, c.Name, cv));
                                }
                            }
                        };
                    }
                    else
                    {
                        Reader = TreeRow =>
                        {
                            var cvs = TreeRow.Stem.Children.Where(col => col.OnStem && col.Stem.Name.Equals(c.Name, StringComparison.OrdinalIgnoreCase)).ToList();
                            if (cvs.Count != 1)
                            {
                                throw new InvalidOperationException(String.Format("InvalidData: {0}.{1}", e.Name, c.Name));
                            }
                            var cv = cvs.Single().Stem.Children.Single().Leaf;
                            if ((cv == null) || (cv == "-"))
                            {
                                return(ColumnVal.CreateOptional(Optional <PrimitiveVal> .Empty));
                            }
                            try
                            {
                                var v = NumericStrings.InvariantParseInt32(cv);
                                return(ColumnVal.CreateOptional(PrimitiveVal.CreateIntValue(v)));
                            }
                            catch (FormatException)
                            {
                                throw new InvalidOperationException(String.Format("InvalidData: {0}.{1} '{2}'", e.Name, c.Name, cv));
                            }
                        };
                    }
                }
                else if (TypeName.Equals("Int64", StringComparison.OrdinalIgnoreCase))
                {
                    if (EnumParser != null)
                    {
                        Reader = TreeRow =>
                        {
                            var cvs = TreeRow.Stem.Children.Where(col => col.OnStem && col.Stem.Name.Equals(c.Name, StringComparison.OrdinalIgnoreCase)).ToList();
                            if (cvs.Count != 1)
                            {
                                throw new InvalidOperationException(String.Format("InvalidData: {0}.{1}", e.Name, c.Name));
                            }
                            var cv = cvs.Single().Stem.Children.Single().Leaf;
                            if ((cv == null) || (cv == "-"))
                            {
                                return(ColumnVal.CreateOptional(Optional <PrimitiveVal> .Empty));
                            }
                            if (EnumParser.ContainsKey(cv))
                            {
                                var v = (Int64)(EnumParser[cv]);
                                return(ColumnVal.CreateOptional(PrimitiveVal.CreateInt64Value(v)));
                            }
                            else
                            {
                                try
                                {
                                    var v = NumericStrings.InvariantParseInt64(cv);
                                    return(ColumnVal.CreateOptional(PrimitiveVal.CreateInt64Value(v)));
                                }
                                catch (FormatException)
                                {
                                    throw new InvalidOperationException(String.Format("InvalidData: {0}.{1} '{2}'", e.Name, c.Name, cv));
                                }
                            }
                        };
                    }
                    else
                    {
                        Reader = TreeRow =>
                        {
                            var cvs = TreeRow.Stem.Children.Where(col => col.OnStem && col.Stem.Name.Equals(c.Name, StringComparison.OrdinalIgnoreCase)).ToList();
                            if (cvs.Count != 1)
                            {
                                throw new InvalidOperationException(String.Format("InvalidData: {0}.{1}", e.Name, c.Name));
                            }
                            var cv = cvs.Single().Stem.Children.Single().Leaf;
                            if ((cv == null) || (cv == "-"))
                            {
                                return(ColumnVal.CreateOptional(Optional <PrimitiveVal> .Empty));
                            }
                            try
                            {
                                var v = NumericStrings.InvariantParseInt64(cv);
                                return(ColumnVal.CreateOptional(PrimitiveVal.CreateInt64Value(v)));
                            }
                            catch (FormatException)
                            {
                                throw new InvalidOperationException(String.Format("InvalidData: {0}.{1} '{2}'", e.Name, c.Name, cv));
                            }
                        };
                    }
                }
                else if (TypeName.Equals("Real", StringComparison.OrdinalIgnoreCase))
                {
                    Reader = TreeRow =>
                    {
                        var cvs = TreeRow.Stem.Children.Where(col => col.OnStem && col.Stem.Name.Equals(c.Name, StringComparison.OrdinalIgnoreCase)).ToList();
                        if (cvs.Count != 1)
                        {
                            throw new InvalidOperationException(String.Format("InvalidData: {0}.{1}", e.Name, c.Name));
                        }
                        var cv = cvs.Single().Stem.Children.Single().Leaf;
                        if ((cv == null) || (cv == "-"))
                        {
                            return(ColumnVal.CreateOptional(Optional <PrimitiveVal> .Empty));
                        }
                        try
                        {
                            var v = NumericStrings.InvariantParseFloat64(cv);
                            return(ColumnVal.CreateOptional(PrimitiveVal.CreateRealValue(v)));
                        }
                        catch (FormatException)
                        {
                            throw new InvalidOperationException(String.Format("InvalidData: {0}.{1} '{2}'", e.Name, c.Name, cv));
                        }
                    };
                }
                else if (TypeName.Equals("Binary", StringComparison.OrdinalIgnoreCase))
                {
                    Reader = TreeRow =>
                    {
                        var cvs = TreeRow.Stem.Children.Where(col => col.OnStem && col.Stem.Name.Equals(c.Name, StringComparison.OrdinalIgnoreCase)).ToList();
                        if (cvs.Count != 1)
                        {
                            throw new InvalidOperationException(String.Format("InvalidData: {0}.{1}", e.Name, c.Name));
                        }
                        var cv = cvs.Single().Stem.Children.Single().Leaf;
                        if ((cv == null) || (cv == "-"))
                        {
                            return(ColumnVal.CreateOptional(Optional <PrimitiveVal> .Empty));
                        }
                        try
                        {
                            var v = Regex.Split(cv.Trim(" \t\r\n".ToCharArray()), "( |\t|\r|\n)+", RegexOptions.ExplicitCapture).Select(s => Byte.Parse(s, System.Globalization.NumberStyles.HexNumber)).ToList();
                            return(ColumnVal.CreateOptional(PrimitiveVal.CreateBinaryValue(v)));
                        }
                        catch (FormatException)
                        {
                            throw new InvalidOperationException(String.Format("InvalidData: {0}.{1} '{2}'", e.Name, c.Name, cv));
                        }
                    };
                }
                else
                {
                    throw new InvalidOperationException("InvalidType: {0}".Formats(TypeName));
                }
            }
            return(Reader);
        }
Пример #2
0
        private Func <IReadableStream, ColumnVal> GetColumnReader(VariableDef c)
        {
            String  TypeName;
            Boolean IsOptional;

            if (c.Type.OnTypeRef)
            {
                TypeName   = c.Type.TypeRef.Value;
                IsOptional = false;
            }
            else if (c.Type.OnOptional)
            {
                TypeName   = c.Type.Optional.Value;
                IsOptional = true;
            }
            else if (c.Type.OnList)
            {
                var ElementTypeName = c.Type.List.Value;
                if (!ElementTypeName.Equals("Byte", StringComparison.OrdinalIgnoreCase))
                {
                    throw new InvalidOperationException("InvalidColumnListType: List<{0}>".Formats(ElementTypeName));
                }

                TypeName   = "Binary";
                IsOptional = false;
            }
            else
            {
                throw new InvalidOperationException();
            }
            if (EnumUnderlyingTypes.ContainsKey(TypeName))
            {
                TypeName = EnumUnderlyingTypes[TypeName];
            }

            Func <IReadableStream, ColumnVal> Reader;

            if (!IsOptional)
            {
                if (TypeName.Equals("Boolean", StringComparison.OrdinalIgnoreCase))
                {
                    Reader = s => ColumnVal.CreatePrimitive(PrimitiveVal.CreateBooleanValue(s.ReadByte() != 0));
                }
                else if (TypeName.Equals("String", StringComparison.OrdinalIgnoreCase))
                {
                    Reader = s =>
                    {
                        var NumBytes = s.ReadInt32();
                        var Bytes    = s.Read(NumBytes);
                        var t        = TextEncoding.UTF16.GetString(Bytes);
                        return(ColumnVal.CreatePrimitive(PrimitiveVal.CreateStringValue(t)));
                    };
                }
                else if (TypeName.Equals("Int", StringComparison.OrdinalIgnoreCase))
                {
                    Reader = s => ColumnVal.CreatePrimitive(PrimitiveVal.CreateIntValue(s.ReadInt32()));
                }
                else if (TypeName.Equals("Int64", StringComparison.OrdinalIgnoreCase))
                {
                    Reader = s => ColumnVal.CreatePrimitive(PrimitiveVal.CreateInt64Value(s.ReadInt64()));
                }
                else if (TypeName.Equals("Real", StringComparison.OrdinalIgnoreCase))
                {
                    Reader = s => ColumnVal.CreatePrimitive(PrimitiveVal.CreateRealValue(s.ReadFloat64()));
                }
                else if (TypeName.Equals("Binary", StringComparison.OrdinalIgnoreCase))
                {
                    Reader = s =>
                    {
                        var NumBytes = s.ReadInt32();
                        var Bytes    = s.Read(NumBytes);
                        return(ColumnVal.CreatePrimitive(PrimitiveVal.CreateBinaryValue(Bytes.ToList())));
                    };
                }
                else
                {
                    throw new InvalidOperationException("InvalidType: {0}".Formats(TypeName));
                }
            }
            else
            {
                if (TypeName.Equals("Boolean", StringComparison.OrdinalIgnoreCase))
                {
                    Reader = s =>
                    {
                        var OnSome = s.ReadInt32() != 0;
                        if (OnSome)
                        {
                            return(ColumnVal.CreateOptional(PrimitiveVal.CreateBooleanValue(s.ReadByte() != 0)));
                        }
                        else
                        {
                            return(ColumnVal.CreateOptional(Optional <PrimitiveVal> .Empty));
                        }
                    };
                }
                else if (TypeName.Equals("String", StringComparison.OrdinalIgnoreCase))
                {
                    Reader = s =>
                    {
                        var OnSome = s.ReadInt32() != 0;
                        if (OnSome)
                        {
                            var NumBytes = s.ReadInt32();
                            var Bytes    = s.Read(NumBytes);
                            var t        = TextEncoding.UTF16.GetString(Bytes);
                            return(ColumnVal.CreateOptional(PrimitiveVal.CreateStringValue(t)));
                        }
                        else
                        {
                            return(ColumnVal.CreateOptional(Optional <PrimitiveVal> .Empty));
                        }
                    };
                }
                else if (TypeName.Equals("Int", StringComparison.OrdinalIgnoreCase))
                {
                    Reader = s =>
                    {
                        var OnSome = s.ReadInt32() != 0;
                        if (OnSome)
                        {
                            return(ColumnVal.CreateOptional(PrimitiveVal.CreateIntValue(s.ReadInt32())));
                        }
                        else
                        {
                            return(ColumnVal.CreateOptional(Optional <PrimitiveVal> .Empty));
                        }
                    };
                }
                else if (TypeName.Equals("Int64", StringComparison.OrdinalIgnoreCase))
                {
                    Reader = s =>
                    {
                        var OnSome = s.ReadInt32() != 0;
                        if (OnSome)
                        {
                            return(ColumnVal.CreateOptional(PrimitiveVal.CreateInt64Value(s.ReadInt64())));
                        }
                        else
                        {
                            return(ColumnVal.CreateOptional(Optional <PrimitiveVal> .Empty));
                        }
                    };
                }
                else if (TypeName.Equals("Real", StringComparison.OrdinalIgnoreCase))
                {
                    Reader = s =>
                    {
                        var OnSome = s.ReadInt32() != 0;
                        if (OnSome)
                        {
                            return(ColumnVal.CreateOptional(PrimitiveVal.CreateRealValue(s.ReadFloat64())));
                        }
                        else
                        {
                            return(ColumnVal.CreateOptional(Optional <PrimitiveVal> .Empty));
                        }
                    };
                }
                else if (TypeName.Equals("Binary", StringComparison.OrdinalIgnoreCase))
                {
                    Reader = s =>
                    {
                        var OnSome = s.ReadInt32() != 0;
                        if (OnSome)
                        {
                            var NumBytes = s.ReadInt32();
                            var Bytes    = s.Read(NumBytes);
                            return(ColumnVal.CreateOptional(PrimitiveVal.CreateBinaryValue(Bytes.ToList())));
                        }
                        else
                        {
                            return(ColumnVal.CreateOptional(Optional <PrimitiveVal> .Empty));
                        }
                    };
                }
                else
                {
                    throw new InvalidOperationException("InvalidType: {0}".Formats(TypeName));
                }
            }
            return(Reader);
        }