the returned string could be NULL and so a separate helper class is used. If
you obtain compilation errors because of this, you can always correct them by
explicitly assigning the function return value to a variable of wanted type.
+ A slightly more intrusive but better solution is to use ParseXXX() version
+ with wxString::const_iterator output parameter which simply returns bool to
+ indicate the parsing success.
- Some structure fields which used to be of type "const wxChar *" (such as
wxCmdLineEntryDesc::shortName, longName and description fields) are now of
wxDECLARE_NO_ASSIGN_CLASS(wxAnyStrPtr);
};
-// at least for VC6 and VC7 these operators are needed too, otherwise boolean
-// expressions involving wxAnyStrPtr don't compile because of ambiguity between
-// built-in overloads of these operators for (bool, bool/char*/wchar_t*)
-inline bool operator||(const wxAnyStrPtr& p, bool v) { return (bool)p || v; }
-inline bool operator||(bool v, const wxAnyStrPtr& p) { return v || (bool)p; }
-inline bool operator&&(const wxAnyStrPtr& p, bool v) { return (bool)p && v; }
-inline bool operator&&(bool v, const wxAnyStrPtr& p) { return v && (bool)p; }
-
#endif // _WX_ANYSTR_H_
inline wxTimeSpan Subtract(const wxDateTime& dt) const;
inline wxTimeSpan operator-(const wxDateTime& dt2) const;
- // conversion to/from text: all conversions from text return an object
- // representing the next character following the date specification (i.e.
- // the one where the scan had to stop) or a special NULL-like object
- // on failure -- this object is necessary to preserve compatibility with
- // the existing code assigning the return value of these functions to
- // either char* or wxChar* (new code should treat the return value as bool
- // and use end parameter to retrieve the end of the scan)
+ // conversion to/from text
// ------------------------------------------------------------------------
+ // all conversions functions return true to indicate whether parsing
+ // succeeded or failed and fill in the provided end iterator, which must
+ // not be NULL, with the location of the character where the parsing
+ // stopped (this will be end() of the passed string if everything was
+ // parsed)
+
// parse a string in RFC 822 format (found e.g. in mail headers and
// having the form "Wed, 10 Feb 1999 19:07:07 +0100")
- wxAnyStrPtr ParseRfc822Date(const wxString& date,
- wxString::const_iterator *end = NULL);
+ bool ParseRfc822Date(const wxString& date,
+ wxString::const_iterator *end);
// parse a date/time in the given format (see strptime(3)), fill in
// the missing (in the string) fields with the values of dateDef (by
// default, they will not change if they had valid values or will
// default to Today() otherwise)
- wxAnyStrPtr ParseFormat(const wxString& date,
- const wxString& format = wxDefaultDateTimeFormat,
- const wxDateTime& dateDef = wxDefaultDateTime,
- wxString::const_iterator *end = NULL);
-
- wxAnyStrPtr ParseFormat(const wxString& date,
- const wxString& format,
- wxString::const_iterator *end)
+ bool ParseFormat(const wxString& date,
+ const wxString& format,
+ const wxDateTime& dateDef,
+ wxString::const_iterator *end);
+
+ bool ParseFormat(const wxString& date,
+ const wxString& format,
+ wxString::const_iterator *end)
{
return ParseFormat(date, format, wxDefaultDateTime, end);
}
+ bool ParseFormat(const wxString& date,
+ wxString::const_iterator *end)
+ {
+ return ParseFormat(date, wxDefaultDateTimeFormat, wxDefaultDateTime, end);
+ }
// parse a string containing date, time or both in ISO 8601 format
//
// provide compatibility overloads for them
bool ParseISODate(const wxString& date)
{
- // FIXME-VC6: notice that writing "return ParseFormat() && ..." crashes
- // VC6 with internal compiler error so don't attempt to
- // simplify this code like this
-
wxString::const_iterator end;
- if ( !ParseFormat(date, wxS("%Y-%m-%d"), &end) )
- return false;
-
- return end == date.end();
+ return ParseFormat(date, wxS("%Y-%m-%d"), &end) && end == date.end();
}
bool ParseISOTime(const wxString& time)
{
wxString::const_iterator end;
- if ( !ParseFormat(time, wxS("%H:%M:%S"), &end) )
- return false;
-
- return end == time.end();
+ return ParseFormat(time, wxS("%H:%M:%S"), &end) && end == time.end();
}
bool ParseISOCombined(const wxString& datetime, char sep = 'T')
{
wxString::const_iterator end;
const wxString fmt = wxS("%Y-%m-%d") + wxString(sep) + wxS("%H:%M:%S");
- if ( !ParseFormat(datetime, fmt, &end) )
- return false;
-
- return end == datetime.end();
+ return ParseFormat(datetime, fmt, &end) && end == datetime.end();
}
// parse a string containing the date/time in "free" format, this
// function will try to make an educated guess at the string contents
- wxAnyStrPtr ParseDateTime(const wxString& datetime,
- wxString::const_iterator *end = NULL);
+ bool ParseDateTime(const wxString& datetime,
+ wxString::const_iterator *end);
// parse a string containing the date only in "free" format (less
// flexible than ParseDateTime)
- wxAnyStrPtr ParseDate(const wxString& date,
- wxString::const_iterator *end = NULL);
+ bool ParseDate(const wxString& date,
+ wxString::const_iterator *end);
// parse a string containing the time only in "free" format
- wxAnyStrPtr ParseTime(const wxString& time,
- wxString::const_iterator *end = NULL);
+ bool ParseTime(const wxString& time,
+ wxString::const_iterator *end);
// this function accepts strftime()-like format string (default
wxString FormatISOCombined(char sep = 'T') const
{ return FormatISODate() + sep + FormatISOTime(); }
+
+ // backwards compatible versions of the parsing functions: they return an
+ // object representing the next character following the date specification
+ // (i.e. the one where the scan had to stop) or a special NULL-like object
+ // on failure
+ //
+ // they're not deprecated because a lot of existing code uses them and
+ // there is no particular harm in keeping them but you should still prefer
+ // the versions above in the new code
+ wxAnyStrPtr ParseRfc822Date(const wxString& date)
+ {
+ wxString::const_iterator end;
+ return ParseRfc822Date(date, &end) ? wxAnyStrPtr(date, end)
+ : wxAnyStrPtr();
+ }
+
+ wxAnyStrPtr ParseFormat(const wxString& date,
+ const wxString& format = wxDefaultDateTimeFormat,
+ const wxDateTime& dateDef = wxDefaultDateTime)
+ {
+ wxString::const_iterator end;
+ return ParseFormat(date, format, dateDef, &end) ? wxAnyStrPtr(date, end)
+ : wxAnyStrPtr();
+ }
+
+ wxAnyStrPtr ParseDateTime(const wxString& datetime)
+ {
+ wxString::const_iterator end;
+ return ParseDateTime(datetime, &end) ? wxAnyStrPtr(datetime, end)
+ : wxAnyStrPtr();
+ }
+
+ wxAnyStrPtr ParseDate(const wxString& date)
+ {
+ wxString::const_iterator end;
+ return ParseDate(date, &end) ? wxAnyStrPtr(date, end)
+ : wxAnyStrPtr();
+ }
+
+ wxAnyStrPtr ParseTime(const wxString& time)
+ {
+ wxString::const_iterator end;
+ return ParseTime(time, &end) ? wxAnyStrPtr(time, end)
+ : wxAnyStrPtr();
+ }
+
// implementation
// ------------------------------------------------------------------------
@see Format()
*/
- const char* ParseDate(const wxString& date,
- wxString::const_iterator* end = NULL);
+ bool ParseDate(const wxString& date, wxString::const_iterator *end);
/**
Parses the string @a datetime containing the date and time in free
See ParseFormat() for the description of function parameters and return
value.
*/
- const char* ParseDateTime(const wxString& datetime,
- wxString::const_iterator* end = NULL);
+ bool ParseDateTime(const wxString& datetime, wxString::const_iterator *end);
/**
This function parses the string @a date according to the given
@a dateDef. If it is not specified, Today() is used as the default
date.
- Notice that the return value of this method is not actually a pointer
- but rather an object of a special proxy class which is convertible to
- either @c char* or @c wchar_t* pointer. This is needed for
- compatibility with the existing code but the new code should use @a end
- parameter instead and just test whether the return value is @NULL or
- not, e.g.:
+ Example of using this function:
@code
wxDateTime dt;
wxString str = "...";
Used to fill in the date components not specified in the @a date
string.
@param end
- If non-@NULL, will be filled with the iterator pointing to the
- location where the parsing stopped. If the entire string was
- consumed, it is set to @c date.end().
+ Will be filled with the iterator pointing to the location where the
+ parsing stopped if the function returns @true. If the entire string
+ was consumed, it is set to @c date.end(). Notice that this argument
+ must be non-@NULL.
@return
- Pointer-like object indicating the location where the scan stopped
- if parsing was successful or @NULL-like otherwise.
+ @true if at least part of the string was parsed successfully,
+ @false otherwise.
@see Format()
*/
- const char* ParseFormat(const wxString& date,
- const wxString& format = wxDefaultDateTimeFormat,
- const wxDateTime& dateDef = wxDefaultDateTime,
- wxString::const_iterator* end = NULL);
+ bool ParseFormat(const wxString& date,
+ const wxString& format = wxDefaultDateTimeFormat,
+ const wxDateTime& dateDef = wxDefaultDateTime,
+ wxString::const_iterator *end);
/**
@overload
*/
- const char* ParseFormat(const wxString& date,
- const wxString& format = wxDefaultDateTimeFormat,
- wxString::const_iterator* end = NULL);
+ bool ParseFormat(const wxString& date,
+ const wxString& format = wxDefaultDateTimeFormat,
+ wxString::const_iterator *end);
+
+ /**
+ @overload
+ */
+ bool ParseFormat(const wxString& date, wxString::const_iterator *end);
/**
This function parses the string containing the date and time in ISO
See ParseFormat() for the description of function parameters and return
value.
*/
- const char* ParseRfc822Date(const wxString& date,
- wxString::const_iterator* end = NULL);
+ bool ParseRfc822Date(const wxString& date, wxString::const_iterator *end);
/**
This functions is like ParseDateTime(), but only allows the time to be
See ParseFormat() for the description of function parameters and return
value.
*/
- const char* ParseTime(const wxString& time,
- wxString::const_iterator* end = NULL);
+ bool ParseTime(const wxString& time, wxString::const_iterator *end);
//@}
case wxCMD_LINE_VAL_DATE:
{
wxDateTime dt;
- const char *res = dt.ParseDate(value);
- if ( !res || *res )
+ wxString::const_iterator end;
+ if ( !dt.ParseDate(value) || end != value.end() )
{
errorMsg << wxString::Format(_("Option '%s': '%s' cannot be converted to a date."),
name.c_str(), value.c_str())
//
// this function is "strict" by design - it must reject anything except true
// RFC822 time specs.
-wxAnyStrPtr
+bool
wxDateTime::ParseRfc822Date(const wxString& date, wxString::const_iterator *end)
{
wxString::const_iterator p = date.begin();
const wxString::const_iterator endWday = p + WDAY_LEN;
const wxString wday(p, endWday);
if ( GetWeekDayFromName(wday, Name_Abbr, DateLang_English) == Inv_WeekDay )
- return wxAnyStrPtr();
+ return false;
//else: ignore week day for now, we could also check that it really
// corresponds to the specified date
// 2. separating comma
if ( *p++ != ',' || *p++ != ' ' )
- return wxAnyStrPtr();
+ return false;
// 3. day number
if ( !wxIsdigit(*p) )
- return wxAnyStrPtr();
+ return false;
wxDateTime_t day = (wxDateTime_t)(*p++ - '0');
if ( wxIsdigit(*p) )
}
if ( *p++ != ' ' )
- return wxAnyStrPtr();
+ return false;
// 4. month name
static const int MONTH_LEN = 3;
const wxString monName(p, endMonth);
Month mon = GetMonthFromName(monName, Name_Abbr, DateLang_English);
if ( mon == Inv_Month )
- return wxAnyStrPtr();
+ return false;
p = endMonth;
if ( *p++ != ' ' )
- return wxAnyStrPtr();
+ return false;
// 5. year
if ( !wxIsdigit(*p) )
- return wxAnyStrPtr();
+ return false;
int year = *p++ - '0';
if ( !wxIsdigit(*p) ) // should have at least 2 digits in the year
- return wxAnyStrPtr();
+ return false;
year *= 10;
year += *p++ - '0';
if ( !wxIsdigit(*p) )
{
// no 3 digit years please
- return wxAnyStrPtr();
+ return false;
}
year *= 10;
}
if ( *p++ != ' ' )
- return wxAnyStrPtr();
+ return false;
// 6. time in hh:mm:ss format with seconds being optional
if ( !wxIsdigit(*p) )
- return wxAnyStrPtr();
+ return false;
wxDateTime_t hour = (wxDateTime_t)(*p++ - '0');
if ( !wxIsdigit(*p) )
- return wxAnyStrPtr();
+ return false;
hour *= 10;
hour = (wxDateTime_t)(hour + (*p++ - '0'));
if ( *p++ != ':' )
- return wxAnyStrPtr();
+ return false;
if ( !wxIsdigit(*p) )
- return wxAnyStrPtr();
+ return false;
wxDateTime_t min = (wxDateTime_t)(*p++ - '0');
if ( !wxIsdigit(*p) )
- return wxAnyStrPtr();
+ return false;
min *= 10;
min += (wxDateTime_t)(*p++ - '0');
{
p++;
if ( !wxIsdigit(*p) )
- return wxAnyStrPtr();
+ return false;
sec = (wxDateTime_t)(*p++ - '0');
if ( !wxIsdigit(*p) )
- return wxAnyStrPtr();
+ return false;
sec *= 10;
sec += (wxDateTime_t)(*p++ - '0');
}
if ( *p++ != ' ' )
- return wxAnyStrPtr();
+ return false;
// 7. now the interesting part: the timezone
int offset wxDUMMY_INITIALIZE(0);
bool plus = *p++ == '+';
if ( !wxIsdigit(*p) || !wxIsdigit(*(p + 1)) )
- return wxAnyStrPtr();
+ return false;
// hours
p += 2;
if ( !wxIsdigit(*p) || !wxIsdigit(*(p + 1)) )
- return wxAnyStrPtr();
+ return false;
// minutes
offset += 10*(*p - '0') + (*(p + 1) - '0');
};
if ( *p < _T('A') || *p > _T('Z') || *p == _T('J') )
- return wxAnyStrPtr();
+ return false;
offset = offsets[*p++ - 'A'];
}
else if ( tz == _T("PDT") )
offset = PDT - GMT0;
else
- return wxAnyStrPtr();
+ return false;
p += tz.length();
}
if ( end )
*end = p;
- return wxAnyStrPtr(date, p);
+ return true;
}
#ifdef __WINDOWS__
#endif // __WINDOWS__
-wxAnyStrPtr
+bool
wxDateTime::ParseFormat(const wxString& date,
const wxString& format,
const wxDateTime& dateDef,
wxString::const_iterator *end)
{
- wxCHECK_MSG( !format.empty(), wxAnyStrPtr(), "format can't be empty" );
+ wxCHECK_MSG( !format.empty(), false, "format can't be empty" );
+ wxCHECK_MSG( end, false, "end iterator pointer must be specified" );
wxString str;
unsigned long num;
if ( *input++ != *fmt )
{
// no match
- return wxAnyStrPtr();
+ return false;
}
}
if ( wday == Inv_WeekDay )
{
// no match
- return wxAnyStrPtr();
+ return false;
}
}
haveWDay = true;
if ( mon == Inv_Month )
{
// no match
- return wxAnyStrPtr();
+ return false;
}
}
haveMon = true;
wxS("%X %x")
);
if ( !dt.IsValid() )
- return wxAnyStrPtr();
+ return false;
Tm tm = dt.GetTm();
(num > 31) || (num < 1) )
{
// no match
- return wxAnyStrPtr();
+ return false;
}
// we can't check whether the day range is correct yet, will
if ( !GetNumericToken(width, input, &num) || (num > 23) )
{
// no match
- return wxAnyStrPtr();
+ return false;
}
haveHour = true;
if ( !GetNumericToken(width, input, &num) || !num || (num > 12) )
{
// no match
- return wxAnyStrPtr();
+ return false;
}
haveHour = true;
if ( !GetNumericToken(width, input, &num) || !num || (num > 366) )
{
// no match
- return wxAnyStrPtr();
+ return false;
}
haveYDay = true;
case _T('l'): // milliseconds (0-999)
if ( !GetNumericToken(width, input, &num) )
- return wxAnyStrPtr();
+ return false;
haveMsec = true;
msec = (wxDateTime_t)num;
if ( !GetNumericToken(width, input, &num) || !num || (num > 12) )
{
// no match
- return wxAnyStrPtr();
+ return false;
}
haveMon = true;
if ( !GetNumericToken(width, input, &num) || (num > 59) )
{
// no match
- return wxAnyStrPtr();
+ return false;
}
haveMin = true;
GetAmPmStrings(&am, &pm);
if (am.empty() && pm.empty())
- return wxAnyStrPtr(); // no am/pm strings defined
+ return false; // no am/pm strings defined
if ( token.CmpNoCase(pm) == 0 )
{
isPM = true;
else if ( token.CmpNoCase(am) != 0 )
{
// no match
- return wxAnyStrPtr();
+ return false;
}
}
break;
wxDateTime dt;
if ( !dt.ParseFormat(wxString(input, date.end()),
wxS("%I:%M:%S %p"), &input) )
- return wxAnyStrPtr();
+ return false;
haveHour = haveMin = haveSec = true;
const wxDateTime
dt = ParseFormatAt(input, date.end(), wxS("%H:%M"));
if ( !dt.IsValid() )
- return wxAnyStrPtr();
+ return false;
haveHour =
haveMin = true;
if ( !GetNumericToken(width, input, &num) || (num > 61) )
{
// no match
- return wxAnyStrPtr();
+ return false;
}
haveSec = true;
const wxDateTime
dt = ParseFormatAt(input, date.end(), wxS("%H:%M:%S"));
if ( !dt.IsValid() )
- return wxAnyStrPtr();
+ return false;
haveHour =
haveMin =
if ( !GetNumericToken(width, input, &num) || (wday > 6) )
{
// no match
- return wxAnyStrPtr();
+ return false;
}
haveWDay = true;
dt = ParseFormatAt(input, date.end(),
fmtDate, fmtDateAlt);
if ( !dt.IsValid() )
- return wxAnyStrPtr();
+ return false;
Tm tm = dt.GetTm();
// use strptime() to do it for us (FIXME !Unicode friendly)
struct tm tm;
if ( !CallStrptime(date, input, "%X", &tm) )
- return wxAnyStrPtr();
+ return false;
haveHour = haveMin = haveSec = true;
const wxDateTime
dt = ParseFormatAt(input, date.end(), "%T", "%r");
if ( !dt.IsValid() )
- return wxAnyStrPtr();
+ return false;
haveHour =
haveMin =
if ( !GetNumericToken(width, input, &num) || (num > 99) )
{
// no match
- return wxAnyStrPtr();
+ return false;
}
haveYear = true;
if ( !GetNumericToken(width, input, &num) )
{
// no match
- return wxAnyStrPtr();
+ return false;
}
haveYear = true;
if ( *input++ != _T('%') )
{
// no match
- return wxAnyStrPtr();
+ return false;
}
break;
// fall through
default: // not a known format spec
- return wxAnyStrPtr();
+ return false;
}
}
if ( haveDay )
{
if ( mday > GetNumberOfDays(tm.mon, tm.year) )
- return wxAnyStrPtr();
+ return false;
tm.mday = mday;
}
else if ( haveYDay )
{
if ( yday > GetNumberOfDays(tm.year) )
- return wxAnyStrPtr();
+ return false;
Tm tm2 = wxDateTime(1, Jan, tm.year).SetToYearDay(yday).GetTm();
// finally check that the week day is consistent -- if we had it
if ( haveWDay && GetWeekDay() != wday )
- return wxAnyStrPtr();
+ return false;
- if ( end )
- *end = input;
+ *end = input;
- return wxAnyStrPtr(date, input);
+ return true;
}
-wxAnyStrPtr
+bool
wxDateTime::ParseDateTime(const wxString& date, wxString::const_iterator *end)
{
+ wxCHECK_MSG( end, false, "end iterator pointer must be specified" );
+
// Set to current day and hour, so strings like '14:00' becomes today at
// 14, not some other random date
wxDateTime dtDate = wxDateTime::Today();
const wxString timestr(endDate, date.end());
if ( !dtTime.ParseTime(timestr, &endTime) )
- return wxAnyStrPtr();
+ return false;
endBoth = endDate + (endTime - timestr.begin());
}
{
// check if we have a time followed by a date
if ( !dtTime.ParseTime(date, &endTime) )
- return wxAnyStrPtr();
+ return false;
while ( endTime != date.end() && wxIsspace(*endTime) )
++endTime;
const wxString datestr(endTime, date.end());
if ( !dtDate.ParseDate(datestr, &endDate) )
- return wxAnyStrPtr();
+ return false;
endBoth = endTime + (endDate - datestr.begin());
}
dtTime.GetHour(), dtTime.GetMinute(), dtTime.GetSecond(),
dtTime.GetMillisecond());
- // Return endpoint of scan
- if ( end )
- *end = endBoth;
+ *end = endBoth;
- return wxAnyStrPtr(date, endBoth);
+ return true;
}
-wxAnyStrPtr
+bool
wxDateTime::ParseDate(const wxString& date, wxString::const_iterator *end)
{
+ wxCHECK_MSG( end, false, "end iterator pointer must be specified" );
+
// this is a simplified version of ParseDateTime() which understands only
// "today" (for wxDate compatibility) and digits only otherwise (and not
// all esoteric constructions ParseDateTime() knows about)
*this += wxDateSpan::Days(dayDiffFromToday);
}
- if ( end )
- *end = pEnd;
+ *end = pEnd;
- return wxAnyStrPtr(date, pEnd);
+ return true;
}
}
// either no more tokens or the scan was stopped by something we couldn't
// parse - in any case, see if we can construct a date from what we have
if ( !haveDay && !haveWDay )
- return wxAnyStrPtr();
+ return false;
if ( haveWDay && (haveMon || haveYear || haveDay) &&
!(haveDay && haveMon && haveYear) )
// without adjectives (which we don't support here) the week day only
// makes sense completely separately or with the full date
// specification (what would "Wed 1999" mean?)
- return wxAnyStrPtr();
+ return false;
}
if ( !haveWDay && haveYear && !(haveDay && haveMon) )
}
if ( !haveMon )
- return wxAnyStrPtr();
+ return false;
}
if ( !haveMon )
// normally we check the day above but the check is optimistic in case
// we find the day before its month/year so we have to redo it now
if ( day > GetNumberOfDays(mon, year) )
- return wxAnyStrPtr();
+ return false;
Set(day, mon, year);
{
// check that it is really the same
if ( GetWeekDay() != wday )
- return wxAnyStrPtr();
+ return false;
}
}
else // haveWDay
p--;
}
- if ( end )
- *end = p;
+ *end = p;
- return wxAnyStrPtr(date, p);
+ return true;
}
-wxAnyStrPtr
+bool
wxDateTime::ParseTime(const wxString& time, wxString::const_iterator *end)
{
+ wxCHECK_MSG( end, false, "end iterator pointer must be specified" );
+
// first try some extra things
static const struct
{
if ( end )
*end = p;
- return wxAnyStrPtr(time, p);
+ return true;
}
}
for ( size_t nFmt = 0; nFmt < WXSIZEOF(timeFormats); nFmt++ )
{
- const wxAnyStrPtr result = ParseFormat(time, timeFormats[nFmt], end);
- if ( result )
- return result;
+ if ( ParseFormat(time, timeFormats[nFmt], end) )
+ return true;
}
- return wxAnyStrPtr();
+ return false;
}
// ----------------------------------------------------------------------------
return true;
}
- if(! m_value.ParseDateTime(str.c_str()/*FIXME-UTF8*/))
- return false;
- return true;
+ wxString::const_iterator end;
+ return m_value.ParseDateTime(str, &end) && end == str.end();
}
// wxVariant
projects / wxWidgets.git / commitdiff
