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

[DEV] continue reviewing strings

Browse Source
This commit is contained in:
Edouard DUPIN 2017-08-25 22:45:09 +02:00
parent 7ac3ef06c4
commit 40a9aaba66
6 changed files with 429 additions and 191 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

305
etk/Number.cpp Normal file
View File

@ -0,0 +1,305 @@
/**
* @author Edouard DUPIN
*
* @copyright 2011, Edouard DUPIN, all right reserved
*
* @license MPL v2.0 (see license file)
*/
#include <etk/Number.hpp>
etk::Number::Number() :
m_negative(false),
m_unit(0),
m_lessZero(0),
m_numberLessZero(0),
m_exponent(0) {
}
etk::Number::Number(int8_t _value) :
m_negative(false),
m_unit(_value),
m_lessZero(0),
m_numberLessZero(0),
m_exponent(0) {
}
etk::Number::Number(int16_t _value) :
m_negative(false),
m_unit(_value),
m_lessZero(0),
m_numberLessZero(0),
m_exponent(0) {
}
etk::Number::Number(int32_t _value) :
m_negative(false),
m_unit(_value),
m_lessZero(0),
m_numberLessZero(0),
m_exponent(0) {
}
etk::Number::Number(int64_t _value) :
m_negative(false),
m_unit(_value),
m_lessZero(0),
m_numberLessZero(0),
m_exponent(0) {
}
etk::Number::Number(uint8_t _value) :
m_negative(false),
m_unit(_value),
m_lessZero(0),
m_numberLessZero(0),
m_exponent(0) {
}
etk::Number::Number(uint16_t _value) :
m_negative(false),
m_unit(_value),
m_lessZero(0),
m_numberLessZero(0),
m_exponent(0) {
}
etk::Number::Number(uint32_t _value) :
m_negative(false),
m_unit(_value),
m_lessZero(0),
m_numberLessZero(0),
m_exponent(0) {
}
etk::Number::Number(uint64_t _value) :
m_negative(false),
m_unit(_value),
m_lessZero(0),
m_numberLessZero(0),
m_exponent(0) {
}
etk::Number::Number(float _value) :
m_negative(false),
m_unit(0),
m_lessZero(0),
m_numberLessZero(0),
m_exponent(0) {
m_unit(_value);
_value -= int64_t(_value);
_value *= 10.0;
for (size_t iii=0; iii<64; ++iii) {
if (_value == 0.0) {
return;
}
uint64_t val = _value;
_value = (_value - val) * 10.0;
m_lessZero *= 10;
m_lessZero += val;
m_numberLessZero++;
}
}
etk::Number::Number(double _value) :
m_negative(false),
m_unit(0),
m_lessZero(0),
m_numberLessZero(0),
m_exponent(0) {
m_unit(_value);
_value -= int64_t(_value);
_value *= 10.0;
for (size_t iii=0; iii<64; ++iii) {
if (_value == 0.0) {
return;
}
uint64_t val = _value;
_value = (_value - val) * 10.0;
m_lessZero *= 10;
m_lessZero += val;
m_numberLessZero++;
}
}
etk::Number::Number(long double _value) :
m_negative(false),
m_unit(0),
m_lessZero(0),
m_numberLessZero(0),
m_exponent(0) {
m_unit(_value);
_value -= int64_t(_value);
_value *= 10.0;
for (size_t iii=0; iii<64; ++iii) {
if (_value == 0.0) {
return;
}
uint64_t val = _value;
_value = (_value - val) * 10.0;
m_lessZero *= 10;
m_lessZero += val;
m_numberLessZero++;
}
}
etk::Number::Number(bool _value) :
m_negative(false),
m_unit(_value),
m_lessZero(0),
m_numberLessZero(0),
m_exponent(0) {
}
etk::Number::Number(const etk::UString& _value) :
m_negative(false),
m_unit(0),
m_lessZero(0),
m_numberLessZero(0),
m_exponent(0) {
parse(_value);
}
void etk::Number::clear() {
m_negative = false;
m_unit = 0;
m_lessZero = 0;
m_exponent = 0;
}
bool etk::Number::isDigit(char32_t _value, enum etk::Number::type _type) {
if (_type == type::numberBinary) {
if ( _value == '0'
|| _value == '1') {
return false;
}
return false;
} else if (_type == type::numberHexadecimal) {
if ( _value >= 'A'
&& _value <= 'F') {
return true;
}
if ( _value >= 'a'
&& _value <= 'f') {
return true;
}
}
if ( _value >= '0'
&& _value <= '9') {
return true;
}
return false;
}
bool etk::Number::parse(const etk::UString& _value) {
enum type section = type::numberDecimal;
for (size_t iii=0; iii<_value.size(); ++iii) {
if ( iii == 0
&& _value[iii] == '+') {
// noting to do ==> already positive value
continue;
}
if ( iii == 0
&& _value[iii] == '-') {
m_negative = true;
continue;
}
if ( iii == 1
&& _value[0] == '0'
&& ( _value[1] == 'x'
|| _value[1] == 'X')) {
section = type::numberHexadecimal;
continue;
}
if ( iii == 1
&& _value[0] == '0'
&& ( _value[1] == 'b'
|| _value[1] == 'B')) {
section = type::numberBinary;
continue;
}
if (_value[iii] == '.') {
if (section == type::numberDecimal) {
section = type::numberLessZero;
continue;
}
TK_ERROR("Can not parse the Number '" << _value << "':" << iii << " '.' can not parse");
return false;
}
if (_value[iii] == 'e') {
if ( section == type::numberDecimal
|| section == type::numberLessZero) {
section = type::numberExponent;
continue;
}
TK_ERROR("Can not parse the Number '" << _value << "':" << iii << " 'e' ==> can not parse ...");
return false;
}
if (isDigit(_value[iii], section) == true) {
// TODO: Check too big number
if (section == type::numberDecimal) {
m_unit = (m_unit*10) + (_value[iii]-'0');
} else if (section == type::numberBinary) {
m_unit = (m_unit<<1) + (_value[iii]-'0');
} else if (section == type::numberHexadecimal) {
if (_value[iii] <= 'F') {
m_unit = (m_unit*16) + (_value[iii]-'A' + 10);
} else if (_value[iii] <= 'f') {
m_unit = (m_unit*16) + (_value[iii]-'a' + 10);
} else {
m_unit = (m_unit*16) + (_value[iii]-'0');
}
} else if (section == type::numberLessZero) {
m_lessZero = (m_lessZero*10) + (_value[iii]-'0');
m_numberLessZero++;
} else {
m_exponent = (m_exponent*10) + (_value[iii]-'0');
}
} else {
return false;
}
}
return false;
}
long double etk::Number::getDouble() {
long double out = 0;
out = m_lessZero;
out *= pow(10,-m_numberLessZero);
out += m_unit;
out *= pow(10,m_exponent);
if (m_negative == true) {
out *= -1.0;
}
return -1;
}
uint64_t etk::Number::getU64() {
uint64_t out = 0;
if (m_exponent != 0) {
// Auto manage exponent
long double tmp = getDouble();
if (tmp <= 0.0) {
return 0;
}
return uint64_t(tmp);
}
out += m_unit;
if (m_negative == true) {
return 0;
}
return out;
}
int64_t etk::Number::getI64() {
int64_t out = 0;
if (m_exponent != 0) {
// Auto manage exponent
long double tmp = getDouble();
if (tmp <= 0.0) {
return 0;
}
return int64_t(tmp);
}
out += m_unit;
if (m_negative == true) {
out *= -1.0;
}
return out;
}

67
etk/Number.hpp Normal file
View File

@ -0,0 +1,67 @@
/**
* @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/UString.hpp>
namespace etk {
struct Number {
protected:
bool m_negative;
uint64_t m_unit;
uint64_t m_lessZero;
uint64_t m_numberLessZero;
uint32_t m_exponent;
public:
enum class type {
numberDecimal,
numberBinary,
numberHexadecimal,
numberLessZero,
numberExponent,
};
Number();
Number(int8_t _value);
Number(int16_t _value);
Number(int32_t _value);
Number(int64_t _value);
Number(uint8_t _value);
Number(uint16_t _value);
Number(uint32_t _value);
Number(uint64_t _value);
Number(float _value);
Number(double _value);
Number(long double _value);
Number(bool _value);
Number(const etk::UString& _value);
void clear();
bool isDigit(char32_t _value, enum type _type);
// Format:
// 51651
// -455465
// +54654
// 51651.545
// -455465.4845
// +54654.485424
// 51651e12
// -455465e12
// +54654e12
// 51651.545e12
// -455465.4845e12
// +54654.485424e12
// 0x123456789ABCDEF
// 0b10101110101010
bool parse(const etk::UString& _value);
long double getDouble();
uint64_t getU64();
int64_t getI64();
};
}

240
etk/UString.cpp
View File

@ -1,6 +1,7 @@
#include <etk/UString.hpp> #include <etk/UString.hpp>
#include <etk/Number.hpp>
etk::UString::UString(): etk::UString::UString():
m_data() { m_data() {
@ -456,182 +457,70 @@ bool etk::UString::startWith(const etk::UString& _val, bool _caseSensitive) cons
return true; return true;
} }
struct Number {
public:
bool m_negative;
uint64_t m_unit;
uint64_t m_lessZero;
uint32_t m_exponent;
Number() :
m_negative(false),
m_unit(0),
m_lessZero(0),
m_exponent(0) {
}
void clear() {
m_negative = false;
m_unit = 0;
m_lessZero = 0;
m_exponent = 0;
}
bool isDigit(char32_t _value) {
if (_value < '0') {
return false;
}
if (_value > '9') {
return false;
}
return true;
}
// Format:
// 51651
// -455465
// +54654
// 51651.545
// -455465.4845
// +54654.485424
// 51651e12
// -455465e12
// +54654e12
// 51651.545e12
// -455465.4845e12
// +54654.485424e12
// 0x123456789ABCDEF
bool parse(const etk::UString& _value) {
int8_t section = 0;
for (size_t iii=0; iii<_value.size(); ++iii) {
if ( iii == 0
&& _value[iii] == "+") {
// noting to do ==> already positive value
continue;
}
if ( iii == 0
&& _value[iii] == "-") {
m_negative = true;
continue;
}
if (_value[iii] == ".") {
if (section == 0) {
section = 1;
continue;
}
TK_ERROR("Can not parse the Number '" << _value << "':" << iii << " '.' can not parse");
return false;
}
if (_value[iii] == "e") {
if ( section == 0
|| section == 1) {
section = 2;
continue;
}
TK_ERROR("Can not parse the Number '" << _value << "':" << iii << " 'e' ==> can not parse ...");
return false;
}
if (isDigit(_value[iii]) == true) {
// TODO: Check too big number
if (section == 0) {
m_unit = m_unit*10 + (_value[iii]-'0');
} else if (section == 0) {
m_lessZero = m_lessZero*10 + (_value[iii]-'0');
} else {
m_exponent = m_exponent*10 + (_value[iii]-'0');
}
}
}
return false;
}
};
template <> template <>
long double etk::UString::to<long double>() const { long double etk::UString::to<long double>() const {
long double ret = 0; etk::Number value(*this);
sscanf(c_str(), "%Lf", &ret); return value.getDouble();
return ret;
} }
template <> template <>
double etk::UString::to<double>() const { double etk::UString::to<double>() const {
double ret = 0; etk::Number value(*this);
sscanf(c_str(), "%lf", &ret); return value.getDouble();
return ret;
} }
template <> template <>
float etk::UString::to<float>() const { float etk::UString::to<float>() const {
float ret = 0; etk::Number value(*this);
sscanf(c_str(), "%f", &ret); return value.getDouble();
return ret;
} }
template <> template <>
int8_t etk::UString::to<int8_t>() const { int8_t etk::UString::to<int8_t>() const {
int ret = 0; etk::Number value(*this);
sscanf(c_str(), "%d", &ret); return value.getI64();
return ret;
} }
template <> template <>
int16_t etk::UString::to<int16_t>() const { int16_t etk::UString::to<int16_t>() const {
int ret = 0; etk::Number value(*this);
sscanf(c_str(), "%d", &ret); return value.getI64();
return ret;
} }
template <> template <>
int32_t etk::UString::to<int32_t>() const { int32_t etk::UString::to<int32_t>() const {
int ret = 0; etk::Number value(*this);
sscanf(c_str(), "%d", &ret); return value.getI64();
return ret;
} }
template <> template <>
int64_t etk::UString::to<int64_t>() const { int64_t etk::UString::to<int64_t>() const {
int64_t ret = 0; etk::Number value(*this);
#if ( defined(__TARGET_OS__Android) \ return value.getI64();
|| defined(__TARGET_OS__Windows) \
|| defined(__TARGET_OS__MacOs) \
|| defined(__TARGET_OS__IOs))
sscanf(c_str(), "%lld", &ret);
#else
sscanf(c_str(), "%ld", &ret);
#endif
return ret;
} }
template <> template <>
uint8_t etk::UString::to<uint8_t>() const { uint8_t etk::UString::to<uint8_t>() const {
int ret = 0; etk::Number value(*this);
sscanf(c_str(), "%d", &ret); return value.getU64();
return ret;
} }
template <> template <>
uint16_t etk::UString::to<uint16_t>() const { uint16_t etk::UString::to<uint16_t>() const {
int ret = 0; etk::Number value(*this);
sscanf(c_str(), "%d", &ret); return value.getU64();
return ret;
} }
template <> template <>
uint32_t etk::UString::to<uint32_t>() const { uint32_t etk::UString::to<uint32_t>() const {
int ret = 0; etk::Number value(*this);
sscanf(c_str(), "%d", &ret); return value.getU64();
return ret;
} }
template <> template <>
uint64_t etk::UString::to<uint64_t>() const { uint64_t etk::UString::to<uint64_t>() const {
uint64_t ret = 0; etk::Number value(*this);
#if ( defined(__TARGET_OS__Android) \ return value.getU64();
|| defined(__TARGET_OS__Windows) \
|| defined(__TARGET_OS__MacOs) \
|| defined(__TARGET_OS__IOs))
sscanf(c_str(), "%llu", &ret);
#else
sscanf(c_str(), "%lu", &ret);
#endif
return ret;
} }
template <> template <>
@ -740,84 +629,57 @@ namespace etk {
} }
template<> template<>
etk::UString etk::toString(const bool& _val) { etk::UString etk::toUString(const bool& _val) {
if (_val == true) { return utf8::convertUnicode(etk::toString(_val));
return "true";
}
return "false";
} }
template<> template<>
etk::UString etk::toString(const int8_t& _val) { etk::UString etk::toUString(const int8_t& _val) {
char32_t tmpVal[256]; return utf8::convertUnicode(etk::toString(_val));
sprintf(tmpVal, "%d", _val);
return tmpVal;
} }
template<> template<>
etk::UString etk::toString(const int16_t& _val) { etk::UString etk::toUString(const int16_t& _val) {
char32_t tmpVal[256]; return utf8::convertUnicode(etk::toString(_val));
sprintf(tmpVal, "%d", _val);
return tmpVal;
} }
template<> template<>
etk::UString etk::toString(const int32_t& _val) { etk::UString etk::toUString(const int32_t& _val) {
char32_t tmpVal[256]; return utf8::convertUnicode(etk::toString(_val));
sprintf(tmpVal, "%d", _val);
return tmpVal;
} }
template<> template<>
etk::UString etk::toString(const int64_t& _val) { etk::UString etk::toUString(const int64_t& _val) {
char32_t tmpVal[256]; return utf8::convertUnicode(etk::toString(_val));
sprintf(tmpVal, "%lld", _val);
return tmpVal;
} }
template<> template<>
etk::UString etk::toString(const uint8_t& _val) { etk::UString etk::toUString(const uint8_t& _val) {
char32_t tmpVal[256]; return utf8::convertUnicode(etk::toString(_val));
sprintf(tmpVal, "%u", _val);
return tmpVal;
} }
template<> template<>
etk::UString etk::toString(const uint16_t& _val) { etk::UString etk::toUString(const uint16_t& _val) {
char32_t tmpVal[256]; return utf8::convertUnicode(etk::toString(_val));
sprintf(tmpVal, "%u", _val);
return tmpVal;
} }
template<> template<>
etk::UString etk::toString(const uint32_t& _val) { etk::UString etk::toUString(const uint32_t& _val) {
char32_t tmpVal[256]; return utf8::convertUnicode(etk::toString(_val));
sprintf(tmpVal, "%u", _val);
return tmpVal;
} }
template<> template<>
etk::UString etk::toString(const uint64_t& _val) { etk::UString etk::toUString(const uint64_t& _val) {
char32_t tmpVal[256]; return utf8::convertUnicode(etk::toString(_val));
sprintf(tmpVal, "%llu", _val);
return tmpVal;
} }
template<> template<>
etk::UString etk::toString(const size_t& _val) { etk::UString etk::toUString(const size_t& _val) {
char32_t tmpVal[256]; return utf8::convertUnicode(etk::toString(_val));
sprintf(tmpVal, "%zu", _val);
return tmpVal;
} }
template<> template<>
etk::UString etk::toString(const float& _val) { etk::UString etk::toUString(const float& _val) {
char32_t tmpVal[256]; return utf8::convertUnicode(etk::toString(_val));
sprintf(tmpVal, "%f", _val);
return tmpVal;
} }
template<> template<>
etk::UString etk::toString(const double& _val) { etk::UString etk::toUString(const double& _val) {
char32_t tmpVal[256]; return utf8::convertUnicode(etk::toString(_val));
sprintf(tmpVal, "%f", _val);
return tmpVal;
} }
template<> template<>
etk::UString etk::toString(const long double& _val) { etk::UString etk::toUString(const long double& _val) {
char32_t tmpVal[256]; return utf8::convertUnicode(etk::toString(_val));
sprintf(tmpVal, "%Lf", _val);
return tmpVal;
} }
size_t etk::UString::find(char32_t _value, size_t _pos) const { size_t etk::UString::find(char32_t _value, size_t _pos) const {
@ -932,10 +794,10 @@ etk::UString etk::UString::getLine(int32_t _pos) const {
if (startPos == etk::UString::npos) { if (startPos == etk::UString::npos) {
startPos = 0; startPos = 0;
} else if (startPos >= size() ) { } else if (startPos >= size() ) {
return ""; return U"";
} }
if (stopPos == etk::UString::npos) { if (stopPos == etk::UString::npos) {
return ""; return U"";
} else if (stopPos >= size() ) { } else if (stopPos >= size() ) {
stopPos = size(); stopPos = size();
} }

5
etk/math/Vector2D.hpp
View File

@ -7,6 +7,7 @@
#include <etk/math/Vector3D.hpp> #include <etk/math/Vector3D.hpp>
#include <etk/types.hpp> #include <etk/types.hpp>
#include <etk/String.hpp> #include <etk/String.hpp>
#include <etk/UString.hpp>
#pragma once #pragma once
@ -71,7 +72,7 @@ namespace etk {
*/ */
Vector2D(const etk::String& _str); Vector2D(const etk::String& _str);
#if __CPP_VERSION__ >= 2011 #if __CPP_VERSION__ >= 2011
Vector2D(const std::u32string& _str); Vector2D(const etk::UString& _str);
#endif #endif
/** /**
* @brief Operator= Asign the current object with an other object * @brief Operator= Asign the current object with an other object
@ -552,7 +553,7 @@ namespace etk {
* @brief String caster of the object. * @brief String caster of the object.
* @return the Object cated in string (x.x,y.y) * @return the Object cated in string (x.x,y.y)
*/ */
operator std::u32string() const; operator etk::UString() const;
#endif #endif
}; };
//! @not_in_doc //! @not_in_doc

2
etk/math/Vector3D.hpp
View File

@ -6,6 +6,8 @@
#include <etk/types.hpp> #include <etk/types.hpp>
#include <etk/debug.hpp> #include <etk/debug.hpp>
#include <etk/UString.hpp>
#include <etk/String.hpp>
#pragma once #pragma once

1
etk/os/FSNodeRight.hpp
View File

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