atria-soft/etk
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

[DEV] continue removing std

Browse Source
This commit is contained in:
Edouard DUPIN 2017-08-24 22:27:27 +02:00
parent 9db3d1daa9
commit 7ac3ef06c4
28 changed files with 3608 additions and 1815 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
etk/Color.hpp
View File

@ -9,6 +9,7 @@
#pragma once
#include <etk/String.hpp>
#include <etk/UString.hpp>
#include <iomanip>
namespace etk {

24
etk/Color_16_bits.cxx
View File

@ -389,11 +389,11 @@ template<> etk::String toString<Color<uint16_t, 1> >(const Color<uint16_t, 1>& _
return _val.getString();
}
#if __cplusplus >= 201103L
template<> std::u32string to_u32string<Color<uint16_t, 1>>(const Color<uint16_t, 1>& _val) {
return to_u32string(_val.getString());
template<> etk::UString toUString<Color<uint16_t, 1>>(const Color<uint16_t, 1>& _val) {
return toUString(_val.getString());
}
template<> bool from_string<Color<uint16_t, 1>>(Color<uint16_t, 1>& _variableRet, const std::u32string& _value) {
template<> bool from_string<Color<uint16_t, 1>>(Color<uint16_t, 1>& _variableRet, const etk::UString& _value) {
_variableRet = Color<uint16_t, 1>(toString(_value));
return true;
}
@ -409,11 +409,11 @@ template<> etk::String toString<Color<uint16_t, 2> >(const Color<uint16_t, 2>& _
return _val.getString();
}
#if __cplusplus >= 201103L
template<> std::u32string to_u32string<Color<uint16_t, 2>>(const Color<uint16_t, 2>& _val) {
return to_u32string(_val.getString());
template<> etk::UString toUString<Color<uint16_t, 2>>(const Color<uint16_t, 2>& _val) {
return toUString(_val.getString());
}
template<> bool from_string<Color<uint16_t, 2>>(Color<uint16_t, 2>& _variableRet, const std::u32string& _value) {
template<> bool from_string<Color<uint16_t, 2>>(Color<uint16_t, 2>& _variableRet, const etk::UString& _value) {
_variableRet = Color<uint16_t, 2>(toString(_value));
return true;
}
@ -429,11 +429,11 @@ template<> etk::String toString<Color<uint16_t, 3> >(const Color<uint16_t, 3>& _
return _val.getString();
}
#if __cplusplus >= 201103L
template<> std::u32string to_u32string<Color<uint16_t, 3>>(const Color<uint16_t, 3>& _val) {
return to_u32string(_val.getString());
template<> etk::UString toUString<Color<uint16_t, 3>>(const Color<uint16_t, 3>& _val) {
return toUString(_val.getString());
}
template<> bool from_string<Color<uint16_t, 3>>(Color<uint16_t, 3>& _variableRet, const std::u32string& _value) {
template<> bool from_string<Color<uint16_t, 3>>(Color<uint16_t, 3>& _variableRet, const etk::UString& _value) {
_variableRet = Color<uint16_t, 3>(toString(_value));
return true;
}
@ -449,11 +449,11 @@ template<> etk::String toString<Color<uint16_t, 4> >(const Color<uint16_t, 4>& _
return _val.getString();
}
#if __cplusplus >= 201103L
template<> std::u32string to_u32string<Color<uint16_t, 4>>(const Color<uint16_t, 4>& _val) {
return to_u32string(_val.getString());
template<> etk::UString toUString<Color<uint16_t, 4>>(const Color<uint16_t, 4>& _val) {
return toUString(_val.getString());
}
template<> bool from_string<Color<uint16_t, 4>>(Color<uint16_t, 4>& _variableRet, const std::u32string& _value) {
template<> bool from_string<Color<uint16_t, 4>>(Color<uint16_t, 4>& _variableRet, const etk::UString& _value) {
_variableRet = Color<uint16_t, 4>(toString(_value));
return true;
}

24
etk/Color_32_bits.cxx
View File

@ -389,10 +389,10 @@ template<> etk::String toString<Color<uint32_t, 1> >(const Color<uint32_t, 1>& _
return _val.getString();
}
#if __cplusplus >= 201103L
template<> std::u32string to_u32string<Color<uint32_t, 1>>(const Color<uint32_t, 1>& _val) {
return to_u32string(_val.getString());
template<> etk::UString toUString<Color<uint32_t, 1>>(const Color<uint32_t, 1>& _val) {
return toUString(_val.getString());
}
template<> bool from_string<Color<uint32_t, 1>>(Color<uint32_t, 1>& _variableRet, const std::u32string& _value) {
template<> bool from_string<Color<uint32_t, 1>>(Color<uint32_t, 1>& _variableRet, const etk::UString& _value) {
_variableRet = Color<uint32_t, 1>(toString(_value));
return true;
}
@ -406,10 +406,10 @@ template<> etk::String toString<Color<uint32_t, 2> >(const Color<uint32_t, 2>& _
return _val.getString();
}
#if __cplusplus >= 201103L
template<> std::u32string to_u32string<Color<uint32_t, 2>>(const Color<uint32_t, 2>& _val) {
return to_u32string(_val.getString());
template<> etk::UString toUString<Color<uint32_t, 2>>(const Color<uint32_t, 2>& _val) {
return toUString(_val.getString());
}
template<> bool from_string<Color<uint32_t, 2>>(Color<uint32_t, 2>& _variableRet, const std::u32string& _value) {
template<> bool from_string<Color<uint32_t, 2>>(Color<uint32_t, 2>& _variableRet, const etk::UString& _value) {
_variableRet = Color<uint32_t, 2>(toString(_value));
return true;
}
@ -425,10 +425,10 @@ template<> etk::String toString<Color<uint32_t, 3> >(const Color<uint32_t, 3>& _
return _val.getString();
}
#if __cplusplus >= 201103L
template<> std::u32string to_u32string<Color<uint32_t, 3>>(const Color<uint32_t, 3>& _val) {
return to_u32string(_val.getString());
template<> etk::UString toUString<Color<uint32_t, 3>>(const Color<uint32_t, 3>& _val) {
return toUString(_val.getString());
}
template<> bool from_string<Color<uint32_t, 3>>(Color<uint32_t, 3>& _variableRet, const std::u32string& _value) {
template<> bool from_string<Color<uint32_t, 3>>(Color<uint32_t, 3>& _variableRet, const etk::UString& _value) {
_variableRet = Color<uint32_t, 3>(toString(_value));
return true;
}
@ -444,10 +444,10 @@ template<> etk::String toString<Color<uint32_t, 4> >(const Color<uint32_t, 4>& _
return _val.getString();
}
#if __cplusplus >= 201103L
template<> std::u32string to_u32string<Color<uint32_t, 4>>(const Color<uint32_t, 4>& _val) {
return to_u32string(_val.getString());
template<> etk::UString toUString<Color<uint32_t, 4>>(const Color<uint32_t, 4>& _val) {
return toUString(_val.getString());
}
template<> bool from_string<Color<uint32_t, 4>>(Color<uint32_t, 4>& _variableRet, const std::u32string& _value) {
template<> bool from_string<Color<uint32_t, 4>>(Color<uint32_t, 4>& _variableRet, const etk::UString& _value) {
_variableRet = Color<uint32_t, 4>(toString(_value));
return true;
}

24
etk/Color_8_bits.cxx
View File

@ -388,10 +388,10 @@ template<> etk::String toString<Color<uint8_t, 1> >(const Color<uint8_t, 1>& _va
return _val.getString();
}
#if __cplusplus >= 201103L
template<> std::u32string to_u32string<Color<uint8_t, 1>>(const Color<uint8_t, 1>& _val) {
return to_u32string(_val.getString());
template<> etk::UString toUString<Color<uint8_t, 1>>(const Color<uint8_t, 1>& _val) {
return toUString(_val.getString());
}
template<> bool from_string<Color<uint8_t, 1>>(Color<uint8_t, 1>& _variableRet, const std::u32string& _value) {
template<> bool from_string<Color<uint8_t, 1>>(Color<uint8_t, 1>& _variableRet, const etk::UString& _value) {
_variableRet = Color<uint8_t, 1>(toString(_value));
return true;
}
@ -408,10 +408,10 @@ template<> etk::String toString<Color<uint8_t, 2> >(const Color<uint8_t, 2>& _va
return _val.getString();
}
#if __cplusplus >= 201103L
template<> std::u32string to_u32string<Color<uint8_t, 2>>(const Color<uint8_t, 2>& _val) {
return to_u32string(_val.getString());
template<> etk::UString toUString<Color<uint8_t, 2>>(const Color<uint8_t, 2>& _val) {
return toUString(_val.getString());
}
template<> bool from_string<Color<uint8_t, 2>>(Color<uint8_t, 2>& _variableRet, const std::u32string& _value) {
template<> bool from_string<Color<uint8_t, 2>>(Color<uint8_t, 2>& _variableRet, const etk::UString& _value) {
_variableRet = Color<uint8_t, 2>(toString(_value));
return true;
}
@ -427,10 +427,10 @@ template<> etk::String toString<Color<uint8_t, 3> >(const Color<uint8_t, 3>& _va
return _val.getString();
}
#if __cplusplus >= 201103L
template<> std::u32string to_u32string<Color<uint8_t, 3>>(const Color<uint8_t, 3>& _val) {
return to_u32string(_val.getString());
template<> etk::UString toUString<Color<uint8_t, 3>>(const Color<uint8_t, 3>& _val) {
return toUString(_val.getString());
}
template<> bool from_string<Color<uint8_t, 3>>(Color<uint8_t, 3>& _variableRet, const std::u32string& _value) {
template<> bool from_string<Color<uint8_t, 3>>(Color<uint8_t, 3>& _variableRet, const etk::UString& _value) {
_variableRet = Color<uint8_t, 3>(toString(_value));
return true;
}
@ -445,10 +445,10 @@ template<> etk::String toString<Color<uint8_t, 4> >(const Color<uint8_t, 4>& _va
return _val.getString();
}
#if __cplusplus >= 201103L
template<> std::u32string to_u32string<Color<uint8_t, 4>>(const Color<uint8_t, 4>& _val) {
return to_u32string(_val.getString());
template<> etk::UString toUString<Color<uint8_t, 4>>(const Color<uint8_t, 4>& _val) {
return toUString(_val.getString());
}
template<> bool from_string<Color<uint8_t, 4>>(Color<uint8_t, 4>& _variableRet, const std::u32string& _value) {
template<> bool from_string<Color<uint8_t, 4>>(Color<uint8_t, 4>& _variableRet, const etk::UString& _value) {
_variableRet = Color<uint8_t, 4>(toString(_value));
return true;
}

24
etk/Color_double.cxx
View File

@ -389,10 +389,10 @@ template<> etk::String toString<Color<double, 1> >(const Color<double, 1>& _val)
return _val.getString();
}
#if __cplusplus >= 201103L
template<> std::u32string to_u32string<Color<double, 1>>(const Color<double, 1>& _val) {
return to_u32string(_val.getString());
template<> etk::UString toUString<Color<double, 1>>(const Color<double, 1>& _val) {
return toUString(_val.getString());
}
template<> bool from_string<Color<double, 1>>(Color<double, 1>& _variableRet, const std::u32string& _value) {
template<> bool from_string<Color<double, 1>>(Color<double, 1>& _variableRet, const etk::UString& _value) {
_variableRet = Color<double, 1>(toString(_value));
return true;
}
@ -409,10 +409,10 @@ template<> etk::String toString<Color<double, 2> >(const Color<double, 2>& _val)
return _val.getString();
}
#if __cplusplus >= 201103L
template<> std::u32string to_u32string<Color<double, 2>>(const Color<double, 2>& _val) {
return to_u32string(_val.getString());
template<> etk::UString toUString<Color<double, 2>>(const Color<double, 2>& _val) {
return toUString(_val.getString());
}
template<> bool from_string<Color<double, 2>>(Color<double, 2>& _variableRet, const std::u32string& _value) {
template<> bool from_string<Color<double, 2>>(Color<double, 2>& _variableRet, const etk::UString& _value) {
_variableRet = Color<double, 2>(toString(_value));
return true;
}
@ -429,10 +429,10 @@ template<> etk::String toString<Color<double, 3> >(const Color<double, 3>& _val)
return _val.getString();
}
#if __cplusplus >= 201103L
template<> std::u32string to_u32string<Color<double, 3>>(const Color<double, 3>& _val) {
return to_u32string(_val.getString());
template<> etk::UString toUString<Color<double, 3>>(const Color<double, 3>& _val) {
return toUString(_val.getString());
}
template<> bool from_string<Color<double, 3>>(Color<double, 3>& _variableRet, const std::u32string& _value) {
template<> bool from_string<Color<double, 3>>(Color<double, 3>& _variableRet, const etk::UString& _value) {
_variableRet = Color<double, 3>(toString(_value));
return true;
}
@ -448,10 +448,10 @@ template<> etk::String toString<Color<double, 4> >(const Color<double, 4>& _val)
return _val.getString();
}
#if __cplusplus >= 201103L
template<> std::u32string to_u32string<Color<double, 4>>(const Color<double, 4>& _val) {
return to_u32string(_val.getString());
template<> etk::UString toUString<Color<double, 4>>(const Color<double, 4>& _val) {
return toUString(_val.getString());
}
template<> bool from_string<Color<double, 4>>(Color<double, 4>& _variableRet, const std::u32string& _value) {
template<> bool from_string<Color<double, 4>>(Color<double, 4>& _variableRet, const etk::UString& _value) {
_variableRet = Color<double, 4>(toString(_value));
return true;
}

24
etk/Color_float.cxx
View File

@ -387,10 +387,10 @@ template<> etk::String toString<Color<float, 1> >(const Color<float, 1>& _val) {
return _val.getString();
}
#if __cplusplus >= 201103L
template<> std::u32string to_u32string<Color<float, 1>>(const Color<float, 1>& _val) {
return to_u32string(_val.getString());
template<> etk::UString toUString<Color<float, 1>>(const Color<float, 1>& _val) {
return toUString(_val.getString());
}
template<> bool from_string<Color<float, 1>>(Color<float, 1>& _variableRet, const std::u32string& _value) {
template<> bool from_string<Color<float, 1>>(Color<float, 1>& _variableRet, const etk::UString& _value) {
_variableRet = Color<float, 1>(toString(_value));
return true;
}
@ -405,10 +405,10 @@ template<> etk::String toString<Color<float, 2> >(const Color<float, 2>& _val) {
return _val.getString();
}
#if __cplusplus >= 201103L
template<> std::u32string to_u32string<Color<float, 2>>(const Color<float, 2>& _val) {
return to_u32string(_val.getString());
template<> etk::UString toUString<Color<float, 2>>(const Color<float, 2>& _val) {
return toUString(_val.getString());
}
template<> bool from_string<Color<float, 2>>(Color<float, 2>& _variableRet, const std::u32string& _value) {
template<> bool from_string<Color<float, 2>>(Color<float, 2>& _variableRet, const etk::UString& _value) {
_variableRet = Color<float, 2>(toString(_value));
return true;
}
@ -423,10 +423,10 @@ template<> etk::String toString<Color<float, 3> >(const Color<float, 3>& _val) {
return _val.getString();
}
#if __cplusplus >= 201103L
template<> std::u32string to_u32string<Color<float, 3>>(const Color<float, 3>& _val) {
return to_u32string(_val.getString());
template<> etk::UString toUString<Color<float, 3>>(const Color<float, 3>& _val) {
return toUString(_val.getString());
}
template<> bool from_string<Color<float, 3>>(Color<float, 3>& _variableRet, const std::u32string& _value) {
template<> bool from_string<Color<float, 3>>(Color<float, 3>& _variableRet, const etk::UString& _value) {
_variableRet = Color<float, 3>(toString(_value));
return true;
}
@ -441,10 +441,10 @@ template<> etk::String toString<Color<float, 4> >(const Color<float, 4>& _val) {
return _val.getString();
}
#if __cplusplus >= 201103L
template<> std::u32string to_u32string<Color<float, 4>>(const Color<float, 4>& _val) {
return to_u32string(_val.getString());
template<> etk::UString toUString<Color<float, 4>>(const Color<float, 4>& _val) {
return toUString(_val.getString());
}
template<> bool from_string<Color<float, 4>>(Color<float, 4>& _variableRet, const std::u32string& _value) {
template<> bool from_string<Color<float, 4>>(Color<float, 4>& _variableRet, const etk::UString& _value) {
_variableRet = Color<float, 4>(toString(_value));
return true;
}

11
etk/Hash.hpp
View File

@ -7,6 +7,7 @@
#include <etk/types.hpp>
#pragma once
#include <etk/String.hpp>
namespace etk {
/**
@ -61,7 +62,7 @@ namespace etk {
*/
template<class MY_TYPE> class Hash {
private:
std::vector<HashData<MY_TYPE>* > m_data; //!< Data of the hash ==> the Hash table is composed of pointer, this permit to have high speed when resize the vector ...
etk::Vector<HashData<MY_TYPE>* > m_data; //!< Data of the hash ==> the Hash table is composed of pointer, this permit to have high speed when resize the vector ...
public:
/**
* @brief Constructor of the Hash table.
@ -166,7 +167,7 @@ namespace etk {
//TK_ERROR("allocation error in Hash table : '" << _key << "'");
return;
}
m_data.push_back(tmp);
m_data.pushBack(tmp);
return;
}
m_data[elementId]->m_value = _value;
@ -237,11 +238,11 @@ namespace etk {
* @brief Get all the element name (keys).
* @return a vector of all name (key).
*/
std::vector<etk::String> getKeys() const {
std::vector<etk::String> keys;
etk::Vector<etk::String> getKeys() const {
etk::Vector<etk::String> keys;
for (auto &it : m_data) {
if (it != nullptr) {
keys.push_back(it->m_key);
keys.pushBack(it->m_key);
}
}
return keys;

14
etk/RegEx.cpp
View File

@ -375,7 +375,7 @@ bool etk::regex::parseBrace(const std::vector<char32_t>& _data, uint32_t& _min,
return false;
} if (_data[k] == '}') {
goto allIsSet;
} else if (true == u32char::isInteger(_data[k])) {
} else if (u32char::isInteger(_data[k]) == true) {
SecondElement *= 10;
SecondElement += u32char::toInt(_data[k]);
} else {
@ -458,21 +458,21 @@ namespace etk {
template<> etk::String toString<etk::RegEx<etk::String>>(const etk::RegEx<etk::String>& _val) {
return _val.getRegEx();
}
template<> etk::String toString<etk::RegEx<std::u32string>>(const etk::RegEx<std::u32string>& _val) {
template<> etk::String toString<etk::RegEx<etk::UString>>(const etk::RegEx<etk::UString>& _val) {
return _val.getRegEx();
}
template<> std::u32string to_u32string<etk::RegEx<etk::String>>(const etk::RegEx<etk::String>& _val) {
template<> etk::UString toUString<etk::RegEx<etk::String>>(const etk::RegEx<etk::String>& _val) {
return _val.getURegEx();
}
template<> std::u32string to_u32string<etk::RegEx<std::u32string>>(const etk::RegEx<std::u32string>& _val) {
template<> etk::UString toUString<etk::RegEx<etk::UString>>(const etk::RegEx<etk::UString>& _val) {
return _val.getURegEx();
}
template<> bool from_string<etk::RegEx<etk::String>>(etk::RegEx<etk::String>& _variableRet, const std::u32string& _value) {
template<> bool from_string<etk::RegEx<etk::String>>(etk::RegEx<etk::String>& _variableRet, const etk::UString& _value) {
_variableRet.compile(_value);
return true;
}
template<> bool from_string<etk::RegEx<std::u32string>>(etk::RegEx<std::u32string>& _variableRet, const std::u32string& _value) {
template<> bool from_string<etk::RegEx<etk::UString>>(etk::RegEx<etk::UString>& _variableRet, const etk::UString& _value) {
_variableRet.compile(_value);
return true;
}
@ -480,7 +480,7 @@ namespace etk {
_variableRet.compile(_value);
return true;
}
template<> bool from_string<etk::RegEx<std::u32string>>(etk::RegEx<std::u32string>& _variableRet, const etk::String& _value) {
template<> bool from_string<etk::RegEx<etk::UString>>(etk::RegEx<etk::UString>& _variableRet, const etk::String& _value) {
_variableRet.compile(_value);
return true;
}

14
etk/RegEx.hpp
View File

@ -11,7 +11,7 @@
#include <etk/debug.hpp>
#include <etk/stdTools.hpp>
#include <etk/String.hpp>
#include <vector>
#include <etk/UString.hpp>
#include <memory>
#define TK_REG_DEBUG TK_HIDDEN
@ -1378,7 +1378,7 @@ template<class CLASS_TYPE> class NodePThese : public Node<CLASS_TYPE> {
*/
template<class CLASS_TYPE> class RegEx {
private:
std::u32string m_expressionRequested; //!< Regular expression parsed ...
etk::UString m_expressionRequested; //!< Regular expression parsed ...
regex::ElementPos m_areaFind; //!< position around selection
regex::NodePThese<CLASS_TYPE> m_expressionRootNode; //!< The tree where data is set
bool m_isOk; //!< Known if we can process with this regEx
@ -1391,7 +1391,7 @@ template<class CLASS_TYPE> class RegEx {
* @brief Constructor
* @param[in,out] _expression Regular expression to parse
*/
RegEx(const std::u32string &_expression=U"") :
RegEx(const etk::UString &_expression=U"") :
m_expressionRequested(U""),
m_isOk(false),
m_notBeginWithChar(false),
@ -1415,7 +1415,7 @@ template<class CLASS_TYPE> class RegEx {
m_areaFind.start=0;
m_areaFind.stop=0;
if (_expression.size() != 0) {
compile(etk::to_u32string(_expression));
compile(etk::toUString(_expression));
}
};
/**
@ -1440,13 +1440,13 @@ template<class CLASS_TYPE> class RegEx {
void compile(const etk::String &_expression) {
if (_expression.size() != 0) {
TK_REG_DEBUG("normal string parse : '" << _expression << "'");
compile(etk::to_u32string(_expression));
compile(etk::toUString(_expression));
}
}
/**
* @previous
*/
void compile(const std::u32string &_expression) {
void compile(const etk::UString &_expression) {
m_expressionRequested = _expression;
std::vector<char32_t> tmpExpression;
@ -1587,7 +1587,7 @@ template<class CLASS_TYPE> class RegEx {
/**
* @previous
*/
const std::u32string& getURegEx() const {
const etk::UString& getURegEx() const {
return m_expressionRequested;
};

690
etk/String.cpp
View File

@ -2,7 +2,466 @@
#include <etk/String.hpp>
etk::String::String():
m_data() {
m_data.resize(1, '\0');
}
etk::String::String(const etk::String& _obj) {
m_data = _obj.m_data;
}
etk::String::String(const etk::String& _obj, size_t _pos, size_t _size) {
if (_pos + _size >= _obj.size()) {
_size = etk::String::npos;
}
if (_size != etk::String::npos) {
resize(_size);
for (size_t iii=0; iii<_size; ++iii) {
m_data[iii] = _obj.m_data[_pos+iii];
}
return;
}
resize(_obj.size()-_pos);
for (size_t iii=0; iii<_obj.size()-_pos; ++iii) {
m_data[iii] = _obj.m_data[_pos+iii];
}
}
etk::String::String(const char* _obj) {
if (_obj == nullptr) {
resize(0);
return;
}
uint32_t size = strlen(_obj);
resize(size);
for (size_t iii=0; iii<size; ++iii) {
m_data[iii] = _obj[iii];
}
}
etk::String::String(const std::string _obj) {
resize(_obj.size());
for (size_t iii=0; iii<_obj.size(); ++iii) {
m_data[iii] = _obj[iii];
}
}
etk::String::String(const char* _obj, size_t _size) {
if ( _obj == nullptr
|| _size == 0) {
resize(0);
return;
}
uint32_t size = strlen(_obj);
if (_size < size) {
size = _size;
}
resize(size);
for (size_t iii=0; iii<size; ++iii) {
m_data[iii] = _obj[iii];
}
}
etk::String::String(size_t _size, char _val) {
resize(_size);
for (size_t iii=0; iii<_size; ++iii) {
m_data[iii] = _val;
}
}
etk::String::String(Iterator _start, Iterator _stop) {
size_t size = etk::distance(_start, _stop);
resize(size);
Iterator it = begin();
while (_start != _stop) {
*it++ = *_start++;
}
}
etk::String::String(etk::String&& _obj) noexcept {
m_data = std::move(_obj.m_data);
}
etk::String::String(char _value) {
resize(1);
m_data[0] = _value;
}
etk::String::~String() {
// nothing to do...
}
void etk::String::swap(etk::String& _obj) {
// avoid Swap of itself
if(this != &_obj) {
m_data.swap(_obj.m_data);
}
}
etk::String& etk::String::operator=(const etk::String& _obj) {
if (this != &_obj) {
m_data = _obj.m_data;
}
// Return the current pointer
return *this;
}
etk::String& etk::String::operator=(const char* _obj) {
clear();
if (_obj == nullptr) {
return *this;
}
size_t numberElement = strlen(_obj);
resize(numberElement);
for (size_t iii=0; iii<numberElement; ++iii) {
m_data[iii] = _obj[iii];
}
// Return the current pointer
return *this;
}
etk::String& etk::String::operator=(char _value) {
resize(1);
m_data[0] = _value;
// Return the current pointer
return *this;
}
etk::String& etk::String::operator+= (const etk::String& _obj) {
size_t numberElement = _obj.size();
size_t idElement = size();
resize(size()+_obj.size());
for (size_t iii=0; iii<_obj.size(); ++iii) {
m_data[idElement+iii] = _obj[iii];
}
// Return the current pointer
return *this;
}
etk::String& etk::String::operator+= (const char* _obj) {
if (_obj == nullptr) {
return *this;
}
size_t numberElement = strlen(_obj);
size_t idElement = size();
resize(size() + numberElement);
for (size_t iii=0; iii<numberElement; ++iii) {
m_data[idElement+iii] = _obj[iii];
}
// Return the current pointer
return *this;
}
etk::String& etk::String::operator+= (char _value) {
pushBack(_value);
// Return the current pointer
return *this;
}
size_t etk::String::size() const {
return m_data.size() - 1; // remove '\0'
}
void etk::String::pushFront(char _item) {
insert(0, &_item, 1);
}
void etk::String::pushFront(const char * _item, size_t _nbElement) {
insert(0, _item, _nbElement);
}
void etk::String::pushBack(const char _item) {
size_t idElement = size();
resize(size()+1);
if (idElement < size()) {
m_data[idElement] = _item;
} else {
TK_ERROR("Resize does not work correctly ... not added item");
}
}
void etk::String::pushBack(const char* _item, size_t _nbElement) {
if (_item == nullptr) {
return;
}
size_t idElement = size();
resize(size()+_nbElement);
if (idElement > size()) {
TK_ERROR("Resize does not work correctly ... not added item");
return;
}
for (size_t iii=0; iii<_nbElement; iii++) {
m_data[idElement+iii] = _item[iii];
}
}
void etk::String::popBack() {
if(size()>0) {
resize(size()-1);
}
}
void etk::String::clear() {
resize(0);
}
void etk::String::insert(size_t _pos, const char* _item, size_t _nbElement) {
if (_pos>size()) {
TK_WARNING(" can not insert Element at this position : " << _pos << " > " << size() << " add it at the end ... ");
pushBack(_item, _nbElement);
return;
}
size_t idElement = size();
// Request resize of the current buffer
resize(size()+_nbElement);
if (idElement>=size()) {
TK_ERROR("Resize does not work correctly ... not added item");
return;
}
// move current data (after the position)
size_t sizeToMove = (idElement - _pos);
if ( 0 < sizeToMove) {
for (size_t iii=1; iii<=sizeToMove; iii++) {
m_data[size()-iii] = m_data[idElement-iii];
}
}
// affectation of all input element
for (size_t iii=0; iii<_nbElement; iii++) {
m_data[_pos+iii] = _item[iii];
}
}
void etk::String::insert(size_t _pos, const char _item) {
insert(_pos, &_item, 1);
}
void etk::String::insert(size_t _pos, const etk::String& _value) {
insert(_pos, &_value[0], _value.size());
}
void etk::String::erase(size_t _pos, size_t _nbElement) {
if (_pos>size()) {
TK_ERROR(" can not Erase Len Element at this position : " << _pos << " > " << size());
return;
}
if (_pos+_nbElement>size()) {
_nbElement = size() - _pos;
}
size_t idElement = size();
// move current data
size_t sizeToMove = (idElement - (_pos+_nbElement));
if ( 0 < sizeToMove) {
for (size_t iii=0; iii<sizeToMove; iii++) {
m_data[_pos+iii] = m_data[_pos+_nbElement+iii];
}
}
// Request resize of the current buffer
resize(size() - _nbElement);
}
void etk::String::eraseRange(size_t _pos, size_t _posEnd) {
if (_pos>size()) {
TK_ERROR(" can not Erase Element at this position : " << _pos << " > " << size());
return;
}
if (_posEnd > size()) {
_posEnd = size();
}
size_t nbElement = size() - _pos;
size_t tmpSize = size();
// move current data
size_t sizeToMove = (tmpSize - (_pos+nbElement));
if ( 0 < sizeToMove) {
for (size_t iii=0; iii<sizeToMove; iii++) {
m_data[_pos+iii] = m_data[_pos+nbElement+iii];
}
}
// Request resize of the current buffer
resize(size()-nbElement);
}
etk::String etk::String::extract(size_t _posStart, size_t _posEnd) const {
etk::String out;
if (_posStart >= size() ) {
return out;
}
if (_posEnd >= size() ) {
_posEnd = size();
}
out.pushBack(&m_data[_posStart], _posEnd-_posStart);
return out;
}
const char* etk::String::c_str() const {
return &m_data[0];
}
etk::String::Iterator etk::String::position(size_t _pos) {
return etk::String::Iterator(this, _pos);
}
const etk::String::Iterator etk::String::position(size_t _pos) const {
return etk::String::Iterator(this, _pos);
}
etk::String::Iterator etk::String::begin() {
return position(0);
}
const etk::String::Iterator etk::String::begin() const {
return position(0);
}
etk::String::Iterator etk::String::end() {
return position( size()-1 );
}
const etk::String::Iterator etk::String::end() const {
return position( size()-1 );
}
void etk::String::resize(size_t _newSize, char _value) {
size_t oldSize = m_data.size();
m_data[m_data.size()-1] = _value;
m_data.resize(_newSize + 1, _value);
// in all case ==> we have the last element that is '\0'
m_data[_newSize] = '\0';
}
bool etk::String::operator== (const etk::String& _obj) const {
// check if it was the same pointer
if( this == &_obj ) {
return true;
}
// first step : check the size ...
if (m_data.size() != _obj.m_data.size()) {
return false;
}
for (size_t iii=0; iii<m_data.size(); ++iii) {
if (m_data[iii] != _obj.m_data[iii]) {
return false;
}
}
return true;
}
bool etk::String::operator!= (const etk::String& _obj) const {
// check if it was the same pointer
if( this == &_obj ) {
return false;
}
// first step : check the size ...
if (m_data.size() != _obj.m_data.size()) {
return true;
}
for (size_t iii=0; iii<m_data.size(); ++iii) {
if (m_data[iii] != _obj.m_data[iii]) {
return true;
}
}
return false;
}
char etk::toLower(char _value) {
if ( _value >= 'A'
&& _value <= 'Z') {
return _value + ('a' - 'A');
}
return _value;
}
char etk::toUpper(char _value) {
if ( _value >= 'a'
&& _value <= 'z') {
return _value + ('A' - 'z');
}
return _value;
}
etk::String etk::String::toLower() const {
etk::String tmp(*this);
for (auto &it: tmp) {
it = etk::toLower(it);
}
return tmp;
}
etk::String& etk::String::lower() {
for (auto &it: m_data) {
it = etk::toLower(it);
}
return *this;
}
etk::String etk::String::toUpper() const {
etk::String tmp(*this);
for (auto &it: tmp) {
it = etk::toUpper(it);
}
return tmp;
}
etk::String& etk::String::upper() {
for (auto &it: m_data) {
it = etk::toUpper(it);
}
return *this;
}
bool etk::String::endWith(const etk::String& _val, bool _caseSensitive) const {
if (_val.size() == 0) {
return false;
}
if (_val.size() > size()) {
return false;
}
if (_caseSensitive == true) {
for( int64_t iii=_val.size()-1, jjj=size()-1;
iii>=0 && jjj>=0;
iii--, jjj--) {
if (m_data[jjj] != _val[iii]) {
return false;
}
}
return true;
}
for( int64_t iii=_val.size()-1, jjj=size()-1;
iii>=0 && jjj>=0;
iii--, jjj--) {
if (etk::toLower(_val[iii]) != etk::toLower(m_data[jjj])) {
return false;
}
}
return true;
}
bool etk::String::startWith(const etk::String& _val, bool _caseSensitive) const {
if (_val.size() == 0) {
return false;
}
if (_val.size() > size()) {
return false;
}
if (_caseSensitive == true) {
for( size_t iii = 0;
iii < size();
iii++) {
if (m_data[iii] != _val[iii]) {
return false;
}
}
return true;
}
for( size_t iii = 0;
iii < _val.size();
iii++) {
if (etk::toLower(_val[iii]) != etk::toLower(m_data[iii])) {
return false;
}
}
return true;
}
template <>
long double etk::String::to<long double>() const {
long double ret = 0;
@ -94,6 +553,16 @@ uint64_t etk::String::to<uint64_t>() const {
return ret;
}
template <>
bool etk::String::to<bool>() const {
if( compare("true", false) == true
|| compare("enable", false) == true
|| compare("yes", false) == true
|| compare("1") == true) {
return true;
}
return false;
}
std::ostream& etk::operator <<(std::ostream& _os, const etk::String& _obj) {
_os << _obj.c_str();
@ -116,6 +585,22 @@ void etk::sort(etk::Vector<etk::String *> &_list) {
}
}
void etk::sort(etk::Vector<etk::String> &_list) {
etk::Vector<etk::String> tmpList(_list);
_list.clear();
for(size_t iii=0; iii<tmpList.size(); iii++) {
size_t findPos = 0;
for(size_t jjj=0; jjj<_list.size(); jjj++) {
//TK_DEBUG("compare : \""<<*tmpList[iii] << "\" and \"" << *m_listDirectory[jjj] << "\"");
if (tmpList[iii] > _list[jjj]) {
findPos = jjj+1;
}
}
//TK_DEBUG("position="<<findPos);
_list.insert(_list.begin()+findPos, tmpList[iii]);
}
}
namespace etk {
@ -181,41 +666,60 @@ etk::String etk::toString(const bool& _val) {
return "false";
}
template<>
etk::String etk::toString(const int& _val) {
etk::String etk::toString(const int8_t& _val) {
char tmpVal[256];
sprintf(tmpVal, "%d", _val);
return tmpVal;
}
template<>
etk::String etk::toString(const long& _val) {
etk::String etk::toString(const int16_t& _val) {
char tmpVal[256];
sprintf(tmpVal, "%ld", _val);
sprintf(tmpVal, "%d", _val);
return tmpVal;
}
template<>
etk::String etk::toString(const long long& _val) {
etk::String etk::toString(const int32_t& _val) {
char tmpVal[256];
sprintf(tmpVal, "%d", _val);
return tmpVal;
}
template<>
etk::String etk::toString(const int64_t& _val) {
char tmpVal[256];
sprintf(tmpVal, "%lld", _val);
return tmpVal;
}
template<>
etk::String etk::toString(const unsigned& _val) {
etk::String etk::toString(const uint8_t& _val) {
char tmpVal[256];
sprintf(tmpVal, "%u", _val);
return tmpVal;
}
template<>
etk::String etk::toString(const unsigned long& _val) {
etk::String etk::toString(const uint16_t& _val) {
char tmpVal[256];
sprintf(tmpVal, "%lu", _val);
sprintf(tmpVal, "%u", _val);
return tmpVal;
}
template<>
etk::String etk::toString(const unsigned long long& _val) {
etk::String etk::toString(const uint32_t& _val) {
char tmpVal[256];
sprintf(tmpVal, "%u", _val);
return tmpVal;
}
template<>
etk::String etk::toString(const uint64_t& _val) {
char tmpVal[256];
sprintf(tmpVal, "%llu", _val);
return tmpVal;
}
template<>
etk::String etk::toString(const size_t& _val) {
char tmpVal[256];
sprintf(tmpVal, "%zu", _val);
return tmpVal;
}
template<>
etk::String etk::toString(const float& _val) {
char tmpVal[256];
@ -357,6 +861,25 @@ etk::String etk::String::getLine(int32_t _pos) const {
return etk::String(*this, startPos, stopPos - startPos);
}
bool etk::String::compare(const etk::String& _val, bool _caseSensitive) const {
if (_val.size() != size()) {
return false;
}
if (_caseSensitive == true) {
for(size_t iii=0; iii<_val.size(); ++iii) {
if (_val[iii] != m_data[iii]) {
return false;
}
}
return true;
}
for(size_t iii=0; iii<_val.size(); ++iii) {
if (etk::toLower(_val[iii]) != etk::toLower(m_data[iii])) {
return false;
}
}
return true;
}
etk::Vector<etk::String> etk::String::split(char _val) const {
etk::Vector<etk::String> list;
@ -389,3 +912,154 @@ etk::Vector<etk::String> etk::String::split(etk::String _val) const {
return list;
}
namespace etk {
long double string_to_long_double(const etk::String& _obj) {
return _obj.to<long double>();
}
double string_to_double(const etk::String& _obj) {
return _obj.to<double>();
}
float string_to_float(const etk::String& _obj) {
return _obj.to<float>();
}
int8_t string_to_int8_t(const etk::String& _obj) {
return _obj.to<int8_t>();
}
int16_t string_to_int16_t(const etk::String& _obj) {
return _obj.to<int16_t>();
}
int32_t string_to_int32_t(const etk::String& _obj) {
return _obj.to<int32_t>();
}
int64_t string_to_int64_t(const etk::String& _obj) {
return _obj.to<int64_t>();
}
uint8_t string_to_uint8_t(const etk::String& _obj) {
return _obj.to<uint8_t>();
}
uint16_t string_to_uint16_t(const etk::String& _obj) {
return _obj.to<uint16_t>();
}
uint32_t string_to_uint32_t(const etk::String& _obj) {
return _obj.to<uint32_t>();
}
uint64_t string_to_uint64_t(const etk::String& _obj) {
return _obj.to<uint64_t>();
}
bool string_to_bool(const etk::String& _obj) {
return _obj.to<bool>();
}
etk::String tolower(etk::String _obj) {
return _obj.toLower();
}
etk::String toupper(etk::String _obj) {
return _obj.toUpper();
}
bool compare_no_case(const etk::String& _obj, const etk::String& _val) {
return _obj.compare(_val, false);
}
bool end_with(const etk::String& _obj, const etk::String& _val, bool _caseSensitive) {
return _obj.endWith(_val, _caseSensitive);
}
bool start_with(const etk::String& _obj, const etk::String& _val, bool _caseSensitive) {
return _obj.startWith(_val, _caseSensitive);
}
etk::String replace(const etk::String& _obj, char _val, char _replace) {
etk::String tmp = _obj;
tmp.replace(_val, _replace);
return tmp;
}
etk::String extract_line(const etk::String& _obj, int32_t _pos) {
return _obj.getLine(_pos);
}
etk::Vector<etk::String> split(const etk::String& _obj, char _val) {
return _obj.split(_val);
}
}
bool etk::operator> (const etk::String& _left, const etk::String& _right) {
for (size_t iii=0; iii<_left.size() && iii<_right.size(); ++iii) {
if (_left[iii] > _right[iii]) {
return true;
}
if (_left[iii] < _right[iii]) {
return false;
}
}
if (_left.size() > _right.size()) {
return true;
}
return false;
}
bool etk::operator>= (const etk::String& _left, const etk::String& _right) {
for (size_t iii=0; iii<_left.size() && iii<_right.size(); ++iii) {
if (_left[iii] > _right[iii]) {
return true;
}
if (_left[iii] < _right[iii]) {
return false;
}
}
if (_left.size() >= _right.size()) {
return true;
}
return false;
}
bool etk::operator< (const etk::String& _left, const etk::String& _right) {
for (size_t iii=0; iii<_left.size() && iii<_right.size(); ++iii) {
if (_left[iii] < _right[iii]) {
return true;
}
if (_left[iii] > _right[iii]) {
return false;
}
}
if (_left.size() < _right.size()) {
return true;
}
return false;
}
bool etk::operator<= (const etk::String& _left, const etk::String& _right) {
for (size_t iii=0; iii<_left.size() && iii<_right.size(); ++iii) {
if (_left[iii] < _right[iii]) {
return true;
}
if (_left[iii] > _right[iii]) {
return false;
}
}
if (_left.size() <= _right.size()) {
return true;
}
return false;
}
etk::String etk::operator+ (const etk::String& _left, const etk::String& _right) {
etk::String tmp = _left;
tmp += _right;
return tmp;
}
etk::String etk::operator+ (const etk::String& _left, const char* _right) {
etk::String tmp = _left;
tmp += _right;
return tmp;
}
etk::String etk::operator+ (const char* _left, const etk::String& _right) {
etk::String tmp = _left;
tmp += _right;
return tmp;
}
etk::String etk::operator+ (const etk::String& _left, char _right) {
etk::String tmp = _left;
tmp.pushBack(_right);
return tmp;
}
etk::String etk::operator+ (char _left, const etk::String& _right) {
etk::String tmp = _left;
tmp += _right;
return tmp;
}

541
etk/String.hpp
View File

@ -8,18 +8,9 @@
#include <etk/types.hpp>
#include <etk/debug.hpp>
#include <etk/Vector.hpp>
#include <etk/stdTools.hpp>
namespace etk {
template<class ETK_ITERATOR_TYPE>
size_t distance(const ETK_ITERATOR_TYPE& _start, const ETK_ITERATOR_TYPE& _stop) {
size_t out = 0;
ETK_ITERATOR_TYPE tmp = _start;
while (tmp != _stop) {
out++;
++tmp;
}
return out;
}
/**
* @brief string class ...
*/
@ -98,7 +89,7 @@ namespace etk {
* @brief Incremental operator
* @return Reference on a new iterator and increment the other one
*/
Iterator operator++ (int32_t) {
Iterator operator++ (int) {
Iterator it(*this);
++(*this);
return it;
@ -107,7 +98,7 @@ namespace etk {
* @brief Decremental operator
* @return Reference on a new iterator and decrement the other one
*/
Iterator operator-- (int32_t) {
Iterator operator-- (int) {
Iterator it(*this);
--(*this);
return it;
@ -122,11 +113,11 @@ namespace etk {
tmp -= _offset;
return tmp;
}
Iterator& operator-= (int64_t _offset) {
Iterator& operator-= (int _offset) {
m_current -= _offset;
return *this;
}
Iterator operator- (int64_t _offset) const {
Iterator operator- (int _offset) const {
Iterator tmp(*this);
tmp -= _offset;
return tmp;
@ -140,11 +131,11 @@ namespace etk {
tmp += _offset;
return tmp;
}
Iterator& operator+= (int64_t _offset) {
Iterator& operator+= (int _offset) {
m_current += _offset;
return *this;
}
Iterator operator+ (int64_t _offset) const {
Iterator operator+ (int _offset) const {
Iterator tmp(*this);
tmp += _offset;
return tmp;
@ -212,226 +203,101 @@ namespace etk {
/**
* @brief Create an empty string
*/
String():
m_data() {
m_data.resize(1, '\0');
}
String();
/**
* @brief Copy constructor (copy all data)
* @param[in] _obj String that might be copy
*/
String(const etk::String& _obj) {
m_data = _obj.m_data;
}
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) {
if (_pos + _size >= _obj.size()) {
_size = etk::String::npos;
}
if (_size != etk::String::npos) {
resize(_size);
for (size_t iii=0; iii<_size; ++iii) {
m_data[iii] = _obj.m_data[_pos+iii];
}
return;
}
resize(_obj.size()-_pos);
for (size_t iii=0; iii<_obj.size()-_pos; ++iii) {
m_data[iii] = _obj.m_data[_pos+iii];
}
}
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) {
if (_obj == nullptr) {
resize(0);
return;
}
uint32_t size = strlen(_obj);
resize(size);
for (size_t iii=0; iii<size; ++iii) {
m_data[iii] = _obj[iii];
}
}
String(const char* _obj);
// TODO : remove this when ready
String(const std::string _obj) {
resize(_obj.size());
for (size_t iii=0; iii<_obj.size(); ++iii) {
m_data[iii] = _obj[iii];
}
}
String(const std::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) {
if ( _obj == nullptr
|| _size == 0) {
resize(0);
return;
}
uint32_t size = strlen(_obj);
if (_size < size) {
size = _size;
}
resize(size);
for (size_t iii=0; iii<size; ++iii) {
m_data[iii] = _obj[iii];
}
}
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) {
resize(_size);
for (size_t iii=0; iii<_size; ++iii) {
m_data[iii] = _val;
}
}
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) {
size_t size = etk::distance(_start, _stop);
resize(size);
Iterator it = begin();
while (_start != _stop) {
*it++ = *_start++;
}
}
String(Iterator _start, Iterator _stop);
/**
* @brief Move constructor
* @param[in] _obj String that might be move inside
*/
String(String&& _obj) noexcept {
m_data = std::move(_obj.m_data);
}
String(String&& _obj) noexcept;
/**
* @brief Set constructor
* @param[in] _value Char element to set in the string
*/
String(char _value) {
resize(1);
m_data[0] = _value;
}
String(char _value);
/**
* @brief Destructor of the current Class
*/
~String() {
// nothing to do...
}
~String();
/**
* @brief Swap the data of 2 Strings
* @param[in] _obj second string to swap data.
*/
void swap(etk::String& _obj) {
// avoid Swap of itself
if(this != &_obj) {
m_data.swap(_obj.m_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) {
if (this != &_obj) {
m_data = _obj.m_data;
}
// Return the current pointer
return *this;
}
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) {
clear();
if (_obj == nullptr) {
return *this;
}
size_t numberElement = strlen(_obj);
resize(numberElement);
for (size_t iii=0; iii<numberElement; ++iii) {
m_data[iii] = _obj[iii];
}
// Return the current pointer
return *this;
}
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) {
resize(1);
m_data[0] = _value;
// Return the current pointer
return *this;
}
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) {
size_t numberElement = _obj.size();
size_t idElement = size();
resize(size()+_obj.size());
for (size_t iii=0; iii<_obj.size(); ++iii) {
m_data[idElement+iii] = _obj[iii];
}
// Return the current pointer
return *this;
}
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) {
if (_obj == nullptr) {
return *this;
}
size_t numberElement = strlen(_obj);
size_t idElement = size();
resize(size() + numberElement);
for (size_t iii=0; iii<numberElement; ++iii) {
m_data[idElement+iii] = _obj[iii];
}
// Return the current pointer
return *this;
}
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) {
pushBack(_value);
// Return the current pointer
return *this;
}
String& operator+= (char _value);
/**
* @brief Get the number of element in the string
* @return The number requested
*/
size_t size() const {
return m_data.size() - 1; // remove '\0'
}
size_t size() const;
/**
* @brief Get a current element in the string
* @param[in] _pos Desired position read
@ -460,268 +326,112 @@ namespace etk {
* @brief Add at the First position of the String
* @param[in] _item Element to add at the end of string
*/
void pushFront(char _item) {
insert(0, &_item, 1);
}
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) {
insert(0, _item, _nbElement);
}
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) {
size_t idElement = size();
resize(size()+1);
if (idElement < size()) {
m_data[idElement] = _item;
} else {
TK_ERROR("Resize does not work correctly ... not added item");
}
}
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) {
if (_item == nullptr) {
return;
}
size_t idElement = size();
resize(size()+_nbElement);
if (idElement > size()) {
TK_ERROR("Resize does not work correctly ... not added item");
return;
}
for (size_t iii=0; iii<_nbElement; iii++) {
m_data[idElement+iii] = _item[iii];
}
}
void pushBack(const char* _item, size_t _nbElement);
/**
* @brief Remove the last element of the string
*/
void popBack() {
if(size()>0) {
resize(size()-1);
}
}
void popBack();
/**
* @brief Remove all element in the current string
*/
void clear() {
resize(0);
}
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) {
if (_pos>size()) {
TK_WARNING(" can not insert Element at this position : " << _pos << " > " << size() << " add it at the end ... ");
pushBack(_item, _nbElement);
return;
}
size_t idElement = size();
// Request resize of the current buffer
resize(size()+_nbElement);
if (idElement>=size()) {
TK_ERROR("Resize does not work correctly ... not added item");
return;
}
// move current data (after the position)
size_t sizeToMove = (idElement - _pos);
if ( 0 < sizeToMove) {
for (size_t iii=1; iii<=sizeToMove; iii++) {
m_data[size()-iii] = m_data[idElement-iii];
}
}
// affectation of all input element
for (size_t iii=0; iii<_nbElement; iii++) {
m_data[_pos+iii] = _item[iii];
}
}
void insert(size_t _pos, const char* _item, size_t _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) {
insert(_pos, &_item, 1);
}
void insert(size_t _pos, const char _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) {
insert(_pos, &_value[0], _value.size());
}
void insert(size_t _pos, const String& _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) {
if (_pos>size()) {
TK_ERROR(" can not Erase Len Element at this position : " << _pos << " > " << size());
return;
}
if (_pos+_nbElement>size()) {
_nbElement = size() - _pos;
}
size_t idElement = size();
// move current data
size_t sizeToMove = (idElement - (_pos+_nbElement));
if ( 0 < sizeToMove) {
for (size_t iii=0; iii<sizeToMove; iii++) {
m_data[_pos+iii] = m_data[_pos+_nbElement+iii];
}
}
// Request resize of the current buffer
resize(size() - _nbElement);
}
void erase(size_t _pos, size_t _nbElement=1);
/**
* @brief Remove N elements
* @param[in] _pos Position to remove the data
* @param[in] _posEnd Last position number
*/
void eraseRange(size_t _pos, size_t _posEnd) {
if (_pos>size()) {
TK_ERROR(" can not Erase Element at this position : " << _pos << " > " << size());
return;
}
if (_posEnd > size()) {
_posEnd = size();
}
size_t nbElement = size() - _pos;
size_t tmpSize = size();
// move current data
size_t sizeToMove = (tmpSize - (_pos+nbElement));
if ( 0 < sizeToMove) {
for (size_t iii=0; iii<sizeToMove; iii++) {
m_data[_pos+iii] = m_data[_pos+nbElement+iii];
}
}
// Request resize of the current buffer
resize(size()-nbElement);
}
void eraseRange(size_t _pos, size_t _posEnd);
/**
* @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 {
etk::String out;
if (_posStart >= size() ) {
return out;
}
if (_posEnd >= size() ) {
_posEnd = size();
}
out.pushBack(&m_data[_posStart], _posEnd-_posStart);
return out;
}
etk::String extract(size_t _posStart = 0, size_t _posEnd=etk::String::npos) const;
/**
* @brief Get the pointer on the data
* @return pointer on the "C" string
*/
const char* c_str() const {
return &m_data[0];
}
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) {
return Iterator(this, _pos);
}
const Iterator position(size_t _pos) const {
return Iterator(this, _pos);
}
Iterator position(size_t _pos);
const Iterator position(size_t _pos) const;
/**
* @brief Get an Iterator on the start position of the String
* @return The Iterator
*/
Iterator begin() {
return position(0);
}
const Iterator begin() const {
return position(0);
}
Iterator begin();
const Iterator begin() const;
/**
* @brief Get an Iterator on the end position of the String
* @return The Iterator
*/
Iterator end() {
return position( size()-1 );
}
const Iterator end() const {
return position( size()-1 );
}
Iterator end();
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') {
size_t oldSize = m_data.size();
m_data[m_data.size()-1] = _value;
m_data.resize(_newSize + 1, _value);
// in all case ==> we have the last element that is '\0'
m_data[_newSize] = '\0';
}
void resize(size_t _newSize, char _value = '\0');
/*****************************************************
* == operator
*****************************************************/
bool operator== (const String& _obj) const {
// check if it was the same pointer
if( this == &_obj ) {
return true;
}
// first step : check the size ...
if (m_data.size() != _obj.m_data.size()) {
return false;
}
for (size_t iii=0; iii<m_data.size(); ++iii) {
if (m_data[iii] != _obj.m_data[iii]) {
return false;
}
}
return true;
}
bool operator== (const String& _obj) const;
/*****************************************************
* != operator
*****************************************************/
bool operator!= (const String& _obj) const {
// check if it was the same pointer
if( this == &_obj ) {
return false;
}
// first step : check the size ...
if (m_data.size() != _obj.m_data.size()) {
return true;
}
for (size_t iii=0; iii<m_data.size(); ++iii) {
if (m_data[iii] != _obj.m_data[iii]) {
return true;
}
}
return false;
}
size_t find(char _value, size_t _pos) const;
size_t find(const etk::String& _value, size_t _pos) const;
size_t rfind(char _value, size_t _pos) const;
size_t rfind(const etk::String& _value, size_t _pos) const;
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);
@ -743,87 +453,17 @@ namespace etk {
template <class ETK_STRING_TYPE>
ETK_STRING_TYPE to() const;
};
bool operator> (const String& _left, const String& _right) {
for (size_t iii=0; iii<_left.size() && iii<_right.size(); ++iii) {
if (_left[iii] > _right[iii]) {
return true;
}
if (_left[iii] < _right[iii]) {
return false;
}
}
if (_left.size() > _right.size()) {
return true;
}
return false;
}
bool operator>= (const String& _left, const String& _right) {
for (size_t iii=0; iii<_left.size() && iii<_right.size(); ++iii) {
if (_left[iii] > _right[iii]) {
return true;
}
if (_left[iii] < _right[iii]) {
return false;
}
}
if (_left.size() >= _right.size()) {
return true;
}
return false;
}
bool operator< (const String& _left, const String& _right) {
for (size_t iii=0; iii<_left.size() && iii<_right.size(); ++iii) {
if (_left[iii] < _right[iii]) {
return true;
}
if (_left[iii] > _right[iii]) {
return false;
}
}
if (_left.size() < _right.size()) {
return true;
}
return false;
}
bool operator<= (const String& _left, const String& _right) {
for (size_t iii=0; iii<_left.size() && iii<_right.size(); ++iii) {
if (_left[iii] < _right[iii]) {
return true;
}
if (_left[iii] > _right[iii]) {
return false;
}
}
if (_left.size() <= _right.size()) {
return true;
}
return false;
}
String operator+ (const String& _left, const String& _right) {
String tmp = _left;
tmp += _right;
return tmp;
}
String operator+ (const String& _left, const char* _right) {
String tmp = _left;
tmp += _right;
return tmp;
}
String operator+ (const char* _left, const String& _right) {
String tmp = _left;
tmp += _right;
return tmp;
}
String operator+ (const String& _left, char _right) {
String tmp = _left;
tmp.pushBack(_right);
return tmp;
}
String operator+ (char _left, const String& _right) {
String tmp = _left;
tmp += _right;
return tmp;
}
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);
/**
* @brief Template to declare conversion from anything in etk::String
* @param[in] _variable Variable to convert
@ -831,13 +471,49 @@ namespace etk {
*/
template <class TYPE>
etk::String toString(const TYPE& _variable);
//! @not_in_doc
std::ostream& operator <<(std::ostream& _os, const etk::String& _obj);
/**
* @brief Template to declare conversion from std::vector<anything> in etk::String
* @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);
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 std::vector<TYPE>& _list) {
etk::String toString(const etk::Vector<TYPE>& _list) {
etk::String out = "{";
for (size_t iii=0; iii<_list.size(); ++iii) {
if (iii!=0) {
@ -848,19 +524,4 @@ namespace etk {
out += "}";
return out;
}
//! @not_in_doc
std::ostream& operator <<(std::ostream& _os, const etk::String& _obj);
/**
* @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);
}

1146
etk/UString.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

526
etk/UString.hpp Normal file
View File

@ -0,0 +1,526 @@
/**
* @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>
#include <etk/utf8.hpp>
#include <etk/stdTools.hpp>
namespace etk {
/**
* @brief string class ...
*/
class UString {
public:
class Iterator {
private:
size_t m_current; //!< current Id on the string
UString* m_string; //!< Pointer on the current element of the stringBin
public:
/**
* @brief Basic iterator constructor with no link with an etk::UString
*/
Iterator():
m_current(0),
m_string(nullptr) {
// nothing to do ...
}
/**
* @brief Recopy constructor on a specific etk::UString.
* @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 = nullptr;
}
/**
* @brief basic boolean cast
* @return true if the element is present in the etk::UString size
*/
operator bool () {
return (m_current < m_string->size());
}
/**
* @brief Incremental operator
* @return Reference on the current iterator increment
*/
Iterator& operator++ () {
if ( m_string != nullptr
&& m_current < m_string->size() )
{
m_current++;
}
return *this;
}
/**
* @brief Decremental operator
* @return Reference on the current iterator decrement
*/
Iterator& operator-- () {
if ( m_string != nullptr
&& 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
*/
char32_t 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
*/
char32_t& 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 UString* _obj, int32_t _pos):
m_current(_pos),
m_string(const_cast<UString*>(_obj)) {
// nothing to do ...
}
friend class UString;
};
private:
etk::Vector<char32_t> m_data; //!< pointer on the current data (contain all time 1 element '\0')
public:
static const size_t npos = size_t(-1);
/**
* @brief Create an empty string
*/
UString();
/**
* @brief Copy constructor (copy all data)
* @param[in] _obj String that might be copy
*/
UString(const etk::UString& _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
*/
UString(const etk::UString& _obj, size_t _pos, size_t _size = etk::UString::npos);
/**
* @brief Copy the null-terminated C string.
* @param[in] _obj C string that might be copy (end by '\0')
*/
UString(const char32_t* _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.
*/
UString(const char32_t* _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
*/
UString(size_t _size, char32_t _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.
*/
UString(Iterator _start, Iterator _stop);
/**
* @brief Move constructor
* @param[in] _obj String that might be move inside
*/
UString(etk::UString&& _obj) noexcept;
/**
* @brief Set constructor
* @param[in] _value Char element to set in the string
*/
UString(char32_t _value);
/**
* @brief Destructor of the current Class
*/
~UString();
/**
* @brief Swap the data of 2 Strings
* @param[in] _obj second string to swap data.
*/
void swap(etk::UString& _obj);
/**
* @brief Re-copy operator
* @param[in] _obj String that might be copy
* @return reference on the current re-copy string
*/
UString& operator=(const etk::UString& _obj);
/**
* @brief Re-copy operator
* @param[in] _obj C string terminated with '\0'
* @return reference on the current re-copy string
*/
UString& operator=(const char32_t* _obj);
/**
* @brief Re-copy operator
* @param[in] _value char32_t value to set in the string
* @return reference on the current re-copy string
*/
UString& operator=(char32_t _value);
/**
* @brief Add at the Last position of the String
* @param[in] _obj Element to add at the end of string
*/
UString& operator+= (const etk::UString& _obj);
/**
* @brief Add at the Last position of the String
* @param[in] _obj C string terminated with '\0'
*/
UString& operator+= (const char32_t* _obj);
/**
* @brief Add at the Last position of the String
* @param[in] _value Simple character to add.
*/
UString& operator+= (char32_t _value);
/**
* @brief Get the number of element in the string
* @return The number requested
*/
size_t size() const;
/**
* @brief Get a current element in the string
* @param[in] _pos Desired position read
* @return Reference on the Element
*/
char32_t& get(size_t _pos) {
return m_data[_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
*/
char32_t& operator[] (size_t _pos) {
return m_data[_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 char32_t& operator[] (size_t _pos) const {
return m_data[_pos];
}
/**
* @brief Add at the First position of the String
* @param[in] _item Element to add at the end of string
*/
void pushFront(char32_t _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 char32_t* _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 char32_t _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 char32_t* _item, size_t _nbElement);
/**
* @brief Remove the last element of the string
*/
void popBack();
/**
* @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 char32_t* _item, size_t _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 char32_t _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 etk::UString& _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);
/**
* @brief Remove N elements
* @param[in] _pos Position to remove the data
* @param[in] _posEnd Last position number
*/
void eraseRange(size_t _pos, size_t _posEnd);
/**
* @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::UString extract(size_t _posStart = 0, size_t _posEnd=etk::UString::npos) const;
/**
* @brief Get the pointer on the data
* @return pointer on the "C" string
*/
const char32_t* 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);
const Iterator position(size_t _pos) const;
/**
* @brief Get an Iterator on the start position of the String
* @return The Iterator
*/
Iterator begin();
const Iterator begin() const;
/**
* @brief Get an Iterator on the end position of the String
* @return The Iterator
*/
Iterator end();
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, char32_t _value = '\0');
/*****************************************************
* == operator
*****************************************************/
bool operator== (const etk::UString& _obj) const;
/*****************************************************
* != operator
*****************************************************/
bool operator!= (const etk::UString& _obj) const;
size_t find(char32_t _value, size_t _pos=0) const;
size_t find(const etk::UString& _value, size_t _pos=0) const;
size_t rfind(char32_t _value, size_t _pos=etk::UString::npos) const;
size_t rfind(const etk::UString& _value, size_t _pos=etk::UString::npos) const;
etk::UString& replace(size_t _pos, size_t _len, char32_t _replace);
etk::UString& replace(size_t _pos, size_t _len, const etk::UString& _replace);
etk::UString& replace(char32_t _val, char32_t _replace);
etk::UString& replace(const etk::UString& _val, const etk::UString& _replace);
etk::UString getLine(int32_t _pos) const;
etk::UString toLower() const;
etk::UString& lower();
etk::UString toUpper() const;
etk::UString& upper();
bool compare(const etk::UString& _val, bool _caseSensitive = true) const;
bool endWith(const etk::UString& _val, bool _caseSensitive = true) const;
bool startWith(const etk::UString& _val, bool _caseSensitive = true) const;
etk::Vector<etk::UString> split(char32_t _val) const;
etk::Vector<etk::UString> split(etk::UString _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;
};
char32_t toLower(char32_t _value);
char32_t toUpper(char32_t _value);
bool operator> (const UString& _left, const UString& _right);
bool operator>= (const UString& _left, const UString& _right);
bool operator< (const UString& _left, const UString& _right);
bool operator<= (const UString& _left, const UString& _right);
UString operator+ (const UString& _left, const UString& _right);
UString operator+ (const UString& _left, const char32_t* _right);
UString operator+ (const char32_t* _left, const UString& _right);
UString operator+ (const UString& _left, char32_t _right);
UString operator+ (char32_t _left, const UString& _right);
/**
* @brief Template to declare conversion from anything in etk::UString
* @param[in] _variable Variable to convert
* @return String of the value
*/
template <class TYPE>
etk::UString toUString(const TYPE& _variable);
//! @not_in_doc
std::ostream& operator <<(std::ostream& _os, const etk::UString& _obj);
/**
* @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::UString& _value);
void sort(etk::Vector<etk::UString *>& _list);
void sort(etk::Vector<etk::UString>& _list);
// TODO: DEPRECATED function:
long double string_to_long_double(const etk::UString& _obj);
double string_to_double(const etk::UString& _obj);
float string_to_float(const etk::UString& _obj);
int8_t string_to_int8_t(const etk::UString& _obj);
int16_t string_to_int16_t(const etk::UString& _obj);
int32_t string_to_int32_t(const etk::UString& _obj);
int64_t string_to_int64_t(const etk::UString& _obj);
uint8_t string_to_uint8_t(const etk::UString& _obj);
uint16_t string_to_uint16_t(const etk::UString& _obj);
uint32_t string_to_uint32_t(const etk::UString& _obj);
uint64_t string_to_uint64_t(const etk::UString& _obj);
bool string_to_bool(const etk::UString& _obj);
etk::UString tolower(etk::UString _obj);
etk::UString toupper(etk::UString _obj);
bool compare_no_case(const etk::UString& _obj, const etk::UString& _val);
bool end_with(const etk::UString& _obj, const etk::UString& _val, bool _caseSensitive = true);
bool start_with(const etk::UString& _obj, const etk::UString& _val, bool _caseSensitive = true);
etk::UString replace(const etk::UString& _obj, char32_t _val, char32_t _replace);
etk::UString extract_line(const etk::UString& _obj, int32_t _pos);
etk::Vector<etk::UString> split(const etk::UString& _obj, char32_t _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::UString toUString(const etk::Vector<TYPE>& _list) {
etk::UString out = U"{";
for (size_t iii=0; iii<_list.size(); ++iii) {
if (iii!=0) {
out += U";";
}
out+= etk::toUString(_list[iii]);
}
out += U"}";
return out;
}
}

11
etk/Vector.hpp
View File

@ -713,6 +713,7 @@ namespace etk {
return false;
}
};
//! @not_in_doc
template<class ETK_VECTOR_TYPE>
std::ostream& operator <<(std::ostream& _os, const etk::Vector<ETK_VECTOR_TYPE>& _obj) {
_os << "{";
@ -725,4 +726,14 @@ namespace etk {
_os << "}";
return _os;
}
//! @not_in_doc
template<typename T, typename T2>
bool isIn(const T& _val, const etk::Vector<T2>& _list) {
for (size_t iii=0; iii<_list.size(); ++iii) {
if (_list[iii] == _val) {
return true;
}
}
return false;
}
}

11
etk/debug.hpp
View File

@ -34,6 +34,17 @@ namespace etk {
#define TK_HIDDEN(data) do { } while(false)
#ifdef DEBUG
#define TK_CHECK_INOUT(condition) \
do { \
if (!(condition)) { \
TK_ERROR("Wrong condition : " #condition); \
} \
} while (0)
#else
#define TK_CHECK_INOUT(condition) do { } while(false)
#endif
#define TK_ASSERT(condition,data) \
do { \
if (!(condition)) { \

88
etk/math/Vector2D.cpp
View File

@ -118,12 +118,12 @@ namespace etk {
return str;
}
#if __CPP_VERSION__ >= 2011
template<> Vector2D<bool>::operator std::u32string() const {
std::u32string str;
template<> Vector2D<bool>::operator etk::UString() const {
etk::UString str;
str = U"(";
str += etk::to_u32string(x());
str += etk::toUString(x());
str += U",";
str += etk::to_u32string(y());
str += etk::toUString(y());
str += U")";
return str;
}
@ -154,11 +154,11 @@ namespace etk {
TK_VERBOSE("Parse : '" << _str << "' ==> " << *this);
}
#if __CPP_VERSION__ >= 2011
template<> Vector2D<bool>::Vector2D(const std::u32string& _str) {
template<> Vector2D<bool>::Vector2D(const etk::UString& _str) {
m_floats[0] = false;
m_floats[1] = false;
// copy to permit to modify it :
std::u32string tmpStr = _str;
etk::UString tmpStr = _str;
if (tmpStr[0] == '(') {
tmpStr.erase(tmpStr.begin());
}
@ -172,7 +172,7 @@ namespace etk {
m_floats[0] = etk::string_to_bool(tmpStr);
m_floats[1] = m_floats[0];
} else {
m_floats[0] = etk::string_to_bool(std::u32string(tmpStr, 0, posComa));
m_floats[0] = etk::string_to_bool(etk::UString(tmpStr, 0, posComa));
tmpStr.erase(0, posComa+1);
m_floats[1] = etk::string_to_bool(tmpStr);
}
@ -190,12 +190,12 @@ namespace etk {
return str;
}
#if __CPP_VERSION__ >= 2011
template<> Vector2D<int32_t>::operator std::u32string() const {
std::u32string str;
template<> Vector2D<int32_t>::operator etk::UString() const {
etk::UString str;
str = U"(";
str += etk::to_u32string(x());
str += etk::toUString(x());
str += U",";
str += etk::to_u32string(y());
str += etk::toUString(y());
str += U")";
return str;
}
@ -227,11 +227,11 @@ namespace etk {
TK_VERBOSE("Parse : \"" << _str << "\" ==> " << *this);
}
#if __CPP_VERSION__ >= 2011
template<> Vector2D<int32_t>::Vector2D(const std::u32string& _str) {
template<> Vector2D<int32_t>::Vector2D(const etk::UString& _str) {
m_floats[0] = 0;
m_floats[1] = 0;
// copy to permit to modify it :
std::u32string tmpStr = _str;
etk::UString tmpStr = _str;
if (tmpStr[0] == '(') {
tmpStr.erase(tmpStr.begin());
}
@ -246,7 +246,7 @@ namespace etk {
m_floats[0] = etk::string_to_int32_t(tmpStr);
m_floats[1] = m_floats[0];
} else {
m_floats[0] = etk::string_to_int32_t(std::u32string(tmpStr, 0, posComa));
m_floats[0] = etk::string_to_int32_t(etk::UString(tmpStr, 0, posComa));
tmpStr.erase(0,posComa+1);
m_floats[1] = etk::string_to_int32_t(tmpStr);
}
@ -264,12 +264,12 @@ namespace etk {
return str;
}
#if __CPP_VERSION__ >= 2011
template<> Vector2D<uint32_t>::operator std::u32string() const {
std::u32string str;
template<> Vector2D<uint32_t>::operator etk::UString() const {
etk::UString str;
str = U"(";
str += etk::to_u32string(x());
str += etk::toUString(x());
str += U",";
str += etk::to_u32string(y());
str += etk::toUString(y());
str += U")";
return str;
}
@ -300,11 +300,11 @@ namespace etk {
TK_VERBOSE("Parse : \"" << _str << "\" ==> " << *this);
}
#if __CPP_VERSION__ >= 2011
template<> Vector2D<uint32_t>::Vector2D(const std::u32string& _str) {
template<> Vector2D<uint32_t>::Vector2D(const etk::UString& _str) {
m_floats[0] = 0;
m_floats[1] = 0;
// copy to permit to modify it :
std::u32string tmpStr = _str;
etk::UString tmpStr = _str;
if (tmpStr[0] == '(') {
tmpStr.erase(tmpStr.begin());
}
@ -318,7 +318,7 @@ namespace etk {
m_floats[0] = etk::string_to_int32_t(tmpStr);
m_floats[1] = m_floats[0];
} else {
m_floats[0] = etk::string_to_int32_t(std::u32string(tmpStr, 0, posComa));
m_floats[0] = etk::string_to_int32_t(etk::UString(tmpStr, 0, posComa));
tmpStr.erase(0,posComa+1);
m_floats[1] = etk::string_to_int32_t(tmpStr);
}
@ -336,12 +336,12 @@ namespace etk {
return str;
}
#if __CPP_VERSION__ >= 2011
template<> Vector2D<float>::operator std::u32string() const {
std::u32string str;
template<> Vector2D<float>::operator etk::UString() const {
etk::UString str;
str = U"(";
str += etk::to_u32string(x());
str += etk::toUString(x());
str += U",";
str += etk::to_u32string(y());
str += etk::toUString(y());
str += U")";
return str;
}
@ -372,11 +372,11 @@ namespace etk {
TK_VERBOSE("Parse : \"" << _str << "\" ==> " << *this);
}
#if __CPP_VERSION__ >= 2011
template<> Vector2D<float>::Vector2D(const std::u32string& _str) {
template<> Vector2D<float>::Vector2D(const etk::UString& _str) {
m_floats[0] = 0;
m_floats[1] = 0;
// copy to permit to modify it :
std::u32string tmpStr = _str;
etk::UString tmpStr = _str;
if (tmpStr[0] == '(') {
tmpStr.erase(tmpStr.begin());
}
@ -390,7 +390,7 @@ namespace etk {
m_floats[0] = etk::string_to_float(tmpStr);
m_floats[1] = m_floats[0];
} else {
m_floats[0] = etk::string_to_float(std::u32string(tmpStr, 0, posComa));
m_floats[0] = etk::string_to_float(etk::UString(tmpStr, 0, posComa));
tmpStr.erase(0,posComa+1);
m_floats[1] = etk::string_to_float(tmpStr);
}
@ -398,7 +398,7 @@ namespace etk {
}
#endif
template<> etk::String to_string<vec2>(const vec2& _obj) {
template<> etk::String toString<vec2>(const vec2& _obj) {
etk::String str;
str = "(";
str += etk::toString(_obj.x());
@ -408,12 +408,12 @@ namespace etk {
return str;
}
#if __CPP_VERSION__ >= 2011
template<> std::u32string to_u32string<vec2>(const vec2& _obj) {
return etk::to_u32string(etk::toString(_obj));
template<> etk::UString toUString<vec2>(const vec2& _obj) {
return etk::toUString(etk::toString(_obj));
}
#endif
template<> etk::String to_string<ivec2>(const ivec2& _obj) {
template<> etk::String toString<ivec2>(const ivec2& _obj) {
etk::String str;
str = "(";
str += etk::toString(_obj.x());
@ -423,12 +423,12 @@ namespace etk {
return str;
}
#if __CPP_VERSION__ >= 2011
template<> std::u32string to_u32string<ivec2>(const ivec2& _obj) {
return etk::to_u32string(etk::toString(_obj));
template<> etk::UString toUString<ivec2>(const ivec2& _obj) {
return etk::toUString(etk::toString(_obj));
}
#endif
template<> etk::String to_string<uivec2>(const uivec2& _obj) {
template<> etk::String toString<uivec2>(const uivec2& _obj) {
etk::String str;
str = "(";
str += etk::toString(_obj.x());
@ -438,12 +438,12 @@ namespace etk {
return str;
}
#if __CPP_VERSION__ >= 2011
template<> std::u32string to_u32string<uivec2>(const uivec2& _obj) {
return etk::to_u32string(etk::toString(_obj));
template<> etk::UString toUString<uivec2>(const uivec2& _obj) {
return etk::toUString(etk::toString(_obj));
}
#endif
template<> etk::String to_string<bvec2>(const bvec2& _obj) {
template<> etk::String toString<bvec2>(const bvec2& _obj) {
etk::String str;
str = "(";
str += etk::toString(_obj.x());
@ -453,8 +453,8 @@ namespace etk {
return str;
}
#if __CPP_VERSION__ >= 2011
template<> std::u32string to_u32string<bvec2>(const bvec2& _obj) {
return etk::to_u32string(etk::toString(_obj));
template<> etk::UString toUString<bvec2>(const bvec2& _obj) {
return etk::toUString(etk::toString(_obj));
}
#endif
@ -463,7 +463,7 @@ namespace etk {
return true;
}
#if __CPP_VERSION__ >= 2011
template<> bool from_string<vec2>(vec2& _variableRet, const std::u32string& _value) {
template<> bool from_string<vec2>(vec2& _variableRet, const etk::UString& _value) {
return from_string(_variableRet, etk::toString(_value));
}
#endif
@ -473,7 +473,7 @@ namespace etk {
return true;
}
#if __CPP_VERSION__ >= 2011
template<> bool from_string<ivec2>(ivec2& _variableRet, const std::u32string& _value) {
template<> bool from_string<ivec2>(ivec2& _variableRet, const etk::UString& _value) {
return from_string(_variableRet, etk::toString(_value));
}
#endif
@ -483,7 +483,7 @@ namespace etk {
return true;
}
#if __CPP_VERSION__ >= 2011
template<> bool from_string<uivec2>(uivec2& _variableRet, const std::u32string& _value) {
template<> bool from_string<uivec2>(uivec2& _variableRet, const etk::UString& _value) {
return from_string(_variableRet, etk::toString(_value));
}
#endif
@ -493,7 +493,7 @@ namespace etk {
return true;
}
#if __CPP_VERSION__ >= 2011
template<> bool from_string<bvec2>(bvec2& _variableRet, const std::u32string& _value) {
template<> bool from_string<bvec2>(bvec2& _variableRet, const etk::UString& _value) {
return from_string(_variableRet, etk::toString(_value));
}
#endif

32
etk/math/Vector3D.cpp
View File

@ -138,7 +138,7 @@ vec3 quaternionToEulerXYZ(const btQuaternion& _quat) {
#endif
namespace etk {
template<> etk::String to_string<vec3>(const vec3& _obj) {
template<> etk::String toString<vec3>(const vec3& _obj) {
etk::String str;
str = "(";
str += etk::toString(_obj.x());
@ -150,12 +150,12 @@ namespace etk {
return str;
}
#if __CPP_VERSION__ >= 2011
template<> std::u32string to_u32string<vec3>(const vec3& _obj) {
return etk::to_u32string(etk::toString(_obj));
template<> etk::UString toUString<vec3>(const vec3& _obj) {
return etk::toUString(etk::toString(_obj));
}
#endif
template<> etk::String to_string<ivec3>(const ivec3& _obj) {
template<> etk::String toString<ivec3>(const ivec3& _obj) {
etk::String str;
str = "(";
str += etk::toString(_obj.x());
@ -167,12 +167,12 @@ namespace etk {
return str;
}
#if __CPP_VERSION__ >= 2011
template<> std::u32string to_u32string<ivec3>(const ivec3& _obj) {
return etk::to_u32string(etk::toString(_obj));
template<> etk::UString toUString<ivec3>(const ivec3& _obj) {
return etk::toUString(etk::toString(_obj));
}
#endif
template<> etk::String to_string<uivec3>(const uivec3& _obj) {
template<> etk::String toString<uivec3>(const uivec3& _obj) {
etk::String str;
str = "(";
str += etk::toString(_obj.x());
@ -184,12 +184,12 @@ namespace etk {
return str;
}
#if __CPP_VERSION__ >= 2011
template<> std::u32string to_u32string<uivec3>(const uivec3& _obj) {
return etk::to_u32string(etk::toString(_obj));
template<> etk::UString toUString<uivec3>(const uivec3& _obj) {
return etk::toUString(etk::toString(_obj));
}
#endif
template<> etk::String to_string<bvec3>(const bvec3& _obj) {
template<> etk::String toString<bvec3>(const bvec3& _obj) {
etk::String str;
str = "(";
str += etk::toString(_obj.x());
@ -201,8 +201,8 @@ namespace etk {
return str;
}
#if __CPP_VERSION__ >= 2011
template<> std::u32string to_u32string<bvec3>(const bvec3& _obj) {
return etk::to_u32string(etk::toString(_obj));
template<> etk::UString toUString<bvec3>(const bvec3& _obj) {
return etk::toUString(etk::toString(_obj));
}
#endif
@ -246,7 +246,7 @@ namespace etk {
return true;
}
#if __CPP_VERSION__ >= 2011
template<> bool from_string<vec3>(vec3& _variableRet, const std::u32string& _value) {
template<> bool from_string<vec3>(vec3& _variableRet, const etk::UString& _value) {
return from_string(_variableRet, etk::toString(_value));
}
#endif
@ -291,7 +291,7 @@ namespace etk {
return true;
}
#if __CPP_VERSION__ >= 2011
template<> bool from_string<ivec3>(ivec3& _variableRet, const std::u32string& _value) {
template<> bool from_string<ivec3>(ivec3& _variableRet, const etk::UString& _value) {
return from_string(_variableRet, etk::toString(_value));
}
#endif
@ -336,7 +336,7 @@ namespace etk {
return true;
}
#if __CPP_VERSION__ >= 2011
template<> bool from_string<uivec3>(uivec3& _variableRet, const std::u32string& _value) {
template<> bool from_string<uivec3>(uivec3& _variableRet, const etk::UString& _value) {
return from_string(_variableRet, etk::toString(_value));
}
#endif
@ -381,7 +381,7 @@ namespace etk {
return true;
}
#if __CPP_VERSION__ >= 2011
template<> bool from_string<bvec3>(bvec3& _variableRet, const std::u32string& _value) {
template<> bool from_string<bvec3>(bvec3& _variableRet, const etk::UString& _value) {
return from_string(_variableRet, etk::toString(_value));
}
#endif

244
etk/os/FSNode.cpp
View File

@ -40,8 +40,8 @@ extern "C" {
#ifdef __TARGET_OS__Windows
static std::vector<etk::String> getListDrive() {
std::vector<etk::String> out;
static etk::Vector<etk::String> getListDrive() {
etk::Vector<etk::String> out;
int dr_type=99;
char dr_avail[4096];
char *temp=dr_avail;
@ -59,23 +59,23 @@ extern "C" {
break;
case 2: // Removable Drive
TK_WARNING("'" << driveName << "' : Removable Drive type");
out.push_back(driveName);
out.pushBack(driveName);
break;
case 3: // Fixed
TK_WARNING("'" << driveName << "' : Hard Disk (Fixed) Drive type");
out.push_back(driveName);
out.pushBack(driveName);
break;
case 4: // Remote
TK_WARNING("'" << driveName << "' : Remote (Network) Drive type");
out.push_back(driveName);
out.pushBack(driveName);
break;
case 5: // CDROM
TK_WARNING("'" << driveName << "' : CD-Rom/DVD-Rom Drive type");
out.push_back(driveName);
out.pushBack(driveName);
break;
case 6: // RamDrive
TK_WARNING("'" << driveName << "' : Ram Drive type");
out.push_back(driveName);
out.pushBack(driveName);
break;
}
temp += lstrlen(temp) + 1; // incriment the buffer
@ -83,8 +83,8 @@ extern "C" {
return out;
}
#else
static std::vector<etk::String> getListDrive() {
std::vector<etk::String> out;
static etk::Vector<etk::String> getListDrive() {
etk::Vector<etk::String> out;
return out;
}
#endif
@ -403,7 +403,7 @@ void etk::setArgZero(const etk::String& _val) {
std::unique_lock<std::mutex> lock(getNodeMutex());
l_argZero = _val;
// set defaiult application name ...
std::vector<etk::String> elems = etk::split(_val, '/');
etk::Vector<etk::String> elems = etk::split(_val, '/');
etk::initDefaultFolder(elems[elems.size()-1].c_str());
}
/*
@ -490,8 +490,8 @@ etk::String getApplicationPath() {
return binaryName;
}
#if __CPP_VERSION__ >= 2011
std::u32string getUApplicationPath() {
return etk::to_u32string(getApplicationPath());
etk::UString getUApplicationPath() {
return etk::toUString(getApplicationPath());
}
#endif
@ -653,8 +653,8 @@ etk::String etk::getUserHomeFolder() {
return baseFolderHome;
}
#if __CPP_VERSION__ >= 2011
std::u32string etk::getUUserHomeFolder() {
return etk::to_u32string(baseFolderHome);
etk::UString etk::getUUserHomeFolder() {
return etk::toUString(baseFolderHome);
}
#endif
@ -662,8 +662,8 @@ etk::String etk::getUserRunFolder() {
return baseRunPath;
}
#if __CPP_VERSION__ >= 2011
std::u32string etk::getUUserRunFolder() {
return etk::to_u32string(baseRunPath);
etk::UString etk::getUUserRunFolder() {
return etk::toUString(baseRunPath);
}
#endif
@ -705,7 +705,7 @@ etk::FSNode::FSNode(const etk::String& _nodeName) :
privateSetName(_nodeName);
}
#if __CPP_VERSION__ >= 2011
etk::FSNode::FSNode(const std::u32string& _nodeName) :
etk::FSNode::FSNode(const etk::UString& _nodeName) :
m_userFileName(""),
m_type(etk::FSNType_unknow),
m_typeNode(etk::typeNode_unknow),
@ -735,8 +735,8 @@ etk::FSNode::~FSNode() {
}
void etk::FSNode::sortElementList(std::vector<etk::FSNode *>& _list) {
std::vector<etk::FSNode *> tmpList = _list;
void etk::FSNode::sortElementList(etk::Vector<etk::FSNode *>& _list) {
etk::Vector<etk::FSNode *> tmpList = _list;
_list.clear();
for(size_t iii=0; iii<tmpList.size(); iii++) {
if (nullptr != tmpList[iii]) {
@ -940,8 +940,8 @@ void etk::FSNode::privateSetName(etk::String _newName) {
TK_DBG_MODE("6 : type : [" << m_typeNode << "] right :" << m_rights);
}
#if __CPP_VERSION__ >= 2011
void etk::FSNode::privateSetName(const std::u32string& _newName) {
privateSetName(etk::to_string(_newName));
void etk::FSNode::privateSetName(const etk::UString& _newName) {
privateSetName(etk::toString(_newName));
}
#endif
@ -963,8 +963,8 @@ bool directCheckFile(etk::String _tmpFileNameDirect, bool _checkInAPKIfNeeded =
return true;
}
#if __CPP_VERSION__ >= 2011
bool directCheckFile(std::u32string _tmpFileNameDirect, bool _checkInAPKIfNeeded = false) {
return directCheckFile(etk::to_string(_tmpFileNameDirect));
bool directCheckFile(etk::UString _tmpFileNameDirect, bool _checkInAPKIfNeeded = false) {
return directCheckFile(etk::toString(_tmpFileNameDirect));
}
#endif
// Now we generate the real FS path:
@ -1026,7 +1026,7 @@ void etk::FSNode::generateFileSystemPath() {
case etk::FSNType_theme:
case etk::FSNType_themeData:
{
//std::u32string myCompleateName=baseFolderData + "/theme/";
//etk::UString myCompleateName=baseFolderData + "/theme/";
etk::String themeName("");
etk::String basicName(m_userFileName);
size_t firstPos = m_userFileName.find(':');
@ -1231,7 +1231,7 @@ void etk::FSNode::setName(const etk::String& _newName) {
privateSetName(_newName);
}
#if __CPP_VERSION__ >= 2011
void etk::FSNode::setName(const std::u32string& _newName) {
void etk::FSNode::setName(const etk::UString& _newName) {
privateSetName(_newName);
}
#endif
@ -1244,8 +1244,8 @@ etk::String etk::FSNode::getNameFolder() const {
return "";
}
#if __CPP_VERSION__ >= 2011
std::u32string etk::FSNode::getUNameFolder() const {
return etk::to_u32string(getNameFolder());
etk::UString etk::FSNode::getUNameFolder() const {
return etk::toUString(getNameFolder());
}
#endif
@ -1253,8 +1253,8 @@ etk::String etk::FSNode::getFileSystemName() const {
return m_systemFileName;
}
#if __CPP_VERSION__ >= 2011
std::u32string etk::FSNode::getUFileSystemName() const {
return etk::to_u32string(getFileSystemName());
etk::UString etk::FSNode::getUFileSystemName() const {
return etk::toUString(getFileSystemName());
}
#endif
@ -1297,8 +1297,8 @@ etk::String etk::FSNode::getName() const {
return output;
}
#if __CPP_VERSION__ >= 2011
std::u32string etk::FSNode::getUName() const {
return etk::to_u32string(getName());
etk::UString etk::FSNode::getUName() const {
return etk::toUString(getName());
}
#endif
@ -1310,8 +1310,8 @@ etk::String etk::FSNode::getNameFile() const {
return "";
}
#if __CPP_VERSION__ >= 2011
std::u32string etk::FSNode::getUNameFile() const {
return etk::to_u32string(getNameFile());
etk::UString etk::FSNode::getUNameFile() const {
return etk::toUString(getNameFile());
}
#endif
@ -1354,8 +1354,8 @@ etk::String etk::FSNode::getRelativeFolder() const {
return "";
}
#if __CPP_VERSION__ >= 2011
std::u32string etk::FSNode::getURelativeFolder() const {
return etk::to_u32string(getRelativeFolder());
etk::UString etk::FSNode::getURelativeFolder() const {
return etk::toUString(getRelativeFolder());
}
#endif
@ -1390,8 +1390,8 @@ bool etk::FSNode::move(const etk::String& _path) {
}
}
#if __CPP_VERSION__ >= 2011
bool etk::FSNode::move(const std::u32string& _path) {
return move(etk::to_string(_path));
bool etk::FSNode::move(const etk::UString& _path) {
return move(etk::toString(_path));
}
#endif
@ -1427,8 +1427,8 @@ etk::String etk::FSNode::timeCreatedString() const {
return tmpTime;
}
#if __CPP_VERSION__ >= 2011
std::u32string etk::FSNode::timeUCreatedString() const {
return etk::to_u32string(timeCreatedString());
etk::UString etk::FSNode::timeUCreatedString() const {
return etk::toUString(timeCreatedString());
}
#endif
@ -1445,8 +1445,8 @@ etk::String etk::FSNode::timeModifiedString() const {
return tmpTime;
}
#if __CPP_VERSION__ >= 2011
std::u32string etk::FSNode::timeUModifiedString() const {
return etk::to_u32string(timeModifiedString());
etk::UString etk::FSNode::timeUModifiedString() const {
return etk::toUString(timeModifiedString());
}
#endif
@ -1463,8 +1463,8 @@ etk::String etk::FSNode::timeAccessedString() const {
return tmpTime;
}
#if __CPP_VERSION__ >= 2011
std::u32string etk::FSNode::timeUAccessedString() const {
return etk::to_u32string(timeAccessedString());
etk::UString etk::FSNode::timeUAccessedString() const {
return etk::toUString(timeAccessedString());
}
#endif
/*
@ -1622,7 +1622,7 @@ int64_t etk::FSNode::folderCount() {
return counter;
}
std::vector<etk::FSNode *> etk::FSNode::folderGetSubList(bool _showHidenFile, bool _getFolderAndOther, bool _getFile, bool _temporaryFile) {
etk::Vector<etk::FSNode *> etk::FSNode::folderGetSubList(bool _showHidenFile, bool _getFolderAndOther, bool _getFile, bool _temporaryFile) {
etk::String filter=".*";
if (_temporaryFile == true) {
filter = ".*(~|\\.bck|\\.tmp)";
@ -1630,15 +1630,15 @@ std::vector<etk::FSNode *> etk::FSNode::folderGetSubList(bool _showHidenFile, bo
return etk::FSNode::folderGetSubList(_showHidenFile, _getFolderAndOther, _getFile, filter);
}
std::vector<etk::FSNode *> etk::FSNode::folderGetSubList(bool _showHidenFile, bool _getFolderAndOther, bool _getFile, const etk::String& _filter) {
etk::Vector<etk::FSNode *> etk::FSNode::folderGetSubList(bool _showHidenFile, bool _getFolderAndOther, bool _getFile, const etk::String& _filter) {
TK_TODO("implement filter ... ");
std::vector<etk::FSNode*> tmpp;
etk::Vector<etk::FSNode*> tmpp;
#ifdef __TARGET_OS__Windows
/*
if (m_systemFileName.size() == 0) {
std::vector<etk::String> listDrive = getListDrive();
etk::Vector<etk::String> listDrive = getListDrive();
for (auto &it : listDrive) {
tmpp.push_back(new etk::FSNode(it));
tmpp.pushBack(new etk::FSNode(it));
}
return tmpp;
}
@ -1652,7 +1652,7 @@ std::vector<etk::FSNode *> etk::FSNode::folderGetSubList(bool _showHidenFile, bo
#ifdef HAVE_ZIP_DATA
if( m_type == etk::FSNType_data
|| m_type == etk::FSNType_themeData) {
std::vector<etk::String> listAdded;
etk::Vector<etk::String> listAdded;
etk::String assetsName = baseFolderData;
etk::String FolderName = getNameFolder();
if (s_APKArchive==nullptr) {
@ -1682,14 +1682,14 @@ std::vector<etk::FSNode *> etk::FSNode::folderGetSubList(bool _showHidenFile, bo
}
}
if (findIt == false) {
listAdded.push_back(tmpString);
listAdded.pushBack(tmpString);
tmpEmement = new etk::FSNode(tmpString);
if (nullptr == tmpEmement) {
TK_ERROR("allocation error ... of ewol::FSNode");
continue;
}
TK_VERBOSE("find element : '" << tmpString << "' --> " << *tmpEmement);
tmpp.push_back(tmpEmement);
tmpp.pushBack(tmpEmement);
tmpEmement = nullptr;
}
}
@ -1719,13 +1719,13 @@ std::vector<etk::FSNode *> etk::FSNode::folderGetSubList(bool _showHidenFile, bo
}
if(tmpEmement->getNodeType() == etk::typeNode_file) {
if (true == _getFile) {
tmpp.push_back(tmpEmement);
tmpp.pushBack(tmpEmement);
} else {
delete(tmpEmement);
tmpEmement = nullptr;
}
} else if (_getFolderAndOther) {
tmpp.push_back(tmpEmement);
tmpp.pushBack(tmpEmement);
} else {
delete(tmpEmement);
tmpEmement = nullptr;
@ -1743,7 +1743,7 @@ std::vector<etk::FSNode *> etk::FSNode::folderGetSubList(bool _showHidenFile, bo
return tmpp;
}
std::vector<etk::String> etk::FSNode::folderGetSub(bool _getFolder, bool _getFile, const etk::String& _filter) {
etk::Vector<etk::String> etk::FSNode::folderGetSub(bool _getFolder, bool _getFile, const etk::String& _filter) {
TK_TODO("implement filter ... ");
#ifdef __TARGET_OS__Windows
/*
@ -1752,7 +1752,7 @@ std::vector<etk::String> etk::FSNode::folderGetSub(bool _getFolder, bool _getFil
}
*/
#endif
std::vector<etk::String> out;
etk::Vector<etk::String> out;
// regenerate the next list :
etk::FSNode * tmpEmement = nullptr;
if (m_typeNode != etk::typeNode_folder ) {
@ -1761,7 +1761,7 @@ std::vector<etk::String> etk::FSNode::folderGetSub(bool _getFolder, bool _getFil
#ifdef HAVE_ZIP_DATA
if( m_type == etk::FSNType_data
|| m_type == etk::FSNType_themeData) {
std::vector<etk::String> listAdded;
etk::Vector<etk::String> listAdded;
etk::String assetsName = baseFolderData;
etk::String FolderName = getNameFolder();
if (s_APKArchive == nullptr) {
@ -1788,10 +1788,10 @@ std::vector<etk::String> etk::FSNode::folderGetSub(bool _getFolder, bool _getFil
}
}
if (findIt == false) {
listAdded.push_back(tmpString);
listAdded.pushBack(tmpString);
etk::FSNode tmpEmement(tmpString);
TK_VERBOSE("find element : '" << tmpString << "' --> " << tmpEmement);
out.push_back(tmpEmement.getName());
out.pushBack(tmpEmement.getName());
}
}
}
@ -1815,10 +1815,10 @@ std::vector<etk::String> etk::FSNode::folderGetSub(bool _getFolder, bool _getFil
etk::FSNode tmpEmement(getRelativeFolder()+tmpName);
if(tmpEmement.getNodeType() == etk::typeNode_file) {
if (_getFile == true) {
out.push_back(tmpEmement.getName());
out.pushBack(tmpEmement.getName());
}
} else if (_getFolder) {
out.push_back(tmpEmement.getName());
out.pushBack(tmpEmement.getName());
}
}
closedir(dir);
@ -1826,7 +1826,7 @@ std::vector<etk::String> etk::FSNode::folderGetSub(bool _getFolder, bool _getFil
TK_ERROR("could not open directory : \"" << *this << "\"");
}
// reorder the files
std::sort(out.begin(), out.end());
etk::sort(out);
return out;
}
@ -1835,7 +1835,7 @@ etk::FSNode etk::FSNode::folderGetParent() {
return tmpp;
}
void etk::FSNode::folderGetRecursiveFiles(std::vector<etk::String>& _output, bool _recursiveEnable) {
void etk::FSNode::folderGetRecursiveFiles(etk::Vector<etk::String>& _output, bool _recursiveEnable) {
#ifdef HAVE_ZIP_DATA
if( m_type == etk::FSNType_data
|| m_type == etk::FSNType_themeData) {
@ -1857,7 +1857,7 @@ void etk::FSNode::folderGetRecursiveFiles(std::vector<etk::String>& _output, boo
filename.erase(0,assetsName.size());
}
tmpString += filename;
_output.push_back(tmpString);
_output.pushBack(tmpString);
}
}
return;
@ -1883,7 +1883,7 @@ void etk::FSNode::folderGetRecursiveFiles(std::vector<etk::String>& _output, boo
if (nullptr != tmpEmement) {
if(tmpEmement->getNodeType() == etk::typeNode_file) {
etk::String tmpVal = tmpEmement->getName();
_output.push_back(tmpVal);
_output.pushBack(tmpVal);
}
if(tmpEmement->getNodeType() == etk::typeNode_folder) {
if (true==_recursiveEnable) {
@ -1904,12 +1904,12 @@ void etk::FSNode::folderGetRecursiveFiles(std::vector<etk::String>& _output, boo
return;
}
#if __CPP_VERSION__ >= 2011
void etk::FSNode::folderGetRecursiveFiles(std::vector<std::u32string>& _output, bool _recursiveEnable) {
void etk::FSNode::folderGetRecursiveFiles(etk::Vector<etk::UString>& _output, bool _recursiveEnable) {
_output.clear();
std::vector<etk::String> tmpVal;
etk::Vector<etk::String> tmpVal;
folderGetRecursiveFiles(tmpVal, _recursiveEnable);
for (size_t iii=0; iii<tmpVal.size(); ++iii) {
_output.push_back(to_u32string(tmpVal[iii]));
_output.pushBack(toUString(tmpVal[iii]));
}
}
#endif
@ -1937,8 +1937,8 @@ etk::String etk::FSNode::fileGetExtention() {
return "";
}
#if __CPP_VERSION__ >= 2011
std::u32string etk::FSNode::fileUGetExtention() {
return etk::to_u32string(fileGetExtention());
etk::UString etk::FSNode::fileUGetExtention() {
return etk::toUString(fileGetExtention());
}
#endif
@ -2336,8 +2336,8 @@ void etk::theme::setName(const etk::String& _refName, const etk::String& _folder
g_listTheme.insert(std::pair<etk::String,etk::String>(_refName, _folderName));
}
#if __CPP_VERSION__ >= 2011
void etk::theme::setName(const std::u32string& _refName, const std::u32string& _folderName) {
setName(etk::to_string(_refName), etk::to_string(_folderName));
void etk::theme::setName(const etk::UString& _refName, const etk::UString& _folderName) {
setName(etk::toString(_refName), etk::toString(_folderName));
}
#endif
@ -2353,30 +2353,30 @@ etk::String etk::theme::getName(const etk::String& _refName) {
return _refName;
}
#if __CPP_VERSION__ >= 2011
std::u32string etk::theme::getName(const std::u32string& _refName) {
return etk::to_u32string(getName(etk::to_string(_refName)));
etk::UString etk::theme::getName(const etk::UString& _refName) {
return etk::toUString(getName(etk::toString(_refName)));
}
#endif
// get the list of all the theme folder availlable in the user Home/appl
std::vector<etk::String> etk::theme::list() {
std::vector<etk::String> keys;
etk::Vector<etk::String> etk::theme::list() {
etk::Vector<etk::String> keys;
#if __CPP_VERSION__ >= 2011
for (auto &it : g_listTheme) {
keys.push_back(it.first);
keys.pushBack(it.first);
}
#else
for (std::map<etk::String, etk::String>::iterator it(g_listTheme.begin()); it != g_listTheme.end(); ++it) {
keys.push_back(it->first);
keys.pushBack(it->first);
}
#endif
return keys;
}
#if __CPP_VERSION__ >= 2011
std::vector<std::u32string> etk::theme::listU() {
std::vector<std::u32string> keys;
etk::Vector<etk::UString> etk::theme::listU() {
etk::Vector<etk::UString> keys;
for (auto &it : g_listTheme) {
keys.push_back(etk::to_u32string(it.first));
keys.pushBack(etk::toUString(it.first));
}
return keys;
}
@ -2396,8 +2396,8 @@ void etk::theme::setNameDefault(const etk::String& _refName, const etk::String&
g_listThemeDefault.insert(std::pair<etk::String,etk::String>(_refName, _folderName));
}
#if __CPP_VERSION__ >= 2011
void etk::theme::setNameDefault(const std::u32string& _refName, const std::u32string& _folderName) {
setNameDefault(etk::to_string(_refName), etk::to_string(_folderName));
void etk::theme::setNameDefault(const etk::UString& _refName, const etk::UString& _folderName) {
setNameDefault(etk::toString(_refName), etk::toString(_folderName));
}
#endif
@ -2413,8 +2413,8 @@ etk::String etk::theme::getNameDefault(const etk::String& _refName) {
return "default";
}
#if __CPP_VERSION__ >= 2011
std::u32string etk::theme::getNameDefault(const std::u32string& _refName) {
return etk::to_u32string(getNameDefault(etk::to_string(_refName)));
etk::UString etk::theme::getNameDefault(const etk::UString& _refName) {
return etk::toUString(getNameDefault(etk::toString(_refName)));
}
#endif
@ -2433,8 +2433,8 @@ uint64_t etk::FSNodeGetSize(const etk::String& _path) {
return tmpNode.fileSize();
}
#if __CPP_VERSION__ >= 2011
uint64_t etk::FSNodeGetSize(const std::u32string& _path) {
return FSNodeGetSize(etk::to_string(_path));
uint64_t etk::FSNodeGetSize(const etk::UString& _path) {
return FSNodeGetSize(etk::toString(_path));
}
#endif
@ -2446,8 +2446,8 @@ bool etk::FSNodeRemove(const etk::String& _path) {
return tmpNode.remove();
}
#if __CPP_VERSION__ >= 2011
bool etk::FSNodeRemove(const std::u32string& _path) {
return FSNodeRemove(etk::to_string(_path));
bool etk::FSNodeRemove(const etk::UString& _path) {
return FSNodeRemove(etk::toString(_path));
}
#endif
@ -2459,8 +2459,8 @@ int64_t etk::FSNodeGetCount(const etk::String& _path) {
return tmpNode.folderCount();
}
#if __CPP_VERSION__ >= 2011
int64_t etk::FSNodeGetCount(const std::u32string& _path) {
return FSNodeGetCount(etk::to_string(_path));
int64_t etk::FSNodeGetCount(const etk::UString& _path) {
return FSNodeGetCount(etk::toString(_path));
}
#endif
@ -2469,8 +2469,8 @@ bool etk::FSNodeCreate(const etk::String& _path, etk::FSNodeRight _right, enum e
return false;
}
#if __CPP_VERSION__ >= 2011
bool etk::FSNodeCreate(const std::u32string& _path, etk::FSNodeRight _right, enum etk::typeNode _type) {
return FSNodeCreate(etk::to_string(_path), _right, _type);
bool etk::FSNodeCreate(const etk::UString& _path, etk::FSNodeRight _right, enum etk::typeNode _type) {
return FSNodeCreate(etk::toString(_path), _right, _type);
}
#endif
@ -2479,8 +2479,8 @@ bool etk::FSNodeExist(const etk::String& _path) {
return tmpNode.exist();
}
#if __CPP_VERSION__ >= 2011
bool etk::FSNodeExist(const std::u32string& _path) {
return FSNodeExist(etk::to_string(_path));
bool etk::FSNodeExist(const etk::UString& _path) {
return FSNodeExist(etk::toString(_path));
}
#endif
@ -2496,8 +2496,8 @@ bool etk::FSNodeMove(const etk::String& _path1, const etk::String& _path2) {
return tmpNode.move(_path2);
}
#if __CPP_VERSION__ >= 2011
bool etk::FSNodeMove(const std::u32string& _path1, const std::u32string& _path2) {
return FSNodeMove(etk::to_string(_path1), etk::to_string(_path2));
bool etk::FSNodeMove(const etk::UString& _path1, const etk::UString& _path2) {
return FSNodeMove(etk::toString(_path1), etk::toString(_path2));
}
#endif
@ -2506,8 +2506,8 @@ etk::FSNodeRight etk::FSNodeGetRight(const etk::String& _path) {
return tmpNode.getRight();
}
#if __CPP_VERSION__ >= 2011
etk::FSNodeRight etk::FSNodeGetRight(const std::u32string& _path) {
return FSNodeGetRight(etk::to_string(_path));
etk::FSNodeRight etk::FSNodeGetRight(const etk::UString& _path) {
return FSNodeGetRight(etk::toString(_path));
}
#endif
@ -2516,8 +2516,8 @@ enum etk::typeNode etk::FSNodeGetType(const etk::String& _path) {
return tmpNode.getNodeType();
}
#if __CPP_VERSION__ >= 2011
enum etk::typeNode etk::FSNodeGetType(const std::u32string& _path) {
return FSNodeGetType(etk::to_string(_path));
enum etk::typeNode etk::FSNodeGetType(const etk::UString& _path) {
return FSNodeGetType(etk::toString(_path));
}
#endif
@ -2526,8 +2526,8 @@ uint64_t etk::FSNodeGetTimeCreated(const etk::String& _path) {
return tmpNode.timeCreated();
}
#if __CPP_VERSION__ >= 2011
uint64_t etk::FSNodeGetTimeCreated(const std::u32string& _path) {
return FSNodeGetTimeCreated(etk::to_string(_path));
uint64_t etk::FSNodeGetTimeCreated(const etk::UString& _path) {
return FSNodeGetTimeCreated(etk::toString(_path));
}
#endif
@ -2536,8 +2536,8 @@ uint64_t etk::FSNodeGetTimeModified(const etk::String& _path) {
return tmpNode.timeModified();
}
#if __CPP_VERSION__ >= 2011
uint64_t etk::FSNodeGetTimeModified(const std::u32string& _path) {
return FSNodeGetTimeModified(etk::to_string(_path));
uint64_t etk::FSNodeGetTimeModified(const etk::UString& _path) {
return FSNodeGetTimeModified(etk::toString(_path));
}
#endif
@ -2546,8 +2546,8 @@ uint64_t etk::FSNodeGetTimeAccessed(const etk::String& _path) {
return tmpNode.timeAccessed();
}
#if __CPP_VERSION__ >= 2011
uint64_t etk::FSNodeGetTimeAccessed(const std::u32string& _path) {
return FSNodeGetTimeAccessed(etk::to_string(_path));
uint64_t etk::FSNodeGetTimeAccessed(const etk::UString& _path) {
return FSNodeGetTimeAccessed(etk::toString(_path));
}
#endif
@ -2556,8 +2556,8 @@ bool etk::FSNodeTouch(const etk::String& _path) {
return tmpNode.touch();
}
#if __CPP_VERSION__ >= 2011
bool etk::FSNodeTouch(const std::u32string& _path) {
return FSNodeTouch(etk::to_string(_path));
bool etk::FSNodeTouch(const etk::UString& _path) {
return FSNodeTouch(etk::toString(_path));
}
#endif
@ -2580,8 +2580,8 @@ bool etk::FSNodeEcho(const etk::String& _path, const etk::String& _dataTowrite)
return tmpNode.fileClose();
}
#if __CPP_VERSION__ >= 2011
bool etk::FSNodeEcho(const std::u32string& _path, const std::u32string& _dataTowrite) {
return FSNodeEcho(etk::to_string(_path), etk::to_string(_dataTowrite));
bool etk::FSNodeEcho(const etk::UString& _path, const etk::UString& _dataTowrite) {
return FSNodeEcho(etk::toString(_path), etk::toString(_dataTowrite));
}
#endif
@ -2604,8 +2604,8 @@ bool etk::FSNodeEchoAdd(const etk::String& _path, const etk::String& _dataTowrit
return tmpNode.fileClose();
}
#if __CPP_VERSION__ >= 2011
bool etk::FSNodeEchoAdd(const std::u32string& _path, const std::u32string& _dataTowrite) {
return FSNodeEchoAdd(etk::to_string(_path), etk::to_string(_dataTowrite));
bool etk::FSNodeEchoAdd(const etk::UString& _path, const etk::UString& _dataTowrite) {
return FSNodeEchoAdd(etk::toString(_path), etk::toString(_dataTowrite));
}
#endif
@ -2613,8 +2613,8 @@ void etk::FSNodeHistory(const etk::String& _path, int32_t _historyCount) {
// step 1 : Move the file to prevent writing error
//Get the first oldest save :
for (int32_t iii=_historyCount-1; iii>0 ; iii--) {
if (etk::FSNodeExist(_path + "-" + etk::to_string(iii)) == true) {
etk::FSNodeMove(_path + "-" + etk::to_string(iii), _path + "-" + etk::to_string(iii+1));
if (etk::FSNodeExist(_path + "-" + etk::toString(iii)) == true) {
etk::FSNodeMove(_path + "-" + etk::toString(iii), _path + "-" + etk::toString(iii+1));
}
}
if (etk::FSNodeExist(_path) == true) {
@ -2622,8 +2622,8 @@ void etk::FSNodeHistory(const etk::String& _path, int32_t _historyCount) {
}
}
#if __CPP_VERSION__ >= 2011
void etk::FSNodeHistory(const std::u32string& _path, int32_t _historyCount) {
return FSNodeHistory(etk::to_string(_path), _historyCount);
void etk::FSNodeHistory(const etk::UString& _path, int32_t _historyCount) {
return FSNodeHistory(etk::toString(_path), _historyCount);
}
#endif
@ -2659,8 +2659,8 @@ etk::String etk::FSNodeGetRealName(const etk::String& _path) {
return node.getFileSystemName();
}
std::vector<etk::String> etk::FSNodeExplodeMultiplePath(const etk::String& _path) {
std::vector<etk::String> out;
etk::Vector<etk::String> etk::FSNodeExplodeMultiplePath(const etk::String& _path) {
etk::Vector<etk::String> out;
etk::String libSearch = "";
etk::String newName = _path;
@ -2680,14 +2680,14 @@ std::vector<etk::String> etk::FSNodeExplodeMultiplePath(const etk::String& _path
}
if (libSearch.size() != 0) {
if (libSearch[0] != '@') {
out.push_back(newName);
out.push_back(etk::String("{@") + libSearch + "}" + newName);
out.pushBack(newName);
out.pushBack(etk::String("{@") + libSearch + "}" + newName);
return out;
}
out.push_back(etk::String("{") + libSearch + "}" + newName);
out.pushBack(etk::String("{") + libSearch + "}" + newName);
return out;
}
out.push_back(newName);
out.pushBack(newName);
return out;
}

102
etk/os/FSNode.hpp
View File

@ -197,7 +197,7 @@ namespace etk {
*/
FSNode(const etk::String& _path = "~");
#if __CPP_VERSION__ >= 2011
FSNode(const std::u32string& _path);
FSNode(const etk::UString& _path);
#endif
/**
* @brief Destructor
@ -219,7 +219,7 @@ namespace etk {
*/
void privateSetName(etk::String _newName);
#if __CPP_VERSION__ >= 2011
void privateSetName(const std::u32string& _newName);
void privateSetName(const etk::UString& _newName);
#endif
private:
#ifdef HAVE_ZIP_DATA
@ -270,7 +270,7 @@ namespace etk {
*/
void setName(const etk::String& _newName);
#if __CPP_VERSION__ >= 2011
void setName(const std::u32string& _newName);
void setName(const etk::UString& _newName);
#endif
/**
* @brief Get the Generate FileSystem name
@ -278,7 +278,7 @@ namespace etk {
*/
etk::String getFileSystemName() const;
#if __CPP_VERSION__ >= 2011
std::u32string getUFileSystemName() const;
etk::UString getUFileSystemName() const;
#endif
/**
* @brief Get the current folder of the Node. (file system name)
@ -287,7 +287,7 @@ namespace etk {
*/
etk::String getNameFolder() const;
#if __CPP_VERSION__ >= 2011
std::u32string getUNameFolder() const;
etk::UString getUNameFolder() const;
#endif
/**
* @brief Get the current compleate node name (file system name)
@ -296,7 +296,7 @@ namespace etk {
*/
etk::String getName() const;
#if __CPP_VERSION__ >= 2011
std::u32string getUName() const;
etk::UString getUName() const;
#endif
/**
* @brief Get the file or current file name (if it was a file)
@ -304,7 +304,7 @@ namespace etk {
*/
etk::String getNameFile() const;
#if __CPP_VERSION__ >= 2011
std::u32string getUNameFile() const;
etk::UString getUNameFile() const;
#endif
/**
* @brief Get the current folder of the Node.
@ -313,7 +313,7 @@ namespace etk {
*/
etk::String getRelativeFolder() const;
#if __CPP_VERSION__ >= 2011
std::u32string getURelativeFolder() const;
etk::UString getURelativeFolder() const;
#endif
/**
* @brief update the Time of the file with the current time
@ -329,7 +329,7 @@ namespace etk {
*/
bool move(const etk::String& _path);
#if __CPP_VERSION__ >= 2011
bool move(const std::u32string& _path);
bool move(const etk::UString& _path);
#endif
/**
* @brief Get the node type (DATA/DIRECT...)
@ -355,7 +355,7 @@ namespace etk {
*/
etk::String timeCreatedString() const;
#if __CPP_VERSION__ >= 2011
std::u32string timeUCreatedString() const;
etk::UString timeUCreatedString() const;
#endif
/**
* @brief Get the modifying time of the File
@ -368,7 +368,7 @@ namespace etk {
*/
etk::String timeModifiedString() const;
#if __CPP_VERSION__ >= 2011
std::u32string timeUModifiedString() const;
etk::UString timeUModifiedString() const;
#endif
/**
* @brief Get the Accessed time of the File
@ -381,7 +381,7 @@ namespace etk {
*/
etk::String timeAccessedString() const;
#if __CPP_VERSION__ >= 2011
std::u32string timeUAccessedString() const;
etk::UString timeUAccessedString() const;
#endif
/**
* @brief copy the other FSnode ==> for vector
@ -423,7 +423,7 @@ namespace etk {
* @param[in] _temporaryFile add Tmp file like .bck or ~
* @return The requested list
*/
std::vector<etk::FSNode*> folderGetSubList(bool _showHidenFile = true,
etk::Vector<etk::FSNode*> folderGetSubList(bool _showHidenFile = true,
bool _getFolderAndOther = true,
bool _getFile = true,
bool _temporaryFile = true);
@ -435,7 +435,7 @@ namespace etk {
* @param[in] _filter Generic regex string to filter file names
* @return The requested list
*/
std::vector<etk::FSNode*> folderGetSubList(bool _showHidenFile = true,
etk::Vector<etk::FSNode*> folderGetSubList(bool _showHidenFile = true,
bool _getFolderAndOther = true,
bool _getFile = true,
const etk::String& _filter = ".*");
@ -446,7 +446,7 @@ namespace etk {
* @param[in] _filter Generic regex string to filter file names
* @return The requested list
*/
std::vector<etk::String> folderGetSub(bool _getFolder, bool _getFile, const etk::String& _filter);
etk::Vector<etk::String> folderGetSub(bool _getFolder, bool _getFile, const etk::String& _filter);
/**
* @brief Get the father node of this node
* @return The requested node
@ -457,9 +457,9 @@ namespace etk {
* @param[out] _output List of all the File names (You must clear it before set it in)
* @param[in] _recursiveEnable Activate the recursive mode (enable by default)
*/
void folderGetRecursiveFiles(std::vector<etk::String>& _output, bool _recursiveEnable=true);
void folderGetRecursiveFiles(etk::Vector<etk::String>& _output, bool _recursiveEnable=true);
#if __CPP_VERSION__ >= 2011
void folderGetRecursiveFiles(std::vector<std::u32string>& _output, bool _recursiveEnable=true);
void folderGetRecursiveFiles(etk::Vector<etk::UString>& _output, bool _recursiveEnable=true);
#endif
/**
* @brief Check if the file have an extention ( ***.ccc)
@ -473,7 +473,7 @@ namespace etk {
*/
etk::String fileGetExtention();
#if __CPP_VERSION__ >= 2011
std::u32string fileUGetExtention();
etk::UString fileUGetExtention();
#endif
/**
* @brief Get the File size
@ -600,8 +600,8 @@ namespace etk {
* @brief Read all element in a file and set it in a generic vector
* @return the read vector
*/
template<typename T> std::vector<T> fileReadAll() {
std::vector<T> value;
template<typename T> etk::Vector<T> fileReadAll() {
etk::Vector<T> value;
value.resize(fileSize());
fileRead(&value[0], sizeof(T), fileSize()/sizeof(T));
return value;
@ -617,7 +617,7 @@ namespace etk {
return value;
}
#if __CPP_VERSION__ >= 2011
std::u32string fileReadAllU32String() {
etk::UString fileReadAllU32String() {
return utf8::convertUnicode(fileReadAllString());
}
#endif
@ -626,7 +626,7 @@ namespace etk {
* @param[in] _value Data to write in the File
*/
template<typename T>
void fileWriteAll(const std::vector<T>& _value) {
void fileWriteAll(const etk::Vector<T>& _value) {
fileWrite(static_cast<const void*>(&(_value[0])), sizeof(T), _value.size()/sizeof(T));
}
/**
@ -637,7 +637,7 @@ namespace etk {
fileWrite(static_cast<const void*>(&(_value[0])), sizeof(char), _value.size()/sizeof(char));
}
#if __CPP_VERSION__ >= 2011
void fileWriteAll(const std::u32string& _value) {
void fileWriteAll(const etk::UString& _value) {
fileWriteAll(u32char::convertToUtf8(_value));
}
#endif
@ -646,7 +646,7 @@ namespace etk {
* @brief Order the list of subnode the folder first and the alphabetical order
* @param[in,out] _list The list to order
*/
void sortElementList(std::vector<etk::FSNode *>& _list);
void sortElementList(etk::Vector<etk::FSNode *>& _list);
};
//! @not_in_doc
std::ostream& operator <<(std::ostream &_os, const etk::FSNode &_obj);
@ -678,7 +678,7 @@ namespace etk {
*/
etk::String getUserHomeFolder();
#if __CPP_VERSION__ >= 2011
std::u32string getUUserHomeFolder();
etk::UString getUUserHomeFolder();
#endif
/**
* @brief Get the folder of the Program is running
@ -686,7 +686,7 @@ namespace etk {
*/
etk::String getUserRunFolder();
#if __CPP_VERSION__ >= 2011
std::u32string getUUserRunFolder();
etk::UString getUUserRunFolder();
#endif
namespace theme {
@ -699,7 +699,7 @@ namespace etk {
void setName(const etk::String& _refName, const etk::String& _folderName);
#if __CPP_VERSION__ >= 2011
//! @previous
void setName(const std::u32string& _refName, const std::u32string& _folderName);
void setName(const etk::UString& _refName, const etk::UString& _folderName);
#endif
/**
* @brief get the folder from a Reference theme
@ -709,7 +709,7 @@ namespace etk {
etk::String getName(const etk::String& _refName);
#if __CPP_VERSION__ >= 2011
//! @previous
std::u32string getName(const std::u32string& _refName);
etk::UString getName(const etk::UString& _refName);
#endif
/**
* @brief Set the default folder of a subset of a theme ...
@ -719,7 +719,7 @@ namespace etk {
void setNameDefault(const etk::String& _refName, const etk::String& _folderName);
#if __CPP_VERSION__ >= 2011
//! @previous
void setNameDefault(const std::u32string& _refName, const std::u32string& _folderName);
void setNameDefault(const etk::UString& _refName, const etk::UString& _folderName);
#endif
/**
* @brief get the default folder from a Reference theme
@ -729,16 +729,16 @@ namespace etk {
etk::String getNameDefault(const etk::String& _refName);
#if __CPP_VERSION__ >= 2011
//! @previous
std::u32string getNameDefault(const std::u32string& _refName);
etk::UString getNameDefault(const etk::UString& _refName);
#endif
/**
* @brief Get the list of all the theme folder availlable in the user Home/appl
* @return The list of elements
*/
std::vector<etk::String> list();
etk::Vector<etk::String> list();
#if __CPP_VERSION__ >= 2011
//! @previous
std::vector<std::u32string> listU();
etk::Vector<etk::UString> listU();
#endif
};
/**
@ -748,7 +748,7 @@ namespace etk {
*/
uint64_t FSNodeGetSize(const etk::String& _path);
#if __CPP_VERSION__ >= 2011
uint64_t FSNodeGetSize(const std::u32string& _path);
uint64_t FSNodeGetSize(const etk::UString& _path);
#endif
/**
@ -759,7 +759,7 @@ namespace etk {
*/
bool FSNodeRemove(const etk::String& _path);
#if __CPP_VERSION__ >= 2011
bool FSNodeRemove(const std::u32string& _path);
bool FSNodeRemove(const etk::UString& _path);
#endif
/**
* @brief Simple access for : count the number of element in a path (if it is not a path ==> return -1)
@ -769,7 +769,7 @@ namespace etk {
*/
int64_t FSNodeGetCount(const etk::String& _path);
#if __CPP_VERSION__ >= 2011
int64_t FSNodeGetCount(const std::u32string& _path);
int64_t FSNodeGetCount(const etk::UString& _path);
#endif
/**
* @brief Simple access for : Create a file or a folder depending of the request
@ -781,7 +781,7 @@ namespace etk {
*/
bool FSNodeCreate(const etk::String& _path, etk::FSNodeRight _right, enum etk::typeNode _type=etk::typeNode_folder);
#if __CPP_VERSION__ >= 2011
bool FSNodeCreate(const std::u32string& _path, etk::FSNodeRight _right, enum etk::typeNode _type=etk::typeNode_folder);
bool FSNodeCreate(const etk::UString& _path, etk::FSNodeRight _right, enum etk::typeNode _type=etk::typeNode_folder);
#endif
/**
* @brief Simple access for : chexk the exestance of an element
@ -791,7 +791,7 @@ namespace etk {
*/
bool FSNodeExist(const etk::String& _path);
#if __CPP_VERSION__ >= 2011
bool FSNodeExist(const std::u32string& _path);
bool FSNodeExist(const etk::UString& _path);
#endif
/**
* @brief Simple access for : chexk the exestance of an element
@ -802,7 +802,7 @@ namespace etk {
*/
bool FSNodeMove(const etk::String& _path1, const etk::String& _path2);
#if __CPP_VERSION__ >= 2011
bool FSNodeMove(const std::u32string& _path1, const std::u32string& _path2);
bool FSNodeMove(const etk::UString& _path1, const etk::UString& _path2);
#endif
/**
* @brief Simple access for : Get right of the current Node
@ -812,7 +812,7 @@ namespace etk {
*/
etk::FSNodeRight FSNodeGetRight(const etk::String& _path);
#if __CPP_VERSION__ >= 2011
etk::FSNodeRight FSNodeGetRight(const std::u32string& _path);
etk::FSNodeRight FSNodeGetRight(const etk::UString& _path);
#endif
/**
* @brief Simple access for : Get type of the current node
@ -822,7 +822,7 @@ namespace etk {
*/
enum etk::typeNode FSNodeGetType(const etk::String& _path);
#if __CPP_VERSION__ >= 2011
enum etk::typeNode FSNodeGetType(const std::u32string& _path);
enum etk::typeNode FSNodeGetType(const etk::UString& _path);
#endif
/**
* @brief Simple access for : Getting creation time of the current node
@ -832,7 +832,7 @@ namespace etk {
*/
uint64_t FSNodeGetTimeCreated(const etk::String& _path);
#if __CPP_VERSION__ >= 2011
uint64_t FSNodeGetTimeCreated(const std::u32string& _path);
uint64_t FSNodeGetTimeCreated(const etk::UString& _path);
#endif
/**
* @brief Simple access for : Getting Modification time of the current node
@ -842,7 +842,7 @@ namespace etk {
*/
uint64_t FSNodeGetTimeModified(const etk::String& _path);
#if __CPP_VERSION__ >= 2011
uint64_t FSNodeGetTimeModified(const std::u32string& _path);
uint64_t FSNodeGetTimeModified(const etk::UString& _path);
#endif
/**
* @brief Simple access for : Getting Accessing time of the current node
@ -852,7 +852,7 @@ namespace etk {
*/
uint64_t FSNodeGetTimeAccessed(const etk::String& _path);
#if __CPP_VERSION__ >= 2011
uint64_t FSNodeGetTimeAccessed(const std::u32string& _path);
uint64_t FSNodeGetTimeAccessed(const etk::UString& _path);
#endif
/**
* @brief Simple access for : Update Modification time with the current time of the node (>)
@ -862,7 +862,7 @@ namespace etk {
*/
bool FSNodeTouch(const etk::String& _path);
#if __CPP_VERSION__ >= 2011
bool FSNodeTouch(const std::u32string& _path);
bool FSNodeTouch(const etk::UString& _path);
#endif
/**
* @brief Simple access for : Basic write on the node (like console echo)
@ -873,7 +873,7 @@ namespace etk {
*/
bool FSNodeEcho(const etk::String& _path, const etk::String& _dataTowrite);
#if __CPP_VERSION__ >= 2011
bool FSNodeEcho(const std::u32string& _path, const std::u32string& _dataTowrite);
bool FSNodeEcho(const etk::UString& _path, const etk::UString& _dataTowrite);
#endif
/**
* @brief Simple access for : Basic write on the node (like console echo) in adding mode (>>)
@ -884,7 +884,7 @@ namespace etk {
*/
bool FSNodeEchoAdd(const etk::String& _path, const etk::String& _dataTowrite);
#if __CPP_VERSION__ >= 2011
bool FSNodeEchoAdd(const std::u32string& _path, const std::u32string& _dataTowrite);
bool FSNodeEchoAdd(const etk::UString& _path, const etk::UString& _dataTowrite);
#endif
/**
* @brief move file to generate an history of the current file
@ -893,7 +893,7 @@ namespace etk {
*/
void FSNodeHistory(const etk::String& _path, int32_t _historyCount);
#if __CPP_VERSION__ >= 2011
void FSNodeHistory(const std::u32string& _path, int32_t _historyCount);
void FSNodeHistory(const etk::UString& _path, int32_t _historyCount);
#endif
/**
* @brief Read all the data from a file
@ -912,8 +912,8 @@ namespace etk {
* @param[in] _path Folder/File/Pipe path of the node
* @return all the data of the file in a typed vector
*/
template<typename TTT> std::vector<TTT> FSNodeReadAllDataType(const etk::String& _path) {
std::vector<TTT> out;
template<typename TTT> etk::Vector<TTT> FSNodeReadAllDataType(const etk::String& _path) {
etk::Vector<TTT> out;
etk::FSNode node(_path);
if (node.fileOpenRead() == false) {
//TK_ERROR("can not open file : '" << node << "'");
@ -933,7 +933,7 @@ namespace etk {
* @param[in] _path Folder/File/Pipe path of the node
* @param[in] _data All the data of the file in a vector Typed bits ...
*/
template<typename TTT> void FSNodeWriteAllDataType(const etk::String& _path, const std::vector<TTT>& _data) {
template<typename TTT> void FSNodeWriteAllDataType(const etk::String& _path, const etk::Vector<TTT>& _data) {
etk::FSNode node(_path);
if (node.fileOpenWrite() == false) {
//TK_ERROR("can not open file : '" << node << "'");
@ -962,7 +962,7 @@ namespace etk {
* // out contain: {"{@ewol}DATA:font"}
* @endcode
*/
std::vector<etk::String> FSNodeExplodeMultiplePath(const etk::String& _path);
etk::Vector<etk::String> FSNodeExplodeMultiplePath(const etk::String& _path);
};

5
etk/os/FSNodeRight.cpp
View File

@ -6,6 +6,7 @@
#include <etk/os/FSNodeRight.hpp>
#include <etk/stdTools.hpp>
// Right Flags :
enum {
@ -147,8 +148,8 @@ void etk::FSNodeRight::setOtherRunable(bool _newStatus) {
}
}
#if __CPP_VERSION__ >= 2011
std::u32string etk::FSNodeRight::getURight() const {
return etk::to_u32string(getRight());
etk::UString etk::FSNodeRight::getURight() const {
return etk::toUString(getRight());
}
#endif

4
etk/os/FSNodeRight.hpp
View File

@ -8,6 +8,8 @@
#pragma once
#include <etk/String.hpp>
namespace etk {
/**
* @brief File System Right management
@ -141,7 +143,7 @@ namespace etk {
* @brief Get the write written in a string mode (like in linux rw-r-----)
* @return String with the right in string
*/
std::u32string getURight() const;
etk::UString getURight() const;
#endif
/**
* @brief Get the write written in a string mode (like in linux rw-r-----)

635
etk/stdTools.cpp
View File

@ -1,240 +1,9 @@
/** @file
* @author Edouard DUPIN
* @copyright 2011, Edouard DUPIN, all right reserved
* @license MPL v2.0 (see license file)
*/
#include <etk/stdTools.hpp>
#include <etk/debug.hpp>
const char32_t u32char::Null('\0');
const char32_t u32char::Return('\n');
const char32_t u32char::CarrierReturn('\r');
const char32_t u32char::Tabulation('\t');
const char32_t u32char::Suppress((const char)127);
const char32_t u32char::Delete((const char)8);
const char32_t u32char::Space(' ');
const char32_t u32char::Escape((const char)27);
bool u32char::isWhiteChar(char32_t _val) {
if( _val == ' '
|| _val == '\t'
|| _val == '\n'
|| _val == '\r') {
return true;
}
return false;
}
bool u32char::isSpecialChar(char32_t _val) {
if( _val < '0'
|| (_val > '9' && _val < 'A')
|| (_val > 'Z' && _val < 'a')
|| (_val > 'z' && _val < 0xFF) ) {
return true;
}
return false;
}
bool u32char::isInteger(char32_t _val) {
if( _val >= (uint32_t)'0'
&& _val <= (uint32_t)'9') {
return true;
}
return false;
}
int32_t u32char::toInt(char32_t _val) {
return _val - (uint32_t)'0';
}
char32_t u32char::changeOrder(char32_t _val) {
if (_val >= 'A' && _val <= 'Z') {
return (_val - (uint32_t)'A')*2 + 'A';
}
if (_val >= 'a' && _val <= 'z') {
return (_val - (uint32_t)'a')*2 + 'A' + 1;
}
if (_val >= ':' && _val <= '@') {
return _val + 52;
}
if (_val >= '[' && _val <= '`') {
return _val +26;
}
return _val;
}
static uint32_t getUtf8Val(char32_t _val) {
uint32_t output = 0;
if (_val <= 127) {
output = _val;
} else if (_val <= 2047) {
// output ==> 00000000 00000000 110xxxxx 10xxxxxx
// input ==> -------- -------- -----222 22111111
output = 0x0000C080;
output+= (_val & 0x000007C0)<<2;
output+= _val & 0x0000003F;
} else if (_val <= 65535) {
// output ==> 00000000 1110xxxx 10xxxxxx 10xxxxxx
// input ==> -------- -------- 33332222 22111111
output = 0x00E08080;
output+= (_val & 0x0000F000)<<4;
output+= (_val & 0x00000FC0)<<2;
output+= _val & 0x0000003F;
} else if (_val <= 1114111) {
// output ==> 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
// input ==> -------- ---44433 33332222 22111111
output = 0xF0808080;
output+= (_val & 0x001C0000)<<6;
output+= (_val & 0x0003F000)<<4;
output+= (_val & 0x00000FC0)<<2;
output+= _val & 0x0000003F;
} else {
//TK_ERROR("NOT UTF8 character input...");
printf("not an utf8 char : %#08x\n", _val);
return 0;
}
//printf("utf-8 conversion : %d=%08x ==> %08x\n",value, value, output);
return output;
}
int8_t u32char::convertUtf8(char32_t _val, char _output[5]) {
uint32_t value = getUtf8Val(_val);
if (0xFF >= value) {
_output[0] = (char)value;
_output[1] = '\0';
return 1;
} else if (0xFFFF >= value) {
_output[0] = (char)((value>>8) & 0x000000FF);
_output[1] = (char)value;
_output[2] = '\0';
return 2;
} else if (0xFFFFFF >= value) {
_output[0] = (char)((value>>16) & 0x000000FF);
_output[1] = (char)((value>>8) & 0x000000FF);
_output[2] = (char)value;
_output[3] = '\0';
return 3;
} else {
_output[0] = (char)((value>>24) & 0x000000FF);
_output[1] = (char)((value>>16) & 0x000000FF);
_output[2] = (char)((value>>8) & 0x000000FF);
_output[3] = (char)value;
_output[4] = '\0';
return 4;
}
}
#if __CPP_VERSION__ >= 2011
std::string u32char::convertToUtf8(const std::u32string& _input) {
TK_TODO("implement this function ...");
return "TODO ... std::string u32char::convertToUtf8(const std::u32string& _input)";
}
#endif
static uint8_t sizeElement(const char* _data, int32_t _lenMax) {
uint8_t size = 0;
TK_ASSERT(0 <= _lenMax, "size can not be < 0 ...");
if (0 > _lenMax) {
return 0;
}
//4 case
if( _lenMax >= 1
&& (_data[0] & 0x80) == 0x00 ) {
// One Char Element
size = 1;
} else if( _lenMax >= 2
&& (_data[0] & 0xE0) == 0xC0
&& (_data[1] & 0xC0) == 0x80) {
size = 2;
} else if( _lenMax >= 3
&& (_data[0] & 0xF0) == 0xE0
&& (_data[1] & 0xC0) == 0x80
&& (_data[2] & 0xC0) == 0x80) {
size = 3;
} else if( _lenMax >= 4
&& (_data[0] & 0xF8) == 0xF0
&& (_data[1] & 0xC0) == 0x80
&& (_data[2] & 0xC0) == 0x80
&& (_data[3] & 0xC0) == 0x80) {
size = 4;
}
return size;
}
char32_t utf8::convertChar32(const char* _input) {
char32_t value = 0;
if (nullptr == _input) {
return value;
}
int32_t len = strlen(_input);
len = sizeElement(_input, len);
switch (len) {
default:
// case 0 : An error occurred...
value = _input[0];
return value;
case 1:
value = (uint8_t)(_input[0]) & 0x7F;
return value;
case 2:
value = (((uint8_t)_input[0]) & 0x1F)<< 6;
value += ((uint8_t)_input[1]) & 0x3F;
return value;
case 3:
value = (((uint8_t)_input[0]) & 0x0F)<< 12;
value += (((uint8_t)_input[1]) & 0x3F)<< 6;
value += ((uint8_t)_input[2]) & 0x3F;
return value;
case 4:
value = (((uint8_t)_input[0]) & 0x07)<< 18;
value += (((uint8_t)_input[1]) & 0x3F)<< 12;
value += (((uint8_t)_input[2]) & 0x3F)<< 6;
value += ((uint8_t)_input[3]) & 0x3F;
return value;
}
}
int8_t utf8::length(const char _input) {
if((_input&0x80) == 0x00 ) {
return 1;
}
if((_input&0xE0) == 0xC0) {
return 2;
}
if((_input&0xF0) == 0xE0) {
return 3;
}
if((_input&0xF8) == 0xF0) {
return 4;
}
return 1;
}
bool utf8::first(const char _input) {
// When started with the bit 0 then the size is single element.
if((_input&0x80) == 0x00 ) {
return true;
}
// for multiple element size, we just need to check the second element (might be != 1)
if((_input&0x40) == 0x40 ) {
return true;
}
return false;
}
#if __CPP_VERSION__ >= 2011
std::u32string utf8::convertUnicode(const etk::String& _input) {
TK_TODO("implement this function ...");
return U"TODO ... std::u32string utf8::convertUnicode(const etk::String& _input)";
}
#endif
namespace etk {
#if __CPP_VERSION__ >= 2011
template<> std::string to_string<std::u32string>(const std::u32string& _input) {
std::string out;
template<> etk::String toString<etk::UString>(const etk::UString& _input) {
etk::String out;
for (size_t iii=0; iii<_input.size(); ++iii) {
char output[10];
u32char::convertUtf8(_input[iii], output);
@ -242,108 +11,22 @@ namespace etk {
}
return out;
}
template<> std::string to_string<char32_t>(const char32_t& _input) {
std::string out;
template<> etk::String toString<char32_t>(const char32_t& _input) {
etk::String out;
char output[10];
u32char::convertUtf8(_input, output);
out += output;
return out;
}
#endif
template<> std::string to_string<std::string>(const std::string& _val) {
return _val;
}
template<> std::string to_string<bool>(const bool& _val) {
if (_val == true) {
return "true";
}
return "false";
}
template<> std::string to_string<int8_t>(const int8_t& _val) {
char tmpVal[256];
sprintf(tmpVal, "%d", _val);
return tmpVal;
}
template<> std::string to_string<int16_t>(const int16_t& _val) {
char tmpVal[256];
sprintf(tmpVal, "%d", _val);
return tmpVal;
}
template<> std::string to_string<int32_t>(const int32_t& _val) {
char tmpVal[256];
sprintf(tmpVal, "%d", _val);
return tmpVal;
}
template<> std::string to_string<int64_t>(const int64_t& _val) {
char tmpVal[256];
#if ( defined(__TARGET_OS__Android) \
|| defined(__TARGET_OS__Windows) \
|| defined(__TARGET_OS__MacOs) \
|| defined(__TARGET_OS__IOs))
sprintf(tmpVal, "%lld", _val);
#else
sprintf(tmpVal, "%ld", _val);
#endif
return tmpVal;
}
template<> std::string to_string<uint8_t>(const uint8_t& _val) {
char tmpVal[256];
sprintf(tmpVal, "%u", _val);
return tmpVal;
}
template<> std::string to_string<uint16_t>(const uint16_t& _val) {
char tmpVal[256];
sprintf(tmpVal, "%u", _val);
return tmpVal;
}
template<> std::string to_string<uint32_t>(const uint32_t& _val) {
char tmpVal[256];
sprintf(tmpVal, "%u", _val);
return tmpVal;
}
template<> std::string to_string<uint64_t>(const uint64_t& _val) {
char tmpVal[256];
#if ( defined(__TARGET_OS__Android) \
|| defined(__TARGET_OS__Windows) \
|| defined(__TARGET_OS__MacOs) \
|| defined(__TARGET_OS__IOs))
sprintf(tmpVal, "%llu", _val);
#else
sprintf(tmpVal, "%lu", _val);
#endif
return tmpVal;
}
#if (defined(__TARGET_OS__IOs) || defined(__TARGET_OS__MacOs))
template<> std::string to_string<size_t>(const size_t& _val) {
char tmpVal[256];
sprintf(tmpVal, "%lu", _val);
return tmpVal;
}
#endif
template<> std::string to_string<float>(const float& _val) {
char tmpVal[256];
sprintf(tmpVal, "%f", _val);
return tmpVal;
}
template<> std::string to_string<double>(const double& _val) {
char tmpVal[256];
sprintf(tmpVal, "%f", _val);
return tmpVal;
}
template<> std::string to_string<long double>(const long double& _val) {
char tmpVal[256];
sprintf(tmpVal, "%Lf", _val);
return tmpVal;
}
};
#if __CPP_VERSION__ >= 2011
static std::u32string transform_to_u32string(const char* _input) {
if (_input == NULL) {
static etk::UString transform_toUString(const char* _input) {
if (_input == nullptr) {
return U"";
}
std::u32string out;
etk::UString out;
char tmpData[20];
int64_t pos = 0;
int64_t inputLen = strlen(_input);
@ -393,46 +76,46 @@ namespace etk {
#endif
#if __CPP_VERSION__ >= 2011
namespace etk {
template<> std::u32string to_u32string<char*>(char* const & _input) {
return transform_to_u32string(_input);
template<> etk::UString toUString<char*>(char* const & _input) {
return transform_toUString(_input);
}
template<> std::u32string to_u32string<std::string>(const std::string& _input) {
return transform_to_u32string(_input.c_str());
template<> etk::UString toUString<etk::String>(const etk::String& _input) {
return transform_toUString(_input.c_str());
}
template<> std::u32string to_u32string<int8_t>(const int8_t& _val) {
return etk::to_u32string(etk::to_string(_val));
template<> etk::UString toUString<int8_t>(const int8_t& _val) {
return etk::toUString(etk::toString(_val));
};
template<> std::u32string to_u32string<int16_t>(const int16_t& _val) {
return etk::to_u32string(etk::to_string(_val));
template<> etk::UString toUString<int16_t>(const int16_t& _val) {
return etk::toUString(etk::toString(_val));
};
template<> std::u32string to_u32string<int32_t>(const int32_t& _val) {
return etk::to_u32string(etk::to_string(_val));
template<> etk::UString toUString<int32_t>(const int32_t& _val) {
return etk::toUString(etk::toString(_val));
};
template<> std::u32string to_u32string<int64_t>(const int64_t& _val) {
return etk::to_u32string(etk::to_string(_val));
template<> etk::UString toUString<int64_t>(const int64_t& _val) {
return etk::toUString(etk::toString(_val));
};
template<> std::u32string to_u32string<uint8_t>(const uint8_t& _val) {
return etk::to_u32string(etk::to_string(_val));
template<> etk::UString toUString<uint8_t>(const uint8_t& _val) {
return etk::toUString(etk::toString(_val));
};
template<> std::u32string to_u32string<uint16_t>(const uint16_t& _val) {
return etk::to_u32string(etk::to_string(_val));
template<> etk::UString toUString<uint16_t>(const uint16_t& _val) {
return etk::toUString(etk::toString(_val));
};
template<> std::u32string to_u32string<uint32_t>(const uint32_t& _val) {
return etk::to_u32string(etk::to_string(_val));
template<> etk::UString toUString<uint32_t>(const uint32_t& _val) {
return etk::toUString(etk::toString(_val));
};
template<> std::u32string to_u32string<uint64_t>(const uint64_t& _val) {
return etk::to_u32string(etk::to_string(_val));
template<> etk::UString toUString<uint64_t>(const uint64_t& _val) {
return etk::toUString(etk::toString(_val));
};
template<> std::u32string to_u32string<float>(const float& _val) {
return etk::to_u32string(etk::to_string(_val));
template<> etk::UString toUString<float>(const float& _val) {
return etk::toUString(etk::toString(_val));
};
template<> std::u32string to_u32string<double>(const double& _val) {
return etk::to_u32string(etk::to_string(_val));
template<> etk::UString toUString<double>(const double& _val) {
return etk::toUString(etk::toString(_val));
};
template<> std::u32string to_u32string<long double>(const long double& _val) {
return etk::to_u32string(etk::to_string(_val));
template<> etk::UString toUString<long double>(const long double& _val) {
return etk::toUString(etk::toString(_val));
};
template<> std::u32string to_u32string<bool>(const bool& _val) {
template<> etk::UString toUString<bool>(const bool& _val) {
if (_val == true) {
return U"true";
}
@ -440,7 +123,7 @@ namespace etk {
}
};
bool etk::string_to_bool(const std::u32string& _str) {
bool etk::string_to_bool(const etk::UString& _str) {
if( true == compare_no_case(_str, U"true")
|| true == compare_no_case(_str, U"enable")
|| true == compare_no_case(_str, U"yes")
@ -450,57 +133,43 @@ namespace etk {
return false;
}
double etk::string_to_double(const std::u32string& _str) {
return std::stod(etk::to_string(_str));
double etk::string_to_double(const etk::UString& _str) {
return etk::string_to_double(etk::toString(_str));
}
long double etk::string_to_long_double(const std::u32string& _str) {
return std::stold(etk::to_string(_str));
long double etk::string_to_long_double(const etk::UString& _str) {
return etk::string_to_long_double(etk::toString(_str));
}
float etk::string_to_float(const std::u32string& _str) {
return std::stof(etk::to_string(_str));
float etk::string_to_float(const etk::UString& _str) {
return etk::string_to_float(etk::toString(_str));
}
int8_t etk::string_to_int8_t(const std::u32string& _str, int _base) {
return std::stoi(etk::to_string(_str), 0, _base);
int8_t etk::string_to_int8_t(const etk::UString& _str) {
return etk::string_to_int8_t(etk::toString(_str));
}
int16_t etk::string_to_int16_t(const std::u32string& _str, int _base) {
return std::stoi(etk::to_string(_str), 0, _base);
int16_t etk::string_to_int16_t(const etk::UString& _str) {
return etk::string_to_int16_t(etk::toString(_str));
}
int32_t etk::string_to_int32_t(const std::u32string& _str, int _base) {
return std::stoi(etk::to_string(_str), 0, _base);
int32_t etk::string_to_int32_t(const etk::UString& _str) {
return etk::string_to_int32_t(etk::toString(_str));
}
int64_t etk::string_to_int64_t(const std::u32string& _str, int _base) {
return std::stoll(etk::to_string(_str), 0, _base);
int64_t etk::string_to_int64_t(const etk::UString& _str) {
return etk::string_to_int64_t(etk::toString(_str));
}
uint8_t etk::string_to_uint8_t(const std::u32string& _str, int _base) {
return std::stoul(etk::to_string(_str), 0, _base);
uint8_t etk::string_to_uint8_t(const etk::UString& _str) {
return etk::string_to_uint8_t(etk::toString(_str));
}
uint16_t etk::string_to_uint16_t(const std::u32string& _str, int _base) {
return std::stoul(etk::to_string(_str), 0, _base);
uint16_t etk::string_to_uint16_t(const etk::UString& _str) {
return etk::string_to_uint16_t(etk::toString(_str));
}
uint32_t etk::string_to_uint32_t(const std::u32string& _str, int _base) {
return std::stoul(etk::to_string(_str), 0, _base);
uint32_t etk::string_to_uint32_t(const etk::UString& _str) {
return etk::string_to_uint32_t(etk::toString(_str));
}
uint64_t etk::string_to_uint64_t(const std::u32string& _str, int _base) {
return std::stoull(etk::to_string(_str), 0, _base);
uint64_t etk::string_to_uint64_t(const etk::UString& _str) {
return etk::string_to_uint64_t(etk::toString(_str));
}
#endif
bool etk::string_to_bool(const std::string& _str) {
if( true == compare_no_case(_str, "true")
|| true == compare_no_case(_str, "enable")
|| true == compare_no_case(_str, "yes")
#if __CPP_VERSION__ >= 2011
|| _str == u8"1"
#else
|| _str == "1"
#endif
) {
return true;
}
return false;
}
#if __CPP_VERSION__ >= 2011
bool etk::compare_no_case(const std::u32string& _obj, const std::u32string& _val) {
bool etk::compare_no_case(const etk::UString& _obj, const etk::UString& _val) {
if (_val.size() != _obj.size()) {
return false;
}
@ -513,17 +182,6 @@ bool etk::string_to_bool(const std::string& _str) {
}
#endif
bool etk::compare_no_case(const std::string& _obj, const std::string& _val) {
if (_val.size() != _obj.size()) {
return false;
}
for(size_t iii=0; iii<_val.size(); ++iii) {
if (std::tolower(_val[iii]) != std::tolower(_obj[iii])) {
return false;
}
}
return true;
}
class DoubleChar {
public:
@ -581,14 +239,8 @@ static char32_t localToLower(char32_t _input) {
}
std::string etk::tolower(std::string _obj) {
for(size_t iii=0 ; iii<_obj.size() ; iii++) {
_obj[iii] = std::tolower(_obj[iii]);
}
return _obj;
}
#if __CPP_VERSION__ >= 2011
std::u32string etk::tolower(std::u32string _obj) {
etk::UString etk::tolower(etk::UString _obj) {
for(size_t iii=0 ; iii<_obj.size() ; iii++) {
_obj[iii] = localToLower(_obj[iii]);
}
@ -596,14 +248,8 @@ std::string etk::tolower(std::string _obj) {
}
#endif
std::string etk::toupper(std::string _obj) {
for(size_t iii=0 ; iii<_obj.size() ; iii++) {
_obj[iii] = std::toupper(_obj[iii]);
}
return _obj;
}
#if __CPP_VERSION__ >= 2011
std::u32string etk::toupper(std::u32string _obj) {
etk::UString etk::toupper(etk::UString _obj) {
for(size_t iii=0 ; iii<_obj.size() ; iii++) {
_obj[iii] = localToUpper(_obj[iii]);
}
@ -611,34 +257,9 @@ std::string etk::toupper(std::string _obj) {
}
#endif
bool etk::end_with(const std::string& _obj, const std::string& _val, bool _caseSensitive) {
if (_val.size() == 0) {
return false;
}
if (_val.size() > _obj.size()) {
return false;
}
if (true == _caseSensitive) {
for( int64_t iii=_val.size()-1, jjj=_obj.size()-1;
iii>=0 && jjj>=0;
iii--, jjj--) {
if (_obj[jjj] != _val[iii]) {
return false;
}
}
return true;
}
for( int64_t iii=_val.size()-1, jjj=_obj.size()-1;
iii>=0 && jjj>=0;
iii--, jjj--) {
if (std::tolower(_val[iii]) != std::tolower(_obj[jjj])) {
return false;
}
}
return true;
}
#if __CPP_VERSION__ >= 2011
bool etk::end_with(const std::u32string& _obj, const std::u32string& _val, bool _caseSensitive) {
bool etk::end_with(const etk::UString& _obj, const etk::UString& _val, bool _caseSensitive) {
if (_val.size() == 0) {
return false;
}
@ -666,34 +287,8 @@ bool etk::end_with(const std::string& _obj, const std::string& _val, bool _caseS
}
#endif
bool etk::start_with(const std::string& _obj, const std::string& _val, bool _caseSensitive) {
if (_val.size() == 0) {
return false;
}
if (_val.size() > _obj.size()) {
return false;
}
if (_caseSensitive == true) {
for( size_t iii = 0;
iii < _val.size();
iii++) {
if (_obj[iii] != _val[iii]) {
return false;
}
}
return true;
}
for( size_t iii = 0;
iii < _val.size();
iii++) {
if (std::tolower(_val[iii]) != std::tolower(_obj[iii])) {
return false;
}
}
return true;
}
#if __CPP_VERSION__ >= 2011
bool etk::start_with(const std::u32string& _obj, const std::u32string& _val, bool _caseSensitive) {
bool etk::start_with(const etk::UString& _obj, const etk::UString& _val, bool _caseSensitive) {
if (_val.size() == 0) {
return false;
}
@ -720,8 +315,8 @@ bool etk::start_with(const std::string& _obj, const std::string& _val, bool _cas
return true;
}
std::u32string etk::replace(const std::u32string& _obj, char32_t _val, char32_t _replace) {
std::u32string copy(_obj);
etk::UString etk::replace(const etk::UString& _obj, char32_t _val, char32_t _replace) {
etk::UString copy(_obj);
for( size_t iii = 0;
iii < copy.size();
iii++) {
@ -734,7 +329,7 @@ bool etk::start_with(const std::string& _obj, const std::string& _val, bool _cas
#endif
#if __CPP_VERSION__ >= 2011
std::u32string etk::extract_line(const std::u32string& _obj, int32_t _pos) {
etk::UString etk::extract_line(const etk::UString& _obj, int32_t _pos) {
// search back : '\n'
size_t startPos = _obj.rfind('\n', _pos);
if ((int64_t)startPos == _pos) {
@ -750,32 +345,32 @@ bool etk::start_with(const std::string& _obj, const std::string& _val, bool _cas
stopPos = _obj.size();
}
}
if (startPos == std::string::npos) {
if (startPos == etk::String::npos) {
startPos = 0;
} else if (startPos >= _obj.size() ) {
return U"";
}
if (stopPos == std::string::npos) {
if (stopPos == etk::String::npos) {
return U"";
} else if (stopPos >= _obj.size() ) {
stopPos = _obj.size();
}
return std::u32string(_obj, startPos, stopPos - startPos);
return etk::UString(_obj, startPos, stopPos - startPos);
}
#endif
#if __CPP_VERSION__ >= 2011
std::vector<std::u32string> etk::split(const std::u32string& _input, char32_t _val) {
std::vector<std::u32string> list;
etk::Vector<etk::UString> etk::split(const etk::UString& _input, char32_t _val) {
etk::Vector<etk::UString> list;
size_t lastStartPos = 0;
for(size_t iii=0; iii<_input.size(); iii++) {
if (_input[iii]==_val) {
list.push_back(std::u32string(_input, lastStartPos, iii - lastStartPos));
list.pushBack(etk::UString(_input, lastStartPos, iii - lastStartPos));
lastStartPos = iii+1;
}
}
if (lastStartPos<_input.size()) {
list.push_back(std::u32string(_input, lastStartPos));
list.pushBack(etk::UString(_input, lastStartPos));
}
return list;
}
@ -784,8 +379,8 @@ bool etk::start_with(const std::string& _obj, const std::string& _val, bool _cas
#if __CPP_VERSION__ >= 2011
void etk::sort(std::vector<std::u32string *> &_list) {
std::vector<std::u32string *> tmpList(_list);
void etk::sort(etk::Vector<etk::UString *> &_list) {
etk::Vector<etk::UString *> tmpList(_list);
_list.clear();
for(size_t iii=0; iii<tmpList.size(); iii++) {
size_t findPos = 0;
@ -803,55 +398,55 @@ bool etk::start_with(const std::string& _obj, const std::string& _val, bool _cas
namespace etk {
#if __CPP_VERSION__ >= 2011
template<> bool from_string<std::u32string>(std::u32string& _variableRet, const std::string& _value) {
_variableRet = etk::to_u32string(_value);
template<> bool from_string<etk::UString>(etk::UString& _variableRet, const etk::String& _value) {
_variableRet = etk::toUString(_value);
return true;
}
template<> bool from_string<int8_t>(int8_t& _variableRet, const std::u32string& _value) {
template<> bool from_string<int8_t>(int8_t& _variableRet, const etk::UString& _value) {
_variableRet = string_to_int8_t(_value);
return true;
}
template<> bool from_string<int16_t>(int16_t& _variableRet, const std::u32string& _value) {
template<> bool from_string<int16_t>(int16_t& _variableRet, const etk::UString& _value) {
_variableRet = string_to_int16_t(_value);
return true;
}
template<> bool from_string<int32_t>(int32_t& _variableRet, const std::u32string& _value) {
template<> bool from_string<int32_t>(int32_t& _variableRet, const etk::UString& _value) {
_variableRet = string_to_int32_t(_value);
return true;
}
template<> bool from_string<int64_t>(int64_t& _variableRet, const std::u32string& _value) {
template<> bool from_string<int64_t>(int64_t& _variableRet, const etk::UString& _value) {
_variableRet = string_to_int64_t(_value);
return true;
}
template<> bool from_string<uint8_t>(uint8_t& _variableRet, const std::u32string& _value) {
template<> bool from_string<uint8_t>(uint8_t& _variableRet, const etk::UString& _value) {
_variableRet = string_to_uint8_t(_value);
return true;
}
template<> bool from_string<uint16_t>(uint16_t& _variableRet, const std::u32string& _value) {
template<> bool from_string<uint16_t>(uint16_t& _variableRet, const etk::UString& _value) {
_variableRet = string_to_uint16_t(_value);
return true;
}
template<> bool from_string<uint32_t>(uint32_t& _variableRet, const std::u32string& _value) {
template<> bool from_string<uint32_t>(uint32_t& _variableRet, const etk::UString& _value) {
_variableRet = string_to_uint32_t(_value);
return true;
}
template<> bool from_string<uint64_t>(uint64_t& _variableRet, const std::u32string& _value) {
template<> bool from_string<uint64_t>(uint64_t& _variableRet, const etk::UString& _value) {
_variableRet = string_to_uint64_t(_value);
return true;
}
template<> bool from_string<float>(float& _variableRet, const std::u32string& _value) {
template<> bool from_string<float>(float& _variableRet, const etk::UString& _value) {
_variableRet = string_to_float(_value);
return true;
}
template<> bool from_string<double>(double& _variableRet, const std::u32string& _value) {
template<> bool from_string<double>(double& _variableRet, const etk::UString& _value) {
_variableRet = string_to_double(_value);
return true;
}
template<> bool from_string<long double>(long double& _variableRet, const std::u32string& _value) {
template<> bool from_string<long double>(long double& _variableRet, const etk::UString& _value) {
_variableRet = string_to_long_double(_value);
return true;
}
template<> bool from_string<bool>(bool& _variableRet, const std::u32string& _value) {
template<> bool from_string<bool>(bool& _variableRet, const etk::UString& _value) {
_variableRet = string_to_bool(_value);
return true;
}
@ -860,12 +455,12 @@ namespace etk {
#if __CPP_VERSION__ >= 2011
std::ostream& std::operator <<(std::ostream& _os, const std::u32string& _obj) {
_os << etk::to_string(_obj).c_str();
std::ostream& std::operator <<(std::ostream& _os, const etk::UString& _obj) {
_os << etk::toString(_obj).c_str();
return _os;
}
std::ostream& std::operator <<(std::ostream& _os, const std::vector<std::u32string>& _obj) {
std::ostream& std::operator <<(std::ostream& _os, const etk::Vector<etk::UString>& _obj) {
_os << "{";
for (size_t iii=0; iii< _obj.size(); iii++) {
if (iii>0) {
@ -878,52 +473,6 @@ namespace etk {
}
#endif
#if (defined(__TARGET_OS__Android))
double std::stod(const std::string& _str, size_t* _id) {
double ret = 0;
sscanf(_str.c_str(), "%lf", &ret);
return ret;
}
float std::stof(const std::string& _str, size_t* _id) {
float ret = 0;
sscanf(_str.c_str(), "%f", &ret);
return ret;
}
int std::stoi(const std::string& _str, size_t* _id, int _base) {
int ret = 0;
sscanf(_str.c_str(), "%d", &ret);
return ret;
}
long std::stol(const std::string& _str, size_t* _id, int _base) {
long ret = 0;
sscanf(_str.c_str(), "%ld", &ret);
return ret;
}
long double std::stold(const std::string& _str, size_t* _id) {
long double ret = 0;
sscanf(_str.c_str(), "%Lf", &ret);
return ret;
}
long long std::stoll(const std::string& _str, size_t* _id, int _base) {
long long ret = 0;
sscanf(_str.c_str(), "%lld", &ret);
return ret;
}
unsigned long std::stoul(const std::string& _str, size_t* _id, int _base) {
unsigned long ret = 0;
sscanf(_str.c_str(), "%lu", &ret);
return ret;
}
unsigned long long std::stoull(const std::string& _str, size_t* _id, int _base) {
unsigned long long ret = 0;
sscanf(_str.c_str(), "%llu", &ret);
return ret;
}
#endif
namespace std {
std::ostream& operator <<(std::ostream& _os, const std::chrono::system_clock::time_point& _obj) {
std::chrono::nanoseconds ns = std::chrono::duration_cast<std::chrono::nanoseconds>(_obj.time_since_epoch());

521
etk/stdTools.hpp
View File

@ -1,526 +1,47 @@
/** @file
* @author Edouard DUPIN
* @copyright 2011, Edouard DUPIN, all right reserved
* @license MPL v2.0 (see license file)
*/
#pragma once
#include <etk/types.hpp>
#include <etk/String.hpp>
#include <etk/Vector.hpp>
#include <vector>
#include <sstream>
#include <iostream>
#include <string>
#include <iomanip>
#include <algorithm>
#include <chrono>
/**
* @brief Unicode simple wrapper interface
*/
namespace u32char {
extern const char32_t Null; //!< Value '\\0'
extern const char32_t Return; //!< Value '\\n'
extern const char32_t CarrierReturn; //!< Value '\\r' CR
extern const char32_t Tabulation; //!< Value '\\t' TAB
extern const char32_t Suppress; //!< Value BS (SUPPRESS)
extern const char32_t Delete; //!< Value DEL
extern const char32_t Space; //!< Value ' ' SPACE
extern const char32_t Escape; //!< Value ESC Escape
/**
* @brief check if the current element is white or not : '\\t' '\\n' '\\r' ' '
* @param[in] _val Value to interpret
* @return true if it is white char
* @return false otherwise
*/
bool isWhiteChar(char32_t _val);
/**
* @brief check if the current element is NOT [a-zA-Z0-9]
* @param[in] _val Value to interpret
* @return true Not in the previous list
* @return false otherwise
*/
bool isSpecialChar(char32_t _val);
/**
* @brief check if the current element is number or not [0-9]
* @param[in] _val Value to interpret
* @return true if it is a number char
* @return false otherwise
*/
bool isInteger(char32_t _val);
/**
* @brief Convert char32_t in an integer
* @param[in] _val Value to interpret
* @return The parsed Value or ...
*/
int32_t toInt(char32_t _val);
/**
* @brief Change order of the value to have an order of display with A->Z and after a->z and after 0->9 and after all the rest ....
* @param[in] _val Value in unicode
* @return A value usable in integer only ... to check order...
*/
char32_t changeOrder(char32_t _val);
/**
* @brief Convert unicode in UTF8 value
* @param[in] _val Value to convert
* @param[out] _output Char data converted
* @return Number of char in utf8
*/
int8_t convertUtf8(char32_t _val, char _output[5]);
#if __CPP_VERSION__ >= 2011
std::string convertToUtf8(const std::u32string& _input);
#endif
};
/**
* @brief UTF-8 simple wrapper interface
*/
namespace utf8 {
/**
* @brief Get the size of an utf8 char with his first char.
* @param[in] _input Char to parse
* @return number of char needed
*/
int8_t length(const char _input);
/**
* @brief When parsing a string in a reverse mode, we need to know if we get the first char
* @param[in] _input Char to parse.
* @return true if it was the first char.
*/
bool first(const char _input);
/**
* @brief Convert a char* in a unicode value
* @param[in] _input pointer on a string C (utf-8) to convert
* @return Converted Value
*/
char32_t convertChar32(const char* _input);
#if __CPP_VERSION__ >= 2011
std::u32string convertUnicode(const etk::String& _input);
#endif
/**
* @brief Iterator on a simple std::string that contain utf8 value
*/
class iterator {
private:
char32_t m_value; //!< store value to prevent multiple calculation of getting the data
std::string* m_data; //!< Pointer on the current Buffer
int64_t m_current; //!< current Id in the Buffer
public:
/**
* @brief Basic constructor that is not link on a string
*/
iterator():
m_value(u32char::Null),
m_data(nullptr),
m_current(0) {
// nothing to do ...
};
/**
* @brief Basic begin constructor link at the start of the string
* @param[in] _str reference on the string to inspect.
*/
iterator(std::string& _str) :
m_value(u32char::Null),
m_data(&_str),
m_current(0) {
// nothing to do ...
};
/**
* @brief Basic position constructor link at the _pos position of the string
* @param[in] _str reference on the string to inspect.
* @param[in] _pos Iterator position on the string.
*/
iterator(std::string& _str, const std::string::iterator& _pos) :
m_value(u32char::Null),
m_data(&_str),
m_current(0) {
if (m_data != nullptr) {
m_current = std::distance(m_data->begin(), _pos);
}
};
/**
* @brief Basic position constructor link at the _pos position of the string
* @param[in] _str reference on the string to inspect.
* @param[in] _pos Position on the string (in AINSI value).
*/
iterator(std::string& _str, size_t _pos) :
m_value(u32char::Null),
m_data(&_str),
m_current(0) {
if (m_data != nullptr) {
if (_pos > m_data->size()) {
m_current = m_data->size();
} else {
m_current = _pos;
}
}
};
/**
* @brief Basic position constructor link at the _pos position of the string
* @param[in] _str Pointer on the string to inspect.
* @param[in] _pos Iterator position on the string.
*/
iterator(std::string* _str, const std::string::iterator& _pos) :
m_value(u32char::Null),
m_data(_str),
m_current(0) {
if (m_data != nullptr) {
m_current = std::distance(m_data->begin(), _pos);
}
};
/**
* @brief Basic position constructor link at the _pos position of the string
* @param[in] _str Pointer on the string to inspect.
* @param[in] _pos Position on the string (in AINSI value).
*/
iterator(std::string* _str, size_t _pos) :
m_value(u32char::Null),
m_data(_str),
m_current(0) {
if (m_data != nullptr) {
if (_pos > m_data->size()) {
m_current = m_data->size();
} else {
m_current = _pos;
}
}
};
/**
* @brief Recopy constructor.
* @param[in] _obj The Iterator that might be copy
*/
iterator(const iterator& _obj):
m_value(u32char::Null),
m_data(_obj.m_data),
m_current(_obj.m_current) {
// nothing to do ...
};
/**
* @brief Assignation operator.
* @param[in] _obj The Iterator that might be copy
* @return reference on the current Iterator
*/
iterator& operator=(const iterator & _obj) {
m_current = _obj.m_current;
m_data = _obj.m_data;
m_value = u32char::Null;
return *this;
};
/**
* @brief Basic destructor
*/
virtual ~iterator() {
m_current = 0;
m_data = nullptr;
m_value = u32char::Null;
};
/**
* @brief basic boolean cast
* @return true if the element is present in buffer
*/
operator size_t () const {
if (m_data == nullptr) {
return 0;
}
if (m_current < 0) {
return 0;
}
if (m_current > (int64_t)m_data->size()) {
return m_data->size();
}
return (size_t)m_current;
};
/**
* @brief Incremental operator
* @return Reference on the current iterator increment
*/
iterator& operator++ ();
/**
* @brief Decremental operator
* @return Reference on the current iterator decrement
*/
iterator& operator-- ();
/**
* @brief Incremental operator
* @return Reference on a new iterator and increment the other one
*/
iterator operator++ (int32_t) {
iterator it(*this);
++(*this);
return it;
};
/**
* @brief Decremental operator
* @return Reference on a new iterator and decrement the other one
*/
iterator operator-- (int32_t) {
iterator it(*this);
--(*this);
return it;
};
/**
* @brief equality iterator
* @param[in] _obj Iterator to compare
* @return true if the iterator is identical pos
*/
bool operator== (const iterator& _obj) const {
if ( m_current == _obj.m_current
&& m_data == _obj.m_data) {
return true;
}
return false;
};
/**
* @brief equality iterator
* @param[in] _obj Iterator to compare
* @return true if the iterator is identical pos
*/
bool operator!= (const iterator& _obj) const {
if ( m_current != _obj.m_current
|| m_data != _obj.m_data) {
return true;
}
return false;
};
/**
* @brief <= iterator
* @param[in] _obj Iterator to compare
* @return true if the iterator is identical pos
*/
bool operator<= (const iterator& _obj) const {
if (m_data != _obj.m_data) {
return false;
}
if (m_current <= _obj.m_current) {
return true;
}
return false;
};
/**
* @brief >= iterator
* @param[in] _obj Iterator to compare
* @return true if the iterator is identical pos
*/
bool operator>= (const iterator& _obj) const {
if (m_data != _obj.m_data) {
return false;
}
if (m_current >= _obj.m_current) {
return true;
}
return false;
};
/**
* @brief < iterator
* @param[in] _obj Iterator to compare
* @return true if the iterator is identical pos
*/
bool operator< (const iterator& _obj) const {
if (m_data != _obj.m_data) {
return false;
}
if (m_current < _obj.m_current) {
return true;
}
return false;
};
/**
* @brief > iterator
* @param[in] _obj Iterator to compare
* @return true if the iterator is identical pos
*/
bool operator> (const iterator& _obj) const {
if (m_data != _obj.m_data) {
return false;
}
if (m_current > _obj.m_current) {
return true;
}
return false;
};
/**
* @brief Get the value on the current element
* @return The request element value
*/
char32_t operator* ();
/**
* @brief Get the position in the buffer
* @return The requested position.
*/
size_t getPos() const {
if (m_data == nullptr) {
return 0;
}
if (m_current < 0) {
return 0;
}
if (m_current >= (int64_t)m_data->size()) {
return m_data->size()-1;
}
return (size_t)m_current;
};
/**
* @brief move the element position
* @param[in] _val Value to add on the Iterator
* @return a new iterator.
*/
iterator operator+ (const int64_t _val) const {
iterator tmp(*this);
for (int64_t iii=0; iii<_val; ++iii) {
++tmp;
}
return tmp;
};
/**
* @copydoc utf8::iterator::operator+ (const int64_t)
*/
iterator operator+ (const int32_t _val) const {
iterator tmp(*this);
for (int64_t iii=0; iii<_val; ++iii) {
++tmp;
}
return tmp;
}
/**
* @copydoc utf8::iterator::operator+ (const int64_t)
*/
iterator operator+ (const size_t _val) const {
iterator tmp(*this);
for (int64_t iii=0; iii<(int64_t)_val; ++iii) {
++tmp;
}
return tmp;
}
/**
* @brief move the element position
* @param[in] _val Value to remove on the Iterator
* @return a new iterator.
*/
iterator operator- (const int64_t _val) const {
iterator tmp(*this);
for (int64_t iii=0; iii<_val; ++iii) {
--tmp;
}
return tmp;
}
/**
* @copydoc utf8::iterator::operator- (const int64_t)
*/
iterator operator- (const int32_t _val) const {
iterator tmp(*this);
for (int64_t iii=0; iii<_val; ++iii) {
--tmp;
}
return tmp;
}
/**
* @copydoc utf8::iterator::operator- (const int64_t)
*/
iterator operator- (const size_t _val) const {
iterator tmp(*this);
for (int64_t iii=0; iii<(int64_t)_val; ++iii) {
--tmp;
}
return tmp;
}
/*
iterator begin() const {
return iterator(m_data);
}
iterator end() const {
return --iterator(m_data, m_data.end());
}
*/
};
};
namespace etk {
// these declaration is to prevent some under template declaration of unknown type
#if __CPP_VERSION__ >= 2011
template <class TYPE>
std::u32string to_u32string(const TYPE& _variable);
template <class TYPE>
bool from_string(TYPE& _variableRet, const std::u32string& _value);
long double string_to_long_double(const std::u32string& _str);
double string_to_double(const std::u32string& _str);
float string_to_float(const std::u32string& _str);
int8_t string_to_int8_t(const std::u32string& _str, int _base = 10);
int16_t string_to_int16_t(const std::u32string& _str, int _base = 10);
int32_t string_to_int32_t(const std::u32string& _str, int _base = 10);
int64_t string_to_int64_t(const std::u32string& _str, int _base = 10);
uint8_t string_to_uint8_t(const std::u32string& _str, int _base = 10);
uint16_t string_to_uint16_t(const std::u32string& _str, int _base = 10);
uint32_t string_to_uint32_t(const std::u32string& _str, int _base = 10);
uint64_t string_to_uint64_t(const std::u32string& _str, int _base = 10);
bool string_to_bool(const std::u32string& _str);
std::u32string tolower(std::u32string _obj);
std::u32string toupper(std::u32string _obj);
bool compare_no_case(const std::u32string& _obj, const std::u32string& _val);
bool end_with(const std::u32string& _obj, const std::u32string& _val, bool _caseSensitive = true);
bool start_with(const std::u32string& _obj, const std::u32string& _val, bool _caseSensitive = true);
std::u32string replace(const std::u32string& _obj, char32_t _val, char32_t _replace);
std::u32string extract_line(const std::u32string& _obj, int32_t _pos);
std::vector<std::u32string> split(const std::u32string& _input, char32_t _val);
void sort(std::vector<std::u32string *>& _list);
#endif
//! @not_in_doc
template<typename T, typename T2>
bool isIn(const T& _val, const std::vector<T2>& _list) {
for (size_t iii=0; iii<_list.size(); ++iii) {
if (_list[iii] == _val) {
return true;
}
template<class ETK_ITERATOR_TYPE>
size_t distance(const ETK_ITERATOR_TYPE& _start, const ETK_ITERATOR_TYPE& _stop) {
size_t out = 0;
ETK_ITERATOR_TYPE tmp = _start;
while (tmp != _stop) {
out++;
++tmp;
}
return false;
return out;
}
};
}
namespace std {
#if __CPP_VERSION__ >= 2011
//! @not_in_doc
std::ostream& operator <<(std::ostream& _os, const std::u32string& _obj);
//! @not_in_doc
std::ostream& operator <<(std::ostream& _os, const std::vector<std::u32string>& _obj);
#endif
//! @not_in_doc
std::ostream& operator <<(std::ostream& _os, const std::vector<float>& _obj);
std::ostream& operator <<(std::ostream& _os, const etk::Vector<float>& _obj);
//! @not_in_doc
std::ostream& operator <<(std::ostream& _os, const std::vector<double>& _obj);
std::ostream& operator <<(std::ostream& _os, const etk::Vector<double>& _obj);
//! @not_in_doc
std::ostream& operator <<(std::ostream& _os, const std::vector<int64_t>& _obj);
std::ostream& operator <<(std::ostream& _os, const etk::Vector<int64_t>& _obj);
//! @not_in_doc
std::ostream& operator <<(std::ostream& _os, const std::vector<uint64_t>& _obj);
std::ostream& operator <<(std::ostream& _os, const etk::Vector<uint64_t>& _obj);
//! @not_in_doc
std::ostream& operator <<(std::ostream& _os, const std::vector<int32_t>& _obj);
std::ostream& operator <<(std::ostream& _os, const etk::Vector<int32_t>& _obj);
//! @not_in_doc
std::ostream& operator <<(std::ostream& _os, const std::vector<uint32_t>& _obj);
std::ostream& operator <<(std::ostream& _os, const etk::Vector<uint32_t>& _obj);
//! @not_in_doc
std::ostream& operator <<(std::ostream& _os, const std::vector<int16_t>& _obj);
std::ostream& operator <<(std::ostream& _os, const etk::Vector<int16_t>& _obj);
//! @not_in_doc
std::ostream& operator <<(std::ostream& _os, const std::vector<uint16_t>& _obj);
std::ostream& operator <<(std::ostream& _os, const etk::Vector<uint16_t>& _obj);
//! @not_in_doc
std::ostream& operator <<(std::ostream& _os, const std::vector<int8_t>& _obj);
std::ostream& operator <<(std::ostream& _os, const etk::Vector<int8_t>& _obj);
//! @not_in_doc
std::ostream& operator <<(std::ostream& _os, const std::vector<uint8_t>& _obj);
std::ostream& operator <<(std::ostream& _os, const etk::Vector<uint8_t>& _obj);
//! @not_in_doc
std::ostream& operator <<(std::ostream& _os, const std::chrono::system_clock::time_point& _obj);
//! @not_in_doc
std::ostream& operator <<(std::ostream& _os, const std::chrono::steady_clock::time_point& _obj);
}
/**
* @brief Calculate the size of a string (unicode)
* @param[in] _data Data to parse to find the end of string
* @return The Number of char32_t before the '\\0' value
*/
int32_t strlen(const char32_t* _data);
#if (defined(__TARGET_OS__Windows))
#define M_PI 3.14159265358979323846
#endif

4
etk/types.hpp
View File

@ -65,6 +65,10 @@
#define ETK_EXPORT_VISIBILITY __attribute__ ((visibility ("default")))
#endif
#if (defined(__TARGET_OS__Windows))
#define M_PI 3.14159265358979323846
#endif
namespace etk {
template <class TYPE> const TYPE& min(const TYPE& _val1, const TYPE& _val2) {
return (_val1 > _val2) ? _val2 : _val1;

233
etk/utf8.cpp Normal file
View File

@ -0,0 +1,233 @@
/** @file
* @author Edouard DUPIN
* @copyright 2011, Edouard DUPIN, all right reserved
* @license MPL v2.0 (see license file)
*/
#include <etk/stdTools.hpp>
#include <etk/debug.hpp>
#include <etk/String.hpp>
const char32_t u32char::Null('\0');
const char32_t u32char::Return('\n');
const char32_t u32char::CarrierReturn('\r');
const char32_t u32char::Tabulation('\t');
const char32_t u32char::Suppress((const char)127);
const char32_t u32char::Delete((const char)8);
const char32_t u32char::Space(' ');
const char32_t u32char::Escape((const char)27);
bool u32char::isWhiteChar(char32_t _val) {
if( _val == ' '
|| _val == '\t'
|| _val == '\n'
|| _val == '\r') {
return true;
}
return false;
}
bool u32char::isSpecialChar(char32_t _val) {
if( _val < '0'
|| (_val > '9' && _val < 'A')
|| (_val > 'Z' && _val < 'a')
|| (_val > 'z' && _val < 0xFF) ) {
return true;
}
return false;
}
bool u32char::isInteger(char32_t _val) {
if( _val >= (uint32_t)'0'
&& _val <= (uint32_t)'9') {
return true;
}
return false;
}
int32_t u32char::toInt(char32_t _val) {
return _val - (uint32_t)'0';
}
char32_t u32char::changeOrder(char32_t _val) {
if (_val >= 'A' && _val <= 'Z') {
return (_val - (uint32_t)'A')*2 + 'A';
}
if (_val >= 'a' && _val <= 'z') {
return (_val - (uint32_t)'a')*2 + 'A' + 1;
}
if (_val >= ':' && _val <= '@') {
return _val + 52;
}
if (_val >= '[' && _val <= '`') {
return _val +26;
}
return _val;
}
static uint32_t getUtf8Val(char32_t _val) {
uint32_t output = 0;
if (_val <= 127) {
output = _val;
} else if (_val <= 2047) {
// output ==> 00000000 00000000 110xxxxx 10xxxxxx
// input ==> -------- -------- -----222 22111111
output = 0x0000C080;
output+= (_val & 0x000007C0)<<2;
output+= _val & 0x0000003F;
} else if (_val <= 65535) {
// output ==> 00000000 1110xxxx 10xxxxxx 10xxxxxx
// input ==> -------- -------- 33332222 22111111
output = 0x00E08080;
output+= (_val & 0x0000F000)<<4;
output+= (_val & 0x00000FC0)<<2;
output+= _val & 0x0000003F;
} else if (_val <= 1114111) {
// output ==> 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
// input ==> -------- ---44433 33332222 22111111
output = 0xF0808080;
output+= (_val & 0x001C0000)<<6;
output+= (_val & 0x0003F000)<<4;
output+= (_val & 0x00000FC0)<<2;
output+= _val & 0x0000003F;
} else {
//TK_ERROR("NOT UTF8 character input...");
printf("not an utf8 char : %#08x\n", _val);
return 0;
}
//printf("utf-8 conversion : %d=%08x ==> %08x\n",value, value, output);
return output;
}
int8_t u32char::convertUtf8(char32_t _val, char _output[5]) {
uint32_t value = getUtf8Val(_val);
if (0xFF >= value) {
_output[0] = (char)value;
_output[1] = '\0';
return 1;
} else if (0xFFFF >= value) {
_output[0] = (char)((value>>8) & 0x000000FF);
_output[1] = (char)value;
_output[2] = '\0';
return 2;
} else if (0xFFFFFF >= value) {
_output[0] = (char)((value>>16) & 0x000000FF);
_output[1] = (char)((value>>8) & 0x000000FF);
_output[2] = (char)value;
_output[3] = '\0';
return 3;
} else {
_output[0] = (char)((value>>24) & 0x000000FF);
_output[1] = (char)((value>>16) & 0x000000FF);
_output[2] = (char)((value>>8) & 0x000000FF);
_output[3] = (char)value;
_output[4] = '\0';
return 4;
}
}
#if __CPP_VERSION__ >= 2011
etk::String u32char::convertToUtf8(const etk::UString& _input) {
TK_TODO("implement this function ...");
return "TODO ... etk::String u32char::convertToUtf8(const etk::UString& _input)";
}
#endif
static uint8_t sizeElement(const char* _data, int32_t _lenMax) {
uint8_t size = 0;
TK_ASSERT(0 <= _lenMax, "size can not be < 0 ...");
if (0 > _lenMax) {
return 0;
}
//4 case
if( _lenMax >= 1
&& (_data[0] & 0x80) == 0x00 ) {
// One Char Element
size = 1;
} else if( _lenMax >= 2
&& (_data[0] & 0xE0) == 0xC0
&& (_data[1] & 0xC0) == 0x80) {
size = 2;
} else if( _lenMax >= 3
&& (_data[0] & 0xF0) == 0xE0
&& (_data[1] & 0xC0) == 0x80
&& (_data[2] & 0xC0) == 0x80) {
size = 3;
} else if( _lenMax >= 4
&& (_data[0] & 0xF8) == 0xF0
&& (_data[1] & 0xC0) == 0x80
&& (_data[2] & 0xC0) == 0x80
&& (_data[3] & 0xC0) == 0x80) {
size = 4;
}
return size;
}
char32_t utf8::convertChar32(const char* _input) {
char32_t value = 0;
if (nullptr == _input) {
return value;
}
int32_t len = strlen(_input);
len = sizeElement(_input, len);
switch (len) {
default:
// case 0 : An error occurred...
value = _input[0];
return value;
case 1:
value = (uint8_t)(_input[0]) & 0x7F;
return value;
case 2:
value = (((uint8_t)_input[0]) & 0x1F)<< 6;
value += ((uint8_t)_input[1]) & 0x3F;
return value;
case 3:
value = (((uint8_t)_input[0]) & 0x0F)<< 12;
value += (((uint8_t)_input[1]) & 0x3F)<< 6;
value += ((uint8_t)_input[2]) & 0x3F;
return value;
case 4:
value = (((uint8_t)_input[0]) & 0x07)<< 18;
value += (((uint8_t)_input[1]) & 0x3F)<< 12;
value += (((uint8_t)_input[2]) & 0x3F)<< 6;
value += ((uint8_t)_input[3]) & 0x3F;
return value;
}
}
int8_t utf8::length(const char _input) {
if((_input&0x80) == 0x00 ) {
return 1;
}
if((_input&0xE0) == 0xC0) {
return 2;
}
if((_input&0xF0) == 0xE0) {
return 3;
}
if((_input&0xF8) == 0xF0) {
return 4;
}
return 1;
}
bool utf8::first(const char _input) {
// When started with the bit 0 then the size is single element.
if((_input&0x80) == 0x00 ) {
return true;
}
// for multiple element size, we just need to check the second element (might be != 1)
if((_input&0x40) == 0x40 ) {
return true;
}
return false;
}
#if __CPP_VERSION__ >= 2011
etk::UString utf8::convertUnicode(const etk::String& _input) {
TK_TODO("implement this function ...");
return U"TODO ... etk::UString utf8::convertUnicode(const etk::String& _input)";
}
#endif

448
etk/utf8.hpp Normal file
View File

@ -0,0 +1,448 @@
/** @file
* @author Edouard DUPIN
* @copyright 2011, Edouard DUPIN, all right reserved
* @license MPL v2.0 (see license file)
*/
#pragma once
#include <etk/types.hpp>
#include <etk/String.hpp>
#include <etk/Vector.hpp>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <algorithm>
#include <chrono>
#include <etk/stdTools.hpp>
namespace etk {
class UString;
}
/**
* @brief Unicode simple wrapper interface
*/
namespace u32char {
extern const char32_t Null; //!< Value '\\0'
extern const char32_t Return; //!< Value '\\n'
extern const char32_t CarrierReturn; //!< Value '\\r' CR
extern const char32_t Tabulation; //!< Value '\\t' TAB
extern const char32_t Suppress; //!< Value BS (SUPPRESS)
extern const char32_t Delete; //!< Value DEL
extern const char32_t Space; //!< Value ' ' SPACE
extern const char32_t Escape; //!< Value ESC Escape
/**
* @brief check if the current element is white or not : '\\t' '\\n' '\\r' ' '
* @param[in] _val Value to interpret
* @return true if it is white char
* @return false otherwise
*/
bool isWhiteChar(char32_t _val);
/**
* @brief check if the current element is NOT [a-zA-Z0-9]
* @param[in] _val Value to interpret
* @return true Not in the previous list
* @return false otherwise
*/
bool isSpecialChar(char32_t _val);
/**
* @brief check if the current element is number or not [0-9]
* @param[in] _val Value to interpret
* @return true if it is a number char
* @return false otherwise
*/
bool isInteger(char32_t _val);
/**
* @brief Convert char32_t in an integer
* @param[in] _val Value to interpret
* @return The parsed Value or ...
*/
int32_t toInt(char32_t _val);
/**
* @brief Change order of the value to have an order of display with A->Z and after a->z and after 0->9 and after all the rest ....
* @param[in] _val Value in unicode
* @return A value usable in integer only ... to check order...
*/
char32_t changeOrder(char32_t _val);
/**
* @brief Convert unicode in UTF8 value
* @param[in] _val Value to convert
* @param[out] _output Char data converted
* @return Number of char in utf8
*/
int8_t convertUtf8(char32_t _val, char _output[5]);
#if __CPP_VERSION__ >= 2011
etk::String convertToUtf8(const etk::UString& _input);
#endif
};
/**
* @brief UTF-8 simple wrapper interface
*/
namespace utf8 {
/**
* @brief Get the size of an utf8 char with his first char.
* @param[in] _input Char to parse
* @return number of char needed
*/
int8_t length(const char _input);
/**
* @brief When parsing a string in a reverse mode, we need to know if we get the first char
* @param[in] _input Char to parse.
* @return true if it was the first char.
*/
bool first(const char _input);
/**
* @brief Convert a char* in a unicode value
* @param[in] _input pointer on a string C (utf-8) to convert
* @return Converted Value
*/
char32_t convertChar32(const char* _input);
#if __CPP_VERSION__ >= 2011
etk::UString convertUnicode(const etk::String& _input);
#endif
/**
* @brief Iterator on a simple etk::String that contain utf8 value
*/
class Iterator {
private:
char32_t m_value; //!< store value to prevent multiple calculation of getting the data
etk::String* m_data; //!< Pointer on the current Buffer
int64_t m_current; //!< current Id in the Buffer
public:
/**
* @brief Basic constructor that is not link on a string
*/
Iterator():
m_value(u32char::Null),
m_data(nullptr),
m_current(0) {
// nothing to do ...
};
/**
* @brief Basic begin constructor link at the start of the string
* @param[in] _str reference on the string to inspect.
*/
Iterator(etk::String& _str) :
m_value(u32char::Null),
m_data(&_str),
m_current(0) {
// nothing to do ...
};
/**
* @brief Basic position constructor link at the _pos position of the string
* @param[in] _str reference on the string to inspect.
* @param[in] _pos Iterator position on the string.
*/
Iterator(etk::String& _str, const etk::String::Iterator& _pos) :
m_value(u32char::Null),
m_data(&_str),
m_current(0) {
if (m_data != nullptr) {
m_current = etk::distance(m_data->begin(), _pos);
}
};
/**
* @brief Basic position constructor link at the _pos position of the string
* @param[in] _str reference on the string to inspect.
* @param[in] _pos Position on the string (in AINSI value).
*/
Iterator(etk::String& _str, size_t _pos) :
m_value(u32char::Null),
m_data(&_str),
m_current(0) {
if (m_data != nullptr) {
if (_pos > m_data->size()) {
m_current = m_data->size();
} else {
m_current = _pos;
}
}
};
/**
* @brief Basic position constructor link at the _pos position of the string
* @param[in] _str Pointer on the string to inspect.
* @param[in] _pos Iterator position on the string.
*/
Iterator(etk::String* _str, const etk::String::Iterator& _pos) :
m_value(u32char::Null),
m_data(_str),
m_current(0) {
if (m_data != nullptr) {
m_current = etk::distance(m_data->begin(), _pos);
}
};
/**
* @brief Basic position constructor link at the _pos position of the string
* @param[in] _str Pointer on the string to inspect.
* @param[in] _pos Position on the string (in AINSI value).
*/
Iterator(etk::String* _str, size_t _pos) :
m_value(u32char::Null),
m_data(_str),
m_current(0) {
if (m_data != nullptr) {
if (_pos > m_data->size()) {
m_current = m_data->size();
} else {
m_current = _pos;
}
}
};
/**
* @brief Recopy constructor.
* @param[in] _obj The Iterator that might be copy
*/
Iterator(const Iterator& _obj):
m_value(u32char::Null),
m_data(_obj.m_data),
m_current(_obj.m_current) {
// nothing to do ...
};
/**
* @brief Assignation operator.
* @param[in] _obj The Iterator that might be copy
* @return reference on the current Iterator
*/
Iterator& operator=(const Iterator & _obj) {
m_current = _obj.m_current;
m_data = _obj.m_data;
m_value = u32char::Null;
return *this;
};
/**
* @brief Basic destructor
*/
virtual ~Iterator() {
m_current = 0;
m_data = nullptr;
m_value = u32char::Null;
};
/**
* @brief basic boolean cast
* @return true if the element is present in buffer
*/
operator size_t () const {
if (m_data == nullptr) {
return 0;
}
if (m_current < 0) {
return 0;
}
if (m_current > (int64_t)m_data->size()) {
return m_data->size();
}
return (size_t)m_current;
};
/**
* @brief Incremental operator
* @return Reference on the current Iterator increment
*/
Iterator& operator++ ();
/**
* @brief Decremental operator
* @return Reference on the current Iterator decrement
*/
Iterator& operator-- ();
/**
* @brief Incremental operator
* @return Reference on a new Iterator and increment the other one
*/
Iterator operator++ (int32_t) {
Iterator it(*this);
++(*this);
return it;
};
/**
* @brief Decremental operator
* @return Reference on a new Iterator and decrement the other one
*/
Iterator operator-- (int32_t) {
Iterator it(*this);
--(*this);
return it;
};
/**
* @brief equality Iterator
* @param[in] _obj Iterator to compare
* @return true if the Iterator is identical pos
*/
bool operator== (const Iterator& _obj) const {
if ( m_current == _obj.m_current
&& m_data == _obj.m_data) {
return true;
}
return false;
};
/**
* @brief equality Iterator
* @param[in] _obj Iterator to compare
* @return true if the Iterator is identical pos
*/
bool operator!= (const Iterator& _obj) const {
if ( m_current != _obj.m_current
|| m_data != _obj.m_data) {
return true;
}
return false;
};
/**
* @brief <= Iterator
* @param[in] _obj Iterator to compare
* @return true if the Iterator is identical pos
*/
bool operator<= (const Iterator& _obj) const {
if (m_data != _obj.m_data) {
return false;
}
if (m_current <= _obj.m_current) {
return true;
}
return false;
};
/**
* @brief >= Iterator
* @param[in] _obj Iterator to compare
* @return true if the Iterator is identical pos
*/
bool operator>= (const Iterator& _obj) const {
if (m_data != _obj.m_data) {
return false;
}
if (m_current >= _obj.m_current) {
return true;
}
return false;
};
/**
* @brief < Iterator
* @param[in] _obj Iterator to compare
* @return true if the Iterator is identical pos
*/
bool operator< (const Iterator& _obj) const {
if (m_data != _obj.m_data) {
return false;
}
if (m_current < _obj.m_current) {
return true;
}
return false;
};
/**
* @brief > Iterator
* @param[in] _obj Iterator to compare
* @return true if the Iterator is identical pos
*/
bool operator> (const Iterator& _obj) const {
if (m_data != _obj.m_data) {
return false;
}
if (m_current > _obj.m_current) {
return true;
}
return false;
};
/**
* @brief Get the value on the current element
* @return The request element value
*/
char32_t operator* ();
/**
* @brief Get the position in the buffer
* @return The requested position.
*/
size_t getPos() const {
if (m_data == nullptr) {
return 0;
}
if (m_current < 0) {
return 0;
}
if (m_current >= (int64_t)m_data->size()) {
return m_data->size()-1;
}
return (size_t)m_current;
};
/**
* @brief move the element position
* @param[in] _val Value to add on the Iterator
* @return a new Iterator.
*/
Iterator operator+ (const int64_t _val) const {
Iterator tmp(*this);
for (int64_t iii=0; iii<_val; ++iii) {
++tmp;
}
return tmp;
};
/**
* @copydoc utf8::Iterator::operator+ (const int64_t)
*/
Iterator operator+ (const int32_t _val) const {
Iterator tmp(*this);
for (int64_t iii=0; iii<_val; ++iii) {
++tmp;
}
return tmp;
}
/**
* @copydoc utf8::Iterator::operator+ (const int64_t)
*/
Iterator operator+ (const size_t _val) const {
Iterator tmp(*this);
for (int64_t iii=0; iii<(int64_t)_val; ++iii) {
++tmp;
}
return tmp;
}
/**
* @brief move the element position
* @param[in] _val Value to remove on the Iterator
* @return a new Iterator.
*/
Iterator operator- (const int64_t _val) const {
Iterator tmp(*this);
for (int64_t iii=0; iii<_val; ++iii) {
--tmp;
}
return tmp;
}
/**
* @copydoc utf8::Iterator::operator- (const int64_t)
*/
Iterator operator- (const int32_t _val) const {
Iterator tmp(*this);
for (int64_t iii=0; iii<_val; ++iii) {
--tmp;
}
return tmp;
}
/**
* @copydoc utf8::Iterator::operator- (const int64_t)
*/
Iterator operator- (const size_t _val) const {
Iterator tmp(*this);
for (int64_t iii=0; iii<(int64_t)_val; ++iii) {
--tmp;
}
return tmp;
}
/*
Iterator begin() const {
return Iterator(m_data);
}
Iterator end() const {
return --Iterator(m_data, m_data.end());
}
*/
};
}
/**
* @brief Calculate the size of a string (unicode)
* @param[in] _data Data to parse to find the end of string
* @return The Number of char32_t before the '\\0' value
*/
int32_t strlen(const char32_t* _data);

4
lutin_etk.py
View File

@ -30,6 +30,8 @@ def configure(target, my_module):
my_module.add_src_file([
'etk/debug.cpp',
'etk/String.cpp',
'etk/UString.cpp',
'etk/utf8.cpp',
'etk/etk.cpp',
'etk/stdTools.cpp',
'etk/tool.cpp',
@ -62,6 +64,8 @@ def configure(target, my_module):
'etk/Buffer.hpp',
'etk/Hash.hpp',
'etk/String.hpp',
'etk/UString.hpp',
'etk/utf8.hpp',
'etk/Vector.hpp',
'etk/math/Matrix2x2.hpp',
'etk/math/Matrix2x3.hpp',

18
test/testHash.cpp
View File

@ -13,12 +13,12 @@
#define NAME "Hash"
TEST(TestEtkHash, Creation) {
etk::Hash<std::string> testData;
etk::Hash<etk::String> testData;
EXPECT_EQ(testData.size(), 0);
}
TEST(TestEtkHash, AddElement) {
etk::Hash<std::string> testData;
etk::Hash<etk::String> testData;
testData.add("TEST", "testData");
testData.add("TEST2", "22222222222222222");
testData.add("TEST4", "4444444444444444444");
@ -31,7 +31,7 @@ TEST(TestEtkHash, AddElement) {
}
TEST(TestEtkHash, OverWriteElement) {
etk::Hash<std::string> testData;
etk::Hash<etk::String> testData;
testData.add("TEST", "testData");
testData.add("TEST2", "22222222222222222");
testData.add("TEST4", "4444444444444444444");
@ -45,7 +45,7 @@ TEST(TestEtkHash, OverWriteElement) {
}
TEST(TestEtkHash, RemoveElement) {
etk::Hash<std::string> testData;
etk::Hash<etk::String> testData;
testData.add("TEST", "testData");
testData.add("TEST2", "22222222222222222");
testData.add("TEST4", "4444444444444444444");
@ -58,7 +58,7 @@ TEST(TestEtkHash, RemoveElement) {
}
TEST(TestEtkHash, ExistElement) {
etk::Hash<std::string> testData;
etk::Hash<etk::String> testData;
testData.add("TEST", "testData");
testData.add("TEST2", "22222222222222222");
EXPECT_EQ(testData.exist("TEST"), true);
@ -66,7 +66,7 @@ TEST(TestEtkHash, ExistElement) {
}
TEST(TestEtkHash, clear) {
etk::Hash<std::string> testData;
etk::Hash<etk::String> testData;
testData.add("TEST", "1");
testData.add("TEST2", "2");
EXPECT_EQ(testData.size(), 2);
@ -75,7 +75,7 @@ TEST(TestEtkHash, clear) {
}
TEST(TestEtkHash, getKey) {
etk::Hash<std::string> testData;
etk::Hash<etk::String> testData;
testData.add("TEST", "1");
testData.add("TEST2", "2");
testData.add("TEST3", "3");
@ -83,11 +83,11 @@ TEST(TestEtkHash, getKey) {
}
TEST(TestEtkHash, getKeys) {
etk::Hash<std::string> testData;
etk::Hash<etk::String> testData;
testData.add("TEST", "1");
testData.add("TEST2", "2");
testData.add("TEST3", "3");
std::vector<std::string> list = testData.getKeys();
etk::Vector<etk::String> list = testData.getKeys();
EXPECT_EQ(list.size(), 3);
EXPECT_EQ(list[0], "TEST");
EXPECT_EQ(list[1], "TEST2");