#pragma once

#include <cstddef>
#include <vector>

namespace std {

  class string {

    std::vector<char> characters;

  public:
    constexpr string() : characters({'\0'}) {}

    constexpr string(const string &other)
    : characters(other.characters) {}

    constexpr string(string &&other) noexcept
    : characters(std::move(other.characters)) {
      other.characters.push_back('\0');
    }

    constexpr string(const char *s) {
      size_t count = 0;
      while (s[count] != '\0')
        ++count;
      characters.resize(count + 1);
      for (size_t i = 0; i <= count; ++i)
        characters[i] = s[i];
    }

    constexpr ~string() {}

    constexpr string &operator =(const string &str) {
      characters = str.characters;
      return *this;
    }

    constexpr string &operator =(string &&str) noexcept {
      characters = std::move(str.characters);
      str.characters.push_back('\0');
      return *this;
    }

    constexpr size_t size() const noexcept {
      return characters.size() - 1;
    }

    constexpr void resize(size_t count) {
      if (count < characters.size() - 1) {
        characters.resize(count + 1);
        characters[count] = '\0';
      }
      else if (count > characters.size() - 1)
        characters.resize(count + 1);
    }

    constexpr void clear() noexcept {
      resize(0);
    }

    constexpr const char *data() const noexcept {
      return characters.data();
    }

    constexpr char *data() noexcept {
      return characters.data();
    }

    constexpr char &operator[](size_t pos) {
      return characters[pos];
    }

    constexpr const char &operator[](size_t pos) const {
      return characters[pos];
    }

  };

}