TStrings.h

Go to the documentation of this file.

#pragma once
#include <misc/gen/TVector.h>
 
namespace sf
{
 
template<typename T, typename CharType>
class TStrings : public TVector<T>
{
  public:
    typedef TVector<T> base_type;
    typedef typename base_type::size_type size_type;
    typedef typename base_type::value_type value_type;
    typedef TIterator<value_type> iter_type;
    typedef const iter_type const_iter_type;
    TStrings() = default;
 
    template<typename InputIterator>
    TStrings(InputIterator first, InputIterator last)
      : base_type(first, last)
    {}
 
    explicit TStrings(std::initializer_list<value_type> list)
      : base_type(list)
    {}
 
    explicit TStrings(const base_type& list)
      : base_type(list)
    {}
 
    explicit TStrings(size_type sz)
      : base_type(sz)
    {}
 
    explicit TStrings(const T& str, const T& separator = ",")
    {
      explode(str, separator);
    }
 
    T join(const T& glue)
    {
      T rv;
      // Iterate through the vector.
      auto it = TVector<T>::begin();
      while (it < TVector<T>::end())
      {
        rv.append(*it++);
        // When not the end entry add the glue.
        if (it < TVector<T>::end())
        {
          rv.append(glue);
        }
      }
      return rv;
    }
 
    TStrings& explode(const T& str, const T& separator)
    {
      size_t ofs = 0, found = str.find_first_of(separator, ofs);
      if (found != std::string::npos)
      {
        do
        {
          base_type::push_back(str.substr(ofs, found - ofs));
          ofs = found + 1;
          if (ofs == T::npos)
          {
            break;
          }
          found = str.find_first_of(separator, ofs);
        } while (found != T::npos);
      }
      if (str.length() > ofs)
      {
        base_type::push_back(str.substr(ofs, str.length()));
      }
      return *this;
    }
 
    TStrings& split(const T& s, CharType sep, CharType delimiter = 0)
    {
 
      bool d = false;
      size_type p = 0, l = 0, i = 0;
      for (; i < s.length(); i++)
      {
        // When the character is a separator
        if (s[i] == sep && !d)
        {
          // First field is empty.
          if (i == 0)
          {
            base_type::append({});
          }
          else
          {
            p += i - l;
            base_type::append(s.substr(p, l));
            l = 0;
            p = 0;
          }
        }
        else
        {
          // if text delimiter was given.
          if (delimiter && s[i] == delimiter)
          {
            // Toggle delimiter flag when flag is encountered.
            d = !d;
            // Skip
            if (d)
            {
              p--;
            }
          }
          else
          {
            // Count the number of characters for the field.
            l++;
          }
        }
      }
      // Check for characters after last separator;
      if (l)
      {
        p += i - l;
        base_type::append(s.substr(p, l));
      }
      return *this;
    }
};
 
typedef TStrings<std::string, std::string::value_type> strings;
typedef TStrings<std::wstring, std::wstring::value_type> wstrings;
 
}// namespace sf