#include "mainthread.h"
+#include "mspcore_api.h"
-extern "C" void ANativeActivity_onCreate(ANativeActivity *activity, void * /*saved_state*/, size_t /*state_size*/)
+extern "C" MSPCORE_API void ANativeActivity_onCreate(ANativeActivity *activity, void * /*saved_state*/, size_t /*state_size*/)
{
static Msp::Android::MainThread *thread = nullptr;
if(thread)
#include <stdexcept>
#include <string>
+#include "mspcore_api.h"
#include "noncopyable.h"
namespace Msp {
/**
Base class for applications. See also RegisteredApplication.
*/
-class Application: private NonCopyable
+class MSPCORE_API Application: private NonCopyable
{
protected:
- class Starter
+ class MSPCORE_API Starter
{
protected:
Starter();
#define ENVIRON_H_
#include <string>
+#include "mspcore_api.h"
namespace Msp {
-std::string getenv(const std::string &);
-void setenv(const std::string &, const std::string &);
-void unsetenv(const std::string &);
+MSPCORE_API std::string getenv(const std::string &);
+MSPCORE_API void setenv(const std::string &, const std::string &);
+MSPCORE_API void unsetenv(const std::string &);
} // namespace Msp
#define MSP_CORE_EXCEPT_H_
#include <stdexcept>
+#include "mspcore_api.h"
namespace Msp {
-class invalid_state: public std::logic_error
+class MSPCORE_API invalid_state: public std::logic_error
{
public:
invalid_state(const std::string &w): logic_error(w) { }
};
-class already_called: public invalid_state
+class MSPCORE_API already_called: public invalid_state
{
public:
already_called(const std::string &w): invalid_state(w) { }
};
-class unsupported: public std::logic_error
+class MSPCORE_API unsupported: public std::logic_error
{
public:
unsupported(const std::string &w): logic_error(w) { }
};
-class internal_error: public std::logic_error
+class MSPCORE_API internal_error: public std::logic_error
{
public:
internal_error(const std::string &w): logic_error(w) { }
#include <string>
#include <vector>
#include <msp/strings/lexicalcast.h>
+#include "mspcore_api.h"
#include "noncopyable.h"
namespace Msp {
-class usage_error: public std::runtime_error
+class MSPCORE_API usage_error: public std::runtime_error
{
private:
std::string m_help;
arguments and their associated help texts. An application may override this by
providing its own option with the same name.
*/
-class GetOpt: private NonCopyable
+class MSPCORE_API GetOpt: private NonCopyable
{
public:
enum ArgType
REQUIRED_ARG
};
- class Option
+ class MSPCORE_API Option
{
protected:
Option() = default;
virtual unsigned get_seen_count() const = 0;
};
- class Argument
+ class MSPCORE_API Argument
{
protected:
Argument() = default;
#include <stdexcept>
#include <typeinfo>
#include <msp/strings/lexicalcast.h>
+#include "mspcore_api.h"
namespace Msp {
} // namespace Internal
-class key_error: public std::runtime_error
+class MSPCORE_API key_error: public std::runtime_error
{
public:
template<typename T>
#define MSP_CORE_MODULE_H_
#include <string>
+#include "mspcore_api.h"
#include "noncopyable.h"
namespace Msp {
-class Module: private NonCopyable
+class MSPCORE_API Module: private NonCopyable
{
private:
struct Private;
--- /dev/null
+#ifndef MSP_CORE_API_H_
+#define MSP_CORE_API_H_
+
+#if defined(_WIN32)
+#if defined(MSPCORE_BUILD)
+#define MSPCORE_API __declspec(dllexport)
+#elif defined(MSPCORE_IMPORT)
+#define MSPCORE_API __declspec(dllimport)
+#else
+#define MSPCORE_API
+#endif
+#elif defined(__GNUC__)
+#define MSPCORE_API __attribute__((visibility("default")))
+#else
+#define MSPCORE_API
+#endif
+
+#endif
#ifndef MSP_CORE_MUTEX_H_
#define MSP_CORE_MUTEX_H_
+#include "mspcore_api.h"
#include "noncopyable.h"
#include "refptr.h"
A class for controlling mutually exclusive access to a resource. Only one
thread can hold a lock on the mutex at a time.
*/
-class Mutex: private NonCopyable
+class MSPCORE_API Mutex: private NonCopyable
{
friend class Semaphore;
/**
Locks the mutex for the lifetime of the object.
*/
-class MutexLock
+class MSPCORE_API MutexLock
{
private:
Mutex &mutex;
#ifndef MSP_CORE_NONCOPYABLE_H_
#define MSP_CORE_NONCOPYABLE_H_
+#include "mspcore_api.h"
+
namespace Msp {
-class NonCopyable
+class MSPCORE_API NonCopyable
{
protected:
NonCopyable() = default;
#include <cstring>
#include "application.h"
+#include "mspcore_api.h"
-int main(int argc, char **argv)
+MSPCORE_API int main(int argc, char **argv)
{
void *data = nullptr;
#include <vector>
#include <msp/fs/path.h>
#include <msp/io/base.h>
+#include "mspcore_api.h"
#include "noncopyable.h"
namespace Msp {
the self object take effect immediately. It is recommended to perform such
redirections directly on the Console objects.
*/
-class Process: private NonCopyable
+class MSPCORE_API Process: private NonCopyable
{
public:
typedef std::vector<std::string> Arguments;
#define MSP_CORE_SEMAPHORE_H_
#include <msp/time/timedelta.h>
+#include "mspcore_api.h"
#include "noncopyable.h"
namespace Msp {
-class Semaphore: private NonCopyable
+class MSPCORE_API Semaphore: private NonCopyable
{
private:
struct Private;
#include <stdexcept>
#include <string>
+#include "mspcore_api.h"
namespace Msp {
-class system_error: public std::runtime_error
+class MSPCORE_API system_error: public std::runtime_error
{
private:
int m_code;
#define MSP_CORE_THREAD_H_
#include <string>
+#include "mspcore_api.h"
#include "noncopyable.h"
namespace Msp {
This is to allow initializing variables of the derived class before the thread
is started.
*/
-class Thread: private NonCopyable
+class MSPCORE_API Thread: private NonCopyable
{
private:
struct Private;
#include "application.h"
+#include "mspcore_api.h"
-int main(int argc, char **argv)
+MSPCORE_API int main(int argc, char **argv)
{
return Msp::Application::run(argc, argv, nullptr);
}
#include <type_traits>
#include <typeinfo>
#include "meta.h"
+#include "mspcore_api.h"
namespace Msp {
-class type_mismatch: public std::runtime_error
+class MSPCORE_API type_mismatch: public std::runtime_error
{
public:
type_mismatch(const std::type_info &, const std::type_info &);
};
-class Variant
+class MSPCORE_API Variant
{
public:
static constexpr unsigned INTERNAL_SIZE = 2*sizeof(void *);
#include <msp/stringcodec/utf16.h>
#include <msp/stringcodec/utf8.h>
#include "application.h"
+#include "mspcore_api.h"
using namespace std;
using namespace Msp;
-int main(int argc, char **argv)
+MSPCORE_API int main(int argc, char **argv)
{
return Msp::Application::run(argc, argv);
}
#include <ostream>
#include <string>
#include <vector>
+#include <msp/core/mspcore_api.h>
namespace Msp {
namespace Debug {
-class Backtrace
+class MSPCORE_API Backtrace
{
public:
struct StackFrame
static Backtrace create();
};
-std::ostream &operator<<(std::ostream &, const Backtrace &);
-std::ostream &operator<<(std::ostream &, const Backtrace::StackFrame &);
+MSPCORE_API std::ostream &operator<<(std::ostream &, const Backtrace &);
+MSPCORE_API std::ostream &operator<<(std::ostream &, const Backtrace::StackFrame &);
} // namespace Debug
} // namespace Msp
#ifndef MSP_DEBUG_DEBUGAPI_H_
#define MSP_DEBUG_DEBUGAPI_H_
+#include <msp/core/mspcore_api.h>
+
namespace Msp {
namespace Debug {
UNKNOWN,
};
-DebuggerType check_debugger(bool = false);
-void debug_break();
+MSPCORE_API DebuggerType check_debugger(bool = false);
+MSPCORE_API void debug_break();
} // namespace Debug
} // namespace Msp
#define MSP_DEBUG_DEMANGLE_H_
#include <string>
+#include <msp/core/mspcore_api.h>
namespace Msp {
namespace Debug {
-std::string demangle(const std::string &);
+MSPCORE_API std::string demangle(const std::string &);
} // namespace Debug
} // namespace Msp
#define MSP_DEBUG_ERRORREPORTER_H_
#include <stdexcept>
+#include <msp/core/mspcore_api.h>
#include <msp/core/noncopyable.h>
namespace Msp {
namespace Debug {
-class ErrorReporter: private NonCopyable
+class MSPCORE_API ErrorReporter: private NonCopyable
{
private:
ErrorReporter *_prev = nullptr;
#ifndef MSP_DEBUG_EXCEPTIONTRACE_H_
#define MSP_DEBUG_EXCEPTIONTRACE_H_
+#include <msp/core/mspcore_api.h>
+
namespace Msp {
namespace Debug {
class Backtrace;
-void enable_exception_trace(bool);
-const Backtrace &get_exception_trace();
+MSPCORE_API void enable_exception_trace(bool);
+MSPCORE_API const Backtrace &get_exception_trace();
} // namespace Debug
} // namespace Msp
#include <map>
#include <string>
#include <vector>
+#include <msp/core/mspcore_api.h>
#include <msp/core/noncopyable.h>
#include <msp/time/timedelta.h>
#include <msp/time/timestamp.h>
Note: This is not thread-safe. To profile multiple threads, create a separate
Profiler for each thread.
*/
-class Profiler: private NonCopyable
+class MSPCORE_API Profiler: private NonCopyable
{
public:
- struct CallInfo
+ struct MSPCORE_API CallInfo
{
Msp::Time::TimeStamp entry_time;
Msp::Time::TimeDelta duration;
};
- struct ScopeInfo
+ struct MSPCORE_API ScopeInfo
{
Time::TimeStamp first_call;
unsigned calls = 0;
#ifndef MSP_DEBUG_PROFILINGSCOPE_H_
#define MSP_DEBUG_PROFILINGSCOPE_H_
+#include <msp/core/mspcore_api.h>
#include <msp/core/noncopyable.h>
#include <msp/time/timestamp.h>
#include "profiler.h"
created and ends when it goes out of scope. If there was another object in an
outer scope, it is notified of the time used in inner scopes.
*/
-class ProfilingScope: private NonCopyable
+class MSPCORE_API ProfilingScope: private NonCopyable
{
private:
Profiler &profiler;
#include <stdexcept>
#include <string>
#include <vector>
+#include <msp/core/mspcore_api.h>
#include "path.h"
namespace Msp {
namespace FS {
-class not_a_directory: public std::runtime_error
+class MSPCORE_API not_a_directory: public std::runtime_error
{
public:
not_a_directory(const Path &);
};
/// Creates a directory
-void mkdir(const Path &path, int mode);
+MSPCORE_API void mkdir(const Path &path, int mode);
/// Creates a directory and any required parent directories
-void mkpath(const Path &path, int mode);
+MSPCORE_API void mkpath(const Path &path, int mode);
/// Removes a directory, which must be empty
-void rmdir(const Path &path);
+MSPCORE_API void rmdir(const Path &path);
/// Removes a directory and anything it contains
-void rmpath(const Path &path);
+MSPCORE_API void rmpath(const Path &path);
/// Lists the contents of a directory
-std::vector<std::string> list_files(const Path &path);
+MSPCORE_API std::vector<std::string> list_files(const Path &path);
/// Lists the contents of a directory, filtered with a regex
-std::vector<std::string> list_filtered(const Path &path, const std::string &filter);
+MSPCORE_API std::vector<std::string> list_filtered(const Path &path, const std::string &filter);
/// Returns the current working directory
-Path getcwd();
+MSPCORE_API Path getcwd();
/// Changes the current working directory
-void chdir(const Path &);
+MSPCORE_API void chdir(const Path &);
/// Returns the user's home directory
-Path get_home_dir();
+MSPCORE_API Path get_home_dir();
/// Returns a directory suitable for storing user-specific data.
-Path get_user_data_dir();
+MSPCORE_API Path get_user_data_dir();
/// Returns a directory containing system-wide configuration.
-Path get_sys_conf_dir();
+MSPCORE_API Path get_sys_conf_dir();
/// Returns a directory containing immutable system-wide data.
-Path get_sys_data_dir();
+MSPCORE_API Path get_sys_data_dir();
/// Returns a directory containing system-wide architecture-specific files.
-Path get_sys_lib_dir();
+MSPCORE_API Path get_sys_lib_dir();
/** Looks for a file in a list of paths. Returns the absolute path to the
first existing location, or an empty Path if the file is not found at all. */
-Path path_lookup(const std::string &, const std::vector<Path> &);
+
MSPCORE_API Path path_lookup(const std::string &, const std::vector<Path> &);
/** Looks for a file using the PATH environment variable. */
-Path path_lookup(const std::string &);
+MSPCORE_API Path path_lookup(const std::string &);
} // namespace FS
} // namespace Msp
#ifndef FILEMONITOR_H_
#define FILEMONITOR_H_
+#include <msp/core/mspcore_api.h>
#include <msp/core/noncopyable.h>
#include <msp/fs/path.h>
#include <msp/io/eventdispatcher.h>
namespace Msp {
namespace FS {
-class FileMonitor: NonCopyable
+class MSPCORE_API FileMonitor: NonCopyable
{
private:
struct Private;
#include <ostream>
#include <string>
#include <vector>
+#include <msp/core/mspcore_api.h>
namespace Msp {
namespace FS {
iteration and slicing. In this context the root directory is treated as a
component of its own.
*/
-class Path
+class MSPCORE_API Path
{
private:
typedef std::vector<std::string::size_type> PositionArray;
public:
- class Iterator
+ class MSPCORE_API Iterator
{
public:
typedef PositionArray::difference_type difference_type;
#ifndef MSP_FS_REDIRECTEDPATH_H_
#define MSP_FS_REDIRECTEDPATH_H_
+#include <msp/core/mspcore_api.h>
#include "path.h"
namespace Msp {
due to an exception, it is unlinked instead. The primary use for this is to
atomically overwrite a file with a new version.
*/
-class RedirectedPath: public Path
+class MSPCORE_API RedirectedPath: public Path
{
private:
Path original;
#include <cstdint>
#include <string>
+#include <msp/core/mspcore_api.h>
#include <msp/time/timestamp.h>
#include "path.h"
/**
Holds file information.
*/
-class Stat
+class MSPCORE_API Stat
{
private:
struct Private;
{ return Stat::lstat(path); }
/// Tests for existence of a file
-bool exists(const Path &path);
+MSPCORE_API bool exists(const Path &path);
/// Tests whether a path refers to an existing regular file
inline bool is_reg(const Path &path)
#ifndef MSP_FS_UTILS_H_
#define MSP_FS_UTILS_H_
+#include <msp/core/mspcore_api.h>
#include "path.h"
namespace Msp {
namespace FS {
/// Extracts the last component of the path.
-std::string basename(const Path &);
+MSPCORE_API std::string basename(const Path &);
/// Removes the last component from the path.
-Path dirname(const Path &);
+MSPCORE_API Path dirname(const Path &);
/** Returns the base part of a filename. This includes everything up to the
last dot, but not the dot itself. */
-std::string basepart(const std::string &);
+MSPCORE_API std::string basepart(const std::string &);
/** Returns the extension part of a filename. This includes the last dot and
everything after it. */
-std::string extpart(const std::string &);
+MSPCORE_API std::string extpart(const std::string &);
/// Fixes the case of a path to match files / directories on the filesystem.
-Path fix_case(const Path &path);
+MSPCORE_API Path fix_case(const Path &path);
/// Reads the contents of a symbolic link
-Path readlink(const Path &path);
+MSPCORE_API Path readlink(const Path &path);
/// Resolves all symlinks from a path. Will always return an absolute path.
-Path realpath(const Path &path);
+MSPCORE_API Path realpath(const Path &path);
/// Removes a file
-void unlink(const Path &path);
+MSPCORE_API void unlink(const Path &path);
/// Renames a file. Existing file, if any, is overwritten.
-void rename(const Path &from, const Path &to);
+MSPCORE_API void rename(const Path &from, const Path &to);
/** Makes a path relative to some base path. That is, base/result==path. Both
paths must be either absolute or relative. */
-Path relative(const Path &path, const Path &base);
+MSPCORE_API Path relative(const Path &path, const Path &base);
/// Returns the longest prefix shared by both paths.
-Path common_ancestor(const Path &, const Path &);
+MSPCORE_API Path common_ancestor(const Path &, const Path &);
/** Determines how many levels a path is below another. Returns -1 if path is
not a descendant of parent. Both paths must be either absolute or relative. */
-int descendant_depth(const Path &path, const Path &parent);
+MSPCORE_API int descendant_depth(const Path &path, const Path &parent);
} // namespace FS
} // namespace Msp
#ifndef MSP_IO_ASSET_H_
#define MSP_IO_ASSET_H_
+#include <msp/core/mspcore_api.h>
#include "seekable.h"
namespace Msp {
contained within the APK. On other platfoms, assets are located in the
directory indicated by FS::get_sys_data_dir(). Assets are always read-only.
*/
-class Asset: public Seekable
+class MSPCORE_API Asset: public Seekable
{
private:
struct Private;
#include <cstddef>
#include <sigc++/sigc++.h>
+#include <msp/core/mspcore_api.h>
#include <msp/core/mutex.h>
#include <msp/core/noncopyable.h>
#include "handle.h"
/**
Common interface for all I/O objects.
*/
-class Base: private NonCopyable
+class MSPCORE_API Base: private NonCopyable
{
public:
/** RAII synchronization primitive. Prevents concurrent access to the
#define MSP_IO_BUFFERED_H_
#include <sigc++/trackable.h>
+#include <msp/core/mspcore_api.h>
#include "base.h"
namespace Msp {
namespace IO {
-class Buffered: public Base, public sigc::trackable
+class MSPCORE_API Buffered: public Base, public sigc::trackable
{
private:
Base &below;
#ifndef MSP_IO_CONSOLE_H_
#define MSP_IO_CONSOLE_H_
+#include <msp/core/mspcore_api.h>
#include "eventobject.h"
#include "handle.h"
be instantiated directly - use one of the cin, cout and cerr references
instead.
*/
-class Console: public EventObject
+class MSPCORE_API Console: public EventObject
{
public:
enum Stream
static Console &instance(Stream);
};
-extern Console &cin;
-extern Console &cout;
-extern Console &cerr;
+MSPCORE_API extern Console &cin;
+MSPCORE_API extern Console &cout;
+MSPCORE_API extern Console &cerr;
} // namespace IO
} // namespace Msp
#include <set>
#include <sigc++/trackable.h>
+#include <msp/core/mspcore_api.h>
#include <msp/time/timedelta.h>
#include <msp/time/timer.h>
#include "poll.h"
Put your I/O objects inside one of these to get signaled when something happens
on some of them.
*/
-class EventDispatcher
+class MSPCORE_API EventDispatcher
{
private:
struct Slot: public sigc::trackable
#ifndef MSP_IO_EVENTOBJECT_H_
#define MSP_IO_EVENTOBJECT_H_
+#include <msp/core/mspcore_api.h>
#include "base.h"
namespace Msp {
can be fed to the various poll functions in poll.h, or added to an
EventDispatcher to generate event signals.
*/
-class EventObject: public Base
+class MSPCORE_API EventObject: public Base
{
public:
/** Emitted when there is data available for reading. If all data is not
#include <stdexcept>
#include <string>
+#include <msp/core/mspcore_api.h>
#include "buffered.h"
#include "handle.h"
#include "seekable.h"
namespace Msp {
namespace IO {
-class file_not_found: public std::runtime_error
+class MSPCORE_API file_not_found: public std::runtime_error
{
public:
file_not_found(const std::string &fn): std::runtime_error(fn) { }
};
-class file_already_exists: public std::runtime_error
+class MSPCORE_API file_already_exists: public std::runtime_error
{
public:
file_already_exists(const std::string &fn): std::runtime_error(fn) { }
Non-blocking mode is not supported on Win32.
*/
-class File: public Seekable
+class MSPCORE_API File: public Seekable
{
public:
enum CreateMode
{ return File::CreateMode(~static_cast<int>(m)); }
-class BufferedFile: public Seekable
+class MSPCORE_API BufferedFile: public Seekable
{
private:
File file;
#define MSP_IO_HANDLE_H_
#include <cstddef>
+#include <msp/core/mspcore_api.h>
namespace Msp {
namespace IO {
-class Handle
+class MSPCORE_API Handle
{
public:
struct Private;
#ifndef MSP_IO_MEMORY_H_
#define MSP_IO_MEMORY_H_
+#include <msp/core/mspcore_api.h>
#include "seekable.h"
namespace Msp {
namespace IO {
-class Memory: public Seekable
+class MSPCORE_API Memory: public Seekable
{
private:
char *begin = nullptr;
#define MSP_IO_MODE_H_
#include <stdexcept>
+#include <msp/core/mspcore_api.h>
namespace Msp {
namespace IO {
{ m = b ? (m|f) : (m&~f); }
-class invalid_access: public std::logic_error
+class MSPCORE_API invalid_access: public std::logic_error
{
public:
invalid_access(Mode);
#ifndef MSP_IO_PIPE_H_
#define MSP_IO_PIPE_H_
+#include <msp/core/mspcore_api.h>
#include "eventobject.h"
#include "eventreader.h"
#include "handle.h"
namespace Msp {
namespace IO {
-class Pipe: public EventObject
+class MSPCORE_API Pipe: public EventObject
{
private:
Handle read_handle;
#include <map>
#include <vector>
+#include <msp/core/mspcore_api.h>
#include <msp/core/noncopyable.h>
#include <msp/time/timedelta.h>
{ return PollEvent(~static_cast<int>(e)); }
-class Poller: private NonCopyable
+class MSPCORE_API Poller: private NonCopyable
{
public:
struct PolledObject
const std::vector<PolledObject> &get_result() const { return poll_result; }
};
-PollEvent poll(EventObject &, PollEvent);
-PollEvent poll(EventObject &, PollEvent, const Time::TimeDelta &);
+MSPCORE_API PollEvent poll(EventObject &, PollEvent);
+MSPCORE_API PollEvent poll(EventObject &, PollEvent, const Time::TimeDelta &);
} // namespace IO
} // namespace Msp
#include <cstdint>
#include <stdexcept>
+#include <msp/core/mspcore_api.h>
#include "base.h"
namespace Msp {
};
-class bad_seek: public std::runtime_error
+class MSPCORE_API bad_seek: public std::runtime_error
{
public:
bad_seek(SeekOffset, SeekType);
};
-class Seekable: public Base
+class MSPCORE_API Seekable: public Base
{
protected:
Seekable() = default;
#ifndef MSP_IO_SERIAL_H_
#define MSP_IO_SERIAL_H_
+#include <msp/core/mspcore_api.h>
#include "eventobject.h"
#include "eventreader.h"
#include "handle.h"
namespace Msp {
namespace IO {
-class Serial: public EventObject
+class MSPCORE_API Serial: public EventObject
{
public:
enum Parity
#ifndef MSP_IO_SLICE_H_
#define MSP_IO_SLICE_H_
+#include <msp/core/mspcore_api.h>
#include "seekable.h"
namespace Msp {
restore it before the next access. This enables multiple Slices to be created
on top of the same object.
*/
-class Slice: public Seekable, public sigc::trackable
+class MSPCORE_API Slice: public Seekable, public sigc::trackable
{
private:
Seekable &below;
#define MSP_IO_UTILS_H_
#include <cstddef>
+#include <msp/core/mspcore_api.h>
namespace Msp {
namespace IO {
Note: If the data is not immediately available and the object is in non-blocking
mode, this function effectively becomes a busyloop until it can get more
data. */
-std::size_t read_all(Base &, char *, std::size_t);
+MSPCORE_API std::size_t read_all(Base &, char *, std::size_t);
} // namespace IO
} // namespace Msp
#include <stdexcept>
#include <string>
#include <sigc++/trackable.h>
+#include <msp/core/mspcore_api.h>
#include "base.h"
namespace Msp {
namespace IO {
-class zlib_error: public std::runtime_error
+class MSPCORE_API zlib_error: public std::runtime_error
{
private:
int m_code;
To ensure proper termination of the compressed data stream, the ZlibCompressed
object must be destroyed before the underlying object is closed.
*/
-class ZlibCompressed: public Base, public sigc::trackable
+class MSPCORE_API ZlibCompressed: public Base, public sigc::trackable
{
private:
struct Private;
#ifndef MSP_STRINGCODEC_ASCII_H_
#define MSP_STRINGCODEC_ASCII_H_
+#include <msp/core/mspcore_api.h>
#include "codec.h"
namespace Msp {
namespace StringCodec {
-class Ascii: public StandardCodec<Ascii>
+class
MSPCORE_API Ascii: public StandardCodec<Ascii>
{
public:
- class Encoder: public Codec::Encoder
+ class MSPCORE_API Encoder: public Codec::Encoder
{
public:
Encoder(ErrorMode em = DEFAULT): Codec::Encoder(em) { }
void transliterate(unichar, std::string &) override;
};
- class Decoder: public Codec::Decoder
+ class MSPCORE_API Decoder: public Codec::Decoder
{
public:
Decoder(ErrorMode em = DEFAULT): Codec::Decoder(em) { }
#define MSP_STRINGCODEC_CODEC_H_
#include <string>
+#include <msp/core/mspcore_api.h>
#include "except.h"
#include "ustring.h"
be an encoded sequence of bytes. A codec is able to determine if an encoded
string could be decoded with it.
*/
-class Codec
+class MSPCORE_API Codec
{
public:
/**
may find it useful or necessary to implement some other functions too
(particularly sync and reset for stateful codecs).
*/
- class Encoder
+ class MSPCORE_API Encoder
{
protected:
ErrorMode err_mode = THROW_ON_ERROR;
Each codec class should contain an Decoder class derived from this.
*/
- class Decoder
+ class MSPCORE_API Decoder
{
protected:
ErrorMode err_mode = THROW_ON_ERROR;
/** Creates a codec for an encoding by name. The caller is responsible for
deleting the codec when it's no longer needed. */
-Codec *create_codec(const std::string &);
+MSPCORE_API Codec *create_codec(const std::string &);
/** Automatically detects the encoding of a string and creates a codec for it.
The codec must be deleted when it's no longer needed. */
-Codec *detect_codec(const std::string &);
+MSPCORE_API Codec *detect_codec(const std::string &);
} // namespace StringCodec
} // namespace Msp
#ifndef MSP_STRINGCODEC_CODECUTILS_H_
#define MSP_STRINGCODEC_CODECUTILS_H_
+#include <msp/core/mspcore_api.h>
+
namespace Msp {
namespace StringCodec {
-int transform_mapping_or_direct(const int *mapping, unsigned map_size, int ch, bool reverse);
+MSPCORE_API int transform_mapping_or_direct(const int *mapping, unsigned map_size, int ch, bool reverse);
} // namespace StringCodec
} // namespace Msp
#define MSP_STRINGCODEC_EXCEPT_H_
#include <stdexcept>
+#include <msp/core/mspcore_api.h>
#include "ustring.h"
namespace Msp {
/**
Base class for codec errors.
*/
-class codec_error: public std::runtime_error
+class MSPCORE_API codec_error: public std::runtime_error
{
public:
codec_error(const std::string &w): std::runtime_error(w) { }
/**
Thrown when a codec can't encode the requested character.
*/
-class invalid_character: public codec_error
+class MSPCORE_API invalid_character: public codec_error
{
public:
invalid_character(unichar, const std::string &);
/**
Thrown when a codec encounters a byte sequence it can't decode.
*/
-class invalid_sequence: public codec_error
+class MSPCORE_API invalid_sequence: public codec_error
{
public:
invalid_sequence(const std::string::const_iterator &, const std::string::const_iterator &, const std::string &);
#ifndef MSP_STRINGCODEC_ISO2022JP_H_
#define MSP_STRINGCODEC_ISO2022JP_H_
+#include <msp/core/mspcore_api.h>
#include "codec.h"
namespace Msp {
namespace StringCodec {
-class Iso2022Jp: public StandardCodec<Iso2022Jp>
+class MSPCORE_API Iso2022Jp: public StandardCodec<Iso2022Jp>
{
public:
enum Mode
JISX0208
};
- class Encoder: public Codec::Encoder
+ class MSPCORE_API Encoder: public Codec::Encoder
{
private:
Mode mode = ASCII;
void transliterate(unichar, std::string &) override;
};
- class Decoder: public Codec::Decoder
+ class MSPCORE_API Decoder: public Codec::Decoder
{
private:
Mode mode = ASCII;
#ifndef MSP_STRINGCODEC_ISO646FI_H_
#define MSP_STRINGCODEC_ISO646FI_H_
+#include <msp/core/mspcore_api.h>
#include "codec.h"
namespace Msp {
namespace StringCodec {
-class Iso646Fi: public StandardCodec<Iso646Fi>
+class MSPCORE_API Iso646Fi: public StandardCodec<Iso646Fi>
{
public:
- class Encoder: public Codec::Encoder
+ class MSPCORE_API Encoder: public Codec::Encoder
{
public:
Encoder(ErrorMode em = DEFAULT): Codec::Encoder(em) { }
void transliterate(unichar, std::string &) override;
};
- class Decoder: public Codec::Decoder
+ class MSPCORE_API Decoder: public Codec::Decoder
{
public:
Decoder(ErrorMode em = DEFAULT): Codec::Decoder(em) { }
#ifndef MSP_STRINGCODEC_ISO88591_H_
#define MSP_STRINGCODEC_ISO88591_H_
+#include <msp/core/mspcore_api.h>
#include "codec.h"
namespace Msp {
namespace StringCodec {
-class Iso88591: public StandardCodec<Iso88591>
+class MSPCORE_API Iso88591: public StandardCodec<Iso88591>
{
public:
- class Encoder: public Codec::Encoder
+ class MSPCORE_API Encoder: public Codec::Encoder
{
public:
Encoder(ErrorMode em = DEFAULT): Codec::Encoder(em) { }
void transliterate(unichar, std::string &) override;
};
- class Decoder: public Codec::Decoder
+ class MSPCORE_API Decoder: public Codec::Decoder
{
public:
Decoder(ErrorMode em = DEFAULT): Codec::Decoder(em) { }
#ifndef MSP_STRINGCODEC_ISO885915_H_
#define MSP_STRINGCODEC_ISO885915_H_
+#include <msp/core/mspcore_api.h>
#include "codec.h"
namespace Msp {
namespace StringCodec {
-class Iso885915: public StandardCodec<Iso885915>
+class MSPCORE_API Iso885915: public StandardCodec<Iso885915>
{
public:
- class Encoder: public Codec::Encoder
+ class MSPCORE_API Encoder: public Codec::Encoder
{
public:
Encoder(ErrorMode em = DEFAULT): Codec::Encoder(em) { }
void transliterate(unichar, std::string &) override;
};
- class Decoder: public Codec::Decoder
+ class MSPCORE_API Decoder: public Codec::Decoder
{
public:
Decoder(ErrorMode em = DEFAULT): Codec::Decoder(em) { }
#ifndef MSP_STRINGCODEC_JISX201_H_
#define MSP_STRINGCODEC_JISX201_H_
+#include <msp/core/mspcore_api.h>
#include "codec.h"
namespace Msp {
namespace StringCodec {
-class JisX0201: public StandardCodec<JisX0201>
+class MSPCORE_API JisX0201: public StandardCodec<JisX0201>
{
public:
- class Encoder: public Codec::Encoder
+ class MSPCORE_API Encoder: public Codec::Encoder
{
public:
Encoder(ErrorMode em = DEFAULT): Codec::Encoder(em) { }
void transliterate(unichar, std::string &) override;
};
- class Decoder: public Codec::Decoder
+ class MSPCORE_API Decoder: public Codec::Decoder
{
public:
Decoder(ErrorMode em = DEFAULT): Codec::Decoder(em) { }
#ifndef MSP_STRINGCODEC_JISX0208_H_
#define MSP_STRINGCODEC_JISX0208_H_
+#include <msp/core/mspcore_api.h>
#include "codec.h"
namespace Msp {
stand-alone codec, due to lack of a linefeed character among other things,
but is included as part of some other encodings.
*/
-class JisX0208: public StandardCodec<JisX0208>
+class MSPCORE_API JisX0208: public StandardCodec<JisX0208>
{
public:
- class Encoder: public Codec::Encoder
+ class MSPCORE_API Encoder: public Codec::Encoder
{
public:
Encoder(ErrorMode em = DEFAULT): Codec::Encoder(em) { }
void transliterate(unichar, std::string &) override;
};
- class Decoder: public Codec::Decoder
+ class MSPCORE_API Decoder: public Codec::Decoder
{
public:
Decoder(ErrorMode em = DEFAULT): Codec::Decoder(em) { }
explicit operator bool() { return ku!=0 && ten!=0; }
};
-unichar jisx0208_to_ucs(Kuten);
-Kuten ucs_to_jisx0208(unichar);
+MSPCORE_API unichar jisx0208_to_ucs(Kuten);
+MSPCORE_API Kuten ucs_to_jisx0208(unichar);
} // namespace StringCodec
} // namespace Msp
#ifndef MSP_STRINGCODEC_UTF16_H_
#define MSP_STRINGCODEC_UTF16_H_
+#include <msp/core/mspcore_api.h>
#include "codec.h"
namespace Msp {
endian are supported, as well as autodetection with the BOM. In the absence
of a BOM, big endian is assumed.
*/
-class Utf16: public StandardCodec<Utf16>
+class MSPCORE_API Utf16: public StandardCodec<Utf16>
{
public:
enum Endian
LITTLE
};
- class Encoder: public Codec::Encoder
+ class MSPCORE_API Encoder: public Codec::Encoder
{
private:
Endian endian = BIG;
void transliterate(unichar, std::string &) override;
};
- class Decoder: public Codec::Decoder
+ class MSPCORE_API Decoder: public Codec::Decoder
{
private:
Endian endian = AUTO;
#ifndef MSP_STRINGCODEC_UTF8_H_
#define MSP_STRINGCODEC_UTF8_H_
+#include <msp/core/mspcore_api.h>
#include "codec.h"
namespace Msp {
namespace StringCodec {
-class Utf8: public StandardCodec<Utf8>
+class MSPCORE_API Utf8: public StandardCodec<Utf8>
{
public:
- class Encoder: public Codec::Encoder
+ class MSPCORE_API Encoder: public Codec::Encoder
{
public:
Encoder(ErrorMode em = DEFAULT): Codec::Encoder(em) { }
void transliterate(unichar, std::string &) override;
};
- class Decoder: public Codec::Decoder
+ class MSPCORE_API Decoder: public Codec::Decoder
{
public:
Decoder(ErrorMode em = DEFAULT): Codec::Decoder(em) { }
#ifndef MSP_STRINGCODEC_WINDOWS1252_H_
#define MSP_STRINGCODEC_WINDOWS1252_H_
+#include <msp/core/mspcore_api.h>
#include "codec.h"
namespace Msp {
namespace StringCodec {
-class Windows1252: public StandardCodec<Windows1252>
+class MSPCORE_API Windows1252: public StandardCodec<Windows1252>
{
public:
- class Encoder: public Codec::Encoder
+ class MSPCORE_API Encoder: public Codec::Encoder
{
public:
Encoder(ErrorMode em = DEFAULT): Codec::Encoder(em) { }
void transliterate(unichar, std::string &) override;
};
- class Decoder: public Codec::Decoder
+ class MSPCORE_API Decoder: public Codec::Decoder
{
public:
Decoder(ErrorMode em = DEFAULT): Codec::Decoder(em) { }
#include <ostream>
#include <stdexcept>
#include <string>
+#include <msp/core/mspcore_api.h>
namespace Msp {
-class format_error: public std::logic_error
+class MSPCORE_API format_error: public std::logic_error
{
public:
format_error(const std::string &w): std::logic_error(w) { }
b/B Binary integer conversion
P Uppercase pointer conversion (like %#X)
*/
-class Fmt
+class MSPCORE_API Fmt
{
public:
enum Type
#define MSP_STRINGS_FORMAT_H_
#include <string>
+#include <msp/core/mspcore_api.h>
#include "lexicalcast.h"
namespace Msp {
/**
Printf-like string formatter class.
*/
-class Formatter
+class MSPCORE_API Formatter
{
private:
std::string fmt;
#define MSP_STRINGS_GLOB_H_
#include <string>
+#include <msp/core/mspcore_api.h>
namespace Msp {
-bool globmatch(const std::string &, const std::string &);
-bool globcasematch(const std::string &, const std::string &);
+MSPCORE_API bool globmatch(const std::string &, const std::string &);
+MSPCORE_API bool globcasematch(const std::string &, const std::string &);
} // namespace Msp
#include <string>
#include <stdexcept>
#include <msp/core/meta.h>
+#include <msp/core/mspcore_api.h>
#include "fmt.h"
namespace Msp {
/**
Thrown for errors in lexical conversions.
*/
-class lexical_error: public std::runtime_error
+class MSPCORE_API lexical_error: public std::runtime_error
{
public:
lexical_error(const std::string &w): runtime_error(w) { }
/**
Thrown when the format is unsuitable for the type being converted.
*/
-class format_mismatch: public lexical_error
+class MSPCORE_API format_mismatch: public lexical_error
{
public:
format_mismatch(const std::string &w): lexical_error(w) { }
/**
Helper class for lexical_cast to facilitate operator overloading.
*/
-class LexicalConverter
+class MSPCORE_API LexicalConverter
{
private:
Fmt fmt;
};
-void operator<<(LexicalConverter &, char);
-void operator<<(LexicalConverter &, signed char);
-void operator<<(LexicalConverter &, short);
-void operator<<(LexicalConverter &, int);
-void operator<<(LexicalConverter &, long);
-void operator<<(LexicalConverter &, unsigned char);
-void operator<<(LexicalConverter &, unsigned short);
-void operator<<(LexicalConverter &, unsigned);
-void operator<<(LexicalConverter &, unsigned long);
-void operator<<(LexicalConverter &, long long);
-void operator<<(LexicalConverter &, unsigned long long);
-void operator<<(LexicalConverter &, bool);
-void operator<<(LexicalConverter &, float);
-void operator<<(LexicalConverter &, double);
-void operator<<(LexicalConverter &, long double);
-void operator<<(LexicalConverter &, const std::string &);
-void operator<<(LexicalConverter &, const char *);
-void operator<<(LexicalConverter &, const void *);
-
-void operator>>(const LexicalConverter &, char &);
-void operator>>(const LexicalConverter &, signed char &);
-void operator>>(const LexicalConverter &, short &);
-void operator>>(const LexicalConverter &, int &);
-void operator>>(const LexicalConverter &, long &);
-void operator>>(const LexicalConverter &, unsigned char &);
-void operator>>(const LexicalConverter &, unsigned short &);
-void operator>>(const LexicalConverter &, unsigned int &);
-void operator>>(const LexicalConverter &, unsigned long &);
-void operator>>(const LexicalConverter &, long long &);
-void operator>>(const LexicalConverter &, unsigned long long &);
-void operator>>(const LexicalConverter &, bool &);
-void operator>>(const LexicalConverter &, float &);
-void operator>>(const LexicalConverter &, double &);
-void operator>>(const LexicalConverter &, long double &);
-void operator>>(const LexicalConverter &, std::string &);
+MSPCORE_API void operator<<(LexicalConverter &, char);
+MSPCORE_API void operator<<(LexicalConverter &, signed char);
+MSPCORE_API void operator<<(LexicalConverter &, short);
+MSPCORE_API void operator<<(LexicalConverter &, int);
+MSPCORE_API void operator<<(LexicalConverter &, long);
+MSPCORE_API void operator<<(LexicalConverter &, unsigned char);
+MSPCORE_API void operator<<(LexicalConverter &, unsigned short);
+MSPCORE_API void operator<<(LexicalConverter &, unsigned);
+MSPCORE_API void operator<<(LexicalConverter &, unsigned long);
+MSPCORE_API void operator<<(LexicalConverter &, long long);
+MSPCORE_API void operator<<(LexicalConverter &, unsigned long long);
+MSPCORE_API void operator<<(LexicalConverter &, bool);
+MSPCORE_API void operator<<(LexicalConverter &, float);
+MSPCORE_API void operator<<(LexicalConverter &, double);
+MSPCORE_API void operator<<(LexicalConverter &, long double);
+MSPCORE_API void operator<<(LexicalConverter &, const std::string &);
+MSPCORE_API void operator<<(LexicalConverter &, const char *);
+MSPCORE_API void operator<<(LexicalConverter &, const void *);
+
+MSPCORE_API void operator>>(const LexicalConverter &, char &);
+MSPCORE_API void operator>>(const LexicalConverter &, signed char &);
+MSPCORE_API void operator>>(const LexicalConverter &, short &);
+MSPCORE_API void operator>>(const LexicalConverter &, int &);
+MSPCORE_API void operator>>(const LexicalConverter &, long &);
+MSPCORE_API void operator>>(const LexicalConverter &, unsigned char &);
+MSPCORE_API void operator>>(const LexicalConverter &, unsigned short &);
+MSPCORE_API void operator>>(const LexicalConverter &, unsigned int &);
+MSPCORE_API void operator>>(const LexicalConverter &, unsigned long &);
+MSPCORE_API void operator>>(const LexicalConverter &, long long &);
+MSPCORE_API void operator>>(const LexicalConverter &, unsigned long long &);
+MSPCORE_API void operator>>(const LexicalConverter &, bool &);
+MSPCORE_API void operator>>(const LexicalConverter &, float &);
+MSPCORE_API void operator>>(const LexicalConverter &, double &);
+MSPCORE_API void operator>>(const LexicalConverter &, long double &);
+MSPCORE_API void operator>>(const LexicalConverter &, std::string &);
// Generic operators using stringstream
#include <stdexcept>
#include <string>
+#include <msp/core/mspcore_api.h>
#include "regmatch.h"
namespace Msp {
-class bad_regex: public std::logic_error
+class MSPCORE_API bad_regex: public std::logic_error
{
public:
bad_regex(const std::string &, const std::string &, const std::string::const_iterator &);
The MATCH_ANY instruction consumes the input character and always succeeds.
*/
-class Regex
+class MSPCORE_API Regex
{
private:
typedef std::basic_string<unsigned char> Code;
#include <string>
#include <vector>
+#include <msp/core/mspcore_api.h>
namespace Msp {
matched by subregexes. These are ordered from left to right, by the opening
parenthesis of the subregex.
*/
-class RegMatch
+class MSPCORE_API RegMatch
{
public:
/**
#include <string>
#include <vector>
+#include <msp/core/mspcore_api.h>
namespace Msp {
than, equal to or greater than zero depending on whether the first string
lexicographically precedes, is equal to or follows the second one,
respectively. */
-int strcasecmp(const std::string &s1, const std::string &s2);
+MSPCORE_API int strcasecmp(const std::string &s1, const std::string &s2);
/** Converts a string to lower case. */
-std::string tolower(const std::string &);
+MSPCORE_API std::string tolower(const std::string &);
/** Converts a string to upper case. */
-std::string toupper(const std::string &);
+MSPCORE_API std::string toupper(const std::string &);
/** Checks whether a string consists of digits only. */
-bool isnumrc(const std::string &);
+MSPCORE_API bool isnumrc(const std::string &);
/** Checks whether a string consists of alphabetic characters only. */
-bool isalpha(const std::string &);
+MSPCORE_API bool isalpha(const std::string &);
/** Checks whether a string consists of alphanumeric characters only. */
-bool isalnum(const std::string &);
+MSPCORE_API bool isalnum(const std::string &);
/* These are required to make the standard version work from inside the Msp
namespace */
If max_split is non-negative, at most that many split will be performed, i.e.
the resulting vector will contain at most max_split+1 elements. */
-std::vector<std::string> split(const std::string &str, const std::string &sep = " \t\r\n", int max_split = -1);
+MSPCORE_API std::vector<std::string> split(const std::string &str, const std::string &sep = " \t\r\n", int max_split = -1);
/** Splits a string on occurrences of a single character. */
-std::vector<std::string> split(const std::string &str, char sep, int max_split = -1);
+MSPCORE_API std::vector<std::string> split(const std::string &str, char sep, int max_split = -1);
/** Splits a string on occurrences of another string. */
-std::vector<std::string> split_long(const std::string &str, const std::string &sep, int max_split = -1);
+MSPCORE_API std::vector<std::string> split_long(const std::string &str, const std::string &sep, int max_split = -1);
/** Splits a string on occurrences of another string. Two consecutive
separators will cause an empty string to be placed in the result. */
-std::vector<std::string> split_fields(const std::string &str, const std::string &sep, int max_split = -1);
+MSPCORE_API std::vector<std::string> split_fields(const std::string &str, const std::string &sep, int max_split = -1);
/** Splits a string on occurrences of a single character. Two consecutive
separators will cause an empty string to be placed in the result. */
-std::vector<std::string> split_fields(const std::string &str, char sep, int max_split = -1);
+MSPCORE_API std::vector<std::string> split_fields(const std::string &str, char sep, int max_split = -1);
/** Appends a string to another, using a separator if both are non-empty. */
-std::string &append(std::string &str, const std::string &sep, const std::string &other);
+MSPCORE_API std::string &append(std::string &str, const std::string &sep, const std::string &other);
/** Joins two strings, using a separator if both are non-empty. */
-std::string join(const std::string &str1, const std::string &sep, const std::string &str2);
+MSPCORE_API std::string join(const std::string &str1, const std::string &sep, const std::string &str2);
/** Concatenates strings from an iterator range. */
template<typename Iter>
}
/** Strips leading and trailing whitespace from a string. */
-std::string strip(const std::string &);
+MSPCORE_API std::string strip(const std::string &);
/** Unescapes a string with C escape sequences. */
-std::string c_unescape(const std::string &str);
+MSPCORE_API std::string c_unescape(const std::string &str);
/** Escapes any non-printable characters in a string with C escape sequences.
Optionally, any characters with the high bit set can be escaped as well. */
-std::string c_escape(const std::string &str, bool escape_8bit = true);
+MSPCORE_API std::string c_escape(const std::string &str, bool escape_8bit = true);
} // namespace Msp
#define MSP_TIME_DATETIME_H_
#include <string>
+#include <msp/core/mspcore_api.h>
#include "timezone.h"
#include "rawtime.h"
are relatively slow. For purposes of internal scheduling in a program, a
TimeStamp is a better choice.
*/
-class DateTime
+class MSPCORE_API DateTime
{
private:
int year = 1970;
#include <cstdlib>
#include <ctime>
+#include <msp/core/mspcore_api.h>
#include <msp/strings/lexicalcast.h>
#include "rawtime.h"
/**
Represents a quantity of time, such as five seconds.
*/
-class TimeDelta
+class MSPCORE_API TimeDelta
{
private:
RawTime usec = 0;
template<typename T>
inline TimeDelta operator*(T a, const TimeDelta &t) { return t*a; }
-void operator<<(LexicalConverter &, const TimeDelta &);
+MSPCORE_API void operator<<(LexicalConverter &, const TimeDelta &);
// Constants to be used in creation of TimeDeltas
-extern const TimeDelta zero;
-extern const TimeDelta usec;
-extern const TimeDelta msec;
-extern const TimeDelta sec;
-extern const TimeDelta min;
-extern const TimeDelta hour;
-extern const TimeDelta day;
-extern const TimeDelta week;
+MSPCORE_API extern const TimeDelta zero;
+MSPCORE_API extern const TimeDelta usec;
+MSPCORE_API extern const TimeDelta msec;
+MSPCORE_API extern const TimeDelta sec;
+MSPCORE_API extern const TimeDelta min;
+MSPCORE_API extern const TimeDelta hour;
+MSPCORE_API extern const TimeDelta day;
+MSPCORE_API extern const TimeDelta week;
inline TimeDelta abs(const TimeDelta &t) { return t>=zero ? t : -t; }
using std::abs;
#include <vector>
#include <sigc++/sigc++.h>
+#include <msp/core/mspcore_api.h>
#include <msp/core/mutex.h>
#include <msp/core/noncopyable.h>
#include <msp/core/semaphore.h>
This class is thread-safe, to allow running timers in a separate thread.
*/
-class Timer: private NonCopyable
+class MSPCORE_API Timer: private NonCopyable
{
public:
class Slot
#ifndef MSP_TIME_TIMESTAMP_H_
#define MSP_TIME_TIMESTAMP_H_
+#include <msp/core/mspcore_api.h>
#include "timedelta.h"
#include "rawtime.h"
For representing user-specified times, use the DateTime class.
*/
-class TimeStamp
+class MSPCORE_API TimeStamp
{
private:
RawTime usec = 0;
#ifndef MSP_TIME_TIMEZONE_H_
#define MSP_TIME_TIMEZONE_H_
+#include <msp/core/mspcore_api.h>
#include "timedelta.h"
namespace Msp {
namespace Time {
-class TimeZone
+class MSPCORE_API TimeZone
{
private:
std::string name;
#define MSP_TIME_UTILS_H_
#include <string>
+#include <msp/core/mspcore_api.h>
namespace Msp {
namespace Time {
class TimeStamp;
/** Returns the current timestamp. */
-TimeStamp now();
+MSPCORE_API TimeStamp now();
-std::string format_now(const std::string &);
+MSPCORE_API std::string format_now(const std::string &);
/** Returns the CPU time used by the program so far. */
-TimeDelta get_cpu_time();
+MSPCORE_API TimeDelta get_cpu_time();
/** Sleeps for the given duration. */
-void sleep(const TimeDelta &);
+MSPCORE_API void sleep(const TimeDelta &);
} // namespace Time
} // namespace Msp
projects / libs / core.git / commitdiff