609 lines
20 KiB
C++
609 lines
20 KiB
C++
/**
|
|
* @author Edouard DUPIN
|
|
* @copyright 2011, Edouard DUPIN, all right reserved
|
|
* @license MPL-2 (see license file)
|
|
*/
|
|
#pragma once
|
|
|
|
#include <etk/types.hpp>
|
|
//#include <etk/debug.hpp>
|
|
#include <etk/Vector.hpp>
|
|
|
|
// This permit to define a minimal size in the string to permit to optimise the unneeded allocation of memory (32 remove allocation of 1 byte and 64 remove multiple allocation of 16 bytes (common)
|
|
#ifndef ETK_ENABLE_INTERNAL_DATA_IN_STRING
|
|
// TODO: NOTE: This is really not functionnal for now...
|
|
//#define ETK_ENABLE_INTERNAL_DATA_IN_STRING 64
|
|
#endif
|
|
|
|
namespace etk {
|
|
/**
|
|
* @brief string class ...
|
|
*/
|
|
class String {
|
|
public:
|
|
class Iterator {
|
|
private:
|
|
size_t m_current = 0; //!< current Id on the string
|
|
String* m_string = null; //!< Pointer on the current element of the string
|
|
public:
|
|
/**
|
|
* @brief Basic iterator constructor with no link with an etk::String
|
|
*/
|
|
Iterator() {
|
|
// nothing to do ...
|
|
}
|
|
/**
|
|
* @brief Recopy constructor on a specific etk::String.
|
|
* @param[in] _obj The Iterator that might be copy
|
|
*/
|
|
Iterator(const Iterator & _obj):
|
|
m_current(_obj.m_current),
|
|
m_string(_obj.m_string) {
|
|
// nothing to do ...
|
|
}
|
|
/**
|
|
* @brief Assignation operator.
|
|
* @param[in] _otherIterator The Iterator that might be copy
|
|
* @return reference on the current Iterator
|
|
*/
|
|
Iterator& operator=(const Iterator & _otherIterator) {
|
|
m_current = _otherIterator.m_current;
|
|
m_string = _otherIterator.m_string;
|
|
return *this;
|
|
}
|
|
/**
|
|
* @brief Basic destructor
|
|
*/
|
|
~Iterator() {
|
|
m_current = 0;
|
|
m_string = null;
|
|
}
|
|
/**
|
|
* @brief basic boolean cast
|
|
* @return true if the element is present in the etk::String size
|
|
*/
|
|
operator bool () {
|
|
return (m_current < m_string->size());
|
|
}
|
|
/**
|
|
* @brief Incremental operator
|
|
* @return Reference on the current iterator increment
|
|
*/
|
|
Iterator& operator++ () {
|
|
if ( m_string != null
|
|
&& m_current < m_string->size() )
|
|
{
|
|
m_current++;
|
|
}
|
|
return *this;
|
|
}
|
|
/**
|
|
* @brief Decremental operator
|
|
* @return Reference on the current iterator decrement
|
|
*/
|
|
Iterator& operator-- () {
|
|
if ( m_string != null
|
|
&& m_current > 0) {
|
|
m_current--;
|
|
}
|
|
return *this;
|
|
}
|
|
/**
|
|
* @brief Incremental operator
|
|
* @return Reference on a new iterator and increment the other one
|
|
*/
|
|
Iterator operator++ (int) {
|
|
Iterator it(*this);
|
|
++(*this);
|
|
return it;
|
|
}
|
|
/**
|
|
* @brief Decremental operator
|
|
* @return Reference on a new iterator and decrement the other one
|
|
*/
|
|
Iterator operator-- (int) {
|
|
Iterator it(*this);
|
|
--(*this);
|
|
return it;
|
|
}
|
|
|
|
Iterator& operator-= (size_t _offset) {
|
|
m_current -= _offset;
|
|
return *this;
|
|
}
|
|
Iterator operator- (size_t _offset) const {
|
|
Iterator tmp(*this);
|
|
tmp -= _offset;
|
|
return tmp;
|
|
}
|
|
Iterator& operator-= (int _offset) {
|
|
m_current -= _offset;
|
|
return *this;
|
|
}
|
|
Iterator operator- (int _offset) const {
|
|
Iterator tmp(*this);
|
|
tmp -= _offset;
|
|
return tmp;
|
|
}
|
|
Iterator& operator+= (size_t _offset) {
|
|
m_current += _offset;
|
|
return *this;
|
|
}
|
|
Iterator operator+ (size_t _offset) const {
|
|
Iterator tmp(*this);
|
|
tmp += _offset;
|
|
return tmp;
|
|
}
|
|
Iterator& operator+= (int _offset) {
|
|
m_current += _offset;
|
|
return *this;
|
|
}
|
|
Iterator operator+ (int _offset) const {
|
|
Iterator tmp(*this);
|
|
tmp += _offset;
|
|
return tmp;
|
|
}
|
|
/**
|
|
* @brief Get reference on the current Element
|
|
* @return the reference on the current Element
|
|
*/
|
|
char operator* () const {
|
|
//TK_ASSERT(m_current < m_string->size(), "out of range");
|
|
return m_string->get(m_current);
|
|
}
|
|
/**
|
|
* @brief Get reference on the current Element
|
|
* @return the reference on the current Element
|
|
*/
|
|
char& operator* () {
|
|
//TK_ASSERT(m_current < m_string->size(), "out of range");
|
|
return m_string->get(m_current);
|
|
}
|
|
/*****************************************************
|
|
* == operator
|
|
*****************************************************/
|
|
bool operator== (const Iterator& _obj) const {
|
|
// check if it was the same pointer
|
|
if( this == &_obj ) {
|
|
return true;
|
|
}
|
|
if (m_current != _obj.m_current) {
|
|
return false;
|
|
}
|
|
if (m_string != _obj.m_string) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
/*****************************************************
|
|
* != operator
|
|
*****************************************************/
|
|
bool operator!= (const Iterator& _obj) const {
|
|
// check if it was the same pointer
|
|
if( this == &_obj ) {
|
|
return false;
|
|
}
|
|
if (m_current != _obj.m_current) {
|
|
return true;
|
|
}
|
|
if (m_string != _obj.m_string) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
private:
|
|
Iterator(const String* _obj, int32_t _pos):
|
|
m_current(_pos),
|
|
m_string(const_cast<String*>(_obj)) {
|
|
// nothing to do ...
|
|
}
|
|
size_t getCurrent() const {
|
|
return m_current;
|
|
}
|
|
friend class String;
|
|
};
|
|
private:
|
|
etk::Vector<char> m_data; //!< pointer on the current data (contain all time 1 element '\0')
|
|
#if ETK_ENABLE_INTERNAL_DATA_IN_STRING >= 32
|
|
char m_localData[ETK_ENABLE_INTERNAL_DATA_IN_STRING-sizeof(etk::Vector<char>)]; //!< Reserve the memory to have all time a buffer of N byte to remove un-needed allocation
|
|
static const size_t m_sizeLocal;
|
|
#endif
|
|
public:
|
|
static const size_t npos = size_t(-1);
|
|
/**
|
|
* @brief Create an empty string
|
|
*/
|
|
String();
|
|
/**
|
|
* @brief Copy constructor (copy all data)
|
|
* @param[in] _obj String that might be copy
|
|
*/
|
|
String(const etk::String& _obj);
|
|
/**
|
|
* @brief Partial copy constructor (copy all needed data)
|
|
* @param[in] _obj String that might be copy (part of it)
|
|
* @param[in] _pos Start position to copy data
|
|
* @param[in] _size Number of element to copy in the string
|
|
*/
|
|
String(const etk::String& _obj, size_t _pos, size_t _size = etk::String::npos);
|
|
/**
|
|
* @brief Copy the null-terminated C string.
|
|
* @param[in] _obj C string that might be copy (end by '\0')
|
|
*/
|
|
String(const char* _obj);
|
|
// TODO : remove this when ready
|
|
//////// String(const etk::String _obj);
|
|
/**
|
|
* @brief Partial copy of the null-terminated C string.
|
|
* @param[in] _obj String that might be copyC string that might be copy (end by '\0')
|
|
* @param[in] _size Number of element to copy.
|
|
*/
|
|
String(const char* _obj, size_t _size);
|
|
/**
|
|
* @brief Fills the string with _size consecutive copies of character _val.
|
|
* @param[in] _size Number of element in the string
|
|
* @param[in] _val Value to set in the string
|
|
*/
|
|
String(size_t _size, char _val);
|
|
/**
|
|
* @brief Copy all element betewwen the 2 iterator of the new string.
|
|
* @param[in] _start Start iterator of adding value.
|
|
* @param[in] _stop Start iterator of adding value.
|
|
*/
|
|
String(Iterator _start, Iterator _stop);
|
|
/**
|
|
* @brief Move constructor
|
|
* @param[in] _obj String that might be move inside
|
|
*/
|
|
String(String&& _obj) noexcept;
|
|
/**
|
|
* @brief Set constructor
|
|
* @param[in] _value Char element to set in the string
|
|
*/
|
|
String(char _value);
|
|
/**
|
|
* @brief Destructor of the current Class
|
|
*/
|
|
~String();
|
|
/**
|
|
* @brief Swap the data of 2 Strings
|
|
* @param[in] _obj second string to swap data.
|
|
*/
|
|
void swap(etk::String& _obj);
|
|
/**
|
|
* @brief Re-copy operator
|
|
* @param[in] _obj String that might be copy
|
|
* @return reference on the current re-copy string
|
|
*/
|
|
String& operator=(const etk::String& _obj);
|
|
/**
|
|
* @brief Re-copy operator
|
|
* @param[in] _obj C string terminated with '\0'
|
|
* @return reference on the current re-copy string
|
|
*/
|
|
String& operator=(const char* _obj);
|
|
/**
|
|
* @brief Re-copy operator
|
|
* @param[in] _value Char value to set in the string
|
|
* @return reference on the current re-copy string
|
|
*/
|
|
String& operator=(char _value);
|
|
/**
|
|
* @brief Add at the Last position of the String
|
|
* @param[in] _obj Element to add at the end of string
|
|
*/
|
|
String& operator+= (const etk::String& _obj);
|
|
/**
|
|
* @brief Add at the Last position of the String
|
|
* @param[in] _obj C string terminated with '\0'
|
|
*/
|
|
String& operator+= (const char* _obj);
|
|
/**
|
|
* @brief Add at the Last position of the String
|
|
* @param[in] _value Simple character to add.
|
|
*/
|
|
String& operator+= (char _value);
|
|
/**
|
|
* @brief Get the number of element in the string
|
|
* @return The number requested
|
|
*/
|
|
size_t size() const;
|
|
/**
|
|
* @brief Check if the container have some element
|
|
* @return true The container is empty
|
|
* @return famse The container have some element
|
|
*/
|
|
bool empty() const {
|
|
return size() == 0;
|
|
}
|
|
/// @previous
|
|
bool isEmpty() const {
|
|
return empty();
|
|
}
|
|
/**
|
|
* @brief Get a current element in the string
|
|
* @param[in] _pos Desired position read
|
|
* @return Reference on the Element
|
|
*/
|
|
char& get(size_t _pos);
|
|
/**
|
|
* @brief Get an copy Element an a special position
|
|
* @param[in] _pos Position in the string that might be get [0..Size()]
|
|
* @return An reference on the copy of selected element
|
|
*/
|
|
char& operator[] (size_t _pos);
|
|
/**
|
|
* @brief Get an Element an a special position
|
|
* @param[in] _pos Position in the string that might be get [0..Size()]
|
|
* @return An reference on the selected element
|
|
*/
|
|
const char& operator[] (size_t _pos) const;
|
|
/**
|
|
* @brief Add at the First position of the String
|
|
* @param[in] _item Element to add at the end of string
|
|
*/
|
|
void pushFront(char _item);
|
|
/**
|
|
* @brief Add at the Last position of the String
|
|
* @param[in] _item Pointer on a list of Element to add at the start of string
|
|
* @param[in] _nbElement Number of element to add.
|
|
*/
|
|
void pushFront(const char * _item, size_t _nbElement);
|
|
/**
|
|
* @brief Add at the Last position of the String
|
|
* @param[in] _item Element to add at the end of string
|
|
*/
|
|
void pushBack(const char _item);
|
|
/**
|
|
* @brief Add at the Last position of the String
|
|
* @param[in] _item Pointer on a list of Element to add at the end of string
|
|
* @param[in] _nbElement Number of element to add.
|
|
*/
|
|
void pushBack(const char* _item, size_t _nbElement);
|
|
/**
|
|
* @brief Remove the last element of the string
|
|
*/
|
|
void popBack();
|
|
/**
|
|
* @brief Get the last element of the String
|
|
* @return An reference on the last char
|
|
*/
|
|
char& back();
|
|
const char& back() const;
|
|
/**
|
|
* @brief Force the container to have a minimum size in memory allocation
|
|
* @param[in] _size Size in byte that is requested.
|
|
*/
|
|
void reserve(size_t _size);
|
|
/**
|
|
* @brief Remove all element in the current string
|
|
*/
|
|
void clear();
|
|
/**
|
|
* @brief Insert N element in the String.
|
|
* @param[in] _pos Position to add the elements.
|
|
* @param[in] _item Pointer on a table of the elements to add.
|
|
* @param[in] _nbElement Number of element to add in the String
|
|
*/
|
|
void insert(size_t _pos, const char* _item, size_t _nbElement);
|
|
//! @previous
|
|
void insert(const Iterator& _pos, const char* _item, size_t _nbElement) {
|
|
insert(_pos.getCurrent(), _item, _nbElement);
|
|
};
|
|
/**
|
|
* @brief Insert one element in the String at a specific position
|
|
* @param[in] _pos Position to add the elements.
|
|
* @param[in] _item Element to add.
|
|
*/
|
|
void insert(size_t _pos, const char _item);
|
|
//! @previous
|
|
void insert(const Iterator& _pos, const char _item) {
|
|
insert(_pos.getCurrent(), _item);
|
|
}
|
|
/**
|
|
* @brief Insert one element in the String at a specific position
|
|
* @param[in] _pos Position to add the elements.
|
|
* @param[in] _item Element to add.
|
|
*/
|
|
void insert(size_t _pos, const String& _value);
|
|
//! @previous
|
|
void insert(const Iterator& _pos, const String& _value) {
|
|
insert(_pos.getCurrent(), _value);
|
|
}
|
|
/**
|
|
* @brief Remove N element
|
|
* @param[in] _pos Position to remove the data
|
|
* @param[in] _nbElement number of element to remove
|
|
*/
|
|
void erase(size_t _pos, size_t _nbElement=1);
|
|
//! @previous
|
|
void erase(const Iterator& _pos) {
|
|
erase(_pos.getCurrent(), 1);
|
|
}
|
|
/**
|
|
* @brief Remove N elements
|
|
* @param[in] _start Position to remove the data
|
|
* @param[in] _stop Last position number
|
|
*/
|
|
void eraseRange(size_t _start, size_t _stop);
|
|
//! @previous
|
|
void erase(const Iterator& _start, const Iterator& _stop) {
|
|
eraseRange(_start.getCurrent(), _stop.getCurrent());
|
|
}
|
|
/**
|
|
* @brief extract data between two point :
|
|
* @param[in] _posStart start position to extract data
|
|
* @param[in] _posEnd End position to extract data
|
|
* @return the extracted string
|
|
*/
|
|
etk::String extract(size_t _posStart = 0, size_t _posEnd=etk::String::npos) const;
|
|
//! @previous
|
|
etk::String extract(const Iterator& _start, const Iterator& _stop) const {
|
|
return extract(_start.getCurrent(), _stop.getCurrent());
|
|
}
|
|
/**
|
|
* @brief Get the pointer on the data
|
|
* @return pointer on the "C" string
|
|
*/
|
|
const char* c_str() const;
|
|
/**
|
|
* @brief Get an iterator an an specific position
|
|
* @param[in] _pos Requested position of the iterator in the string
|
|
* @return The Iterator
|
|
*/
|
|
Iterator position(size_t _pos);
|
|
//! @previous
|
|
const Iterator position(size_t _pos) const;
|
|
/**
|
|
* @brief Get an Iterator on the start position of the String
|
|
* @return The Iterator
|
|
*/
|
|
Iterator begin();
|
|
//! @previous
|
|
const Iterator begin() const;
|
|
/**
|
|
* @brief Get an Iterator on the end position of the String
|
|
* @return The Iterator
|
|
*/
|
|
Iterator end();
|
|
//! @previous
|
|
const Iterator end() const;
|
|
/**
|
|
* @brief Change the current size of the string
|
|
* @param[in] _newSize New requested size of element in the string
|
|
* @param[in] _value Value to set at the new element
|
|
*/
|
|
void resize(size_t _newSize, char _value = '\0');
|
|
void append(Iterator _start, Iterator _stop);
|
|
/*****************************************************
|
|
* == operator
|
|
*****************************************************/
|
|
bool operator== (const String& _obj) const;
|
|
/*****************************************************
|
|
* != operator
|
|
*****************************************************/
|
|
bool operator!= (const String& _obj) const;
|
|
size_t find(char _value, size_t _pos=0) const;
|
|
size_t find(const etk::String& _value, size_t _pos=0) const;
|
|
size_t rfind(char _value, size_t _pos=etk::String::npos) const;
|
|
size_t rfind(const etk::String& _value, size_t _pos=etk::String::npos) const;
|
|
etk::String& replace(size_t _pos, size_t _len, char _replace);
|
|
etk::String& replace(size_t _pos, size_t _len, const etk::String& _replace);
|
|
etk::String& replace(char _val, char _replace);
|
|
etk::String& replace(const etk::String& _val, const etk::String& _replace);
|
|
etk::String getLine(int32_t _pos) const;
|
|
etk::String toLower() const;
|
|
etk::String& lower();
|
|
etk::String toUpper() const;
|
|
etk::String& upper();
|
|
bool compare(const etk::String& _val, bool _caseSensitive = true) const;
|
|
bool endWith(const etk::String& _val, bool _caseSensitive = true) const;
|
|
bool startWith(const etk::String& _val, bool _caseSensitive = true) const;
|
|
etk::Vector<etk::String> split(char _val) const;
|
|
etk::Vector<etk::String> split(etk::String _val) const;
|
|
/**
|
|
* @brief Template that permit to convert string in everythings you want
|
|
* @param[in] ETK_STRING_TYPE Template type of the convertion output
|
|
*/
|
|
template <class ETK_STRING_TYPE>
|
|
ETK_STRING_TYPE to() const;
|
|
};
|
|
char toLower(char _value);
|
|
char toUpper(char _value);
|
|
bool operator> (const String& _left, const String& _right);
|
|
bool operator>= (const String& _left, const String& _right);
|
|
bool operator< (const String& _left, const String& _right);
|
|
bool operator<= (const String& _left, const String& _right);
|
|
String operator+ (const String& _left, const String& _right);
|
|
String operator+ (const String& _left, const char* _right);
|
|
String operator+ (const char* _left, const String& _right);
|
|
String operator+ (const String& _left, char _right);
|
|
String operator+ (char _left, const String& _right);
|
|
|
|
inline bool operator== (const char* _left, const String& _right) {
|
|
return _right == _left;
|
|
}
|
|
inline bool operator!= (const char* _left, const String& _right) {
|
|
return _right != _left;
|
|
}
|
|
inline bool operator> (const char* _left, const String& _right) {
|
|
return _right > _left;
|
|
}
|
|
inline bool operator>= (const char* _left, const String& _right) {
|
|
return _right >= _left;
|
|
}
|
|
inline bool operator< (const char* _left, const String& _right) {
|
|
return _right < _left;
|
|
}
|
|
inline bool operator<= (const char* _left, const String& _right) {
|
|
return _right <= _left;
|
|
}
|
|
//! @not_in_doc
|
|
etk::Stream& operator <<(etk::Stream& _os, const etk::String& _obj);
|
|
/**
|
|
* @brief Template to declare conversion from anything in etk::String
|
|
* @param[in] _variable Variable to convert
|
|
* @return String of the value
|
|
*/
|
|
template <class TYPE>
|
|
etk::String toString(const TYPE& _variable);
|
|
/**
|
|
* @brief Template to declare conversion from string to anything
|
|
* @param[out] _variableRet Output value
|
|
* @param[in] _value input property
|
|
* @return true if the can be converted.
|
|
*/
|
|
template <class TYPE>
|
|
bool from_string(TYPE& _variableRet, const etk::String& _value);
|
|
void sort(etk::Vector<etk::String *>& _list);
|
|
void sort(etk::Vector<etk::String>& _list);
|
|
|
|
// TODO: DEPRECATED function:
|
|
long double string_to_long_double(const etk::String& _obj);
|
|
double string_to_double(const etk::String& _obj);
|
|
float string_to_float(const etk::String& _obj);
|
|
int8_t string_to_int8_t(const etk::String& _obj);
|
|
int16_t string_to_int16_t(const etk::String& _obj);
|
|
int32_t string_to_int32_t(const etk::String& _obj);
|
|
int64_t string_to_int64_t(const etk::String& _obj);
|
|
uint8_t string_to_uint8_t(const etk::String& _obj);
|
|
uint16_t string_to_uint16_t(const etk::String& _obj);
|
|
uint32_t string_to_uint32_t(const etk::String& _obj);
|
|
uint64_t string_to_uint64_t(const etk::String& _obj);
|
|
uint64_t hexaString_to_uint64_t(const etk::String& _obj);
|
|
uint64_t bitString_to_uint64_t(const etk::String& _obj);
|
|
uint64_t octalString_to_uint64_t(const etk::String& _obj);
|
|
bool string_to_bool(const etk::String& _obj);
|
|
etk::String toLower(etk::String _obj);
|
|
etk::String toUpper(etk::String _obj);
|
|
bool compare_no_case(const etk::String& _obj, const etk::String& _val);
|
|
bool end_with(const etk::String& _obj, const etk::String& _val, bool _caseSensitive = true);
|
|
bool start_with(const etk::String& _obj, const etk::String& _val, bool _caseSensitive = true);
|
|
etk::String replace(const etk::String& _obj, char _val, char _replace);
|
|
etk::String extract_line(const etk::String& _obj, int32_t _pos);
|
|
etk::Vector<etk::String> split(const etk::String& _obj, char _val);
|
|
|
|
|
|
/**
|
|
* @brief Template to declare conversion from etk::Vector<anything> in etk::String
|
|
* @param[in] _list Variable to convert
|
|
* @return String of the value: {...,...,...}
|
|
*/
|
|
template <class TYPE>
|
|
etk::String toString(const etk::Vector<TYPE>& _list) {
|
|
etk::String out = "{";
|
|
for (size_t iii=0; iii<_list.size(); ++iii) {
|
|
if (iii!=0) {
|
|
out += ";";
|
|
}
|
|
out+= etk::toString(_list[iii]);
|
|
}
|
|
out += "}";
|
|
return out;
|
|
}
|
|
|
|
char toHexChar(uint8_t _value);
|
|
etk::String toHex(uint64_t _value, uint32_t _size = 2);
|
|
etk::String toBin(uint64_t _value, uint32_t _size = 1);
|
|
}
|