StringReader.h

00001 //
00002 // Copyright(C) 2005--2006 Institute of Computing Tech, Chinese Academy of Sciences. 
00003 // All rights reserved.
00004 // This file is part of FirteX (www.firtex.org)
00005 //
00006 // Use of the FirteX is subject to the terms of the software license set forth in 
00007 // the LICENSE file included with this software, and also available at
00008 // http://www.firtex.org/license.html
00009 //
00010 // Author       : 郭瑞杰(GuoRuijie)
00011 // Email        : ruijieguo@software.ict.ac.cn,ruijieguo@gmail.com
00012 // Created      : 2006/5/20
00013 //
00014 #ifndef _STRINGREADER_H
00015 #define _STRINGREADER_H
00016 
00017 #if _MSC_VER > 1000
00018 #pragma once
00019 #endif // _MSC_VER > 1000
00020 
00021 
00022 #include "../utility/StdHeader.h"
00023 #include <string>
00024 #include "Reader.h"
00025 using namespace std;
00026 
00027 namespace firtex
00028 {
00029         namespace utility
00030         {
00031                 class CStringReader :   public CReader
00032                 {
00033                 public:
00034                         CStringReader():CReader()
00035                         {
00036 
00037                         }
00038                         CStringReader(const char* value):CReader(strlen(value)+1)
00039                         {                       
00040                                 if(value && value[0] != 0)
00041                                 {       
00042                                         strcpy(m_buffer,value);
00043                                         m_bufferLength = strlen(value);
00044                                         m_length = m_bufferLength;
00045                                 }                               
00046                         }
00047                         CStringReader(const char* value,const size_t length):CReader(length+1)
00048                         {                               
00049                                 memcpy(m_buffer,value,length);
00050                                 m_bufferLength = length;
00051                                 m_buffer[length] = 0;                           
00052                                 m_length = m_bufferLength;
00053                         }
00054                         CStringReader(const string& value):CReader((size_t)value.size() + 1)
00055                         {       
00056                                 m_bufferLength = value.size();
00057                                 if(m_bufferLength > 0)
00058                                 {                                       
00059                                         memcpy(m_buffer,value.c_str(),m_bufferLength);
00060                                         m_buffer[m_bufferLength] = 0; 
00061                                 }                                               
00062                                 m_length = m_bufferLength;
00063                         }
00064                         virtual ~CStringReader(void)
00065                         {                               
00066                         }
00067                 public:
00068                         CReader*        clone(char* buffer,size_t buffsize)
00069                         {                               
00070                                 //CStringReader* pClone = new CStringReader(m_filename,buffer,buffsize);
00071                                 return NULL;
00072                         }
00073 
00074                         CReader*        clone()
00075                         {
00076                                 CStringReader* pClone = new CStringReader(m_buffer,m_bufferLength);
00077                                 return pClone;
00078                         }
00079 
00080                         char    readChar()
00081                         {
00082                                 if (m_bufferPosition >= m_bufferLength)
00083                                         refill();
00084                                 return m_buffer[m_bufferPosition++];
00085                         }
00086                         char    peek()
00087                         {
00088                                 if (m_bufferPosition >= m_bufferLength)
00089                                         refill();
00090                                 return m_buffer[m_bufferPosition];
00091                         }
00092                         
00093                         bool    open(const char* strBuffer,size_t len)
00094                         {
00095                                 CReader::close();
00096                                 if(m_bOwnBuff)
00097                                         delete[] m_buffer;
00098                                 m_buffer = (char*)strBuffer;
00099                                 m_length = m_bufferSize = len;
00100                                 m_bOwnBuff = false;             
00101                                 return true;
00102                         }                       
00103 
00104                         const char* getReaderName() const{return "StringReader";}
00105                 protected:
00106                         void    readInternal(char* b, size_t offset, size_t len){}                      
00107                         void    seekInternal(int64_t position){}                                
00108                 };
00109         }
00110 }
00111 
00112 #endif