simpledateformat.cpp

log4cxx 0.10 unix下编译包

  }

private:
  std::vector < LogString > names;

};



class FullDayNameToken : public PatternToken
{
public:
  FullDayNameToken( int width, const std::locale *locale) : names( 7 ) {
      renderFacet(locale, PatternToken::incrementDay, 'A', 0x41, "%A", names);
  }

  void format( LogString& s, const apr_time_exp_t & tm, Pool & /* p */ ) const
  {
    s.append( names[tm.tm_wday] );
  }

private:
  std::vector < LogString > names;

};



class MilitaryHourToken : public NumericToken
{
public:
  MilitaryHourToken( int width1, int offset1 ) : NumericToken( width1 ), offset( offset1 )
  {
  }

  int getField( const apr_time_exp_t & tm ) const
  {
    return tm.tm_hour + offset;
  }

private:
  int offset;
};



class HourToken : public NumericToken
{
public:
  HourToken( int width1, int /* offset1 */ ) : NumericToken( width1 )
  {
  }

  int getField( const apr_time_exp_t & tm ) const
  {
    return ( ( tm.tm_hour + 12 - offset ) % 12 ) + offset;
  }

private:
  int offset;
};



class MinuteToken : public NumericToken
{
public:
  MinuteToken( int width1 ) : NumericToken( width1 )
  {
  }

  int getField( const apr_time_exp_t & tm ) const
  {
    return tm.tm_min;
  }
};



class SecondToken : public NumericToken
{
public:
  SecondToken( int width1 ) : NumericToken( width1 )
  {
  }

  int getField( const apr_time_exp_t & tm ) const
  {
    return tm.tm_sec;
  }
};



class MillisecondToken : public NumericToken
{
public:
  MillisecondToken( int width1 ) : NumericToken( width1 )
  {
  }

  int getField( const apr_time_exp_t & tm ) const
  {
    return tm.tm_usec / 1000;
  }
};



class AMPMToken : public PatternToken
{
public:
  AMPMToken( int width, const std::locale *locale) : names( 2 ) {
      renderFacet(locale, PatternToken::incrementHalfDay, 'p', 0x70, "%p", names);
  }

  void format( LogString& s, const apr_time_exp_t & tm, Pool & /* p */ ) const
  {
    s.append( names[tm.tm_hour / 12] );
  }

private:
  std::vector < LogString > names;
};



class GeneralTimeZoneToken : public PatternToken
{
public:
  GeneralTimeZoneToken( int /* width */ )
  {
  }

  void format( LogString& s, const apr_time_exp_t & , Pool & /* p */ ) const {
    s.append(timeZone->getID());
  }

  void setTimeZone( const TimeZonePtr & zone )
  {
    timeZone = zone;
  }

private:
  TimeZonePtr timeZone;
};



class RFC822TimeZoneToken : public PatternToken
{
public:
  RFC822TimeZoneToken( int /* width */ )
  {
  }

  void format( LogString& s, const apr_time_exp_t & tm, Pool & p ) const
  {
    if ( tm.tm_gmtoff == 0 )
    {
      s.append( 1, (logchar) 0x5A /* 'Z'  */ );
    }
    else
    {
      apr_int32_t off = tm.tm_gmtoff;
      size_t basePos = s.length();
      s.append( LOG4CXX_STR( "+0000" ) );
      if ( off < 0 )
      {
        s[basePos] = 0x2D; // '-'
        off = -off;
      }
      LogString hours;
      StringHelper::toString( off / 3600, p, hours );
      size_t hourPos = basePos + 2;
      //
      //   assumes that point values for 0-9 are same between char and wchar_t
      //
      for ( size_t i = hours.length(); i-- > 0; )
      {
        s[hourPos--] = hours[i];
      }
      LogString min;
      StringHelper::toString( ( off % 3600 ) / 60, p, min );
      size_t minPos = basePos + 4;
      //
      //   assumes that point values for 0-9 are same between char and wchar_t
      //
      for ( size_t j = min.length(); j-- > 0; )
      {
        s[minPos--] = min[j];
      }
    }
  }
};




  }
}
}


using namespace log4cxx::helpers::SimpleDateFormatImpl;

void SimpleDateFormat::addToken(const logchar spec, const int repeat, const std::locale * locale,
           std::vector < PatternToken * > & pattern )
           {
             PatternToken * token = NULL;
             switch ( spec )
             {
               case 0x47: // 'G' 
                 token = ( new EraToken( repeat, locale ) );
               break;

               case 0x79: // 'y'
                 token = ( new YearToken( repeat ) );
               break;

               case 0x4D: // 'M'
                 if ( repeat <= 2 )
                 {
                   token = ( new MonthToken( repeat ) );
                 }
                 else if ( repeat <= 3 )
                 {
                   token = ( new AbbreviatedMonthNameToken( repeat, locale ) );
                 }
                 else
                 {
                   token = ( new FullMonthNameToken( repeat, locale ) );
                 }
               break;

               case 0x77: // 'w'
                 token = ( new WeekInYearToken( repeat ) );
               break;

               case 0x57: // 'W'
                 token = ( new WeekInMonthToken( repeat ) );
               break;

               case 0x44: // 'D'
                 token = ( new DayInYearToken( repeat ) );
               break;

               case 0x64: // 'd'
                 token = ( new DayInMonthToken( repeat ) );
               break;

               case 0x46: // 'F'
                 token = ( new DayOfWeekInMonthToken( repeat ) );
               break;

               case 0x45: // 'E'
                 if ( repeat <= 3 )
                 {
                   token = ( new AbbreviatedDayNameToken( repeat, locale ) );
                 }
                 else
                 {
                   token = ( new FullDayNameToken( repeat, locale ) );
                 }
               break;

               case 0x61: // 'a'
                 token = ( new AMPMToken( repeat, locale ) );
               break;

               case 0x48: // 'H'
                 token = ( new MilitaryHourToken( repeat, 0 ) );
               break;

               case 0x6B: // 'k'
                 token = ( new MilitaryHourToken( repeat, 1 ) );
               break;

               case 0x4B: // 'K'
                 token = ( new HourToken( repeat, 0 ) );
               break;

               case 0x68: // 'h'
                 token = ( new HourToken( repeat, 1 ) );
               break;

               case 0x6D: // 'm' 
                 token = ( new MinuteToken( repeat ) );
               break;

               case 0x73: // 's' 
                 token = ( new SecondToken( repeat ) );
               break;

               case 0x53: // 'S'
                 token = ( new MillisecondToken( repeat ) );
               break;

               case 0x7A: // 'z'
                 token = ( new GeneralTimeZoneToken( repeat ) );
               break;

               case 0x5A: // 'Z'
                 token = ( new RFC822TimeZoneToken( repeat ) );
               break;

               default:
                 token = ( new LiteralToken( spec, repeat ) );
             }
             assert( token != NULL );
             pattern.push_back( token );
}


void SimpleDateFormat::parsePattern( const LogString & fmt, const std::locale * locale,
           std::vector < PatternToken * > & pattern )
{
             if ( !fmt.empty() )
             {
               LogString::const_iterator iter = fmt.begin();
               int repeat = 1;
               logchar prevChar = * iter;
               for ( iter++; iter != fmt.end(); iter++ )
               {
                 if ( * iter == prevChar )
                 {
                   repeat++;
                 }
                 else
                 {
                   addToken( prevChar, repeat, locale, pattern );
                   prevChar = * iter;
                   repeat = 1;
                 }
               }
               addToken( prevChar, repeat, locale, pattern );
             }
}


SimpleDateFormat::SimpleDateFormat( const LogString & fmt ) : timeZone( TimeZone::getDefault() )
{
#if LOG4CXX_HAS_STD_LOCALE
  std::locale defaultLocale;
  parsePattern( fmt, & defaultLocale, pattern );
#else
  parsePattern( fmt, NULL, pattern );
#endif
  for ( PatternTokenList::iterator iter = pattern.begin(); iter != pattern.end(); iter++ )
  {
    ( * iter )->setTimeZone( timeZone );
  }
}

SimpleDateFormat::SimpleDateFormat( const LogString & fmt, const std::locale * locale ) : timeZone( TimeZone::getDefault() )
{
  parsePattern( fmt, locale, pattern );
  for ( PatternTokenList::iterator iter = pattern.begin(); iter != pattern.end(); iter++ )
  {
    ( * iter )->setTimeZone( timeZone );
  }
}


SimpleDateFormat::~SimpleDateFormat()
{
  for ( PatternTokenList::iterator iter = pattern.begin(); iter != pattern.end(); iter++ )
  {
    delete * iter;
  }
}


void SimpleDateFormat::format( LogString & s, log4cxx_time_t time, Pool & p ) const
{
  apr_time_exp_t exploded;
  apr_status_t stat = timeZone->explode( & exploded, time );
  if ( stat == APR_SUCCESS )
  {
    for ( PatternTokenList::const_iterator iter = pattern.begin(); iter != pattern.end(); iter++ )
    {
      ( * iter )->format( s, exploded, p );
    }
  }
}

void SimpleDateFormat::setTimeZone( const TimeZonePtr & zone )
{
  timeZone = zone;
}