LLBC_BundleHandle LLBC_CreateBundle(const LLBC_String &path)
{
LLBC_String realPath = LLBC_GetMainBundlePath();
if (UNLIKELY(realPath.empty()))
return LLBC_INVALID_BUNDLE_HANDLE;
// Main bundle-path + /(\\) + path.
// Trim right(/(\\)).
if (!path.empty())
{
#if LLBC_TARGET_PLATFORM_NON_WIN32
realPath.append(1, LLBC_SLASH_A);
#else
realPath.append(1, LLBC_BACKLASH_A);
#endif
realPath.append(path);
const LLBC_String::size_type len = realPath.length();
if (realPath[len - 1] == LLBC_SLASH_A || realPath[len - 1] == LLBC_BACKLASH_A)
realPath.erase(len - 1, 1);
}
// Check path.
if (!LLBC_DirectoryExist(realPath))
return LLBC_INVALID_BUNDLE_HANDLE;
return new LLBC_String(realPath);
}
__LLBC_NS_BEGIN
void LLBC_SplitString(const LLBC_String &str,
const LLBC_String &separator,
std::vector<LLBC_String> &destStrList,
bool justSplitFirst,
char escapeChar)
{
if (UNLIKELY(str.empty()))
{
return;
}
if (UNLIKELY(separator.empty()))
{
destStrList.push_back(str);
}
LLBC_String::size_type curPos = 0;
LLBC_String::size_type prevPos = 0;
LLBC_String strInternal = str;
while ((curPos = strInternal.find(separator, curPos)) != LLBC_String::npos)
{
if (curPos != 0 && strInternal[curPos - 1] == escapeChar)
{
strInternal.erase(-- curPos, 1);
curPos += separator.size();
continue;
}
LLBC_String temp = strInternal.substr(prevPos, curPos - prevPos);
destStrList.push_back(temp);
if (justSplitFirst)
{
destStrList.push_back(strInternal.substr(curPos + separator.size()));
return;
}
curPos += separator.size();
prevPos = curPos;
}
LLBC_String temp = strInternal.substr(prevPos);
if (!temp.empty())
{
destStrList.push_back(temp);
}
}
LLBC_String LLBC_BaseName(const LLBC_String &path, bool incExtension)
{
if (UNLIKELY(path.empty()))
{
return LLBC_String();
}
LLBC_String baseName;
#if LLBC_TARGET_PLATFORM_NON_WIN32
baseName = ::basename(const_cast<char *>(path.c_str()));
#else
LLBC_String::size_type slashPos = path.rfind(LLBC_SLASH_A);
LLBC_String::size_type backlashPos = path.rfind(LLBC_BACKLASH_A);
if (slashPos == LLBC_String::npos)
{
if (backlashPos == LLBC_String::npos)
{
baseName = path;
}
else
{
baseName = path.substr(backlashPos + 1);
}
}
else
{
if (backlashPos == LLBC_String::npos)
{
baseName = path.substr(slashPos + 1);
}
else
{
baseName = path.substr(MAX(slashPos, backlashPos) + 1);
}
}
#endif
if (!incExtension)
{
LLBC_String::size_type dotPos = baseName.rfind('.');
if (dotPos != LLBC_String::npos && dotPos != 0)
{
baseName.erase(dotPos);
}
}
return baseName;
}
int LLBC_LogTokenChain::Build(const LLBC_String &pattern)
{
if (_head)
{
LLBC_SetLastError(LLBC_ERROR_REENTRY);
return LLBC_RTN_FAILED;
}
char ch = '\0';
const char *curPattern = NULL;
LLBC_String::size_type patternLength = 0;
int state = LLBC_INTERNAL_NS __g_literal_state;
LLBC_ILogToken *token = NULL;
LLBC_LogFormattingInfo *formatter = NULL;
LLBC_String buf;
if (pattern.empty())
{
curPattern = LLBC_INTERNAL_NS __g_default_pattern;
patternLength = LLBC_StrLenA(LLBC_INTERNAL_NS __g_default_pattern);
}
else
{
curPattern = pattern.data();
patternLength = pattern.size();
}
for (size_t i = 0; i < patternLength;)
{
ch = curPattern[i ++];
switch(state)
{
case LLBC_INTERNAL_NS __g_literal_state:
if (i == patternLength)
{
buf.append(1, ch);
break;
}
if (ch == LLBC_LogTokenType::EscapeToken)
{
if (curPattern[i] == LLBC_LogTokenType::EscapeToken)
{
buf.append(1, ch);
i ++;
}
else
{
if (!buf.empty())
{
token = LLBC_LogTokenBuilderSingleton->BuildLogToken(LLBC_LogTokenType::StrToken);
token->Initialize(formatter, buf);
this->AppendToken(token);
buf.clear();
formatter = NULL;
}
buf.append(1, ch);
LLBC_XDelete(formatter);
state = LLBC_INTERNAL_NS __g_converter_state;
}
}
else
{
buf.append(1, ch);
}
break;
case LLBC_INTERNAL_NS __g_converter_state:
buf.append(1, ch);
if ((ch >= 0x30 && ch <= 0x39) || ch == '-')
{
state = LLBC_INTERNAL_NS __g_number_state;
break;
}
buf.erase(buf.rfind(LLBC_LogTokenType::EscapeToken));
token = LLBC_LogTokenBuilderSingleton->BuildLogToken(ch);
if (!formatter)
{
formatter = new LLBC_LogFormattingInfo;
}
token->Initialize(formatter, "");
this->AppendToken(token);
formatter = NULL;
state = LLBC_INTERNAL_NS __g_literal_state;
break;
case LLBC_INTERNAL_NS __g_number_state:
if ((ch < 0x30 || ch > 0x39) && ch != '-')
{
int minLength = LLBC_Str2Int32(&buf[buf.rfind(LLBC_LogTokenType::EscapeToken) + 1]);
if (!formatter)
{
formatter = new LLBC_LogFormattingInfo(minLength < 0 ? true : false, ::abs(minLength), INT_MAX);
}
else
{
formatter->SetLeftAligh(minLength < 0 ? true : false);
formatter->SetMinLen(minLength);
formatter->SetMaxLen(INT_MAX);
}
i --;
state = LLBC_INTERNAL_NS __g_converter_state;
break;
}
buf.append(1, ch);
break;
default:
LLBC_XDelete(formatter);
this->Cleanup();
LLBC_SetLastError(LLBC_ERROR_FORMAT);
return LLBC_RTN_FAILED;
break;
}
}
if (!buf.empty())
{
token = LLBC_LogTokenBuilderSingleton->BuildLogToken(LLBC_LogTokenType::StrToken);
token->Initialize(NULL, buf);
this->AppendToken(token);
}
return LLBC_RTN_OK;
}
