path.h

Go to the documentation of this file.

#ifndef PATH_H
#define PATH_H
#pragma once
/***************************************************************************
 *   Copyright (C) 2007-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 "platform.h"
#include <vector>
#include <string>
#include <stdexcept>

template<char Delim>
struct path {

        path() = default;

        explicit path(std::string const & path)
                :   _path(path) {
                analyse();
        }

        path & operator=(std::string const & str) {
                cut();
                _path = str;
                analyse();
                posn() = 0;
                return *this;
        }

        bool operator==(path const & other) const {
                return _path == other._path;
        }

        bool operator!=(path const & other) const {
                return !(_path == other._path);
        }

        bool operator<(path const & other) const {
                return _path < other._path;
        }

        size_t elements() const {
                return _elements.size();
        }

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

        size_t length() const {
                return _path.length();
        }

        std::string element(size_t which) const {
                if (which >= elements()) {
                        throw std::out_of_range("Out of range in path::element(size_t)");
                }
                element_pos const & element = _elements[which];
                return element.second == 0 ?
                       std::string(1,Delim) :
                       _path.substr(element.first,element.second);
        }

        std::string cur_element() const {
                return element(posn());
        }

        std::string operator[](size_t which) const {
                return element(which);
        }

        bool is_prefix_of(path const & other) const {
                path common = common_prefix(*this,other);
                return *this == common;
        }

        std::string
        segment(size_t start = 0, size_t len = std::string::npos) const {
                element_pos section = get_section(start,len);
                return section.first != std::string::npos ?
                       _path.substr(section.first,section.second) : std::string();
        }

        void push_back(std::string const & str) {
                if (length() && _last != Delim) {
                        _path += Delim;
                }
                _path +=  str;
                analyse();
        }

        void pop_back() {
                size_t parts = elements();
                if (parts) {
                        size_t cut = _elements[parts - 1].first;
                        cut -= parts-- > 1;
                        _path.erase(cut);
                        analyse();
                }
        }

        void push_front(std::string const & str) {
                if (_first != Delim) {
                        _path.insert(0,1,Delim);
                }
                _path.insert(0,str);
                analyse();
        }

        void pop_front() {
                size_t parts = elements();
                if (parts) {
                        size_t start = _elements[0].first;
                        size_t len = _elements[0].second;
                        len += parts-- > 1;
                        _path.erase(start,len);
                        analyse();
                }
        }


        path operator+(std::string const & str) const {
                path p(*this);
                p.append(str);
                return p;
        }

        path operator+(path const & rhs) const {
                return *this + rhs.str();
        }

        path & operator+=(std::string const & str) {
                push_back(str);
                return *this;
        }

        path & operator+=(path const & rhs) {
                push_back(rhs.str());
                return *this;
        }

        void insert(size_t after,std::string const & str) {
                if (after < elements() - 1) {
                        element_pos element = _elements[after];
                        after = element.first + element.second + 1;
                        _path.insert(after,str + Delim);
                        analyse();
                } else {
                        push_back(str);
                }
        }

        void cut(size_t start = 0, size_t len = std::string::npos) {
                element_pos section = get_section(start,len);
                if (section.first != std::string::npos) {
                        if (section.first + section.second < _path.length()) {
                                ++section.second;
                        } else if (section.first > 0) {
                                --section.first;
                        }
                        _path.erase(section.first,section.second);
                        analyse();
                }
        }

        void rectify() {
                std::string match(2,Delim);
                for (size_t posn ; (posn = _path.find(match)) != std::string::npos; ) {
                        _path.erase(posn + 1);
                }
                size_t len = _path.length();
                if (len > 1 && _path[len - 1] == Delim) {
                        _path.resize(len - 1);
                }
                analyse();
        }


        int & posn() {
                return _cursor;
        }
        int const & posn() const {
                return _cursor;
        }

        int to_end() {
                _cursor = elements() ? elements() - 1 : 0;
                return _cursor;
        }

        static path common_prefix(path const & lhs, path const & rhs) {
                size_t count = std::min(lhs.elements(),rhs.elements());
                path p;
                for (size_t ndx = 0; ndx < count; ++ndx) {
                        if (rhs[ndx] == lhs[ndx]) {
                                p += rhs[ndx];
                        }
                }
                return p;
        }

private:

        using element_pos = std::pair<size_t,size_t>;

        void analyse() {
                _elements.resize(0);
                size_t start = 0;
                size_t end;
                for (   ; (end = _path.find(Delim,start)) != std::string::npos;
                        start = end + 1) {
                        _elements.push_back(element_pos(start,end - start));
                }
                if (start < _path.length()) {
                        _elements.push_back(element_pos(start,_path.length() - start));
                }
                if (_path.length()) {
                        _first = _path[0];
                        _last = _path[_path.length() - 1];
                } else {
                        _first = _last = 0;
                }
                if (_cursor >= elements()) {
            to_end();
                }
        }

        element_pos
        get_section(size_t start, size_t len = std::string::npos) const {
                if (len && start < elements()) {
                        len = std::min(len,_path.length() - start);
                        element_pos const & first = _elements[start];
                        if (start + len <= elements()) {
                                element_pos const & last = _elements[(start + len) - 1];
                                len = (last.first + last.second) - first.first;
                                return len ?
                                       element_pos(first.first,len) : element_pos(first.first,1);
                        }
                        return element_pos(first.first,len);
                }
                return element_pos(std::string::npos,std::string::npos);
        }

        std::string _path;
        std::vector<element_pos> _elements;
        int _cursor = 0;
        char _first = 0;
        char _last = 0;
};

template<char Delim>
path<Delim> operator+(std::string const & str, path<Delim> const & path)
{
        return path<Delim>(str) + path;
}

using path_t = path<PATH_DELIM>;


#endif /* EOF*/