parse_buffer.h

Go to the documentation of this file.

#ifndef PARSE_BUFFER_H
#define PARSE_BUFFER_H
#pragma once
/***************************************************************************
 *   Copyright (C) 2013 Mike Kinghan, imk@burroingroingjoing.com                   *
 *   All rights reserved.                                                  *
 *                                                                         *
 *   Contributed originally by Mike Kinghan, imk@burroingroingjoing.com    *
 *                                                                         *
 *   Redistribution and use in source and binary forms, with or without    *
 *   modification, are permitted provided that the following conditions    *
 *   are met:                                                              *
 *                                                                         *
 *   Redistributions of source code must retain the above copyright        *
 *   notice, this list of conditions and the following disclaimer.         *
 *                                                                         *
 *   Redistributions in binary form must reproduce the above copyright     *
 *   notice, this list of conditions and the following disclaimer in the   *
 *   documentation and/or other materials provided with the distribution.  *
 *                                                                         *
 *   Neither the name of Mike Kinghan nor the names of its contributors    *
 *   may be used to endorse or promote products derived from this software *
 *   without specific prior written permission.                            *
 *                                                                         *
 *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS   *
 *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT     *
 *   LIMITED TO, THE IMPLIED WARRANTIES OF  MERCHANTABILITY AND FITNESS    *
 *   FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE        *
 *   COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,   *
 *   INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,  *
 *   BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS *
 *   OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED    *
 *   AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,*
 *   OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF *
 *   THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH  *
 *   DAMAGE.                                                               *
 *                                                                         *
 **************************************************************************/

#include <string>
#include "eol.h"

struct parse_buffer
{
    using value_type = char;

        parse_buffer() = default;

        virtual ~parse_buffer(){};

        explicit parse_buffer(std::string const & str)
        : _text(str){}

        parse_buffer & operator=(parse_buffer const &) = default;

        parse_buffer & operator=(std::string const & str) {
                _text = str;
                return *this;
        }

        bool operator==(parse_buffer const & other) const {
                return _text == other._text;
        }

        bool operator!=(parse_buffer const & other) const {
                return _text != other._text;
        }

        size_t size() const {
                return _text.size();
        }

        std::string & str() {
                return _text;
        }
        std::string const & str() const {
                return _text;
        }

        explicit operator std::string const &() const {
                return str();
        }

        char const * data() const {
                return _text.data();
        }
        char * data() {
                return const_cast<char *>(_text.data());
        }

        std::string substr(size_t start, size_t len = std::string::npos) const {
                return _text.substr(start,len);
        }

        bool overshoot(size_t off = 0) const {
                return off >= size();
        }

        char at(size_t off) const {
                return _text[off];
        }

        char & at(size_t off) {
                return _text[off];
        }
        char operator[](size_t off) const {
                return at(off);
        }

        char & operator[](size_t offset) {
                return at(offset);
        }

        void clear() {
                _text.clear();
        }

        unsigned eol(size_t offset) const {
                return ::eol(_text,offset);
        }

        virtual size_t extend() {
                return 0;
        }

        virtual size_t extension_pending(size_t off) const {
                return 0;
        }

        virtual size_t extend(size_t skip) {
                return 0;
        }

protected:

        std::string _text;

};

#endif // EOF