Ejemplo n.º 1
0
        /// <summary>
        /// Initializes a new instance of the <see cref="YamlDocument"/> class.
        /// </summary>
        internal YamlDocument(IParser parser)
        {
            var state = new DocumentLoadingState();

            parser.Consume <DocumentStart>();

            while (!parser.TryConsume <DocumentEnd>(out var _))
            {
                Debug.Assert(RootNode == null);
                RootNode = YamlNode.ParseNode(parser, state);

                if (RootNode is YamlAliasNode)
                {
                    throw new YamlException("A document cannot contain only an alias");
                }
            }

            state.ResolveAliases();

            // Throw should not happen unless the parser has a bug
            RootNode = RootNode ?? throw new ArgumentException("Atempted to parse an empty document");
        }
Ejemplo n.º 2
0
        public IExpression Parse(TextSpan token, IParser parser)
        {
            parser.ConsumeToken(SqlToken.Next);
            parser.ConsumeToken(SqlToken.From);

            var cursorName = parser.ConsumeTableName();

            parser.ConsumeToken(SqlToken.Into);
            var variableNameList = new List <SqlCodeExpr>();

            do
            {
                var variableName = parser.Consume(SqlToken.Variable);
                variableNameList.Add(variableName);
            } while (parser.MatchToken(SqlToken.Comma));

            return(new FetchSqlCodeExpr
            {
                CursorName = cursorName,
                VariableNameList = variableNameList
            });
        }
    public object?ReadYaml(IParser parser, Type type)
    {
        type = Nullable.GetUnderlyingType(type) ??
               throw new ArgumentException("Expected nullable enum type for ReadYaml");

        if (parser.Accept <NodeEvent>(out var @event) && NodeIsNull(@event))
        {
            parser.SkipThisAndNestedEvents();
            return(null);
        }

        var scalar = parser.Consume <Scalar>();

        try
        {
            return(Enum.Parse(type, scalar.Value, true));
        }
        catch (Exception ex)
        {
            throw new YamlException($"Invalid value: \"{scalar.Value}\" for {type.Name}", ex);
        }
    }
Ejemplo n.º 4
0
        bool INodeDeserializer.Deserialize(IParser parser, Type expectedType, Func <IParser, Type, object?> nestedObjectDeserializer, out object?value)
        {
            if (!parser.TryConsume <MappingStart>(out var mapping))
            {
                value = null;
                return(false);
            }

            value = objectFactory.Create(expectedType);
            while (!parser.TryConsume <MappingEnd>(out var _))
            {
                var propertyName = parser.Consume <Scalar>();
                var property     = typeDescriptor.GetProperty(expectedType, null, propertyName.Value, ignoreUnmatched);
                if (property == null)
                {
                    parser.SkipThisAndNestedEvents();
                    continue;
                }

                var propertyValue = nestedObjectDeserializer(parser, property.Type);
                if (propertyValue is IValuePromise propertyValuePromise)
                {
                    var valueRef = value;
                    propertyValuePromise.ValueAvailable += v =>
                    {
                        var convertedValue = TypeConverter.ChangeType(v, property.Type);
                        property.Write(valueRef, convertedValue);
                    };
                }
                else
                {
                    var convertedValue = TypeConverter.ChangeType(propertyValue, property.Type);
                    property.Write(value, convertedValue);
                }
            }

            return(true);
        }
Ejemplo n.º 5
0
        public bool Deserialize(IParser reader, Type expectedType, Func <IParser, Type, object?> nestedObjectDeserializer, out object?value)
        {
            value = default;
            if (expectedType != typeof(VariableParameter) && expectedType != typeof(ExpressionParameter))
            {
                return(false);
            }

            var argument = reader.Consume <Scalar>();

            if (expectedType == typeof(VariableParameter))
            {
                value = new VariableParameter(argument.Value);
            }
            else if (expectedType == typeof(ExpressionParameter))
            {
                value = new ExpressionParameter(argument.Value);
            }
            else
            {
                return(false);
            }
            return(true);
        }
        public object ReadYaml(IParser parser, Type type)
        {
            var currentAsScalar   = parser.Current as Scalar;
            var currentAsSequence = parser.Current as SequenceStart;
            var currentAsMapping  = parser.Current as MappingStart;

            if (currentAsScalar != null)
            {
                return(bool.Parse(parser.Consume <Scalar>().Value));
            }
            else if (currentAsSequence != null)
            {
                return(YamlRead.Deserializer.Deserialize <List <UnittestSpec> >(parser));
            }
            else if (currentAsMapping != null)
            {
                return(new List <UnittestSpec>()
                {
                    YamlRead.Deserializer.Deserialize <UnittestSpec>(parser)
                });
            }

            throw new NotImplementedException();
        }
Ejemplo n.º 7
0
 public object?ReadYaml(IParser parser, Type type) => (IntstrIntOrString)parser.Consume <Scalar>().Value;
Ejemplo n.º 8
0
        public object ReadYaml(IParser parser, Type type)
        {
            string   clientId = null, username = null, pwd = null, broker = null;
            int?     port = null, retriesCount = null;
            TimeSpan?retriesInterval = null;

            if (!parser.TryConsume <MappingStart>(out _))
            {
                throw new InvalidOperationException("Unexpected token received from the parser!");
            }

            while (!parser.TryConsume <MappingEnd>(out _))
            {
                var propertyName = parser.Consume <Scalar>();
                switch (propertyName.Value)
                {
                case "client_id":
                    clientId = parser.Consume <Scalar>().Value;
                    break;

                case "user":
                    username = parser.Consume <Scalar>().Value;
                    break;

                case "password":
                    pwd = parser.Consume <Scalar>().Value;
                    break;

                case "broker":
                    broker = parser.Consume <Scalar>().Value;
                    break;

                case "port":
                    port = int.TryParse(parser.Consume <Scalar>().Value, out var p)
                            ? p
                            : throw new InvalidOperationException("Unable to build MQTT configuration - invalid port given!");
                    break;

                case "retries_interval":
                    retriesInterval = TimeSpan.TryParse(parser.Consume <Scalar>().Value, out var t)
                            ? t
                            : throw new InvalidOperationException("Unable to build MQTT configuration - invalid retries_interval given!");
                    break;

                case "retries_count":
                    retriesCount = int.TryParse(parser.Consume <Scalar>().Value, out var c)
                            ? c
                            : throw new InvalidOperationException("Unable to build MQTT configuration - invalid retries_count given!");
                    break;
                }
            }

            if (string.IsNullOrEmpty(clientId))
            {
                throw new InvalidOperationException("Unable to build MQTT configuration - client_id is not provided!");
            }
            if (string.IsNullOrEmpty(username))
            {
                throw new InvalidOperationException("Unable to build MQTT configuration - user is not provided!");
            }
            if (string.IsNullOrEmpty(pwd))
            {
                throw new InvalidOperationException("Unable to build MQTT configuration - password is not provided!");
            }
            if (string.IsNullOrEmpty(broker))
            {
                throw new InvalidOperationException("Unable to build MQTT configuration - broker is not provided!");
            }

            var client = new MqttClientOptionsBuilder()
                         .WithClientId(clientId)
                         .WithTcpServer(broker, port)
                         .WithCredentials(username, pwd)
                         .Build();

            if (retriesCount.HasValue && !retriesInterval.HasValue)
            {
                throw new InvalidOperationException("Unable to build MQTT configuration! - retries_interval provided without retries_count!");
            }
            if (!retriesCount.HasValue && retriesInterval.HasValue)
            {
                throw new InvalidOperationException("Unable to build MQTT configuration! - retries_count provided without retries_interval!");
            }
            if (retriesCount <= 0)
            {
                throw new InvalidOperationException("Unable to build MQTT configuration! - retries_count invalid retries_count given!");
            }

            return(new MqttOptions(client, new RetryOptions(retriesInterval, (uint)(retriesCount ?? DefaultRetriesCount))));
        }
Ejemplo n.º 9
0
        internal static Ingredient Parse(IParser parser)
        {
            parser.Consume <MappingStart>();

            string     name       = parser.Consume <Scalar>().Value;
            Ingredient ingredient = new Ingredient(name);

            bool HasMappingStart = parser.TryConsume <MappingStart>(out _);

            do
            {
                Scalar next = parser.Consume <Scalar>();
                if (next.Value == "usda_num")
                {
                    ingredient.USDA = parser.Consume <Scalar>().Value;
                }
                else if (next.Value == "amounts")
                {
                    parser.Consume <SequenceStart>();
                    do
                    {
                        ingredient.Amounts.Add(Amount.Parse(parser));
                    }while (parser.TryConsume <SequenceEnd>(out _) == false);
                }
                else if (next.Value == "substitutions")
                {
                    parser.Consume <SequenceStart>();
                    do
                    {
                        ingredient.Substitutions.Add(Ingredient.Parse(parser));
                    }while (parser.TryConsume <SequenceEnd>(out _) == false);
                }
                else if (next.Value == "notes")
                {
                    parser.Consume <SequenceStart>();
                    do
                    {
                        ingredient.Notes.Add(parser.Consume <Scalar>().Value);
                    }while (parser.TryConsume <SequenceEnd>(out _) == false);
                }
                else if (next.Value == "processing")
                {
                    parser.Consume <SequenceStart>();
                    do
                    {
                        ingredient.Processing.Add(parser.Consume <Scalar>().Value);
                    }while (parser.TryConsume <SequenceEnd>(out _) == false);
                }
            } while (parser.TryConsume <MappingEnd>(out _) == false);

            if (HasMappingStart)
            {
                parser.Consume <MappingEnd>();
            }

            return(ingredient);
        }
 /// <inheritdoc />
 public object ReadYaml(IParser parser, Type type) =>
 Double.TryParse(parser.Consume <Scalar>()?.Value, out var value)
     ? value as object
     : null;
Ejemplo n.º 11
0
            public bool Deserialize(IParser parser, Type expectedType, Func <IParser, Type, object> nestedObjectDeserializer, out object value)
            {
                value = null;
                if (!typeof(ManagedGameObject).IsAssignableFrom(expectedType) || !parser.TryConsume(out MappingStart _))
                {
                    return(false);
                }
                bool findType = false;

                MappingEnd event2;

                Scalar scalar = parser.Consume <Scalar>();

                if (scalar.Value == "MGO.Type")
                {
                    string i = nestedObjectDeserializer(parser, typeof(string)) as string;
                    expectedType = TypeByName(i);
#if DEBUG
                    debugLogger.Start("Deserialize");

                    debugLogger.WriteLine($"nestedObjectDeserializer : { i }");
                    debugLogger.WriteLine($"expectedType : { expectedType }");

                    debugLogger.End();
#endif
                    if (expectedType == null)
                    {
                        findType = false;
                    }
                    else
                    {
                        value    = objectFactory.Create(expectedType);
                        findType = true;
                    }
                }

                while (!parser.TryConsume(out event2))
                {
                    scalar = parser.Consume <Scalar>();
                    IPropertyDescriptor property = typeDescriptor.GetProperty(expectedType, null, scalar.Value, false);
                    if (property == null || !findType)
                    {
                        parser.SkipThisAndNestedEvents();
                        continue;
                    }

                    object        obj          = nestedObjectDeserializer(parser, property.Type);
                    IValuePromise valuePromise = obj as IValuePromise;
                    if (valuePromise != null)
                    {
                        object valueRef = value;
                        valuePromise.ValueAvailable += (Action <object>) delegate(object v)
                        {
                            object value3 = YamlDotNet.Serialization.Utilities.
                                            TypeConverter.ChangeType(v, property.Type);
                            property.Write(valueRef, value3);
                        };
                    }
                    else
                    {
                        object value2 = YamlDotNet.Serialization.Utilities.
                                        TypeConverter.ChangeType(obj, property.Type);
                        property.Write(value, value2);
                    }
                }
                return(true);
            }
Ejemplo n.º 12
0
        public object ReadYaml(IParser parser, Type type)
        {
            string s = parser.Consume <Scalar>().Value;

            return(new Secret(s.Sha256()));
        }
Ejemplo n.º 13
0
        public object ReadYaml(IParser parser, Type type)
        {
            var value = parser.Consume <Scalar>().Value;

            return(new Guid(value));
        }
Ejemplo n.º 14
0
        public void Read(IParser parser, Type expectedType, ObjectDeserializer nestedObjectDeserializer)
        {
            if (!parser.TryConsume <MappingStart>(out var mapping))
            {
                throw new SerializationException("Invalid varvalue");
            }

            if (parser.TryConsume <MappingEnd>(out var _))
            {
                throw new SerializationException("Invalid varvalue");
            }

            var propertyName1 = parser.Consume <Scalar>().Value;

            if (propertyName1 != "type")
            {
                throw new SerializationException("Invalid varvalue: expected type");
            }

            var propertyValue1 = (string)nestedObjectDeserializer(typeof(string));

            if (parser.TryConsume <MappingEnd>(out var _))
            {
                throw new SerializationException("Invalid varvalue");
            }

            var propertyName2 = parser.Consume <Scalar>().Value;

            if (propertyName2 != "value")
            {
                throw new SerializationException("Invalid varvalue: expected value");
            }

            // TODO: Add more type conversions!
            switch (propertyValue1)
            {
            case "string":
            {
                type      = new TypeDefinition();
                type.Name = "value";
                type.Type = DataTypes.string_t;
                value     = (string)nestedObjectDeserializer(typeof(string));
                break;
            }

            case "double":
            {
                type      = new TypeDefinition();
                type.Name = "value";
                type.Type = DataTypes.double_t;
                value     = (double)nestedObjectDeserializer(typeof(double));
                break;
            }

            case "int32":
            {
                type      = new TypeDefinition();
                type.Name = "value";
                type.Type = DataTypes.int32_t;
                value     = (int)nestedObjectDeserializer(typeof(int));
                break;
            }

            case "uint32":
            {
                type      = new TypeDefinition();
                type.Name = "value";
                type.Type = DataTypes.uint32_t;
                value     = (uint)nestedObjectDeserializer(typeof(uint));
                break;
            }

            case "double[]":
            {
                type           = new TypeDefinition();
                type.Name      = "value";
                type.Type      = DataTypes.double_t;
                type.ArrayType = DataTypes_ArrayTypes.array;
                value          = (double[])nestedObjectDeserializer(typeof(double[]));
                break;
            }

            case "int32[]":
            {
                type           = new TypeDefinition();
                type.Name      = "value";
                type.Type      = DataTypes.int32_t;
                type.ArrayType = DataTypes_ArrayTypes.array;
                value          = (int[])nestedObjectDeserializer(typeof(int[]));
                break;
            }

            case "uint32[]":
            {
                type           = new TypeDefinition();
                type.Name      = "value";
                type.Type      = DataTypes.uint32_t;
                type.ArrayType = DataTypes_ArrayTypes.array;
                value          = (uint[])nestedObjectDeserializer(typeof(uint[]));
                break;
            }

            default:
                throw new SerializationException($"Invalid varvalue: unknown type {propertyValue1}");
            }

            if (!parser.TryConsume <MappingEnd>(out var _))
            {
                throw new SerializationException("Invalid varvalue, extra fields found");
            }
        }
Ejemplo n.º 15
0
 public object ReadYaml(IParser parser, Type type)
 {
     return(new Version(parser.Consume <Scalar>().Value));
 }
Ejemplo n.º 16
0
        public object ReadYaml(IParser parser, Type type)
        {
            var scalar = parser.Consume <Scalar>().Value;

            return(ParseScalar(scalar, type));
        }
        public object?ReadYaml(IParser parser, Type type)
        {
            var value = parser.Consume <Scalar>().Value;

            return(_translate[value]);
        }
Ejemplo n.º 18
0
        public object ReadYaml(IParser parser, Type type)
        {
            var parsedValue = parser.Consume <Scalar>().Value;

            return(new DateTimeOrDays(parsedValue));
        }
Ejemplo n.º 19
0
        public object ReadYaml(IParser parser, Type type)
        {
            var value = parser.Consume <Scalar>().Value;

            return(Type.GetType(value, throwOnError: true) !); // Will throw instead of returning null
        }
Ejemplo n.º 20
0
        public object ReadYaml(IParser parser, Type type)
        {
            var value = parser.Consume <Scalar>().Value;

            return(TimeSpan.FromSeconds(double.Parse(value, CultureInfo.InvariantCulture)));
        }
Ejemplo n.º 21
0
        public static (List <ASTError>, ASTType) Parse(IParser parser, List <ASTAnnotation> annotations, List <ASTDirective> directives)
        {
            ASTType result = new ASTType();

            try
            {
                List <ASTError> errors = new List <ASTError>();

                result.Annotations = annotations;
                result.Directives  = directives;

                parser.Next();
                result.Name       = parser.Consume(TokenType.Identifier).Value;
                result.Parameters =
                    parser
                    .ConsumeWhile(TokenType.GenericParameter)
                    .Select(v => v.Value)
                    .ToList();


                /*
                 * If there is an 'extends' extension.
                 */
                var extends = parser.TryConsume(TokenType.KW_Extends);
                if (!(extends is null))
                {
                    result.Extensions =
                        parser
                        .ConsumeWhile(TokenType.Identifier)
                        .Select(v => v.Value)
                        .ToList();
                }


                /*
                 * If there is an '=' sign we know that there will be
                 * Fields which we can parse...
                 */
                var equals = parser.TryConsume(TokenType.Equal);
                if (!(equals is null))
                {
                    List <ASTTypeField> fields = new List <ASTTypeField>();
                    while (parser.TryConsume(TokenType.ContextEnded) == null)
                    {
                        fields.Add(ASTTypeField.Parse(parser));
                    }
                    result.Fields = fields;
                    if (fields.Count == 0)
                    {
                        if (parser.Current.TokenType == TokenType.Paragraph)
                        {
                            var nextPhrase = parser.Current.Value;
                            errors.Add(new ASTError($@"
Missing type body. If you use an '=' sign you should have at least one field.
It might be that you are missing an indentation:

type {result.Name} =
{nextPhrase}

Example:
type {result.Name} =
    {nextPhrase}
", parser.Current));
                        }
                        else
                        {
                            errors.Add(new ASTError($@"
Missing type body. If you use an '=' sign you should have at least one field.", parser.Current));
                        }
                    }
                }

                return(errors, result);
            }
            catch (InvalidTokenException ex)
            {
                return(new List <ASTError>
                {
                    new ASTError(ex.Message, parser.Current)
                }, result);
            }
        }
        public object ReadYaml(IParser parser, Type type)
        {
            var env = new InternalEnvironmentVariables();

            parser.Consume <MappingStart>();

            do
            {
                parser.Accept <Scalar>(out var scalar);

                if (scalar != null)
                {
                    if (scalar.Value == "global")
                    {
                        // discard "global" value itself
                        parser.Consume <Scalar>();

                        // read global variables (common to all matrix items)
                        parser.Consume <MappingStart>();

                        do
                        {
                            env.InternalCommonVariables.Add(_deserializer.Deserialize <InternalVariable>(parser));
                        } while (!parser.Accept <MappingEnd>(out _));

                        parser.Consume <MappingEnd>();
                    }
                    else if (scalar.Value == "matrix")
                    {
                        // discard "matrix" value itself
                        parser.Consume <Scalar>();

                        // discard SequenceStart
                        parser.Consume <SequenceStart>();

                        do
                        {
                            var matrixItemVariables = new List <InternalVariable>();

                            parser.Consume <MappingStart>();

                            do
                            {
                                matrixItemVariables.Add(_deserializer.Deserialize <InternalVariable>(parser));
                            } while (!parser.Accept <MappingEnd>(out _));

                            parser.Consume <MappingEnd>();

                            env.InternalMatrix.Add(matrixItemVariables.AsReadOnly());
                        } while (!parser.Accept <SequenceEnd>(out _));

                        parser.Consume <SequenceEnd>();
                    }
                    else
                    {
                        var variable = _deserializer.Deserialize <InternalVariable>(parser);
                        env.InternalCommonVariables.Add(variable);
                    }
                }
            } while (!parser.Accept <MappingEnd>(out _));

            parser.Consume <MappingEnd>();

            return(env);
        }