MainThread::MainThread(ANativeActivity *a):
asset_manager(a->assetManager),
- int_data_path(a->internalDataPath),
- starting_up(true)
+ int_data_path(a->internalDataPath)
{
attach_to_activity(a);
startup_mutex.lock();
sigc::signal<void, AInputQueue *> signal_input_queue_destroyed;
private:
- ANativeActivity *activity;
- AAssetManager *asset_manager;
+ ANativeActivity *activity = 0;
+ AAssetManager *asset_manager = 0;
FS::Path int_data_path;
- bool starting_up;
+ bool starting_up = true;
Mutex startup_mutex;
public:
string Application::name_;
void *Application::data_ = 0;
-Application::Application(const string &n):
- exit_code(0)
+Application::Application(const string &n)
{
if(app_)
throw logic_error("instance already exists");
virtual Application *create_app(int, char **) = 0;
};
- bool done;
- int exit_code;
+ bool done = false;
+ int exit_code = 0;
private:
static Starter *starter_;
namespace Msp {
-GetOpt::GetOpt():
- help(false)
+GetOpt::GetOpt()
{
add_option("help", help, NO_ARG).set_help("Displays this help");
}
shrt(s),
lng(l),
arg_type(a),
- seen_count(0),
- ext_seen_count(0),
- metavar("ARG"),
store(t.clone())
{ }
class OptionImpl: public Option
{
protected:
- char shrt;
+ char shrt = 0;
std::string lng;
- ArgType arg_type;
- unsigned seen_count;
- unsigned *ext_seen_count;
+ ArgType arg_type = NO_ARG;
+ unsigned seen_count = 0;
+ unsigned *ext_seen_count = 0;
std::string help;
- std::string metavar;
- Store *store;
+ std::string metavar = "ARG";
+ Store *store = 0;
public:
OptionImpl(char, const std::string &, const Store &, ArgType);
{
private:
std::string name;
- ArgType type;
+ ArgType type = REQUIRED_ARG;
std::string help;
- Store *store;
+ Store *store = 0;
public:
ArgumentImpl(const std::string &, const Store &, ArgType);
{ data.push_back(lexical_cast<typename T::value_type>(a)); }
};
- bool help;
+ bool help = false;
std::vector<OptionImpl *> opts;
std::vector<ArgumentImpl *> args;
std::vector<std::string> args_raw;
private:
struct Private;
- Private *priv;
+ Private *priv = 0;
public:
Module(const std::string &);
private:
struct Private;
- Private *priv;
+ Private *priv = 0;
public:
Mutex();
Process::Process(const Private &p):
priv(new Private(p))
-{
- init();
-}
+{ }
Process::Process():
priv(new Private)
-{
- init();
-}
-
-void Process::init()
-{
- redirect = false;
- cin = 0;
- cout = 0;
- cerr = 0;
- running = false;
- finished = false;
- exit_code = 0;
-}
+{ }
Process &Process::self()
{
private:
struct Private;
- Private *priv;
+ Private *priv = 0;
FS::Path work_dir;
- bool redirect;
- IO::Base *cin;
- IO::Base *cout;
- IO::Base *cerr;
- bool running;
- bool finished;
- unsigned exit_code;
+ bool redirect = false;
+ IO::Base *cin = 0;
+ IO::Base *cout = 0;
+ IO::Base *cerr = 0;
+ bool running = false;
+ bool finished = false;
+ unsigned exit_code = 0;
static Process *_self;
Process(const Private &);
- void init();
public:
Process();
~Process();
template<typename U> friend class WeakPtr;
private:
- T *data;
- RefCounts *counts;
+ T *data = 0;
+ RefCounts *counts = 0;
public:
- RefPtr(): data(0), counts(0) { }
+ RefPtr() { }
RefPtr(T *d): data(d), counts(data ? new RefCounts : 0) { incref(); }
private:
RefPtr(T *d, RefCounts *c): data(d), counts(d ? c : 0) { incref(); }
template<typename U> friend class WeakPtr;
private:
- T *data;
- RefCounts *counts;
+ T *data = 0;
+ RefCounts *counts = 0;
public:
- WeakPtr(): data(0), counts(0) { }
+ WeakPtr() { }
private:
WeakPtr(T *d, RefCounts *c): data(d), counts(d ? c : 0) { incref(); }
private:
struct Private;
- Private *priv;
+ Private *priv = 0;
public:
Semaphore(unsigned);
Thread::Thread(const string &name):
priv_(new Private),
- name_(name),
- state_(PENDING)
+ name_(name)
{ }
Thread::~Thread()
JOINED
};
- Private *priv_;
+ Private *priv_ = 0;
std::string name_;
- State state_;
+ State state_ = PENDING;
protected:
Thread(const std::string & = std::string());
{
Mutex mutex;
pthread_cond_t cond;
- unsigned limit;
- unsigned count;
+ unsigned limit = 1;
+ unsigned count = 0;
};
{
pthread_cond_init(&priv->cond, 0);
priv->limit = limit;
- priv->count = 0;
}
Semaphore::~Semaphore()
{ return false; }
};
- StoreBase *store;
+ StoreBase *store = 0;
public:
- Variant(): store(0) { }
+ Variant() { }
template<typename T>
Variant(const T &v): store(new Store<typename std::remove_cv<T>::type>(v)) { }
Variant(const Variant &v): store(v.store ? v.store->clone() : 0) { }
public:
struct StackFrame
{
- void *address;
+ void *address = 0;
std::string file;
std::string symbol;
};
class ErrorReporter: private NonCopyable
{
private:
- ErrorReporter *prev;
+ ErrorReporter *prev = 0;
static ErrorReporter *current;
namespace Msp {
namespace Debug {
-Profiler::Profiler():
- period(0),
- inner(0)
-{ }
-
void Profiler::set_period(unsigned p)
{
if(p==period)
return get_item(scopes, sn);
}
-
-Profiler::ScopeInfo::ScopeInfo():
- calls(0),
- calls_per_sec(0),
- hist_pos(0),
- hist_full(false)
-{ }
-
} // namespace Debug
} // namespace Msp
struct ScopeInfo
{
Time::TimeStamp first_call;
- unsigned calls;
+ unsigned calls = 0;
Time::TimeDelta total_time;
Time::TimeDelta self_time;
Time::TimeDelta avg_time;
- float calls_per_sec;
+ float calls_per_sec = 0;
std::vector<CallInfo> history;
- unsigned hist_pos;
- bool hist_full;
+ unsigned hist_pos = 0;
+ bool hist_full = false;
std::map<std::string, unsigned> called_from;
-
- ScopeInfo();
};
private:
- unsigned period;
+ unsigned period = 0;
std::map<std::string, ScopeInfo> scopes;
- ProfilingScope *inner;
+ ProfilingScope *inner = 0;
public:
- Profiler();
-
/** Sets the averaging period for timing data, measured in calls. Previous
average timings are cleared. */
void set_period(unsigned p);
private:
Profiler &profiler;
std::string name;
- ProfilingScope *parent;
+ ProfilingScope *parent = 0;
Time::TimeStamp entry_time;
Time::TimeDelta time_spent;
Time::TimeDelta child_time;
namespace FS {
FileMonitor::FileMonitor():
- priv(new Private(*this)),
- event_disp(0)
+ priv(new Private(*this))
{ }
FileMonitor::~FileMonitor()
{
MonitoredFile file;
file.path = path;
- file.modified = false;
prepare_file(file);
files.push_back(file);
}
struct MonitoredFile
{
FS::Path path;
- bool modified;
- int tag;
+ bool modified = false;
+ int tag = -1;
};
public:
sigc::signal<void, const FS::Path &> signal_file_modified;
private:
- Private *priv;
- IO::EventDispatcher *event_disp;
+ Private *priv = 0;
+ IO::EventDispatcher *event_disp = 0;
std::vector<MonitoredFile> files;
public:
{ }
Path::Path(const string &p)
-{
- init(p);
-}
-
-Path::Path(const char *p)
-{
- init(p);
-}
-
-void Path::init(const string &p)
{
if(p.empty())
return;
public:
Path();
Path(const std::string &);
- Path(const char *);
-private:
- void init(const std::string &);
+ Path(const char *p): Path(std::string(p)) { }
-public:
/// Returns the path as a string.
const std::string &str() const { return path; }
namespace Msp {
namespace FS {
-Stat::Private::Private():
- owner_id(0),
- group_id(0)
-{ }
-
-
-Stat::Stat():
- exists(false),
- type(UNKNOWN),
- size(0),
- alloc_size(0),
- priv(0)
-{ }
-
Stat::Stat(const Stat &other):
exists(other.exists),
type(other.type),
std::string group;
};
- bool exists;
- FileType type;
- FileSize size;
- FileSize alloc_size;
+ bool exists = false;
+ FileType type = UNKNOWN;
+ FileSize size = 0;
+ FileSize alloc_size = 0;
Time::TimeStamp mtime;
mutable OwnerInfo owner_info;
- Private *priv;
+ Private *priv = 0;
public:
- Stat();
+ Stat() { }
Stat(const Stat &);
Stat &operator=(const Stat &);
~Stat();
private:
struct Private;
- Private *priv;
+ Private *priv = 0;
public:
Asset(const std::string &);
namespace Msp {
namespace IO {
-Base::Base():
- mode(M_READ),
- eof_flag(false),
- mutex(0)
+Base::Base()
{ }
Base::~Base()
sigc::signal<void> signal_deleted;
protected:
- Mode mode;
- bool eof_flag;
- Mutex *mutex;
+ Mode mode = M_READ;
+ bool eof_flag = false;
+ Mutex *mutex = 0;
Base();
public:
buf_size(s),
buf(new char[buf_size]),
begin(buf),
- end(buf),
- cur_op(M_NONE)
+ end(buf)
{
mode = below.get_mode();
below.signal_flush_required.connect(sigc::mem_fun(this, &Buffered::flush));
{
private:
Base &below;
- std::size_t buf_size;
- char *buf;
- char *begin;
- char *end;
- Mode cur_op;
+ std::size_t buf_size = 0;
+ char *buf = 0;
+ char *begin = 0;
+ char *end = 0;
+ Mode cur_op = M_NONE;
public:
Buffered(Base &, unsigned = 8192);
namespace Msp {
namespace IO {
-EventObject::EventObject():
- events(P_NONE)
+EventObject::EventObject()
{ }
EventObject::~EventObject()
sigc::signal<void, PollEvent> signal_events_changed;
private:
- PollEvent events;
+ PollEvent events = P_NONE;
protected:
EventObject();
struct Private;
Handle &handle;
- Private *priv;
+ Private *priv = 0;
public:
EventReader(Handle &, unsigned);
struct Private;
private:
- Private *priv;
+ Private *priv = 0;
public:
Handle();
namespace Msp {
namespace IO {
-Memory::Memory(char *d, size_t s, Mode m)
-{
- init(d, d+s, m);
-}
-
Memory::Memory(char *b, char *e, Mode m)
-{
- init(b, e, m);
-}
-
-Memory::Memory(const char *cd, size_t s)
-{
- char *d = const_cast<char *>(cd);
- init(d, d+s, M_READ);
-}
-
-Memory::Memory(const char *b, const char *e)
-{
- init(const_cast<char *>(b), const_cast<char *>(e), M_READ);
-}
-
-void Memory::init(char *b, char *e, Mode m)
{
begin = b;
end = e;
class Memory: public Seekable
{
private:
- char *begin;
- char *end;
- char *pos;
+ char *begin = 0;
+ char *end = 0;
+ char *pos = 0;
public:
- Memory(char *, std::size_t, Mode = M_RDWR);
+ Memory(char *d, std::size_t s, Mode m = M_RDWR): Memory(d, d+s, m) { }
Memory(char *, char *, Mode = M_RDWR);
- Memory(const char *, std::size_t);
- Memory(const char *, const char *);
-private:
- void init(char *, char *, Mode);
+ Memory(const char *d, std::size_t s): Memory(const_cast<char *>(d), const_cast<char *>(d+s), M_READ) { }
+ Memory(const char *b, const char *e): Memory(const_cast<char *>(b), const_cast<char *>(e), M_READ) { }
-public:
virtual void set_block(bool);
virtual void set_inherit(bool);
namespace IO {
Poller::Poller():
- priv(new Private),
- events_changed(false),
- objs_changed(false)
+ priv(new Private)
{ }
Poller::~Poller()
public:
struct PolledObject
{
- EventObject *object;
- PollEvent events;
+ EventObject *object = 0;
+ PollEvent events = P_NONE;
PolledObject(EventObject *o, PollEvent e): object(o), events(e) { }
};
struct Private;
std::vector<PolledObject> objects;
- Private *priv;
- bool events_changed;
- bool objs_changed;
+ Private *priv = 0;
+ bool events_changed = false;
+ bool objs_changed = false;
std::vector<PolledObject> poll_result;
public:
Slice::Slice(Seekable &b, SeekOffset s, SeekOffset l):
below(b),
start_offset(s),
- length(l),
- position(0),
- sync_position(true)
+ length(l)
{
if(s<0 || l<0)
throw invalid_argument("Slice");
{
private:
Seekable &below;
- SeekOffset start_offset;
- SeekOffset length;
- SeekOffset position;
- bool sync_position;
+ SeekOffset start_offset = 0;
+ SeekOffset length = 0;
+ SeekOffset position = 0;
+ bool sync_position = true;
public:
Slice(Seekable &, SeekOffset, SeekOffset);
namespace IO {
EventReader::EventReader(Handle &h, unsigned):
- handle(h),
- priv(0)
+ handle(h)
{ }
EventReader::~EventReader()
{
OVERLAPPED overlapped;
Handle event;
- unsigned buf_size;
- char *buffer;
- unsigned buf_avail;
- char *buf_next;
- bool pending;
- bool eof;
+ unsigned buf_size = 0;
+ char *buffer = 0;
+ unsigned buf_avail = 0;
+ char *buf_next = 0;
+ bool pending = false;
+ bool eof = false;
};
priv->overlapped.hEvent = *priv->event;
priv->buf_size = size;
priv->buffer = new char[priv->buf_size];
- priv->buf_avail = 0;
priv->buf_next = priv->buffer;
- priv->pending = false;
- priv->eof = false;
}
EventReader::~EventReader()
}
-ZlibCompressed::ZlibCompressed(Base &b, unsigned level):
- below(b)
-{
- mode = below.get_mode()&M_RDWR;
- if(mode!=M_READ && mode!=M_WRITE)
- throw invalid_access(mode);
-
- init(level);
-}
-
ZlibCompressed::ZlibCompressed(Base &b, Mode m, unsigned level):
below(b)
{
if(mode!=M_READ && mode!=M_WRITE)
throw invalid_access(m);
- init(level);
-}
-
-void ZlibCompressed::init(unsigned level)
-{
#ifdef WITH_ZLIB
- buffer_size = 1024;
- in_buffer = 0;
- out_buffer = 0;
- stream_end = false;
priv = new Private;
if(mode==M_WRITE)
struct Private;
Base &below;
- std::size_t buffer_size;
- unsigned char *in_buffer;
- unsigned char *out_buffer;
- bool stream_end;
- Private *priv;
+ std::size_t buffer_size = 1024;
+ unsigned char *in_buffer = 0;
+ unsigned char *out_buffer = 0;
+ bool stream_end = false;
+ Private *priv = 0;
public:
/** Creates a zlib de/compression object. The underlying object must be
open for reading or writing, not both. The level parameter determines
compression quality, ranging from 1 (fastest) to 9 (best compression). */
- ZlibCompressed(Base &, unsigned level = 9);
+ ZlibCompressed(Base &b, unsigned level = 9): ZlibCompressed(b, b.get_mode()&M_RDWR, level) { }
/** Creates a zlib de/compression object. Mode must be either read or
write, and compatible with the underlying object. */
ZlibCompressed(Base &, Mode, unsigned level = 9);
-private:
- void init(unsigned);
-
-public:
virtual ~ZlibCompressed();
virtual void set_block(bool);
class Encoder
{
protected:
- ErrorMode err_mode;
+ ErrorMode err_mode = THROW_ON_ERROR;
Encoder(ErrorMode em): err_mode(em==DEFAULT ? THROW_ON_ERROR : em) { }
public:
class Decoder
{
protected:
- ErrorMode err_mode;
+ ErrorMode err_mode = THROW_ON_ERROR;
Decoder(ErrorMode em): err_mode(em==DEFAULT ? THROW_ON_ERROR : em) { }
public:
class StandardCodec: public Codec
{
private:
- ErrorMode err_mode;
+ ErrorMode err_mode = THROW_ON_ERROR;
protected:
StandardCodec(ErrorMode em): err_mode(em==DEFAULT ? THROW_ON_ERROR : em) { }
Iso2022Jp::Decoder::Decoder(ErrorMode em):
Codec::Decoder(em),
- mode(ASCII),
dec(new Ascii::Decoder)
{ }
class Encoder: public Codec::Encoder
{
private:
- Mode mode;
+ Mode mode = ASCII;
public:
- Encoder(ErrorMode em = DEFAULT): Codec::Encoder(em), mode(ASCII) { }
+ Encoder(ErrorMode em = DEFAULT): Codec::Encoder(em) { }
virtual void encode_char(unichar, std::string &);
virtual void sync(std::string &);
class Decoder: public Codec::Decoder
{
private:
- Mode mode;
- Codec::Decoder *dec;
+ Mode mode = ASCII;
+ Codec::Decoder *dec = 0;
public:
Decoder(ErrorMode = DEFAULT);
struct Kuten
{
- unsigned short ku;
- unsigned short ten;
-
- Kuten(): ku(0), ten(0) { }
+ unsigned short ku = 0;
+ unsigned short ten = 0;
operator bool() { return ku!=0 && ten!=0; }
};
Utf16::Encoder::Encoder(ErrorMode em, Endian en):
Codec::Encoder(em),
- endian(en==AUTO ? BIG : en),
- emit_bom(true)
+ endian(en==AUTO ? BIG : en)
{ }
void Utf16::Encoder::encode_char(unichar ch, string &buf)
class Encoder: public Codec::Encoder
{
private:
- Endian endian;
- bool emit_bom;
+ Endian endian = BIG;
+ bool emit_bom = true;
public:
Encoder(ErrorMode em = DEFAULT, Endian en = BIG);
class Decoder: public Codec::Decoder
{
private:
- Endian endian;
+ Endian endian = AUTO;
public:
Decoder(ErrorMode em = DEFAULT, Endian en = AUTO);
};
private:
- Endian endian;
+ Endian endian = AUTO;
public:
Utf16(ErrorMode em = DEFAULT, Endian en = AUTO):
Fmt &Fmt::reset()
{
- wd = 0;
- prec = 6;
- spos = false;
- fillc = ' ';
- base = DEC;
- sbase = false;
- fmode = AUTOFLT;
- spoint = false;
- align = RIGHT;
- ucase = false;
- type = STR;
-
- return *this;
+ return *this = Fmt();
}
void Fmt::apply(ostream &out) const
};
private:
- unsigned wd;
- unsigned prec;
- bool spos;
- wchar_t fillc;
- Base base;
- bool sbase;
- FloatMode fmode;
- bool spoint;
- Align align;
- bool ucase;
- Type type;
+ unsigned wd = 0;
+ unsigned prec = 6;
+ bool spos = false;
+ wchar_t fillc = ' ';
+ Base base = DEC;
+ bool sbase = false;
+ FloatMode fmode = AUTOFLT;
+ bool spoint = false;
+ Align align = RIGHT;
+ bool ucase = false;
+ Type type = STR;
public:
- Fmt() { reset(); }
- Fmt(const char *f) { reset(); parse(f); }
- Fmt(const std::string &f) { reset(); parse(f.c_str()); }
+ Fmt() = default;
+ Fmt(const char *f) { parse(f); }
+ Fmt(const std::string &f) { parse(f.c_str()); }
private:
void parse(const char *);
{
private:
Fmt fmt;
- bool filled;
+ bool filled = false;
std::string buf;
public:
- LexicalConverter(const Fmt &f): fmt(f), filled(false) { }
+ LexicalConverter(const Fmt &f): fmt(f) { }
LexicalConverter(const std::string &s, const Fmt &f): fmt(f), filled(true), buf(s) { }
const Fmt &get_fmt() const { return fmt; }
Regex::Regex(const string &expr)
{
- n_groups = 0;
auto iter = expr.begin();
code = compile(expr, iter, n_groups, false);
++n_groups;
};
Code code;
- unsigned n_groups;
+ unsigned n_groups = 0;
public:
/** Constructs a new Regex object from a string representation. */
{
typedef std::string::size_type size_type;
- bool match; //< Whether or not this group matched
- size_type begin; //< First offset of the match
- size_type end; //< One-past-last offset
- size_type length; //< Length of the match (end-begin)
- std::string str; //< The part of the string that matched
+ bool match = false; //< Whether or not this group matched
+ size_type begin; //< First offset of the match
+ size_type end; //< One-past-last offset
+ size_type length; //< Length of the match (end-begin)
+ std::string str; //< The part of the string that matched
- Group(): match(false) { }
operator bool() const { return match; }
};
DateTime::DateTime(const TimeStamp &ts)
{
- init(ts);
+ add_raw(ts.raw());
}
-DateTime::DateTime(const TimeStamp &ts, const TimeZone &tz)
+DateTime::DateTime(const TimeStamp &ts, const TimeZone &tz):
+ DateTime(ts)
{
- init(ts);
convert_timezone(tz);
}
-DateTime::DateTime(int y, unsigned char m, unsigned char d)
-{
- init(y, m, d, 0, 0, 0, 0);
-}
-
-DateTime::DateTime(int y, unsigned char m, unsigned char d, unsigned char h, unsigned char n, unsigned char s)
+DateTime::DateTime(int y, unsigned char m, unsigned char d):
+ DateTime(y, m, d, 0, 0, 0, 0)
+{ }
+
+DateTime::DateTime(int y, unsigned char m, unsigned char d, unsigned char h, unsigned char n, unsigned char s):
+ DateTime(y, m, d, h, n, s, 0)
+{ }
+
+DateTime::DateTime(int y, unsigned char m, unsigned char d, unsigned char h, unsigned char n, unsigned char s, unsigned u):
+ year(y),
+ month(m),
+ mday(d),
+ hour(h),
+ minute(n),
+ second(s),
+ usec(u)
{
- init(y, m, d, h, n, s, 0);
-}
-
-DateTime::DateTime(int y, unsigned char m, unsigned char d, unsigned char h, unsigned char n, unsigned char s, unsigned u)
-{
- init(y, m, d, h, n, s, u);
-}
-
-void DateTime::init(const TimeStamp &ts)
-{
- year = 1970;
- month = 1;
- mday = 1;
- hour = 0;
- minute = 0;
- second = 0;
- usec = 0;
- add_raw(ts.raw());
-}
-
-void DateTime::init(int y, unsigned char m, unsigned char d, unsigned char h, unsigned char n, unsigned char s, unsigned u)
-{
- year = y;
- month = m;
- mday = d;
- hour = h;
- minute = n;
- second = s;
- usec = u;
-
if(usec>=1000000)
throw out_of_range("DateTime::DateTime usec");
if(second>=60)
class DateTime
{
private:
- int year;
- unsigned char month;
- unsigned char mday;
- unsigned char hour;
- unsigned char minute;
- unsigned char second;
- unsigned usec;
+ int year = 1970;
+ unsigned char month = 1;
+ unsigned char mday = 1;
+ unsigned char hour = 0;
+ unsigned char minute = 0;
+ unsigned char second = 0;
+ unsigned usec = 0;
TimeZone zone;
public:
DateTime(int, unsigned char, unsigned char);
DateTime(int, unsigned char, unsigned char, unsigned char, unsigned char, unsigned char);
DateTime(int, unsigned char, unsigned char, unsigned char, unsigned char, unsigned char, unsigned);
-private:
- void init(const TimeStamp &);
- void init(int, unsigned char, unsigned char, unsigned char, unsigned char, unsigned char, unsigned);
-public:
static DateTime parse_rfc3339(const std::string &);
int get_year() const { return year; }
class TimeDelta
{
private:
- RawTime usec;
+ RawTime usec = 0;
public:
/** Constructs a zero TimeDelta. */
- TimeDelta(): usec(0) { }
+ TimeDelta() { }
/** Constructs a TimeDelta from a plain number. The purpose of this is to
allow serialization together with the raw() function. */
namespace Time {
Timer::Timer():
- sem(1),
- blocking(false)
+ sem(1)
{ }
Timer::~Timer()
private:
struct SlotProxy
{
- Slot *slot;
+ Slot *slot = 0;
SlotProxy(Slot *);
bool operator<(const SlotProxy &) const;
std::vector<SlotProxy> slots;
Semaphore sem;
Mutex mutex;
- bool blocking;
+ bool blocking = false;
public:
Timer();
class TimeStamp
{
private:
- RawTime usec;
+ RawTime usec = 0;
public:
/** Construct a TimeStamp that represents an arbitarily distant point in the
past. It's guaranteed to be less than any valid timestamp. */
- TimeStamp(): usec(0) { }
+ TimeStamp() { }
/** Constructs a TimeStamp from a plain number. The purpose of this is to allow
serialization together with the raw() function. */
projects / libs / core.git / commitdiff