C++ wxDateTime::GetDay方法代码示例

long CVSCPTable::getRangeOfData( wxDateTime& wxStart, wxDateTime& wxEnd, void *buf, uint16_t size )
{
    uint64_t from, to;
    time_t rawtime;
    struct tm *timeStart;
    struct tm *timeEnd;
    time ( &rawtime );

    timeStart = localtime( &rawtime );
    timeStart->tm_hour = wxStart.GetHour();
    timeStart->tm_min = wxStart.GetMinute();
    timeStart->tm_sec = wxStart.GetSecond();
    timeStart->tm_mday = wxStart.GetDay();
    timeStart->tm_mon = wxStart.GetDay();
    timeStart->tm_year = wxStart.GetYear();
    from = mktime ( timeStart );

    timeEnd = localtime( &rawtime );
    timeEnd->tm_hour = wxEnd.GetHour();
    timeEnd->tm_min = wxEnd.GetMinute();
    timeEnd->tm_sec = wxEnd.GetSecond();
    timeEnd->tm_mday = wxEnd.GetDay();
    timeEnd->tm_mon = wxEnd.GetDay();
    timeEnd->tm_year = wxEnd.GetYear();
    to = mktime ( timeEnd );

    return getRangeOfData( from, to, buf, size );
}

QDate wxQtConvertDate(const wxDateTime& date)
{
    if ( date.IsValid() )
        return QDate(date.GetYear(), date.GetMonth() + 1, date.GetDay());
    else
        return QDate();
}

INLINE 
void  wxeReturn::addDate(wxDateTime dateTime) {
    addInt(dateTime.GetYear());
    addInt(dateTime.GetMonth()+1); // c++ month is zero based
    addInt(dateTime.GetDay());
    addTupleCount(3);
}

void DashboardInstrument_Moon::SetUtcTime( wxDateTime data )
{
    if (data.IsValid())
    {
        m_phase = moon_phase(data.GetYear(), data.GetMonth() + 1, data.GetDay());
    }
}

wxString CompDateAxis::GetSpanLabel(wxDateTime date, wxDateSpan span)
{
    int days = span.GetDays();
    int weeks = span.GetWeeks();
    int months = span.GetMonths();
    int years = span.GetYears();

    if (days != 0 && weeks == 0 && months == 0 && years == 0) {
        // days span
        int startDay = date.GetDay();
        int endDay = startDay + days;

        wxDateTime::wxDateTime_t maxDay = wxDateTime::GetNumberOfDays(date.GetMonth(), date.GetYear());
        if (endDay > maxDay) {
            endDay -= maxDay;
        }
        return FormatInterval(startDay, endDay);
    }
    else if (days == 0 && weeks != 0 && months == 0 && years == 0) {
        // weeks span
        int startWeek = date.GetWeekOfMonth();
        int endWeek = startWeek + weeks;

        return FormatInterval(startWeek, endWeek);
    }
    else if (days == 0 && weeks == 0 && months != 0 && years == 0) {
        // monthes span
        int startMonth = MonthNum(date.GetMonth());
        int endMonth = startMonth + months;
        if (endMonth > 12) {
            endMonth = endMonth % 12;
        }

        if (months == 1) {
            return wxDateTime::GetMonthName(MonthFromNum(startMonth));
        }
        else {
            return wxString::Format(wxT("%s-%s"),
                                    wxDateTime::GetMonthName(MonthFromNum(startMonth)).c_str(),
                                    wxDateTime::GetMonthName(MonthFromNum(endMonth)).c_str());
        }
    }
    else if (days == 0 && weeks == 0 && months == 0 && years != 0) {
        // years span
        int startYear = date.GetYear();
        int endYear = startYear + years;

        return FormatInterval(startYear, endYear);
    }
    else {
        // we have unaligned span, so print start-end dates
        wxDateTime endDate = date;
        endDate += span;

        return wxString::Format(wxT("%s-%s"),
                                date.Format(wxT("%d-%m-%y")).c_str(),
                                endDate.Format(wxT("%d-%m-%y")).c_str());
    }
}

/* this is not actually all that accurate (no oblate earth, refraction etc...
   but it's at least simple, could fix and optimize to only compute if
   there are possible plans which need this */
static bool ComputeDayTime(const wxDateTime &gribtime, double lat, double lon, int &daytime)

{
    if(daytime != -1)
        return daytime != 0;

    double yearpos = 2*M_PI*(gribtime.GetDay()-186)/365.24;
    double gha = 2*M_PI*(lon/15 - gribtime.GetHour() - gribtime.GetMinute()/60)/24;
    double suninc = 90*cos(deg2rad(lat))*sin(gha) + 23.45*cos(yearpos);    

    return (daytime = (suninc > 0)) != 0; /* sun above horizon */
}

void wxMysqlPreparedStatementParameter::SetDate(const wxDateTime& dateValue)
{
  m_Data.dateValue.year = dateValue.GetYear();
  m_Data.dateValue.month = dateValue.GetMonth();
  m_Data.dateValue.day = dateValue.GetDay();
  m_Data.dateValue.hour = dateValue.GetHour();
  m_Data.dateValue.minute = dateValue.GetMinute();
  m_Data.dateValue.second = dateValue.GetSecond();
    
  m_pBind->buffer_type = MYSQL_TYPE_DATETIME;
  m_pBind->buffer = (void*)&m_Data.dateValue;
}

wxDateTime RoundDateToSpan(wxDateTime date, wxDateSpan span)
{
    wxDateTime::wxDateTime_t day = date.GetDay();
    int month = MonthNum(date.GetMonth());
    wxDateTime::wxDateTime_t year = date.GetYear();

    wxDateTime::wxDateTime_t modDays = Mod(day - 1, span.GetTotalDays());
    wxDateTime::wxDateTime_t modMonths = Mod(month - 1, span.GetMonths());
    wxDateTime::wxDateTime_t modYears = Mod(year, span.GetYears());

    return wxDateTime(day - modDays, MonthFromNum(month - modMonths), year - modYears);
}

	static inline std::tm to_tm(const wxDateTime& datetime)
	{
		std::tm result;
		result.tm_sec  = datetime.GetSecond();
		result.tm_min  = datetime.GetMinute();
		result.tm_hour = datetime.GetHour();
		result.tm_mday = datetime.GetDay();
		result.tm_mon  = datetime.GetMonth();
		result.tm_year = datetime.GetYear();
		result.tm_wday = datetime.GetWeekDay();
		result.tm_yday = datetime.GetDayOfYear();
		result.tm_isdst= datetime.IsDST();
		return result;
	}

wxOdbcParameter::wxOdbcParameter(const wxDateTime& dateValue)
{
  m_nParameterType = wxOdbcParameter::PARAM_DATETIME;
    	      
  m_DateValue.year = dateValue.GetYear();
  m_DateValue.month = dateValue.GetMonth()+1;
	m_DateValue.day = dateValue.GetDay();
    	    
  m_DateValue.hour = dateValue.GetHour();
  m_DateValue.minute = dateValue.GetMinute();
  m_DateValue.second = dateValue.GetSecond();
  m_DateValue.fraction = dateValue.GetMillisecond();

  m_nBufferLength = 0;
}

//* Date Functions----------------------------------------------------------*//
const wxString mmGetNiceDateSimpleString(const wxDateTime &dt)
{
    wxString dateFmt = mmOptions::instance().dateFormat_;
    dateFmt.Replace("%Y%m%d", "%Y %m %d");
    dateFmt.Replace(".", " ");
    dateFmt.Replace(",", " ");
    dateFmt.Replace("/", " ");
    dateFmt.Replace("-", " ");
    dateFmt.Replace("%d", wxString::Format("%d", dt.GetDay()));
    dateFmt.Replace("%Y", wxString::Format("%d", dt.GetYear()));
    dateFmt.Replace("%y", wxString::Format("%d", dt.GetYear()).Mid(2,2));
    dateFmt.Replace("%m", wxGetTranslation(wxDateTime::GetEnglishMonthName(dt.GetMonth())));

    return dateFmt;
}

/* rebuild the map at a given date */
bool MagneticPlotMap::Recompute(wxDateTime date)
{
    if(!m_bEnabled)
        return true;

    UserDate.Year = date.GetYear();
    UserDate.Month = date.GetMonth();
    UserDate.Day = date.GetDay();

    char err[255];
    WMM_DateToYear(&UserDate, err);

    /* Time adjust the coefficients, Equation 19, WMM Technical report */
    WMM_TimelyModifyMagneticModel(UserDate, MagneticModel, TimedMagneticModel);

    return IsoBarMap::Recompute()
}

MysqlParameter::MysqlParameter(const wxDateTime& dateValue)
{
  m_nParameterType = MysqlParameter::PARAM_DATETIME;

  m_pDate = new MYSQL_TIME();

  memset(m_pDate, 0, sizeof(MYSQL_TIME));

  m_pDate->year = dateValue.GetYear();
  m_pDate->month = dateValue.GetMonth()+1;
  m_pDate->day = dateValue.GetDay();
  m_pDate->hour = dateValue.GetHour();
  m_pDate->minute = dateValue.GetMinute();
  m_pDate->second = dateValue.GetSecond();
  m_pDate->neg = 0;

  m_nBufferLength = sizeof(MYSQL_TIME);
}

// -------------------------------------------------------
// GRIBMELINE is a misnomer
void climatology_pi::SendTimelineMessage(wxDateTime time)
{
    Json::Value v;
    if (time.IsValid()) {
        v["Day"] = time.GetDay();
        v["Month"] = time.GetMonth();
        v["Year"] = time.GetYear();
        v["Hour"] = time.GetHour();
        v["Minute"] = time.GetMinute();
        v["Second"] = time.GetSecond();
    } else {
        v["Day"] = -1;
        v["Month"] = -1;
        v["Year"] = -1;
        v["Hour"] = -1;
        v["Minute"] = -1;
        v["Second"] = -1;
    }
    Json::FastWriter writer;
    SendPluginMessage("GRIB_TIMELINE", writer.write( v ));
}

static void ConvertWxToFileTime(FILETIME *ft, const wxDateTime& dt)
{
    SYSTEMTIME st;
    st.wDay = dt.GetDay();
    st.wMonth = (WORD)(dt.GetMonth() + 1);
    st.wYear = (WORD)dt.GetYear();
    st.wHour = dt.GetHour();
    st.wMinute = dt.GetMinute();
    st.wSecond = dt.GetSecond();
    st.wMilliseconds = dt.GetMillisecond();

    FILETIME ftLocal;
    if ( !::SystemTimeToFileTime(&st, &ftLocal) )
    {
        wxLogLastError(_T("SystemTimeToFileTime"));
    }

    if ( !::LocalFileTimeToFileTime(&ftLocal, ft) )
    {
        wxLogLastError(_T("LocalFileTimeToFileTime"));
    }
}