1021 lines
20 KiB
C++
1021 lines
20 KiB
C++
// file : xsd/cxx/parser/xml-schema.ixx
|
|
// license : GNU GPL v2 + exceptions; see accompanying LICENSE file
|
|
|
|
#include <new> // operator new/delete
|
|
#include <cstring> // std::memcpy, std::memcmp
|
|
|
|
namespace xsd
|
|
{
|
|
namespace cxx
|
|
{
|
|
namespace parser
|
|
{
|
|
// string_sequence
|
|
//
|
|
template <typename C>
|
|
string_sequence<C>::
|
|
string_sequence ()
|
|
{
|
|
}
|
|
|
|
template <typename C>
|
|
string_sequence<C>::
|
|
string_sequence (size_type n, const value_type& x)
|
|
: base (n, x)
|
|
{
|
|
}
|
|
|
|
template <typename C>
|
|
template <typename I>
|
|
string_sequence<C>::
|
|
string_sequence (const I& begin, const I& end)
|
|
: base (begin, end)
|
|
{
|
|
}
|
|
|
|
template <typename C>
|
|
inline bool
|
|
operator!= (const string_sequence<C>& a, const string_sequence<C>& b)
|
|
{
|
|
return !(a == b);
|
|
}
|
|
|
|
// qname
|
|
//
|
|
template <typename C>
|
|
inline qname<C>::
|
|
qname (const std::basic_string<C>& name)
|
|
: name_ (name)
|
|
{
|
|
}
|
|
|
|
template <typename C>
|
|
inline qname<C>::
|
|
qname (const std::basic_string<C>& prefix,
|
|
const std::basic_string<C>& name)
|
|
: prefix_ (prefix), name_ (name)
|
|
{
|
|
}
|
|
|
|
template <typename C>
|
|
void qname<C>::
|
|
swap (qname<C>& x)
|
|
{
|
|
prefix_.swap (x.prefix_);
|
|
name_.swap (x.name_);
|
|
}
|
|
|
|
template <typename C>
|
|
inline const std::basic_string<C>& qname<C>::
|
|
prefix () const
|
|
{
|
|
return prefix_;
|
|
}
|
|
|
|
template <typename C>
|
|
inline std::basic_string<C>& qname<C>::
|
|
prefix ()
|
|
{
|
|
return prefix_;
|
|
}
|
|
|
|
template <typename C>
|
|
inline void qname<C>::
|
|
prefix (const std::basic_string<C>& prefix)
|
|
{
|
|
prefix_ = prefix;
|
|
}
|
|
|
|
template <typename C>
|
|
inline const std::basic_string<C>& qname<C>::
|
|
name () const
|
|
{
|
|
return name_;
|
|
}
|
|
|
|
template <typename C>
|
|
inline std::basic_string<C>& qname<C>::
|
|
name ()
|
|
{
|
|
return name_;
|
|
}
|
|
|
|
template <typename C>
|
|
inline void qname<C>::
|
|
name (const std::basic_string<C>& name)
|
|
{
|
|
name_ = name;
|
|
}
|
|
|
|
template <typename C>
|
|
inline bool
|
|
operator== (const qname<C>& a, const qname<C>& b)
|
|
{
|
|
return a.prefix () == b.prefix () && a.name () == b.name ();
|
|
}
|
|
|
|
template <typename C>
|
|
inline bool
|
|
operator!= (const qname<C>& a, const qname<C>& b)
|
|
{
|
|
return !(a == b);
|
|
}
|
|
|
|
// buffer
|
|
//
|
|
inline buffer::
|
|
~buffer ()
|
|
{
|
|
if (data_)
|
|
operator delete (data_);
|
|
}
|
|
|
|
inline buffer::
|
|
buffer (size_t size)
|
|
: data_ (0), size_ (0), capacity_ (0)
|
|
{
|
|
capacity (size);
|
|
size_ = size;
|
|
}
|
|
|
|
inline buffer::
|
|
buffer (size_t size, size_t cap)
|
|
: data_ (0), size_ (0), capacity_ (0)
|
|
{
|
|
if (size > cap)
|
|
throw bounds ();
|
|
|
|
capacity (cap);
|
|
size_ = size;
|
|
}
|
|
|
|
inline buffer::
|
|
buffer (const void* data, size_t size)
|
|
: data_ (0), size_ (0), capacity_ (0)
|
|
{
|
|
capacity (size);
|
|
size_ = size;
|
|
|
|
if (size_)
|
|
std::memcpy (data_, data, size_);
|
|
}
|
|
|
|
inline buffer::
|
|
buffer (const void* data, size_t size, size_t cap)
|
|
: data_ (0), size_ (0), capacity_ (0)
|
|
{
|
|
if (size > cap)
|
|
throw bounds ();
|
|
|
|
capacity (cap);
|
|
size_ = size;
|
|
|
|
if (size_)
|
|
std::memcpy (data_, data, size_);
|
|
}
|
|
|
|
inline buffer::
|
|
buffer (void* data, size_t size, size_t cap, bool own)
|
|
: data_ (0), size_ (0), capacity_ (0)
|
|
{
|
|
if (size > cap)
|
|
throw bounds ();
|
|
|
|
if (own)
|
|
{
|
|
data_ = reinterpret_cast<char*> (data);
|
|
size_ = size;
|
|
capacity_ = cap;
|
|
}
|
|
else
|
|
{
|
|
capacity (cap);
|
|
size_ = size;
|
|
|
|
if (size_)
|
|
std::memcpy (data_, data, size_);
|
|
}
|
|
}
|
|
|
|
inline buffer::
|
|
buffer (const buffer& other)
|
|
: data_ (0), size_ (0), capacity_ (0)
|
|
{
|
|
capacity (other.capacity_);
|
|
size_ = other.size_;
|
|
|
|
if (size_)
|
|
std::memcpy (data_, other.data_, size_);
|
|
}
|
|
|
|
inline buffer& buffer::
|
|
operator= (const buffer& other)
|
|
{
|
|
if (this != &other)
|
|
{
|
|
capacity (other.capacity_, false);
|
|
size_ = other.size_;
|
|
|
|
if (size_)
|
|
std::memcpy (data_, other.data_, size_);
|
|
}
|
|
|
|
return *this;
|
|
}
|
|
|
|
inline size_t buffer::
|
|
capacity () const
|
|
{
|
|
return capacity_;
|
|
}
|
|
|
|
inline bool buffer::
|
|
capacity (size_t cap)
|
|
{
|
|
return capacity (cap, true);
|
|
}
|
|
|
|
inline size_t buffer::
|
|
size () const
|
|
{
|
|
return size_;
|
|
}
|
|
|
|
inline bool buffer::
|
|
size (size_t size)
|
|
{
|
|
bool r (false);
|
|
|
|
if (size > capacity_)
|
|
r = capacity (size);
|
|
|
|
size_ = size;
|
|
|
|
return r;
|
|
}
|
|
|
|
inline const char* buffer::
|
|
data () const
|
|
{
|
|
return data_;
|
|
}
|
|
|
|
inline char* buffer::
|
|
data ()
|
|
{
|
|
return data_;
|
|
}
|
|
|
|
inline const char* buffer::
|
|
begin () const
|
|
{
|
|
return data_;
|
|
}
|
|
|
|
inline char* buffer::
|
|
begin ()
|
|
{
|
|
return data_;
|
|
}
|
|
|
|
inline const char* buffer::
|
|
end () const
|
|
{
|
|
return data_ + size_;
|
|
}
|
|
|
|
inline char* buffer::
|
|
end ()
|
|
{
|
|
return data_ + size_;
|
|
}
|
|
|
|
inline void buffer::
|
|
swap (buffer& other)
|
|
{
|
|
char* tmp_data (data_);
|
|
size_t tmp_size (size_);
|
|
size_t tmp_capacity (capacity_);
|
|
|
|
data_ = other.data_;
|
|
size_ = other.size_;
|
|
capacity_ = other.capacity_;
|
|
|
|
other.data_ = tmp_data;
|
|
other.size_ = tmp_size;
|
|
other.capacity_ = tmp_capacity;
|
|
}
|
|
|
|
inline bool buffer::
|
|
capacity (size_t capacity, bool copy)
|
|
{
|
|
if (size_ > capacity)
|
|
throw bounds ();
|
|
|
|
if (capacity <= capacity_)
|
|
{
|
|
return false; // Do nothing if shrinking is requested.
|
|
}
|
|
else
|
|
{
|
|
char* data (reinterpret_cast<char*> (operator new (capacity)));
|
|
|
|
if (copy && size_ > 0)
|
|
std::memcpy (data, data_, size_);
|
|
|
|
if (data_)
|
|
operator delete (data_);
|
|
|
|
data_ = data;
|
|
capacity_ = capacity;
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
inline bool
|
|
operator== (const buffer& a, const buffer& b)
|
|
{
|
|
return a.size () == b.size () &&
|
|
std::memcmp (a.data (), b.data (), a.size ()) == 0;
|
|
}
|
|
|
|
inline bool
|
|
operator!= (const buffer& a, const buffer& b)
|
|
{
|
|
return !(a == b);
|
|
}
|
|
|
|
// time_zone
|
|
//
|
|
inline time_zone::
|
|
time_zone ()
|
|
: present_ (false)
|
|
{
|
|
}
|
|
|
|
inline time_zone::
|
|
time_zone (short h, short m)
|
|
: present_ (true), hours_ (h), minutes_ (m)
|
|
{
|
|
}
|
|
|
|
inline bool time_zone::
|
|
zone_present () const
|
|
{
|
|
return present_;
|
|
}
|
|
|
|
inline void time_zone::
|
|
zone_reset ()
|
|
{
|
|
present_ = false;
|
|
}
|
|
|
|
inline short time_zone::
|
|
zone_hours () const
|
|
{
|
|
return hours_;
|
|
}
|
|
|
|
inline void time_zone::
|
|
zone_hours (short h)
|
|
{
|
|
hours_ = h;
|
|
present_ = true;
|
|
}
|
|
|
|
inline short time_zone::
|
|
zone_minutes () const
|
|
{
|
|
return minutes_;
|
|
}
|
|
|
|
inline void time_zone::
|
|
zone_minutes (short m)
|
|
{
|
|
minutes_ = m;
|
|
present_ = true;
|
|
}
|
|
|
|
inline bool
|
|
operator== (const time_zone& x, const time_zone& y)
|
|
{
|
|
return x.zone_present ()
|
|
? y.zone_present () &&
|
|
x.zone_hours () == y.zone_hours () &&
|
|
x.zone_minutes () == y.zone_minutes ()
|
|
: !y.zone_present ();
|
|
}
|
|
|
|
inline bool
|
|
operator!= (const time_zone& x, const time_zone& y)
|
|
{
|
|
return !(x == y);
|
|
}
|
|
|
|
// gday
|
|
//
|
|
inline gday::
|
|
gday (unsigned short day)
|
|
: day_ (day)
|
|
{
|
|
}
|
|
|
|
inline gday::
|
|
gday (unsigned short day, short zh, short zm)
|
|
: time_zone (zh, zm), day_ (day)
|
|
{
|
|
}
|
|
|
|
inline unsigned short gday::
|
|
day () const
|
|
{
|
|
return day_;
|
|
}
|
|
|
|
inline void gday::
|
|
day (unsigned short day)
|
|
{
|
|
day_ = day;
|
|
}
|
|
|
|
inline bool
|
|
operator== (const gday& a, const gday& b)
|
|
{
|
|
const time_zone& az = a;
|
|
const time_zone& bz = b;
|
|
|
|
return a.day () == b.day () && az == bz;
|
|
}
|
|
|
|
inline bool
|
|
operator!= (const gday& a, const gday& b)
|
|
{
|
|
return !(a == b);
|
|
}
|
|
|
|
// gmonth
|
|
//
|
|
inline gmonth::
|
|
gmonth (unsigned short month)
|
|
: month_ (month)
|
|
{
|
|
}
|
|
|
|
inline gmonth::
|
|
gmonth (unsigned short month, short zh, short zm)
|
|
: time_zone (zh, zm), month_ (month)
|
|
{
|
|
}
|
|
|
|
inline unsigned short gmonth::
|
|
month () const
|
|
{
|
|
return month_;
|
|
}
|
|
|
|
inline void gmonth::
|
|
month (unsigned short month)
|
|
{
|
|
month_ = month;
|
|
}
|
|
|
|
inline bool
|
|
operator== (const gmonth& a, const gmonth& b)
|
|
{
|
|
const time_zone& az = a;
|
|
const time_zone& bz = b;
|
|
|
|
return a.month () == b.month () && az == bz;
|
|
}
|
|
|
|
inline bool
|
|
operator!= (const gmonth& a, const gmonth& b)
|
|
{
|
|
return !(a == b);
|
|
}
|
|
|
|
// gyear
|
|
//
|
|
inline gyear::
|
|
gyear (int year)
|
|
: year_ (year)
|
|
{
|
|
}
|
|
|
|
inline gyear::
|
|
gyear (int year, short zh, short zm)
|
|
: time_zone (zh, zm), year_ (year)
|
|
{
|
|
}
|
|
|
|
inline int gyear::
|
|
year () const
|
|
{
|
|
return year_;
|
|
}
|
|
|
|
inline void gyear::
|
|
year (int year)
|
|
{
|
|
year_ = year;
|
|
}
|
|
|
|
inline bool
|
|
operator== (const gyear& a, const gyear& b)
|
|
{
|
|
const time_zone& az = a;
|
|
const time_zone& bz = b;
|
|
|
|
return a.year () == b.year () && az == bz;
|
|
}
|
|
|
|
inline bool
|
|
operator!= (const gyear& a, const gyear& b)
|
|
{
|
|
return !(a == b);
|
|
}
|
|
|
|
// gmonth_day
|
|
//
|
|
inline gmonth_day::
|
|
gmonth_day (unsigned short month, unsigned short day)
|
|
: month_ (month), day_ (day)
|
|
{
|
|
}
|
|
|
|
inline gmonth_day::
|
|
gmonth_day (unsigned short month,
|
|
unsigned short day,
|
|
short zh, short zm)
|
|
: time_zone (zh, zm), month_ (month), day_ (day)
|
|
{
|
|
}
|
|
|
|
inline unsigned short gmonth_day::
|
|
month () const
|
|
{
|
|
return month_;
|
|
}
|
|
|
|
inline void gmonth_day::
|
|
month (unsigned short month)
|
|
{
|
|
month_ = month;
|
|
}
|
|
|
|
inline unsigned short gmonth_day::
|
|
day () const
|
|
{
|
|
return day_;
|
|
}
|
|
|
|
inline void gmonth_day::
|
|
day (unsigned short day)
|
|
{
|
|
day_ = day;
|
|
}
|
|
|
|
inline bool
|
|
operator== (const gmonth_day& a, const gmonth_day& b)
|
|
{
|
|
const time_zone& az = a;
|
|
const time_zone& bz = b;
|
|
|
|
return a.month () == b.month () &&
|
|
a.day () == b.day () &&
|
|
az == bz;
|
|
}
|
|
|
|
inline bool
|
|
operator!= (const gmonth_day& a, const gmonth_day& b)
|
|
{
|
|
return !(a == b);
|
|
}
|
|
|
|
// gyear_month
|
|
//
|
|
inline gyear_month::
|
|
gyear_month (int year, unsigned short month)
|
|
: year_ (year), month_ (month)
|
|
{
|
|
}
|
|
|
|
inline gyear_month::
|
|
gyear_month (int year, unsigned short month,
|
|
short zh, short zm)
|
|
: time_zone (zh, zm), year_ (year), month_ (month)
|
|
{
|
|
}
|
|
|
|
inline int gyear_month::
|
|
year () const
|
|
{
|
|
return year_;
|
|
}
|
|
|
|
inline void gyear_month::
|
|
year (int year)
|
|
{
|
|
year_ = year;
|
|
}
|
|
|
|
inline unsigned short gyear_month::
|
|
month () const
|
|
{
|
|
return month_;
|
|
}
|
|
|
|
inline void gyear_month::
|
|
month (unsigned short month)
|
|
{
|
|
month_ = month;
|
|
}
|
|
|
|
inline bool
|
|
operator== (const gyear_month& a, const gyear_month& b)
|
|
{
|
|
const time_zone& az = a;
|
|
const time_zone& bz = b;
|
|
|
|
return a.year () == b.year () &&
|
|
a.month () == b.month () &&
|
|
az == bz;
|
|
}
|
|
|
|
inline bool
|
|
operator!= (const gyear_month& a, const gyear_month& b)
|
|
{
|
|
return !(a == b);
|
|
}
|
|
|
|
// date
|
|
//
|
|
inline date::
|
|
date (int year, unsigned short month, unsigned short day)
|
|
: year_ (year), month_ (month), day_ (day)
|
|
{
|
|
}
|
|
|
|
inline date::
|
|
date (int year, unsigned short month, unsigned short day,
|
|
short zh, short zm)
|
|
: time_zone (zh, zm), year_ (year), month_ (month), day_ (day)
|
|
{
|
|
}
|
|
|
|
inline int date::
|
|
year () const
|
|
{
|
|
return year_;
|
|
}
|
|
|
|
inline void date::
|
|
year (int year)
|
|
{
|
|
year_ = year;
|
|
}
|
|
|
|
inline unsigned short date::
|
|
month () const
|
|
{
|
|
return month_;
|
|
}
|
|
|
|
inline void date::
|
|
month (unsigned short month)
|
|
{
|
|
month_ = month;
|
|
}
|
|
|
|
inline unsigned short date::
|
|
day () const
|
|
{
|
|
return day_;
|
|
}
|
|
|
|
inline void date::
|
|
day (unsigned short day)
|
|
{
|
|
day_ = day;
|
|
}
|
|
|
|
inline bool
|
|
operator== (const date& a, const date& b)
|
|
{
|
|
const time_zone& az = a;
|
|
const time_zone& bz = b;
|
|
|
|
return a.year () == b.year () &&
|
|
a.month () == b.month () &&
|
|
a.day () == b.day () &&
|
|
az == bz;
|
|
}
|
|
|
|
inline bool
|
|
operator!= (const date& a, const date& b)
|
|
{
|
|
return !(a == b);
|
|
}
|
|
|
|
// time
|
|
//
|
|
inline time::
|
|
time (unsigned short hours, unsigned short minutes, double seconds)
|
|
: hours_ (hours), minutes_ (minutes), seconds_ (seconds)
|
|
{
|
|
}
|
|
|
|
inline time::
|
|
time (unsigned short hours, unsigned short minutes, double seconds,
|
|
short zh, short zm)
|
|
: time_zone (zh, zm),
|
|
hours_ (hours), minutes_ (minutes), seconds_ (seconds)
|
|
{
|
|
}
|
|
|
|
inline unsigned short time::
|
|
hours () const
|
|
{
|
|
return hours_;
|
|
}
|
|
|
|
inline void time::
|
|
hours (unsigned short hours)
|
|
{
|
|
hours_ = hours;
|
|
}
|
|
|
|
inline unsigned short time::
|
|
minutes () const
|
|
{
|
|
return minutes_;
|
|
}
|
|
|
|
inline void time::
|
|
minutes (unsigned short minutes)
|
|
{
|
|
minutes_ = minutes;
|
|
}
|
|
|
|
inline double time::
|
|
seconds () const
|
|
{
|
|
return seconds_;
|
|
}
|
|
|
|
inline void time::
|
|
seconds (double seconds)
|
|
{
|
|
seconds_ = seconds;
|
|
}
|
|
|
|
inline bool
|
|
operator== (const time& a, const time& b)
|
|
{
|
|
const time_zone& az = a;
|
|
const time_zone& bz = b;
|
|
|
|
return a.hours () == b.hours () &&
|
|
a.minutes () == b.minutes () &&
|
|
a.seconds () == b.seconds () &&
|
|
az == bz;
|
|
}
|
|
|
|
inline bool
|
|
operator!= (const time& a, const time& b)
|
|
{
|
|
return !(a == b);
|
|
}
|
|
|
|
// date_time
|
|
//
|
|
inline date_time::
|
|
date_time (int year, unsigned short month, unsigned short day,
|
|
unsigned short hours, unsigned short minutes, double seconds)
|
|
: year_ (year), month_ (month), day_ (day),
|
|
hours_ (hours), minutes_ (minutes), seconds_ (seconds)
|
|
{
|
|
}
|
|
|
|
inline date_time::
|
|
date_time (int year, unsigned short month, unsigned short day,
|
|
unsigned short hours, unsigned short minutes, double seconds,
|
|
short zh, short zm)
|
|
: time_zone (zh, zm),
|
|
year_ (year), month_ (month), day_ (day),
|
|
hours_ (hours), minutes_ (minutes), seconds_ (seconds)
|
|
{
|
|
}
|
|
|
|
inline int date_time::
|
|
year () const
|
|
{
|
|
return year_;
|
|
}
|
|
|
|
inline void date_time::
|
|
year (int year)
|
|
{
|
|
year_ = year;
|
|
}
|
|
|
|
inline unsigned short date_time::
|
|
month () const
|
|
{
|
|
return month_;
|
|
}
|
|
|
|
inline void date_time::
|
|
month (unsigned short month)
|
|
{
|
|
month_ = month;
|
|
}
|
|
|
|
inline unsigned short date_time::
|
|
day () const
|
|
{
|
|
return day_;
|
|
}
|
|
|
|
inline void date_time::
|
|
day (unsigned short day)
|
|
{
|
|
day_ = day;
|
|
}
|
|
|
|
inline unsigned short date_time::
|
|
hours () const
|
|
{
|
|
return hours_;
|
|
}
|
|
|
|
inline void date_time::
|
|
hours (unsigned short hours)
|
|
{
|
|
hours_ = hours;
|
|
}
|
|
|
|
inline unsigned short date_time::
|
|
minutes () const
|
|
{
|
|
return minutes_;
|
|
}
|
|
|
|
inline void date_time::
|
|
minutes (unsigned short minutes)
|
|
{
|
|
minutes_ = minutes;
|
|
}
|
|
|
|
inline double date_time::
|
|
seconds () const
|
|
{
|
|
return seconds_;
|
|
}
|
|
|
|
inline void date_time::
|
|
seconds (double seconds)
|
|
{
|
|
seconds_ = seconds;
|
|
}
|
|
|
|
inline bool
|
|
operator== (const date_time& a, const date_time& b)
|
|
{
|
|
const time_zone& az = a;
|
|
const time_zone& bz = b;
|
|
|
|
return a.year () == b.year () &&
|
|
a.month () == b.month () &&
|
|
a.day () == b.day () &&
|
|
a.hours () == b.hours () &&
|
|
a.minutes () == b.minutes () &&
|
|
a.seconds () == b.seconds () &&
|
|
az == bz;
|
|
}
|
|
|
|
inline bool
|
|
operator!= (const date_time& a, const date_time& b)
|
|
{
|
|
return !(a == b);
|
|
}
|
|
|
|
// duration
|
|
//
|
|
inline duration::
|
|
duration (bool negative,
|
|
unsigned int years, unsigned int months, unsigned int days,
|
|
unsigned int hours, unsigned int minutes, double seconds)
|
|
: negative_ (negative),
|
|
years_ (years), months_ (months), days_ (days),
|
|
hours_ (hours), minutes_ (minutes), seconds_ (seconds)
|
|
{
|
|
}
|
|
|
|
inline bool duration::
|
|
negative () const
|
|
{
|
|
return negative_;
|
|
}
|
|
|
|
inline void duration::
|
|
negative (bool negative)
|
|
{
|
|
negative_ = negative;
|
|
}
|
|
|
|
inline unsigned int duration::
|
|
years () const
|
|
{
|
|
return years_;
|
|
}
|
|
|
|
inline void duration::
|
|
years (unsigned int years)
|
|
{
|
|
years_ = years;
|
|
}
|
|
|
|
inline unsigned int duration::
|
|
months () const
|
|
{
|
|
return months_;
|
|
}
|
|
|
|
inline void duration::
|
|
months (unsigned int months)
|
|
{
|
|
months_ = months;
|
|
}
|
|
|
|
inline unsigned int duration::
|
|
days () const
|
|
{
|
|
return days_;
|
|
}
|
|
|
|
inline void duration::
|
|
days (unsigned int days)
|
|
{
|
|
days_ = days;
|
|
}
|
|
|
|
inline unsigned int duration::
|
|
hours () const
|
|
{
|
|
return hours_;
|
|
}
|
|
|
|
inline void duration::
|
|
hours (unsigned int hours)
|
|
{
|
|
hours_ = hours;
|
|
}
|
|
|
|
inline unsigned int duration::
|
|
minutes () const
|
|
{
|
|
return minutes_;
|
|
}
|
|
|
|
inline void duration::
|
|
minutes (unsigned int minutes)
|
|
{
|
|
minutes_ = minutes;
|
|
}
|
|
|
|
inline double duration::
|
|
seconds () const
|
|
{
|
|
return seconds_;
|
|
}
|
|
|
|
inline void duration::
|
|
seconds (double seconds)
|
|
{
|
|
seconds_ = seconds;
|
|
}
|
|
|
|
inline bool
|
|
operator== (const duration& a, const duration& b)
|
|
{
|
|
return a.negative () == b.negative () &&
|
|
a.years () == b.years () &&
|
|
a.months () == b.months () &&
|
|
a.days () == b.days () &&
|
|
a.hours () == b.hours () &&
|
|
a.minutes () == b.minutes () &&
|
|
a.seconds () == b.seconds ();
|
|
}
|
|
|
|
inline bool
|
|
operator!= (const duration& a, const duration& b)
|
|
{
|
|
return !(a == b);
|
|
}
|
|
}
|
|
}
|
|
}
|