C# IOutputStream.Write方法代码示例

   public override void WriteTo(
 IOutputStream stream,
 Document context
 )
   {
       stream.Write(BeginChunk);
         base.WriteTo(stream, context);
         stream.Write(EndChunk);
   }

 public override void WriteTo(
     IOutputStream stream,
     Document context
     )
 {
     stream.Write(value);
 }

   public override void WriteTo(
 IOutputStream stream,
 Document context
 )
   {
       if(operands != null)
         {
       files.File fileContext = context.File;
       foreach(PdfDirectObject operand in operands)
       {operand.WriteTo(stream, fileContext); stream.Write(Chunk.Space);}
         }
         stream.Write(operator_); stream.Write(Chunk.LineFeed);
   }

        private void DisplayCoreDump(ExecutionMirror executionMirror, IOutputStream outputStream)
        {
            if (null == executionMirror)
                return; // This can be "null" if there's compilation errors.

            ITextEditorSettings editorSettings = TextEditorCore.Instance.TextEditorSettings;
            if (false == editorSettings.DisplayOutput)
                return; // The output display has been disabled, don't display.

            try
            {
                List<string> variableList = null;
                executionMirror.GetCoreDump(out variableList,
                    editorSettings.MaxArrayDisplaySize,
                    editorSettings.MaxOutputDepth);

                if (null != variableList)
                {
                    foreach (string variable in variableList)
                    {
                        outputStream.Write(new ProtoCore.OutputMessage(
                            OutputMessage.MessageType.Info, variable));

                        Logger.LogPerf("CoreDump-ExecSession", variable);
                    }
                }
            }
            catch (System.Exception ex)
            {
                outputStream.Write(new ProtoCore.OutputMessage(OutputMessage.MessageType.Error, ex.Message));
                Logger.LogPerf("CoreDumpEx", ex.Message);

            }
        }

 public override void WriteTo(
     IOutputStream stream,
     Document context
     )
 {
     stream.Write(BeginOperatorKeyword); stream.Write("\n");
       Header.WriteTo(stream, context);
       stream.Write(DataOperatorKeyword); stream.Write("\n");
       Body.WriteTo(stream, context); stream.Write("\n");
       stream.Write(EndOperatorKeyword);
 }

   public override void WriteTo(
 IOutputStream stream,
 File context
 )
   {
       // Header.
         stream.Write(reference.Id); stream.Write(BeginIndirectObjectChunk);
         // Body.
         DataObject.WriteTo(stream, context);
         // Tail.
         stream.Write(EndIndirectObjectChunk);
   }

        public override void WriteTo(
      IOutputStream stream,
      File context
      )
        {
            header.Updateable = false;

              bool unencodedBody;
              byte[] bodyData;
              int bodyLength;

              // 1. Header.
              // Encoding.
              PdfDirectObject filterObject = header[PdfName.Filter];
              if(filterObject == null) // Unencoded body.
              {
            /*
              NOTE: Header entries related to stream body encoding are temporary, instrumental to the
              current serialization process only.
            */
            unencodedBody = true;

            // Set the filter to apply!
            filterObject = PdfName.FlateDecode; // zlib/deflate filter.
            // Get encoded body data applying the filter to the stream!
            bodyData = body.Encode(Filter.Get((PdfName)filterObject), null);
            // Set encoded length!
            bodyLength = bodyData.Length;
            // Update 'Filter' entry!
            header[PdfName.Filter] = filterObject;
              }
              else // Encoded body.
              {
            unencodedBody = false;

            // Get encoded body data!
            bodyData = body.ToByteArray();
            // Set encoded length!
            bodyLength = (int)body.Length;
              }
              // Set encoded length!
              header[PdfName.Length] = new PdfInteger(bodyLength);

              header.WriteTo(stream, context);

              // Is the body free from encodings?
              if(unencodedBody)
              {
            // Restore actual header entries!
            header[PdfName.Length] = new PdfInteger((int)body.Length);
            header[PdfName.Filter] = null;
              }

              // 2. Body.
              stream.Write(BeginStreamBodyChunk);
              stream.Write(bodyData);
              stream.Write(EndStreamBodyChunk);

              header.Updateable = true;
        }

        public override void WriteTo(
            IOutputStream stream,
            File context
            )
        {
            /*
            NOTE: The header is temporarily tweaked to accommodate serialization settings.
              */
              header.Updateable = false;

              byte[] bodyData;
              {
            bool bodyUnencoded;
            {
              FileSpecification dataFile = DataFile;
              /*
            NOTE: In case of external file, the body buffer has to be saved back only if the file was
            actually resolved (that is brought into the body buffer) and modified.
              */
              bool encodeBody = (dataFile == null || (bodyResolved && body.Dirty));
              if(encodeBody)
              {
            PdfDirectObject filterObject = Filter;
            if(filterObject == null && context.Configuration.StreamFilterEnabled) // Unencoded body.
            {
              /*
                NOTE: Header entries related to stream body encoding are temporary, instrumental to
                the current serialization process only.
              */
              bodyUnencoded = true;

              // Set the filter to apply!
              filterObject = PdfName.FlateDecode; // zlib/deflate filter.
              // Get encoded body data applying the filter to the stream!
              bodyData = body.Encode(bytes.filters.Filter.Get((PdfName)filterObject), null);
              // Set 'Filter' entry!
              Filter = filterObject;
            }
            else // Encoded body.
            {
              bodyUnencoded = false;

              // Get encoded body data!
              bodyData = body.ToByteArray();
            }

            if(dataFile != null)
            {
              /*
                NOTE: In case of external file, body data has to be serialized there, leaving empty
                its representation within this stream.
              */
              try
              {
                IOutputStream dataFileOutputStream = dataFile.GetOutputStream();
                dataFileOutputStream.Write(bodyData);
                dataFileOutputStream.Dispose();
              }
              catch(Exception e)
              {throw new Exception("Data writing into " + dataFile.Path + " failed.", e);}
              // Local serialization is empty!
              bodyData = new byte[]{};
            }
              }
              else
              {
            bodyUnencoded = false;
            bodyData = new byte[]{};
              }
            }

            // Set the encoded data length!
            header[PdfName.Length] = PdfInteger.Get(bodyData.Length);

            // 1. Header.
            header.WriteTo(stream, context);

            if(bodyUnencoded)
            {
              // Restore actual header entries!
              header[PdfName.Length] = PdfInteger.Get((int)body.Length);
              Filter = null;
            }
              }

              // 2. Body.
              stream.Write(BeginStreamBodyChunk);
              stream.Write(bodyData);
              stream.Write(EndStreamBodyChunk);

              header.Updateable = true;
        }

 public override void WriteTo(
     IOutputStream stream,
     File context
     )
 {
     stream.Write(IndirectReference);
 }