| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #ifndef _LOG4CXX_HELPERS_CACHED_DATE_FORMAT_H |
| #define _LOG4CXX_HELPERS_CACHED_DATE_FORMAT_H |
| |
| #include <log4cxx/helpers/dateformat.h> |
| |
| #if defined(_MSC_VER) |
| #pragma warning ( push ) |
| #pragma warning ( disable: 4251 ) |
| #endif |
| |
| namespace log4cxx |
| { |
| namespace pattern |
| { |
| class LOG4CXX_EXPORT CachedDateFormat : public log4cxx::helpers::DateFormat |
| { |
| public: |
| enum |
| { |
| /* |
| * Constant used to represent that there was no change |
| * observed when changing the millisecond count. |
| */ |
| NO_MILLISECONDS = -2, |
| /* |
| * Constant used to represent that there was an |
| * observed change, but was an expected change. |
| */ |
| UNRECOGNIZED_MILLISECONDS = -1 |
| }; |
| |
| private: |
| /** |
| * Supported digit set. If the wrapped DateFormat uses |
| * a different unit set, the millisecond pattern |
| * will not be recognized and duplicate requests |
| * will use the cache. |
| */ |
| static const logchar digits[]; |
| |
| |
| /** |
| * First magic number (in microseconds) used to detect |
| * the millisecond position. |
| */ |
| static const int magic1; |
| |
| |
| /** |
| * Expected representation of first magic number in milliseconds. |
| */ |
| static const logchar magicString1[]; |
| |
| |
| /** |
| * Second magic number (in microseconds) used to detect |
| * the millisecond position. |
| */ |
| static const int magic2; |
| |
| |
| /** |
| * Expected representation of second magic number in milliseconds. |
| */ |
| static const logchar magicString2[]; |
| |
| |
| /** |
| * Expected representation of 0 milliseconds. |
| */ |
| static const logchar zeroString[]; |
| |
| /** |
| * Wrapped formatter. |
| */ |
| log4cxx::helpers::DateFormatPtr formatter; |
| |
| /** |
| * Index of initial digit of millisecond pattern or |
| * UNRECOGNIZED_MILLISECONDS or NO_MILLISECONDS. |
| */ |
| mutable int millisecondStart; |
| |
| /** |
| * Integral second preceding the previous convered Date. |
| */ |
| mutable log4cxx_time_t slotBegin; |
| |
| |
| /** |
| * Cache of previous conversion. |
| */ |
| mutable LogString cache; |
| |
| |
| /** |
| * Maximum validity period for the cache. |
| * Typically 1, use cache for duplicate requests only, or |
| * 1000000, use cache for requests within the same integral second. |
| */ |
| const int expiration; |
| |
| /** |
| * Date requested in previous conversion. |
| */ |
| mutable log4cxx_time_t previousTime; |
| |
| public: |
| /** |
| * Creates a new CachedDateFormat object. |
| * @param dateFormat Date format, may not be null. |
| * @param expiration maximum cached range in microseconds. |
| * If the dateFormat is known to be incompatible with the |
| * caching algorithm, use a value of 0 to totally disable |
| * caching or 1 to only use cache for duplicate requests. |
| */ |
| CachedDateFormat(const log4cxx::helpers::DateFormatPtr& dateFormat, int expiration); |
| |
| /** |
| * 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 |
| * @param pool pool. |
| * @return int position in string of first digit of milliseconds, |
| * -1 indicates no millisecond field, -2 indicates unrecognized |
| * field (likely RelativeTimeDateFormat) |
| */ |
| static int findMillisecondStart( |
| log4cxx_time_t time, const LogString& formatted, |
| const log4cxx::helpers::DateFormatPtr& formatter, |
| log4cxx::helpers::Pool& pool); |
| |
| /** |
| * Formats a Date into a date/time string. |
| * |
| * @param date the date to format. |
| * @param sbuf the string buffer to write to. |
| * @param p memory pool. |
| */ |
| virtual void format(LogString& sbuf, |
| log4cxx_time_t date, |
| log4cxx::helpers::Pool& p) const; |
| |
| private: |
| /** |
| * Formats a count of milliseconds (0-999) into a numeric representation. |
| * @param millis Millisecond coun between 0 and 999. |
| * @buf String buffer, may not be null. |
| * @offset Starting position in buffer, the length of the |
| * buffer must be at least offset + 3. |
| */ |
| static void millisecondFormat(int millis, |
| LogString& buf, |
| int offset); |
| |
| |
| public: |
| /** |
| * Set timezone. |
| * |
| * @remarks Setting the timezone using getCalendar().setTimeZone() |
| * will likely cause caching to misbehave. |
| * @param zone TimeZone new timezone |
| */ |
| virtual void setTimeZone(const log4cxx::helpers::TimeZonePtr& zone); |
| |
| /** |
| * Format an integer consistent with the format method. |
| * @param s string to which the numeric string is appended. |
| * @param n integer value. |
| * @param p memory pool used during formatting. |
| */ |
| virtual void numberFormat(LogString& s, |
| int n, |
| log4cxx::helpers::Pool& p) const; |
| |
| /** |
| * 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. |
| */ |
| static int getMaximumCacheValidity(const LogString& pattern); |
| |
| private: |
| CachedDateFormat(const CachedDateFormat&); |
| CachedDateFormat& operator=(const CachedDateFormat&); |
| |
| /** |
| * 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. |
| */ |
| static bool regionMatches( |
| const LogString& target, |
| size_t toffset, |
| const LogString& other, |
| size_t ooffset, |
| size_t len); |
| |
| }; |
| |
| |
| |
| } // namespace helpers |
| } // namespace log4cxx |
| |
| #if defined(_MSC_VER) |
| #pragma warning (pop) |
| #endif |
| |
| #endif // _LOG4CXX_HELPERS_SIMPLE_DATE_FORMAT_H |