#include <cstdlib>
#include <chrono>
#include <memory>
#include <array>
#include <functional>
#include "regex.h"
#include "datetime.h"
#include "config.h"
#include "portable.h"
#include "language.h"
#include "message.h"
#include "growbuf.h"

Include dependency graph for datetime.cpp:

Classes
struct	SpecFormat

struct	DateTimeField

Typedefs
using	TMFieldAssigner = std::function< void(std::tm &,int value) >

Functions
std::tm	getCurrentDateTime ()
	Returns the filled in std::tm for the current date and time.

QCString	dateToString (DateTimeType includeTime)
	Returns the current date, when `includeTime` is set also the time is provided.

QCString	yearToString ()
	Returns the current year as a string.

static void	determine_weekday (std::tm &tm)

QCString	dateTimeFromString (const QCString &spec, std::tm &dt, int &format)
	Returns the filled in std::tm for a given string representing a date and/or time.

QCString	formatDateTime (const QCString &format, const std::tm &dt, int &formatUsed)
	Return a string representation for a given std::tm value that is formatted according to the pattern given by a format.

Variables
static std::array	g_specFormats

static std::array	g_assignValues

Typedef Documentation

◆ TMFieldAssigner

using TMFieldAssigner = std::function< void(std::tm &,int value) >

Definition at line 90 of file datetime.cpp.

Function Documentation

◆ dateTimeFromString()

QCString dateTimeFromString	(	const QCString &	spec,
		std::tm &	dt,
		int &	format )

Returns the filled in std::tm for a given string representing a date and/or time.

Parameters

[in]	spec	The string representation of the date and/or time Possible formats: the empty string: the current date and time is returned `YYYY-MM-DD HH:MM:SS`: the date and time are fully specified `YYYY-MM-DD HH:MM`: the date and time without seconds `YYYY-MM-DD`: the date without time `HH:MM:SS`: the time with seconds but without date `HH:MM`: the time without seconds and without date
[out]	dt	The corresponding datetime value.
[out]	format	The parts that have been found in spec; a bitwise or of `SF_Date`, `SF_Time` and `SF_Seconds`.

Returns: An empty string if the spec has a supported format, or an error message if the format is invalid.

Definition at line 134 of file datetime.cpp.

{
  // for an empty spec field return the current date and time
  dt = getCurrentDateTime();
  if (spec.isEmpty())
  {
    format = SF_Date | SF_Time | SF_Seconds;
    return QCString();
  }
 
  // find a matching pattern
  std::string s = spec.str();
  for (const auto &fmt : g_specFormats)
  {
    reg::Match m;
    if (reg::match(s,m,fmt.re)) // match found
    {
      for (int i=0; i<fmt.count; i++)
      {
        int value = std::atoi(m[i+1].str().c_str());
        const DateTimeField &dtf = g_assignValues[i+fmt.offset];
        if (value<dtf.minVal || value>dtf.maxVal) // check if the value is in the expected range
        {
          return QCString().sprintf("value for %s is %d which is outside of the value range [%d..%d]",
              dtf.name, value, dtf.minVal, dtf.maxVal);
        }
        dtf.assigner(dt,value);
      }
      format = fmt.format;
      if (format&SF_Date) // if we have a date also determine the weekday
      {
        determine_weekday(dt);
      }
      return QCString();
    }
  }
 
  // no matching pattern found
  return "invalid or non representable date/time argument";
}

References DateTimeField::assigner, determine_weekday(), g_assignValues, g_specFormats, getCurrentDateTime(), QCString::isEmpty(), reg::match(), DateTimeField::maxVal, DateTimeField::minVal, DateTimeField::name, SF_Date, SF_Seconds, SF_Time, QCString::sprintf(), and QCString::str().

Referenced by DocPara::handleShowDate(), and showDate().

◆ dateToString()

QCString dateToString ( DateTimeType includeTime )

Returns the current date, when includeTime is set also the time is provided.

Parameters

[in] includeTime include the time in the output

Definition at line 63 of file datetime.cpp.

{
  auto current = getCurrentDateTime();
  return theTranslator->trDateTime(current.tm_year + 1900,
                                   current.tm_mon + 1,
                                   current.tm_mday,
                                   (current.tm_wday+6)%7+1, // map: Sun=0..Sat=6 to Mon=1..Sun=7
                                   current.tm_hour,
                                   current.tm_min,
                                   current.tm_sec,
                                   includeTime);
}

References getCurrentDateTime(), and theTranslator.

Referenced by RTFGenerator::endIndexSection(), ManGenerator::endTitleHead(), recordMetadata(), substituteHtmlKeywords(), substituteKeywords(), substituteLatexKeywords(), and HtmlGenerator::writeLogoAsString().

◆ determine_weekday()

static void determine_weekday ( std::tm & tm )

static

Definition at line 121 of file datetime.cpp.

{
  auto cpy = tm;
  // there are some problems when the hr:min:sec are on 00:00:00 in determining the weekday
  cpy.tm_hour = 12;
  const auto as_time_t = std::mktime( &cpy ) ;
  if (as_time_t != -1)
  {
    cpy = *std::localtime( &as_time_t ) ;
    tm.tm_wday = cpy.tm_wday;
  }
}

Referenced by dateTimeFromString().

◆ formatDateTime()

QCString formatDateTime	(	const QCString &	format,
		const std::tm &	dt,
		int &	formatUsed )

Return a string representation for a given std::tm value that is formatted according to the pattern given by a format.

Parameters

[in]	format	the string used for format the date and time, e.g. `Y-m-d`
[in]	dt	the date and time value to fill in
[out]	formatUsed	A bitwise OR of `SF_Date`, `SF_Time` and `SF_Seconds` representing the the types of markers found in the format string.

Definition at line 175 of file datetime.cpp.

{
  formatUsed = 0;
  auto getYear      = [](const std::tm &dat) { return dat.tm_year+1900;    };
  auto getMonth     = [](const std::tm &dat) { return dat.tm_mon+1;        };
  auto getDay       = [](const std::tm &dat) { return dat.tm_mday;         };
  auto getDayOfWeek = [](const std::tm &dat) { return (dat.tm_wday+6)%7+1; };
  GrowBuf growBuf;
  char c = 0;
  const char *p            = format.data();
  const char *fmt_zero     = "%02d";
  const char *fmt_nonzero  = "%d";
  const char *fmt_selected = nullptr;
  if (p==nullptr) return QCString();
  while ((c=*p++))
  {
    char nc = *p;
    switch (c)
    {
      case '%':
        fmt_selected = nc=='-' ? fmt_nonzero : fmt_zero; // %-H produces 1 and %H produces 01
        if (nc=='-') nc=*++p; // skip over -
        switch (nc)
        {
          case '%': growBuf.addChar('%');                                                                              break;
          case 'y': growBuf.addInt(fmt_selected,getYear(dt)%100);                              formatUsed|=SF_Date;    break;
          case 'Y': growBuf.addInt("%d",getYear(dt));                                          formatUsed|=SF_Date;    break;
          case 'm': growBuf.addInt(fmt_selected,getMonth(dt));                                 formatUsed|=SF_Date;    break;
          case 'b': growBuf.addStr(theTranslator->trMonth(getMonth(dt),false,false));          formatUsed|=SF_Date;    break;
          case 'B': growBuf.addStr(theTranslator->trMonth(getMonth(dt),false,true));           formatUsed|=SF_Date;    break;
          case 'd': growBuf.addInt(fmt_selected,getDay(dt));                                   formatUsed|=SF_Date;    break;
          case 'u': growBuf.addInt("%d",getDayOfWeek(dt));   /* Monday = 1 ... Sunday = 7 */   formatUsed|=SF_Date;    break;
          case 'w': growBuf.addInt("%d",getDayOfWeek(dt)%7); /* Sunday = 0 ... Saturday = 6 */ formatUsed|=SF_Date;    break;
          case 'a': growBuf.addStr(theTranslator->trDayOfWeek(getDayOfWeek(dt),false,false));  formatUsed|=SF_Date;    break;
          case 'A': growBuf.addStr(theTranslator->trDayOfWeek(getDayOfWeek(dt),false,true));   formatUsed|=SF_Date;    break;
          case 'H': growBuf.addInt(fmt_selected,dt.tm_hour);                                   formatUsed|=SF_Time;    break;
          case 'I': growBuf.addInt(fmt_selected,dt.tm_hour%12);                                formatUsed|=SF_Time;    break;
          case 'p': growBuf.addStr(theTranslator->trDayPeriod(dt.tm_hour>=12));                formatUsed|=SF_Time;    break;
          case 'M': growBuf.addInt(fmt_selected,dt.tm_min);                                    formatUsed|=SF_Time;    break;
          case 'S': growBuf.addInt(fmt_selected,dt.tm_sec);                                    formatUsed|=SF_Seconds; break;
          default:
            growBuf.addChar(c);
            if (*(p-1)=='-') growBuf.addChar('-');
            growBuf.addChar(nc);
            break;
        }
        p++;
        break;
      default:
        growBuf.addChar(c);
        break;
    }
  }
  growBuf.addChar(0);
  return growBuf.get();
}

References GrowBuf::addChar(), GrowBuf::addInt(), GrowBuf::addStr(), QCString::data(), GrowBuf::get(), SF_Date, SF_Seconds, SF_Time, and theTranslator.

Referenced by DocPara::handleShowDate(), and showDate().

◆ getCurrentDateTime()

std::tm getCurrentDateTime ( )

Returns the filled in std::tm for the current date and time.

Definition at line 30 of file datetime.cpp.

{
  QCString sourceDateEpoch = Portable::getenv("SOURCE_DATE_EPOCH");
  if (!sourceDateEpoch.isEmpty()) // see https://reproducible-builds.org/specs/source-date-epoch/
  {
    bool ok = false;
    uint64_t epoch = sourceDateEpoch.toUInt64(&ok);
    if (!ok)
    {
      static bool warnedOnce=FALSE;
      if (!warnedOnce)
      {
        warn_uncond("Environment variable SOURCE_DATE_EPOCH does not contain a valid number; value is '%s'\n",
            qPrint(sourceDateEpoch));
        warnedOnce=TRUE;
      }
    }
    else // use given epoch value as current 'built' time
    {
      auto epoch_start    = std::chrono::time_point<std::chrono::system_clock>{};
      auto epoch_seconds  = std::chrono::seconds(epoch);
      auto build_time     = epoch_start + epoch_seconds;
      std::time_t time    = std::chrono::system_clock::to_time_t(build_time);
      return *gmtime(&time);
    }
  }
 
  // return current local time
  auto now = std::chrono::system_clock::now();
  std::time_t time = std::chrono::system_clock::to_time_t(now);
  return *localtime(&time);
}

References FALSE, Portable::getenv(), QCString::isEmpty(), qPrint(), QCString::toUInt64(), TRUE, and warn_uncond.

Referenced by dateTimeFromString(), dateToRTFDateString(), dateToString(), and yearToString().

◆ yearToString()

QCString yearToString ( )

Returns the current year as a string.

Definition at line 76 of file datetime.cpp.

{
  auto current = getCurrentDateTime();
  return QCString().setNum(current.tm_year+1900);
}

References getCurrentDateTime(), and QCString::setNum().

Referenced by substituteKeywords().

Variable Documentation

◆ g_assignValues

std::array g_assignValues

static

Initial value:

{
  
  DateTimeField{ [](std::tm &tm,int value) { tm.tm_year = value-1900; }, 1900,       9999,    "year"   },
  DateTimeField{ [](std::tm &tm,int value) { tm.tm_mon  = value-1;    },    1,         12,    "month"  },
  DateTimeField{ [](std::tm &tm,int value) { tm.tm_mday = value;      },    1,         31,    "day"    },
  DateTimeField{ [](std::tm &tm,int value) { tm.tm_hour = value;      },    0,         23,    "hour"   },
  DateTimeField{ [](std::tm &tm,int value) { tm.tm_min  = value;      },    0,         59,    "minute" },
  DateTimeField{ [](std::tm &tm,int value) { tm.tm_sec  = value;      },    0,         59,    "second" }
}

Definition at line 110 of file datetime.cpp.

{
  // assigner,                                            minVal,     maxVal,    name
  DateTimeField{ [](std::tm &tm,int value) { tm.tm_year = value-1900; }, 1900,       9999,    "year"   },
  DateTimeField{ [](std::tm &tm,int value) { tm.tm_mon  = value-1;    },    1,         12,    "month"  },
  DateTimeField{ [](std::tm &tm,int value) { tm.tm_mday = value;      },    1,         31,    "day"    },
  DateTimeField{ [](std::tm &tm,int value) { tm.tm_hour = value;      },    0,         23,    "hour"   },
  DateTimeField{ [](std::tm &tm,int value) { tm.tm_min  = value;      },    0,         59,    "minute" },
  DateTimeField{ [](std::tm &tm,int value) { tm.tm_sec  = value;      },    0,         59,    "second" }
};

Referenced by dateTimeFromString().

◆ g_specFormats

std::array g_specFormats

static

Initial value:

{
  
  SpecFormat{ std::string_view(R"((\d+)-(\d+)-(\d+)\s*(\d+):(\d+):(\d+))"),  6,  0,  SF_Date|SF_Time|SF_Seconds }, 
  SpecFormat{ std::string_view(R"((\d+)-(\d+)-(\d+)\s*(\d+):(\d+))"),        5,  0,  SF_Date|SF_Time            }, 
  SpecFormat{ std::string_view(R"((\d+)-(\d+)-(\d+))"),                      3,  0,  SF_Date                    }, 
  SpecFormat{ std::string_view(R"((\d+):(\d+):(\d+))"),                      3,  3,  SF_Time|SF_Seconds         }, 
  SpecFormat{ std::string_view(R"((\d+):(\d+))"),                            2,  3,  SF_Time                    }  
}

Definition at line 100 of file datetime.cpp.

{
  // regular expression,                            num values, offset, format bits
  SpecFormat{ std::string_view(R"((\d+)-(\d+)-(\d+)\s*(\d+):(\d+):(\d+))"),  6,  0,  SF_Date|SF_Time|SF_Seconds }, // format 13-04-2015 12:34:56
  SpecFormat{ std::string_view(R"((\d+)-(\d+)-(\d+)\s*(\d+):(\d+))"),        5,  0,  SF_Date|SF_Time            }, // format 13-04-2015 12:34
  SpecFormat{ std::string_view(R"((\d+)-(\d+)-(\d+))"),                      3,  0,  SF_Date                    }, // format 13-04-2015
  SpecFormat{ std::string_view(R"((\d+):(\d+):(\d+))"),                      3,  3,  SF_Time|SF_Seconds         }, // format 12:34:56
  SpecFormat{ std::string_view(R"((\d+):(\d+))"),                            2,  3,  SF_Time                    }  // format 12:34
};

Referenced by dateTimeFromString().

Classes

Typedefs

Functions

Variables

Typedef Documentation

◆ TMFieldAssigner

Function Documentation

◆ dateTimeFromString()

◆ dateToString()

◆ determine_weekday()

◆ formatDateTime()

◆ getCurrentDateTime()

◆ yearToString()

Variable Documentation

◆ g_assignValues

◆ g_specFormats