#ifndef OPAQUE_EXPERIMENTAL_STRING_TYPEDEF_HPP
#define OPAQUE_EXPERIMENTAL_STRING_TYPEDEF_HPP
//
// Copyright (c) 2016
// Kyle Markley.  All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// 1. Redistributions of source code must retain the above copyright notice,
//    this list of conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright notice,
//    this list of conditions and the following disclaimer in the documentation
//    and/or other materials provided with the distribution.
// 3. Neither the name of the author nor the names of any contributors may be
//    used to endorse or promote products derived from this software without
//    specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
#include "safer_string_typedef.hpp"
#include <memory>
#include <string>

namespace opaque {
namespace experimental {

/// \addtogroup typedefs
/// @{

///
/// String opaque typedef base type
///
/// This is an opaque typedef base class for standard strings.
///
/// Template arguments:
///  -# S : The string type (e.g. std::string)
///  -# R : The result type, your subclass
///
template <typename S, typename R>
struct string_typedef : safer_string_typedef<S,R> {
private:
  using base = safer_string_typedef<S,R>;
public:
  using typename base::underlying_type;
  using typename base::opaque_type;
  using base::value;

  using typename base::allocator_type;
  using typename base::size_type;
  using base::npos;

private:
  typedef          allocator_type Allocator;
  typedef typename std::allocator_traits<Allocator>::value_type charT;
public:

  using base::base;

  opaque_type& operator=(const charT* s) {
    value = s;
    return downcast();
  }

  opaque_type& operator+=(const charT* s) {
    value += s;
    return downcast();
  }
  opaque_type& append(const charT* s, size_type n) {
    value.append(s, n);
    return downcast();
  }
  opaque_type& append(const charT* s) {
    value.append(s);
    return downcast();
  }

  opaque_type& assign(const charT* s, size_type n) {
    value.assign(s, n);
    return downcast();
  }
  opaque_type& assign(const charT* s) {
    value.assign(s);
    return downcast();
  }

  opaque_type& insert(size_type pos, const charT* s, size_type n) {
    value.insert(pos, s, n);
    return downcast();
  }
  opaque_type& insert(size_type pos, const charT* s) {
    value.insert(pos, s);
    return downcast();
  }

  opaque_type& replace(size_type pos, size_type n1, const charT* s,
      size_type n2) {
    value.replace(pos, n1, s, n2);
    return downcast();
  }
  opaque_type& replace(size_type pos, size_type n1, const charT* s) {
    value.replace(pos, n1, s);
    return downcast();
  }

  friend opaque_type operator+(const charT* lhs, const opaque_type&  rhs) {
    return lhs +           rhs.value ;
  }
  friend opaque_type operator+(const charT* lhs,       opaque_type&& rhs) {
    return lhs + std::move(rhs.value);
  }
  friend opaque_type operator+(const opaque_type&  lhs, const charT* rhs) {
    return           lhs.value  + rhs;
  }
  friend opaque_type operator+(      opaque_type&& lhs, const charT* rhs) {
    return std::move(lhs.value) + rhs;
  }

  string_typedef() = default;
  string_typedef(const string_typedef& ) = default;
  string_typedef(      string_typedef&&) = default;
  string_typedef& operator=(const string_typedef& ) = default;
  string_typedef& operator=(      string_typedef&&) = default;
protected:
  ~string_typedef() = default;
  using base::downcast;
};

/// @}

}
}

#endif