Program Listing for File string_silent.hpp

↰ Return to documentation for file (/tmp/ws/src/apex_containers/apex_containers/include/string/string_silent.hpp)

// Copyright 2017-2018 Apex.AI, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.


#ifndef STRING__STRING_SILENT_HPP_
#define STRING__STRING_SILENT_HPP_

#include <apexutils/apexdef.h>
#include <apex_containers/visibility_control.hpp>

#include <stdexcept>
#include <cstring>
#include <algorithm>
#include <istream>
#include <ostream>
#include <string>

namespace apex
{

template<::size64_t STRING_BUFFER_SIZE>
class String : public BaseString<STRING_BUFFER_SIZE>
{
public:
  using iterator =
    typename apex::template BaseString<STRING_BUFFER_SIZE>::template abs_iterator<::char8_t>;
  using const_iterator = typename
    apex::template BaseString<STRING_BUFFER_SIZE>::template abs_iterator<const ::char8_t>;

  String(void) noexcept
  : apex::BaseString<STRING_BUFFER_SIZE>()
  {
  }

  String(const ::size64_t n, const ::char8_t c) noexcept
  : String()
  {
    const ::size64_t chars_to_fill = (n < this->capacity()) ? n : this->capacity();
    // Ignore unneeded returned pointer to destination
    (void)memset(this->m_string, c, chars_to_fill);
  }

  String & operator+=(const char8_t * const src) noexcept
  {
    if (src != nullptr) {
      const ::size64_t my_length = this->length();
      if (my_length < this->capacity()) {
        const ::size64_t their_length = ::strnlen(src, this->capacity());
        if (their_length > 0U) {
          const ::size64_t max_copy_size = this->capacity() - my_length;
          const ::size64_t copy_size =
            (max_copy_size < their_length) ? max_copy_size : their_length;
          (void)::memmove(&(this->m_string[my_length]), src, copy_size);
          this->m_string[my_length + copy_size] = '\0';
        }
      }
    }
    return *this;
  }

  String & operator+=(const char8_t chr) noexcept
  {
    const ::size64_t my_length = this->length();
    if (my_length < this->capacity()) {
      this->m_string[my_length] = chr;
      this->m_string[my_length + 1] = '\0';
    }
    return *this;
  }

  String(const ::char8_t * const str) noexcept  // NOLINT: constructors should be explicit
  : String()  // but we want to have ability to convert a classic char pointer to apex::string
  {
    *this += str;
  }

  explicit String(const ::apex_string_t & str) noexcept
  : String(str.c_str)
  {
  }

  template<::size64_t LEN>
  String(const apex::BaseString<LEN> & src) noexcept // NOLINT: constructors should be explicit but we
  : String(src.c_str())  // want to to convert a different legth string to apex::string
  {
  }

  explicit String(const apex::String<STRING_BUFFER_SIZE> & src) noexcept
  : String(src.c_str())
  {
  }

  // Addition

  template<::size64_t LEN>
  const apex::String<STRING_BUFFER_SIZE + LEN>
  operator+(const apex::String<LEN> & rhs) const noexcept
  {
    apex::String<STRING_BUFFER_SIZE + LEN> retval(*this);
    retval += rhs.c_str();
    return retval;
  }

  template<::size64_t LEN>
  auto
  operator+(const char (& rhs)[LEN]) const noexcept
  {
    apex::String<STRING_BUFFER_SIZE + LEN> retval(*this);
    retval += rhs;
    return retval;
  }

  const apex::String<STRING_BUFFER_SIZE + APEX_STRING_SIZE>
  operator+(const ::apex_string_t & rhs) const noexcept
  {
    apex::String<STRING_BUFFER_SIZE + APEX_STRING_SIZE> retval(*this);
    retval += rhs.c_str;
    return retval;
  }

  // Increments

  template<::size64_t LEN>
  apex::String<STRING_BUFFER_SIZE> & operator+=(const apex::String<LEN> & rhs) noexcept
  {
    *this += rhs.c_str();
    return *this;
  }

  apex::String<STRING_BUFFER_SIZE> & operator+=(const ::apex_string_t & src) noexcept
  {
    *this += src.c_str;
    return *this;
  }

  // Assignments

  String & operator=(const String & rhs) noexcept
  {
    // Ignore unneeded pointer to destination
    (void)::memset(&(this->m_string[0U]), 0, this->get_buffer_size());
    *this += rhs.c_str();
    return *this;
  }

  template<::size64_t LEN>
  apex::String<STRING_BUFFER_SIZE> & operator=(const apex::String<LEN> & rhs) noexcept
  {
    // Ignore unneeded pointer to destination
    (void)::memset(&(this->m_string[0U]), 0, this->get_buffer_size());
    *this += rhs.c_str();
    return *this;
  }

  apex::String<STRING_BUFFER_SIZE> & operator=(const ::char8_t * const src) noexcept
  {
    // Ignore unneeded pointer to destination
    (void)::memset(&(this->m_string[0U]), 0, this->get_buffer_size());
    *this += src;
    return *this;
  }

  apex::String<STRING_BUFFER_SIZE> & operator=(const ::apex_string_t & src) noexcept
  {
    // Ignore unneeded pointer to destination
    (void)::memset(&(this->m_string[0U]), 0, this->get_buffer_size());
    *this += src.c_str;
    return *this;
  }

  static apex::String<STRING_BUFFER_SIZE> to_string(const uint32_t value);

  iterator begin() noexcept
  {
    return iterator(&(BaseString<STRING_BUFFER_SIZE>::m_string[0U]));
  }

  iterator end() noexcept
  {
    return iterator(
      &(BaseString<STRING_BUFFER_SIZE>::m_string[0U]) + BaseString<STRING_BUFFER_SIZE>::size());
  }

  const_iterator cbegin() const noexcept
  {
    return const_iterator(
      &(BaseString<STRING_BUFFER_SIZE>::m_string[0U]));
  }

  const_iterator cend() const noexcept
  {
    return const_iterator(
      &(BaseString<STRING_BUFFER_SIZE>::m_string[0U]) + BaseString<STRING_BUFFER_SIZE>::size());
  }
};

template<::size64_t LEN>
inline apex::String<APEX_STRING_SIZE + LEN>
operator+(const ::apex_string_t & lhs, const apex::String<LEN> & rhs) noexcept
{
  String<APEX_STRING_SIZE + LEN> retval(lhs.c_str);
  retval += rhs.c_str();
  return retval;
}

template<::size64_t CSTR_LEN, ::size64_t APEX_STRING_LEN>
inline auto
operator+(const char (& lhs)[CSTR_LEN], const apex::String<APEX_STRING_LEN> & rhs)
{
  apex::String<CSTR_LEN + APEX_STRING_LEN> retval(lhs);
  retval += rhs;
  return retval;
}


using string8_t = String<8U>;
static_assert(sizeof(string8_t) == 8U, "sizeof(string8_t) != 8U");

using string16_t = String<16U>;
static_assert(sizeof(string16_t) == 16U, "sizeof(string16_t) != 16U");

using string32_t = String<32U>;
static_assert(sizeof(string32_t) == 32U, "sizeof(string32_t) != 32U");

using string64_t = String<64U>;
static_assert(sizeof(string64_t) == 64U, "sizeof(string64_t) != 64U");

using string128_t = String<128U>;
static_assert(sizeof(string128_t) == 128U, "sizeof(string8_t) != 128U");

using string256_t = String<APEX_STRING_SIZE>;
static_assert(sizeof(string256_t) == 256U, "sizeof(string256_t) != 256U");

template<size64_t STRING_BUFFER_SIZE>
typename ::std::istream & operator>>(
  std::istream & in_stream,
  apex::String<STRING_BUFFER_SIZE> & str)
{
  typename apex::String<STRING_BUFFER_SIZE>::iterator it = str.begin();
  return in_stream.getline(&(it[0U]), str.get_buffer_size());
}

}  // namespace apex

namespace std
{
template<size64_t SizeN>
struct hash<apex::String<SizeN>>: std::hash<apex::BaseString<SizeN>> {};
}  // namespace std

#endif  // STRING__STRING_SILENT_HPP_