stringops.hpp

Go to the documentation of this file.

/*
 * Copyright 2008,2009,2010,2011,2012 Stephan Ossowski, Korbinian Schneeberger,
 * Felix Ott, Joerg Hagmann, Alf Scotland, Sebastian Bender
 * 
 * This file is part of SHORE.
 * 
 * SHORE is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * SHORE 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 General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with SHORE.  If not, see <http://www.gnu.org/licenses/>.
 */


#ifndef SHORE_MISC_STRINGOPS_HPP__
#define SHORE_MISC_STRINGOPS_HPP__

#include <algorithm>
#include <cstdio>
#include <iomanip>
#include <ios>
#include <iostream>
#include <iterator>
#include <limits>
#include <stdexcept>
#include <sstream>
#include <string>
#include <vector>

#include <stdint.h>
#include <fstream>

#include <boost/utility/enable_if.hpp>
#include <boost/type_traits.hpp>

namespace shore {

void tolower(std::string& str);

void toupper(std::string& str);

struct iless
{
        bool operator()(const std::string& s0,const std::string& s1) const;
};

template<typename Iter>
bool is_numeric(Iter b,Iter e)
{
        bool ret=(b!=e);
        while(ret&&(b!=e))
        {
                ret=std::isdigit(*b);
                ++b;
        }
        return ret;
}


template<typename iter_type,
         typename delim_type=typename std::iterator_traits<iter_type>::value_type>
class tok_occurrence
{
 private:

        std::pair<iter_type,iter_type> m_range;
        const iter_type m_end;
        const delim_type m_delim;

        size_t m_index;
        bool m_hasdata;


 public:

        typedef std::pair<iter_type,iter_type> current_type;

        tok_occurrence(const iter_type& beg,const iter_type& end,const delim_type d)
        :m_range(beg,std::find(beg,end,d)),
         m_end(end),m_delim(d),m_index(0),m_hasdata(true)
        {}

        const std::pair<iter_type,iter_type>& current() const
        {
                return m_range;
        }

        bool has_data() const
        {
                return m_hasdata;
        }

        void next()
        {
                if(m_range.second==m_end)
                {
                        m_hasdata=false;
                }
                else
                {
                        ++m_range.second;
                        m_range.first=m_range.second;
                        m_range.second=std::find(m_range.first,m_end,m_delim);
                        ++m_index;
                }
        }

        size_t index() const
        {
                return m_index;
        }
};

template<typename iter_type,typename delim_iter_type>
class tok_occurrences
{
 private:

        std::pair<iter_type,iter_type> m_range;
        const iter_type m_end;
        const delim_iter_type m_dbeg;
        const delim_iter_type m_dend;

        size_t m_index;
        bool m_hasdata;


 public:

        typedef std::pair<iter_type,iter_type> current_type;

        tok_occurrences(const iter_type& beg,const iter_type& end,
          const delim_iter_type& dbeg,const delim_iter_type& dend)
        :m_range(beg,std::find_first_of(beg,end,dbeg,dend)),
         m_end(end),m_dbeg(dbeg),m_dend(dend),m_index(0),m_hasdata(true)
        {}

        const std::pair<iter_type,iter_type>& current() const
        {
                return m_range;
        }

        bool has_data() const
        {
                return m_hasdata;
        }

        void next()
        {
                if(m_range.second==m_end)
                {
                        m_hasdata=false;
                }
                else
                {
                        ++m_range.second;
                        m_range.first=m_range.second;
                        m_range.second=std::find_first_of(m_range.first,m_end,m_dbeg,m_dend);
                        ++m_index;
                }
        }

        size_t index() const
        {
                return m_index;
        }
};

template<typename iter_type,typename delim_type>
class tok_transition
{
 private:

        std::pair<iter_type,iter_type> m_range;
        const iter_type m_end;
        const delim_type m_delim;

        size_t m_index;
        bool m_hasdata;

 public:

        typedef std::pair<iter_type,iter_type> current_type;

        tok_transition(const iter_type& beg,const iter_type& end,const delim_type d)
        :m_range(beg,std::find(beg,end,d)),
         m_end(end),m_delim(d),m_index(0),m_hasdata(true)
        {}

        const std::pair<iter_type,iter_type>& current() const
        {
                return m_range;
        }

        bool has_data() const
        {
                return m_hasdata;
        }

        void next()
        {
                if(m_range.second==m_end)
                {
                        m_hasdata=false;
                }
                else
                {
                        do
                        {
                                ++m_range.second;
                        }
                        while((m_range.second!=m_end)&&((*m_range.second)==m_delim))
                        ;

                        m_range.first=m_range.second;
                        m_range.second=std::find(m_range.first,m_end,m_delim);
                        ++m_index;
                }
        }

        size_t index() const
        {
                return m_index;
        }
};

template<typename iter_type,typename delim_iter_type>
class tok_transitions
{
 private:

        std::pair<iter_type,iter_type> m_range;
        const iter_type m_end;
        const delim_iter_type m_dbeg;
        const delim_iter_type m_dend;

        size_t m_index;
        bool m_hasdata;


 public:

        typedef std::pair<iter_type,iter_type> current_type;

        tok_transitions(const iter_type& beg,const iter_type& end,
          const delim_iter_type& dbeg,const delim_iter_type& dend)
        :m_range(beg,std::find_first_of(beg,end,dbeg,dend)),
         m_end(end),m_dbeg(dbeg),m_dend(dend),m_index(0),m_hasdata(true)
        {}

        const std::pair<iter_type,iter_type>& current() const
        {
                return m_range;
        }

        bool has_data() const
        {
                return m_hasdata;
        }

        void next()
        {
                if(m_range.second==m_end)
                {
                        m_hasdata=false;
                }
                else
                {
                        do
                        {
                                ++m_range.second;
                        }
                        while((m_range.second!=m_end)
                              &&(std::find(m_dbeg,m_dend,*m_range.second)!=m_dend))
                        ;

                        m_range.first=m_range.second;
                        m_range.second=std::find_first_of(m_range.first,m_end,m_dbeg,m_dend);
                        ++m_index;
                }
        }

        size_t index() const
        {
                return m_index;
        }
};

template<typename iter_type,typename delim_iter_type>
class ltok_occurrence
{
 private:

        std::pair<iter_type,iter_type> m_range;
        const iter_type m_end;
        const delim_iter_type m_dbeg;
        const delim_iter_type m_dend;

        size_t m_index;
        bool m_hasdata;


 public:

        typedef std::pair<iter_type,iter_type> current_type;

        ltok_occurrence(const iter_type& beg,const iter_type& end,
          const delim_iter_type& dbeg,const delim_iter_type& dend)
        :m_range(beg,std::search(beg,end,dbeg,dend)),
         m_end(end),m_dbeg(dbeg),m_dend(dend),m_index(0),m_hasdata(true)
        {}

        const std::pair<iter_type,iter_type>& current() const
        {
                return m_range;
        }

        bool has_data() const
        {
                return m_hasdata;
        }

        void next()
        {
                if(m_range.second==m_end)
                {
                        m_hasdata=false;
                }
                else
                {
                        for(delim_iter_type di=m_dbeg;di!=m_dend;++di)
                        {
                                ++m_range.second;
                        }
                        m_range.first=m_range.second;
                        m_range.second=std::search(m_range.first,m_end,m_dbeg,m_dend);
                        ++m_index;
                }
        }

        size_t index() const
        {
                return m_index;
        }
};

template<typename iter_type,typename delim_iter_type>
class ltok_transition
{
 private:

        std::pair<iter_type,iter_type> m_range;
        const iter_type m_end;
        const delim_iter_type m_dbeg;
        const delim_iter_type m_dend;
        delim_iter_type m_aux;

        size_t m_index;
        bool m_hasdata;


 public:

        typedef std::pair<iter_type,iter_type> current_type;

        ltok_transition(const iter_type& beg,const iter_type& end,
          const delim_iter_type& dbeg,const delim_iter_type& dend)
        :m_range(beg,std::search(beg,end,dbeg,dend)),
         m_end(end),m_dbeg(dbeg),m_dend(dend),m_aux(dbeg),
         m_index(0),m_hasdata(true)
        {}

        const std::pair<iter_type,iter_type>& current() const
        {
                return m_range;
        }

        bool has_data() const
        {
                return m_hasdata;
        }

        void next()
        {
                if(m_range.second==m_end)
                {
                        m_hasdata=false;
                }
                else
                {
                        do
                        {
                                while(m_aux!=m_dend)
                                {
                                        ++m_range.second;
                                        ++m_aux;
                                }
                                m_aux=m_dbeg;
                                m_range.first=m_range.second;
                                m_range.second=std::search(m_range.first,m_end,m_dbeg,m_dend);
                        }
                        while((m_range.first==m_range.second)&&(m_range.second!=m_end))
                        ;

                        ++m_index;
                }
        }

        size_t index() const
        {
                return m_index;
        }
};

template<typename T,T termval=T()>
class valterm_iterator
:public std::iterator<std::forward_iterator_tag,T>
{
 private:
        
        T* m_ptr;

 public:

        valterm_iterator(T*const c=0)
        {
                if((c==0)||((*c)==termval))
                        m_ptr=0;
                else
                        m_ptr=c;
        }

        valterm_iterator(const valterm_iterator& other)
        :m_ptr(other.m_ptr)
        {}

        valterm_iterator& operator=(const valterm_iterator& other)
        {
                m_ptr=other.m_ptr;
        }

        bool operator==(const valterm_iterator& other)
        {
                return m_ptr==other.m_ptr;
        }

        bool operator!=(const valterm_iterator& other)
        {
                return m_ptr!=other.m_ptr;
        }

        T& operator*() const
        {
                return *m_ptr;
        }

        T* operator->() const
        {
                return m_ptr;
        }

        valterm_iterator& operator++()
        {
                ++m_ptr;
                if((*m_ptr)==termval)
                        m_ptr=0;
                return *this;
        }

        valterm_iterator operator++(int)
        {
                valterm_iterator ret=*this;
                ++m_ptr;
                if((*m_ptr)==termval)
                        m_ptr=0;
                return ret;
        }
};

std::vector<std::string> split(const std::string& s,const char delim='\t');

std::vector<std::string> split(const std::string& s,const char*const delims);

std::vector<std::string> tsplit(const std::string& s,const char delim='\t');

std::vector<std::string> tsplit(const std::string& s,const char*const delims);

std::vector<std::string> lsplit(const std::string& s,const std::string& delim);

std::vector<std::string> ltsplit(const std::string& s,const std::string& delim);

template<class StringIterator>
size_t split(const std::string& s,StringIterator destination,
             const char delim='\t',
             const size_t limit=std::numeric_limits<size_t>::max()-1)
{
        typedef std::string::const_iterator iter_t;
        typedef std::pair<iter_t,iter_t> range_t;
        typedef tok_occurrence<iter_t,char> tok_t;
        
        tok_t tok(s.begin(),s.end(),delim);

        const range_t& r=tok.current();
        destination->assign(r.first,r.second);
        ++destination;

        tok.next();

        while(tok.has_data()&&(tok.index()<limit))
        {
                const range_t& r=tok.current();

                destination->assign(r.first,r.second);
                ++destination;

                tok.next();
        }

        return tok.index()+1;
}

template<class StringIterator>
size_t split(const std::string& s,StringIterator destination,
             const char*const delims,
             const size_t limit=std::numeric_limits<size_t>::max()-1)
{
        typedef std::string::const_iterator iter_t;
        typedef std::pair<iter_t,iter_t> range_t;
        typedef valterm_iterator<const char> delim_iter_t;
        typedef tok_occurrences<iter_t,delim_iter_t> tok_t;
        
        tok_t tok(s.begin(),s.end(),delim_iter_t(delims),delim_iter_t());

        const range_t& r=tok.current();
        destination->assign(r.first,r.second);
        ++destination;

        tok.next();

        while(tok.has_data()&&(tok.index()<limit))
        {
                const range_t& r=tok.current();

                destination->assign(r.first,r.second);
                ++destination;

                tok.next();
        }

        return tok.index()+1;
}

template<class StringIterator>
size_t tsplit(const std::string& s,StringIterator destination,
             const char delim='\t',
             const size_t limit=std::numeric_limits<size_t>::max()-1)
{
        typedef std::string::const_iterator iter_t;
        typedef std::pair<iter_t,iter_t> range_t;
        typedef tok_transition<iter_t,char> tok_t;
        
        tok_t tok(s.begin(),s.end(),delim);

        const range_t& r=tok.current();
        destination->assign(r.first,r.second);
        ++destination;

        tok.next();

        while(tok.has_data()&&(tok.index()<limit))
        {
                const range_t& r=tok.current();

                destination->assign(r.first,r.second);
                ++destination;

                tok.next();
        }

        return tok.index()+1;
}

template<class StringIterator>
size_t tsplit(const std::string& s,StringIterator destination,
             const char*const delims,
             const size_t limit=std::numeric_limits<size_t>::max()-1)
{
        typedef std::string::const_iterator iter_t;
        typedef std::pair<iter_t,iter_t> range_t;
        typedef valterm_iterator<const char> delim_iter_t;
        typedef tok_transitions<iter_t,delim_iter_t> tok_t;

        tok_t tok(s.begin(),s.end(),delim_iter_t(delims),delim_iter_t());

        const range_t& r=tok.current();
        destination->assign(r.first,r.second);
        ++destination;

        tok.next();

        while(tok.has_data()&&(tok.index()<limit))
        {
                const range_t& r=tok.current();

                destination->assign(r.first,r.second);
                ++destination;

                tok.next();
        }

        return tok.index()+1;
}


template<typename T>
std::string to_string(const T& value,const int prec)
{
        std::ostringstream os;
        os<<std::setprecision(prec)<<value;
        return os.str();
}

template<typename T,int precision>
std::string to_string(const T& value)
{
        std::ostringstream os;
        os<<std::setprecision(precision)<<value;
        return os.str();
}

template<typename T>
std::string to_string(const T& value)
{
        return to_string<T,14>(value);
}

template<>
inline
std::string to_string<bool>(const bool& value)
{
        return value?"yes":"no";
}

template<>
inline
std::string to_string<std::ostringstream>(const std::ostringstream& str)
{
        return str.str();
}

template<>
inline
std::string to_string<std::string>(const std::string& s)
{
        return s;
}


template<class Iter>
std::string join(Iter begin,Iter end,const std::string& delim)
{
        if(begin==end)
                return "";

        --end;

        std::string ret;

        while(begin!=end)
        {
                ret+=to_string(*begin)+delim;
                ++begin;
        }
        return ret+to_string(*end);
}

template<class Iter>
std::string join(const Iter begin,const Iter end)
{
        return join(begin,end,"\t");
}

template<typename T>
std::string join(const std::vector<T>& sv,const std::string& delim)
{
        return join(sv.begin(),sv.end(),delim);
}

template<typename T>
std::string join(const std::vector<T>& sv)
{
        return join(sv.begin(),sv.end());
}

template<class Iteriter>
std::string ijoin(Iteriter begin,Iteriter end,const std::string& delim)
{
        if(begin==end)
                return "";

        --end;

        std::string ret;

        while(begin!=end)
        {
                ret+=to_string(**begin)+delim;
                ++begin;
        }
        return ret+to_string(**end);
}

template<typename Iter>
std::string ijoin(const std::vector<Iter>& sv,const std::string &delim)
{
        return ijoin(sv.begin(),sv.end(),delim);
}

inline std::vector<std::string> join2d(
  std::vector<std::vector<std::string> >& pv,const std::string& delim)
{
        std::vector<std::string> ret;
        for(size_t i=0;i<pv.size();++i)
                ret.push_back(join(pv[i],delim));
        return ret;
}


template<typename T>
std::string to_string(const std::vector<T>& v)
{
        return join(v,",");
}

template<typename T>
std::string to_string(const std::vector<std::vector<T> >& v)
{
        return join(join2d(v,":"),",");
}


template<typename conv_type,void (*initfunc)(conv_type *const)>
const conv_type *chartab();

template<typename conv_type,void (*initfunc)(conv_type *const)>
class chartable
{
        private:

                friend const conv_type *chartab<conv_type,initfunc>();

                struct ptrmgr
                {
                        chartable *ptr;

                        ~ptrmgr()
                        {
                                delete ptr;
                        }
                };

                static ptrmgr m_instance;

                conv_type m_table[256];

                chartable()
                {
                        initfunc(m_table);
                }
};

template<typename conv_type,void (*initfunc)(conv_type *const)>
const conv_type *chartab()
{
        if(chartable<conv_type,initfunc>::m_instance.ptr==0)
        {
                chartable<conv_type,initfunc>::m_instance.ptr=new chartable<conv_type,initfunc>;
        }
        return chartable<conv_type,initfunc>::m_instance.ptr->m_table;
}

template<typename conv_type,void (*initfunc)(conv_type *const)>
typename chartable<conv_type,initfunc>::ptrmgr chartable<conv_type,initfunc>::m_instance;

void ctabinit_digit(int *const table);

template<int exp>
void ctabinit_expdigit(int64_t *const table)
{
        uint64_t signif=1;
        for(int i=0;i<exp;++i)
                signif*=10;
        for(unsigned int i=0;i<256;++i)
        {
                if(i==uint8_t('0'))
                {
                        if(exp>=19)
                                table[i]=-8; // leading zero
                        else
                                table[i]=0;
                }
                else if((i>=uint8_t('1'))&&(i<=uint8_t('9')))
                {
                        if(exp<19)
                                table[i]=signif*(i-uint8_t('0'));
                        else
                                table[i]=-7; // out of range
                }
                else if(i==uint8_t('-'))
                        table[i]=-2;
                else if(i==uint8_t('+'))
                        table[i]=-3;
                else if(i==uint8_t('.'))
                        table[i]=-4;
                else if(i==uint8_t('e'))
                        table[i]=-5;
                else if(i==uint8_t('E'))
                        table[i]=-5;
                else if(i==uint8_t(' '))
                        table[i]=-6;
                else if(i==uint8_t('\t'))
                        table[i]=-6;
                else if(i==uint8_t('\n'))
                        table[i]=-6;
                else
                        table[i]=-1;
        }
}

void ctabinit_base32hex(int *const table);

extern const int *const ctab_digit;
extern const int64_t *const ctab_expdigit[21];

template<typename iter_type>
uint64_t parse_uint64(iter_type beg,iter_type end)
{
        if(beg==end)
                throw std::runtime_error("parse_uint64: empty range");

        uint64_t ret=0;
        const int64_t *const *digtab=ctab_expdigit;

        do
        {
                --end;

                const int64_t d=(*digtab)[uint8_t(*end)];

                if(d<0)
                {
                        if(end==beg)
                        {
                                // leading '+'
                                if(d==-3)
                                        return ret;
                                // out of range
                                if(d==-7)
                                {
                                        if((*end)=='1')
                                        {
                                                const uint64_t d2=
                                                        uint64_t((*(digtab-1))[uint8_t('1')])*10;

                                                if((std::numeric_limits<uint64_t>::max()-d2)>=ret)
                                                        return ret+d2;

                                                throw std::runtime_error("parse_uint64: out of range: "
                                                                         +std::string(beg,++end));
                                        }
                                        else
                                                throw std::runtime_error("parse_uint64: out of range: "
                                                                         +std::string(beg,++end));
                                }
                                if(d==-2)
                                        throw  std::runtime_error("parse_uint64: sign error: "
                                                                  +std::string(beg,++end));
                                throw std::runtime_error("parse_uint64: conversion error 2: "
                                                         +std::string(beg,++end));
                        }
                        else
                                throw std::runtime_error("parse_uint64: conversion error: "
                                                         +std::string(beg,++end));
                }

                ret+=d;
                ++digtab;
        }
        while(end!=beg)
        ;

        return ret;
}

template<typename iter_type>
int64_t parse_int64(iter_type beg,iter_type end)
{
        if(beg==end)
                throw std::runtime_error("parse_uint64: empty range");

        uint64_t ret=0;
        const int64_t *const *digtab=ctab_expdigit;

        do
        {
                --end;

                const int64_t d=(*digtab)[uint8_t(*end)];

                if(d<0)
                {
                        if(end==beg)
                        {
                                // leading '-'
                                if(d==-2)
                                {
                                        if(ret>(1+uint64_t(std::numeric_limits<int64_t>::max())))
                                                throw std::runtime_error("parse_int64: out of range: "
                                                                         +std::string(beg,++end));

                                        return -(int64_t(ret));
                                }
                                // leading '+'
                                if(d==-3)
                                        return ret;
                                // out of range
                                if(d==-7)
                                {
                                        if((*end)=='1')
                                        {
                                                const uint64_t d2=uint64_t((*(digtab-1))[uint8_t('1')])*10;

                                                if((std::numeric_limits<uint64_t>::max()-d2)>=ret)
                                                        return ret+d2;

                                                throw std::runtime_error("parse_int64: out of range: "
                                                                         +std::string(beg,++end));
                                        }
                                        else
                                                throw std::runtime_error("parse_int64: out of range: "
                                                                         +std::string(beg,++end));
                                }
                                throw std::runtime_error("parse_int64: conversion error 2: "
                                                         +std::string(beg,++end));
                        }
                        else
                                throw std::runtime_error("parse_int64: conversion error: "
                                                         +std::string(beg,++end));
                }

                ret+=d;
                ++digtab;
        }
        while(end!=beg)
        ;

        if(ret>uint64_t(std::numeric_limits<int64_t>::max()))
                throw std::runtime_error("parse_int64: out of range: "
                                         +std::string(beg,end));

        return ret;
}


template<typename T>
void parse_value(T* dest,const std::string& str)
{
        std::istringstream sstr(str);
        if(!(sstr>>std::noskipws>>(*dest)))
                throw std::runtime_error("stream conversion failed for \""+str+"\"");
        if((sstr.peek()!=EOF))
                throw std::runtime_error(
                        "stream conversion failed for \""+str+"\": trailing characters");
}

template<>
inline void parse_value<std::string>(std::string* dest,const std::string& str)
{
        (*dest)=str;
}

template<>
void parse_value<bool>(bool *dest,const std::string& str);

template<typename T>
T parse_value(const std::string& str)
{
        T value;
        parse_value<T>(&value,str);
        return value;
}

template<>
inline double parse_value<double>(const std::string& str)
{
        double value=std::atof(str.c_str());
        // if unsure if conversion was successful
        if(value==0.0)
        {
                parse_value<double>(&value,str);
        }
        return value;
}


template<typename iter_type>
void parse_value(std::string *const dest,iter_type beg,iter_type end)
{
        dest->assign(beg,end);
}

template<typename iter_type>
void parse_value(uint64_t *const dest,iter_type beg,iter_type end)
{
        (*dest)=parse_uint64(beg,end);
}

template<typename iter_type>
void parse_value(int64_t *const dest,iter_type beg,iter_type end)
{
        (*dest)=parse_int64(beg,end);
}

template<typename T,typename iter_type>
void parse_value(T *const dest,iter_type beg,iter_type end,
  typename boost::enable_if<boost::is_integral<T> >::type *dummy_int=0,
  typename boost::enable_if<boost::is_signed<T> >::type *dummy_sign=0)
{
        const int64_t v=parse_int64(beg,end);
        if((v>int64_t(std::numeric_limits<T>::max()))
           ||(v<int64_t(std::numeric_limits<T>::min())))
                throw std::runtime_error("parse_value: out of range");
        (*dest)=v;
}

template<typename T,typename iter_type>
void parse_value(T *const dest,iter_type beg,iter_type end,
  typename boost::enable_if<boost::is_integral<T> >::type *dummy_int=0,
  typename boost::disable_if<boost::is_signed<T> >::type *dummy_sign=0)
{
        const uint64_t v=parse_uint64(beg,end);
        if(v>uint64_t(std::numeric_limits<T>::max()))
                throw std::runtime_error("parse_value: out of range");
        (*dest)=v;
}

template<typename Dest,typename Default>
void parse_envvar(Dest *const dest,const std::string &envvar,const Default &def)
{
        const char *const env=std::getenv(envvar.c_str());
        if(env!=0)
                parse_value(dest,env);
        else
                (*dest)=def;
}

template<typename Dest,typename Default>
Dest parse_envvar(const std::string &envvar,const Default &def)
{
        Dest ret;
        parse_envvar(&ret,envvar,def);
        return ret;
}


bool charcmp_ci(const char a,const char b);
bool charcmp_equal_ci(const char a,const char b);

template<typename Iterator>
bool equal_ci(const std::string &s,Iterator b,Iterator e)
{
        return (s.size()==size_t(e-b))&&std::equal(b,e,s.begin(),charcmp_equal_ci);
}

bool starts_with_cs(const std::string& s,const std::string& pref);
bool ends_with_cs(const std::string& s,const std::string& suff);
bool starts_with_ci(const std::string& s,const std::string& pref);
bool ends_with_ci(const std::string& s,const std::string& suff);
std::string toggle_suffix_cs(const std::string& s,const std::string& suff);
std::string remove_suffix_cs(const std::string& s,const std::string& suff);
std::string toggle_suffix_ci(const std::string& s,const std::string& suff);
std::string remove_suffix_ci(const std::string& s,const std::string& suff);


template<class T>
std::string lprefix(const T& what,const std::string& prefix)
{
        const std::string whatstr=to_string<T>(what);
        if(whatstr.empty())
                return whatstr;

        return prefix+join(split(whatstr,'\n'),"\n"+prefix);
}

std::vector<std::string> wrap_line(const std::string& line,const size_t maxlw);

void expand_tabs(std::istream& in,std::ostream& out,
                 const int colsep=4,
                 const std::vector<size_t>& maxwidths=std::vector<size_t>(),
                 const bool headings=true);

std::string expand_tabs(const std::string& str,
                        const int colsep=4,
                        const std::vector<size_t>& maxwidths=std::vector<size_t>(),
                        const bool headings=true);

template<class Iter>
std::string expand_tabs(const std::string& str,
                        const int colsep,
                        Iter b_maxwidths,Iter e_maxwidths,
                        const bool headings=true)
{
        const std::vector<size_t> maxwidths(b_maxwidths,e_maxwidths);
        return expand_tabs(str,colsep,maxwidths,headings);
}

template<typename Iter>
std::pair<Iter,Iter> trim(Iter beg,Iter end)
{
        while((beg!=end)&&std::isspace(*beg)) ++beg;
        while((beg!=end)&&std::isspace(*(end-1))) --end;
        return std::make_pair(beg,end);
}


template<class T>
struct manipd
{
        typedef std::ios_base& (*manip_type)(std::ios_base&);
        T value;
        const manip_type manip;
        char fill;
        int width;
        int precision;

        manipd(manip_type m=0,int f=0,int w=0,int p=0):
        manip(m),fill(f),width(w),precision(p)
        {}
        manipd(const T& v,manip_type m=0,int f=0,int w=0,int p=0)
        :value(v),manip(m),fill(f),width(w),precision(p)
        {}
};

template<class T>
std::ostream& operator<<(std::ostream& os,const manipd<T>& mp)
{
        const std::ios_base::fmtflags fl=os.flags();
        const int fc=os.fill();
        const int fw=os.width();
        const int pr=os.precision();

        if(mp.manip!=0)
                mp.manip(os);

        if(mp.fill>0)
                os.fill(mp.fill);
        if(mp.width>0)
                os.width(mp.width);
        if(mp.precision>0)
                os.precision(mp.precision);

        os<<mp.value;

        if(mp.precision>0)
                os.precision(pr);
        if(mp.width>0)
                os.width(fw);
        if(mp.fill>0)
                os.fill(fc);
        if(mp.manip!=0)
                os.flags(fl);
        return os;
}

template<class T>
std::istream& operator>>(std::istream& is,manipd<T>& mp)
{
        const std::ios_base::fmtflags fl=is.flags();
        if(mp.manip!=0)
                mp.manip(is);
        is>>mp.value;
        if(mp.manip!=0)
                is.flags(fl);
        return is;
}


// Helper for match_arg().
template<typename exception_type>
void throw_exception(const std::string &msg)
{
        throw exception_type(msg);
}

// Helper for match_arg().
template<>
inline void throw_exception<void>(const std::string &msg)
{}

template<class exception_type,class Iter>
Iter match_arg(
  const std::string& arg,Iter beg,Iter end,
  const std::string& exlabel=std::string("match_arg"))
{
        std::string arg_lc=arg;
        tolower(arg_lc);
        std::vector<std::string> matches;
        std::vector<Iter> positions;

        // perfect match, case sensitive
        for(Iter i=beg;i!=end;++i)
        {
                if((*i)==arg)
                        return i;
        }

        if(arg.empty())
                throw_exception<exception_type>(exlabel
                                                +" - tried to match an empty string");

        // perfect match, case insensitive
        for(Iter i=beg;i!=end;++i)
        {
                std::string match_lc=*i;
                tolower(match_lc);
                if(match_lc==arg_lc)
                {
                        matches.push_back(*i);
                        positions.push_back(i);
                }
        }

        if(!positions.empty())
        {
                if(positions.size()==1)
                        return positions.front();
                throw_exception<exception_type>(exlabel+" - ambiguous match for \""
                                                +arg+"\": "+join(matches,", "));
                return end;
        }

        // prefix match, case sensitive
        for(Iter i=beg;i!=end;++i)
        {
                if(i->substr(0,arg.size())==arg)
                {
                        matches.push_back(*i);
                        positions.push_back(i);
                }
        }

        if(!positions.empty())
        {
                if(positions.size()==1)
                        return positions.front();
                throw_exception<exception_type>(
                  exlabel+" - ambiguous match for \""+arg+"\": "+join(matches,", "));
                return end;
        }

        // prefix match, case insensitive
        for(Iter i=beg;i!=end;++i)
        {
                std::string match_lc=*i;
                tolower(match_lc);
                if(match_lc.substr(0,arg_lc.size())==arg_lc)
                {
                        matches.push_back(*i);
                        positions.push_back(i);
                }
        }

        if(positions.size()==1)
                return positions.front();

        if(positions.empty())
                throw_exception<exception_type>(exlabel+" - no match for \""+arg+"\"");

        if(positions.size()>1)
                throw_exception<exception_type>(exlabel+" - ambiguous match for \""
                                                +arg+"\": "+join(matches,", "));

        return end;
}

template<class Ex,class Iter>
size_t match_arg_idx(
  const std::string& arg,Iter beg,Iter end,
  const std::string& exlabel=std::string("match_arg"))
{
        return match_arg<Ex,Iter>(arg,beg,end,exlabel)-beg;
}

template<typename Enum,typename Iter>
std::istream &parse_enum(std::istream &in,Enum &dest,Iter beg,Iter end)
{
        std::string buf;
        in>>buf;

        try
        {
                dest=static_cast<Enum>(
                  match_arg_idx<std::runtime_error>(buf,beg,end));
        }
        catch(const std::runtime_error &)
        {
                in.setstate(std::ios_base::failbit);
        }
        return in;
}

template<typename Enum,int SZ>
std::istream &parse_enum(std::istream &in,Enum &dest,const std::string (&templ)[SZ])
{
        return parse_enum(in,dest,templ,end(templ));
}

template<typename Enum>
struct enum_traits;

#define MAKE_ENUM_TRAITS(T)\
        namespace shore {\
        template<>\
        struct enum_traits<T>\
        {\
                typedef std::istream istream_type;\
                typedef std::ostream ostream_type;\
                static const std::string values;\
                static const std::string description;\
        };\
        }

// Version of the MAKE_ENUM_TRAITS macro for use inside the shore namespace.
#define S_MAKE_ENUM_TRAITS(T)\
        template<>\
        struct enum_traits<T>\
        {\
                typedef std::istream istream_type;\
                typedef std::ostream ostream_type;\
                static const std::string values;\
                static const std::string description;\
        };

template<typename Enum>
typename enum_traits<Enum>::istream_type &operator>>(std::istream &in,Enum &en)
{
        const std::vector<std::string> values=
                shore::split(enum_traits<Enum>::values,'|');
        return shore::parse_enum(in,en,values.begin(),values.end());
}

template<typename Enum>
typename enum_traits<Enum>::ostream_type &operator<<(std::ostream &out,const Enum &en)
{
        const std::vector<std::string> labels=
                shore::split(enum_traits<Enum>::values,'|');
        if((static_cast<int>(en)<0)
           ||(static_cast<size_t>(en)>labels.size())
           ||labels[en].empty())
                return out<<"UNNAMED_ENUM_VALUE"<<static_cast<int>(en);
        return out<<labels[en];
}

} // namespace shore

#endif // SHORE_MISC_STRINGOPS_HPP__