Clear() public method

Clears the list of elements inside this HoconValue.
public Clear ( ) : void
return void
Esempio n. 1
0
        private void ParseKeyContent(HoconValue value, string currentPath)
        {
            while (!_reader.EoF)
            {
                Token t = _reader.PullNext();
                switch (t.Type)
                {
                case TokenType.Dot:
                    ParseObject(value, false, currentPath);
                    return;

                case TokenType.Assign:

                    if (!value.IsObject())
                    {
                        //if not an object, then replace the value.
                        //if object. value should be merged
                        value.Clear();
                    }
                    ParseValue(value, currentPath);
                    return;

                case TokenType.ObjectStart:
                    ParseObject(value, true, currentPath);
                    return;
                }
            }
        }
Esempio n. 2
0
        public void ParseValue(HoconValue owner)
        {
            if (reader.EoF)
            {
                throw new Exception("End of file reached while trying to read a value");
            }

            bool isObject = owner.IsObject();

            reader.PullWhitespaceAndComments();
            while (reader.IsValue())
            {
                Token t = reader.PullValue();

                switch (t.Type)
                {
                case TokenType.EoF:
                    break;

                case TokenType.LiteralValue:
                    if (isObject)
                    {
                        //needed to allow for override objects
                        isObject = false;
                        owner.Clear();
                    }
                    var lit = new HoconLiteral
                    {
                        Value = t.Value
                    };
                    owner.AppendValue(lit);

                    break;

                case TokenType.ObjectStart:
                    ParseObject(owner, true);
                    break;

                case TokenType.ArrayStart:
                    HoconArray arr = ParseArray();
                    owner.AppendValue(arr);
                    break;

                case TokenType.Substitute:
                    HoconSubstitution sub = ParseSubstitution(t.Value);
                    substitutions.Add(sub);
                    owner.AppendValue(sub);
                    break;
                }
                if (reader.IsSpaceOrTab())
                {
                    ParseTrailingWhitespace(owner);
                }
            }

            IgnoreComma();
        }
Esempio n. 3
0
        private void ParseKeyContent(HoconValue value, string currentPath)
        {
            try
            {
                var last = currentPath.Split('.').Last();
                PushDiagnostics(string.Format("{0} = ", last));
                while (!_reader.EoF)
                {
                    Token t = _reader.PullNext();
                    switch (t.Type)
                    {
                    case TokenType.Dot:
                        ParseObject(value, false, currentPath);
                        return;

                    case TokenType.Assign:

                        if (!value.IsObject())
                        {
                            //if not an object, then replace the value.
                            //if object. value should be merged
                            value.Clear();
                        }
                        ParseValue(value, currentPath);
                        return;

                    case TokenType.ObjectStart:
                        ParseObject(value, true, currentPath);
                        return;
                    }
                }
            }
            finally
            {
                PopDiagnostics();
            }
        }
Esempio n. 4
0
        /// <summary>
        /// Retrieves the next value token from the tokenizer and appends it
        /// to the supplied element <paramref name="owner"/>.
        /// </summary>
        /// <param name="owner">The element to append the next token.</param>
        /// <exception cref="System.Exception">End of file reached while trying to read a value</exception>
        public void ParseValue(HoconValue owner,string currentPath)
        {
            if (_reader.EoF)
                throw new Exception("End of file reached while trying to read a value");

            _reader.PullWhitespaceAndComments();
            while (_reader.IsValue())
            {
                Token t = _reader.PullValue();

                switch (t.Type)
                {
                    case TokenType.EoF:
                        break;
                    case TokenType.LiteralValue:
                        if (owner.IsObject())
                        {
                            //needed to allow for override objects
                            owner.Clear();
                        }
                        var lit = new HoconLiteral
                        {
                            Value = t.Value
                        };
                        owner.AppendValue(lit);

                        break;
                    case TokenType.ObjectStart:
                        ParseObject(owner, true,currentPath);
                        break;
                    case TokenType.ArrayStart:
                        HoconArray arr = ParseArray(currentPath);
                        owner.AppendValue(arr);
                        break;
                    case TokenType.Substitute:
                        HoconSubstitution sub = ParseSubstitution(t.Value);
                        _substitutions.Add(sub);
                        owner.AppendValue(sub);
                        break;
                }
                if (_reader.IsSpaceOrTab())
                {
                    ParseTrailingWhitespace(owner);
                }
            }

            IgnoreComma();
        }
Esempio n. 5
0
 private void ParseKeyContent(HoconValue value,string currentPath)
 {
     while (!_reader.EoF)
     {
         Token t = _reader.PullNext();
         switch (t.Type)
         {
             case TokenType.Dot:
                 ParseObject(value, false,currentPath);
                 return;
             case TokenType.Assign:
                 
                 if (!value.IsObject())
                 {
                     //if not an object, then replace the value.
                     //if object. value should be merged
                     value.Clear();
                 }
                 ParseValue(value,currentPath);
                 return;
             case TokenType.ObjectStart:
                 ParseObject(value, true,currentPath);
                 return;
         }
     }
 }
Esempio n. 6
0
        /// <summary>
        /// Retrieves the next value token from the tokenizer and appends it
        /// to the supplied element <paramref name="owner"/>.
        /// </summary>
        /// <param name="owner">The element to append the next token.</param>
        /// <exception cref="System.Exception">End of file reached while trying to read a value</exception>
        public void ParseValue(HoconValue owner,string currentPath)
        {
            if (_reader.EoF)
                throw new HoconParserException("End of file reached while trying to read a value");

            _reader.PullWhitespaceAndComments();
            var start = _reader.Index;
            try
            {
                while (_reader.IsValue())
                {
                    Token t = _reader.PullValue();

                    switch (t.Type)
                    {
                        case TokenType.EoF:
                            break;
                        case TokenType.LiteralValue:
                            if (owner.IsObject())
                            {
                                //needed to allow for override objects
                                owner.Clear();
                            }
                            var lit = new HoconLiteral
                            {
                                Value = t.Value
                            };
                            owner.AppendValue(lit);

                            break;
                        case TokenType.ObjectStart:
                            ParseObject(owner, true, currentPath);
                            break;
                        case TokenType.ArrayStart:
                            HoconArray arr = ParseArray(currentPath);
                            owner.AppendValue(arr);
                            break;
                        case TokenType.Substitute:
                            HoconSubstitution sub = ParseSubstitution(t.Value);
                            _substitutions.Add(sub);
                            owner.AppendValue(sub);
                            break;
                    }
                    if (_reader.IsSpaceOrTab())
                    {
                        ParseTrailingWhitespace(owner);
                    }
                }

                IgnoreComma();
            }
            catch(HoconTokenizerException tokenizerException)
            {
                throw new HoconParserException(string.Format("{0}\r{1}", tokenizerException.Message, GetDiagnosticsStackTrace()),tokenizerException);
            }
            finally
            {
                //no value was found, tokenizer is still at the same position
                if (_reader.Index == start)
                {
                    throw new HoconParserException(string.Format("Hocon syntax error {0}\r{1}",_reader.GetHelpTextAtIndex(start),GetDiagnosticsStackTrace()));
                }
            }
        }
Esempio n. 7
0
        private void ParseKeyContent(HoconValue value,string currentPath)
        {
            try
            {
                var last = currentPath.Split('.').Last();
                PushDiagnostics(string.Format("{0} = ", last));
                while (!_reader.EoF)
                {
                    Token t = _reader.PullNext();
                    switch (t.Type)
                    {
                        case TokenType.Dot:
                            ParseObject(value, false, currentPath);
                            return;
                        case TokenType.Assign:

                            if (!value.IsObject())
                            {
                                //if not an object, then replace the value.
                                //if object. value should be merged
                                value.Clear();
                            }
                            ParseValue(value, currentPath);
                            return;
                        case TokenType.ObjectStart:
                            ParseObject(value, true, currentPath);
                            return;
                    }
                }
            }
            finally
            {
                PopDiagnostics();
            }
        }
Esempio n. 8
0
        /// <summary>
        /// Retrieves the next value token from the tokenizer and appends it
        /// to the supplied element <paramref name="owner"/>.
        /// </summary>
        /// <param name="owner">The element to append the next token.</param>
        /// <exception cref="System.Exception">End of file reached while trying to read a value</exception>
        public void ParseValue(HoconValue owner, string currentPath)
        {
            if (_reader.EoF)
            {
                throw new HoconParserException("End of file reached while trying to read a value");
            }

            _reader.PullWhitespaceAndComments();
            var start = _reader.Index;

            try
            {
                while (_reader.IsValue())
                {
                    Token t = _reader.PullValue();

                    switch (t.Type)
                    {
                    case TokenType.EoF:
                        break;

                    case TokenType.LiteralValue:
                        if (owner.IsObject())
                        {
                            //needed to allow for override objects
                            owner.Clear();
                        }
                        var lit = new HoconLiteral
                        {
                            Value = t.Value
                        };
                        owner.AppendValue(lit);

                        break;

                    case TokenType.ObjectStart:
                        ParseObject(owner, true, currentPath);
                        break;

                    case TokenType.ArrayStart:
                        HoconArray arr = ParseArray(currentPath);
                        owner.AppendValue(arr);
                        break;

                    case TokenType.Substitute:
                        HoconSubstitution sub = ParseSubstitution(t.Value);
                        _substitutions.Add(sub);
                        owner.AppendValue(sub);
                        break;
                    }
                    if (_reader.IsSpaceOrTab())
                    {
                        ParseTrailingWhitespace(owner);
                    }
                }

                IgnoreComma();
            }
            catch (HoconTokenizerException tokenizerException)
            {
                throw new HoconParserException(string.Format("{0}\r{1}", tokenizerException.Message, GetDiagnosticsStackTrace()), tokenizerException);
            }
            finally
            {
                //no value was found, tokenizer is still at the same position
                if (_reader.Index == start)
                {
                    throw new HoconParserException(string.Format("Hocon syntax error {0}\r{1}", _reader.GetHelpTextAtIndex(start), GetDiagnosticsStackTrace()));
                }
            }
        }