const_super_string.hpp

#ifndef _BASIC_CONST_SUPER_STRING_HPP__
#define _BASIC_CONST_SUPER_STRING_HPP__


/* Copyright 2006 CrystalClear Software, Inc.
 * Use, modification and distribution is subject to the 
 * Boost Software License, Version 1.0. (See accompanying
 * file LICENSE-1.0 or http://www.boost.org/LICENSE-1.0)
 *
 * Author:  Jeff Garland 
 * Last Modified: $Date: 2006/07/03 02:43:02 $
 * Created: Sat Jun  29 14:02:41 2006 
 */


#include <boost/const_string/const_string.hpp>
#include <boost/const_string/concatenation.hpp>
#include <boost/const_string/io.hpp>

#include <boost/algorithm/string.hpp>
#include <boost/algorithm/string/regex.hpp>
#include <boost/regex.hpp>
#include <boost/format.hpp>
#include <string>
#include <vector>
#include <sstream>
#include <fstream>

template<class char_type>
class basic_const_super_string : public boost::const_string<char_type> {
public:
  typedef boost::const_string<char_type>              ss_base_string_type;
  typedef boost::const_string<char_type>              base_string_type;
  typedef std::basic_string<char_type>                std_string_type;
  typedef typename base_string_type::const_iterator   iterator_type;
  typedef typename base_string_type::size_type        size_type;
  typedef std::basic_stringstream<char_type>          string_stream_type;
  typedef std::vector<basic_const_super_string<char_type> > string_vector;
  
  basic_const_super_string() 
  {}

  basic_const_super_string(const char_type* const s) :
    base_string_type(s)
  {}

  basic_const_super_string(const base_string_type& s) :
    base_string_type(s)
  {}

  basic_const_super_string(iterator_type beg, iterator_type end) :
    base_string_type(beg, end)
  {}

  //Append contents of a file to the string
  basic_const_super_string append_file(const std_string_type& filepath) const;

  //See if the string contains the regular expression somewhere
  bool contains_regex (const base_string_type& s) const;

  //Query functions for start / contains
  bool contains    (const base_string_type& s) const;
  bool starts_with (const base_string_type& s, size_type offset=0) const;
  bool ends_with   (const base_string_type& s) const;

  //Case insensitive query functions 
  bool icontains   (const base_string_type& s) const;
  bool istarts_with(const base_string_type& s, size_type offset=0) const;
  bool iends_with  (const base_string_type& s) const;

  //Split the string based on the predicate string
  unsigned int split(const base_string_type& predicate, 
                     string_vector& result)             const;

  unsigned int split_regex(const base_string_type& predicate_regex, 
                           string_vector& result)             const;
  

  //Enhanced replace functions
  basic_const_super_string
  replace_all_regex  (const base_string_type& match_regex, 
                      const base_string_type& replace_regex) const;

  basic_const_super_string 
  replace_first(const base_string_type& match_string, 
                const base_string_type& replace_string) const;

  basic_const_super_string 
  replace_last (const base_string_type& match_string, 
                const base_string_type& replace_string) const;

  basic_const_super_string 
  replace_nth  (const base_string_type& match_string, 
                const base_string_type& replace_string, 
                size_type n) const;

  basic_const_super_string 
  replace_all  (const base_string_type& match_string, 
                const base_string_type& replace_string) const;

  //Case insensitive enhanced replace functions
  basic_const_super_string 
  ireplace_first(const base_string_type& match_string, 
                 const base_string_type& replace_string) const;

  basic_const_super_string 
  ireplace_last (const base_string_type& match_string, 
                 const base_string_type& replace_string) const;

  basic_const_super_string 
  ireplace_nth  (const base_string_type& match_string, 
                 const base_string_type& replace_string, 
                 size_type n) const;

  basic_const_super_string 
  ireplace_all  (const base_string_type& match_string, 
                 const base_string_type& replace_string) const;
  
  //White space trimming functions
  basic_const_super_string trim()       const;
  basic_const_super_string trim_left()  const;
  basic_const_super_string trim_right() const;
  

  //Case Conversion
  basic_const_super_string  to_lower() const;
  basic_const_super_string  to_upper() const;


  //Type  conversion functions
  //JKG TODO: look at doing some meta-programming magic to write
  //the these functions with few overloads.
  template<typename T>
  basic_const_super_string<char_type> append    (const T& value) const;

  template<typename T1, typename T2>
  basic_const_super_string<char_type> append    (const T1& val1, 
                                                 const T2& val2) const;

  template<typename T1, typename T2, typename T3>
  basic_const_super_string<char_type> append    (const T1& val1, 
                                                 const T2& val2,
                                                 const T3& val3) const;
  
  template<typename T1, typename T2, typename T3, typename T4>
  basic_const_super_string<char_type> append    (const T1& val1, 
                                                 const T2& val2,
                                                 const T3& val3,
                                                 const T4& val4) const;

  template<typename T1, typename T2, typename T3, typename T4, typename T5>
  basic_const_super_string<char_type> append    (const T1& val1, 
                                                 const T2& val2,
                                                 const T3& val3,
                                                 const T4& val4,
                                                 const T5& val5) const;
  template<class T>
  basic_const_super_string<char_type> prepend   (const T& value) const;

  template<class T> 
  basic_const_super_string<char_type> insert_at (size_type pos, 
                                                 const T& value) const;

  template<typename T> 
  basic_const_super_string<char_type> append_formatted (const T& value, 
                                                        const base_string_type& fmt) const;
  template<typename T1, typename T2> 
  basic_const_super_string<char_type> append_formatted (const T1& val1, 
                                                        const T2& val2,
                                                        const base_string_type& fmt) const;
  template<typename T1, typename T2, typename T3> 
  basic_const_super_string<char_type> append_formatted (const T1& val1, 
                                                        const T2& val2,
                                                        const T3& val3,
                                                        const base_string_type& fmt) const;
  template<typename T1, typename T2, typename T3, typename T4> 
  basic_const_super_string<char_type> append_formatted (const T1& val1, 
                                                        const T2& val2,
                                                        const T3& val3,
                                                        const T4& val4,
                                                        const base_string_type& fmt) const;
  template<typename T1, typename T2, typename T3, typename T4, typename T5> 
  basic_const_super_string<char_type> append_formatted (const T1& val1, 
                                                        const T2& val2,
                                                        const T3& val3,
                                                        const T4& val4,
                                                        const T5& val5,
                                                        const base_string_type& fmt) const;


private:

};


template<class char_type>
inline
basic_const_super_string<char_type>
basic_const_super_string<char_type>::append_file(const std_string_type& filepath) const
{
  std::ifstream infile(filepath.c_str());
  if (infile) {
    std::istreambuf_iterator<char> itr(infile);
    std::istreambuf_iterator<char> file_end;
    std_string_type data(itr, file_end);
    return base_string_type(this->str() + data);
  }
  return base_string_type();
}


template<class char_type>
inline
unsigned int 
basic_const_super_string<char_type>::split(const base_string_type& predicate, 
                                     string_vector& result) const
{

  namespace alg = boost::algorithm;
  
  alg::iter_split(result, *this, 
                  alg::first_finder(predicate, alg::is_equal()));
  
  //iter_split will return entire string if no matches found
  return result.size()-1; //todo bug here is result not empty
}

template<class char_type>
inline
unsigned int 
basic_const_super_string<char_type>::split_regex(const base_string_type& predicate_regex, 
                                                                   string_vector& result)  const
{

  boost::basic_regex<char_type> re(predicate_regex.begin(),
                                   predicate_regex.end());

  boost::regex_token_iterator<iterator_type> i(this->begin(), 
                                               this->end(), 
                                               re, -1);
  boost::regex_token_iterator<iterator_type> j;
  
  unsigned int count = 0;
  while(i != j) {
    base_string_type s(*i);
    result.push_back(s);
    count++;
    i++;
  }
  return count;
  
}


template<class char_type>
inline
bool
basic_const_super_string<char_type>::contains_regex(const base_string_type& predicate_regex) const
{
  boost::regex::basic_regex<char_type> pred(predicate_regex.begin(),
                                            predicate_regex.end());
  return boost::regex_search(this->begin(),
                             this->end(),
                             pred,
                             boost::match_default);
}


template<class char_type>
inline
basic_const_super_string<char_type>
basic_const_super_string<char_type>::replace_all_regex(const base_string_type& match_regex, 
                                                                         const base_string_type& replace_format) const
{
  boost::regex::basic_regex<char_type> pred(match_regex.str());
  return base_string_type(boost::algorithm::replace_all_regex_copy(this->str(), 
                                                                   pred, 
                                                                   replace_format.str()));
}


template<class char_type>
inline
basic_const_super_string<char_type>
basic_const_super_string<char_type>::replace_all(const base_string_type& match_string, 
                                                                   const base_string_type& replace_string) const
{
  return base_string_type(boost::algorithm::replace_all_copy(this->str(), 
                                                             match_string, 
                                                             replace_string));
}


template<class char_type>
inline
basic_const_super_string<char_type>
basic_const_super_string<char_type>::replace_nth(const base_string_type& match_string, 
                                                                   const base_string_type& replace_string,
                                                                   size_type n) const
{
  return base_string_type(boost::algorithm::replace_nth_copy(this->str(), 
                                                             match_string, 
                                                             n,
                                                             replace_string));
}


template<class char_type>
inline
basic_const_super_string<char_type>
basic_const_super_string<char_type>::replace_first(const base_string_type& match_string, 
                                                                     const base_string_type& replace_string) const
{
  return base_string_type(boost::algorithm::replace_first_copy(this->str(), 
                                                               match_string, 
                                                               replace_string));
}


template<class char_type>
inline
basic_const_super_string<char_type>
basic_const_super_string<char_type>::replace_last(const base_string_type& match_string, 
                                                                    const base_string_type& replace_string) const
{
  return base_string_type(boost::algorithm::replace_last_copy(this->str(), 
                                                              match_string, 
                                                              replace_string));
}

template<class char_type>
inline
basic_const_super_string<char_type>
basic_const_super_string<char_type>::ireplace_all(const base_string_type& match_string, 
                                                                    const base_string_type& replace_string) const
{
  return base_string_type(boost::algorithm::ireplace_all_copy(this->str(), 
                                                              match_string, 
                                                              replace_string));
}


template<class char_type>
inline
basic_const_super_string<char_type>
basic_const_super_string<char_type>::ireplace_nth(const base_string_type& match_string, 
                                                                    const base_string_type& replace_string,
                                                                    size_type n) const
{
  return base_string_type(boost::algorithm::ireplace_nth_copy(this->str(), 
                                                              match_string, 
                                                              n, 
                                                              replace_string));
}


template<class char_type>
inline
basic_const_super_string<char_type>
basic_const_super_string<char_type>::ireplace_first(const base_string_type& match_string, 
                                                                      const base_string_type& replace_string) const
{
  return base_string_type(boost::algorithm::ireplace_first_copy(this->str(), 
                                                                match_string, 
                                                                replace_string));
}


template<class char_type>
inline
basic_const_super_string<char_type>
basic_const_super_string<char_type>::ireplace_last(const base_string_type& match_string, 
                                                                     const base_string_type& replace_string) const
{
  return base_string_type(boost::algorithm::ireplace_last_copy(this->str(), 
                                                               match_string, 
                                                               replace_string));
}


template<class char_type>
inline
bool
basic_const_super_string<char_type>::contains(const base_string_type& predicate_string) const
{
  return boost::algorithm::contains(*this, predicate_string);
}

template<class char_type>
inline
bool
basic_const_super_string<char_type>::icontains(const base_string_type& predicate_string) const
{
  return boost::algorithm::icontains(*this, predicate_string);
}


template<class char_type>
inline
bool
basic_const_super_string<char_type>::ends_with(const base_string_type& predicate_string) const
{
  return boost::algorithm::ends_with(*this, predicate_string);
}

template<class char_type>
inline
bool
basic_const_super_string<char_type>::iends_with(const base_string_type& predicate_string) const
{
  return boost::algorithm::iends_with(*this, predicate_string);
}


template<class char_type>
inline
bool
basic_const_super_string<char_type>::starts_with(const base_string_type& predicate_string,
                                           size_type offset) const
{
  return boost::algorithm::starts_with(this->substr(offset), predicate_string);
}

template<class char_type>
inline
bool
basic_const_super_string<char_type>::istarts_with(const base_string_type& predicate_string, 
                                            size_type offset) const
{
  return boost::algorithm::istarts_with(this->substr(offset), predicate_string);
}


template<class char_type>
template<typename T>
inline
basic_const_super_string<char_type>
basic_const_super_string<char_type>::append(const T& value) const
{
  string_stream_type ss;
  ss << value;
  return base_string_type(*this + ss.str());
}


template<class char_type>
template<typename T1, typename T2>
inline
basic_const_super_string<char_type>
basic_const_super_string<char_type>::append(const T1& val1, const T2& val2) const
{
  string_stream_type ss;
  ss << val1 << val2;
  return base_string_type(*this + ss.str());
}

template<class char_type>
template<typename T1, typename T2, typename T3>
inline
basic_const_super_string<char_type>
basic_const_super_string<char_type>::append(const T1& val1, 
                                                              const T2& val2,
                                                              const T3& val3) const
{
  string_stream_type ss;
  ss << val1 << val2 << val3;
  return base_string_type(*this + ss.str());
}


template<class char_type>
template<typename T1, typename T2, typename T3, typename T4>
inline
basic_const_super_string<char_type>
basic_const_super_string<char_type>::append(const T1& val1, 
                                            const T2& val2,
                                            const T3& val3,
                                            const T4& val4) const
{
  string_stream_type ss;
  ss << val1 << val2 << val3 << val4;
  return base_string_type(*this + ss.str());
}

template<class char_type>
template<typename T1, typename T2, typename T3, typename T4, typename T5>
inline
basic_const_super_string<char_type>
basic_const_super_string<char_type>::append(const T1& val1, 
                                            const T2& val2,
                                            const T3& val3,
                                            const T4& val4,
                                            const T5& val5) const
{
  string_stream_type ss;
  ss << val1 << val2 << val3 << val4 << val5;
  return base_string_type(*this + ss.str());
}


template<class char_type>
template<typename T>
inline
basic_const_super_string<char_type>
basic_const_super_string<char_type>::append_formatted(const T& value, 
                                                      const base_string_type& format) const
{
  boost::format f(format.str());
  string_stream_type ss;
  ss << *this << f % value;
  return base_string_type(ss.str());
}


template<class char_type>
template<typename T1, typename T2>
inline
basic_const_super_string<char_type>
basic_const_super_string<char_type>::append_formatted(const T1& val1,
                                                      const T2& val2,
                                                      const base_string_type& format) const
{
  boost::format f(format.str());
  string_stream_type ss;
  ss << *this << f % val1 % val2;
  return base_string_type(ss.str());
}

template<class char_type>
template<typename T1, typename T2, typename T3>
inline
basic_const_super_string<char_type>
basic_const_super_string<char_type>::append_formatted(const T1& val1,
                                                      const T2& val2,
                                                      const T3& val3,
                                                      const base_string_type& format) const
{
  boost::format f(format.str());
  string_stream_type ss;
  ss << *this << f % val1 % val2 % val3;
  return base_string_type(ss.str());
}


template<class char_type>
template<typename T1, typename T2, typename T3, typename T4>
inline
basic_const_super_string<char_type>
basic_const_super_string<char_type>::append_formatted(const T1& val1,
                                                      const T2& val2,
                                                      const T3& val3,
                                                      const T4& val4,
                                                      const base_string_type& format) const
{
  boost::format f(format.str());
  string_stream_type ss;
  ss << *this << f % val1 % val2 % val3 % val4;
  return base_string_type(ss.str());
}

template<class char_type>
template<typename T1, typename T2, typename T3, typename T4, typename T5>
inline
basic_const_super_string<char_type>
basic_const_super_string<char_type>::append_formatted(const T1& val1,
                                                      const T2& val2,
                                                      const T3& val3,
                                                      const T4& val4,
                                                      const T5& val5,
                                                      const base_string_type& format) const
{
  boost::format f(format.str());
  string_stream_type ss;
  ss << *this << f % val1 % val2 % val3 % val4 % val5;
  return base_string_type(ss.str());
}


template<class char_type>
template<class T>
inline
basic_const_super_string<char_type>
basic_const_super_string<char_type>::prepend(const T& value) const
{
  string_stream_type ss;
  ss << value;
  return base_string_type(ss.str()+this->str());
}

template<class char_type>
template<class T>
inline
basic_const_super_string<char_type>
basic_const_super_string<char_type>::insert_at(size_type position, 
                                               const T& value) const
{
  string_stream_type ss;
  ss << this->substr(0, position) << value << this->substr(position);
  
  return base_string_type(ss.str());
}



template<class char_type>
inline
basic_const_super_string<char_type>
basic_const_super_string<char_type>::to_upper() const
{
  //TODO: more hacking here...pure to_upper_copy fails
  std::basic_string<char_type> s(this->str());
  boost::algorithm::to_upper(s);
  return basic_const_super_string<char_type>(s);
}


template<class char_type>
inline
basic_const_super_string<char_type>
basic_const_super_string<char_type>::to_lower() const
{
  //TODO: more hacking here...pure to_upper_copy fails
  std::basic_string<char_type> s(this->str());
  boost::algorithm::to_lower(s);
  return basic_const_super_string<char_type>(s);
}

template<class char_type>
inline
basic_const_super_string<char_type>
basic_const_super_string<char_type>::trim() const
{
  return boost::algorithm::trim_copy(*this);
}



template<class char_type>
inline
basic_const_super_string<char_type>
basic_const_super_string<char_type>::trim_left() const
{
  return boost::algorithm::trim_left_copy(*this);
}


template<class char_type>
inline
basic_const_super_string<char_type>
basic_const_super_string<char_type>::trim_right() const
{
  return boost::algorithm::trim_right_copy(*this);
}



typedef basic_const_super_string<char> const_super_string;

typedef basic_const_super_string<wchar_t> wconst_super_string;


#endif

---