示例#1
0
        /// <summary>
        /// Reades all data from the specified stream and writes it to source stream. Period handlign and period terminator is added as required.
        /// </summary>
        /// <param name="stream">Stream which data to write to source stream.</param>
        /// <param name="maxSize">Maximum muber of bytes to read from <b>stream</b> and write source stream.</param>
        /// <returns>Returns number of bytes written to source stream. Note this value differs from 
        /// <b>stream</b> readed bytes count because of period handling and period terminator.
        /// </returns>
        /// <exception cref="ArgumentNullException">Raised when <b>stream</b> is null.</exception>
        /// <exception cref="InvalidOperationException">Raised when there already is pending write operation.</exception>
        /// <exception cref="LineSizeExceededException">Raised when <b>stream</b> contains line with bigger line size than allowed.</exception>
        /// <exception cref="DataSizeExceededException">Raised when <b>stream</b> has more data than <b>maxSize</b> allows..</exception>
        public int WritePeriodTerminated(Stream stream, int maxSize)
        {
            if (stream == null)
            {
                throw new ArgumentNullException("stream");
            }
            lock (this)
            {
                if (m_IsWriteActive)
                {
                    throw new InvalidOperationException(
                        "There is pending write operation, multiple write operations not allowed !");
                }
                m_IsWriteActive = true;
            }

            try
            {
                BufferedStream bufferedStoreStream = new BufferedStream(m_pStream, Workaround.Definitions.MaxStreamLineLength);
                StreamHelper reader = new StreamHelper(stream);
                int totalWrittenCount = 0;
                int readedCount = 0;
                int rawReadedCount = 0;
                while (true)
                {
                    // Read data block.
                    readedCount = ReadLineInternal(m_pLineBuffer,
                                                   SizeExceededAction.ThrowException,
                                                   out rawReadedCount,
                                                   false);

                    // We reached end of stream, no more data.
                    if (readedCount == 0)
                    {
                        break;
                    }

                    // Maximum allowed data size exceeded.
                    if ((totalWrittenCount + rawReadedCount) > maxSize)
                    {
                        throw new DataSizeExceededException();
                    }

                    // If line starts with period(.), additional period is added.
                    if (m_pLineBuffer[0] == '.')
                    {
                        bufferedStoreStream.WriteByte((byte) '.');
                        totalWrittenCount++;
                    }

                    // Write readed line to buffered stream.
                    bufferedStoreStream.Write(m_pLineBuffer, 0, readedCount);
                    bufferedStoreStream.Write(m_LineBreak, 0, m_LineBreak.Length);
                    totalWrittenCount += (readedCount + m_LineBreak.Length);
                }

                // Write terminator ".<CRLF>". We have start <CRLF> already in stream.
                bufferedStoreStream.Write(new[] {(byte) '.', (byte) '\r', (byte) '\n'}, 0, 3);
                bufferedStoreStream.Flush();
                m_pStream.Flush();

                // Log
                if (Logger != null)
                {
                    Logger.AddWrite(totalWrittenCount, null);
                }

                return totalWrittenCount;
            }
            finally
            {
                m_IsWriteActive = false;
            }
        }
示例#2
0
 /// <summary>
 /// Default constructor.
 /// </summary>
 /// <param name="streamHelper">Reference to StreamHelper.</param>
 /// <param name="storeStream">Stream where to store readed data.</param>
 /// <param name="maxSize">Maximum number of bytes to read.</param>
 /// <param name="exceededAction">Specifies how this method behaves when maximum size exceeded.</param>
 /// <param name="callback">Callback what will be called if asynchronous reading compltes.</param>
 /// <param name="tag">User data.</param>
 public _ToStreamReader(StreamHelper streamHelper,
                        Stream storeStream,
                        int maxSize,
                        SizeExceededAction exceededAction,
                        ReadToStreamCallback callback,
                        object tag)
 {
     m_pStreamHelper = streamHelper;
     m_pStoreStream = storeStream;
     m_pBufferedStream = new BufferedStream(m_pStoreStream, Workaround.Definitions.MaxStreamLineLength);
     m_MaxSize = maxSize;
     m_ExceededAction = exceededAction;
     m_pCallback = callback;
     m_pTag = tag;
     m_pBuffer = new byte[Workaround.Definitions.MaxStreamLineLength];
     m_pLineBuffer = new byte[4096];
 }