DateTimeFormat.h++

Go to the documentation of this file.

/* ---------------------------------------------------------------------------
   commonc++ - A C++ Common Class Library
   Copyright (C) 2005-2014  Mark A Lindner

   This file is part of commonc++.

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.

   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public
   License along with this library; if not, write to the Free
   Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
   ---------------------------------------------------------------------------
*/

#ifndef __ccxx_DateTimeFormat_hxx
#define __ccxx_DateTimeFormat_hxx

#include <commonc++/Common.h++>
#include <commonc++/DateTime.h++>
#include <commonc++/ParseException.h++>

#include <cstring>

namespace ccxx {

class CStringBuilder; // fwd decl

class COMMONCPP_API DateTimeFormat
{
 public:

  DateTimeFormat(String format = "%t %T", String dateFormat = "%t",
                 String timeFormat = "%T");

  ~DateTimeFormat();

  inline void setFormat(const String& format)
  { _parseFormat(format, _dateTimeFormat); }

  inline void setDateFormat(const String& dateFormat)
  { _parseFormat(dateFormat, _dateFormat); }

  inline void setTimeFormat(const String& timeFormat)
  { _parseFormat(timeFormat, _timeFormat); }

  String format(const Date& value) const;

  size_t format(const Date& value, char* buf, size_t bufsz) const;

  String format(const Time& value) const;

  size_t format(const Time& value, char* buf, size_t bufsz) const;

  String format(const DateTime& value) const;

  size_t format(const DateTime& value, char* buf, size_t bufsz) const;

  void parse(Date& value, const String& text) const;

  void parse(Time& value, const String& text) const;

  void parse(DateTime& value, const String& text) const;

 private:

  class TokenList; // fwd decl

  static String _monthNames[12];
  static String _monthNamesLong[12];
  static String _weekdayNames[7];
  static String _weekdayNamesLong[7];
  static String _meridiemUpper[2];
  static String _meridiemLower[2];
  static bool _cacheStrings();
  static bool _stringsCached;

  enum TokenCode { TOK_INVALID = -1, TOK_LITERAL = 0, TOK_HOURS,
                   TOK_HOURS12, TOK_MINUTES, TOK_SECONDS, TOK_MSEC,
                   TOK_AMPM_LOWER, TOK_AMPM_UPPER, TOK_MONTH, TOK_DAY,
                   TOK_DAYNUM, TOK_YEAR, TOK_YEAR_4, TOK_WEEKDAY,
                   TOK_WEEKNUM, TOK_TZ, TOK_DATE, TOK_TIME };

  enum TokenFormat { FMT_INVALID = -1, FMT_NUMERIC, FMT_NUMERIC_0,
                     FMT_NUMERIC_SPC, FMT_STRING, FMT_STRING_LONG };

  class Token
  {
   private:

    TokenCode _token;
    TokenFormat _format;
    char* _text;

   public:

    Token(TokenCode token, TokenFormat format, const char* text = NULL,
          int len = 0)
      : _token(token), _format(format)
    {
      if(text != NULL)
      {
        _text = new char[len + 1];
        std::memcpy(_text, text, len);
        _text[len] = NUL;
      }
      else
        _text = NULL;
    }

    ~Token()
    {
      delete[] _text;
    }

    inline TokenCode getType() const
    { return(_token); }

    inline TokenFormat getFormat() const
    { return(_format); }

    inline const char *getText() const
    { return(_text); }

  };

  void _formatNumeric(String& s, uint_t val, uint_t width,
                      TokenFormat format) const;
  void _parseFormat(const String& format, TokenList* tokens);
  String _format(const TokenList* tokens, const DateTime& value) const;
  size_t _format(const TokenList* tokens, const DateTime& value,
                 CStringBuilder& builder) const;
  void _parse(const TokenList* tokens, DateTime& value, const char* buf) const;

  int _parseInt(const char*& p, uint_t& pos, int min, int max) const;
  int _parseString(const char*& p, uint_t& pos, const String* list,
                   size_t count) const;
  void _skip(const char*& p, uint_t& pos, uint_t count) const;

  TokenList* _dateFormat;
  TokenList* _timeFormat;
  TokenList* _dateTimeFormat;
};

} // namespace ccxx

#endif // __ccxx_DateTimeFormat_hxx