#include <etk/UString.hpp>
#include <etk/Number.hpp>

etk::UString::UString():
  m_data() {
	m_data.resize(1, '\0');
}

etk::UString::UString(const etk::UString& _obj) {
	m_data = _obj.m_data;
}

etk::UString::UString(const etk::UString& _obj, size_t _pos, size_t _size) {
	if (_pos + _size >= _obj.size()) {
		_size = etk::UString::npos;
	}
	if (_size != etk::UString::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::UString::UString(const char32_t* _obj) {
	if (_obj == null) {
		resize(0);
		return;
	}
	uint32_t size = u32char::strlen(_obj);
	resize(size);
	for (size_t iii=0; iii<size; ++iii) {
		m_data[iii] = _obj[iii];
	}
}

etk::UString::UString(const char32_t* _obj, size_t _size) {
	if (    _obj == null
	     || _size == 0) {
		resize(0);
		return;
	}
	uint32_t size = u32char::strlen(_obj);
	if (_size < size) {
		size = _size;
	}
	resize(size);
	for (size_t iii=0; iii<size; ++iii) {
		m_data[iii] = _obj[iii];
	}
}

etk::UString::UString(size_t _size, char32_t _val) {
	resize(_size);
	for (size_t iii=0; iii<_size; ++iii) {
		m_data[iii] = _val;
	}
}

etk::UString::UString(Iterator _start, Iterator _stop) {
	size_t size = etk::distance(_start, _stop);
	resize(size);
	Iterator it = begin();
	while (_start != _stop) {
		*it++ = *_start++;
	}
}

etk::UString::UString(etk::UString&& _obj) noexcept {
	resize(0);
	m_data.swap(_obj.m_data);
}

etk::UString::UString(char32_t _value) {
	resize(1);
	m_data[0] = _value;
}

etk::UString::~UString() {
	// nothing to do...
}

void etk::UString::swap(etk::UString& _obj) {
	// avoid Swap of itself
	if(this != &_obj) {
		m_data.swap(_obj.m_data);
	}
}

etk::UString& etk::UString::operator=(const etk::UString& _obj) {
	if (this != &_obj) {
		m_data = _obj.m_data;
	}
	// Return the current pointer
	return *this;
}

etk::UString& etk::UString::operator=(const char32_t* _obj) {
	clear();
	if (_obj == null) {
		return *this;
	}
	size_t numberElement = u32char::strlen(_obj);
	resize(numberElement);
	for (size_t iii=0; iii<numberElement; ++iii) {
		m_data[iii] = _obj[iii];
	}
	// Return the current pointer
	return *this;
}

etk::UString& etk::UString::operator=(char32_t _value) {
	resize(1);
	m_data[0] = _value;
	// Return the current pointer
	return *this;
}

etk::UString& etk::UString::operator+= (const etk::UString& _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::UString& etk::UString::operator+= (const char32_t* _obj) {
	if (_obj == null) {
		return *this;
	}
	size_t numberElement = u32char::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::UString& etk::UString::operator+= (char32_t _value) {
	pushBack(_value);
	// Return the current pointer
	return *this;
}
size_t etk::UString::size() const {
	return m_data.size() - 1; // remove '\0'
}

void etk::UString::pushFront(char32_t _item) {
	insert(0, &_item, 1);
}

void etk::UString::pushFront(const char32_t * _item, size_t _nbElement) {
	insert(0, _item, _nbElement);
}

void etk::UString::pushBack(const char32_t _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::UString::pushBack(const char32_t* _item, size_t _nbElement) {
	if (_item == null) {
		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::UString::popBack() {
	if(size()>0) {
		resize(size()-1);
	}
}

void etk::UString::reserve(size_t _size) {
	m_data.reserve(_size+1);
}

void etk::UString::clear() {
	resize(0);
}

void etk::UString::insert(size_t _pos, const char32_t* _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::UString::insert(size_t _pos, const char32_t _item) {
	insert(_pos, &_item, 1);
}

void etk::UString::insert(size_t _pos, const etk::UString& _value) {
	insert(_pos, &_value[0], _value.size());
}

void etk::UString::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::UString::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::UString etk::UString::extract(size_t _posStart, size_t _posEnd) const {
	etk::UString out;
	if (_posStart >= size() ) {
		return out;
	}
	if (_posEnd >= size() ) {
		_posEnd = size();
	}
	out.pushBack(&m_data[_posStart], _posEnd-_posStart);
	return out;
}

const char32_t* etk::UString::c_str() const {
	return &m_data[0];
}

etk::UString::Iterator etk::UString::position(size_t _pos) {
	return etk::UString::Iterator(this, _pos);
}

const etk::UString::Iterator etk::UString::position(size_t _pos) const {
	return etk::UString::Iterator(this, _pos);
}

etk::UString::Iterator etk::UString::begin() {
	return position(0);
}

const etk::UString::Iterator etk::UString::begin() const {
	return position(0);
}

etk::UString::Iterator etk::UString::end() {
	return position( size()-1 );
}

const etk::UString::Iterator etk::UString::end() const {
	return position( size()-1 );
}

void etk::UString::resize(size_t _newSize, char32_t _value) {
	size_t oldSize = m_data.size();
	if (oldSize != 0) {
		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::UString::operator== (const etk::UString& _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::UString::operator!= (const etk::UString& _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;
}


etk::UString etk::UString::toLower() const {
	etk::UString tmp(*this);
	for (auto &it: tmp) {
		it = u32char::toLower(it);
	}
	return tmp;
}

etk::UString& etk::UString::lower() {
	for (auto &it: m_data) {
		it = u32char::toLower(it);
	}
	return *this;
}

etk::UString etk::UString::toUpper() const {
	etk::UString tmp(*this);
	for (auto &it: tmp) {
		it = u32char::toUpper(it);
	}
	return tmp;
}

etk::UString& etk::UString::upper() {
	for (auto &it: m_data) {
		it = u32char::toUpper(it);
	}
	return *this;
}

bool etk::UString::endWith(const etk::UString& _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 (u32char::toLower(_val[iii]) != u32char::toLower(m_data[jjj])) {
			return false;
		}
	}
	return true;
}

bool etk::UString::startWith(const etk::UString& _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 < _val.size();
		     iii++) {
			if (m_data[iii] != _val[iii]) {
				return false;
			}
		}
		return true;
	}
	for( size_t iii = 0;
	     iii < _val.size();
	     iii++) {
		if (u32char::toLower(_val[iii]) != u32char::toLower(m_data[iii])) {
			return false;
		}
	}
	return true;
}

template <>
long double etk::UString::to<long double>() const {
	return etk::toString(*this).to<long double>();
}

template <>
double etk::UString::to<double>() const {
	return etk::toString(*this).to<double>();
}

template <>
float etk::UString::to<float>() const {
	return etk::toString(*this).to<float>();
}

template <>
int8_t etk::UString::to<int8_t>() const {
	return etk::toString(*this).to<int8_t>();
}

template <>
int16_t etk::UString::to<int16_t>() const {
	return etk::toString(*this).to<int16_t>();
}

template <>
int32_t etk::UString::to<int32_t>() const {
	return etk::toString(*this).to<int32_t>();
}

template <>
int64_t etk::UString::to<int64_t>() const {
	return etk::toString(*this).to<int64_t>();
}

template <>
uint8_t etk::UString::to<uint8_t>() const {
	return etk::toString(*this).to<uint8_t>();
}

template <>
uint16_t etk::UString::to<uint16_t>() const {
	return etk::toString(*this).to<uint16_t>();
}

template <>
uint32_t etk::UString::to<uint32_t>() const {
	return etk::toString(*this).to<uint32_t>();
}

template <>
uint64_t etk::UString::to<uint64_t>() const {
	return etk::toString(*this).to<uint64_t>();
}

template <>
bool etk::UString::to<bool>() const {
	if(    compare(U"true", false) == true
	    || compare(U"enable", false) == true
	    || compare(U"yes", false) == true
	    || compare(U"1") == true) {
		return true;
	}
	return false;
}

etk::Stream& etk::operator <<(etk::Stream& _os, const etk::UString& _obj) {
	_os << _obj.c_str();
	return _os;
}

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;
		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]);
	}
}

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;
		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 {
	template<> bool from_string<etk::UString>(etk::UString& _variableRet, const etk::UString& _value) {
		_variableRet = _value;
		return true;
	}
	template<> bool from_string<int8_t>(int8_t& _variableRet, const etk::UString& _value) {
		_variableRet = _value.to<int8_t>();
		return true;
	}
	template<> bool from_string<int16_t>(int16_t& _variableRet, const etk::UString& _value) {
		_variableRet = _value.to<int16_t>();
		return true;
	}
	template<> bool from_string<int32_t>(int32_t& _variableRet, const etk::UString& _value) {
		_variableRet = _value.to<int32_t>();
		return true;
	}
	template<> bool from_string<int64_t>(int64_t& _variableRet, const etk::UString& _value) {
		_variableRet = _value.to<int64_t>();
		return true;
	}
	template<> bool from_string<uint8_t>(uint8_t& _variableRet, const etk::UString& _value) {
		_variableRet = _value.to<uint8_t>();
		return true;
	}
	template<> bool from_string<uint16_t>(uint16_t& _variableRet, const etk::UString& _value) {
		_variableRet = _value.to<uint16_t>();
		return true;
	}
	template<> bool from_string<uint32_t>(uint32_t& _variableRet, const etk::UString& _value) {
		_variableRet = _value.to<uint32_t>();
		return true;
	}
	template<> bool from_string<uint64_t>(uint64_t& _variableRet, const etk::UString& _value) {
		_variableRet = _value.to<uint64_t>();
		return true;
	}
	template<> bool from_string<float>(float& _variableRet, const etk::UString& _value) {
		_variableRet = _value.to<float>();
		return true;
	}
	template<> bool from_string<double>(double& _variableRet, const etk::UString& _value) {
		_variableRet = _value.to<double>();
		return true;
	}
	template<> bool from_string<long double>(long double& _variableRet, const etk::UString& _value) {
		_variableRet = _value.to<long double>();
		return true;
	}
	template<> bool from_string<bool>(bool& _variableRet, const etk::UString& _value) {
		_variableRet = _value.to<bool>();
		return true;
	}
}

template<>
etk::UString etk::toUString<char*>(char* const & _input) {
	return utf8::convertUnicode(_input);
}
template<>
etk::UString etk::toUString<etk::String>(const etk::String& _input) {
	return utf8::convertUnicode(_input);
}
template<>
etk::UString etk::toUString(const bool& _val) {
	return utf8::convertUnicode(etk::toString(_val));
}
template<>
etk::UString etk::toUString(const int8_t& _val) {
	return utf8::convertUnicode(etk::toString(_val));
}
template<>
etk::UString etk::toUString(const int16_t& _val) {
	return utf8::convertUnicode(etk::toString(_val));
}
template<>
etk::UString etk::toUString(const int32_t& _val) {
	return utf8::convertUnicode(etk::toString(_val));
}
template<>
etk::UString etk::toUString(const int64_t& _val) {
	return utf8::convertUnicode(etk::toString(_val));
}
template<>
etk::UString etk::toUString(const uint8_t& _val) {
	return utf8::convertUnicode(etk::toString(_val));
}
template<>
etk::UString etk::toUString(const uint16_t& _val) {
	return utf8::convertUnicode(etk::toString(_val));
}
template<>
etk::UString etk::toUString(const uint32_t& _val) {
	return utf8::convertUnicode(etk::toString(_val));
}
template<>
etk::UString etk::toUString(const uint64_t& _val) {
	return utf8::convertUnicode(etk::toString(_val));
}
/*
template<>
etk::UString etk::toUString(const size_t& _val) {
	return utf8::convertUnicode(etk::toString(_val));
}
*/
template<>
etk::UString etk::toUString(const float& _val) {
	return utf8::convertUnicode(etk::toString(_val));
}
template<>
etk::UString etk::toUString(const double& _val) {
	return utf8::convertUnicode(etk::toString(_val));
}
template<>
etk::UString etk::toUString(const long double& _val) {
	return utf8::convertUnicode(etk::toString(_val));
}

size_t etk::UString::find(char32_t _value, size_t _pos) const {
	for (size_t iii=_pos; iii<m_data.size(); ++iii) {
		if (_value == m_data[iii]) {
			return iii;
		}
	}
	return etk::UString::npos;
}

size_t etk::UString::find(const etk::UString& _value, size_t _pos) const {
	for (size_t iii=_pos; iii<m_data.size(); ++iii) {
		bool check = true;
		for (size_t jjj=0; jjj<_value.size(); ++jjj) {
			if (iii+jjj >= m_data.size()) {
				return etk::UString::npos;
			}
			if (_value[jjj] != m_data[iii+jjj]) {
				check = false;
				break;
			}
		}
		if (check == true) {
			return iii;
		}
	}
	return etk::UString::npos;
}

size_t etk::UString::rfind(char32_t _value, size_t _pos) const {
	if (_pos >= m_data.size()) {
		_pos = m_data.size()-1;
	}
	for (int64_t iii=_pos; iii>=0; --iii) {
		if (_value == m_data[iii]) {
			return iii;
		}
	}
	return etk::UString::npos;
}

size_t etk::UString::rfind(const etk::UString& _value, size_t _pos) const {
	if (_pos >= m_data.size()) {
		_pos = m_data.size()-1;
	}
	for (int64_t iii=_pos; iii>=0; --iii) {
		bool check = true;
		for (size_t jjj=0; jjj<_value.size(); ++jjj) {
			if (iii+jjj >= m_data.size()) {
				check = false;
				break;
			}
			if (_value[jjj] != m_data[iii+jjj]) {
				check = false;
				break;
			}
		}
		if (check == true) {
			return iii;
		}
	}
	return etk::UString::npos;
}

etk::UString& etk::UString::replace(size_t _pos, size_t _len, char32_t _replace) {
	erase(_pos, _len);
	insert(_pos, _replace);
	return *this;
}

etk::UString& etk::UString::replace(size_t _pos, size_t _len, const etk::UString& _replace) {
	erase(_pos, _len);
	insert(_pos, _replace);
	return *this;
}

etk::UString& etk::UString::replace(char32_t _val, char32_t _replace) {
	size_t pos = 0;
	while ((pos = find(_val, pos)) != etk::UString::npos) {
		replace(pos, 1, _replace);
		pos += 1;
	}
	return *this;
}

etk::UString& etk::UString::replace(const etk::UString& _val, const etk::UString& _replace) {
	size_t pos = 0;
	while ((pos = find(_val, pos)) != etk::UString::npos) {
		replace(pos, _val.size(), _replace);
		pos += _replace.size();
	}
	return *this;
}

etk::UString etk::UString::getLine(int32_t _pos) const {
	// search back : '\n'
	size_t startPos = rfind('\n', _pos);
	if ((int64_t)startPos == (int64_t)_pos) {
		startPos = 0;
	} else {
		startPos++;
	}
	// search forward : '\n'
	size_t stopPos = _pos;
	if (m_data[_pos] != '\n') {
		stopPos = find('\n', _pos);
		if ((int64_t)stopPos == _pos) {
			stopPos = size();
		}
	}
	if (startPos == etk::UString::npos) {
		startPos = 0;
	} else if (startPos >= size() ) {
		return U"";
	}
	if (stopPos == etk::UString::npos) {
		return U"";
	} else if (stopPos >= size() ) {
		stopPos = size();
	}
	return etk::UString(*this, startPos, stopPos - startPos);
}

bool etk::UString::compare(const etk::UString& _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 (u32char::toLower(_val[iii]) != u32char::toLower(m_data[iii])) {
			return false;
		}
	}
	return true;
}

etk::Vector<etk::UString> etk::UString::split(char32_t _val) const {
	etk::Vector<etk::UString> list;
	size_t lastStartPos = 0;
	for(size_t iii=0; iii<size(); iii++) {
		if (m_data[iii] == _val) {
			list.pushBack(etk::UString(*this, lastStartPos, iii - lastStartPos));
			lastStartPos = iii+1;
		}
	}
	if (lastStartPos < size()) {
		list.pushBack(etk::UString(*this, lastStartPos));
	}
	return list;
}

etk::Vector<etk::UString> etk::UString::split(etk::UString _val) const {
	etk::Vector<etk::UString> list;
	size_t lastStartPos = 0;
	for(size_t iii=0; iii<size()-_val.size(); iii++) {
		if (etk::UString(begin()+iii, begin()+iii+_val.size()) ==_val) {
			list.pushBack(etk::UString(*this, lastStartPos, iii - lastStartPos));
			lastStartPos = iii+_val.size();
			iii += _val.size()-1;
		}
	}
	if (lastStartPos < size()) {
		list.pushBack(etk::UString(*this, lastStartPos));
	}
	return list;
}

namespace etk {
	long double string_to_long_double(const etk::UString& _obj) {
		return _obj.to<long double>();
	}
	double string_to_double(const etk::UString& _obj) {
		return _obj.to<double>();
	}
	float string_to_float(const etk::UString& _obj) {
		return _obj.to<float>();
	}
	int8_t string_to_int8_t(const etk::UString& _obj) {
		return _obj.to<int8_t>();
	}
	int16_t string_to_int16_t(const etk::UString& _obj) {
		return _obj.to<int16_t>();
	}
	int32_t string_to_int32_t(const etk::UString& _obj) {
		return _obj.to<int32_t>();
	}
	int64_t string_to_int64_t(const etk::UString& _obj) {
		return _obj.to<int64_t>();
	}
	uint8_t string_to_uint8_t(const etk::UString& _obj) {
		return _obj.to<uint8_t>();
	}
	uint16_t string_to_uint16_t(const etk::UString& _obj) {
		return _obj.to<uint16_t>();
	}
	uint32_t string_to_uint32_t(const etk::UString& _obj) {
		return _obj.to<uint32_t>();
	}
	uint64_t string_to_uint64_t(const etk::UString& _obj) {
		return _obj.to<uint64_t>();
	}
	bool string_to_bool(const etk::UString& _obj) {
		return _obj.to<bool>();
	}
	etk::UString toLower(etk::UString _obj) {
		return _obj.toLower();
	}
	etk::UString toUpper(etk::UString _obj) {
		return _obj.toUpper();
	}
	bool compare_no_case(const etk::UString& _obj, const etk::UString& _val) {
		return _obj.compare(_val, false);
	}
	bool end_with(const etk::UString& _obj, const etk::UString& _val, bool _caseSensitive) {
		return _obj.endWith(_val, _caseSensitive);
	}
	bool start_with(const etk::UString& _obj, const etk::UString& _val, bool _caseSensitive) {
		return _obj.startWith(_val, _caseSensitive);
	}
	etk::UString replace(const etk::UString& _obj, char32_t _val, char32_t _replace) {
		etk::UString tmp = _obj;
		tmp.replace(_val, _replace);
		return tmp;
	}
	etk::UString extract_line(const etk::UString& _obj, int32_t _pos) {
		return _obj.getLine(_pos);
	}
	etk::Vector<etk::UString> split(const etk::UString& _obj, char32_t _val) {
		return _obj.split(_val);
	}
}




bool etk::operator> (const etk::UString& _left, const etk::UString& _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::UString& _left, const etk::UString& _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::UString& _left, const etk::UString& _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::UString& _left, const etk::UString& _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::UString etk::operator+ (const etk::UString& _left, const etk::UString& _right) {
	etk::UString tmp = _left;
	tmp += _right;
	return tmp;
}
etk::UString etk::operator+ (const etk::UString& _left, const char32_t* _right) {
	etk::UString tmp = _left;
	tmp += _right;
	return tmp;
}
etk::UString etk::operator+ (const char32_t* _left, const etk::UString& _right) {
	etk::UString tmp = _left;
	tmp += _right;
	return tmp;
}
etk::UString etk::operator+ (const etk::UString& _left, char32_t _right) {
	etk::UString tmp = _left;
	tmp.pushBack(_right);
	return tmp;
}
etk::UString etk::operator+ (char32_t _left, const etk::UString& _right) {
	etk::UString tmp = _left;
	tmp += _right;
	return tmp;
}



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;
	}
}