LineVector.h

// WARNING: Changes to this file must be contributed back to Sawyer or else they will
//          be clobbered by the next update from Sawyer.  The Sawyer repository is at
//          https://gitlab.com/charger7534/sawyer.git.
 
 
 
 
#ifndef Sawyer_Container_LineVector_H
#define Sawyer_Container_LineVector_H
 
#include <Sawyer/Buffer.h>
#include <Sawyer/Sawyer.h>
 
#include <algorithm>
#include <boost/filesystem.hpp>
#include <vector>
 
namespace Sawyer {
namespace Container {
 
class LineVector {
    Buffer<size_t, char>::Ptr buffer_;
    const char *charBuf_;                               // cached ptr to first byte of buffer
    size_t bufSize_;                                    // cached size of buffer
    mutable std::vector<size_t> lineFeeds_;
    mutable size_t nextCharToScan_;
 
public:
    LineVector(): charBuf_(NULL), bufSize_(0), nextCharToScan_(0) {}
 
    explicit LineVector(const boost::filesystem::path&);
 
    explicit LineVector(const Buffer<size_t, char>::Ptr&);
 
    LineVector(size_t nBytes, const char *buf);
 
    void load(const boost::filesystem::path&);
 
    void load(const Buffer<size_t, char>::Ptr&);
 
    void load(size_t nBytes, const char *buf);
 
    void clear() {
        buffer_ = Buffer<size_t, char>::Ptr();
        charBuf_ = NULL;
        lineFeeds_.clear();
        nextCharToScan_ = 0;
    }
 
    size_t nLines() const;
 
    size_t nCharacters() const {
        return bufSize_;
    }
 
    size_t nCharacters(size_t lineIdx) const;
 
    int character(size_t charIdx) const {
        return charIdx >= nCharacters() ? EOF : (int)charBuf_[charIdx];
    }
 
    const char *characters(size_t charIdx) const;
 
    int character(size_t lineIdx, size_t colIdx) const;
 
    const char* lineChars(size_t lineIdx) const;
 
    std::string lineString(size_t lineIdx) const;
 
    size_t characterIndex(size_t lineIdx) const;
 
    size_t lineIndex(size_t charIndex) const;
 
    std::pair<size_t, size_t> location(size_t charIndex) const;
 
    bool isLastLineTerminated() const;
 
    bool isEmpty() const;
 
    std::string contentAsString(size_t begin, size_t end) const;
 
private:
    void cacheLines(size_t nLines) const;
    void cacheCharacters(size_t nCharacters) const;
};
 
} // namespace
} // namespace
 
#endif