Esempio n. 1
0
        public static async Task <Stream> CreateTemplateStreamAsync([NotNull] ExtendedParseInformation parseOutput, [NotNull] object data, CancellationToken token)
        {
            var timeoutCancellation = new CancellationTokenSource();

            if (parseOutput.ParserOptions.Timeout != TimeSpan.Zero)
            {
                timeoutCancellation.CancelAfter(parseOutput.ParserOptions.Timeout);
                var anyCancellationToken = CancellationTokenSource.CreateLinkedTokenSource(token, timeoutCancellation.Token);
                token = anyCancellationToken.Token;
            }
            var sourceStream = parseOutput.ParserOptions.SourceFactory();

            try
            {
                if (!sourceStream.CanWrite)
                {
                    throw new InvalidOperationException("The stream is ReadOnly");
                }

                using (var byteCounterStreamWriter = new ByteCounterStreamWriter(sourceStream,
                                                                                 parseOutput.ParserOptions.Encoding, BufferSize, true))
                {
                    var context = new ContextObject(parseOutput.ParserOptions, "")
                    {
                        Value             = data,
                        CancellationToken = token
                    };
                    await parseOutput.InternalTemplate.Value(byteCounterStreamWriter, context);
                }

                if (timeoutCancellation.IsCancellationRequested)
                {
                    sourceStream.Dispose();
                    throw new TimeoutException($"The requested timeout of {parseOutput.ParserOptions.Timeout:g} for report generation was reached");
                }
            }
            catch
            {
                //If there is any exception while generating the template we must dispose any data written to the stream as it will never returned and might
                //create a memory leak with this. This is also true for a timeout
                sourceStream.Dispose();
                throw;
            }
            return(sourceStream);
        }
Esempio n. 2
0
 public async Task ExecuteWith(ByteCounterStreamWriter builder, ContextObject context)
 {
     foreach (var a in Elements.TakeWhile(e => StopOrAbortBuilding(builder, context)))
     {
         if (a is SyncParserAction action)
         {
             action(builder, context);
         }
         else if (a is AsyncParserAction asyncAction)
         {
             await asyncAction(builder, context);
         }
         else
         {
             throw new InvalidOperationException($"The internal parser action was of a not recognized type '{a.GetType()}'");
         }
     }
 }
Esempio n. 3
0
        public static Stream CreateTemplateStream([NotNull] ExtendedParseInformation parseOutput, [NotNull] object data, CancellationToken token)
        {
            var sourceStream = parseOutput.ParserOptions.SourceFactory();

            if (!sourceStream.CanWrite)
            {
                throw new InvalidOperationException("The stream is ReadOnly");
            }

            using (var ByteCounterStreamWriter = new ByteCounterStreamWriter(sourceStream, parseOutput.ParserOptions.Encoding, BufferSize, true))
            {
                var context = new ContextObject(parseOutput.ParserOptions)
                {
                    Value             = data,
                    Key               = "",
                    CancellationToken = token
                };
                parseOutput.InternalTemplate.Value(ByteCounterStreamWriter, context);
            }

            return(sourceStream);
        }
Esempio n. 4
0
        private static void WriteContent(ByteCounterStreamWriter builder, string content, ContextObject context)
        {
            content = content ?? context.Options.Null;

            var sourceCount = builder.BytesWritten;

            if (context.Options.MaxSize == 0)
            {
                builder.Write(content);
                return;
            }

            if (sourceCount >= context.Options.MaxSize - 1)
            {
                builder.ReachedLimit = true;
                return;
            }

            var cl = context.Options.Encoding.GetByteCount(content);

            var overflow = sourceCount + cl - context.Options.MaxSize;

            if (overflow <= 0)
            {
                //builder.BaseStream.Write(binaryContent, 0, binaryContent.Length);
                builder.Write(content, cl);
                return;
            }

            if (overflow < content.Length)
            {
                builder.Write(content.ToCharArray(0, (int)(cl - overflow)), cl - overflow);
            }
            else
            {
                builder.Write(content, cl);
            }
        }
Esempio n. 5
0
        private static void WriteContent(ByteCounterStreamWriter builder, string content, ContextObject context)
        {
            content = content ?? context.Options.Null;

            var sourceCount = builder.BytesWritten;

            if (context.Options.MaxSize == 0)
            {
                builder.Write(content);
                return;
            }

            if (sourceCount >= context.Options.MaxSize - 1)
            {
                builder.ReachedLimit = true;
                return;
            }
            //TODO this is a performance critical operation. As we might deal with variable-length encodings this cannot be compute initial
            var cl = context.Options.Encoding.GetByteCount(content);

            var overflow = sourceCount + cl - context.Options.MaxSize;

            if (overflow <= 0)
            {
                builder.Write(content, cl);
                return;
            }

            if (overflow < content.Length)
            {
                builder.Write(content.ToCharArray(0, (int)(cl - overflow)), cl - overflow);
            }
            else
            {
                builder.Write(content, cl);
            }
        }
Esempio n. 6
0
 private static bool StopOrAbortBuilding(ByteCounterStreamWriter builder, ContextObject context)
 {
     return(!context.AbortGeneration && !context.CancellationToken.IsCancellationRequested && !builder.ReachedLimit);
 }