Loading...
Searching...
No Matches
u16string.h
Go to the documentation of this file.
/******************************************************************************
The MIT License(MIT)
Embedded Template Library.
https://github.com/ETLCPP/etl
https://www.etlcpp.com
Copyright(c) 2016 John Wellbelove
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files(the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions :
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
******************************************************************************/
#ifndef ETL_U16STRING_INCLUDED
#define ETL_U16STRING_INCLUDED
#include "platform.h"
#include "basic_string.h"
#include "hash.h"
#include "initializer_list.h"
#include "string_view.h"
#include "private/minmax_push.h"
namespace etl
{
#if ETL_USING_CPP11
inline namespace literals
{
inline namespace string_literals
{
inline constexpr etl::u16string_view operator""_sv(const char16_t* str, size_t length) ETL_NOEXCEPT
{
return etl::u16string_view{str, length};
}
} // namespace string_literals
} // namespace literals
#endif
typedef ibasic_string<char16_t> iu16string;
//***************************************************************************
//***************************************************************************
template <size_t MAX_SIZE_>
class u16string : public iu16string
{
public:
typedef iu16string base_type;
typedef iu16string interface_type;
typedef iu16string::value_type value_type;
static const size_t MAX_SIZE = MAX_SIZE_;
//*************************************************************************
//*************************************************************************
u16string()
: iu16string(reinterpret_cast<value_type*>(&buffer), MAX_SIZE)
{
this->initialise();
}
//*************************************************************************
//*************************************************************************
u16string(const etl::u16string<MAX_SIZE_>& other)
: iu16string(reinterpret_cast<value_type*>(&buffer), MAX_SIZE)
{
this->assign(other);
}
//*************************************************************************
//*************************************************************************
u16string(const etl::iu16string& other)
: iu16string(reinterpret_cast<value_type*>(&buffer), MAX_SIZE)
{
this->assign(other);
}
//*************************************************************************
//*************************************************************************
u16string(const etl::iu16string& other, size_type position, size_type length = npos)
: iu16string(reinterpret_cast<value_type*>(&buffer), MAX_SIZE)
{
ETL_ASSERT(position < other.size(), ETL_ERROR(string_out_of_bounds));
this->assign(other, position, length);
}
//*************************************************************************
//*************************************************************************
ETL_EXPLICIT_STRING_FROM_CHAR u16string(const value_type* text)
: iu16string(reinterpret_cast<value_type*>(&buffer), MAX_SIZE)
{
this->assign(text);
}
//*************************************************************************
//*************************************************************************
u16string(const value_type* text, size_type count)
: iu16string(reinterpret_cast<value_type*>(&buffer), MAX_SIZE)
{
this->assign(text, text + count);
}
//*************************************************************************
//*************************************************************************
u16string(size_type count, value_type c)
: iu16string(reinterpret_cast<value_type*>(&buffer), MAX_SIZE)
{
this->initialise();
this->resize(count, c);
}
//*************************************************************************
//*************************************************************************
template <typename TIterator>
u16string(TIterator first, TIterator last, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0)
: iu16string(reinterpret_cast<value_type*>(&buffer), MAX_SIZE)
{
this->assign(first, last);
}
#if ETL_HAS_INITIALIZER_LIST
//*************************************************************************
//*************************************************************************
u16string(std::initializer_list<value_type> init)
: iu16string(reinterpret_cast<value_type*>(&buffer), MAX_SIZE)
{
this->assign(init.begin(), init.end());
}
#endif
//*************************************************************************
//*************************************************************************
explicit u16string(const etl::u16string_view& view)
: iu16string(reinterpret_cast<value_type*>(&buffer), MAX_SIZE)
{
this->assign(view.begin(), view.end());
}
//*************************************************************************
//*************************************************************************
etl::u16string<MAX_SIZE_> substr(size_type position = 0, size_type length_ = npos) const
{
etl::u16string<MAX_SIZE_> new_string;
if (position != size())
{
ETL_ASSERT(position < size(), ETL_ERROR(string_out_of_bounds));
length_ = etl::min(length_, size() - position);
new_string.assign(buffer + position, buffer + position + length_);
}
return new_string;
}
//*************************************************************************
//*************************************************************************
u16string& operator=(const u16string& rhs)
{
if (&rhs != this)
{
this->assign(rhs);
}
return *this;
}
//*************************************************************************
//*************************************************************************
u16string& operator=(const value_type* text)
{
this->assign(text);
return *this;
}
//*************************************************************************
//*************************************************************************
u16string& operator=(const etl::u16string_view& view)
{
this->assign(view);
return *this;
}
//*************************************************************************
//*************************************************************************
#if ETL_HAS_ISTRING_REPAIR
virtual void repair() ETL_OVERRIDE
#else
void repair()
#endif
{
etl::iu16string::repair_buffer(buffer);
}
private:
value_type buffer[MAX_SIZE + 1];
};
//***************************************************************************
//***************************************************************************
class u16string_ext : public iu16string
{
public:
typedef iu16string base_type;
typedef iu16string interface_type;
typedef iu16string::value_type value_type;
typedef iu16string::size_type size_type;
//*************************************************************************
//*************************************************************************
u16string_ext(value_type* buffer, size_type buffer_size)
: iu16string(buffer, buffer_size - 1U)
{
this->initialise();
}
//*************************************************************************
//*************************************************************************
template <size_t Size>
u16string_ext(value_type (&buffer)[Size])
: iu16string(buffer, Size - 1U)
{
this->initialise();
}
//*************************************************************************
//*************************************************************************
u16string_ext(const etl::u16string_ext& other, value_type* buffer, size_type buffer_size)
: iu16string(buffer, buffer_size - 1U)
{
if (this->is_within_buffer(other.data()))
{
this->current_size = other.size();
}
else
{
this->assign(other);
}
}
//*************************************************************************
//*************************************************************************
u16string_ext(const etl::iu16string& other, value_type* buffer, size_type buffer_size)
: iu16string(buffer, buffer_size - 1U)
{
if (this->is_within_buffer(other.data()))
{
this->current_size = other.size();
}
else
{
this->assign(other);
}
}
//*************************************************************************
//*************************************************************************
template <size_t BufferSize>
u16string_ext(const etl::iu16string& other, value_type (&buffer)[BufferSize])
: iu16string(buffer, BufferSize - 1U)
{
if (this->is_within_buffer(other.data()))
{
this->current_size = other.size();
}
else
{
this->assign(other);
}
}
//*************************************************************************
//*************************************************************************
u16string_ext(const etl::iu16string& other, value_type* buffer, size_type buffer_size, size_type position, size_type length = npos)
: iu16string(buffer, buffer_size - 1U)
{
ETL_ASSERT(position < other.size(), ETL_ERROR(string_out_of_bounds));
if (this->is_within_buffer(other.data()))
{
this->current_size = other.size();
}
else
{
this->assign(other, position, length);
}
}
//*************************************************************************
//*************************************************************************
template <size_t BufferSize>
u16string_ext(const etl::iu16string& other, value_type (&buffer)[BufferSize], size_type position, size_type length = npos)
: iu16string(buffer, BufferSize - 1U)
{
ETL_ASSERT(position < other.size(), ETL_ERROR(string_out_of_bounds));
if (this->is_within_buffer(other.data()))
{
this->current_size = other.size();
}
else
{
this->assign(other, position, length);
}
}
//*************************************************************************
//*************************************************************************
template <typename TPointer>
u16string_ext(TPointer text, value_type* buffer, size_type buffer_size,
typename etl::enable_if<etl::is_same<const value_type*, TPointer>::value, int>::type* = ETL_NULLPTR)
: iu16string(buffer, buffer_size - 1U)
{
if (this->is_within_buffer(text))
{
this->current_size = etl::strlen(buffer);
}
else
{
this->assign(text);
}
}
//*************************************************************************
//*************************************************************************
template <typename TPointer, size_t BufferSize>
u16string_ext(TPointer text, value_type (&buffer)[BufferSize],
typename etl::enable_if<etl::is_same<const value_type*, TPointer>::value, int>::type* = ETL_NULLPTR)
: iu16string(buffer, BufferSize - 1U)
{
if (this->is_within_buffer(text))
{
this->current_size = etl::strlen(buffer);
}
else
{
this->assign(text);
}
}
//*************************************************************************
//*************************************************************************
template <size_t Size>
u16string_ext(const value_type (&literal)[Size], value_type* buffer, size_type buffer_size)
: iu16string(buffer, buffer_size - 1U)
{
if (this->is_within_buffer(literal))
{
this->current_size = etl::strlen(literal);
}
else
{
this->assign(literal);
}
}
//*************************************************************************
//*************************************************************************
template <size_t LiteralSize, size_t BufferSize>
u16string_ext(const value_type (&literal)[LiteralSize], value_type (&buffer)[BufferSize])
: iu16string(buffer, BufferSize - 1U)
{
if (this->is_within_buffer(literal))
{
this->current_size = etl::strlen(literal);
}
else
{
this->assign(literal);
}
}
//*************************************************************************
//*************************************************************************
u16string_ext(const value_type* text, size_type count, value_type* buffer, size_type buffer_size)
: iu16string(buffer, buffer_size - 1U)
{
if (this->is_within_buffer(text))
{
this->current_size = count;
}
else
{
this->assign(text, text + count);
}
}
//*************************************************************************
//*************************************************************************
template <size_t BufferSize>
u16string_ext(const value_type* text, size_type count, value_type (&buffer)[BufferSize])
: iu16string(buffer, BufferSize - 1U)
{
if (this->is_within_buffer(text))
{
this->current_size = count;
}
else
{
this->assign(text, text + count);
}
}
//*************************************************************************
//*************************************************************************
u16string_ext(size_type count, value_type c, value_type* buffer, size_type buffer_size)
: iu16string(buffer, buffer_size - 1U)
{
this->initialise();
this->resize(count, c);
}
//*************************************************************************
//*************************************************************************
template <size_t BufferSize>
u16string_ext(size_type count, value_type c, value_type (&buffer)[BufferSize])
: iu16string(buffer, BufferSize - 1U)
{
this->initialise();
this->resize(count, c);
}
//*************************************************************************
//*************************************************************************
explicit u16string_ext(const etl::u16string_view& view, value_type* buffer, size_type buffer_size)
: iu16string(buffer, buffer_size - 1U)
{
if (this->is_within_buffer(view.data()))
{
this->current_size = view.size();
}
else
{
this->assign(view.begin(), view.end());
}
}
//*************************************************************************
//*************************************************************************
template <size_t BufferSize>
explicit u16string_ext(const etl::u16string_view& view, value_type (&buffer)[BufferSize])
: iu16string(buffer, BufferSize - 1U)
{
if (this->is_within_buffer(view.data()))
{
this->current_size = view.size();
}
else
{
this->assign(view.begin(), view.end());
}
}
//*************************************************************************
//*************************************************************************
template <typename TIterator>
u16string_ext(TIterator first, TIterator last, value_type* buffer, size_type buffer_size,
typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0)
: iu16string(buffer, buffer_size - 1U)
{
if (this->is_within_buffer(reinterpret_cast<const_iterator>(etl::addressof(*first))))
{
this->current_size = static_cast<size_type>(etl::distance(first, last));
}
else
{
this->assign(first, last);
}
}
//*************************************************************************
//*************************************************************************
template <typename TIterator, size_t BufferSize>
u16string_ext(TIterator first, TIterator last, value_type (&buffer)[BufferSize],
typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0)
: iu16string(buffer, BufferSize - 1U)
{
if (this->is_within_buffer(reinterpret_cast<const_iterator>(etl::addressof(*first))))
{
this->current_size = static_cast<size_type>(etl::distance(first, last));
}
else
{
this->assign(first, last);
}
}
#if ETL_HAS_INITIALIZER_LIST
//*************************************************************************
//*************************************************************************
u16string_ext(std::initializer_list<value_type> init, value_type* buffer, size_type buffer_size)
: iu16string(buffer, buffer_size - 1U)
{
this->assign(init.begin(), init.end());
}
//*************************************************************************
//*************************************************************************
template <size_t BufferSize>
u16string_ext(std::initializer_list<value_type> init, value_type (&buffer)[BufferSize])
: iu16string(buffer, BufferSize - 1U)
{
this->assign(init.begin(), init.end());
}
#endif
//*************************************************************************
//*************************************************************************
u16string_ext& operator=(const u16string_ext& rhs)
{
if (&rhs != this)
{
this->assign(rhs);
}
return *this;
}
//*************************************************************************
//*************************************************************************
u16string_ext& operator=(const iu16string& rhs)
{
if (&rhs != this)
{
this->assign(rhs);
}
return *this;
}
//*************************************************************************
//*************************************************************************
u16string_ext& operator=(const value_type* text)
{
this->assign(text);
return *this;
}
//*************************************************************************
//*************************************************************************
u16string_ext& operator=(const etl::u16string_view& view)
{
this->assign(view);
return *this;
}
//*************************************************************************
//*************************************************************************
#if ETL_HAS_ISTRING_REPAIR
virtual void repair() ETL_OVERRIDE
#else
void repair()
#endif
{
}
private:
//*************************************************************************
//*************************************************************************
u16string_ext(const u16string_ext& other) ETL_DELETE;
};
//*************************************************************************
//*************************************************************************
#if ETL_USING_8BIT_TYPES
template <>
struct hash<etl::iu16string>
{
size_t operator()(const etl::iu16string& text) const
{
return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(text.data()),
reinterpret_cast<const uint8_t*>(text.data() + text.size()));
}
};
template <size_t SIZE>
struct hash<etl::u16string<SIZE> >
{
size_t operator()(const etl::u16string<SIZE>& text) const
{
return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(text.data()),
reinterpret_cast<const uint8_t*>(text.data() + text.size()));
}
};
template <>
struct hash<etl::u16string_ext >
{
size_t operator()(const etl::u16string_ext& text) const
{
return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(text.data()),
reinterpret_cast<const uint8_t*>(text.data() + text.size()));
}
};
#endif
//***************************************************************************
//***************************************************************************
template <size_t Array_Size>
etl::u16string<Array_Size - 1U> make_string(const char16_t (&text)[Array_Size])
{
return etl::u16string<Array_Size - 1U>(text, etl::strlen(text, Array_Size - 1U));
}
//***************************************************************************
//***************************************************************************
template <size_t MAX_SIZE, size_t SIZE>
etl::u16string<MAX_SIZE> make_string_with_capacity(const char16_t (&text)[SIZE])
{
return etl::u16string<MAX_SIZE>(text, etl::strlen(text, SIZE));
}
} // namespace etl
#include "private/minmax_pop.h"
#endif
basic_string.h
etl::basic_string_view::data
ETL_CONSTEXPR const_pointer data() const ETL_NOEXCEPT
Returns a const pointer to the first element of the internal storage.
Definition string_view.h:223
etl::basic_string_view::end
ETL_CONSTEXPR const_iterator end() const ETL_NOEXCEPT
Returns a const iterator to the end of the array.
Definition string_view.h:247
etl::basic_string_view::begin
ETL_CONSTEXPR const_iterator begin() const ETL_NOEXCEPT
Returns a const iterator to the beginning of the array.
Definition string_view.h:231
etl::ibasic_string
Definition basic_string.h:335
etl::ibasic_string< char16_t >::is_within_buffer
bool is_within_buffer(const_pointer ptr) const
Definition basic_string.h:2694
etl::ibasic_string< char16_t >::resize
void resize(size_type new_size)
Definition basic_string.h:465
etl::ibasic_string< char16_t >::assign
void assign(const etl::ibasic_string< char16_t > &other)
Definition basic_string.h:670
etl::ibasic_string::data
pointer data()
Definition basic_string.h:633
etl::ibasic_string< char16_t >::initialise
void initialise()
Definition basic_string.h:2465
etl::ibasic_string< char16_t >::repair_buffer
void repair_buffer(char16_t *p_buffer_)
Definition basic_string.h:2477
etl::size_type
etl::string_base::length
size_type length() const
Definition basic_string.h:187
etl::string_base::current_size
size_type current_size
The current number of elements in the string.
Definition basic_string.h:319
etl::string_base::size
size_type size() const
Definition basic_string.h:178
etl::string_out_of_bounds
Definition basic_string.h:100
etl::u16string_ext
Definition u16string.h:262
etl::u16string_ext::operator=
u16string_ext & operator=(const u16string_ext &rhs)
Assignment operator.
Definition u16string.h:633
etl::u16string_ext::u16string_ext
u16string_ext(const value_type(&literal)[LiteralSize], value_type(&buffer)[BufferSize])
Definition u16string.h:451
etl::u16string_ext::u16string_ext
u16string_ext(size_type count, value_type c, value_type *buffer, size_type buffer_size)
Definition u16string.h:507
etl::u16string_ext::operator=
u16string_ext & operator=(const etl::u16string_view &view)
Assignment operator.
Definition u16string.h:669
etl::u16string_ext::u16string_ext
u16string_ext(const etl::iu16string &other, value_type(&buffer)[BufferSize], size_type position, size_type length=npos)
Definition u16string.h:373
etl::u16string_ext::u16string_ext
u16string_ext(value_type *buffer, size_type buffer_size)
Constructor.
Definition u16string.h:274
etl::u16string_ext::u16string_ext
u16string_ext(value_type(&buffer)[Size])
Definition u16string.h:285
etl::u16string_ext::u16string_ext
u16string_ext(TPointer text, value_type *buffer, size_type buffer_size, typename etl::enable_if< etl::is_same< const value_type *, TPointer >::value, int >::type *=ETL_NULLPTR)
Definition u16string.h:393
etl::u16string_ext::u16string_ext
u16string_ext(TIterator first, TIterator last, value_type *buffer, size_type buffer_size, typename etl::enable_if<!etl::is_integral< TIterator >::value, int >::type=0)
Definition u16string.h:571
etl::u16string_ext::u16string_ext
u16string_ext(const etl::u16string_view &view, value_type *buffer, size_type buffer_size)
Definition u16string.h:532
etl::u16string_ext::u16string_ext
u16string_ext(const value_type(&literal)[Size], value_type *buffer, size_type buffer_size)
Definition u16string.h:432
etl::u16string_ext::u16string_ext
u16string_ext(TIterator first, TIterator last, value_type(&buffer)[BufferSize], typename etl::enable_if<!etl::is_integral< TIterator >::value, int >::type=0)
Definition u16string.h:593
etl::u16string_ext::u16string_ext
u16string_ext(const value_type *text, size_type count, value_type *buffer, size_type buffer_size)
Definition u16string.h:469
etl::u16string_ext::u16string_ext
u16string_ext(const etl::iu16string &other, value_type *buffer, size_type buffer_size, size_type position, size_type length=npos)
Definition u16string.h:350
etl::u16string_ext::u16string_ext
u16string_ext(TPointer text, value_type(&buffer)[BufferSize], typename etl::enable_if< etl::is_same< const value_type *, TPointer >::value, int >::type *=ETL_NULLPTR)
Definition u16string.h:413
etl::u16string_ext::u16string_ext
u16string_ext(const value_type *text, size_type count, value_type(&buffer)[BufferSize])
Definition u16string.h:489
etl::u16string_ext::u16string_ext
u16string_ext(const etl::iu16string &other, value_type *buffer, size_type buffer_size)
Definition u16string.h:312
etl::u16string_ext::u16string_ext
u16string_ext(const etl::u16string_view &view, value_type(&buffer)[BufferSize])
Definition u16string.h:551
etl::u16string_ext::operator=
u16string_ext & operator=(const value_type *text)
Assignment operator.
Definition u16string.h:659
etl::u16string_ext::repair
void repair()
Fix the internal pointers after a low level memory copy.
Definition u16string.h:682
etl::u16string_ext::operator=
u16string_ext & operator=(const iu16string &rhs)
Assignment operator.
Definition u16string.h:646
etl::u16string_ext::u16string_ext
u16string_ext(const etl::iu16string &other, value_type(&buffer)[BufferSize])
Definition u16string.h:331
etl::u16string_ext::u16string_ext
u16string_ext(size_type count, value_type c, value_type(&buffer)[BufferSize])
Definition u16string.h:521
etl::u16string_ext::u16string_ext
u16string_ext(const etl::u16string_ext &other, value_type *buffer, size_type buffer_size)
Definition u16string.h:295
etl::u16string
Definition u16string.h:66
etl::u16string::u16string
u16string(const etl::iu16string &other)
Definition u16string.h:99
etl::u16string::operator=
u16string & operator=(const value_type *text)
Assignment operator.
Definition u16string.h:223
etl::u16string::u16string
u16string(const etl::iu16string &other, size_type position, size_type length=npos)
Definition u16string.h:111
etl::u16string::substr
etl::u16string< MAX_SIZE_ > substr(size_type position=0, size_type length_=npos) const
Definition u16string.h:191
etl::u16string::u16string
u16string(size_type count, value_type c)
Definition u16string.h:145
etl::u16string::u16string
u16string(TIterator first, TIterator last, typename etl::enable_if<!etl::is_integral< TIterator >::value, int >::type=0)
Definition u16string.h:159
etl::u16string::u16string
ETL_EXPLICIT_STRING_FROM_CHAR u16string(const value_type *text)
Definition u16string.h:123
etl::u16string::operator=
u16string & operator=(const u16string &rhs)
Assignment operator.
Definition u16string.h:210
etl::u16string::u16string
u16string(const etl::u16string_view &view)
Definition u16string.h:180
etl::u16string::operator=
u16string & operator=(const etl::u16string_view &view)
Assignment operator.
Definition u16string.h:233
etl::u16string::u16string
u16string(const etl::u16string< MAX_SIZE_ > &other)
Definition u16string.h:89
etl::u16string::u16string
u16string()
Constructor.
Definition u16string.h:79
etl::u16string::u16string
u16string(const value_type *text, size_type count)
Definition u16string.h:134
etl::u16string::repair
void repair()
Fix the internal pointers after a low level memory copy.
Definition u16string.h:246
ETL_ASSERT
#define ETL_ASSERT(b, e)
Definition error_handler.h:511
etl::addressof
ETL_CONSTEXPR17 etl::enable_if<!etl::is_same< T, etl::nullptr_t >::value, T >::type * addressof(T &t)
Definition addressof.h:52
hash.h
initializer_list.h
minmax_pop.h
minmax_push.h
etl
Definition absolute.h:40
etl::make_string
etl::string< Array_Size - 1U > make_string(const char(&text)[Array_Size])
Hash function.
Definition string.h:753
etl::make_string_with_capacity
etl::string< MAX_SIZE > make_string_with_capacity(const char(&text)[SIZE])
Make string with max capacity from string literal or array.
Definition string.h:762
etl::strlen
ETL_CONSTEXPR14 size_t strlen(const T *t) ETL_NOEXCEPT
Alternative strlen for all character types.
Definition char_traits.h:293
platform.h
string_view.h
etl::value_type
etl::type