/// <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,32000);
     m_MaxSize         = maxSize;
     m_ExceededAction  = exceededAction;
     m_pCallback       = callback;
     m_pTag            = tag;
     m_pBuffer         = new byte[32000];
     m_pLineBuffer     = new byte[4096];
 }
        /// <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,32000);
                StreamHelper   reader              = new StreamHelper(stream);
                int            totalWrittenCount   = 0;
                int            readedCount         = 0;
                int            rawReadedCount      = 0;
                while(true){
                    // Read data block.
                    readedCount = this.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)'.',(byte)'\r',(byte)'\n'},0,3);
                bufferedStoreStream.Flush();
                m_pStream.Flush();

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

                return totalWrittenCount;
            }
            finally{
                m_IsWriteActive = false;
            }
        }