##// END OF EJS Templates
HG_REPOSITORIES » LPP » INSTRUMENTATION » USERS » JEANDET » SciQLOPCore
RSS
Some work on SpectrogramTS Python wrapper...
Some work on SpectrogramTS Python wrapper Signed-off-by: Alexis Jeandet <alexis.jeandet@member.fsf.org>
jeandet - - Load All Authors

File last commit:

r4:96a6baa9f92b
r83:698d7cfa01b0
Show More
safer_string_typedef.hpp
581 lines | 21.1 KiB | text/x-c++hdr | CppLexer
/ include / opaque / experimental / safer_string_typedef.hpp
History | Source | Raw |Copy content |Copy permalink
jeandet
Introduced opaque library from Kyle Markley and improved DateTimeRange...
 r4 #ifndef OPAQUE_EXPERIMENTAL_SAFER_STRING_TYPEDEF_HPP
#define OPAQUE_EXPERIMENTAL_SAFER_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 "../data.hpp"
#include <memory>
#include <string>
namespace opaque {
namespace experimental {
/// \addtogroup typedefs
/// @{
///
/// Safer string opaque typedef base type
///
/// This is an opaque typedef base class for standard strings, but without
/// interoperability with character arrays in ways that would modify the
/// opaque object or create new opaque object instances.
///
/// Template arguments:
/// -# S : The string type (e.g. std::string)
/// -# R : The result type, your subclass
///
template <typename S, typename R>
struct safer_string_typedef : data<S,R> {
private:
using base = opaque::data<S,R>;
public:
using typename base::underlying_type;
using typename base::opaque_type;
using base::value;
typedef typename S::traits_type traits_type;
typedef typename S::value_type value_type;
typedef typename S::allocator_type allocator_type;
typedef typename S::size_type size_type;
typedef typename S::difference_type difference_type;
typedef typename S::reference reference;
typedef typename S::const_reference const_reference;
typedef typename S::pointer pointer;
typedef typename S::const_pointer const_pointer;
typedef typename S::iterator iterator;
typedef typename S::const_iterator const_iterator;
typedef typename S::reverse_iterator reverse_iterator;
typedef typename S::const_reverse_iterator const_reverse_iterator;
static const size_type npos = size_type(0)-size_type(1);
private:
typedef allocator_type Allocator;
typedef typename std::allocator_traits<Allocator>::value_type charT;
public:
//
// Constructor philosophy
//
// 1) Provide for explicit construction from an instance of underlying_type.
//
// 2) Constructors that have an argument of underlying_type are provided in
// in two flavors: an explicit one taking underlying_type, and one taking
// opaque_type that has the explicitness of the original.
//
// 3) Constructors that do not have an argument of underlying_type are made
// explicit.
//
explicit safer_string_typedef(const underlying_type& str) noexcept
: base(str) { }
explicit safer_string_typedef( underlying_type&& str) noexcept
: base(std::move(str)) { }
//
// The default constructor has the C++14 interface; a zero-argument
// form (defaulted below) and a single-argument form taking an Allocator.
//
explicit safer_string_typedef(const Allocator& a)
: base(a) { }
explicit safer_string_typedef(const underlying_type& str, size_type pos,
size_type n = npos, const Allocator& a = Allocator())
: base(str.value, pos, n, a) { }
safer_string_typedef(const opaque_type& str, size_type pos,
size_type n = npos, const Allocator& a = Allocator())
: base(str.value, pos, n, a) { }
explicit safer_string_typedef(const charT* s, size_type n,
const Allocator& a = Allocator())
: base(s, n, a) { }
explicit safer_string_typedef(const charT* s,
const Allocator& a = Allocator())
: base(s, a) { }
explicit safer_string_typedef(size_type n, charT c,
const Allocator& a = Allocator())
: base(n, c, a) { }
template <class InputIterator>
explicit safer_string_typedef(InputIterator Begin, InputIterator End,
const Allocator& a = Allocator())
: base(Begin, End, a) { }
explicit safer_string_typedef(std::initializer_list<charT> il,
const Allocator& a = Allocator())
: base(il, a) { }
explicit safer_string_typedef(const underlying_type& str, const Allocator& a)
: base(str.value, a) { }
explicit safer_string_typedef(underlying_type&& str, const Allocator& a)
: base(std::move(str.value), a) { }
safer_string_typedef(const opaque_type& str, const Allocator& a)
: base(str.value, a) { }
safer_string_typedef(opaque_type&& str, const Allocator& a)
: base(std::move(str.value), a) { }
// opaque_type& operator=(const charT* s);
opaque_type& operator=(charT c) {
value = c;
return downcast();
}
opaque_type& operator=(std::initializer_list<charT> il) {
value = il;
return downcast();
}
iterator begin() noexcept { return value.begin() ; }
const_iterator begin() const noexcept { return value.begin() ; }
iterator end() noexcept { return value.end() ; }
const_iterator end() const noexcept { return value.end() ; }
reverse_iterator rbegin() noexcept { return value.rbegin() ; }
const_reverse_iterator rbegin() const noexcept { return value.rbegin() ; }
reverse_iterator rend() noexcept { return value.rend() ; }
const_reverse_iterator rend() const noexcept { return value.rend() ; }
const_iterator cbegin() const noexcept { return value.cbegin() ; }
const_iterator cend() const noexcept { return value.cend() ; }
const_reverse_iterator crbegin() const noexcept { return value.crbegin(); }
const_reverse_iterator crend() const noexcept { return value.crend() ; }
size_type size() const noexcept { return value.size(); }
size_type length() const noexcept { return value.length(); }
size_type max_size() const noexcept { return value.max_size(); }
void resize(size_type n, charT c) { return value.resize(n, c); }
void resize(size_type n) { return value.resize(n); }
size_type capacity() const noexcept { return value.capacity(); }
void reserve(size_type res_arg = 0) { return value.reserve(res_arg); }
void shrink_to_fit() { return value.shrink_to_fit(); }
void clear() noexcept { return value.clear(); }
bool empty() const noexcept { return value.empty(); }
const_reference operator[](size_type pos) const { return value[pos]; }
reference operator[](size_type pos) { return value[pos]; }
const_reference at(size_type n) const { return value.at(n); }
reference at(size_type n) { return value.at(n); }
const charT& front() const { return value.front(); }
charT& front() { return value.front(); }
const charT& back() const { return value.back(); }
charT& back() { return value.back(); }
opaque_type& operator+=(const opaque_type& str) {
value += str.value;
return downcast();
}
// opaque_type& operator+=(const charT* s);
opaque_type& operator+=(charT c) {
value += c;
return downcast();
}
opaque_type& operator+=(std::initializer_list<charT> il) {
value += il;
return downcast();
}
opaque_type& append(const opaque_type& str) {
value.append(str.value);
return downcast();
}
// C++14 interface
opaque_type& append(const opaque_type& str, size_type pos,
size_type n = npos) {
value.append(str.value, pos, n);
return downcast();
}
//opaque_type& append(const charT* s, size_type n);
//opaque_type& append(const charT* s);
opaque_type& append(size_type n, charT c) {
value.append(n, c);
return downcast();
}
template <class InputIterator>
opaque_type& append(InputIterator first, InputIterator last) {
value.append(first, last);
return downcast();
}
opaque_type& append(std::initializer_list<charT> il) {
value.append(il);
return downcast();
}
void push_back(charT c) {
return value.push_back(c);
}
opaque_type& assign(const opaque_type& str) {
value.assign(str.value);
return downcast();
}
opaque_type& assign(opaque_type&& str) noexcept {
value.assign(std::move(str.value));
return downcast();
}
// C++14 interface
opaque_type& assign(const opaque_type& str, size_type pos,
size_type n = npos) {
value.assign(str.value, pos, n);
return downcast();
}
// opaque_type& assign(const charT* s, size_type n);
// opaque_type& assign(const charT* s);
opaque_type& assign(size_type n, charT c) {
value.assign(n, c);
return downcast();
}
template <class InputIterator>
opaque_type& assign(InputIterator first, InputIterator last) {
value.assign(first, last);
return downcast();
}
opaque_type& assign(std::initializer_list<charT> il) {
value.assign(il);
return downcast();
}
opaque_type& insert(size_type pos1, const opaque_type& str) {
value.insert(pos1, str.value);
return downcast();
}
// C++14 interface
opaque_type& insert(size_type pos1, const opaque_type& str,
size_type pos2, size_type n = npos) {
value.insert(pos1, str.value, pos2, n);
return downcast();
}
// opaque_type& insert(size_type pos, const charT* s, size_type n);
// opaque_type& insert(size_type pos, const charT* s);
opaque_type& insert(size_type pos, size_type n, charT c) {
value.insert(pos, n, c);
return downcast();
}
// C++03 interface
iterator insert(iterator p, charT c) {
return insert(p, c);
}
// C++03 interface
iterator insert(iterator p, size_type n, charT c) {
return insert(p, n, c);
}
// C++03 interface
template <class InputIterator>
iterator insert(iterator p, InputIterator first, InputIterator last) {
return insert(p, first, last);
}
iterator insert(const_iterator p, charT c) {
return insert(p, c);
}
iterator insert(const_iterator p, size_type n, charT c) {
return insert(p, n, c);
}
template <class InputIterator>
iterator insert(const_iterator p, InputIterator first, InputIterator last) {
return insert(p, first, last);
}
iterator insert(const_iterator p, std::initializer_list<charT> il) {
return insert(p, il);
}
opaque_type& erase(size_type pos = 0, size_type n = npos) {
value.erase(pos, n);
return downcast();
}
// C++03 interface
iterator erase(iterator p) {
return value.erase(p);
}
// C++03 interface
iterator erase(iterator first, iterator last) {
return value.erase(first, last);
}
iterator erase(const_iterator p) {
return value.erase(p);
}
iterator erase(const_iterator first, const_iterator last) {
return value.erase(first, last);
}
void pop_back() { return value.pop_back(); }
opaque_type& replace(size_type pos1, size_type n1, const opaque_type& str) {
value.replace(pos1, n1, str.value);
return downcast();
}
// C++14 interface
opaque_type& replace(size_type pos1, size_type n1, const opaque_type& str,
size_type pos2, size_type n2 = npos) {
value.replace(pos1, n1, str.value, pos2, n2);
return downcast();
}
// opaque_type& replace(size_type pos, size_type n1, const charT* s,
// size_type n2);
// opaque_type& replace(size_type pos, size_type n1, const charT* s);
opaque_type& replace(size_type pos, size_type n1, size_type n2, charT c) {
value.replace(pos, n1, n2, c);
return downcast();
}
opaque_type& replace(const_iterator i1, const_iterator i2,
const opaque_type& str) {
value.replace(i1, i2, str.value);
return downcast();
}
opaque_type& replace(const_iterator i1, const_iterator i2,
const charT* s, size_type n) {
value.replace(i1, i2, s, n);
return downcast();
}
opaque_type& replace(const_iterator i1, const_iterator i2,
const charT* s) {
value.replace(i1, i2, s);
return downcast();
}
opaque_type& replace(const_iterator i1, const_iterator i2,
size_type n, charT c) {
value.replace(i1, i2, n, c);
return downcast();
}
template <class InputIterator>
opaque_type& replace(const_iterator i1, const_iterator i2,
InputIterator j1, InputIterator j2) {
value.replace(i1, i2, j1, j2);
return downcast();
}
opaque_type& replace(const_iterator i1, const_iterator i2,
std::initializer_list<charT> il) {
value.replace(i1, i2, il);
return downcast();
}
size_type copy(charT* s, size_type n, size_type pos = 0) const {
return value.copy(s, n, pos);
}
void swap(opaque_type& str) { return value.swap(str.value); }
const charT* c_str() const noexcept { return value.c_str(); }
const charT* data() const noexcept { return value.data(); }
allocator_type get_allocator() const noexcept {
return value.get_allocator();
}
size_type find (const opaque_type& str, size_type pos = 0) const noexcept {
return value.find(str.value, pos);
}
size_type find (const charT* s, size_type pos, size_type n) const {
return value.find(s, pos, n);
}
size_type find (const charT* s, size_type pos = 0) const {
return value.find(s, pos);
}
size_type find (charT c, size_type pos = 0) const noexcept {
return value.find(c, pos);
}
size_type rfind(const opaque_type& str, size_type pos = npos) const noexcept {
return value.rfind(str.value, pos);
}
size_type rfind(const charT* s, size_type pos, size_type n) const {
return value.rfind(s, pos, n);
}
size_type rfind(const charT* s, size_type pos = npos) const {
return value.rfind(s, pos);
}
size_type rfind(charT c, size_type pos = npos) const noexcept {
return value.rfind(c, pos);
}
size_type find_first_of(const opaque_type& str, size_type pos = 0) const noexcept {
return value.find_first_of(str.value, pos);
}
size_type find_first_of(const charT* s, size_type pos, size_type n) const {
return value.find_first_of(s, pos, n);
}
size_type find_first_of(const charT* s, size_type pos = 0) const {
return value.find_first_of(s, pos);
}
size_type find_first_of(charT c, size_type pos = 0) const noexcept {
return value.find_first_of(c, pos);
}
size_type find_last_of (const opaque_type& str, size_type pos = npos) const noexcept {
return value.find_last_of(str.value, pos);
}
size_type find_last_of (const charT* s, size_type pos, size_type n) const {
return value.find_last_of(s, pos, n);
}
size_type find_last_of (const charT* s, size_type pos = npos) const {
return value.find_last_of(s, pos);
}
size_type find_last_of (charT c, size_type pos = npos) const noexcept {
return value.find_last_of(c, pos);
}
size_type find_first_not_of(const opaque_type& str, size_type pos = 0) const noexcept {
return value.find_first_not_of(str.value, pos);
}
size_type find_first_not_of(const charT* s, size_type pos, size_type n) const {
return value.find_first_not_of(s, pos, n);
}
size_type find_first_not_of(const charT* s, size_type pos = 0) const {
return value.find_first_not_of(s, pos);
}
size_type find_first_not_of(charT c, size_type pos = 0) const noexcept {
return value.find_first_not_of(c, pos);
}
size_type find_last_not_of (const opaque_type& str, size_type pos = npos) const noexcept {
return value.find_last_not_of(str.value, pos);
}
size_type find_last_not_of (const charT* s, size_type pos, size_type n) const {
return value.find_last_not_of(s, pos, n);
}
size_type find_last_not_of (const charT* s, size_type pos = npos) const {
return value.find_last_not_of(s, pos);
}
size_type find_last_not_of (charT c, size_type pos = npos) const noexcept {
return value.find_last_not_of(c, pos);
}
opaque_type substr(size_type pos = 0, size_type n = npos) const {
return opaque_type(value.substr(pos, n));
}
int compare(const opaque_type& str) const noexcept {
return value.compare(str.value);
}
int compare(size_type pos1, size_type n1, const opaque_type& str) const {
return value.compare(pos1, n1, str.value);
}
// C++14 interface
int compare(size_type pos1, size_type n1, const opaque_type& str,
size_type pos2, size_type n2 = npos) const {
return value.compare(pos1, n1, str.value, pos2, n2);
}
int compare(const charT* s) const {
return value.compare(s);
}
int compare(size_type pos1, size_type n1, const charT* s) const {
return value.compare(pos1, n1, s);
}
int compare(size_type pos1, size_type n1, const charT* s, size_type n2) const {
return value.compare(pos1, n1, s, n2);
}
friend opaque_type operator+(const opaque_type& l, const opaque_type& r) {
return opaque_type( l.value + r.value );
}
friend opaque_type operator+( opaque_type&& l, const opaque_type& r) {
return opaque_type(std::move(l.value) + r.value );
}
friend opaque_type operator+(const opaque_type& l, opaque_type&& r) {
return opaque_type( l.value + std::move(r.value));
}
friend opaque_type operator+( opaque_type&& l, opaque_type&& r) {
return opaque_type(std::move(l.value) + std::move(r.value));
}
// friend opaque_type operator+(const charT* lhs, const opaque_type& rhs);
// friend opaque_type operator+(const charT* lhs, opaque_type&& rhs);
friend opaque_type operator+( charT lhs, const opaque_type& rhs) {
return lhs + rhs.value ;
}
friend opaque_type operator+( charT lhs, opaque_type&& rhs) {
return lhs + std::move(rhs.value);
}
// friend opaque_type operator+(const opaque_type& lhs, const charT* rhs);
// friend opaque_type operator+( opaque_type&& lhs, const charT* rhs);
friend opaque_type operator+(const opaque_type& lhs, charT rhs) {
return lhs.value + rhs;
}
friend opaque_type operator+( opaque_type&& lhs, charT rhs) {
return std::move(lhs.value) + rhs;
}
friend bool operator==(const opaque_type& lhs, const opaque_type& rhs) {
return lhs.value == rhs.value;
}
friend bool operator==(const charT* lhs, const opaque_type& rhs) {
return lhs == rhs.value;
}
friend bool operator==(const opaque_type& lhs, const charT* rhs) {
return lhs.value == rhs ;
}
friend bool operator!=(const opaque_type& lhs, const opaque_type& rhs) {
return lhs.value != rhs.value;
}
friend bool operator!=(const charT* lhs, const opaque_type& rhs) {
return lhs != rhs.value;
}
friend bool operator!=(const opaque_type& lhs, const charT* rhs) {
return lhs.value != rhs ;
}
friend bool operator< (const opaque_type& lhs, const opaque_type& rhs) {
return lhs.value < rhs.value;
}
friend bool operator< (const charT* lhs, const opaque_type& rhs) {
return lhs < rhs.value;
}
friend bool operator< (const opaque_type& lhs, const charT* rhs) {
return lhs.value < rhs ;
}
friend bool operator> (const opaque_type& lhs, const opaque_type& rhs) {
return lhs.value > rhs.value;
}
friend bool operator> (const charT* lhs, const opaque_type& rhs) {
return lhs > rhs.value;
}
friend bool operator> (const opaque_type& lhs, const charT* rhs) {
return lhs.value > rhs ;
}
friend bool operator<=(const opaque_type& lhs, const opaque_type& rhs) {
return lhs.value <= rhs.value;
}
friend bool operator<=(const charT* lhs, const opaque_type& rhs) {
return lhs <= rhs.value;
}
friend bool operator<=(const opaque_type& lhs, const charT* rhs) {
return lhs.value <= rhs ;
}
friend bool operator>=(const opaque_type& lhs, const opaque_type& rhs) {
return lhs.value >= rhs.value;
}
friend bool operator>=(const charT* lhs, const opaque_type& rhs) {
return lhs >= rhs.value;
}
friend bool operator>=(const opaque_type& lhs, const charT* rhs) {
return lhs.value >= rhs ;
}
friend void swap(opaque_type& lhs, opaque_type& rhs) {
using std::swap;
return swap(lhs.value, rhs.value);
}
safer_string_typedef() = default;
safer_string_typedef(const safer_string_typedef& ) = default;
safer_string_typedef( safer_string_typedef&&) = default;
safer_string_typedef& operator=(const safer_string_typedef& ) = default;
safer_string_typedef& operator=( safer_string_typedef&&) = default;
protected:
~safer_string_typedef() = default;
using base::downcast;
};
/// @}
}
}
#endif