CLucene - a full-featured, c++ search engine
API Documentation

---

Reader.h

Go to the documentation of this file.

/*------------------------------------------------------------------------------
* Copyright (C) 2003-2006 Ben van Klinken and the CLucene Team
* 
* Distributable under the terms of either the Apache License (Version 2.0) or 
* the GNU Lesser General Public License, as specified in the COPYING file.
------------------------------------------------------------------------------*/
#ifndef _lucene_util_Reader_
#define _lucene_util_Reader_


#include "streambase.h"
#include "stringreader.h"
#include "fileinputstream.h"
#include "bufferedstream.h"

CL_NS_DEF(util)
class CLUCENE_EXPORT Reader:LUCENE_BASE {
typedef jstreams::StreamBase<TCHAR> jsReader;
public:
        bool deleteReader;
        jsReader* reader;

        Reader(jsReader* reader, bool deleteReader){
                this->reader = reader;
                this->deleteReader = deleteReader;
        }
        virtual ~Reader(){
                if ( deleteReader )
                        delete reader;
                reader = NULL;
        }
        inline int read(){
                const TCHAR*b;
                const int32_t nread = reader->read(b, 1,1);
                if ( nread < -1 ) //if not eof
                        _CLTHROWA(CL_ERR_IO,reader->getError() );
                else if ( nread == -1 )
                        return -1;
                else
                        return b[0];
        }

        // Read one line, return the length of the line read
        inline int32_t readLine(TCHAR* buffer){
                int32_t i = 0;
                while (true) {
                        int32_t b = read();
                        if (b < 1)
                                break;
                        if (b == '\n' || b == '\r') {
                                if (i > 0)
                                        break;
                                else
                                        continue;
                        }
                        buffer[i++] = b;
                }
                buffer[i] = 0;
                return i;
        }
        inline int32_t read(const TCHAR*& start){
                int32_t nread = reader->read(start,1,0);
                if ( nread < -1 ) //if not eof
                        _CLTHROWA(CL_ERR_IO,reader->getError());
                else
                        return nread;
        }
        inline int32_t read(const TCHAR*& start, int32_t len){
                int32_t nread = reader->read(start, len, len);
                if ( nread < -1 ) //if not eof
                        _CLTHROWA(CL_ERR_IO,reader->getError());
                else
                        return nread;
        }
        inline int64_t skip(int64_t ntoskip){
                int64_t skipped = reader->skip(ntoskip);
                if ( skipped < 0 ) 
                        _CLTHROWA(CL_ERR_IO,reader->getError());
                else
                        return skipped;
        }
        inline int64_t mark(int32_t readAheadlimit){
                int64_t pos = reader->mark(readAheadlimit);
                if ( pos < 0 )
                        _CLTHROWA(CL_ERR_IO,reader->getError());
                else
                        return pos;
        }
        int64_t reset(int64_t pos){
                int64_t r = reader->reset(pos);
                if ( r < 0 )
                        _CLTHROWA(CL_ERR_IO,reader->getError());
                else
                        return r;
        }
};

class StringReader: public Reader{
public:
        StringReader ( const TCHAR* value );
    StringReader ( const TCHAR* value, const int32_t length );
    StringReader ( const TCHAR* value, const int32_t length, bool copyData );
        ~StringReader();
};

class SimpleInputStreamReader: public jstreams::BufferedInputStream<TCHAR>{
    int32_t decode(TCHAR* start, int32_t space);
        int encoding;
        enum{
                ASCII=1,
                UTF8=2,
                UCS2_LE=3
        };
    bool finishedDecoding;
    jstreams::StreamBase<char>* input;
    int32_t charsLeft;

    jstreams::InputStreamBuffer<char> charbuf;
    int32_t fillBuffer(TCHAR* start, int32_t space);
public:
        SimpleInputStreamReader(jstreams::StreamBase<char> *i, const char* encoding);
        ~SimpleInputStreamReader();
};

class FileReader: public Reader{
        jstreams::FileInputStream* input;
public:
        FileReader ( const char* path, const char* enc,
        const int32_t cachelen = 13,
        const int32_t cachebuff = 14 ); //todo: optimise these cache values
        ~FileReader ();

    int32_t read(const TCHAR*& start, int32_t _min, int32_t _max);
    int64_t mark(int32_t readlimit);
    int64_t reset(int64_t);
};

CL_NS_END
#endif

---

clucene.sourceforge.net