Example #1
0
 public PointReader(StreamEncodingBase <TKey, TValue> encodingMethod, RemoteBinaryStream stream, Action onComplete)
 {
     m_onComplete     = onComplete;
     m_encodingMethod = encodingMethod;
     m_stream         = stream;
     encodingMethod.ResetEncoder();
 }
Example #2
0
            internal BulkWriting(StreamingClientDatabase <TKey, TValue> client)
            {
                if (client.m_writer != null)
                {
                    throw new Exception("Duplicate call to StartBulkWriting");
                }

                m_client          = client;
                m_client.m_writer = this;
                m_stream          = m_client.m_stream;
                m_encodingMode    = m_client.m_encodingMode;

                m_stream.Write((byte)ServerCommand.Write);
                m_encodingMode.ResetEncoder();
            }
Example #3
0
        private bool ProcessRead()
        {
            SeekFilterBase <TKey>          key1Parser    = null;
            MatchFilterBase <TKey, TValue> key2Parser    = null;
            SortedTreeEngineReaderOptions  readerOptions = null;

            if (m_stream.ReadBoolean())
            {
                try
                {
                    key1Parser = Library.Filters.GetSeekFilter <TKey>(m_stream.ReadGuid(), m_stream);
                }
                catch
                {
                    m_stream.Write((byte)ServerResponse.UnknownOrCorruptSeekFilter);
                    m_stream.Flush();
                    return(false);
                }
            }
            if (m_stream.ReadBoolean())
            {
                try
                {
                    key2Parser = Library.Filters.GetMatchFilter <TKey, TValue>(m_stream.ReadGuid(), m_stream);
                }
                catch
                {
                    m_stream.Write((byte)ServerResponse.UnknownOrCorruptMatchFilter);
                    m_stream.Flush();
                    return(false);
                }
            }
            if (m_stream.ReadBoolean())
            {
                try
                {
                    readerOptions = new SortedTreeEngineReaderOptions(m_stream);
                }
                catch
                {
                    m_stream.Write((byte)ServerResponse.UnknownOrCorruptReaderOptions);
                    m_stream.Flush();
                    return(false);
                }
            }

            bool needToFinishStream = false;

            try
            {
                using (TreeStream <TKey, TValue> scanner = m_sortedTreeEngine.Read(readerOptions, key1Parser, key2Parser))
                {
                    m_stream.Write((byte)ServerResponse.SerializingPoints);


                    m_encodingMethod.ResetEncoder();
                    //if (m_encodingMethod.SupportsPointerSerialization)
                    //    ProcessReadWithPointers(scanner);
                    //else

                    needToFinishStream = true;
                    bool wasCanceled = !ProcessRead(scanner);
                    m_encodingMethod.WriteEndOfStream(m_stream);
                    needToFinishStream = false;

                    if (wasCanceled)
                    {
                        m_stream.Write((byte)ServerResponse.CanceledRead);
                    }
                    else
                    {
                        m_stream.Write((byte)ServerResponse.ReadComplete);
                    }
                    m_stream.Flush();
                    return(true);
                }
            }
            catch (Exception ex)
            {
                if (needToFinishStream)
                {
                    m_encodingMethod.WriteEndOfStream(m_stream);
                }
                m_stream.Write((byte)ServerResponse.ErrorWhileReading);
                m_stream.Write(ex.ToString());
                m_stream.Flush();
                return(false);
            }
        }