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

[DEV] continue removing STL

Browse Source
This commit is contained in:
Edouard DUPIN 2017-09-14 00:59:21 +02:00
parent d8a6c0a9a9
commit ac23f7b934
29 changed files with 317 additions and 161 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
etk/Color.hpp
View File

@ -523,22 +523,18 @@ namespace etk {
//! @not_in_doc
template<int MY_TYPE_SIZE> etk::Stream& operator <<(etk::Stream& _os, const Color<uint8_t, MY_TYPE_SIZE>& _obj) { // RGB & RGBA 8 bits
// TODO: set it back !!!!
/*
std::ostringstream os;
if (MY_TYPE_SIZE >= 3) {
_os << "#";
os << std::setw(2) << std::setfill('0') << std::hex << uint32_t(_obj.r());
_os << etk::toHex(_obj.r());
if (MY_TYPE_SIZE >= 2) {
os << std::setw(2) << std::setfill('0') << std::hex << uint32_t(_obj.g());
_os << etk::toHex(_obj.g());
}
if (MY_TYPE_SIZE >= 3) {
os << std::setw(2) << std::setfill('0') << std::hex << uint32_t(_obj.b());
_os << etk::toHex(_obj.b());
}
if (MY_TYPE_SIZE >= 4) {
os << std::setw(2) << std::setfill('0') << std::hex << uint32_t(_obj.a());
_os << etk::toHex(_obj.a());
}
_os << os.str();
} else {
if (MY_TYPE_SIZE >= 2) {
_os << "be";
@ -546,14 +542,13 @@ namespace etk {
_os << "Mono";
}
_os << "[U8](";
os << "0x" << std::setw(2) << std::setfill('0') << std::hex << uint32_t(_obj.r());
_os << "0x" << etk::toHex(_obj.r());
if (MY_TYPE_SIZE >= 2) {
_os << ",";
os << "0x" << std::setw(2) << std::setfill('0') << std::hex << uint32_t(_obj.g());
_os << "0x" << etk::toHex(_obj.g());
}
_os << os.str();
_os << ")";
}*/
}
return _os;
}
//! @not_in_doc
@ -568,25 +563,20 @@ namespace etk {
_os << "Mono";
}
_os << "[U16](";
// TODO: set it back !!!!
/*
os << "0x" << std::setw(4) << std::setfill('0') << std::hex << _obj.r();
_os << "0x" << etk::toHex(_obj.r(), 4);
if (MY_TYPE_SIZE >= 2) {
os << ",0x" << std::setw(4) << std::setfill('0') << std::hex << _obj.g();
_os << ",0x" << etk::toHex(_obj.g(), 4);
}
if (MY_TYPE_SIZE >= 3) {
os << ",0x" << std::setw(4) << std::setfill('0') << std::hex << _obj.b();
_os << ",0x" << etk::toHex(_obj.b(), 4);
}
if (MY_TYPE_SIZE >= 4) {
os << ",0x" << std::setw(4) << std::setfill('0') << std::hex << _obj.a();
_os << ",0x" << etk::toHex(_obj.a(), 4);
}
_os << os.str() << ")";
*/
return _os;
}
//! @not_in_doc
template<int MY_TYPE_SIZE> etk::Stream& operator <<(etk::Stream& _os, const Color<uint32_t, MY_TYPE_SIZE>& _obj) { // RGB & RGBA 8 bits
//std::ostringstream os;
if (MY_TYPE_SIZE >= 4) {
_os << "rgba";
} else if (MY_TYPE_SIZE >= 3) {
@ -597,20 +587,16 @@ namespace etk {
_os << "Mono";
}
_os << "[U32](";
// TODO: set it back !!!!
/*
os << "0x" << std::setw(8) << std::setfill('0') << std::hex << _obj.r();
_os << "0x" << etk::toHex(_obj.r(), 8);
if (MY_TYPE_SIZE >= 2) {
os << ",0x" << std::setw(8) << std::setfill('0') << std::hex << _obj.g();
_os << ",0x" << etk::toHex(_obj.g(), 8);
}
if (MY_TYPE_SIZE >= 3) {
os << ",0x" << std::setw(8) << std::setfill('0') << std::hex << _obj.b();
_os << ",0x" << etk::toHex(_obj.b(), 8);
}
if (MY_TYPE_SIZE >= 4) {
os << ",0x" << std::setw(8) << std::setfill('0') << std::hex << _obj.a();
_os << ",0x" << etk::toHex(_obj.a(), 8);
}
_os << os.str() << ")";
*/
return _os;
}
//! @not_in_doc

9
etk/Function.cpp
View File

@ -0,0 +1,9 @@
/** @file
* @author Edouard DUPIN
* @copyright 2011, Edouard DUPIN, all right reserved
* @license MPL v2.0 (see license file)
*/
#include <etk/Function.hpp>
uint32_t etk::MM___pppppp = 0;

2
etk/Map.hpp
View File

@ -19,8 +19,6 @@ namespace etk {
*
* @note The name is unique and the value is what you want
*
* @todo check if something else exist in the generic library. (not the etk::Map and the std::unordered_map
*
* @note The index are all time available since they are created. The order is the the one created
*
* A simple example of use:

10
etk/Noise.cpp
View File

@ -9,11 +9,11 @@
#include <etk/debug.hpp>
#include <etk/tool.hpp>
#include <etk/Noise.hpp>
// for the rand ...
#include <time.h>
#include <cmath>
#include <cstdlib>
extern "C" {
#include <time.h>
#include <math.h>
#include <stdlib.h>
}
etk::BaseNoise::BaseNoise(const ivec2& _size, float _min, float _max) :
m_data(_size.x()*_size.y()),

19
etk/Stream.hpp
View File

@ -14,7 +14,7 @@ namespace etk {
*/
class Stream {
private:
// remove dependency of std::string and vector
// remove dependency of etk::String and vector
etk::String* m_data;
public:
Stream(size_t _basicSize=0);
@ -40,21 +40,6 @@ namespace etk {
const etk::String& str() const;
const size_t size() const;
};
// TODO: This is not a good place ...
/*
//! @not_in_doc
template<class ETK_VECTOR_TYPE>
etk::Stream& operator <<(etk::Stream& _os, const etk::Vector<ETK_VECTOR_TYPE>& _obj) {
_os << "{";
for (size_t iii=0; iii< _obj.size(); iii++) {
if (iii>0) {
_os << ";";
}
_os << _obj[iii];
}
_os << "}";
return _os;
}
*/
}

46
etk/String.cpp
View File

@ -41,7 +41,7 @@ etk::String::String(const char* _obj) {
}
}
/*
etk::String::String(const std::string _obj) {
etk::String::String(const etk::String _obj) {
resize(_obj.size());
for (size_t iii=0; iii<_obj.size(); ++iii) {
m_data[iii] = _obj[iii];
@ -1124,3 +1124,47 @@ etk::String etk::operator+ (char _left, const etk::String& _right) {
}
namespace etk {
template<> etk::String toString<etk::String>(const etk::String& _val) {
return _val;
}
template<> bool from_string<etk::String>(etk::String& _variableRet, const etk::UString& _value) {
_variableRet = u32char::convertToUtf8(_value);
return true;
}
}
char etk::toHexChar(uint8_t _value) {
char out;
if (_value < 10) {
return _value + '0';
}
return _value - 10 + 'A';
}
etk::String etk::toHex(uint64_t _value, uint32_t _size) {
etk::String out;
for (int32_t iii = 15; iii >=0; --iii) {
if ( _size >= iii
|| _value >= uint64_t(1)<<iii) {
out += etk::toHexChar((_value>>(iii*4)) & 0x0F);
}
}
return out;
}
etk::String etk::toBin(uint64_t _value, uint32_t _size) {
etk::String out;
for (int32_t iii = 63; iii >=0; --iii) {
if ( _size >= iii
|| _value >= uint64_t(1)<<iii) {
out += etk::toHexChar((_value>>(iii)) & 0x01);
}
}
return out;
}

6
etk/String.hpp
View File

@ -225,7 +225,7 @@ namespace etk {
*/
String(const char* _obj);
// TODO : remove this when ready
//////// String(const std::string _obj);
//////// String(const etk::String _obj);
/**
* @brief Partial copy of the null-terminated C string.
* @param[in] _obj String that might be copyC string that might be copy (end by '\0')
@ -574,4 +574,8 @@ namespace etk {
out += "}";
return out;
}
char toHexChar(uint8_t _value);
etk::String toHex(uint64_t _value, uint32_t _size = 2);
etk::String toBin(uint64_t _value, uint32_t _size = 1);
}

13
etk/UString.cpp
View File

@ -991,3 +991,16 @@ etk::UString etk::operator+ (char32_t _left, const etk::UString& _right) {
}
namespace etk {
/*
template<> etk::UString toString<etk::UString>(const etk::UString& _val) {
return _val;
}
*/
template<> bool from_string<etk::UString>(etk::UString& _variableRet, const etk::String& _value) {
_variableRet = utf8::convertUnicode(_value);
return true;
}
}

51
etk/Vector.hpp
View File

@ -223,6 +223,17 @@ namespace etk {
changeAllocation(_count);
m_size = _count;
}
/**
* @brief List initializer (ex: etk::Vector<etk::String> plop = {"hello", world"}
* @param[in] _element element to add in the vector
*/
template<typename... ETK_VECTOR_TYPE_2>
Vector(const ETK_VECTOR_TYPE_2& ... _args):
m_data(nullptr),
m_size(0),
m_allocated(0) {
pushBackN(_args...);
}
/**
* @brief Re-copy constructor (copy all needed data)
* @param[in] _obj Vector that might be copy
@ -414,6 +425,19 @@ namespace etk {
void pushFront(const ETK_VECTOR_TYPE * _item, size_t _nbElement) {
insert(0, _item, _nbElement);
}
/**
* @brief Add at the Last position of the Vector (move push)
* @param[in] _item Element to add at the end of vector
*/
void pushBack(ETK_VECTOR_TYPE&& _item) {
size_t idElement = m_size;
resize(m_size+1);
if (idElement < m_size) {
m_data[idElement] = etk::move(_item);
} else {
//TK_ERROR("Resize does not work correctly ... not added item");
}
}
/**
* @brief Add at the Last position of the Vector
* @param[in] _item Element to add at the end of vector
@ -446,6 +470,14 @@ namespace etk {
m_data[idElement+iii] = _item[iii];
}
}
void pushBackN(const ETK_VECTOR_TYPE& _value) {
pushBack(_value);
}
template<typename... ETK_VECTOR_TYPE_2>
void pushBackN(const ETK_VECTOR_TYPE& _value, const ETK_VECTOR_TYPE_2& ... _args) {
pushBack(_value);
pushBackN(_args...);
}
/**
* @brief Remove the first element of the vector
*/
@ -809,8 +841,8 @@ namespace etk {
}
};
//! @not_in_doc
template<typename T, typename T2>
bool isIn(const T& _val, const etk::Vector<T2>& _list) {
template<typename ETK_VECTOR_TYPE_1, typename ETK_VECTOR_TYPE_2>
bool isIn(const ETK_VECTOR_TYPE_1& _val, const etk::Vector<ETK_VECTOR_TYPE_2>& _list) {
for (size_t iii=0; iii<_list.size(); ++iii) {
if (_list[iii] == _val) {
return true;
@ -818,4 +850,19 @@ namespace etk {
}
return false;
}
class Stream;
//! @not_in_doc
template<class ETK_VECTOR_TYPE>
etk::Stream& operator <<(etk::Stream& _os, const etk::Vector<ETK_VECTOR_TYPE>& _obj) {
_os << "{";
for (size_t iii=0; iii< _obj.size(); iii++) {
if (iii>0) {
_os << ";";
}
_os << _obj[iii];
}
_os << "}";
return _os;
}
}

3
etk/etk.cpp
View File

@ -10,10 +10,9 @@
#include <etk/debug.hpp>
#include <elog/elog.hpp>
#include <etk/os/FSNode.hpp>
#include <etk/Function.hpp>
static int32_t nbTimeInit = 0;
uint32_t etk::MM___pppppp = 0;
void etk::unInit() {
if (nbTimeInit > 1) {
nbTimeInit--;

2
etk/math/Matrix.hpp
View File

@ -534,7 +534,7 @@ namespace etk {
*/
void identity() {
// copy data for the same size :
for (int32_t iii=0; iii< std::mim(m_size.x(), m_size.y()); iii++) {
for (int32_t iii=0; iii< etk::mim(m_size.x(), m_size.y()); iii++) {
(*this)(iii,iii) = (T)1;
}
};

14
etk/math/Matrix2x2.cpp
View File

@ -192,14 +192,14 @@ etk::Matrix2x2 etk::Matrix2x2::zero() {
}
etk::Matrix2x2 etk::Matrix2x2::getAbsolute() const {
return Matrix2x2(std::abs(m_mat[0]), std::abs(m_mat[1]),
std::abs(m_mat[2]), std::abs(m_mat[3]));
return Matrix2x2(etk::abs(m_mat[0]), etk::abs(m_mat[1]),
etk::abs(m_mat[2]), etk::abs(m_mat[3]));
}
void etk::Matrix2x2::absolute() {
m_mat[0] = std::abs(m_mat[0]);
m_mat[1] = std::abs(m_mat[1]);
m_mat[2] = std::abs(m_mat[2]);
m_mat[3] = std::abs(m_mat[3]);
m_mat[0] = etk::abs(m_mat[0]);
m_mat[1] = etk::abs(m_mat[1]);
m_mat[2] = etk::abs(m_mat[2]);
m_mat[3] = etk::abs(m_mat[3]);
}
void etk::Matrix2x2::inverse() {
@ -208,7 +208,7 @@ void etk::Matrix2x2::inverse() {
etk::Matrix2x2 etk::Matrix2x2::getInverse() const {
float det = determinant();
//assert(std::abs(det) > MACHINE_EPSILON);
//assert(etk::abs(det) > MACHINE_EPSILON);
float invDet = 1.0f / det;
return etk::Matrix2x2(m_mat[3], -m_mat[1], -m_mat[2], m_mat[0]) * invDet;
}

26
etk/math/Matrix3x3.cpp
View File

@ -146,21 +146,21 @@ etk::Matrix3x3 etk::Matrix3x3::zero() {
}
void etk::Matrix3x3::absolute() {
m_mat[0] = std::abs(m_mat[0]);
m_mat[1] = std::abs(m_mat[1]);
m_mat[2] = std::abs(m_mat[2]);
m_mat[3] = std::abs(m_mat[3]);
m_mat[4] = std::abs(m_mat[4]);
m_mat[5] = std::abs(m_mat[5]);
m_mat[6] = std::abs(m_mat[6]);
m_mat[7] = std::abs(m_mat[7]);
m_mat[8] = std::abs(m_mat[8]);
m_mat[0] = etk::abs(m_mat[0]);
m_mat[1] = etk::abs(m_mat[1]);
m_mat[2] = etk::abs(m_mat[2]);
m_mat[3] = etk::abs(m_mat[3]);
m_mat[4] = etk::abs(m_mat[4]);
m_mat[5] = etk::abs(m_mat[5]);
m_mat[6] = etk::abs(m_mat[6]);
m_mat[7] = etk::abs(m_mat[7]);
m_mat[8] = etk::abs(m_mat[8]);
}
etk::Matrix3x3 etk::Matrix3x3::getAbsolute() const {
return etk::Matrix3x3(std::abs(m_mat[0]), std::abs(m_mat[1]), std::abs(m_mat[2]),
std::abs(m_mat[3]), std::abs(m_mat[4]), std::abs(m_mat[5]),
std::abs(m_mat[6]), std::abs(m_mat[7]), std::abs(m_mat[8]));
return etk::Matrix3x3(etk::abs(m_mat[0]), etk::abs(m_mat[1]), etk::abs(m_mat[2]),
etk::abs(m_mat[3]), etk::abs(m_mat[4]), etk::abs(m_mat[5]),
etk::abs(m_mat[6]), etk::abs(m_mat[7]), etk::abs(m_mat[8]));
}
@ -272,7 +272,7 @@ void etk::Matrix3x3::inverse() {
etk::Matrix3x3 etk::Matrix3x3::getInverse() const {
float det = determinant();
//assert(std::abs(det) > MACHINE_EPSILON);
//assert(etk::abs(det) > MACHINE_EPSILON);
float invDet = 1.0f / det;
return etk::Matrix3x3( (m_mat[4]*m_mat[8]-m_mat[7]*m_mat[5]),
-(m_mat[1]*m_mat[8]-m_mat[7]*m_mat[2]),

2
etk/math/Matrix4x4.cpp
View File

@ -346,7 +346,7 @@ float etk::Matrix4x4::determinant() const {
etk::Matrix4x4 etk::Matrix4x4::invert() {
float det = determinant();
if(std::abs(det) < (1.0e-7f)) {
if(etk::abs(det) < (1.0e-7f)) {
// The matrix is not invertible! Singular case!
return *this;
}

12
etk/math/Quaternion.cpp
View File

@ -125,14 +125,14 @@ etk::Quaternion etk::Quaternion::slerp(const Quaternion& _obj1,
void etk::Quaternion::setEulerAngles(const vec3& _angles) {
float angle = _angles.x() * 0.5f;
float sinX = std::sin(angle);
float cosX = std::cos(angle);
float sinX = etk::sin(angle);
float cosX = etk::cos(angle);
angle = _angles.y() * 0.5f;
float sinY = std::sin(angle);
float cosY = std::cos(angle);
float sinY = etk::sin(angle);
float cosY = etk::cos(angle);
angle = _angles.z() * 0.5f;
float sinZ = std::sin(angle);
float cosZ = std::cos(angle);
float sinZ = etk::sin(angle);
float cosZ = etk::cos(angle);
float cosYcosZ = cosY * cosZ;
float sinYcosZ = sinY * cosZ;
float cosYsinZ = cosY * sinZ;

10
etk/math/Quaternion.hpp
View File

@ -188,7 +188,7 @@ namespace etk {
*/
float length() const {
#if __CPP_VERSION__ >= 2011 && !defined(__TARGET_OS__MacOs) && !defined(__TARGET_OS__IOs)
return std::sqrt(length2());
return etk::sqrt(length2());
#else
return sqrt(length2());
#endif
@ -270,10 +270,10 @@ namespace etk {
* @return New quaternion with the absolute value
*/
Quaternion absolute() const {
return Quaternion( std::abs(m_floats[0]),
std::abs(m_floats[1]),
std::abs(m_floats[2]),
std::abs(m_floats[3]));
return Quaternion( etk::abs(m_floats[0]),
etk::abs(m_floats[1]),
etk::abs(m_floats[2]),
etk::abs(m_floats[3]));
}
/**
* @brief Get X value

4
etk/math/Vector2D.cpp
View File

@ -87,8 +87,8 @@ etk::Stream& etk::operator <<(etk::Stream& _os, const etk::Vector<bvec2 >& _obj)
vec2 vec2rotate(const vec2& _val, const vec2& _point, float _angle) {
vec2 out = _val;
#if __CPP_VERSION__ >= 2011 && !defined(__STDCPP_LLVM__)
float sinAngle = std::sin(_angle);
float cosAngle = std::cos(_angle);
float sinAngle = etk::sin(_angle);
float cosAngle = etk::cos(_angle);
#else
float sinAngle = sin(_angle);
float cosAngle = cos(_angle);

6
etk/math/Vector2D.hpp
View File

@ -365,7 +365,7 @@ namespace etk {
*/
float length() const {
#if __CPP_VERSION__ >= 2011 && !defined(__STDCPP_LLVM__)
return std::sqrt(length2());
return etk::sqrt(length2());
#else
return sqrt(length2());
#endif
@ -421,8 +421,8 @@ namespace etk {
* @return New vector containing the value
*/
Vector2D<ETK_TYPE> absolute() const {
return Vector2D<ETK_TYPE>( std::abs(m_floats[0]),
std::abs(m_floats[1]));
return Vector2D<ETK_TYPE>( etk::abs(m_floats[0]),
etk::abs(m_floats[1]));
}
/**
* @brief Return the axis with the smallest value

16
etk/math/Vector3D.hpp
View File

@ -185,7 +185,7 @@ namespace etk {
*/
float length() const {
#if __CPP_VERSION__ >= 2011 && !defined(__STDCPP_LLVM__)
return std::sqrt(length2());
return etk::sqrt(length2());
#else
return sqrt(length2());
#endif
@ -274,9 +274,9 @@ namespace etk {
* @return New vector containing the value
*/
Vector3D<T> absolute() const {
return Vector3D<T>( std::abs(m_floats[0]),
std::abs(m_floats[1]),
std::abs(m_floats[2]));
return Vector3D<T>( etk::abs(m_floats[0]),
etk::abs(m_floats[1]),
etk::abs(m_floats[2]));
}
/**
* @brief Return the cross product between this and another vector
@ -567,16 +567,16 @@ namespace etk {
* @return The ortho vector
*/
Vector3D<T> getOrthoVector() const {
Vector3D<T> vectorAbs(std::abs(m_floats[0]), std::abs(m_floats[1]), std::abs(m_floats[2]));
Vector3D<T> vectorAbs(etk::abs(m_floats[0]), etk::abs(m_floats[1]), etk::abs(m_floats[2]));
int32_t minElement = vectorAbs.getMinAxis();
if (minElement == 0) {
float devider = 1.0f / std::sqrt(m_floats[1]*m_floats[1] + m_floats[2]*m_floats[2]);
float devider = 1.0f / etk::sqrt(m_floats[1]*m_floats[1] + m_floats[2]*m_floats[2]);
return Vector3D<T>(0.0f, -m_floats[2]*devider, m_floats[1]*devider);
} else if (minElement == 1) {
float devider = 1.0f / std::sqrt(m_floats[0]*m_floats[0] + m_floats[2]*m_floats[2]);
float devider = 1.0f / etk::sqrt(m_floats[0]*m_floats[0] + m_floats[2]*m_floats[2]);
return Vector3D<T>(-m_floats[2]*devider, 0.0f, m_floats[0]*devider);
}
float devider = 1.0f / std::sqrt(m_floats[0]*m_floats[0] + m_floats[1]*m_floats[1]);
float devider = 1.0f / etk::sqrt(m_floats[0]*m_floats[0] + m_floats[1]*m_floats[1]);
return Vector3D<T>(-m_floats[1]*devider, m_floats[0]*devider, 0.0f);
}

10
etk/math/Vector4D.hpp
View File

@ -178,7 +178,7 @@ namespace etk {
return btSqrt(length2());
#else
#if __CPP_VERSION__ >= 2011 && !defined(__TARGET_OS__MacOs) && !defined(__TARGET_OS__IOs)
return std::sqrt(length2());
return etk::sqrt(length2());
#else
return sqrt(length2());
#endif
@ -221,10 +221,10 @@ namespace etk {
* @return New vector with the absolute value
*/
Vector4D<T> absolute() const {
return Vector4D<T>( std::abs(m_floats[0]),
std::abs(m_floats[1]),
std::abs(m_floats[2]),
std::abs(m_floats[3]));
return Vector4D<T>( etk::abs(m_floats[0]),
etk::abs(m_floats[1]),
etk::abs(m_floats[2]),
etk::abs(m_floats[3]));
}
/**
* @brief Multiply this vector by the other.

16
etk/move.hpp
View File

@ -6,7 +6,6 @@
#pragma once
#include <etk/typeTrait.hpp>
#include <utility>
namespace etk {
template<class ETK_MOVE_TYPE>
struct RemoveReference {
@ -23,20 +22,11 @@ namespace etk {
// remove rvalue reference
typedef ETK_MOVE_TYPE m_type;
};
#if 0
template<class ETK_MOVE_TYPE> inline
typename etk::RemoveReference<ETK_MOVE_TYPE>::m_type&& move(ETK_MOVE_TYPE&& _obj) {
template<typename ETK_MOVE_TYPE>
inline typename etk::RemoveReference<ETK_MOVE_TYPE>::m_type&& move(ETK_MOVE_TYPE&& _obj) {
// forward _Arg as movable
return ((typename etk::RemoveReference<ETK_MOVE_TYPE>::m_type&&)_obj);
return (typename etk::RemoveReference<ETK_MOVE_TYPE>::m_type&&)_obj;
}
#else
template<class ETK_MOVE_TYPE> inline
ETK_MOVE_TYPE move(const ETK_MOVE_TYPE& _obj) {
// forward _Arg as movable
return _obj;
}
#endif
template<typename ETK_SWAP_TYPE>
inline void swap(ETK_SWAP_TYPE& _obj1, ETK_SWAP_TYPE& _obj2) {

7
etk/os/FSNode.cpp
View File

@ -8,21 +8,20 @@
#include <etk/types.hpp>
#include <etk/os/FSNode.hpp>
#include <unistd.h>
#include <cstdlib>
#include <stdlib.h>
#include <etk/tool.hpp>
#include <etk/debug.hpp>
#include <etk/Map.hpp>
#include <ethread/Mutex.hpp>
#ifdef __TARGET_OS__Windows
#include <tchar.h>
#include <iostream>
#include <windows.h>
#endif
extern "C" {
// file browsing ...
#include <dirent.h>
#include <sys/stat.h>
#include <cerrno>
#include <errno.h>
}
#ifdef HAVE_ZIP_DATA
@ -1702,7 +1701,7 @@ etk::Vector<etk::String> etk::FSNode::folderGetSub(bool _getFolder, bool _getFil
}
}
}
std::sort(out.begin(), out.end());
out.sort(0, out.size(), [](const etk::String& _left, const etk::String& _right) { return(_left<_right); });
return out;
}
#endif

31
etk/os/Fifo.hpp
View File

@ -9,8 +9,8 @@
#pragma once
#include <ethread/Mutex.hpp>
#include <ethread/Semaphore.hpp>
#include <etk/Vector.hpp>
#include <condition_variable>
namespace etk {
/**
@ -21,7 +21,7 @@ namespace etk {
template<class MY_TYPE=int32_t> class Fifo {
private :
ethread::Mutex m_mutex; //!< protection of the internal data.
std::condition_variable m_condition; //!< Message system to send event on an other thread.
ethread::Semaphore m_semaphore; //!< protection of the internal data.
etk::Vector<MY_TYPE> m_data; //!< List of all message to send
public :
/**
@ -43,15 +43,15 @@ namespace etk {
* @return false No data found or closed fifo
*/
bool wait(MY_TYPE &_data) {
std::unique_lock<ethread::Mutex> lock(m_mutex);
// Check if data is not previously here
while(m_data.size() == 0) {
m_condition.wait(lock);
m_semaphore.wait();
}
ethread::UniqueLock lock(m_mutex);
// End Waiting message :
if (m_data.size() > 0) {
// copy element :
std::swap(_data, m_data[0]);
etk::swap(_data, m_data[0]);
// remove element :
m_data.erase(m_data.begin());
return true;
@ -66,17 +66,17 @@ namespace etk {
* @return false No message found while time-out appear.
*/
bool wait(MY_TYPE &_data, uint32_t _timeOutInUs) {
std::unique_lock<ethread::Mutex> lock(m_mutex);
// Check if data is not previously here
while(m_data.size() == 0) {
if (m_condition.wait_for(lock, std::chrono::microseconds(_timeOutInUs)) == std::cv_status::timeout) {
if (m_semaphore.wait(_timeOutInUs) == false) {
return false;
}
}
ethread::UniqueLock lock(m_mutex);
// End Waiting message :
if (m_data.size() > 0) {
// copy element :
std::swap(_data, m_data[0]);
etk::swap(_data, m_data[0]);
// remove element :
m_data.erase(0);
return true;
@ -88,7 +88,7 @@ namespace etk {
* @return Number of message in the fifo.
*/
int32_t count() {
std::unique_lock<ethread::Mutex> lock(m_mutex);
ethread::UniqueLock lock(m_mutex);
int32_t nbElement = m_data.size();
return nbElement;
};
@ -97,27 +97,28 @@ namespace etk {
* @param[in] _data New data to add at the fifo.
*/
void post(MY_TYPE &_data) {
std::unique_lock<ethread::Mutex> lock(m_mutex);
ethread::UniqueLock lock(m_mutex);
m_data.pushBack(_data);
m_condition.notify_all();
m_semaphore.post();
};
/**
* @brief Send a message at the other thread by setting a new message in the fifo.
* @param[in] _data New data to add at the fifo.
*/
void post(const MY_TYPE &_data) {
std::unique_lock<ethread::Mutex> lock(m_mutex);
ethread::UniqueLock lock(m_mutex);
m_data.pushBack(_data);
m_condition.notify_all();
m_semaphore.post();
};
/**
* @brief Remove all the message in the fifo.
*/
void clean() {
std::unique_lock<ethread::Mutex> lock(m_mutex);
ethread::UniqueLock lock(m_mutex);
// remove data
m_data.clear();
m_condition.wait_for(lock, std::chrono::microseconds(0));
//m_condition.wait_for(lock, echrono::microseconds(0));
m_semaphore.post();
};
};
}

56
etk/stdTools.hpp
View File

@ -4,14 +4,60 @@
* @license MPL v2.0 (see license file)
*/
#pragma once
//#include <etk/Stream.hpp>
namespace etk {
inline float cos(float _value) {
return ::cosf(_value);
}
inline float sin(float _value) {
return ::sinf(_value);
}
inline float tan(float _value) {
return ::tanf(_value);
}
inline float acos(float _value) {
return ::acosf(_value);
}
inline float asin(float _value) {
return ::asinf(_value);
}
inline float atan(float _value) {
return ::atanf(_value);
}
inline float sqrt(float _value) {
return ::sqrtf(_value);
}
inline double cos(double _value) {
return ::cos(_value);
}
inline double sin(double _value) {
return ::sin(_value);
}
inline double tan(double _value) {
return ::tan(_value);
}
inline double acos(double _value) {
return ::acos(_value);
}
inline double asin(double _value) {
return ::asin(_value);
}
inline double atan(double _value) {
return ::atan(_value);
}
inline double sqrt(double _value) {
return ::sqrt(_value);
}
template <class TYPE> const TYPE& min(const TYPE& _val1, const TYPE& _val2) {
return (_val1 > _val2) ? _val2 : _val1;
}
template <class TYPE> const TYPE& max(const TYPE& _val1, const TYPE& _val2) {
return (_val1 > _val2) ? _val1 : _val2;
}
template <class TYPE> TYPE abs(const TYPE& _value) {
return (_value >= 0) ? _value : -_value;
}
/**
* @brief in std, we have min, max but not avg ==> it is missing... the Define of avg template.
* @param[in] _min Minimum value of the range
@ -32,4 +78,14 @@ namespace etk {
}
return out;
}
template<class ETK_ITERATOR_TYPE_1, class ETK_ITERATOR_TYPE_2>
ETK_ITERATOR_TYPE_1 find(ETK_ITERATOR_TYPE_1 _start, ETK_ITERATOR_TYPE_1 _stop, const ETK_ITERATOR_TYPE_2& _value) {
while (_start != _stop) {
if (*_start == _value) {
return _start;
}
++_start;
}
return _stop;
}
}

13
etk/tool.cpp
View File

@ -6,11 +6,11 @@
#include <etk/tool.hpp>
#include <etk/os/FSNode.hpp>
// for the rand ...
#include <time.h>
#include <cmath>
#include <cstdlib>
extern "C" {
#include <time.h>
#include <math.h>
#include <stdlib.h>
}
double etk::tool::frand(double _a, double _b) {
return (float)(( (double)rand()/(double)RAND_MAX ) * ((double)_b-(double)_a) + (double)_a);
@ -19,6 +19,9 @@ double etk::tool::frand(double _a, double _b) {
int32_t etk::tool::irand(int32_t _a, int32_t _b) {
return (int32_t)(( rand()/(double)RAND_MAX ) * ((double)_b-(double)_a) + (double)_a);
}
uint32_t etk::tool::urand(uint32_t _a, uint32_t _b) {
return (uint32_t)(( rand()/(double)RAND_MAX ) * ((double)_b-(double)_a) + (double)_a);
}
void etk::tool::resetRandom() {
srand(time(NULL));

3
etk/tool.hpp
View File

@ -27,7 +27,8 @@ namespace etk {
* @param[in] _b Bigger value of the random.
* @return Random Value between [_a and _b]
*/
int32_t irand(int32_t _a, int32_t _b);
int32_t irand(int32_t _a=0x80000000, int32_t _b=0x7FFFFFFF);
uint32_t urand(uint32_t _a=0, uint32_t _b=0xFFFFFFFF);
/**
* @brief Reset the random system with a random value (time).
*/

2
etk/utf8.hpp
View File

@ -66,9 +66,7 @@ namespace u32char {
* @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
char32_t toUpper(char32_t _input);
char32_t toLower(char32_t _input);
size_t strlen(const char32_t* _input);

6
test/testQuaternion.cpp
View File

@ -54,7 +54,7 @@ TEST(TestQuaternion, constructorMatrix) {
TEST(TestQuaternion, constructorEuler) {
etk::Quaternion test0(vec3(M_PI*0.5f, 0, 0));
etk::Quaternion test01(std::sin(M_PI*0.25f), 0, 0, std::cos(M_PI*0.25f));
etk::Quaternion test01(etk::sin(M_PI*0.25f), 0, 0, etk::cos(M_PI*0.25f));
test01.normalize();
EXPECT_FLOAT_EQ(test0.x(), test01.x());
EXPECT_FLOAT_EQ(test0.y(), test01.y());
@ -62,7 +62,7 @@ TEST(TestQuaternion, constructorEuler) {
EXPECT_FLOAT_EQ(test0.w(), test01.w());
etk::Quaternion test1(vec3(0, M_PI*0.5f, 0));
etk::Quaternion test11(0, std::sin(M_PI*0.25f), 0, std::cos(M_PI*0.25f));
etk::Quaternion test11(0, etk::sin(M_PI*0.25f), 0, etk::cos(M_PI*0.25f));
test11.normalize();
EXPECT_FLOAT_EQ(test1.x(), test11.x());
EXPECT_FLOAT_EQ(test1.y(), test11.y());
@ -70,7 +70,7 @@ TEST(TestQuaternion, constructorEuler) {
EXPECT_FLOAT_EQ(test1.w(), test11.w());
etk::Quaternion test2(vec3(0, 0, M_PI*0.5f));
etk::Quaternion test21(0, 0, std::sin(M_PI*0.25f), std::cos(M_PI*0.25f));
etk::Quaternion test21(0, 0, etk::sin(M_PI*0.25f), etk::cos(M_PI*0.25f));
test21.normalize();
EXPECT_FLOAT_EQ(test2.x(), test21.x());
EXPECT_FLOAT_EQ(test2.y(), test21.y());

33
test/testTrait.cpp
View File

@ -10,27 +10,27 @@
#define NAME "Color"
TEST(typeTrait, RemoveConstVolatile_1) {
typedef std::remove_cv<const int>::type type1;
typedef etk::RemoveConstVolatile<const int>::type type1;
auto ret = etk::IsSame<int, type1>::value;
EXPECT_EQ(ret, true);
}
TEST(typeTrait, RemoveConstVolatile_2) {
typedef std::remove_cv<volatile int>::type type1;
typedef etk::RemoveConstVolatile<volatile int>::type type1;
auto ret = etk::IsSame<int, type1>::value;
EXPECT_EQ(ret, true);
}
TEST(typeTrait, RemoveConstVolatile_3) {
typedef std::remove_cv<const volatile int>::type type1;
typedef etk::RemoveConstVolatile<const volatile int>::type type1;
auto ret = etk::IsSame<int, type1>::value;
EXPECT_EQ(ret, true);
}
TEST(typeTrait, RemoveConstVolatile_4) {
typedef std::remove_cv<const volatile int*>::type type1;
typedef etk::RemoveConstVolatile<const volatile int*>::type type1;
auto ret = etk::IsSame<const volatile int*, type1>::value;
EXPECT_EQ(ret, true);
}
TEST(typeTrait, RemoveConstVolatile_5) {
typedef std::remove_cv<int* const volatile>::type type1;
typedef etk::RemoveConstVolatile<int* const volatile>::type type1;
auto ret = etk::IsSame<int*, type1>::value;
EXPECT_EQ(ret, true);
}
@ -192,3 +192,26 @@ TEST(typeTrait, IsUnion_4) {
//etk::EnableIf<has_insertion_operator<etk::Pair<float,float>>::value, uint32_t>::type plop = 55;
etk::EnableIf<has_insertion_operator<int32_t>::value, uint32_t>::type plop = 55;
*/
static uint32_t contructCount = 0;
class PlopMove {
public:
PlopMove() {
contructCount ++;
}
};
void hello(PlopMove _val) {
contructCount += 1000;
}
TEST(typeMove, move_1) {
contructCount = 0;
PlopMove value;
EXPECT_EQ(contructCount, 1);
hello(etk::move(value));
EXPECT_EQ(contructCount, 1001);
}