string.hh

Go to the documentation of this file.

#pragma once
#undef NDEBUG
#include <cassert>
#include <string>
#include <iostream>

#include <vcsn/misc/escape.hh>
#include <vcsn/misc/flyweight.hh>

namespace vcsn
{
  class string_letters
  {
  public:
    using letter_t
      = boost::flyweight<std::string, boost::flyweights::no_tracking>;
    using word_t = std::vector<letter_t>;

    static std::string sname()
    {
      return "string_letters";
    }

    virtual std::string vname(bool = true) const
    {
      return sname();
    }

    word_t
    to_word(const letter_t l) const
    {
      return {l};
    }

    const word_t&
    to_word(const word_t& l) const
    {
      return l;
    }

    word_t
    concat(const letter_t l, const letter_t r) const
    {
      if (l == one_letter())
        {
          if (r == one_letter())
            return {};
          else
            return {r};
        }
      else if (r == one_letter())
        return {l};
      else
        return {l, r};
    }

    word_t
    concat(const word_t& l, const letter_t r) const
    {
      if (r == one_letter())
        return l;
      else
        {
          word_t res;
          res.reserve(l.size() + 1);
          res.insert(end(res), begin(l), end(l));
          res.insert(end(res), r);
          return res;
        }
    }

    word_t
    concat(const letter_t l, const word_t& r) const
    {
      if (l == one_letter())
        return r;
      else
        {
          word_t res;
          res.reserve(1 + r.size());
          res.insert(end(res), l);
          res.insert(end(res), begin(r), end(r));
          return res;
        }
    }

    word_t
    concat(const word_t& l, const word_t& r) const
    {
      if (is_empty_word(l))
        return r;
      else if (is_empty_word(r))
        return l;
      else
        {
          word_t res;
          res.reserve(l.size() + r.size());
          res.insert(end(res), begin(l), end(l));
          res.insert(end(res), begin(r), end(r));
          return res;
        }
    }

    word_t delimit(const word_t& w) const
    {
      return concat(concat(special_letter(), w), special_letter());
    }

    word_t undelimit(const word_t& w) const
    {
      size_t s = w.size();
      assert(2 <= s);
      assert(w[0] == special_letter());
      assert(w[s-1] == special_letter());
      return {begin(w) + 1, begin(w) + (s - 1)};
    }

    static word_t
    empty_word()
    {
      return {};
    }

    static bool
    is_empty_word(const word_t& w)
    {
      return w.empty();
    }

    word_t
    transpose(const word_t& w) const
    {
      // C++11 lacks std::rbegin/rend...
      return {w.rbegin(), w.rend()};
    }

    letter_t
    transpose(letter_t l) const
    {
      return l;
    }

    bool
    equals(const letter_t& l1, const letter_t& l2) const
    {
      return l1 == l2;
    }

    bool
    equals(const word_t& w1, const word_t& w2) const
    {
      return w1 == w2;
    }

    bool
    is_letter(const letter_t&) const
    {
      return true;
    }

    bool
    is_letter(const word_t& w) const
    {
      return w.size() == 1;
    }

    static letter_t one_letter() { return letter_t(""); }

  private:
    static letter_t special_letter() { return letter_t{"\xFF"}; }

  public:

    static char get_char(std::istream& i)
    {
      int res = i.get();
      if (res == EOF)
        throw std::domain_error("invalid label: unexpected end-of-file");
      else if (res == '\\')
        {
          res = i.get();
          if (res == EOF)
            throw std::domain_error("invalid label: unexpected end-of-file");
        }
      return res;
    }


    static letter_t get_letter(std::istream& i)
    {
      char c = get_char(i);
      if (c == '\'')
        {
          std::string res;
          while (true)
            {
              c = get_char(i);
              if (c == '\'')
                break;
              else
                res += c;
            }
          return letter_t{res};
        }
      else
        return letter_t{c};
    }

    std::ostream&
    print(const letter_t& l, std::ostream& o,
          const std::string& format = "text") const
    {
      if (l == special_letter())
        o << '$';
      else if (l == one_letter())
        o << "ε";
      else
        {
          if (format == "latex")
            o << "\\mathit{";
          o << l;
          if (format == "latex")
            o << '}';
        }
      return o;
    }

    std::ostream&
    print(const word_t& w, std::ostream& o,
          const std::string& format = "text") const
    {
      if (format == "latex")
        o << "\\mathit{";
      for (auto l: w)
        print(l, o, "text");
      if (format == "latex")
        o << '}';
      return o;
    }

    template <typename T = letter_t>
    static T special();
  };

  template <>
  inline
  string_letters::letter_t
  string_letters::special<string_letters::letter_t>()
  {
    return special_letter();
  }

  template <>
  inline
  string_letters::word_t
  string_letters::special<string_letters::word_t>()
  {
    return {special_letter()};
  }

}