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

[DEV] some file acces corection when apk file loading

Browse Source
This commit is contained in:
Edouard DUPIN 2013-07-25 21:50:53 +02:00
parent f2edd2def6
commit b9a79c1dfc
10 changed files with 415 additions and 400 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
etk/Debug.cpp
View File

@ -15,21 +15,21 @@
#define FUNCTION_NAME_SIZE (70) #define FUNCTION_NAME_SIZE (70)
void TOOLS_DisplayFuncName(int32_t ligne, const char* className, const char* funcName, const char* libName) void TOOLS_DisplayFuncName(int32_t _ligne, const char* _className, const char* _funcName, const char* _libName)
{ {
char tmpName[FUNCTION_NAME_SIZE] = ""; char tmpName[FUNCTION_NAME_SIZE] = "";
if (NULL == className) { if (NULL == _className) {
if (NULL == libName) { if (NULL == _libName) {
snprintf(tmpName, FUNCTION_NAME_SIZE-1, "???????? | (l=%5d) %s ",ligne, funcName); snprintf(tmpName, FUNCTION_NAME_SIZE-1, "???????? | (l=%5d) %s ",_ligne, _funcName);
} else { } else {
snprintf(tmpName, FUNCTION_NAME_SIZE-1, "%s | (l=%5d) %s ",libName, ligne, funcName); snprintf(tmpName, FUNCTION_NAME_SIZE-1, "%s | (l=%5d) %s ",_libName, _ligne, _funcName);
} }
} else { } else {
if (NULL == libName) { if (NULL == _libName) {
snprintf(tmpName, FUNCTION_NAME_SIZE-1, "???????? | (l=%5d) %s::%s ",ligne, className, funcName); snprintf(tmpName, FUNCTION_NAME_SIZE-1, "???????? | (l=%5d) %s::%s ",_ligne, _className, _funcName);
} else { } else {
snprintf(tmpName, FUNCTION_NAME_SIZE-1, "%s | (l=%5d) %s::%s ", libName, ligne, className, funcName); snprintf(tmpName, FUNCTION_NAME_SIZE-1, "%s | (l=%5d) %s::%s ", _libName, _ligne, _className, _funcName);
} }
} }
tmpName[FUNCTION_NAME_SIZE-4] = ' '; tmpName[FUNCTION_NAME_SIZE-4] = ' ';
@ -45,13 +45,13 @@ void TOOLS_DisplayTime(void)
#ifdef __TARGET_OS__Android #ifdef __TARGET_OS__Android
struct timeval now; struct timeval now;
gettimeofday(&now, NULL); gettimeofday(&now, NULL);
sprintf(tmpdata, " %2dh %2dmin %2ds | ", (int32_t)(now.tv_sec/3600)%24, (int32_t)(now.tv_sec/60)%60, (int32_t)(now.tv_sec%60)); sprintf(tmpdata, " %2dh%2d'%2d | ", (int32_t)(now.tv_sec/3600)%24, (int32_t)(now.tv_sec/60)%60, (int32_t)(now.tv_sec%60));
#else #else
time_t rawtime; time_t rawtime;
struct tm * timeinfo; struct tm * timeinfo;
time(&rawtime); time(&rawtime);
timeinfo = localtime(&rawtime); timeinfo = localtime(&rawtime);
sprintf(tmpdata, " %2dh %2dmin %2ds | ", (timeinfo->tm_hour)%24, timeinfo->tm_min, timeinfo->tm_sec); sprintf(tmpdata, " %2dh%2d'%2d | ", (timeinfo->tm_hour)%24, timeinfo->tm_min, timeinfo->tm_sec);
#endif #endif
etk::cout << tmpdata ; etk::cout << tmpdata ;
} }
@ -62,7 +62,7 @@ etk::logLevel_te g_requestedLevel = etk::LOG_LEVEL_VERBOSE;
#else #else
etk::logLevel_te g_requestedLevel = etk::LOG_LEVEL_ERROR; etk::logLevel_te g_requestedLevel = etk::LOG_LEVEL_ERROR;
#endif #endif
void GeneralDebugSetLevel(etk::logLevel_te ccc) { void GeneralDebugSetLevel(etk::logLevel_te _ccc) {
g_requestedLevel = ccc; g_requestedLevel = _ccc;
} }

4
etk/Debug.h
View File

@ -13,7 +13,7 @@
#include <etk/Stream.h> #include <etk/Stream.h>
// Log Message System For EDN // Log Message System For EDN
void TOOLS_DisplayFuncName(int32_t ligne, const char* className, const char* funcName, const char* libName); void TOOLS_DisplayFuncName(int32_t _ligne, const char* _className, const char* _funcName, const char* _libName);
void TOOLS_DisplayTime(void); void TOOLS_DisplayTime(void);
@ -21,7 +21,7 @@ void TOOLS_DisplayTime(void);
#define __class__ (NULL) #define __class__ (NULL)
extern etk::logLevel_te g_requestedLevel; extern etk::logLevel_te g_requestedLevel;
void GeneralDebugSetLevel(etk::logLevel_te ccc); void GeneralDebugSetLevel(etk::logLevel_te _ccc);
#define ETK_DBG_COMMON(libName, info, data) do { \ #define ETK_DBG_COMMON(libName, info, data) do { \
if (info <= g_requestedLevel) { \ if (info <= g_requestedLevel) { \

120
etk/Stream.cpp
View File

@ -59,69 +59,77 @@ etk::CStart etk::cstart;
# include <android/log.h> # include <android/log.h>
#endif #endif
etk::CCout& etk::operator <<(etk::CCout &os, const etk::logLevel_te obj) etk::CCout& etk::operator <<(etk::CCout &_os, const etk::logLevel_te _obj)
{ {
switch (obj) switch (_obj)
{ {
case LOG_LEVEL_CRITICAL: case LOG_LEVEL_CRITICAL:
#if !defined(__TARGET_OS__Windows) #if !defined(__TARGET_OS__Windows)
os << ETK_BASH_COLOR_BOLD_RED; _os << ETK_BASH_COLOR_BOLD_RED;
#endif #endif
#if defined(__TARGET_OS__Android) #if defined(__TARGET_OS__Android)
os.m_levelAndroid = ANDROID_LOG_FATAL; _os.m_levelAndroid = ANDROID_LOG_FATAL;
#else
_os << "[C]";
#endif #endif
os << "[C]";
break; break;
case LOG_LEVEL_ERROR: case LOG_LEVEL_ERROR:
#if !defined(__TARGET_OS__Windows) #if !defined(__TARGET_OS__Windows)
os << ETK_BASH_COLOR_RED; _os << ETK_BASH_COLOR_RED;
#endif #endif
#if defined(__TARGET_OS__Android) #if defined(__TARGET_OS__Android)
os.m_levelAndroid = ANDROID_LOG_ERROR; _os.m_levelAndroid = ANDROID_LOG_ERROR;
#else
_os << "[E]";
#endif #endif
os << "[E]";
break; break;
case LOG_LEVEL_WARNING: case LOG_LEVEL_WARNING:
#if !defined(__TARGET_OS__Windows) #if !defined(__TARGET_OS__Windows)
os << ETK_BASH_COLOR_MAGENTA; _os << ETK_BASH_COLOR_MAGENTA;
#endif #endif
#if defined(__TARGET_OS__Android) #if defined(__TARGET_OS__Android)
os.m_levelAndroid = ANDROID_LOG_WARN; _os.m_levelAndroid = ANDROID_LOG_WARN;
#else
_os << "[W]";
#endif #endif
os << "[W]";
break; break;
case LOG_LEVEL_INFO: case LOG_LEVEL_INFO:
#if !defined(__TARGET_OS__Windows) #if !defined(__TARGET_OS__Windows)
os << ETK_BASH_COLOR_CYAN; _os << ETK_BASH_COLOR_CYAN;
#endif #endif
#if defined(__TARGET_OS__Android) #if defined(__TARGET_OS__Android)
os.m_levelAndroid = ANDROID_LOG_INFO; _os.m_levelAndroid = ANDROID_LOG_INFO;
#else
_os << "[I]";
#endif #endif
os << "[I]";
break; break;
case LOG_LEVEL_DEBUG: case LOG_LEVEL_DEBUG:
#if !defined(__TARGET_OS__Windows) #if !defined(__TARGET_OS__Windows)
os << ETK_BASH_COLOR_YELLOW; _os << ETK_BASH_COLOR_YELLOW;
#endif #endif
#if defined(__TARGET_OS__Android) #if defined(__TARGET_OS__Android)
os.m_levelAndroid = ANDROID_LOG_DEBUG; _os.m_levelAndroid = ANDROID_LOG_DEBUG;
#else
_os << "[D]";
#endif #endif
os << "[D]";
break; break;
case LOG_LEVEL_VERBOSE: case LOG_LEVEL_VERBOSE:
#if !defined(__TARGET_OS__Windows) #if !defined(__TARGET_OS__Windows)
os << ETK_BASH_COLOR_WHITE; _os << ETK_BASH_COLOR_WHITE;
#endif #endif
#if defined(__TARGET_OS__Android) #if defined(__TARGET_OS__Android)
os.m_levelAndroid = ANDROID_LOG_VERBOSE; _os.m_levelAndroid = ANDROID_LOG_VERBOSE;
#else
_os << "[V]";
#endif #endif
os << "[V]";
break; break;
default: default:
os << "[?]"; #if !defined(__TARGET_OS__Android)
_os << "[?]";
#endif
break; break;
} }
return os; return _os;
} }
@ -141,117 +149,117 @@ etk::CCout::~CCout()
}; };
etk::CCout& etk::CCout::operator << (const etk::UniChar& t) etk::CCout& etk::CCout::operator << (const etk::UniChar& _t)
{ {
char output[5]; char output[5];
t.GetUtf8(output); _t.GetUtf8(output);
snprintf(tmp, MAX_LOG_SIZE_TMP, "%s", output); snprintf(tmp, MAX_LOG_SIZE_TMP, "%s", output);
strncat(m_tmpChar, tmp, MAX_LOG_SIZE); strncat(m_tmpChar, tmp, MAX_LOG_SIZE);
return *this; return *this;
} }
etk::CCout& etk::CCout::operator << (int8_t t) etk::CCout& etk::CCout::operator << (int8_t _t)
{ {
snprintf(tmp, MAX_LOG_SIZE_TMP, "%d", t); snprintf(tmp, MAX_LOG_SIZE_TMP, "%d", _t);
strncat(m_tmpChar, tmp, MAX_LOG_SIZE); strncat(m_tmpChar, tmp, MAX_LOG_SIZE);
return *this; return *this;
} }
etk::CCout& etk::CCout::operator << (int16_t t) etk::CCout& etk::CCout::operator << (int16_t _t)
{ {
snprintf(tmp, MAX_LOG_SIZE_TMP, "%d", t); snprintf(tmp, MAX_LOG_SIZE_TMP, "%d", _t);
strncat(m_tmpChar, tmp, MAX_LOG_SIZE); strncat(m_tmpChar, tmp, MAX_LOG_SIZE);
return *this; return *this;
} }
etk::CCout& etk::CCout::operator << (int32_t t) etk::CCout& etk::CCout::operator << (int32_t _t)
{ {
snprintf(tmp, MAX_LOG_SIZE_TMP, "%d", t); snprintf(tmp, MAX_LOG_SIZE_TMP, "%d", _t);
strncat(m_tmpChar, tmp, MAX_LOG_SIZE); strncat(m_tmpChar, tmp, MAX_LOG_SIZE);
return *this; return *this;
} }
etk::CCout& etk::CCout::operator << (int64_t t) etk::CCout& etk::CCout::operator << (int64_t _t)
{ {
#if __WORDSIZE == 64 #if __WORDSIZE == 64
snprintf(tmp, MAX_LOG_SIZE_TMP, "%ld", t); snprintf(tmp, MAX_LOG_SIZE_TMP, "%ld", _t);
#else #else
snprintf(tmp, MAX_LOG_SIZE_TMP, "%lld", t); snprintf(tmp, MAX_LOG_SIZE_TMP, "%lld", _t);
#endif #endif
strncat(m_tmpChar, tmp, MAX_LOG_SIZE); strncat(m_tmpChar, tmp, MAX_LOG_SIZE);
return *this; return *this;
} }
etk::CCout& etk::CCout::operator << (uint8_t t) etk::CCout& etk::CCout::operator << (uint8_t _t)
{ {
snprintf(tmp, MAX_LOG_SIZE_TMP, "%u", t); snprintf(tmp, MAX_LOG_SIZE_TMP, "%u", _t);
strncat(m_tmpChar, tmp, MAX_LOG_SIZE); strncat(m_tmpChar, tmp, MAX_LOG_SIZE);
return *this; return *this;
} }
etk::CCout& etk::CCout::operator << (uint16_t t) etk::CCout& etk::CCout::operator << (uint16_t _t)
{ {
snprintf(tmp, MAX_LOG_SIZE_TMP, "%u", t); snprintf(tmp, MAX_LOG_SIZE_TMP, "%u", _t);
strncat(m_tmpChar, tmp, MAX_LOG_SIZE); strncat(m_tmpChar, tmp, MAX_LOG_SIZE);
return *this; return *this;
} }
etk::CCout& etk::CCout::operator << (uint32_t t) etk::CCout& etk::CCout::operator << (uint32_t _t)
{ {
snprintf(tmp, MAX_LOG_SIZE_TMP, "%u", t); snprintf(tmp, MAX_LOG_SIZE_TMP, "%u", _t);
strncat(m_tmpChar, tmp, MAX_LOG_SIZE); strncat(m_tmpChar, tmp, MAX_LOG_SIZE);
return *this; return *this;
} }
etk::CCout& etk::CCout::operator << (uint64_t t) etk::CCout& etk::CCout::operator << (uint64_t _t)
{ {
#if __WORDSIZE == 64 #if __WORDSIZE == 64
snprintf(tmp, MAX_LOG_SIZE_TMP, "%lu", t); snprintf(tmp, MAX_LOG_SIZE_TMP, "%lu", _t);
#else #else
snprintf(tmp, MAX_LOG_SIZE_TMP, "%llu", t); snprintf(tmp, MAX_LOG_SIZE_TMP, "%llu", _t);
#endif #endif
strncat(m_tmpChar, tmp, MAX_LOG_SIZE); strncat(m_tmpChar, tmp, MAX_LOG_SIZE);
return *this; return *this;
} }
etk::CCout& etk::CCout::operator << (double t) etk::CCout& etk::CCout::operator << (double _t)
{ {
snprintf(tmp, MAX_LOG_SIZE_TMP, "%f", t); snprintf(tmp, MAX_LOG_SIZE_TMP, "%f", _t);
strncat(m_tmpChar, tmp, MAX_LOG_SIZE); strncat(m_tmpChar, tmp, MAX_LOG_SIZE);
return *this; return *this;
} }
etk::CCout& etk::CCout::operator << (float t) etk::CCout& etk::CCout::operator << (float _t)
{ {
snprintf(tmp, MAX_LOG_SIZE_TMP, "%f", t); snprintf(tmp, MAX_LOG_SIZE_TMP, "%f", _t);
strncat(m_tmpChar, tmp, MAX_LOG_SIZE); strncat(m_tmpChar, tmp, MAX_LOG_SIZE);
return *this; return *this;
} }
etk::CCout& etk::CCout::operator << (char * t) etk::CCout& etk::CCout::operator << (char * _t)
{ {
snprintf(tmp, MAX_LOG_SIZE_TMP, "%s", t); snprintf(tmp, MAX_LOG_SIZE_TMP, "%s", _t);
strncat(m_tmpChar, tmp, MAX_LOG_SIZE); strncat(m_tmpChar, tmp, MAX_LOG_SIZE);
return *this; return *this;
} }
etk::CCout& etk::CCout::operator << (const char * t) etk::CCout& etk::CCout::operator << (const char * _t)
{ {
snprintf(tmp, MAX_LOG_SIZE_TMP, "%s", t); snprintf(tmp, MAX_LOG_SIZE_TMP, "%s", _t);
strncat(m_tmpChar, tmp, MAX_LOG_SIZE); strncat(m_tmpChar, tmp, MAX_LOG_SIZE);
return *this; return *this;
} }
etk::CCout& etk::CCout::operator << (char t) etk::CCout& etk::CCout::operator << (char _t)
{ {
snprintf(tmp, MAX_LOG_SIZE_TMP, "%c", t); snprintf(tmp, MAX_LOG_SIZE_TMP, "%c", _t);
strncat(m_tmpChar, tmp, MAX_LOG_SIZE); strncat(m_tmpChar, tmp, MAX_LOG_SIZE);
return *this; return *this;
} }
etk::CCout& etk::CCout::operator << (bool t) etk::CCout& etk::CCout::operator << (bool _t)
{ {
if (t) { if (_t) {
strncat(m_tmpChar, "true", MAX_LOG_SIZE); strncat(m_tmpChar, "true", MAX_LOG_SIZE);
} else { } else {
strncat(m_tmpChar, "false", MAX_LOG_SIZE); strncat(m_tmpChar, "false", MAX_LOG_SIZE);
@ -260,14 +268,14 @@ etk::CCout& etk::CCout::operator << (bool t)
} }
etk::CCout& etk::CCout::operator << (CStart ccc) etk::CCout& etk::CCout::operator << (CStart _ccc)
{ {
m_mutex.Lock(); m_mutex.Lock();
return *this; return *this;
} }
etk::CCout& etk::CCout::operator << (etk::CEndl t) etk::CCout& etk::CCout::operator << (etk::CEndl _t)
{ {
#if !defined(__TARGET_OS__Windows) #if !defined(__TARGET_OS__Windows)
strncat(m_tmpChar, ETK_BASH_COLOR_NORMAL, MAX_LOG_SIZE); strncat(m_tmpChar, ETK_BASH_COLOR_NORMAL, MAX_LOG_SIZE);

36
etk/Stream.h
View File

@ -32,23 +32,23 @@ namespace etk
public: public:
CCout(void); CCout(void);
~CCout(void); ~CCout(void);
CCout& operator << (const etk::UniChar& t);; CCout& operator << (const etk::UniChar& _t);;
CCout& operator << (int8_t t); CCout& operator << (int8_t _t);
CCout& operator << (int16_t t); CCout& operator << (int16_t _t);
CCout& operator << (int32_t t); CCout& operator << (int32_t _t);
CCout& operator << (int64_t t); CCout& operator << (int64_t _t);
CCout& operator << (uint8_t t); CCout& operator << (uint8_t _t);
CCout& operator << (uint16_t t); CCout& operator << (uint16_t _t);
CCout& operator << (uint32_t t); CCout& operator << (uint32_t _t);
CCout& operator << (uint64_t t); CCout& operator << (uint64_t _t);
CCout& operator << (double t); CCout& operator << (double _t);
CCout& operator << (float t); CCout& operator << (float _t);
CCout& operator << (char * t); CCout& operator << (char * _t);
CCout& operator << (const char * t); CCout& operator << (const char * _t);
CCout& operator << (char t); CCout& operator << (char _t);
CCout& operator << (bool t); CCout& operator << (bool _t);
CCout& operator << (CStart ccc); CCout& operator << (CStart _ccc);
CCout& operator << (etk::CEndl t); CCout& operator << (etk::CEndl _t);
}; };
extern etk::CCout cout; extern etk::CCout cout;
extern etk::CEndl endl; extern etk::CEndl endl;
@ -67,7 +67,7 @@ namespace etk
/** /**
* @brief Debug operator To display the curent element in a Human redeable information * @brief Debug operator To display the curent element in a Human redeable information
*/ */
etk::CCout& operator <<(etk::CCout &os, const etk::logLevel_te obj); etk::CCout& operator <<(etk::CCout &_os, const etk::logLevel_te _obj);
void DisplayBacktrace(void); void DisplayBacktrace(void);
}; };

5
etk/archive/Archive.cpp
View File

@ -23,8 +23,9 @@ const etk::Archive::Content& etk::Archive::GetContent(const etk::UString& _key)
void etk::Archive::Display(void) void etk::Archive::Display(void)
{ {
for (esize_t iii=0; iii<m_content.Size(); iii++) { for (esize_t iii=0; iii<m_content.Size(); iii++) {
esize_t size = m_content.GetValue(iii).Size(); esize_t size = m_content.GetValue(iii).GetTheoricSize();
TK_INFO(" element : " << m_content.GetKey(iii) << " size=" << size); esize_t sizeR = m_content.GetValue(iii).Size();
TK_INFO(" element : " << m_content.GetKey(iii) << " size=" << size << " allocated=" << sizeR);
} }
} }

6
etk/archive/Zip.cpp
View File

@ -60,7 +60,7 @@ etk::archive::Zip::~Zip(void)
void etk::archive::Zip::LoadFile(int32_t _id) void etk::archive::Zip::LoadFile(int32_t _id)
{ {
etk::UString fileNameRequested = m_content.GetKey(_id); etk::UString fileNameRequested = m_content.GetKey(_id);
TK_WARNING("Load file Here ... : " << _id << " = '" << fileNameRequested << "'"); TK_VERBOSE("Real load file : " << _id << " = '" << fileNameRequested << "'");
unzGoToFirstFile(m_ctx); unzGoToFirstFile(m_ctx);
@ -96,6 +96,10 @@ void etk::archive::Zip::LoadFile(int32_t _id)
return; return;
} }
} while ( error > 0 ); } while ( error > 0 );
//((char*)data)[m_content.GetValue(_id).GetTheoricSize()] = '\0';
// stop searching here
unzCloseCurrentFile(m_ctx);
return;
} }
unzCloseCurrentFile(m_ctx); unzCloseCurrentFile(m_ctx);

352
etk/os/FSNode.cpp
View File

@ -36,46 +36,46 @@ extern "C" {
static etk::UString SimplifyPathAbstractPath(etk::UString input) static etk::UString SimplifyPathAbstractPath(etk::UString _input)
{ {
int32_t findStartPos = input.FindForward('/') + 1; int32_t findStartPos = _input.FindForward('/') + 1;
int32_t findPos = input.FindForward('/', findStartPos); int32_t findPos = _input.FindForward('/', findStartPos);
//TK_DEBUG("Siplify : \"" << input << "\""); //TK_DEBUG("Siplify : \"" << input << "\"");
int32_t preventBadCode = 0; int32_t preventBadCode = 0;
while (findPos!=-1) while (findPos!=-1)
{ {
//TK_DEBUG(" string=\"" << input << "\""); //TK_DEBUG(" string=\"" << input << "\"");
//TK_DEBUG(" '/' @" << findPos); //TK_DEBUG(" '/' @" << findPos);
if (input.Size()<findPos+1) { if (_input.Size()<findPos+1) {
// no more element ... // no more element ...
break; break;
} }
if( input[findPos+1] == '/' if( _input[findPos+1] == '/'
|| ( input[findPos+1] == '.' || ( _input[findPos+1] == '.'
&& input.Size()==findPos+2 )) { && _input.Size()==findPos+2 )) {
// cleane the element path // cleane the element path
input.Remove(findPos+1, 1); _input.Remove(findPos+1, 1);
//TK_DEBUG(" Remove // string=\"" << input << "\""); //TK_DEBUG(" Remove // string=\"" << input << "\"");
} else { } else {
if (input.Size()<findPos+2) { if (_input.Size()<findPos+2) {
// no more element ... // no more element ...
break; break;
} }
if( input[findPos+1] == '.' if( _input[findPos+1] == '.'
&& input[findPos+2] == '.') { && _input[findPos+2] == '.') {
// cleane the element path // cleane the element path
input.Remove(findStartPos, findPos+3 - findStartPos ); _input.Remove(findStartPos, findPos+3 - findStartPos );
//TK_DEBUG(" Remove xxx/.. string=\"" << input << "\""); //TK_DEBUG(" Remove xxx/.. string=\"" << input << "\"");
} else if( input[findPos+1] == '.' } else if( _input[findPos+1] == '.'
&& input[findPos+2] == '/') { && _input[findPos+2] == '/') {
// cleane the element path // cleane the element path
input.Remove(findPos+1, 2); _input.Remove(findPos+1, 2);
//TK_DEBUG(" Remove ./ string=\"" << input << "\""); //TK_DEBUG(" Remove ./ string=\"" << input << "\"");
} else { } else {
findStartPos = findPos+1; findStartPos = findPos+1;
} }
} }
findPos = input.FindForward('/', findStartPos); findPos = _input.FindForward('/', findStartPos);
preventBadCode++; preventBadCode++;
if (preventBadCode>5000) { if (preventBadCode>5000) {
TK_CRITICAL("ERROR when getting the small path ... this is loop prevention..."); TK_CRITICAL("ERROR when getting the small path ... this is loop prevention...");
@ -97,7 +97,7 @@ static etk::UString SimplifyPathAbstractPath(etk::UString input)
#endif #endif
*/ */
//TK_DEBUG(" ==> \"" << input << "\""); //TK_DEBUG(" ==> \"" << input << "\"");
return input; return _input;
} }
@ -126,50 +126,50 @@ static etk::UString baseRunPath = "/";
#ifdef __TARGET_OS__Android #ifdef __TARGET_OS__Android
static etk::Archive* s_APKArchive = NULL; static etk::Archive* s_APKArchive = NULL;
static void loadAPK(etk::UString& apkPath) static void loadAPK(etk::UString& _apkPath)
{ {
TK_DEBUG("Loading APK \"" << apkPath << "\""); TK_DEBUG("Loading APK \"" << _apkPath << "\"");
s_APKArchive = etk::Archive::Load(apkPath); s_APKArchive = etk::Archive::Load(_apkPath);
TK_ASSERT(s_APKArchive != NULL, "Error loading APK ... \"" << apkPath << "\""); TK_ASSERT(s_APKArchive != NULL, "Error loading APK ... \"" << _apkPath << "\"");
//Just for debug, print APK contents //Just for debug, print APK contents
s_APKArchive->Display(); s_APKArchive->Display();
} }
#endif #endif
// for specific device contraint : // for specific device contraint :
void etk::SetBaseFolderData(const char * folder) void etk::SetBaseFolderData(const char* _folder)
{ {
#ifdef __TARGET_OS__Android #ifdef __TARGET_OS__Android
baseFolderData = "assets/"; baseFolderData = "assets/";
s_fileAPK = folder; s_fileAPK = _folder;
loadAPK(s_fileAPK); loadAPK(s_fileAPK);
#else #else
TK_WARNING("Not Availlable Outside Android"); TK_WARNING("Not Availlable Outside Android");
#endif #endif
} }
void etk::SetBaseFolderDataUser(const char * folder) void etk::SetBaseFolderDataUser(const char* _folder)
{ {
#ifdef __TARGET_OS__Android #ifdef __TARGET_OS__Android
baseFolderDataUser = folder; baseFolderDataUser = _folder;
#else #else
TK_WARNING("Not Availlable Outside Android"); TK_WARNING("Not Availlable Outside Android");
#endif #endif
} }
void etk::SetBaseFolderCache(const char * folder) void etk::SetBaseFolderCache(const char* _folder)
{ {
#ifdef __TARGET_OS__Android #ifdef __TARGET_OS__Android
baseFolderCache = folder; baseFolderCache = _folder;
#else #else
TK_WARNING("Not Availlable Outside Android"); TK_WARNING("Not Availlable Outside Android");
#endif #endif
} }
etk::UString l_argZero=""; etk::UString l_argZero="";
void etk::SetArgZero(const etk::UString& val) void etk::SetArgZero(const etk::UString& _val)
{ {
l_argZero = val; l_argZero = _val;
} }
/* /*
On Unixes with /proc really straight and realiable way is to: On Unixes with /proc really straight and realiable way is to:
@ -246,19 +246,19 @@ etk::UString GetApplicationPath(void)
return SimplifyPathAbstractPath(binaryName); return SimplifyPathAbstractPath(binaryName);
} }
} }
char * basicPathPATH = getenv("PATH"); //char * basicPathPATH = getenv("PATH");
if (NULL != basicPathPWD) { //if (NULL != basicPathPWD) {
// TODO : bad case ... // TODO : bad case ...
} //}
// and now we will really in a bad mood ... // and now we will really in a bad mood ...
#endif #endif
TK_INFO("Binary name : " << binaryName); TK_INFO("Binary name : " << binaryName);
return binaryName; return binaryName;
} }
void etk::InitDefaultFolder(const char * applName) void etk::InitDefaultFolder(const char* _applName)
{ {
baseApplName = applName; baseApplName = _applName;
char cCurrentPath[FILENAME_MAX]; char cCurrentPath[FILENAME_MAX];
char * basicPath = getenv("HOME"); char * basicPath = getenv("HOME");
@ -266,6 +266,8 @@ void etk::InitDefaultFolder(const char * applName)
TK_ERROR("ERROR while trying to get the path of the home folder"); TK_ERROR("ERROR while trying to get the path of the home folder");
#if defined(__TARGET_OS__Windows) #if defined(__TARGET_OS__Windows)
baseFolderHome = "c:/"; baseFolderHome = "c:/";
#elif defined(__TARGET_OS__Android)
baseFolderHome = "/sdcard";
#else #else
baseFolderHome = "~"; baseFolderHome = "~";
#endif #endif
@ -368,16 +370,16 @@ bool etk::FSNode::LoadDataZip(void)
static int32_t FSNODE_LOCAL_mkdir(const char *path, mode_t mode) static int32_t FSNODE_LOCAL_mkdir(const char* _path, mode_t _mode)
{ {
struct stat st; struct stat st;
int32_t status = 0; int32_t status = 0;
if (stat(path, &st) != 0) { if (stat(_path, &st) != 0) {
/* Directory does not exist. EEXIST for race condition */ /* Directory does not exist. EEXIST for race condition */
#ifdef __TARGET_OS__Windows #ifdef __TARGET_OS__Windows
if(0!=mkdir(path) if(0!=mkdir(_path)
#else #else
if(0!=mkdir(path, mode) if(0!=mkdir(_path, _mode)
#endif #endif
&& errno != EEXIST) { && errno != EEXIST) {
status = -1; status = -1;
@ -390,12 +392,12 @@ static int32_t FSNODE_LOCAL_mkdir(const char *path, mode_t mode)
return(status); return(status);
} }
static int32_t FSNODE_LOCAL_mkPath(const char *path, mode_t mode) static int32_t FSNODE_LOCAL_mkPath(const char* _path, mode_t _mode)
{ {
char *pp; char *pp;
char *sp; char *sp;
int status; int status;
char *copypath = strdup(path); char *copypath = strdup(_path);
if (NULL==copypath) { if (NULL==copypath) {
return -1; return -1;
} }
@ -405,13 +407,13 @@ static int32_t FSNODE_LOCAL_mkPath(const char *path, mode_t mode)
if (sp != pp) { if (sp != pp) {
/* Neither root nor double slash in path */ /* Neither root nor double slash in path */
*sp = '\0'; *sp = '\0';
status = FSNODE_LOCAL_mkdir(copypath, mode); status = FSNODE_LOCAL_mkdir(copypath, _mode);
*sp = '/'; *sp = '/';
} }
pp = sp + 1; pp = sp + 1;
} }
if (status == 0) { if (status == 0) {
status = FSNODE_LOCAL_mkdir(path, mode); status = FSNODE_LOCAL_mkdir(_path, _mode);
} }
free(copypath); free(copypath);
return (status); return (status);
@ -424,7 +426,7 @@ static int32_t FSNODE_LOCAL_mkPath(const char *path, mode_t mode)
#undef __class__ #undef __class__
#define __class__ "FSNode" #define __class__ "FSNode"
etk::FSNode::FSNode(const etk::UString& nodeName) : etk::FSNode::FSNode(const etk::UString& _nodeName) :
m_userFileName(""), m_userFileName(""),
m_type(etk::FSN_TYPE_UNKNOW), m_type(etk::FSN_TYPE_UNKNOW),
m_typeNode(etk::FSN_UNKNOW), m_typeNode(etk::FSN_UNKNOW),
@ -437,7 +439,7 @@ etk::FSNode::FSNode(const etk::UString& nodeName) :
m_zipReadingOffset(-1) m_zipReadingOffset(-1)
#endif #endif
{ {
PrivateSetName(nodeName); PrivateSetName(_nodeName);
} }
@ -454,28 +456,28 @@ etk::FSNode::~FSNode(void)
} }
void etk::FSNode::SortElementList(etk::Vector<etk::FSNode *> &list) void etk::FSNode::SortElementList(etk::Vector<etk::FSNode *>& _list)
{ {
etk::Vector<etk::FSNode *> tmpList = list; etk::Vector<etk::FSNode *> tmpList = _list;
list.Clear(); _list.Clear();
for(int32_t iii=0; iii<tmpList.Size(); iii++) { for(int32_t iii=0; iii<tmpList.Size(); iii++) {
if (NULL != tmpList[iii]) { if (NULL != tmpList[iii]) {
int32_t findPos = 0; int32_t findPos = 0;
for(int32_t jjj=0; jjj<list.Size(); jjj++) { for(int32_t jjj=0; jjj<_list.Size(); jjj++) {
//EWOL_DEBUG("compare : \""<<*tmpList[iii] << "\" and \"" << *m_listDirectory[jjj] << "\""); //EWOL_DEBUG("compare : \""<<*tmpList[iii] << "\" and \"" << *m_listDirectory[jjj] << "\"");
if (list[jjj]!=NULL) { if (_list[jjj]!=NULL) {
if (tmpList[iii]->GetNameFile() > list[jjj]->GetNameFile()) { if (tmpList[iii]->GetNameFile() > _list[jjj]->GetNameFile()) {
findPos = jjj+1; findPos = jjj+1;
} }
} }
} }
//EWOL_DEBUG("position="<<findPos); //EWOL_DEBUG("position="<<findPos);
list.Insert(findPos, tmpList[iii]); _list.Insert(findPos, tmpList[iii]);
} }
} }
} }
void etk::FSNode::PrivateSetName(const etk::UString& newName) void etk::FSNode::PrivateSetName(const etk::UString& _newName)
{ {
if( NULL != m_PointerFile if( NULL != m_PointerFile
#ifdef __TARGET_OS__Android #ifdef __TARGET_OS__Android
@ -495,15 +497,15 @@ void etk::FSNode::PrivateSetName(const etk::UString& newName)
// Reset ALL DATA : // Reset ALL DATA :
m_userFileName = ""; m_userFileName = "";
m_type = etk::FSN_TYPE_UNKNOW; m_type = etk::FSN_TYPE_UNKNOW;
TK_DBG_MODE("1 : Set Name : \"" << newName << "\""); TK_DBG_MODE("1 : Set Name : \"" << _newName << "\"");
// generate destination name in case of the input error // generate destination name in case of the input error
etk::UString destFilename; etk::UString destFilename;
if (newName.Size() == 0) { if (_newName.Size() == 0) {
// if no name ==> go to the root Folder // if no name ==> go to the root Folder
destFilename = "ROOT:"; destFilename = "ROOT:";
} else { } else {
destFilename = newName; destFilename = _newName;
} }
bool isRootFolder = false; bool isRootFolder = false;
@ -617,12 +619,12 @@ void etk::FSNode::PrivateSetName(const etk::UString& newName)
} }
bool DirectCheckFile(etk::UString tmpFileNameDirect, bool checkInAPKIfNeeded=false) bool DirectCheckFile(etk::UString _tmpFileNameDirect, bool _checkInAPKIfNeeded=false)
{ {
#ifdef __TARGET_OS__Android #ifdef __TARGET_OS__Android
if (true == checkInAPKIfNeeded) { if (true == _checkInAPKIfNeeded) {
if( NULL != s_APKArchive if( NULL != s_APKArchive
&& true == s_APKArchive->Exist(tmpFileNameDirect) ) { && true == s_APKArchive->Exist(_tmpFileNameDirect) ) {
return true; return true;
} }
return false; return false;
@ -630,7 +632,7 @@ bool DirectCheckFile(etk::UString tmpFileNameDirect, bool checkInAPKIfNeeded=fal
#endif #endif
// tmpStat Buffer : // tmpStat Buffer :
struct stat statProperty; struct stat statProperty;
if (-1 == stat(tmpFileNameDirect.c_str(), &statProperty)) { if (-1 == stat(_tmpFileNameDirect.c_str(), &statProperty)) {
return false; return false;
} }
return true; return true;
@ -794,16 +796,16 @@ void etk::FSNode::UpdateFileSystemProperty(void)
return; return;
} }
bool etk::FSNode::SetRight(etk::FSNodeRight newRight) bool etk::FSNode::SetRight(etk::FSNodeRight _newRight)
{ {
// TODO : ... // TODO : ...
TK_ERROR("Can not set the new rights ..."); TK_ERROR("Can not set the new rights ...");
return false; return false;
} }
void etk::FSNode::SetName(const etk::UString& newName) void etk::FSNode::SetName(const etk::UString& _newName)
{ {
PrivateSetName(newName); PrivateSetName(_newName);
} }
etk::UString etk::FSNode::GetNameFolder(void) const etk::UString etk::FSNode::GetNameFolder(void) const
@ -920,9 +922,9 @@ bool etk::FSNode::Touch(void)
return ret; return ret;
} }
bool etk::FSNode::Move(const etk::UString& path) bool etk::FSNode::Move(const etk::UString& _path)
{ {
etk::FSNode tmpDst(path); etk::FSNode tmpDst(_path);
if (tmpDst.Exist()==true) { if (tmpDst.Exist()==true) {
tmpDst.Remove(); tmpDst.Remove();
} }
@ -1003,9 +1005,9 @@ etk::UString etk::FSNode::TimeAccessedString(void) const
/* /*
Operator : Operator :
*/ */
const etk::FSNode& etk::FSNode::operator= (const etk::FSNode &obj ) const etk::FSNode& etk::FSNode::operator= (const etk::FSNode &_obj )
{ {
if( this != &obj ) // avoid copy to itself if( this != &_obj ) // avoid copy to itself
{ {
if( NULL != m_PointerFile if( NULL != m_PointerFile
#ifdef __TARGET_OS__Android #ifdef __TARGET_OS__Android
@ -1020,17 +1022,17 @@ const etk::FSNode& etk::FSNode::operator= (const etk::FSNode &obj )
m_zipContent = NULL; m_zipContent = NULL;
m_zipReadingOffset = 0; m_zipReadingOffset = 0;
#endif #endif
etk::UString tmppp = obj.GetName(); etk::UString tmppp = _obj.GetName();
PrivateSetName(tmppp); PrivateSetName(tmppp);
} }
return *this; return *this;
} }
bool etk::FSNode::operator== (const etk::FSNode &obj ) const bool etk::FSNode::operator== (const etk::FSNode& _obj ) const
{ {
if( this != &obj ) { if( this != &_obj ) {
if( obj.m_userFileName == m_userFileName if( _obj.m_userFileName == m_userFileName
&& obj.m_systemFileName == m_systemFileName && _obj.m_systemFileName == m_systemFileName
&& obj.m_type == m_type ) { && _obj.m_type == m_type ) {
return true; return true;
} else { } else {
return false; return false;
@ -1040,88 +1042,88 @@ bool etk::FSNode::operator== (const etk::FSNode &obj ) const
return true; return true;
} }
bool etk::FSNode::operator!= (const etk::FSNode &obj ) const bool etk::FSNode::operator!= (const etk::FSNode& _obj ) const
{ {
return !(*this == obj); return !(*this == _obj);
} }
etk::CCout& etk::operator <<(etk::CCout &os, const etk::FSNode &obj) etk::CCout& etk::operator <<(etk::CCout &_os, const etk::FSNode &_obj)
{ {
os << "[" << obj.m_type << "]->\"" << obj.m_userFileName << "\""; _os << "[" << _obj.m_type << "]->\"" << _obj.m_userFileName << "\"";
return os; return _os;
} }
etk::CCout& etk::operator <<(etk::CCout &os, const etk::FSNType_te &obj) etk::CCout& etk::operator <<(etk::CCout &_os, const etk::FSNType_te &_obj)
{ {
switch (obj) switch (_obj)
{ {
case etk::FSN_TYPE_UNKNOW: case etk::FSN_TYPE_UNKNOW:
os << "FSN_TYPE_UNKNOW"; _os << "FSN_TYPE_UNKNOW";
break; break;
case etk::FSN_TYPE_DIRECT: case etk::FSN_TYPE_DIRECT:
os << "FSN_TYPE_DIRECT"; _os << "FSN_TYPE_DIRECT";
break; break;
case etk::FSN_TYPE_RELATIF: case etk::FSN_TYPE_RELATIF:
os << "FSN_TYPE_RELATIF"; _os << "FSN_TYPE_RELATIF";
break; break;
case etk::FSN_TYPE_HOME: case etk::FSN_TYPE_HOME:
os << "FSN_TYPE_HOME"; _os << "FSN_TYPE_HOME";
break; break;
case etk::FSN_TYPE_DATA: case etk::FSN_TYPE_DATA:
os << "FSN_TYPE_DATA"; _os << "FSN_TYPE_DATA";
break; break;
case etk::FSN_TYPE_USER_DATA: case etk::FSN_TYPE_USER_DATA:
os << "FSN_TYPE_USER_DATA"; _os << "FSN_TYPE_USER_DATA";
break; break;
case etk::FSN_TYPE_CACHE: case etk::FSN_TYPE_CACHE:
os << "FSN_TYPE_CACHE"; _os << "FSN_TYPE_CACHE";
break; break;
case etk::FSN_TYPE_THEME: case etk::FSN_TYPE_THEME:
os << "FSN_TYPE_THEME"; _os << "FSN_TYPE_THEME";
break; break;
case etk::FSN_TYPE_THEME_DATA: case etk::FSN_TYPE_THEME_DATA:
os << "FSN_TYPE_THEME(DATA)"; _os << "FSN_TYPE_THEME(DATA)";
break; break;
default: default:
os << "FSN_TYPE_????"; _os << "FSN_TYPE_????";
break; break;
} }
return os; return _os;
} }
etk::CCout& etk::operator <<(etk::CCout &os, const etk::typeNode_te &obj) etk::CCout& etk::operator <<(etk::CCout &_os, const etk::typeNode_te &_obj)
{ {
switch (obj) switch (_obj)
{ {
case etk::FSN_UNKNOW: case etk::FSN_UNKNOW:
os << "FSN_UNKNOW"; _os << "FSN_UNKNOW";
break; break;
case etk::FSN_BLOCK: case etk::FSN_BLOCK:
os << "FSN_BLOCK"; _os << "FSN_BLOCK";
break; break;
case etk::FSN_CHARACTER: case etk::FSN_CHARACTER:
os << "FSN_CHARACTER"; _os << "FSN_CHARACTER";
break; break;
case etk::FSN_FOLDER: case etk::FSN_FOLDER:
os << "FSN_FOLDER"; _os << "FSN_FOLDER";
break; break;
case etk::FSN_FIFO: case etk::FSN_FIFO:
os << "FSN_FIFO"; _os << "FSN_FIFO";
break; break;
case etk::FSN_LINK: case etk::FSN_LINK:
os << "FSN_LINK"; _os << "FSN_LINK";
break; break;
case etk::FSN_FILE: case etk::FSN_FILE:
os << "FSN_FILE"; _os << "FSN_FILE";
break; break;
case etk::FSN_SOCKET: case etk::FSN_SOCKET:
os << "FSN_SOCKET"; _os << "FSN_SOCKET";
break; break;
default: default:
os << "FSN_????"; _os << "FSN_????";
break; break;
} }
return os; return _os;
} }
/* /*
@ -1151,7 +1153,7 @@ int64_t etk::FSNode::FolderCount(void)
} }
return counter; return counter;
} }
etk::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::Vector<etk::FSNode*> tmpp; etk::Vector<etk::FSNode*> tmpp;
if (m_typeNode != etk::FSN_FOLDER ) { if (m_typeNode != etk::FSN_FOLDER ) {
@ -1174,20 +1176,20 @@ etk::Vector<etk::FSNode *> etk::FSNode::FolderGetSubList(bool showHidenFile, boo
continue; continue;
} }
if( false == tmpName.StartWith(".") if( false == tmpName.StartWith(".")
|| true == showHidenFile) { || true == _showHidenFile) {
tmpEmement = new etk::FSNode(GetRelativeFolder()+tmpName); tmpEmement = new etk::FSNode(GetRelativeFolder()+tmpName);
if (NULL == tmpEmement) { if (NULL == tmpEmement) {
TK_ERROR("allocation error ... of ewol::FSNode"); TK_ERROR("allocation error ... of ewol::FSNode");
continue; continue;
} }
if(tmpEmement->GetNodeType() == etk::FSN_FILE) { if(tmpEmement->GetNodeType() == etk::FSN_FILE) {
if (true == getFile) { if (true == _getFile) {
tmpp.PushBack(tmpEmement); tmpp.PushBack(tmpEmement);
} else { } else {
delete(tmpEmement); delete(tmpEmement);
tmpEmement = NULL; tmpEmement = NULL;
} }
} else if (getFolderAndOther) { } else if (_getFolderAndOther) {
tmpp.PushBack(tmpEmement); tmpp.PushBack(tmpEmement);
} else { } else {
delete(tmpEmement); delete(tmpEmement);
@ -1211,7 +1213,7 @@ etk::FSNode etk::FSNode::FolderGetParent(void)
return tmpp; return tmpp;
} }
void etk::FSNode::FolderGetRecursiveFiles(etk::Vector<etk::UString>& output, bool recursiveEnable) void etk::FSNode::FolderGetRecursiveFiles(etk::Vector<etk::UString>& _output, bool _recursiveEnable)
{ {
#ifdef __TARGET_OS__Android #ifdef __TARGET_OS__Android
if( m_type == etk::FSN_TYPE_DATA if( m_type == etk::FSN_TYPE_DATA
@ -1234,7 +1236,7 @@ void etk::FSNode::FolderGetRecursiveFiles(etk::Vector<etk::UString>& output, boo
filename.Remove(0,assetsName.Size()); filename.Remove(0,assetsName.Size());
} }
tmpString += filename; tmpString += filename;
output.PushBack(tmpString); _output.PushBack(tmpString);
} }
} }
return; return;
@ -1260,11 +1262,11 @@ void etk::FSNode::FolderGetRecursiveFiles(etk::Vector<etk::UString>& output, boo
if (NULL != tmpEmement) { if (NULL != tmpEmement) {
if(tmpEmement->GetNodeType() == etk::FSN_FILE) { if(tmpEmement->GetNodeType() == etk::FSN_FILE) {
etk::UString tmpVal = tmpEmement->GetName(); etk::UString tmpVal = tmpEmement->GetName();
output.PushBack(tmpVal); _output.PushBack(tmpVal);
} }
if(tmpEmement->GetNodeType() == etk::FSN_FOLDER) { if(tmpEmement->GetNodeType() == etk::FSN_FOLDER) {
if (true==recursiveEnable) { if (true==_recursiveEnable) {
tmpEmement->FolderGetRecursiveFiles(output); tmpEmement->FolderGetRecursiveFiles(_output, _recursiveEnable);
} }
} }
delete(tmpEmement); delete(tmpEmement);
@ -1433,11 +1435,11 @@ bool etk::FSNode::FileClose(void)
m_PointerFile = NULL; m_PointerFile = NULL;
return true; return true;
} }
char* etk::FSNode::FileGets(char * elementLine, int64_t maxData) char* etk::FSNode::FileGets(char * _elementLine, int64_t _maxData)
{ {
memset(elementLine, 0, maxData); memset(_elementLine, 0, _maxData);
#ifdef __TARGET_OS__Android #ifdef __TARGET_OS__Android
char * element = elementLine; char * element = _elementLine;
int64_t outSize = 0; int64_t outSize = 0;
if( etk::FSN_TYPE_DATA == m_type if( etk::FSN_TYPE_DATA == m_type
|| etk::FSN_TYPE_THEME_DATA == m_type) {//char * tmpData = internalDataFiles[iii].data + m_readingOffset; || etk::FSN_TYPE_THEME_DATA == m_type) {//char * tmpData = internalDataFiles[iii].data + m_readingOffset;
@ -1445,7 +1447,7 @@ char* etk::FSNode::FileGets(char * elementLine, int64_t maxData)
element[0] = '\0'; element[0] = '\0';
return NULL; return NULL;
} }
if (m_zipReadingOffset>m_zipContent->Size()) { if (m_zipReadingOffset>=m_zipContent->Size()) {
element[0] = '\0'; element[0] = '\0';
return NULL; return NULL;
} }
@ -1457,19 +1459,19 @@ char* etk::FSNode::FileGets(char * elementLine, int64_t maxData)
element++; element++;
m_zipReadingOffset++; m_zipReadingOffset++;
*element = '\0'; *element = '\0';
return elementLine; return _elementLine;
} }
*element = ((char*)m_zipContent->Data())[m_zipReadingOffset]; *element = ((char*)m_zipContent->Data())[m_zipReadingOffset];
element++; element++;
m_zipReadingOffset++; m_zipReadingOffset++;
if (m_zipReadingOffset>m_zipContent->Size()) { if (m_zipReadingOffset>=m_zipContent->Size()) {
*element = '\0'; *element = '\0';
return elementLine; return _elementLine;
} }
// check maxData Size ... // check maxData Size ...
if (outSize>=maxData-1) { if (outSize>=_maxData-1) {
*element = '\0'; *element = '\0';
return elementLine; return _elementLine;
} }
outSize++; outSize++;
} }
@ -1477,34 +1479,34 @@ char* etk::FSNode::FileGets(char * elementLine, int64_t maxData)
return NULL; return NULL;
} else { } else {
// send last line // send last line
return elementLine; return _elementLine;
} }
} }
#endif #endif
return fgets(elementLine, maxData, m_PointerFile); return fgets(_elementLine, _maxData, m_PointerFile);
} }
int64_t etk::FSNode::FileRead(void * data, int64_t blockSize, int64_t nbBlock) int64_t etk::FSNode::FileRead(void* _data, int64_t _blockSize, int64_t _nbBlock)
{ {
#ifdef __TARGET_OS__Android #ifdef __TARGET_OS__Android
if( etk::FSN_TYPE_DATA == m_type if( etk::FSN_TYPE_DATA == m_type
|| etk::FSN_TYPE_THEME_DATA == m_type) { || etk::FSN_TYPE_THEME_DATA == m_type) {
if (NULL == m_zipContent) { if (NULL == m_zipContent) {
((char*)data)[0] = '\0'; ((char*)_data)[0] = '\0';
return 0; return 0;
} }
int32_t dataToRead = blockSize * nbBlock; int32_t dataToRead = _blockSize * _nbBlock;
if (dataToRead + m_zipReadingOffset > m_zipContent->Size()) { if (dataToRead + m_zipReadingOffset > m_zipContent->Size()) {
nbBlock = ((m_zipContent->Size() - m_zipReadingOffset) / blockSize); _nbBlock = ((m_zipContent->Size() - m_zipReadingOffset) / _blockSize);
dataToRead = blockSize * nbBlock; dataToRead = _blockSize * _nbBlock;
} }
memcpy(data, &((char*)m_zipContent->Data())[m_zipReadingOffset], dataToRead); memcpy(_data, &((char*)m_zipContent->Data())[m_zipReadingOffset], dataToRead);
m_zipReadingOffset += dataToRead; m_zipReadingOffset += dataToRead;
return nbBlock; return _nbBlock;
} }
#endif #endif
return fread(data, blockSize, nbBlock, m_PointerFile); return fread(_data, _blockSize, _nbBlock, m_PointerFile);
} }
int64_t etk::FSNode::FileWrite(void * data, int64_t blockSize, int64_t nbBlock) int64_t etk::FSNode::FileWrite(void * _data, int64_t _blockSize, int64_t _nbBlock)
{ {
#ifdef __TARGET_OS__Android #ifdef __TARGET_OS__Android
if( etk::FSN_TYPE_DATA == m_type if( etk::FSN_TYPE_DATA == m_type
@ -1513,9 +1515,9 @@ int64_t etk::FSNode::FileWrite(void * data, int64_t blockSize, int64_t nbBlock)
return 0; return 0;
} }
#endif #endif
return fwrite(data, blockSize, nbBlock, m_PointerFile); return fwrite(_data, _blockSize, _nbBlock, m_PointerFile);
} }
bool etk::FSNode::FileSeek(long int offset, etk::seekNode_te origin) bool etk::FSNode::FileSeek(long int _offset, etk::seekNode_te _origin)
{ {
#ifdef __TARGET_OS__Android #ifdef __TARGET_OS__Android
if( etk::FSN_TYPE_DATA == m_type if( etk::FSN_TYPE_DATA == m_type
@ -1524,7 +1526,7 @@ bool etk::FSNode::FileSeek(long int offset, etk::seekNode_te origin)
return false; return false;
} }
int32_t positionEnd = 0; int32_t positionEnd = 0;
switch(origin) { switch(_origin) {
case etk::FSN_SEEK_END: case etk::FSN_SEEK_END:
positionEnd = m_zipContent->Size(); positionEnd = m_zipContent->Size();
break; break;
@ -1535,7 +1537,7 @@ bool etk::FSNode::FileSeek(long int offset, etk::seekNode_te origin)
positionEnd = 0; positionEnd = 0;
break; break;
} }
positionEnd += offset; positionEnd += _offset;
if (positionEnd < 0) { if (positionEnd < 0) {
positionEnd = 0; positionEnd = 0;
} else if (positionEnd > m_zipContent->Size()) { } else if (positionEnd > m_zipContent->Size()) {
@ -1546,7 +1548,7 @@ bool etk::FSNode::FileSeek(long int offset, etk::seekNode_te origin)
} }
#endif #endif
int originFS = 0; int originFS = 0;
switch(origin) { switch(_origin) {
case etk::FSN_SEEK_END: case etk::FSN_SEEK_END:
originFS = SEEK_END; originFS = SEEK_END;
break; break;
@ -1557,7 +1559,7 @@ bool etk::FSNode::FileSeek(long int offset, etk::seekNode_te origin)
originFS = 0; originFS = 0;
break; break;
} }
fseek(m_PointerFile, offset, originFS); fseek(m_PointerFile, _offset, originFS);
if(ferror(m_PointerFile)) { if(ferror(m_PointerFile)) {
return false; return false;
} else { } else {
@ -1593,12 +1595,12 @@ class tmpThemeElement
static etk::Vector<tmpThemeElement*> g_listTheme; static etk::Vector<tmpThemeElement*> g_listTheme;
// set the Folder of a subset of a theme ... // set the Folder of a subset of a theme ...
void etk::theme::SetName(etk::UString refName, etk::UString folderName) void etk::theme::SetName(etk::UString _refName, etk::UString _folderName)
{ {
for(int32_t iii=0; iii<g_listTheme.Size(); iii++) { for(int32_t iii=0; iii<g_listTheme.Size(); iii++) {
if (NULL != g_listTheme[iii]) { if (NULL != g_listTheme[iii]) {
if (g_listTheme[iii]->refName==refName) { if (g_listTheme[iii]->refName==_refName) {
g_listTheme[iii]->folderName = folderName; g_listTheme[iii]->folderName = _folderName;
// action done // action done
return; return;
} }
@ -1610,23 +1612,23 @@ void etk::theme::SetName(etk::UString refName, etk::UString folderName)
TK_ERROR("pb to add a reference theme"); TK_ERROR("pb to add a reference theme");
return; return;
} }
tmpp->refName = refName; tmpp->refName = _refName;
tmpp->folderName = folderName; tmpp->folderName = _folderName;
g_listTheme.PushBack(tmpp); g_listTheme.PushBack(tmpp);
} }
// get the folder from a Reference theme // get the folder from a Reference theme
etk::UString etk::theme::GetName(etk::UString refName) etk::UString etk::theme::GetName(etk::UString _refName)
{ {
for(int32_t iii=0; iii<g_listTheme.Size(); iii++) { for(int32_t iii=0; iii<g_listTheme.Size(); iii++) {
if (NULL != g_listTheme[iii]) { if (NULL != g_listTheme[iii]) {
if (g_listTheme[iii]->refName==refName) { if (g_listTheme[iii]->refName==_refName) {
return g_listTheme[iii]->folderName; return g_listTheme[iii]->folderName;
} }
} }
} }
// We did not find the theme // We did not find the theme
return refName; return _refName;
} }
// get the list of all the theme folder availlable in the user Home/appl // get the list of all the theme folder availlable in the user Home/appl
@ -1643,88 +1645,88 @@ etk::Vector<etk::UString> etk::theme::List(void)
* Simple direct wrapper on the FileSystem node access : * Simple direct wrapper on the FileSystem node access :
* *
* -------------------------------------------------------------------------- */ * -------------------------------------------------------------------------- */
bool etk::FSNodeRemove(const etk::UString& path) bool etk::FSNodeRemove(const etk::UString& _path)
{ {
etk::FSNode tmpNode(path); etk::FSNode tmpNode(_path);
if (false==tmpNode.Exist()) { if (false==tmpNode.Exist()) {
return false; return false;
} }
return tmpNode.Remove(); return tmpNode.Remove();
} }
int64_t etk::FSNodeGetCount(const etk::UString& path) int64_t etk::FSNodeGetCount(const etk::UString& _path)
{ {
etk::FSNode tmpNode(path); etk::FSNode tmpNode(_path);
if (false==tmpNode.Exist()) { if (false==tmpNode.Exist()) {
return -1; return -1;
} }
return tmpNode.FolderCount(); return tmpNode.FolderCount();
} }
bool etk::FSNodeCreate(const etk::UString& path, etk::FSNodeRight right, etk::typeNode_te type) bool etk::FSNodeCreate(const etk::UString& _path, etk::FSNodeRight _right, etk::typeNode_te _type)
{ {
// TODO : // TODO :
return false; return false;
} }
bool etk::FSNodeExist(const etk::UString& path) bool etk::FSNodeExist(const etk::UString& _path)
{ {
etk::FSNode tmpNode(path); etk::FSNode tmpNode(_path);
return tmpNode.Exist(); return tmpNode.Exist();
} }
bool etk::FSNodeMove(const etk::UString& path1, const etk::UString& path2) bool etk::FSNodeMove(const etk::UString& _path1, const etk::UString& _path2)
{ {
etk::FSNode tmpNode(path1); etk::FSNode tmpNode(_path1);
if (false==tmpNode.Exist()) { if (false==tmpNode.Exist()) {
TK_DEBUG("try to move un existant file \"" << path1 << "\""); TK_DEBUG("try to move un existant file \"" << _path1 << "\"");
return false; return false;
} }
// no check error in every case // no check error in every case
(void)etk::FSNodeRemove(path2); (void)etk::FSNodeRemove(_path2);
//move the node //move the node
return tmpNode.Move(path2); return tmpNode.Move(_path2);
} }
etk::FSNodeRight etk::FSNodeGetRight(const etk::UString& path) etk::FSNodeRight etk::FSNodeGetRight(const etk::UString& _path)
{ {
etk::FSNode tmpNode(path); etk::FSNode tmpNode(_path);
return tmpNode.GetRight(); return tmpNode.GetRight();
} }
etk::typeNode_te etk::FSNodeGetType(const etk::UString& path) etk::typeNode_te etk::FSNodeGetType(const etk::UString& _path)
{ {
etk::FSNode tmpNode(path); etk::FSNode tmpNode(_path);
return tmpNode.GetNodeType(); return tmpNode.GetNodeType();
} }
uint64_t etk::FSNodeGetTimeCreated(const etk::UString& path) uint64_t etk::FSNodeGetTimeCreated(const etk::UString& _path)
{ {
etk::FSNode tmpNode(path); etk::FSNode tmpNode(_path);
return tmpNode.TimeCreated(); return tmpNode.TimeCreated();
} }
uint64_t etk::FSNodeGetTimeModified(const etk::UString& path) uint64_t etk::FSNodeGetTimeModified(const etk::UString& _path)
{ {
etk::FSNode tmpNode(path); etk::FSNode tmpNode(_path);
return tmpNode.TimeModified(); return tmpNode.TimeModified();
} }
uint64_t etk::FSNodeGetTimeAccessed(const etk::UString& path) uint64_t etk::FSNodeGetTimeAccessed(const etk::UString& _path)
{ {
etk::FSNode tmpNode(path); etk::FSNode tmpNode(_path);
return tmpNode.TimeAccessed(); return tmpNode.TimeAccessed();
} }
bool etk::FSNodeTouch(const etk::UString& path) bool etk::FSNodeTouch(const etk::UString& _path)
{ {
etk::FSNode tmpNode(path); etk::FSNode tmpNode(_path);
return tmpNode.Touch(); return tmpNode.Touch();
} }
bool etk::FSNodeEcho(const etk::UString& path, const etk::UString& dataTowrite) bool etk::FSNodeEcho(const etk::UString& _path, const etk::UString& _dataTowrite)
{ {
etk::FSNode tmpNode(path); etk::FSNode tmpNode(_path);
if (false==tmpNode.Exist()) { if (false==tmpNode.Exist()) {
return false; return false;
} }
@ -1735,7 +1737,7 @@ bool etk::FSNodeEcho(const etk::UString& path, const etk::UString& dataTowrite)
return false; return false;
} }
// convert in UTF8 : // convert in UTF8 :
etk::Char tmpChar = dataTowrite.c_str(); etk::Char tmpChar = _dataTowrite.c_str();
int32_t nbChar = strlen(tmpChar); int32_t nbChar = strlen(tmpChar);
if (nbChar != tmpNode.FileWrite(tmpChar, 1, nbChar)) { if (nbChar != tmpNode.FileWrite(tmpChar, 1, nbChar)) {
tmpNode.FileClose(); tmpNode.FileClose();
@ -1744,9 +1746,9 @@ bool etk::FSNodeEcho(const etk::UString& path, const etk::UString& dataTowrite)
return tmpNode.FileClose(); return tmpNode.FileClose();
} }
bool etk::FSNodeEchoAdd(const etk::UString& path, const etk::UString& dataTowrite) bool etk::FSNodeEchoAdd(const etk::UString& _path, const etk::UString& _dataTowrite)
{ {
etk::FSNode tmpNode(path); etk::FSNode tmpNode(_path);
if (false==tmpNode.Exist()) { if (false==tmpNode.Exist()) {
return false; return false;
} }
@ -1757,7 +1759,7 @@ bool etk::FSNodeEchoAdd(const etk::UString& path, const etk::UString& dataTowrit
return false; return false;
} }
// convert in UTF8 : // convert in UTF8 :
etk::Char tmpChar = dataTowrite.c_str(); etk::Char tmpChar = _dataTowrite.c_str();
int32_t nbChar = strlen(tmpChar); int32_t nbChar = strlen(tmpChar);
if (nbChar != tmpNode.FileWrite(tmpChar, 1, nbChar)) { if (nbChar != tmpNode.FileWrite(tmpChar, 1, nbChar)) {
tmpNode.FileClose(); tmpNode.FileClose();

188
etk/os/FSNode.h
View File

@ -22,7 +22,7 @@
namespace etk namespace etk
{ {
void SetArgZero(const etk::UString& val); void SetArgZero(const etk::UString& _val);
/** /**
* List of Type that a node can have (this wrap some type that not exist on Windows) * List of Type that a node can have (this wrap some type that not exist on Windows)
*/ */
@ -37,7 +37,7 @@ namespace etk
FSN_SOCKET, //!< The node is a socket FSN_SOCKET, //!< The node is a socket
} typeNode_te; } typeNode_te;
etk::CCout& operator <<(etk::CCout &os, const etk::typeNode_te &obj); etk::CCout& operator <<(etk::CCout &_os, const etk::typeNode_te &_obj);
typedef enum { typedef enum {
FSN_SEEK_START, FSN_SEEK_START,
@ -87,7 +87,7 @@ namespace etk
FSN_TYPE_THEME_DATA FSN_TYPE_THEME_DATA
} FSNType_te; } FSNType_te;
etk::CCout& operator <<(etk::CCout &os, const etk::FSNType_te &obj); etk::CCout& operator <<(etk::CCout &_os, const etk::FSNType_te &_obj);
/* /*
note : The filename can be note : The filename can be
@ -138,9 +138,9 @@ namespace etk
public: public:
/** /**
* @brief Constructor * @brief Constructor
* @param[in] path Path of the curent file /folder ... * @param[in] _path Path of the curent file /folder ...
*/ */
FSNode(const etk::UString& path="~"); FSNode(const etk::UString& _path="~");
/** /**
* @brief Destructor * @brief Destructor
* @note you will have some warning if you did not close your files * @note you will have some warning if you did not close your files
@ -157,9 +157,9 @@ namespace etk
void UpdateFileSystemProperty(void); void UpdateFileSystemProperty(void);
/** /**
* @brief Common set name of the Node (if the user decide to change the node selection * @brief Common set name of the Node (if the user decide to change the node selection
* @param[in] newName Name of the Node * @param[in] _newName Name of the Node
*/ */
void PrivateSetName(const etk::UString& newName); void PrivateSetName(const etk::UString& _newName);
private: private:
#ifdef __TARGET_OS__Android #ifdef __TARGET_OS__Android
/** /**
@ -190,18 +190,18 @@ namespace etk
etk::FSNodeRight GetRight(void) const { return m_rights; }; etk::FSNodeRight GetRight(void) const { return m_rights; };
/** /**
* @brief Set the specific right of the node * @brief Set the specific right of the node
* @param[in] newRight new right to set * @param[in] _newRight new right to set
* @return true : action done * @return true : action done
* @return false : action not done * @return false : action not done
*/ */
bool SetRight(etk::FSNodeRight newRight); bool SetRight(etk::FSNodeRight _newRight);
/** /**
* @brief Change the Node seeing (not rename the node, for this @ref Move) * @brief Change the Node seeing (not rename the node, for this @ref Move)
* @param[in] newName New node name to show * @param[in] _newName New node name to show
* @return true : action done * @return true : action done
* @return false : action not done * @return false : action not done
*/ */
void SetName(const etk::UString& newName); void SetName(const etk::UString& _newName);
/** /**
* @brief Get the Generate FileSystem name * @brief Get the Generate FileSystem name
* @return the requested filename * @return the requested filename
@ -238,11 +238,11 @@ namespace etk
bool Touch(void); bool Touch(void);
/** /**
* @brief Move the Node at a new path * @brief Move the Node at a new path
* @param[in] path The new path * @param[in] _path The new path
* @return true : action done * @return true : action done
* @return false : action not done * @return false : action not done
*/ */
bool Move(const etk::UString& path); bool Move(const etk::UString& _path);
/** /**
* @brief Get the node type (DATA/DIRECT...) * @brief Get the node type (DATA/DIRECT...)
* @return the requested type * @return the requested type
@ -286,29 +286,29 @@ namespace etk
etk::UString TimeAccessedString(void) const; etk::UString TimeAccessedString(void) const;
/** /**
* @brief copy the other FSnode ==> for vector * @brief copy the other FSnode ==> for vector
* @param[in] obj input node * @param[in] _obj input node
* @return the current modify node * @return the current modify node
*/ */
const etk::FSNode& operator= (const etk::FSNode &obj ); const etk::FSNode& operator= (const etk::FSNode &_obj );
/** /**
* @brief Check if the 2 node are link with the same file * @brief Check if the 2 node are link with the same file
* @param[in] obj input node * @param[in] _obj input node
* @return true : same node, false otherwise * @return true : same node, false otherwise
*/ */
bool operator== (const etk::FSNode &obj ) const; bool operator== (const etk::FSNode &_obj ) const;
/** /**
* @brief Check if the 2 node are NOT link with the same file * @brief Check if the 2 node are NOT link with the same file
* @param[in] obj input node * @param[in] _obj input node
* @return false : same node, true otherwise * @return false : same node, true otherwise
*/ */
bool operator!= (const etk::FSNode &obj ) const; bool operator!= (const etk::FSNode &_obj ) const;
/** /**
* @brief Write in the statard debug IO the current node * @brief Write in the statard debug IO the current node
* @param[in] os std debug IO * @param[in] _os std debug IO
* @param[in] obj Node to display * @param[in] _obj Node to display
* @return std debug IO * @return std debug IO
*/ */
friend etk::CCout& operator <<( etk::CCout &os,const etk::FSNode &obj); friend etk::CCout& operator <<( etk::CCout &_os,const etk::FSNode &_obj);
/** /**
* @brief Count the number of subFolder in the curent Folder * @brief Count the number of subFolder in the curent Folder
@ -318,16 +318,16 @@ namespace etk
int64_t FolderCount(void); int64_t FolderCount(void);
/** /**
* @brief Get the List of all node inside a node (folder only) * @brief Get the List of all node inside a node (folder only)
* @param[in] showHidenFile Add hidden file/folder/... * @param[in] _showHidenFile Add hidden file/folder/...
* @param[in] getFolderAndOther get folder * @param[in] _getFolderAndOther get folder
* @param[in] getFile Get files * @param[in] _getFile Get files
* @param[in] temporaryFile add Tmp file like .bck or ~ * @param[in] _temporaryFile add Tmp file like .bck or ~
* @return The requested list * @return The requested list
*/ */
etk::Vector<etk::FSNode *> FolderGetSubList(bool showHidenFile=true, etk::Vector<etk::FSNode *> FolderGetSubList(bool _showHidenFile=true,
bool getFolderAndOther=true, bool _getFolderAndOther=true,
bool getFile=true, bool _getFile=true,
bool temporaryFile=true); bool _temporaryFile=true);
/** /**
* @brief Get the father node of this node * @brief Get the father node of this node
* @return The requested node * @return The requested node
@ -335,10 +335,10 @@ namespace etk
etk::FSNode FolderGetParent(void); etk::FSNode FolderGetParent(void);
/** /**
* @brief Get all the File inside a Folder (done recursively) * @brief Get all the File inside a Folder (done recursively)
* @param[out] output List of all the File names (You must clear it before set it in) * @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) * @param[in] _recursiveEnable Activate the recursive mode (enable by default)
*/ */
void FolderGetRecursiveFiles(etk::Vector<etk::UString>& output, bool recursiveEnable=true); void FolderGetRecursiveFiles(etk::Vector<etk::UString>& _output, bool _recursiveEnable=true);
/** /**
* @brief Check if the file have an extention ( ***.ccc) * @brief Check if the file have an extention ( ***.ccc)
* @return true The file have an extention. * @return true The file have an extention.
@ -383,35 +383,35 @@ namespace etk
bool FileClose(void); bool FileClose(void);
/** /**
* @brief Get the pointer on the start line and the next line (or null) * @brief Get the pointer on the start line and the next line (or null)
* @param[in,out] elementLine Pointer to an array of chars where the string read is copied. * @param[in,out] _elementLine Pointer to an array of chars where the string read is copied.
* @param[in] maxData Maximum number of characters to be copied into str (including the terminating null-character). * @param[in] _maxData Maximum number of characters to be copied into str (including the terminating null-character).
* @return the pointer on the end of the cuurent line. * @return the pointer on the end of the cuurent line.
*/ */
char* FileGets(char * elementLine, int64_t maxData); char* FileGets(char* _elementLine, int64_t _maxData);
/** /**
* @brief Read data from the file * @brief Read data from the file
* @param[in,out] data Pointer on the buffer that might be set the data * @param[in,out] _data Pointer on the buffer that might be set the data
* @param[in] blockSize Size of one block of data * @param[in] _blockSize Size of one block of data
* @param[in] nbBlock Number of block needed * @param[in] _nbBlock Number of block needed
* @return Number of element read (in block number) * @return Number of element read (in block number)
*/ */
int64_t FileRead(void * data, int64_t blockSize, int64_t nbBlock); int64_t FileRead(void* _data, int64_t _blockSize, int64_t _nbBlock);
/** /**
* @brief Write data on the file * @brief Write data on the file
* @param[in] data Pointer on the buffer that might be set on the file * @param[in] _data Pointer on the buffer that might be set on the file
* @param[in] blockSize Size of one block of data * @param[in] _blockSize Size of one block of data
* @param[in] nbBlock Number of block needed * @param[in] _nbBlock Number of block needed
* @return Number of element written (in block number) * @return Number of element written (in block number)
*/ */
int64_t FileWrite(void * data, int64_t blockSize, int64_t nbBlock); int64_t FileWrite(void* _data, int64_t _blockSize, int64_t _nbBlock);
/** /**
* @brief Move in the file Position * @brief Move in the file Position
* @param[in] offset Offset to apply at the file * @param[in] _offset Offset to apply at the file
* @param[in] origin Origin of the position * @param[in] _origin Origin of the position
* @return true : action done * @return true : action done
* @return false : action not done * @return false : action not done
*/ */
bool FileSeek(long int offset, etk::seekNode_te origin); bool FileSeek(long int _offset, etk::seekNode_te _origin);
/** /**
* @brief Flush the current file * @brief Flush the current file
*/ */
@ -419,33 +419,33 @@ namespace etk
private: private:
/** /**
* @brief Order the list of subnode the folder first and the alphabetical order * @brief Order the list of subnode the folder first and the alphabetical order
* @param[in,out] list The list to order * @param[in,out] _list The list to order
*/ */
void SortElementList(etk::Vector<etk::FSNode *> &list); void SortElementList(etk::Vector<etk::FSNode *>& _list);
}; };
etk::CCout& operator <<(etk::CCout &os, const etk::FSNode &obj); etk::CCout& operator <<(etk::CCout &_os, const etk::FSNode &_obj);
/** /**
* @brief Set manualy the folder of the Data.(like /usr/shared/applName/ for linux) * @brief Set manualy the folder of the Data.(like /usr/shared/applName/ for linux)
* @param[in] folder folder path of the cathegorie * @param[in] _folder folder path of the cathegorie
*/ */
void SetBaseFolderData(const char * folder); void SetBaseFolderData(const char* _folder);
/** /**
* @brief Set the user data folder (like /home/machin/.local/applName/ for linux) * @brief Set the user data folder (like /home/machin/.local/applName/ for linux)
* @param[in] folder folder path of the cathegorie * @param[in] _folder folder path of the cathegorie
*/ */
void SetBaseFolderDataUser(const char * folder); void SetBaseFolderDataUser(const char* _folder);
/** /**
* @brief Set the Cach folder for the application (like /tmp) * @brief Set the Cach folder for the application (like /tmp)
* @param[in] folder folder path of the cathegorie * @param[in] _folder folder path of the cathegorie
*/ */
void SetBaseFolderCache(const char * folder); void SetBaseFolderCache(const char* _folder);
/** /**
* @brief Initialyse all the subFolder usable by the user like DATA/HOME/CACHE/USERDATA * @brief Initialyse all the subFolder usable by the user like DATA/HOME/CACHE/USERDATA
* @param[in] applName the name of the application * @param[in] _applName the name of the application
*/ */
void InitDefaultFolder(const char * applName); void InitDefaultFolder(const char* _applName);
/** /**
* @brief Get the home folder of the user * @brief Get the home folder of the user
* @return the home folder : like : "/home/machin/" * @return the home folder : like : "/home/machin/"
@ -462,16 +462,16 @@ namespace etk
// TODO : Add an INIT ... // TODO : Add an INIT ...
/** /**
* @brief Set the Folder of a subset of a theme ... * @brief Set the Folder of a subset of a theme ...
* @param[in] refName Theme cathegorie ex : "GUI" "SHADER" "DEFAULT" * @param[in] _refName Theme cathegorie ex : "GUI" "SHADER" "DEFAULT"
* @param[in] folderName The associated folder of the Theme (like "myTheme/folder/folder2/") * @param[in] _folderName The associated folder of the Theme (like "myTheme/folder/folder2/")
*/ */
void SetName(etk::UString refName, etk::UString folderName); void SetName(etk::UString _refName, etk::UString _folderName);
/** /**
* @brief get the folder from a Reference theme * @brief get the folder from a Reference theme
* @param[in] refName Theme cathegorie ex : "GUI" "SHADER" "DEFAULT" * @param[in] _refName Theme cathegorie ex : "GUI" "SHADER" "DEFAULT"
* @return the path of the theme * @return the path of the theme
*/ */
etk::UString GetName(etk::UString refName); etk::UString GetName(etk::UString _refName);
/** /**
* @brief Get the list of all the theme folder availlable in the user Home/appl * @brief Get the list of all the theme folder availlable in the user Home/appl
* @return The list of elements * @return The list of elements
@ -481,100 +481,100 @@ namespace etk
/** /**
* @brief Simple access for : Remove folder and subFolder, files pipes ... * @brief Simple access for : Remove folder and subFolder, files pipes ...
* @param[in] path Folder/File/Pipe path of the node * @param[in] _path Folder/File/Pipe path of the node
* @return true : Action done corectly * @return true : Action done corectly
* @return false : An error occured * @return false : An error occured
*/ */
bool FSNodeRemove(const etk::UString& path); bool FSNodeRemove(const etk::UString& _path);
/** /**
* @brief Simple access for : count the number of element in a path (if it is not a path ==> return -1) * @brief Simple access for : count the number of element in a path (if it is not a path ==> return -1)
* @param[in] path Folder/File/Pipe path of the node * @param[in] _path Folder/File/Pipe path of the node
* @return number of File inside * @return number of File inside
* @return -1 : An error occured * @return -1 : An error occured
*/ */
int64_t FSNodeGetCount(const etk::UString& path); int64_t FSNodeGetCount(const etk::UString& _path);
/** /**
* @brief Simple access for : Create a file or a folder depending of the request * @brief Simple access for : Create a file or a folder depending of the request
* @param[in] path Folder/File/Pipe path of the node * @param[in] _path Folder/File/Pipe path of the node
* @param[in] right Right of the creation * @param[in] _right Right of the creation
* @param[in] type Type of the element that might be created * @param[in] _type Type of the element that might be created
* @return true : Action done corectly * @return true : Action done corectly
* @return false : An error occured * @return false : An error occured
*/ */
bool FSNodeCreate(const etk::UString& path, etk::FSNodeRight right, etk::typeNode_te type=etk::FSN_FOLDER); bool FSNodeCreate(const etk::UString& _path, etk::FSNodeRight _right, etk::typeNode_te _type=etk::FSN_FOLDER);
/** /**
* @brief Simple access for : chexk the exestance of an element * @brief Simple access for : chexk the exestance of an element
* @param[in] path Folder/File/Pipe path of the node * @param[in] _path Folder/File/Pipe path of the node
* @return true : Action done corectly * @return true : Action done corectly
* @return false : An error occured * @return false : An error occured
*/ */
bool FSNodeExist(const etk::UString& path); bool FSNodeExist(const etk::UString& _path);
/** /**
* @brief Simple access for : chexk the exestance of an element * @brief Simple access for : chexk the exestance of an element
* @param[in] path Folder/File/Pipe path of the node sources * @param[in] _path1 Folder/File/Pipe path of the node sources
* @param[in] path Folder/File/Pipe path of the node destination * @param[in] _path2 Folder/File/Pipe path of the node destination
* @return true : Action done corectly * @return true : Action done corectly
* @return false : An error occured * @return false : An error occured
*/ */
bool FSNodeMove(const etk::UString& path1, const etk::UString& path2); bool FSNodeMove(const etk::UString& _path1, const etk::UString& _path2);
/** /**
* @brief Simple access for : Get right of the current Node * @brief Simple access for : Get right of the current Node
* @param[in] path Folder/File/Pipe path of the node * @param[in] _path Folder/File/Pipe path of the node
* @return true : Action done corectly * @return true : Action done corectly
* @return false : An error occured * @return false : An error occured
*/ */
etk::FSNodeRight FSNodeGetRight(const etk::UString& path); etk::FSNodeRight FSNodeGetRight(const etk::UString& _path);
/** /**
* @brief Simple access for : Get type of the current node * @brief Simple access for : Get type of the current node
* @param[in] path Folder/File/Pipe path of the node * @param[in] _path Folder/File/Pipe path of the node
* @return true : Action done corectly * @return true : Action done corectly
* @return false : An error occured * @return false : An error occured
*/ */
etk::typeNode_te FSNodeGetType(const etk::UString& path); etk::typeNode_te FSNodeGetType(const etk::UString& _path);
/** /**
* @brief Simple access for : Getting creation time of the current node * @brief Simple access for : Getting creation time of the current node
* @param[in] path Folder/File/Pipe path of the node * @param[in] _path Folder/File/Pipe path of the node
* @return true : Action done corectly * @return true : Action done corectly
* @return false : An error occured * @return false : An error occured
*/ */
uint64_t FSNodeGetTimeCreated(const etk::UString& path); uint64_t FSNodeGetTimeCreated(const etk::UString& _path);
/** /**
* @brief Simple access for : Getting Modification time of the current node * @brief Simple access for : Getting Modification time of the current node
* @param[in] path Folder/File/Pipe path of the node * @param[in] _path Folder/File/Pipe path of the node
* @return true : Action done corectly * @return true : Action done corectly
* @return false : An error occured * @return false : An error occured
*/ */
uint64_t FSNodeGetTimeModified(const etk::UString& path); uint64_t FSNodeGetTimeModified(const etk::UString& _path);
/** /**
* @brief Simple access for : Getting Accessing time of the current node * @brief Simple access for : Getting Accessing time of the current node
* @param[in] path Folder/File/Pipe path of the node * @param[in] _path Folder/File/Pipe path of the node
* @return true : Action done corectly * @return true : Action done corectly
* @return false : An error occured * @return false : An error occured
*/ */
uint64_t FSNodeGetTimeAccessed(const etk::UString& path); uint64_t FSNodeGetTimeAccessed(const etk::UString& _path);
/** /**
* @brief Simple access for : Update Modification time with the current time of the node (>) * @brief Simple access for : Update Modification time with the current time of the node (>)
* @param[in] path Folder/File/Pipe path of the node * @param[in] _path Folder/File/Pipe path of the node
* @return true : Action done corectly * @return true : Action done corectly
* @return false : An error occured * @return false : An error occured
*/ */
bool FSNodeTouch(const etk::UString& path); bool FSNodeTouch(const etk::UString& _path);
/** /**
* @brief Simple access for : Basic write on the node (like console echo) * @brief Simple access for : Basic write on the node (like console echo)
* @param[in] path Folder/File/Pipe path of the node * @param[in] _path Folder/File/Pipe path of the node
* @param[in] dataTowrite write data in the Node * @param[in] _dataTowrite write data in the Node
* @return true : Action done corectly * @return true : Action done corectly
* @return false : An error occured * @return false : An error occured
*/ */
bool FSNodeEcho(const etk::UString& path, const etk::UString& dataTowrite); bool FSNodeEcho(const etk::UString& _path, const etk::UString& _dataTowrite);
/** /**
* @brief Simple access for : Basic write on the node (like console echo) in adding mode (>>) * @brief Simple access for : Basic write on the node (like console echo) in adding mode (>>)
* @param[in] path Folder/File/Pipe path of the node * @param[in] _path Folder/File/Pipe path of the node
* @param[in] dataTowrite write data in the Node * @param[in] _dataTowrite write data in the Node
* @return true : Action done corectly * @return true : Action done corectly
* @return false : An error occured * @return false : An error occured
*/ */
bool FSNodeEchoAdd(const etk::UString& path, const etk::UString& dataTowrite); bool FSNodeEchoAdd(const etk::UString& _path, const etk::UString& _dataTowrite);
/** /**
* @brief move file to generate an history of the current file * @brief move file to generate an history of the current file
* @param[in] _path Folder/File/Pipe path of the node * @param[in] _path Folder/File/Pipe path of the node

54
etk/os/FSNodeRight.cpp
View File

@ -29,22 +29,22 @@ etk::FSNodeRight::FSNodeRight(void) :
{ {
} }
etk::FSNodeRight::FSNodeRight(int16_t newRight) : etk::FSNodeRight::FSNodeRight(int16_t _newRight) :
m_rights(newRight&0x01FF) m_rights(_newRight&0x01FF)
{ {
} }
// copy operator : // copy operator :
const etk::FSNodeRight& etk::FSNodeRight::operator= (const etk::FSNodeRight &obj ) const etk::FSNodeRight& etk::FSNodeRight::operator= (const etk::FSNodeRight &_obj )
{ {
m_rights = obj.m_rights; m_rights = _obj.m_rights;
return *this; return *this;
} }
// set right : // set right :
const etk::FSNodeRight& etk::FSNodeRight::operator= (const int32_t newVal ) const etk::FSNodeRight& etk::FSNodeRight::operator= (const int32_t _newVal )
{ {
m_rights = newVal&0x01FF; m_rights = _newVal&0x01FF;
return *this; return *this;
} }
@ -64,29 +64,29 @@ bool etk::FSNodeRight::IsUserRunable(void) const
return ((m_rights&RIGHT_USER_EXECUTE)!=0)?true:false; return ((m_rights&RIGHT_USER_EXECUTE)!=0)?true:false;
} }
void etk::FSNodeRight::SetUserReadable(bool newStatus) void etk::FSNodeRight::SetUserReadable(bool _newStatus)
{ {
// reset the flag : // reset the flag :
m_rights &= (0xFFFFFFFF - RIGHT_USER_READ); m_rights &= (0xFFFFFFFF - RIGHT_USER_READ);
if (true == newStatus) { if (true == _newStatus) {
m_rights |= RIGHT_USER_READ; m_rights |= RIGHT_USER_READ;
} }
} }
void etk::FSNodeRight::SetUserWritable(bool newStatus) void etk::FSNodeRight::SetUserWritable(bool _newStatus)
{ {
// reset the flag : // reset the flag :
m_rights &= (0xFFFFFFFF - RIGHT_USER_WRITE); m_rights &= (0xFFFFFFFF - RIGHT_USER_WRITE);
if (true == newStatus) { if (true == _newStatus) {
m_rights |= RIGHT_USER_WRITE; m_rights |= RIGHT_USER_WRITE;
} }
} }
void etk::FSNodeRight::SetUserRunable(bool newStatus) void etk::FSNodeRight::SetUserRunable(bool _newStatus)
{ {
// reset the flag : // reset the flag :
m_rights &= (0xFFFFFFFF - RIGHT_USER_EXECUTE); m_rights &= (0xFFFFFFFF - RIGHT_USER_EXECUTE);
if (true == newStatus) { if (true == _newStatus) {
m_rights |= RIGHT_USER_EXECUTE; m_rights |= RIGHT_USER_EXECUTE;
} }
} }
@ -107,29 +107,29 @@ bool etk::FSNodeRight::IsGroupRunable(void) const
return ((m_rights&RIGHT_GROUP_EXECUTE)!=0)?true:false; return ((m_rights&RIGHT_GROUP_EXECUTE)!=0)?true:false;
} }
void etk::FSNodeRight::SetGroupReadable(bool newStatus) void etk::FSNodeRight::SetGroupReadable(bool _newStatus)
{ {
// reset the flag : // reset the flag :
m_rights &= (0xFFFFFFFF - RIGHT_GROUP_READ); m_rights &= (0xFFFFFFFF - RIGHT_GROUP_READ);
if (true == newStatus) { if (true == _newStatus) {
m_rights |= RIGHT_GROUP_READ; m_rights |= RIGHT_GROUP_READ;
} }
} }
void etk::FSNodeRight::SetGroupWritable(bool newStatus) void etk::FSNodeRight::SetGroupWritable(bool _newStatus)
{ {
// reset the flag : // reset the flag :
m_rights &= (0xFFFFFFFF - RIGHT_GROUP_WRITE); m_rights &= (0xFFFFFFFF - RIGHT_GROUP_WRITE);
if (true == newStatus) { if (true == _newStatus) {
m_rights |= RIGHT_GROUP_WRITE; m_rights |= RIGHT_GROUP_WRITE;
} }
} }
void etk::FSNodeRight::SetGroupRunable(bool newStatus) void etk::FSNodeRight::SetGroupRunable(bool _newStatus)
{ {
// reset the flag : // reset the flag :
m_rights &= (0xFFFFFFFF - RIGHT_GROUP_EXECUTE); m_rights &= (0xFFFFFFFF - RIGHT_GROUP_EXECUTE);
if (true == newStatus) { if (true == _newStatus) {
m_rights |= RIGHT_GROUP_EXECUTE; m_rights |= RIGHT_GROUP_EXECUTE;
} }
} }
@ -150,29 +150,29 @@ bool etk::FSNodeRight::IsOtherRunable(void) const
return ((m_rights&RIGHT_OTHER_EXECUTE)!=0)?true:false; return ((m_rights&RIGHT_OTHER_EXECUTE)!=0)?true:false;
} }
void etk::FSNodeRight::SetOtherReadable(bool newStatus) void etk::FSNodeRight::SetOtherReadable(bool _newStatus)
{ {
// reset the flag : // reset the flag :
m_rights &= (0xFFFFFFFF - RIGHT_OTHER_READ); m_rights &= (0xFFFFFFFF - RIGHT_OTHER_READ);
if (true == newStatus) { if (true == _newStatus) {
m_rights |= RIGHT_OTHER_READ; m_rights |= RIGHT_OTHER_READ;
} }
} }
void etk::FSNodeRight::SetOtherWritable(bool newStatus) void etk::FSNodeRight::SetOtherWritable(bool _newStatus)
{ {
// reset the flag : // reset the flag :
m_rights &= (0xFFFFFFFF - RIGHT_OTHER_WRITE); m_rights &= (0xFFFFFFFF - RIGHT_OTHER_WRITE);
if (true == newStatus) { if (true == _newStatus) {
m_rights |= RIGHT_OTHER_WRITE; m_rights |= RIGHT_OTHER_WRITE;
} }
} }
void etk::FSNodeRight::SetOtherRunable(bool newStatus) void etk::FSNodeRight::SetOtherRunable(bool _newStatus)
{ {
// reset the flag : // reset the flag :
m_rights &= (0xFFFFFFFF - RIGHT_OTHER_EXECUTE); m_rights &= (0xFFFFFFFF - RIGHT_OTHER_EXECUTE);
if (true == newStatus) { if (true == _newStatus) {
m_rights |= RIGHT_OTHER_EXECUTE; m_rights |= RIGHT_OTHER_EXECUTE;
} }
} }
@ -228,9 +228,9 @@ etk::UString etk::FSNodeRight::GetRight(void) const
} }
etk::CCout& etk::operator <<(etk::CCout &os, const etk::FSNodeRight &obj) etk::CCout& etk::operator <<(etk::CCout &_os, const etk::FSNodeRight &_obj)
{ {
os << obj.GetRight(); _os << _obj.GetRight();
return os; return _os;
}; };

26
etk/os/FSNodeRight.h
View File

@ -19,39 +19,39 @@ namespace etk
uint16_t m_rights; uint16_t m_rights;
public: public:
FSNodeRight(void); FSNodeRight(void);
FSNodeRight(int16_t newRight); FSNodeRight(int16_t _newRight);
~FSNodeRight(void) { }; ~FSNodeRight(void) { };
// copy operator : // copy operator :
const etk::FSNodeRight& operator= (const etk::FSNodeRight &obj ); const etk::FSNodeRight& operator= (const etk::FSNodeRight &_obj );
// set right : // set right :
const etk::FSNodeRight& operator= (const int32_t newVal ); const etk::FSNodeRight& operator= (const int32_t _newVal );
void Clear(void) { m_rights = 0; }; void Clear(void) { m_rights = 0; };
// User // User
bool IsUserReadable(void) const; bool IsUserReadable(void) const;
bool IsUserWritable(void) const; bool IsUserWritable(void) const;
bool IsUserRunable(void) const; bool IsUserRunable(void) const;
void SetUserReadable(bool newStatus); void SetUserReadable(bool _newStatus);
void SetUserWritable(bool newStatus); void SetUserWritable(bool _newStatus);
void SetUserRunable(bool newStatus); void SetUserRunable(bool _newStatus);
// group // group
bool IsGroupReadable(void) const; bool IsGroupReadable(void) const;
bool IsGroupWritable(void) const; bool IsGroupWritable(void) const;
bool IsGroupRunable(void) const; bool IsGroupRunable(void) const;
void SetGroupReadable(bool newStatus); void SetGroupReadable(bool _newStatus);
void SetGroupWritable(bool newStatus); void SetGroupWritable(bool _newStatus);
void SetGroupRunable(bool newStatus); void SetGroupRunable(bool _newStatus);
// other // other
bool IsOtherReadable(void) const; bool IsOtherReadable(void) const;
bool IsOtherWritable(void) const; bool IsOtherWritable(void) const;
bool IsOtherRunable(void) const; bool IsOtherRunable(void) const;
void SetOtherReadable(bool newStatus); void SetOtherReadable(bool _newStatus);
void SetOtherWritable(bool newStatus); void SetOtherWritable(bool _newStatus);
void SetOtherRunable(bool newStatus); void SetOtherRunable(bool _newStatus);
etk::UString GetRight(void) const; etk::UString GetRight(void) const;
}; };
etk::CCout& operator <<(etk::CCout &os, const etk::FSNodeRight &obj); etk::CCout& operator <<(etk::CCout &_os, const etk::FSNodeRight &_obj);
}; };
#endif #endif