diff options
Diffstat (limited to '3rdparty/clucene/src/CLucene/util/bufferedstream.h')
| -rw-r--r-- | 3rdparty/clucene/src/CLucene/util/bufferedstream.h | 157 |
1 files changed, 157 insertions, 0 deletions
diff --git a/3rdparty/clucene/src/CLucene/util/bufferedstream.h b/3rdparty/clucene/src/CLucene/util/bufferedstream.h new file mode 100644 index 000000000..d905955b1 --- /dev/null +++ b/3rdparty/clucene/src/CLucene/util/bufferedstream.h @@ -0,0 +1,157 @@ +/*------------------------------------------------------------------------------ +* Copyright (C) 2003-2006 Jos van den Oever +* +* 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. +------------------------------------------------------------------------------*/ +/* This file is part of Strigi Desktop Search + * + * Copyright (C) 2006 Jos van den Oever <jos@vandenoever.info> + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + */ +#ifndef BUFFEREDSTREAM_H +#define BUFFEREDSTREAM_H + +#include "streambase.h" +#include "inputstreambuffer.h" + +#include <cassert> +#include <stdio.h> + +namespace jstreams { + +template <class T> +class BufferedInputStream : public StreamBase<T> { +private: + bool finishedWritingToBuffer; + InputStreamBuffer<T> buffer; + + void writeToBuffer(int32_t minsize); + int32_t read_(const T*& start, int32_t min, int32_t max); +protected: + /** + * This function must be implemented by the subclasses. + * It should write a maximum of @p space characters at the buffer + * position pointed to by @p start. If no more data is available due to + * end of file, -1 should be returned. If an error occurs, the status + * should be set to Error, an error message should be set and the function + * must return -1. + **/ + virtual int32_t fillBuffer(T* start, int32_t space) = 0; + // this function might be useful if you want to reuse a bufferedstream + void resetBuffer() {printf("implement 'resetBuffer'\n");} + BufferedInputStream<T>(); +public: + int32_t read(const T*& start, int32_t min, int32_t max); + int64_t reset(int64_t); + virtual int64_t skip(int64_t ntoskip); +}; + +template <class T> +BufferedInputStream<T>::BufferedInputStream() { + finishedWritingToBuffer = false; +} + +template <class T> +void +BufferedInputStream<T>::writeToBuffer(int32_t ntoread) { + int32_t missing = ntoread - buffer.avail; + int32_t nwritten = 0; + while (missing > 0 && nwritten >= 0) { + int32_t space; + space = buffer.makeSpace(missing); + T* start = buffer.readPos + buffer.avail; + nwritten = fillBuffer(start, space); + assert(StreamBase<T>::status != Eof); + if (nwritten > 0) { + buffer.avail += nwritten; + missing = ntoread - buffer.avail; + } + } + if (nwritten < 0) { + finishedWritingToBuffer = true; + } +} +template <class T> +int32_t +BufferedInputStream<T>::read(const T*& start, int32_t min, int32_t max) { + if (StreamBase<T>::status == Error) return -2; + if (StreamBase<T>::status == Eof) return -1; + + // do we need to read data into the buffer? + if (!finishedWritingToBuffer && min > buffer.avail) { + // do we have enough space in the buffer? + writeToBuffer(min); + if (StreamBase<T>::status == Error) return -2; + } + + int32_t nread = buffer.read(start, max); + + BufferedInputStream<T>::position += nread; + if (BufferedInputStream<T>::position > BufferedInputStream<T>::size + && BufferedInputStream<T>::size > 0) { + // error: we read more than was specified in size + // this is an error because all dependent code might have been labouring + // under a misapprehension + BufferedInputStream<T>::status = Error; + BufferedInputStream<T>::error = "Stream is longer than specified."; + nread = -2; + } else if (BufferedInputStream<T>::status == Ok && buffer.avail == 0 + && finishedWritingToBuffer) { + BufferedInputStream<T>::status = Eof; + if (BufferedInputStream<T>::size == -1) { + BufferedInputStream<T>::size = BufferedInputStream<T>::position; + } + // save one call to read() by already returning -1 if no data is there + if (nread == 0) nread = -1; + } + return nread; +} +template <class T> +int64_t +BufferedInputStream<T>::reset(int64_t newpos) { + if (StreamBase<T>::status == Error) return -2; + // check to see if we have this position + int64_t d = BufferedInputStream<T>::position - newpos; + if (buffer.readPos - d >= buffer.start && -d < buffer.avail) { + BufferedInputStream<T>::position -= d; + buffer.avail += (int32_t)d; + buffer.readPos -= d; + StreamBase<T>::status = Ok; + } + return StreamBase<T>::position; +} +template <class T> +int64_t +BufferedInputStream<T>::skip(int64_t ntoskip) { + const T *begin; + int32_t nread; + int64_t skipped = 0; + while (ntoskip) { + int32_t step = (int32_t)((ntoskip > buffer.size) ?buffer.size :ntoskip); + nread = read(begin, 1, step); + if (nread <= 0) { + return skipped; + } + ntoskip -= nread; + skipped += nread; + } + return skipped; +} +} + +#endif |