fixed_string.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2014-2015, Hewlett-Packard Development Company, LP.
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the Free
 * Software Foundation; either version 2 of the License, or (at your option)
 * any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details. You should have received a copy of the GNU General Public
 * License along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 *
 * HP designates this particular file as subject to the "Classpath" exception
 * as provided by HP in the LICENSE.txt file that accompanied this code.
 */
#ifndef FOEDUS_ASSORTED_FIXED_STRING_HPP_
#define FOEDUS_ASSORTED_FIXED_STRING_HPP_
#include <stdint.h>

#include <algorithm>
#include <cstring>
#include <cwchar>
#include <ostream>
#include <string>

#include "foedus/assert_nd.hpp"
#include "foedus/cxx11.hpp"

namespace foedus {
namespace assorted {

template <uint MAXLEN, typename CHAR = char>
class FixedString {
 public:
  FixedString() CXX11_NOEXCEPT : length_(0) {}

  template <uint MAXLEN2>
  explicit FixedString(const FixedString<MAXLEN2, CHAR>& other) CXX11_NOEXCEPT { assign(other); }

  FixedString(const CHAR* str, uint32_t len) CXX11_NOEXCEPT { assign(str, len); }

  FixedString(const CHAR* str) CXX11_NOEXCEPT {  // NOLINT(runtime/explicit) follows std::string
    assign(str, strlen(str));
  }

  static uint32_t strlen(const char* str) CXX11_NOEXCEPT { return std::strlen(str); }
  static uint32_t strlen(const wchar_t* str) CXX11_NOEXCEPT { return std::wcslen(str); }

  template <uint MAXLEN2>
  FixedString& operator=(const FixedString<MAXLEN2, CHAR>& other) CXX11_NOEXCEPT {
    assign(other);
    return *this;
  }

  template <uint MAXLEN2>
  bool operator==(const FixedString<MAXLEN2, CHAR>& other) const CXX11_NOEXCEPT {
    if (length_ == 0) {
      return other.length() == 0;
    }
    return length_ == other.length() &&
      std::memcmp(data_, other.data(), length_ * sizeof(CHAR)) == 0;
  }
  template <uint MAXLEN2>
  bool operator!=(const FixedString<MAXLEN2, CHAR>& other) const CXX11_NOEXCEPT {
    return !operator==(other);
  }
  template <uint MAXLEN2>
  bool operator<(const FixedString<MAXLEN2, CHAR>& other) const CXX11_NOEXCEPT {
    uint32_t min_len = std::min<uint32_t>(length_, other.length());
    if (min_len == 0) {
      return length_ < other.length();
    }
    int result = std::memcmp(data_, other.data(), min_len * sizeof(CHAR));
    if (result != 0) {
      return result < 0;
    }
    return length_ < other.length();
  }

  template <uint MAXLEN2>
  void      assign(const FixedString<MAXLEN2, CHAR>& other) CXX11_NOEXCEPT {
    ASSERT_ND(other.length() <= MAXLEN2);
    length_ = other.length() > MAXLEN ? MAXLEN : other.length();
    std::memcpy(data_, other.data(), length_ * sizeof(CHAR));
  }
  void      assign(const std::basic_string<CHAR>& str) CXX11_NOEXCEPT {
    length_ = str.size() > MAXLEN ? MAXLEN : str.size();
    std::memcpy(data_, str.data(), length_ * sizeof(CHAR));
  }

  void      assign(const CHAR* str, uint32_t len) CXX11_NOEXCEPT {
    length_ = len > MAXLEN ? MAXLEN : len;
    std::memcpy(data_, str, length_ * sizeof(CHAR));
  }

  template <uint MAXLEN2>
  void      append(const FixedString<MAXLEN2, CHAR>& other) CXX11_NOEXCEPT {
    ASSERT_ND(other.length() <= MAXLEN2);
    uint32_t len = length_ + other.length() > MAXLEN ? MAXLEN - length_ : other.length();
    std::memcpy(data_ + length_, other.data(), len * sizeof(CHAR));
    length_ += len;
  }

  void      append(const std::basic_string<CHAR>& str) CXX11_NOEXCEPT {
    uint32_t len = length_ + str.size() > MAXLEN ? MAXLEN - length_ : str.size();
    std::memcpy(data_ + length_, str.data(), len * sizeof(CHAR));
    length_ += len;
  }

  void      append(const CHAR* str, uint32_t len) CXX11_NOEXCEPT {
    len = length_ + len > MAXLEN ? MAXLEN - length_ : len;
    std::memcpy(data_ + length_, str, len * sizeof(CHAR));
    length_ += len;
  }

  // the following methods imitate std::string signatures.

  uint32_t  length() const CXX11_NOEXCEPT { return length_; }
  uint32_t  size() const CXX11_NOEXCEPT { return length_; }
  uint32_t  capacity() const CXX11_NOEXCEPT { return MAXLEN; }
  uint32_t  max_size() const CXX11_NOEXCEPT { return MAXLEN; }
  void      clear() CXX11_NOEXCEPT { length_ = 0; }
  bool      empty() const CXX11_NOEXCEPT { return length_ == 0; }
  void      zero_fill_remaining() const CXX11_NOEXCEPT {
    if (length_ < MAXLEN) {
      // this is not logically changing the content, so const is the right semantics.
      std::memset(const_cast<char*>(data_ + length_), 0, MAXLEN - length_);
    }
  }


  const CHAR* data() const CXX11_NOEXCEPT { return data_; }
  std::basic_string<CHAR> str() const {
    return std::basic_string<CHAR>(data_, length_);
  }
  const CHAR* c_str() const { return str().c_str(); }

  static const uint32_t npos = -1;

  friend std::ostream& operator<<(std::ostream& o, const FixedString& v) {
    o << v.str();
    return o;
  }

 private:
  uint32_t  length_;        // +4
  CHAR      data_[MAXLEN];  // +MAXLEN
};

}  // namespace assorted
}  // namespace foedus
#endif  // FOEDUS_ASSORTED_FIXED_STRING_HPP_