string1.hh

#ifndef LOCARNA_STRING1_HH
#define LOCARNA_STRING1_HH
 
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
 
#include <string>
#include <algorithm>
 
namespace LocARNA {
    class string1 {
        std::string s_;
 
    public:
        explicit string1(const std::string &s) : s_(s) {}
 
        string1(const string1 &s) : s_(s.s_) {}
 
        const std::string &
        str() const {
            return s_;
        }
 
        std::string &
        str() {
            return s_;
        }
 
        const char &operator[](size_t i) const {
            assert(i >= 1);
            assert(i <= s_.length());
            return s_[i - 1];
        }
 
        char &operator[](size_t i) {
            assert(i >= 1);
            assert(i <= s_.length());
            return s_[i - 1];
        }
 
        size_t
        length() const {
            return s_.length();
        }
 
        string1 &
        operator=(const string1 &s) {
            s_ = s.s_;
            return *this;
        }
 
        void
        reverse() {
            std::reverse(s_.begin(), s_.end());
        }
 
        void
        push_back(char c) {
            s_.push_back(c);
        }
 
        string1
        substr(size_t pos, size_t len) const {
            assert(pos >= 1);
            assert(pos <= s_.length());
            return string1(s_.substr(pos - 1, len));
        }
 
        auto begin() const {
            return s_.begin()+1;
        };
        auto end() const {
            return s_.end();
        };
        auto begin() {
            return s_.begin()+1;
        };
        auto end() {
            return s_.end();
        };
 
    };
 
} // end namespace LocARNA
 
#endif // LOCARNA_STRING1_HH