public void Parse <TPackage>(IBlockGenerator <TBlock, TPackage> inGenerator, BlockMetaCache inCache = null)
            where TPackage : ScriptableDataBlockPackage <TBlock>
        {
            if (m_Parsed)
            {
                return;
            }

            TPackage self = (TPackage)this;

            BlockParser.Parse(ref self, name, Source(), BlockParsingRules.Default, inGenerator, inCache);
        }
Esempio n. 2
0
            public void Dispose()
            {
                if (Builder != null)
                {
                    BlockParser.ReturnStringBuilder(Builder);
                    Builder = null;
                }

                if (ContentBuilder != null)
                {
                    BlockParser.ReturnStringBuilder(ContentBuilder);
                    ContentBuilder = null;
                }

                PrefixPriorities = null;
                Rules            = null;
                Generator        = null;
                TagDelimiters    = null;
                Cache            = null;

                Package      = null;
                CurrentBlock = null;
            }
Esempio n. 3
0
        static internal IEnumerator ParseFile(string inFileName, StringSlice inFile, TPackage ioPackage, IBlockParsingRules inRules, IBlockGenerator <TBlock, TPackage> inGenerator, BlockMetaCache inCache)
        {
            var state = new ParseState();

            state.PrefixPriorities = GeneratePrefixPriority(inRules);
            state.Rules            = inRules;
            state.Generator        = inGenerator;
            state.TagDelimiters    = new BlockParser.BlockTagDelimiters(inRules);
            state.Package          = ioPackage;
            state.Builder          = BlockParser.RentStringBuilder();
            state.ContentBuilder   = BlockParser.RentStringBuilder();
            state.Cache            = inCache ?? BlockMetaCache.Default;

            using (var disposeRef = state)
            {
                uint lineNumber = 0;
                state.Position = new BlockFilePosition(inFileName, lineNumber);
                inGenerator.OnStart(state, state.Package);

                foreach (var rawLine in SplitIntoLines(inRules, inFile))
                {
                    lineNumber++;
                    state.Position = new BlockFilePosition(inFileName, lineNumber);

                    LineResult result = ParseLine(ref state, rawLine);
                    if (result == LineResult.Exception)
                    {
                        inGenerator.OnEnd(state, state.Package, true);
                        yield break;
                    }

                    yield return(null);
                }

                if (state.CurrentBlock != null)
                {
                    state.Error |= !TryEndBlock(ref state, StringSlice.Empty);
                }

                inGenerator.OnEnd(state, state.Package, state.Error);
            }
        }
Esempio n. 4
0
        /// <summary>
        /// Parses the given file contents into blocks asynchronously.
        /// Each MoveNext() call on the returned IEnumerator will parse one line.
        /// </summary>
        static public TPackage ParseAsync <TBlock, TPackage>(string inFileName, StringSlice inFile, IBlockParsingRules inRules, IBlockGenerator <TBlock, TPackage> inGenerator, BlockMetaCache inCache, out IEnumerator outLoader)
            where TBlock : class, IDataBlock
            where TPackage : class, IDataBlockPackage <TBlock>
        {
            if (inFile.IsEmpty)
            {
                outLoader = null;
                return(null);
            }

            if (inRules == null)
            {
                throw new ArgumentNullException("inRules");
            }
            if (inGenerator == null)
            {
                throw new ArgumentNullException("inGenerator");
            }

            string   fileName = string.IsNullOrEmpty(inFileName) ? NullFilename : inFileName;
            TPackage package  = inGenerator.CreatePackage(fileName);

            outLoader = InternalBlockParser <TBlock, TPackage> .ParseFile(fileName, inFile, package, inRules, inGenerator, inCache);

            return(package);
        }
Esempio n. 5
0
        /// <summary>
        /// Parses the given file contents into blocks
        /// and merges into the given package.
        /// </summary>
        static public void Parse <TBlock, TPackage>(ref TPackage ioPackage, string inFileName, StringSlice inFile, IBlockParsingRules inRules, IBlockGenerator <TBlock, TPackage> inGenerator, BlockMetaCache inCache = null)
            where TBlock : class, IDataBlock
            where TPackage : class, IDataBlockPackage <TBlock>
        {
            IEnumerator parser = ParseAsync(ref ioPackage, inFileName, inFile, inRules, inGenerator, inCache);

            if (parser != null)
            {
                while (parser.MoveNext())
                {
                    ;
                }
            }
        }
Esempio n. 6
0
        /// <summary>
        /// Parses the given file contents into blocks.
        /// </summary>
        static public TPackage Parse <TBlock, TPackage>(string inFileName, StringSlice inFile, IBlockParsingRules inRules, IBlockGenerator <TBlock, TPackage> inGenerator, BlockMetaCache inCache = null)
            where TBlock : class, IDataBlock
            where TPackage : class, IDataBlockPackage <TBlock>
        {
            IEnumerator parser;
            TPackage    package = ParseAsync(inFileName, inFile, inRules, inGenerator, inCache, out parser);

            if (parser != null)
            {
                while (parser.MoveNext())
                {
                    ;
                }
            }

            return(package);
        }
Esempio n. 7
0
        /// <summary>
        /// Parses the given file contents into blocks asynchronously
        /// and merges into the given package.
        /// Each MoveNext() call on the returned IEnumerator will parse one line.
        /// </summary>
        static public IEnumerator ParseAsync <TBlock, TPackage>(ref TPackage ioPackage, string inFileName, StringSlice inFile, IBlockParsingRules inRules, IBlockGenerator <TBlock, TPackage> inGenerator, BlockMetaCache inCache = null)
            where TBlock : class, IDataBlock
            where TPackage : class, IDataBlockPackage <TBlock>
        {
            if (inFile.IsEmpty)
            {
                return(null);
            }

            if (inRules == null)
            {
                throw new ArgumentNullException("inRules");
            }
            if (inGenerator == null)
            {
                throw new ArgumentNullException("inGenerator");
            }

            string fileName = string.IsNullOrEmpty(inFileName) ? NullFilename : inFileName;

            if (ioPackage == null)
            {
                ioPackage = inGenerator.CreatePackage(fileName);
            }
            return(InternalBlockParser <TBlock, TPackage> .ParseFile(fileName, inFile, ioPackage, inRules, inGenerator, inCache));
        }
        public IEnumerator ParseAsync <TPackage>(IBlockParsingRules inRules, IBlockGenerator <TBlock, TPackage> inGenerator, BlockMetaCache inCache = null)
            where TPackage : ScriptableDataBlockPackage <TBlock>
        {
            if (m_Parsed)
            {
                return(null);
            }

            TPackage self = (TPackage)this;

            return(BlockParser.ParseAsync(ref self, name, Source(), inRules, inGenerator, inCache));
        }