bool StringHelper::endsWith(const LogString& s, const LogString& suffix)
{
if (suffix.length() <= s.length()) {
return s.compare(s.length() - suffix.length(), suffix.length(), suffix) == 0;
}
return false;
}
/**
* Finds start of millisecond field in formatted time.
* @param time long time, must be integral number of seconds
* @param formatted String corresponding formatted string
* @param formatter DateFormat date format
* @return int position in string of first digit of milliseconds,
* -1 indicates no millisecond field, -2 indicates unrecognized
* field (likely RelativeTimeDateFormat)
*/
int CachedDateFormat::findMillisecondStart(
log4cxx_time_t time, const LogString& formatted,
const DateFormatPtr& formatter,
Pool& pool) {
apr_time_t slotBegin = (time / 1000000) * 1000000;
if (slotBegin > time) {
slotBegin -= 1000000;
}
int millis = (int) (time - slotBegin)/1000;
int magic = magic1;
LogString magicString(magicString1);
if (millis == magic1) {
magic = magic2;
magicString = magicString2;
}
LogString plusMagic;
formatter->format(plusMagic, slotBegin + magic, pool);
/**
* If the string lengths differ then
* we can't use the cache except for duplicate requests.
*/
if (plusMagic.length() != formatted.length()) {
return UNRECOGNIZED_MILLISECONDS;
} else {
// find first difference between values
for (LogString::size_type i = 0; i < formatted.length(); i++) {
if (formatted[i] != plusMagic[i]) {
//
// determine the expected digits for the base time
const logchar abc[] = { 0x41, 0x42, 0x43, 0 };
LogString formattedMillis(abc);
millisecondFormat(millis, formattedMillis, 0);
LogString plusZero;
formatter->format(plusZero, slotBegin, pool);
// If the next 3 characters match the magic
// strings and the remaining fragments are identical
//
//
if (plusZero.length() == formatted.length()
&& regionMatches(magicString, 0, plusMagic, i, magicString.length())
&& regionMatches(formattedMillis, 0, formatted, i, magicString.length())
&& regionMatches(zeroString, 0, plusZero, i, 3)
&& (formatted.length() == i + 3
|| plusZero.compare(i + 3,
LogString::npos, plusMagic, i+3, LogString::npos) == 0)) {
return i;
} else {
return UNRECOGNIZED_MILLISECONDS;
}
}
}
}
return NO_MILLISECONDS;
}
/**
* Tests if two string regions are equal.
* @param target target string.
* @param toffset character position in target to start comparison.
* @param other other string.
* @param ooffset character position in other to start comparison.
* @param len length of region.
* @return true if regions are equal.
*/
bool CachedDateFormat::regionMatches(
const LogString& target,
size_t toffset,
const LogString& other,
size_t ooffset,
size_t len) {
return target.compare(toffset, len, other, ooffset, len) == 0;
}
/**
* Gets maximum cache validity for the specified SimpleDateTime
* conversion pattern.
* @param pattern conversion pattern, may not be null.
* @returns Duration in microseconds from an integral second
* that the cache will return consistent results.
*/
int CachedDateFormat::getMaximumCacheValidity(const LogString& pattern) {
//
// If there are more "S" in the pattern than just one "SSS" then
// (for example, "HH:mm:ss,SSS SSS"), then set the expiration to
// one millisecond which should only perform duplicate request caching.
//
const logchar S = 0x53;
const logchar SSS[] = { 0x53, 0x53, 0x53, 0 };
size_t firstS = pattern.find(S);
size_t len = pattern.length();
//
// if there are no S's or
// three that start with the first S and no fourth S in the string
//
if (firstS == LogString::npos ||
(len >= firstS + 3 && pattern.compare(firstS, 3, SSS) == 0
&& (len == firstS + 3 ||
pattern.find(S, firstS + 3) == LogString::npos))) {
return 1000000;
}
return 1000;
}
bool StringHelper::startsWith(const LogString& s, const LogString& prefix)
{
return s.compare(0, prefix.length(), prefix) == 0;
}