String and BufferIterator value_type goes back to plain char

1 files changed, 14 insertions, 49 deletions

diff --git a/src/string.hh b/src/string.hh
index 2e8172c1..31af1986 100644
--- a/src/string.hh
+++ b/src/string.hh
@@ -11,8 +11,8 @@
 namespace Kakoune
 {
 
-typedef wchar_t Character;
-typedef boost::basic_regex<Character> Regex;
+typedef int32_t Character;
+typedef boost::regex Regex;
 
 class String
 {
@@ -22,11 +22,11 @@ public:
    String(std::string content) : m_content(std::move(content)) {}
    String(const String& string) = default;
    String(String&& string) = default;
-   explicit String(Character content) : m_content(std::string() + (char)content) {}
+   explicit String(char content) : m_content(std::string() + content) {}
    template<typename Iterator>
    String(Iterator begin, Iterator end) : m_content(begin, end) {}
 
-   Character operator[](CharCount pos) const { return static_cast<Character>(m_content[(int)pos]); }
+   char      operator[](CharCount pos) const { return m_content[(int)pos]; }
    CharCount length() const { return m_content.length(); }
    bool      empty()  const { return m_content.empty(); }
 
@@ -40,8 +40,8 @@ public:
    String    operator+  (const String& other) const { return String(m_content + other.m_content); }
    String&   operator+= (const String& other)       { m_content += other.m_content; return *this; }
 
-   String    operator+  (Character character) const { return String(m_content + (char)character); }
-   String&   operator+= (Character character)       { m_content += (char)character; return *this; }
+   String    operator+  (char c) const { return String(m_content + c); }
+   String&   operator+= (char c)       { m_content += c; return *this; }
 
    memoryview<char> data()  const { return memoryview<char>(m_content.data(), m_content.size()); }
    const char*      c_str() const { return m_content.c_str(); }
@@ -49,50 +49,15 @@ public:
    String substr(CharCount pos, CharCount length = -1) const { return String(m_content.substr((int)pos, (int)length)); }
    String replace(const String& expression, const String& replacement) const;
 
-   class iterator
-   {
-   public:
-       typedef Character         value_type;
-       typedef const value_type* pointer;
-       typedef const value_type& reference;
-       typedef size_t            difference_type;
-       typedef std::random_access_iterator_tag iterator_category;
-
-       iterator() {}
-       iterator(const std::string::const_iterator& it) : m_iterator(it) {}
-
-       Character operator*()
-       { return static_cast<Character>(*m_iterator); }
-
-       iterator& operator++ () { ++m_iterator; return *this; }
-       iterator& operator-- () { --m_iterator; return *this; }
-
-       iterator operator+ (size_t size) { return iterator(m_iterator + size); }
-       iterator operator- (size_t size) { return iterator(m_iterator - size); }
-
-       iterator& operator+= (size_t size) { m_iterator += size; return *this; }
-       iterator& operator-= (size_t size) { m_iterator -= size; return *this; }
-
-       size_t operator- (const iterator& other) const { return m_iterator - other.m_iterator; }
-
-       bool operator== (const iterator& other) const { return m_iterator == other.m_iterator; }
-       bool operator!= (const iterator& other) const { return m_iterator != other.m_iterator; }
-       bool operator<  (const iterator& other) const { return m_iterator < other.m_iterator; }
-       bool operator<= (const iterator& other) const { return m_iterator <= other.m_iterator; }
-       bool operator>  (const iterator& other) const { return m_iterator > other.m_iterator; }
-       bool operator>= (const iterator& other) const { return m_iterator >= other.m_iterator; }
-
-   private:
-       std::string::const_iterator m_iterator;
-   };
+   using iterator = std::string::const_iterator;
 
-   iterator  begin() const { return iterator(m_content.begin()); }
-   iterator  end()   const { return iterator(m_content.end()); }
+   iterator begin() const { return m_content.begin(); }
+   iterator end()   const { return m_content.end(); }
 
-   Character front() const { return Character(m_content.front()); }
-   Character back()  const { return Character(m_content.back()); }
+   char     front() const { return m_content.front(); }
+   char     back()  const { return m_content.back(); }
 
-   size_t    hash() const { return std::hash<std::string>()(m_content); }
+   size_t   hash() const { return std::hash<std::string>()(m_content); }
 
    inline friend std::ostream& operator<<(std::ostream& os, const String& str)
    {
@@ -110,14 +75,14 @@ inline String operator+(const char* lhs, const String& rhs)
     return String(lhs) + rhs;
 }
 
-inline String operator+(Character lhs, const String& rhs)
+inline String operator+(char lhs, const String& rhs)
 {
     return String(lhs) + rhs;
 }
 
 String int_to_str(int value);
 int    str_to_int(const String& str);
-std::vector<String> split(const String& str, Character separator);
+std::vector<String> split(const String& str, char separator);
 
 inline bool is_word(Character c)
 {