SCRUG-NA/2025
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Install SeisComP and scanloc ARM64 nightly packages

Browse Source
This commit is contained in:
Enrico Ellguth
2025-10-29 12:34:04 +00:00
parent 2ff097f9d1
commit 165b829fb7
606 changed files with 24438 additions and 16358 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
include/fmt/args.h
View File

@ -1,4 +1,4 @@
// Formatting library for C++ - dynamic format arguments
// Formatting library for C++ - dynamic argument lists
//
// Copyright (c) 2012 - present, Victor Zverovich
// All rights reserved.
@ -22,8 +22,9 @@ template <typename T> struct is_reference_wrapper : std::false_type {};
template <typename T>
struct is_reference_wrapper<std::reference_wrapper<T>> : std::true_type {};
template <typename T> const T& unwrap(const T& v) { return v; }
template <typename T> const T& unwrap(const std::reference_wrapper<T>& v) {
template <typename T> auto unwrap(const T& v) -> const T& { return v; }
template <typename T>
auto unwrap(const std::reference_wrapper<T>& v) -> const T& {
return static_cast<const T&>(v);
}
@ -50,7 +51,7 @@ class dynamic_arg_list {
std::unique_ptr<node<>> head_;
public:
template <typename T, typename Arg> const T& push(const Arg& arg) {
template <typename T, typename Arg> auto push(const Arg& arg) -> const T& {
auto new_node = std::unique_ptr<typed_node<T>>(new typed_node<T>(arg));
auto& value = new_node->value;
new_node->next = std::move(head_);
@ -110,14 +111,14 @@ class dynamic_format_arg_store
friend class basic_format_args<Context>;
unsigned long long get_types() const {
auto get_types() const -> unsigned long long {
return detail::is_unpacked_bit | data_.size() |
(named_info_.empty()
? 0ULL
: static_cast<unsigned long long>(detail::has_named_args_bit));
}
const basic_format_arg<Context>* data() const {
auto data() const -> const basic_format_arg<Context>* {
return named_info_.empty() ? data_.data() : data_.data() + 1;
}

1003
include/fmt/chrono.h
View File

File diff suppressed because it is too large Load Diff

132
include/fmt/color.h
View File

@ -11,7 +11,7 @@
#include "format.h"
FMT_BEGIN_NAMESPACE
FMT_MODULE_EXPORT_BEGIN
FMT_BEGIN_EXPORT
enum class color : uint32_t {
alice_blue = 0xF0F8FF, // rgb(240,248,255)
@ -203,7 +203,7 @@ struct rgb {
uint8_t b;
};
FMT_BEGIN_DETAIL_NAMESPACE
namespace detail {
// color is a struct of either a rgb color or a terminal color.
struct color_type {
@ -225,8 +225,7 @@ struct color_type {
uint32_t rgb_color;
} value;
};
FMT_END_DETAIL_NAMESPACE
} // namespace detail
/** A text style consisting of foreground and background colors and emphasis. */
class text_style {
@ -234,7 +233,7 @@ class text_style {
FMT_CONSTEXPR text_style(emphasis em = emphasis()) noexcept
: set_foreground_color(), set_background_color(), ems(em) {}
FMT_CONSTEXPR text_style& operator|=(const text_style& rhs) {
FMT_CONSTEXPR auto operator|=(const text_style& rhs) -> text_style& {
if (!set_foreground_color) {
set_foreground_color = rhs.set_foreground_color;
foreground_color = rhs.foreground_color;
@ -258,29 +257,29 @@ class text_style {
return *this;
}
friend FMT_CONSTEXPR text_style operator|(text_style lhs,
const text_style& rhs) {
friend FMT_CONSTEXPR auto operator|(text_style lhs, const text_style& rhs)
-> text_style {
return lhs |= rhs;
}
FMT_CONSTEXPR bool has_foreground() const noexcept {
FMT_CONSTEXPR auto has_foreground() const noexcept -> bool {
return set_foreground_color;
}
FMT_CONSTEXPR bool has_background() const noexcept {
FMT_CONSTEXPR auto has_background() const noexcept -> bool {
return set_background_color;
}
FMT_CONSTEXPR bool has_emphasis() const noexcept {
FMT_CONSTEXPR auto has_emphasis() const noexcept -> bool {
return static_cast<uint8_t>(ems) != 0;
}
FMT_CONSTEXPR detail::color_type get_foreground() const noexcept {
FMT_CONSTEXPR auto get_foreground() const noexcept -> detail::color_type {
FMT_ASSERT(has_foreground(), "no foreground specified for this style");
return foreground_color;
}
FMT_CONSTEXPR detail::color_type get_background() const noexcept {
FMT_CONSTEXPR auto get_background() const noexcept -> detail::color_type {
FMT_ASSERT(has_background(), "no background specified for this style");
return background_color;
}
FMT_CONSTEXPR emphasis get_emphasis() const noexcept {
FMT_CONSTEXPR auto get_emphasis() const noexcept -> emphasis {
FMT_ASSERT(has_emphasis(), "no emphasis specified for this style");
return ems;
}
@ -298,9 +297,11 @@ class text_style {
}
}
friend FMT_CONSTEXPR text_style fg(detail::color_type foreground) noexcept;
friend FMT_CONSTEXPR auto fg(detail::color_type foreground) noexcept
-> text_style;
friend FMT_CONSTEXPR text_style bg(detail::color_type background) noexcept;
friend FMT_CONSTEXPR auto bg(detail::color_type background) noexcept
-> text_style;
detail::color_type foreground_color;
detail::color_type background_color;
@ -310,20 +311,23 @@ class text_style {
};
/** Creates a text style from the foreground (text) color. */
FMT_CONSTEXPR inline text_style fg(detail::color_type foreground) noexcept {
FMT_CONSTEXPR inline auto fg(detail::color_type foreground) noexcept
-> text_style {
return text_style(true, foreground);
}
/** Creates a text style from the background color. */
FMT_CONSTEXPR inline text_style bg(detail::color_type background) noexcept {
FMT_CONSTEXPR inline auto bg(detail::color_type background) noexcept
-> text_style {
return text_style(false, background);
}
FMT_CONSTEXPR inline text_style operator|(emphasis lhs, emphasis rhs) noexcept {
FMT_CONSTEXPR inline auto operator|(emphasis lhs, emphasis rhs) noexcept
-> text_style {
return text_style(lhs) | rhs;
}
FMT_BEGIN_DETAIL_NAMESPACE
namespace detail {
template <typename Char> struct ansi_color_escape {
FMT_CONSTEXPR ansi_color_escape(detail::color_type text_color,
@ -385,8 +389,8 @@ template <typename Char> struct ansi_color_escape {
}
FMT_CONSTEXPR operator const Char*() const noexcept { return buffer; }
FMT_CONSTEXPR const Char* begin() const noexcept { return buffer; }
FMT_CONSTEXPR_CHAR_TRAITS const Char* end() const noexcept {
FMT_CONSTEXPR auto begin() const noexcept -> const Char* { return buffer; }
FMT_CONSTEXPR_CHAR_TRAITS auto end() const noexcept -> const Char* {
return buffer + std::char_traits<Char>::length(buffer);
}
@ -401,56 +405,39 @@ template <typename Char> struct ansi_color_escape {
out[2] = static_cast<Char>('0' + c % 10);
out[3] = static_cast<Char>(delimiter);
}
static FMT_CONSTEXPR bool has_emphasis(emphasis em, emphasis mask) noexcept {
static FMT_CONSTEXPR auto has_emphasis(emphasis em, emphasis mask) noexcept
-> bool {
return static_cast<uint8_t>(em) & static_cast<uint8_t>(mask);
}
};
template <typename Char>
FMT_CONSTEXPR ansi_color_escape<Char> make_foreground_color(
detail::color_type foreground) noexcept {
FMT_CONSTEXPR auto make_foreground_color(detail::color_type foreground) noexcept
-> ansi_color_escape<Char> {
return ansi_color_escape<Char>(foreground, "\x1b[38;2;");
}
template <typename Char>
FMT_CONSTEXPR ansi_color_escape<Char> make_background_color(
detail::color_type background) noexcept {
FMT_CONSTEXPR auto make_background_color(detail::color_type background) noexcept
-> ansi_color_escape<Char> {
return ansi_color_escape<Char>(background, "\x1b[48;2;");
}
template <typename Char>
FMT_CONSTEXPR ansi_color_escape<Char> make_emphasis(emphasis em) noexcept {
FMT_CONSTEXPR auto make_emphasis(emphasis em) noexcept
-> ansi_color_escape<Char> {
return ansi_color_escape<Char>(em);
}
template <typename Char> inline void fputs(const Char* chars, FILE* stream) {
int result = std::fputs(chars, stream);
if (result < 0)
FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
}
template <> inline void fputs<wchar_t>(const wchar_t* chars, FILE* stream) {
int result = std::fputws(chars, stream);
if (result < 0)
FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
}
template <typename Char> inline void reset_color(FILE* stream) {
fputs("\x1b[0m", stream);
}
template <> inline void reset_color<wchar_t>(FILE* stream) {
fputs(L"\x1b[0m", stream);
}
template <typename Char> inline void reset_color(buffer<Char>& buffer) {
auto reset_color = string_view("\x1b[0m");
buffer.append(reset_color.begin(), reset_color.end());
}
template <typename T> struct styled_arg {
template <typename T> struct styled_arg : detail::view {
const T& value;
text_style style;
styled_arg(const T& v, text_style s) : value(v), style(s) {}
};
template <typename Char>
@ -477,19 +464,21 @@ void vformat_to(buffer<Char>& buf, const text_style& ts,
if (has_style) detail::reset_color<Char>(buf);
}
FMT_END_DETAIL_NAMESPACE
} // namespace detail
template <typename S, typename Char = char_t<S>>
void vprint(std::FILE* f, const text_style& ts, const S& format,
basic_format_args<buffer_context<type_identity_t<Char>>> args) {
basic_memory_buffer<Char> buf;
detail::vformat_to(buf, ts, detail::to_string_view(format), args);
inline void vprint(std::FILE* f, const text_style& ts, string_view fmt,
format_args args) {
// Legacy wide streams are not supported.
auto buf = memory_buffer();
detail::vformat_to(buf, ts, fmt, args);
if (detail::is_utf8()) {
detail::print(f, basic_string_view<Char>(buf.begin(), buf.size()));
} else {
buf.push_back(Char(0));
detail::fputs(buf.data(), f);
detail::print(f, string_view(buf.begin(), buf.size()));
return;
}
buf.push_back('\0');
int result = std::fputs(buf.data(), f);
if (result < 0)
FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
}
/**
@ -529,9 +518,10 @@ void print(const text_style& ts, const S& format_str, const Args&... args) {
}
template <typename S, typename Char = char_t<S>>
inline std::basic_string<Char> vformat(
inline auto vformat(
const text_style& ts, const S& format_str,
basic_format_args<buffer_context<type_identity_t<Char>>> args) {
basic_format_args<buffer_context<type_identity_t<Char>>> args)
-> std::basic_string<Char> {
basic_memory_buffer<Char> buf;
detail::vformat_to(buf, ts, detail::to_string_view(format_str), args);
return fmt::to_string(buf);
@ -550,8 +540,8 @@ inline std::basic_string<Char> vformat(
\endrst
*/
template <typename S, typename... Args, typename Char = char_t<S>>
inline std::basic_string<Char> format(const text_style& ts, const S& format_str,
const Args&... args) {
inline auto format(const text_style& ts, const S& format_str,
const Args&... args) -> std::basic_string<Char> {
return fmt::vformat(ts, detail::to_string_view(format_str),
fmt::make_format_args<buffer_context<Char>>(args...));
}
@ -561,12 +551,13 @@ inline std::basic_string<Char> format(const text_style& ts, const S& format_str,
*/
template <typename OutputIt, typename Char,
FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value)>
OutputIt vformat_to(
OutputIt out, const text_style& ts, basic_string_view<Char> format_str,
basic_format_args<buffer_context<type_identity_t<Char>>> args) {
auto vformat_to(OutputIt out, const text_style& ts,
basic_string_view<Char> format_str,
basic_format_args<buffer_context<type_identity_t<Char>>> args)
-> OutputIt {
auto&& buf = detail::get_buffer<Char>(out);
detail::vformat_to(buf, ts, format_str, args);
return detail::get_iterator(buf);
return detail::get_iterator(buf, out);
}
/**
@ -581,9 +572,10 @@ OutputIt vformat_to(
fmt::emphasis::bold | fg(fmt::color::red), "{}", 42);
\endrst
*/
template <typename OutputIt, typename S, typename... Args,
bool enable = detail::is_output_iterator<OutputIt, char_t<S>>::value&&
detail::is_string<S>::value>
template <
typename OutputIt, typename S, typename... Args,
bool enable = detail::is_output_iterator<OutputIt, char_t<S>>::value &&
detail::is_string<S>::value>
inline auto format_to(OutputIt out, const text_style& ts, const S& format_str,
Args&&... args) ->
typename std::enable_if<enable, OutputIt>::type {
@ -645,7 +637,7 @@ FMT_CONSTEXPR auto styled(const T& value, text_style ts)
return detail::styled_arg<remove_cvref_t<T>>{value, ts};
}
FMT_MODULE_EXPORT_END
FMT_END_EXPORT
FMT_END_NAMESPACE
#endif // FMT_COLOR_H_

146
include/fmt/compile.h
View File

@ -14,89 +14,11 @@ FMT_BEGIN_NAMESPACE
namespace detail {
template <typename Char, typename InputIt>
FMT_CONSTEXPR inline counting_iterator copy_str(InputIt begin, InputIt end,
counting_iterator it) {
FMT_CONSTEXPR inline auto copy_str(InputIt begin, InputIt end,
counting_iterator it) -> counting_iterator {
return it + (end - begin);
}
template <typename OutputIt> class truncating_iterator_base {
protected:
OutputIt out_;
size_t limit_;
size_t count_ = 0;
truncating_iterator_base() : out_(), limit_(0) {}
truncating_iterator_base(OutputIt out, size_t limit)
: out_(out), limit_(limit) {}
public:
using iterator_category = std::output_iterator_tag;
using value_type = typename std::iterator_traits<OutputIt>::value_type;
using difference_type = std::ptrdiff_t;
using pointer = void;
using reference = void;
FMT_UNCHECKED_ITERATOR(truncating_iterator_base);
OutputIt base() const { return out_; }
size_t count() const { return count_; }
};
// An output iterator that truncates the output and counts the number of objects
// written to it.
template <typename OutputIt,
typename Enable = typename std::is_void<
typename std::iterator_traits<OutputIt>::value_type>::type>
class truncating_iterator;
template <typename OutputIt>
class truncating_iterator<OutputIt, std::false_type>
: public truncating_iterator_base<OutputIt> {
mutable typename truncating_iterator_base<OutputIt>::value_type blackhole_;
public:
using value_type = typename truncating_iterator_base<OutputIt>::value_type;
truncating_iterator() = default;
truncating_iterator(OutputIt out, size_t limit)
: truncating_iterator_base<OutputIt>(out, limit) {}
truncating_iterator& operator++() {
if (this->count_++ < this->limit_) ++this->out_;
return *this;
}
truncating_iterator operator++(int) {
auto it = *this;
++*this;
return it;
}
value_type& operator*() const {
return this->count_ < this->limit_ ? *this->out_ : blackhole_;
}
};
template <typename OutputIt>
class truncating_iterator<OutputIt, std::true_type>
: public truncating_iterator_base<OutputIt> {
public:
truncating_iterator() = default;
truncating_iterator(OutputIt out, size_t limit)
: truncating_iterator_base<OutputIt>(out, limit) {}
template <typename T> truncating_iterator& operator=(T val) {
if (this->count_++ < this->limit_) *this->out_++ = val;
return *this;
}
truncating_iterator& operator++() { return *this; }
truncating_iterator& operator++(int) { return *this; }
truncating_iterator& operator*() { return *this; }
};
// A compile-time string which is compiled into fast formatting code.
class compiled_string {};
@ -135,7 +57,7 @@ struct udl_compiled_string : compiled_string {
#endif
template <typename T, typename... Tail>
const T& first(const T& value, const Tail&...) {
auto first(const T& value, const Tail&...) -> const T& {
return value;
}
@ -196,7 +118,8 @@ template <typename Char> struct code_unit {
template <typename OutputIt, typename... Args>
constexpr OutputIt format(OutputIt out, const Args&...) const {
return write<Char>(out, value);
*out++ = value;
return out;
}
};
@ -220,7 +143,12 @@ template <typename Char, typename T, int N> struct field {
template <typename OutputIt, typename... Args>
constexpr OutputIt format(OutputIt out, const Args&... args) const {
return write<Char>(out, get_arg_checked<T, N>(args...));
const T& arg = get_arg_checked<T, N>(args...);
if constexpr (std::is_convertible_v<T, basic_string_view<Char>>) {
auto s = basic_string_view<Char>(arg);
return copy_str<Char>(s.begin(), s.end(), out);
}
return write<Char>(out, arg);
}
};
@ -331,14 +259,14 @@ template <typename T, typename Char> struct parse_specs_result {
int next_arg_id;
};
constexpr int manual_indexing_id = -1;
enum { manual_indexing_id = -1 };
template <typename T, typename Char>
constexpr parse_specs_result<T, Char> parse_specs(basic_string_view<Char> str,
size_t pos, int next_arg_id) {
str.remove_prefix(pos);
auto ctx = compile_parse_context<Char>(str, max_value<int>(), nullptr, {},
next_arg_id);
auto ctx =
compile_parse_context<Char>(str, max_value<int>(), nullptr, next_arg_id);
auto f = formatter<T, Char>();
auto end = f.parse(ctx);
return {f, pos + fmt::detail::to_unsigned(end - str.data()),
@ -348,22 +276,18 @@ constexpr parse_specs_result<T, Char> parse_specs(basic_string_view<Char> str,
template <typename Char> struct arg_id_handler {
arg_ref<Char> arg_id;
constexpr int operator()() {
constexpr int on_auto() {
FMT_ASSERT(false, "handler cannot be used with automatic indexing");
return 0;
}
constexpr int operator()(int id) {
constexpr int on_index(int id) {
arg_id = arg_ref<Char>(id);
return 0;
}
constexpr int operator()(basic_string_view<Char> id) {
constexpr int on_name(basic_string_view<Char> id) {
arg_id = arg_ref<Char>(id);
return 0;
}
constexpr void on_error(const char* message) {
FMT_THROW(format_error(message));
}
};
template <typename Char> struct parse_arg_id_result {
@ -452,20 +376,18 @@ constexpr auto compile_format_string(S format_str) {
} else if constexpr (arg_id_result.arg_id.kind == arg_id_kind::name) {
constexpr auto arg_index =
get_arg_index_by_name(arg_id_result.arg_id.val.name, Args{});
if constexpr (arg_index != invalid_arg_index) {
if constexpr (arg_index >= 0) {
constexpr auto next_id =
ID != manual_indexing_id ? ID + 1 : manual_indexing_id;
return parse_replacement_field_then_tail<
decltype(get_type<arg_index, Args>::value), Args, arg_id_end_pos,
arg_index, next_id>(format_str);
} else {
if constexpr (c == '}') {
return parse_tail<Args, arg_id_end_pos + 1, ID>(
runtime_named_field<char_type>{arg_id_result.arg_id.val.name},
format_str);
} else if constexpr (c == ':') {
return unknown_format(); // no type info for specs parsing
}
} else if constexpr (c == '}') {
return parse_tail<Args, arg_id_end_pos + 1, ID>(
runtime_named_field<char_type>{arg_id_result.arg_id.val.name},
format_str);
} else if constexpr (c == ':') {
return unknown_format(); // no type info for specs parsing
}
}
}
@ -501,7 +423,7 @@ constexpr auto compile(S format_str) {
#endif // defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)
} // namespace detail
FMT_MODULE_EXPORT_BEGIN
FMT_BEGIN_EXPORT
#if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)
@ -566,17 +488,19 @@ FMT_CONSTEXPR OutputIt format_to(OutputIt out, const S&, Args&&... args) {
template <typename OutputIt, typename S, typename... Args,
FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
format_to_n_result<OutputIt> format_to_n(OutputIt out, size_t n,
const S& format_str, Args&&... args) {
auto it = fmt::format_to(detail::truncating_iterator<OutputIt>(out, n),
format_str, std::forward<Args>(args)...);
return {it.base(), it.count()};
auto format_to_n(OutputIt out, size_t n, const S& format_str, Args&&... args)
-> format_to_n_result<OutputIt> {
using traits = detail::fixed_buffer_traits;
auto buf = detail::iterator_buffer<OutputIt, char, traits>(out, n);
fmt::format_to(std::back_inserter(buf), format_str,
std::forward<Args>(args)...);
return {buf.out(), buf.count()};
}
template <typename S, typename... Args,
FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
FMT_CONSTEXPR20 size_t formatted_size(const S& format_str,
const Args&... args) {
FMT_CONSTEXPR20 auto formatted_size(const S& format_str, const Args&... args)
-> size_t {
return fmt::format_to(detail::counting_iterator(), format_str, args...)
.count();
}
@ -605,7 +529,7 @@ template <detail_exported::fixed_string Str> constexpr auto operator""_cf() {
} // namespace literals
#endif
FMT_MODULE_EXPORT_END
FMT_END_EXPORT
FMT_END_NAMESPACE
#endif // FMT_COMPILE_H_

1920
include/fmt/core.h
View File

File diff suppressed because it is too large Load Diff

367
include/fmt/format-inl.h
View File

@ -9,20 +9,16 @@
#define FMT_FORMAT_INL_H_
#include <algorithm>
#include <cctype>
#include <cerrno> // errno
#include <climits>
#include <cmath>
#include <cstdarg>
#include <cstring> // std::memmove
#include <cwchar>
#include <exception>
#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
# include <locale>
#endif
#ifdef _WIN32
#if defined(_WIN32) && !defined(FMT_WINDOWS_NO_WCHAR)
# include <io.h> // _isatty
#endif
@ -62,8 +58,8 @@ FMT_FUNC void format_error_code(detail::buffer<char>& out, int error_code,
error_code_size += detail::to_unsigned(detail::count_digits(abs_value));
auto it = buffer_appender<char>(out);
if (message.size() <= inline_buffer_size - error_code_size)
format_to(it, FMT_STRING("{}{}"), message, SEP);
format_to(it, FMT_STRING("{}{}"), ERROR_STR, error_code);
fmt::format_to(it, FMT_STRING("{}{}"), message, SEP);
fmt::format_to(it, FMT_STRING("{}{}"), ERROR_STR, error_code);
FMT_ASSERT(out.size() <= inline_buffer_size, "");
}
@ -77,9 +73,8 @@ FMT_FUNC void report_error(format_func func, int error_code,
}
// A wrapper around fwrite that throws on error.
inline void fwrite_fully(const void* ptr, size_t size, size_t count,
FILE* stream) {
size_t written = std::fwrite(ptr, size, count, stream);
inline void fwrite_fully(const void* ptr, size_t count, FILE* stream) {
size_t written = std::fwrite(ptr, 1, count, stream);
if (written < count)
FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
}
@ -90,7 +85,7 @@ locale_ref::locale_ref(const Locale& loc) : locale_(&loc) {
static_assert(std::is_same<Locale, std::locale>::value, "");
}
template <typename Locale> Locale locale_ref::get() const {
template <typename Locale> auto locale_ref::get() const -> Locale {
static_assert(std::is_same<Locale, std::locale>::value, "");
return locale_ ? *static_cast<const std::locale*>(locale_) : std::locale();
}
@ -102,7 +97,8 @@ FMT_FUNC auto thousands_sep_impl(locale_ref loc) -> thousands_sep_result<Char> {
auto thousands_sep = grouping.empty() ? Char() : facet.thousands_sep();
return {std::move(grouping), thousands_sep};
}
template <typename Char> FMT_FUNC Char decimal_point_impl(locale_ref loc) {
template <typename Char>
FMT_FUNC auto decimal_point_impl(locale_ref loc) -> Char {
return std::use_facet<std::numpunct<Char>>(loc.get<std::locale>())
.decimal_point();
}
@ -115,96 +111,74 @@ template <typename Char> FMT_FUNC Char decimal_point_impl(locale_ref) {
return '.';
}
#endif
FMT_FUNC auto write_loc(appender out, loc_value value,
const format_specs<>& specs, locale_ref loc) -> bool {
#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
auto locale = loc.get<std::locale>();
// We cannot use the num_put<char> facet because it may produce output in
// a wrong encoding.
using facet = format_facet<std::locale>;
if (std::has_facet<facet>(locale))
return std::use_facet<facet>(locale).put(out, value, specs);
return facet(locale).put(out, value, specs);
#endif
return false;
}
} // namespace detail
#if !FMT_MSC_VERSION
FMT_API FMT_FUNC format_error::~format_error() noexcept = default;
template <typename Locale> typename Locale::id format_facet<Locale>::id;
#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
template <typename Locale> format_facet<Locale>::format_facet(Locale& loc) {
auto& numpunct = std::use_facet<std::numpunct<char>>(loc);
grouping_ = numpunct.grouping();
if (!grouping_.empty()) separator_ = std::string(1, numpunct.thousands_sep());
}
template <>
FMT_API FMT_FUNC auto format_facet<std::locale>::do_put(
appender out, loc_value val, const format_specs<>& specs) const -> bool {
return val.visit(
detail::loc_writer<>{out, specs, separator_, grouping_, decimal_point_});
}
#endif
FMT_FUNC std::system_error vsystem_error(int error_code, string_view format_str,
format_args args) {
FMT_FUNC auto vsystem_error(int error_code, string_view fmt, format_args args)
-> std::system_error {
auto ec = std::error_code(error_code, std::generic_category());
return std::system_error(ec, vformat(format_str, args));
return std::system_error(ec, vformat(fmt, args));
}
namespace detail {
template <typename F> inline bool operator==(basic_fp<F> x, basic_fp<F> y) {
template <typename F>
inline auto operator==(basic_fp<F> x, basic_fp<F> y) -> bool {
return x.f == y.f && x.e == y.e;
}
// Compilers should be able to optimize this into the ror instruction.
FMT_CONSTEXPR inline uint32_t rotr(uint32_t n, uint32_t r) noexcept {
FMT_CONSTEXPR inline auto rotr(uint32_t n, uint32_t r) noexcept -> uint32_t {
r &= 31;
return (n >> r) | (n << (32 - r));
}
FMT_CONSTEXPR inline uint64_t rotr(uint64_t n, uint32_t r) noexcept {
FMT_CONSTEXPR inline auto rotr(uint64_t n, uint32_t r) noexcept -> uint64_t {
r &= 63;
return (n >> r) | (n << (64 - r));
}
// Computes 128-bit result of multiplication of two 64-bit unsigned integers.
inline uint128_fallback umul128(uint64_t x, uint64_t y) noexcept {
#if FMT_USE_INT128
auto p = static_cast<uint128_opt>(x) * static_cast<uint128_opt>(y);
return {static_cast<uint64_t>(p >> 64), static_cast<uint64_t>(p)};
#elif defined(_MSC_VER) && defined(_M_X64)
auto result = uint128_fallback();
result.lo_ = _umul128(x, y, &result.hi_);
return result;
#else
const uint64_t mask = static_cast<uint64_t>(max_value<uint32_t>());
uint64_t a = x >> 32;
uint64_t b = x & mask;
uint64_t c = y >> 32;
uint64_t d = y & mask;
uint64_t ac = a * c;
uint64_t bc = b * c;
uint64_t ad = a * d;
uint64_t bd = b * d;
uint64_t intermediate = (bd >> 32) + (ad & mask) + (bc & mask);
return {ac + (intermediate >> 32) + (ad >> 32) + (bc >> 32),
(intermediate << 32) + (bd & mask)};
#endif
}
// Implementation of Dragonbox algorithm: https://github.com/jk-jeon/dragonbox.
namespace dragonbox {
// Computes upper 64 bits of multiplication of two 64-bit unsigned integers.
inline uint64_t umul128_upper64(uint64_t x, uint64_t y) noexcept {
#if FMT_USE_INT128
auto p = static_cast<uint128_opt>(x) * static_cast<uint128_opt>(y);
return static_cast<uint64_t>(p >> 64);
#elif defined(_MSC_VER) && defined(_M_X64)
return __umulh(x, y);
#else
return umul128(x, y).high();
#endif
}
// Computes upper 128 bits of multiplication of a 64-bit unsigned integer and a
// 128-bit unsigned integer.
inline uint128_fallback umul192_upper128(uint64_t x,
uint128_fallback y) noexcept {
uint128_fallback r = umul128(x, y.high());
r += umul128_upper64(x, y.low());
return r;
}
// Computes upper 64 bits of multiplication of a 32-bit unsigned integer and a
// 64-bit unsigned integer.
inline uint64_t umul96_upper64(uint32_t x, uint64_t y) noexcept {
inline auto umul96_upper64(uint32_t x, uint64_t y) noexcept -> uint64_t {
return umul128_upper64(static_cast<uint64_t>(x) << 32, y);
}
// Computes lower 128 bits of multiplication of a 64-bit unsigned integer and a
// 128-bit unsigned integer.
inline uint128_fallback umul192_lower128(uint64_t x,
uint128_fallback y) noexcept {
inline auto umul192_lower128(uint64_t x, uint128_fallback y) noexcept
-> uint128_fallback {
uint64_t high = x * y.high();
uint128_fallback high_low = umul128(x, y.low());
return {high + high_low.high(), high_low.low()};
@ -212,29 +186,17 @@ inline uint128_fallback umul192_lower128(uint64_t x,
// Computes lower 64 bits of multiplication of a 32-bit unsigned integer and a
// 64-bit unsigned integer.
inline uint64_t umul96_lower64(uint32_t x, uint64_t y) noexcept {
inline auto umul96_lower64(uint32_t x, uint64_t y) noexcept -> uint64_t {
return x * y;
}
// Computes floor(log10(pow(2, e))) for e in [-2620, 2620] using the method from
// https://fmt.dev/papers/Dragonbox.pdf#page=28, section 6.1.
inline int floor_log10_pow2(int e) noexcept {
FMT_ASSERT(e <= 2620 && e >= -2620, "too large exponent");
static_assert((-1 >> 1) == -1, "right shift is not arithmetic");
return (e * 315653) >> 20;
}
// Various fast log computations.
inline int floor_log2_pow10(int e) noexcept {
FMT_ASSERT(e <= 1233 && e >= -1233, "too large exponent");
return (e * 1741647) >> 19;
}
inline int floor_log10_pow2_minus_log10_4_over_3(int e) noexcept {
inline auto floor_log10_pow2_minus_log10_4_over_3(int e) noexcept -> int {
FMT_ASSERT(e <= 2936 && e >= -2985, "too large exponent");
return (e * 631305 - 261663) >> 21;
}
static constexpr struct {
FMT_INLINE_VARIABLE constexpr struct {
uint32_t divisor;
int shift_amount;
} div_small_pow10_infos[] = {{10, 16}, {100, 16}};
@ -243,7 +205,7 @@ static constexpr struct {
// divisible by pow(10, N).
// Precondition: n <= pow(10, N + 1).
template <int N>
bool check_divisibility_and_divide_by_pow10(uint32_t& n) noexcept {
auto check_divisibility_and_divide_by_pow10(uint32_t& n) noexcept -> bool {
// The numbers below are chosen such that:
// 1. floor(n/d) = floor(nm / 2^k) where d=10 or d=100,
// 2. nm mod 2^k < m if and only if n is divisible by d,
@ -268,7 +230,7 @@ bool check_divisibility_and_divide_by_pow10(uint32_t& n) noexcept {
// Computes floor(n / pow(10, N)) for small n and N.
// Precondition: n <= pow(10, N + 1).
template <int N> uint32_t small_division_by_pow10(uint32_t n) noexcept {
template <int N> auto small_division_by_pow10(uint32_t n) noexcept -> uint32_t {
constexpr auto info = div_small_pow10_infos[N - 1];
FMT_ASSERT(n <= info.divisor * 10, "n is too large");
constexpr uint32_t magic_number =
@ -277,24 +239,24 @@ template <int N> uint32_t small_division_by_pow10(uint32_t n) noexcept {
}
// Computes floor(n / 10^(kappa + 1)) (float)
inline uint32_t divide_by_10_to_kappa_plus_1(uint32_t n) noexcept {
inline auto divide_by_10_to_kappa_plus_1(uint32_t n) noexcept -> uint32_t {
// 1374389535 = ceil(2^37/100)
return static_cast<uint32_t>((static_cast<uint64_t>(n) * 1374389535) >> 37);
}
// Computes floor(n / 10^(kappa + 1)) (double)
inline uint64_t divide_by_10_to_kappa_plus_1(uint64_t n) noexcept {
inline auto divide_by_10_to_kappa_plus_1(uint64_t n) noexcept -> uint64_t {
// 2361183241434822607 = ceil(2^(64+7)/1000)
return umul128_upper64(n, 2361183241434822607ull) >> 7;
}
// Various subroutines using pow10 cache
template <class T> struct cache_accessor;
template <typename T> struct cache_accessor;
template <> struct cache_accessor<float> {
using carrier_uint = float_info<float>::carrier_uint;
using cache_entry_type = uint64_t;
static uint64_t get_cached_power(int k) noexcept {
static auto get_cached_power(int k) noexcept -> uint64_t {
FMT_ASSERT(k >= float_info<float>::min_k && k <= float_info<float>::max_k,
"k is out of range");
static constexpr const uint64_t pow10_significands[] = {
@ -336,20 +298,23 @@ template <> struct cache_accessor<float> {
bool is_integer;
};
static compute_mul_result compute_mul(
carrier_uint u, const cache_entry_type& cache) noexcept {
static auto compute_mul(carrier_uint u,
const cache_entry_type& cache) noexcept
-> compute_mul_result {
auto r = umul96_upper64(u, cache);
return {static_cast<carrier_uint>(r >> 32),
static_cast<carrier_uint>(r) == 0};
}
static uint32_t compute_delta(const cache_entry_type& cache,
int beta) noexcept {
static auto compute_delta(const cache_entry_type& cache, int beta) noexcept
-> uint32_t {
return static_cast<uint32_t>(cache >> (64 - 1 - beta));
}
static compute_mul_parity_result compute_mul_parity(
carrier_uint two_f, const cache_entry_type& cache, int beta) noexcept {
static auto compute_mul_parity(carrier_uint two_f,
const cache_entry_type& cache,
int beta) noexcept
-> compute_mul_parity_result {
FMT_ASSERT(beta >= 1, "");
FMT_ASSERT(beta < 64, "");
@ -358,22 +323,22 @@ template <> struct cache_accessor<float> {
static_cast<uint32_t>(r >> (32 - beta)) == 0};
}
static carrier_uint compute_left_endpoint_for_shorter_interval_case(
const cache_entry_type& cache, int beta) noexcept {
static auto compute_left_endpoint_for_shorter_interval_case(
const cache_entry_type& cache, int beta) noexcept -> carrier_uint {
return static_cast<carrier_uint>(
(cache - (cache >> (num_significand_bits<float>() + 2))) >>
(64 - num_significand_bits<float>() - 1 - beta));
}
static carrier_uint compute_right_endpoint_for_shorter_interval_case(
const cache_entry_type& cache, int beta) noexcept {
static auto compute_right_endpoint_for_shorter_interval_case(
const cache_entry_type& cache, int beta) noexcept -> carrier_uint {
return static_cast<carrier_uint>(
(cache + (cache >> (num_significand_bits<float>() + 1))) >>
(64 - num_significand_bits<float>() - 1 - beta));
}
static carrier_uint compute_round_up_for_shorter_interval_case(
const cache_entry_type& cache, int beta) noexcept {
static auto compute_round_up_for_shorter_interval_case(
const cache_entry_type& cache, int beta) noexcept -> carrier_uint {
return (static_cast<carrier_uint>(
cache >> (64 - num_significand_bits<float>() - 2 - beta)) +
1) /
@ -385,7 +350,7 @@ template <> struct cache_accessor<double> {
using carrier_uint = float_info<double>::carrier_uint;
using cache_entry_type = uint128_fallback;
static uint128_fallback get_cached_power(int k) noexcept {
static auto get_cached_power(int k) noexcept -> uint128_fallback {
FMT_ASSERT(k >= float_info<double>::min_k && k <= float_info<double>::max_k,
"k is out of range");
@ -1009,8 +974,22 @@ template <> struct cache_accessor<double> {
{0xfcf62c1dee382c42, 0x46729e03dd9ed7b6},
{0x9e19db92b4e31ba9, 0x6c07a2c26a8346d2},
{0xc5a05277621be293, 0xc7098b7305241886},
{ 0xf70867153aa2db38,
0xb8cbee4fc66d1ea8 }
{0xf70867153aa2db38, 0xb8cbee4fc66d1ea8},
{0x9a65406d44a5c903, 0x737f74f1dc043329},
{0xc0fe908895cf3b44, 0x505f522e53053ff3},
{0xf13e34aabb430a15, 0x647726b9e7c68ff0},
{0x96c6e0eab509e64d, 0x5eca783430dc19f6},
{0xbc789925624c5fe0, 0xb67d16413d132073},
{0xeb96bf6ebadf77d8, 0xe41c5bd18c57e890},
{0x933e37a534cbaae7, 0x8e91b962f7b6f15a},
{0xb80dc58e81fe95a1, 0x723627bbb5a4adb1},
{0xe61136f2227e3b09, 0xcec3b1aaa30dd91d},
{0x8fcac257558ee4e6, 0x213a4f0aa5e8a7b2},
{0xb3bd72ed2af29e1f, 0xa988e2cd4f62d19e},
{0xe0accfa875af45a7, 0x93eb1b80a33b8606},
{0x8c6c01c9498d8b88, 0xbc72f130660533c4},
{0xaf87023b9bf0ee6a, 0xeb8fad7c7f8680b5},
{0xdb68c2ca82ed2a05, 0xa67398db9f6820e2},
#else
{0xff77b1fcbebcdc4f, 0x25e8e89c13bb0f7b},
{0xce5d73ff402d98e3, 0xfb0a3d212dc81290},
@ -1034,8 +1013,8 @@ template <> struct cache_accessor<double> {
{0x8da471a9de737e24, 0x5ceaecfed289e5d3},
{0xe4d5e82392a40515, 0x0fabaf3feaa5334b},
{0xb8da1662e7b00a17, 0x3d6a751f3b936244},
{ 0x95527a5202df0ccb,
0x0f37801e0c43ebc9 }
{0x95527a5202df0ccb, 0x0f37801e0c43ebc9},
{0xf13e34aabb430a15, 0x647726b9e7c68ff0}
#endif
};
@ -1095,19 +1074,22 @@ template <> struct cache_accessor<double> {
bool is_integer;
};
static compute_mul_result compute_mul(
carrier_uint u, const cache_entry_type& cache) noexcept {
static auto compute_mul(carrier_uint u,
const cache_entry_type& cache) noexcept
-> compute_mul_result {
auto r = umul192_upper128(u, cache);
return {r.high(), r.low() == 0};
}
static uint32_t compute_delta(cache_entry_type const& cache,
int beta) noexcept {
static auto compute_delta(cache_entry_type const& cache, int beta) noexcept
-> uint32_t {
return static_cast<uint32_t>(cache.high() >> (64 - 1 - beta));
}
static compute_mul_parity_result compute_mul_parity(
carrier_uint two_f, const cache_entry_type& cache, int beta) noexcept {
static auto compute_mul_parity(carrier_uint two_f,
const cache_entry_type& cache,
int beta) noexcept
-> compute_mul_parity_result {
FMT_ASSERT(beta >= 1, "");
FMT_ASSERT(beta < 64, "");
@ -1116,31 +1098,35 @@ template <> struct cache_accessor<double> {
((r.high() << beta) | (r.low() >> (64 - beta))) == 0};
}
static carrier_uint compute_left_endpoint_for_shorter_interval_case(
const cache_entry_type& cache, int beta) noexcept {
static auto compute_left_endpoint_for_shorter_interval_case(
const cache_entry_type& cache, int beta) noexcept -> carrier_uint {
return (cache.high() -
(cache.high() >> (num_significand_bits<double>() + 2))) >>
(64 - num_significand_bits<double>() - 1 - beta);
}
static carrier_uint compute_right_endpoint_for_shorter_interval_case(
const cache_entry_type& cache, int beta) noexcept {
static auto compute_right_endpoint_for_shorter_interval_case(
const cache_entry_type& cache, int beta) noexcept -> carrier_uint {
return (cache.high() +
(cache.high() >> (num_significand_bits<double>() + 1))) >>
(64 - num_significand_bits<double>() - 1 - beta);
}
static carrier_uint compute_round_up_for_shorter_interval_case(
const cache_entry_type& cache, int beta) noexcept {
static auto compute_round_up_for_shorter_interval_case(
const cache_entry_type& cache, int beta) noexcept -> carrier_uint {
return ((cache.high() >> (64 - num_significand_bits<double>() - 2 - beta)) +
1) /
2;
}
};
FMT_FUNC auto get_cached_power(int k) noexcept -> uint128_fallback {
return cache_accessor<double>::get_cached_power(k);
}
// Various integer checks
template <class T>
bool is_left_endpoint_integer_shorter_interval(int exponent) noexcept {
template <typename T>
auto is_left_endpoint_integer_shorter_interval(int exponent) noexcept -> bool {
const int case_shorter_interval_left_endpoint_lower_threshold = 2;
const int case_shorter_interval_left_endpoint_upper_threshold = 3;
return exponent >= case_shorter_interval_left_endpoint_lower_threshold &&
@ -1148,12 +1134,12 @@ bool is_left_endpoint_integer_shorter_interval(int exponent) noexcept {
}
// Remove trailing zeros from n and return the number of zeros removed (float)
FMT_INLINE int remove_trailing_zeros(uint32_t& n) noexcept {
FMT_INLINE int remove_trailing_zeros(uint32_t& n, int s = 0) noexcept {
FMT_ASSERT(n != 0, "");
const uint32_t mod_inv_5 = 0xcccccccd;
const uint32_t mod_inv_25 = mod_inv_5 * mod_inv_5;
// Modular inverse of 5 (mod 2^32): (mod_inv_5 * 5) mod 2^32 = 1.
constexpr uint32_t mod_inv_5 = 0xcccccccd;
constexpr uint32_t mod_inv_25 = 0xc28f5c29; // = mod_inv_5 * mod_inv_5
int s = 0;
while (true) {
auto q = rotr(n * mod_inv_25, 2);
if (q > max_value<uint32_t>() / 100) break;
@ -1165,7 +1151,6 @@ FMT_INLINE int remove_trailing_zeros(uint32_t& n) noexcept {
n = q;
s |= 1;
}
return s;
}
@ -1179,32 +1164,17 @@ FMT_INLINE int remove_trailing_zeros(uint64_t& n) noexcept {
// Is n is divisible by 10^8?
if ((nm.high() & ((1ull << (90 - 64)) - 1)) == 0 && nm.low() < magic_number) {
// If yes, work with the quotient.
// If yes, work with the quotient...
auto n32 = static_cast<uint32_t>(nm.high() >> (90 - 64));
const uint32_t mod_inv_5 = 0xcccccccd;
const uint32_t mod_inv_25 = mod_inv_5 * mod_inv_5;
int s = 8;
while (true) {
auto q = rotr(n32 * mod_inv_25, 2);
if (q > max_value<uint32_t>() / 100) break;
n32 = q;
s += 2;
}
auto q = rotr(n32 * mod_inv_5, 1);
if (q <= max_value<uint32_t>() / 10) {
n32 = q;
s |= 1;
}
// ... and use the 32 bit variant of the function
int s = remove_trailing_zeros(n32, 8);
n = n32;
return s;
}
// If n is not divisible by 10^8, work with n itself.
const uint64_t mod_inv_5 = 0xcccccccccccccccd;
const uint64_t mod_inv_25 = mod_inv_5 * mod_inv_5;
constexpr uint64_t mod_inv_5 = 0xcccccccccccccccd;
constexpr uint64_t mod_inv_25 = 0x8f5c28f5c28f5c29; // mod_inv_5 * mod_inv_5
int s = 0;
while (true) {
@ -1223,7 +1193,7 @@ FMT_INLINE int remove_trailing_zeros(uint64_t& n) noexcept {
}
// The main algorithm for shorter interval case
template <class T>
template <typename T>
FMT_INLINE decimal_fp<T> shorter_interval_case(int exponent) noexcept {
decimal_fp<T> ret_value;
// Compute k and beta
@ -1270,7 +1240,7 @@ FMT_INLINE decimal_fp<T> shorter_interval_case(int exponent) noexcept {
return ret_value;
}
template <typename T> decimal_fp<T> to_decimal(T x) noexcept {
template <typename T> auto to_decimal(T x) noexcept -> decimal_fp<T> {
// Step 1: integer promotion & Schubfach multiplier calculation.
using carrier_uint = typename float_info<T>::carrier_uint;
@ -1394,17 +1364,6 @@ small_divisor_case_label:
return ret_value;
}
} // namespace dragonbox
#ifdef _MSC_VER
FMT_FUNC auto fmt_snprintf(char* buf, size_t size, const char* fmt, ...)
-> int {
auto args = va_list();
va_start(args, fmt);
int result = vsnprintf_s(buf, size, _TRUNCATE, fmt, args);
va_end(args);
return result;
}
#endif
} // namespace detail
template <> struct formatter<detail::bigint> {
@ -1413,23 +1372,22 @@ template <> struct formatter<detail::bigint> {
return ctx.begin();
}
template <typename FormatContext>
auto format(const detail::bigint& n, FormatContext& ctx) const ->
typename FormatContext::iterator {
auto format(const detail::bigint& n, format_context& ctx) const
-> format_context::iterator {
auto out = ctx.out();
bool first = true;
for (auto i = n.bigits_.size(); i > 0; --i) {
auto value = n.bigits_[i - 1u];
if (first) {
out = format_to(out, FMT_STRING("{:x}"), value);
out = fmt::format_to(out, FMT_STRING("{:x}"), value);
first = false;
continue;
}
out = format_to(out, FMT_STRING("{:08x}"), value);
out = fmt::format_to(out, FMT_STRING("{:08x}"), value);
}
if (n.exp_ > 0)
out = format_to(out, FMT_STRING("p{}"),
n.exp_ * detail::bigint::bigit_bits);
out = fmt::format_to(out, FMT_STRING("p{}"),
n.exp_ * detail::bigint::bigit_bits);
return out;
}
};
@ -1465,7 +1423,7 @@ FMT_FUNC void report_system_error(int error_code,
report_error(format_system_error, error_code, message);
}
FMT_FUNC std::string vformat(string_view fmt, format_args args) {
FMT_FUNC auto vformat(string_view fmt, format_args args) -> std::string {
// Don't optimize the "{}" case to keep the binary size small and because it
// can be better optimized in fmt::format anyway.
auto buffer = memory_buffer();
@ -1474,57 +1432,54 @@ FMT_FUNC std::string vformat(string_view fmt, format_args args) {
}
namespace detail {
#ifdef _WIN32
#if !defined(_WIN32) || defined(FMT_WINDOWS_NO_WCHAR)
FMT_FUNC auto write_console(int, string_view) -> bool { return false; }
FMT_FUNC auto write_console(std::FILE*, string_view) -> bool { return false; }
#else
using dword = conditional_t<sizeof(long) == 4, unsigned long, unsigned>;
extern "C" __declspec(dllimport) int __stdcall WriteConsoleW( //
void*, const void*, dword, dword*, void*);
FMT_FUNC bool write_console(std::FILE* f, string_view text) {
auto fd = _fileno(f);
if (_isatty(fd)) {
detail::utf8_to_utf16 u16(string_view(text.data(), text.size()));
auto written = detail::dword();
if (detail::WriteConsoleW(reinterpret_cast<void*>(_get_osfhandle(fd)),
u16.c_str(), static_cast<uint32_t>(u16.size()),
&written, nullptr)) {
return true;
}
}
// We return false if the file descriptor was not TTY, or it was but
// SetConsoleW failed which can happen if the output has been redirected to
// NUL. In both cases when we return false, we should attempt to do regular
// write via fwrite or std::ostream::write.
return false;
FMT_FUNC bool write_console(int fd, string_view text) {
auto u16 = utf8_to_utf16(text);
return WriteConsoleW(reinterpret_cast<void*>(_get_osfhandle(fd)), u16.c_str(),
static_cast<dword>(u16.size()), nullptr, nullptr) != 0;
}
FMT_FUNC auto write_console(std::FILE* f, string_view text) -> bool {
return write_console(_fileno(f), text);
}
#endif
#ifdef _WIN32
// Print assuming legacy (non-Unicode) encoding.
FMT_FUNC void vprint_mojibake(std::FILE* f, string_view fmt, format_args args) {
auto buffer = memory_buffer();
detail::vformat_to(buffer, fmt, args);
fwrite_fully(buffer.data(), buffer.size(), f);
}
#endif
FMT_FUNC void print(std::FILE* f, string_view text) {
#ifdef _WIN32
if (write_console(f, text)) return;
int fd = _fileno(f);
if (_isatty(fd)) {
std::fflush(f);
if (write_console(fd, text)) return;
}
#endif
detail::fwrite_fully(text.data(), 1, text.size(), f);
fwrite_fully(text.data(), text.size(), f);
}
} // namespace detail
FMT_FUNC void vprint(std::FILE* f, string_view format_str, format_args args) {
memory_buffer buffer;
detail::vformat_to(buffer, format_str, args);
FMT_FUNC void vprint(std::FILE* f, string_view fmt, format_args args) {
auto buffer = memory_buffer();
detail::vformat_to(buffer, fmt, args);
detail::print(f, {buffer.data(), buffer.size()});
}
#ifdef _WIN32
// Print assuming legacy (non-Unicode) encoding.
FMT_FUNC void detail::vprint_mojibake(std::FILE* f, string_view format_str,
format_args args) {
memory_buffer buffer;
detail::vformat_to(buffer, format_str,
basic_format_args<buffer_context<char>>(args));
fwrite_fully(buffer.data(), 1, buffer.size(), f);
}
#endif
FMT_FUNC void vprint(string_view format_str, format_args args) {
vprint(stdout, format_str, args);
FMT_FUNC void vprint(string_view fmt, format_args args) {
vprint(stdout, fmt, args);
}
namespace detail {

2208
include/fmt/format.h
View File

File diff suppressed because it is too large Load Diff

159
include/fmt/os.h
View File

@ -13,12 +13,14 @@
#include <cstdio>
#include <system_error> // std::system_error
#if defined __APPLE__ || defined(__FreeBSD__)
# include <xlocale.h> // for LC_NUMERIC_MASK on OS X
#endif
#include "format.h"
#if defined __APPLE__ || defined(__FreeBSD__)
# if FMT_HAS_INCLUDE(<xlocale.h>)
# include <xlocale.h> // for LC_NUMERIC_MASK on OS X
# endif
#endif
#ifndef FMT_USE_FCNTL
// UWP doesn't provide _pipe.
# if FMT_HAS_INCLUDE("winapifamily.h")
@ -46,6 +48,7 @@
// Calls to system functions are wrapped in FMT_SYSTEM for testability.
#ifdef FMT_SYSTEM
# define FMT_HAS_SYSTEM
# define FMT_POSIX_CALL(call) FMT_SYSTEM(call)
#else
# define FMT_SYSTEM(call) ::call
@ -71,7 +74,7 @@
#define FMT_RETRY(result, expression) FMT_RETRY_VAL(result, expression, -1)
FMT_BEGIN_NAMESPACE
FMT_MODULE_EXPORT_BEGIN
FMT_BEGIN_EXPORT
/**
\rst
@ -114,57 +117,19 @@ template <typename Char> class basic_cstring_view {
basic_cstring_view(const std::basic_string<Char>& s) : data_(s.c_str()) {}
/** Returns the pointer to a C string. */
const Char* c_str() const { return data_; }
auto c_str() const -> const Char* { return data_; }
};
using cstring_view = basic_cstring_view<char>;
using wcstring_view = basic_cstring_view<wchar_t>;
template <typename Char> struct formatter<std::error_code, Char> {
template <typename ParseContext>
FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
return ctx.begin();
}
template <typename FormatContext>
FMT_CONSTEXPR auto format(const std::error_code& ec, FormatContext& ctx) const
-> decltype(ctx.out()) {
auto out = ctx.out();
out = detail::write_bytes(out, ec.category().name(),
basic_format_specs<Char>());
out = detail::write<Char>(out, Char(':'));
out = detail::write<Char>(out, ec.value());
return out;
}
};
#ifdef _WIN32
FMT_API const std::error_category& system_category() noexcept;
FMT_BEGIN_DETAIL_NAMESPACE
// A converter from UTF-16 to UTF-8.
// It is only provided for Windows since other systems support UTF-8 natively.
class utf16_to_utf8 {
private:
memory_buffer buffer_;
public:
utf16_to_utf8() {}
FMT_API explicit utf16_to_utf8(basic_string_view<wchar_t> s);
operator string_view() const { return string_view(&buffer_[0], size()); }
size_t size() const { return buffer_.size() - 1; }
const char* c_str() const { return &buffer_[0]; }
std::string str() const { return std::string(&buffer_[0], size()); }
// Performs conversion returning a system error code instead of
// throwing exception on conversion error. This method may still throw
// in case of memory allocation error.
FMT_API int convert(basic_string_view<wchar_t> s);
};
namespace detail {
FMT_API void format_windows_error(buffer<char>& out, int error_code,
const char* message) noexcept;
FMT_END_DETAIL_NAMESPACE
}
FMT_API std::system_error vwindows_error(int error_code, string_view format_str,
format_args args);
@ -207,7 +172,7 @@ std::system_error windows_error(int error_code, string_view message,
// Can be used to report errors from destructors.
FMT_API void report_windows_error(int error_code, const char* message) noexcept;
#else
inline const std::error_category& system_category() noexcept {
inline auto system_category() noexcept -> const std::error_category& {
return std::system_category();
}
#endif // _WIN32
@ -244,7 +209,7 @@ class buffered_file {
other.file_ = nullptr;
}
buffered_file& operator=(buffered_file&& other) {
auto operator=(buffered_file&& other) -> buffered_file& {
close();
file_ = other.file_;
other.file_ = nullptr;
@ -258,9 +223,9 @@ class buffered_file {
FMT_API void close();
// Returns the pointer to a FILE object representing this file.
FILE* get() const noexcept { return file_; }
auto get() const noexcept -> FILE* { return file_; }
FMT_API int descriptor() const;
FMT_API auto descriptor() const -> int;
void vprint(string_view format_str, format_args args) {
fmt::vprint(file_, format_str, args);
@ -310,7 +275,7 @@ class FMT_API file {
file(file&& other) noexcept : fd_(other.fd_) { other.fd_ = -1; }
// Move assignment is not noexcept because close may throw.
file& operator=(file&& other) {
auto operator=(file&& other) -> file& {
close();
fd_ = other.fd_;
other.fd_ = -1;
@ -321,24 +286,24 @@ class FMT_API file {
~file() noexcept;
// Returns the file descriptor.
int descriptor() const noexcept { return fd_; }
auto descriptor() const noexcept -> int { return fd_; }
// Closes the file.
void close();
// Returns the file size. The size has signed type for consistency with
// stat::st_size.
long long size() const;
auto size() const -> long long;
// Attempts to read count bytes from the file into the specified buffer.
size_t read(void* buffer, size_t count);
auto read(void* buffer, size_t count) -> size_t;
// Attempts to write count bytes from the specified buffer to the file.
size_t write(const void* buffer, size_t count);
auto write(const void* buffer, size_t count) -> size_t;
// Duplicates a file descriptor with the dup function and returns
// the duplicate as a file object.
static file dup(int fd);
static auto dup(int fd) -> file;
// Makes fd be the copy of this file descriptor, closing fd first if
// necessary.
@ -350,22 +315,29 @@ class FMT_API file {
// Creates a pipe setting up read_end and write_end file objects for reading
// and writing respectively.
// DEPRECATED! Taking files as out parameters is deprecated.
static void pipe(file& read_end, file& write_end);
// Creates a buffered_file object associated with this file and detaches
// this file object from the file.
buffered_file fdopen(const char* mode);
auto fdopen(const char* mode) -> buffered_file;
# if defined(_WIN32) && !defined(__MINGW32__)
// Opens a file and constructs a file object representing this file by
// wcstring_view filename. Windows only.
static file open_windows_file(wcstring_view path, int oflag);
# endif
};
// Returns the memory page size.
long getpagesize();
auto getpagesize() -> long;
FMT_BEGIN_DETAIL_NAMESPACE
namespace detail {
struct buffer_size {
buffer_size() = default;
size_t value = 0;
buffer_size operator=(size_t val) const {
auto operator=(size_t val) const -> buffer_size {
auto bs = buffer_size();
bs.value = val;
return bs;
@ -397,56 +369,61 @@ struct ostream_params {
# endif
};
FMT_END_DETAIL_NAMESPACE
class file_buffer final : public buffer<char> {
file file_;
FMT_API void grow(size_t) override;
public:
FMT_API file_buffer(cstring_view path, const ostream_params& params);
FMT_API file_buffer(file_buffer&& other);
FMT_API ~file_buffer();
void flush() {
if (size() == 0) return;
file_.write(data(), size() * sizeof(data()[0]));
clear();
}
void close() {
flush();
file_.close();
}
};
} // namespace detail
// Added {} below to work around default constructor error known to
// occur in Xcode versions 7.2.1 and 8.2.1.
constexpr detail::buffer_size buffer_size{};
/** A fast output stream which is not thread-safe. */
class FMT_API ostream final : private detail::buffer<char> {
class FMT_API ostream {
private:
file file_;
void grow(size_t) override;
FMT_MSC_WARNING(suppress : 4251)
detail::file_buffer buffer_;
ostream(cstring_view path, const detail::ostream_params& params)
: file_(path, params.oflag) {
set(new char[params.buffer_size], params.buffer_size);
}
: buffer_(path, params) {}
public:
ostream(ostream&& other)
: detail::buffer<char>(other.data(), other.size(), other.capacity()),
file_(std::move(other.file_)) {
other.clear();
other.set(nullptr, 0);
}
~ostream() {
flush();
delete[] data();
}
ostream(ostream&& other) : buffer_(std::move(other.buffer_)) {}
void flush() {
if (size() == 0) return;
file_.write(data(), size());
clear();
}
~ostream();
void flush() { buffer_.flush(); }
template <typename... T>
friend ostream output_file(cstring_view path, T... params);
friend auto output_file(cstring_view path, T... params) -> ostream;
void close() {
flush();
file_.close();
}
void close() { buffer_.close(); }
/**
Formats ``args`` according to specifications in ``fmt`` and writes the
output to the file.
*/
template <typename... T> void print(format_string<T...> fmt, T&&... args) {
vformat_to(detail::buffer_appender<char>(*this), fmt,
vformat_to(std::back_inserter(buffer_), fmt,
fmt::make_format_args(args...));
}
};
@ -467,12 +444,12 @@ class FMT_API ostream final : private detail::buffer<char> {
\endrst
*/
template <typename... T>
inline ostream output_file(cstring_view path, T... params) {
inline auto output_file(cstring_view path, T... params) -> ostream {
return {path, detail::ostream_params(params...)};
}
#endif // FMT_USE_FCNTL
FMT_MODULE_EXPORT_END
FMT_END_EXPORT
FMT_END_NAMESPACE
#endif // FMT_OS_H_

152
include/fmt/ostream.h
View File

@ -8,61 +8,58 @@
#ifndef FMT_OSTREAM_H_
#define FMT_OSTREAM_H_
#include <fstream>
#include <ostream>
#if defined(_WIN32) && defined(__GLIBCXX__)
# include <ext/stdio_filebuf.h>
# include <ext/stdio_sync_filebuf.h>
#elif defined(_WIN32) && defined(_LIBCPP_VERSION)
# include <__std_stream>
#include <fstream> // std::filebuf
#ifdef _WIN32
# ifdef __GLIBCXX__
# include <ext/stdio_filebuf.h>
# include <ext/stdio_sync_filebuf.h>
# endif
# include <io.h>
#endif
#include "format.h"
FMT_BEGIN_NAMESPACE
template <typename OutputIt, typename Char> class basic_printf_context;
namespace detail {
// Checks if T has a user-defined operator<<.
template <typename T, typename Char, typename Enable = void>
class is_streamable {
template <typename Streambuf> class formatbuf : public Streambuf {
private:
template <typename U>
static auto test(int)
-> bool_constant<sizeof(std::declval<std::basic_ostream<Char>&>()
<< std::declval<U>()) != 0>;
using char_type = typename Streambuf::char_type;
using streamsize = decltype(std::declval<Streambuf>().sputn(nullptr, 0));
using int_type = typename Streambuf::int_type;
using traits_type = typename Streambuf::traits_type;
template <typename> static auto test(...) -> std::false_type;
using result = decltype(test<T>(0));
buffer<char_type>& buffer_;
public:
is_streamable() = default;
explicit formatbuf(buffer<char_type>& buf) : buffer_(buf) {}
static const bool value = result::value;
protected:
// The put area is always empty. This makes the implementation simpler and has
// the advantage that the streambuf and the buffer are always in sync and
// sputc never writes into uninitialized memory. A disadvantage is that each
// call to sputc always results in a (virtual) call to overflow. There is no
// disadvantage here for sputn since this always results in a call to xsputn.
auto overflow(int_type ch) -> int_type override {
if (!traits_type::eq_int_type(ch, traits_type::eof()))
buffer_.push_back(static_cast<char_type>(ch));
return ch;
}
auto xsputn(const char_type* s, streamsize count) -> streamsize override {
buffer_.append(s, s + count);
return count;
}
};
// Formatting of built-in types and arrays is intentionally disabled because
// it's handled by standard (non-ostream) formatters.
template <typename T, typename Char>
struct is_streamable<
T, Char,
enable_if_t<
std::is_arithmetic<T>::value || std::is_array<T>::value ||
std::is_pointer<T>::value || std::is_same<T, char8_type>::value ||
std::is_convertible<T, fmt::basic_string_view<Char>>::value ||
std::is_same<T, std_string_view<Char>>::value ||
(std::is_convertible<T, int>::value && !std::is_enum<T>::value)>>
: std::false_type {};
// Generate a unique explicit instantion in every translation unit using a tag
// type in an anonymous namespace.
namespace {
struct file_access_tag {};
} // namespace
template <class Tag, class BufType, FILE* BufType::*FileMemberPtr>
template <typename Tag, typename BufType, FILE* BufType::*FileMemberPtr>
class file_access {
friend auto get_file(BufType& obj) -> FILE* { return obj.*FileMemberPtr; }
};
@ -71,36 +68,40 @@ class file_access {
template class file_access<file_access_tag, std::filebuf,
&std::filebuf::_Myfile>;
auto get_file(std::filebuf&) -> FILE*;
#elif defined(_WIN32) && defined(_LIBCPP_VERSION)
template class file_access<file_access_tag, std::__stdoutbuf<char>,
&std::__stdoutbuf<char>::__file_>;
auto get_file(std::__stdoutbuf<char>&) -> FILE*;
#endif
inline bool write_ostream_unicode(std::ostream& os, fmt::string_view data) {
inline auto write_ostream_unicode(std::ostream& os, fmt::string_view data)
-> bool {
FILE* f = nullptr;
#if FMT_MSC_VERSION
if (auto* buf = dynamic_cast<std::filebuf*>(os.rdbuf()))
if (FILE* f = get_file(*buf)) return write_console(f, data);
#elif defined(_WIN32) && defined(__GLIBCXX__)
auto* rdbuf = os.rdbuf();
FILE* c_file;
if (auto* fbuf = dynamic_cast<__gnu_cxx::stdio_sync_filebuf<char>*>(rdbuf))
c_file = fbuf->file();
else if (auto* fbuf = dynamic_cast<__gnu_cxx::stdio_filebuf<char>*>(rdbuf))
c_file = fbuf->file();
f = get_file(*buf);
else
return false;
#elif defined(_WIN32) && defined(__GLIBCXX__)
auto* rdbuf = os.rdbuf();
if (auto* sfbuf = dynamic_cast<__gnu_cxx::stdio_sync_filebuf<char>*>(rdbuf))
f = sfbuf->file();
else if (auto* fbuf = dynamic_cast<__gnu_cxx::stdio_filebuf<char>*>(rdbuf))
f = fbuf->file();
else
return false;
if (c_file) return write_console(c_file, data);
#elif defined(_WIN32) && defined(_LIBCPP_VERSION)
if (auto* buf = dynamic_cast<std::__stdoutbuf<char>*>(os.rdbuf()))
if (FILE* f = get_file(*buf)) return write_console(f, data);
#else
ignore_unused(os, data);
ignore_unused(os, data, f);
#endif
#ifdef _WIN32
if (f) {
int fd = _fileno(f);
if (_isatty(fd)) {
os.flush();
return write_console(fd, data);
}
}
#endif
return false;
}
inline bool write_ostream_unicode(std::wostream&,
fmt::basic_string_view<wchar_t>) {
inline auto write_ostream_unicode(std::wostream&,
fmt::basic_string_view<wchar_t>) -> bool {
return false;
}
@ -121,18 +122,19 @@ void write_buffer(std::basic_ostream<Char>& os, buffer<Char>& buf) {
}
template <typename Char, typename T>
void format_value(buffer<Char>& buf, const T& value,
locale_ref loc = locale_ref()) {
void format_value(buffer<Char>& buf, const T& value) {
auto&& format_buf = formatbuf<std::basic_streambuf<Char>>(buf);
auto&& output = std::basic_ostream<Char>(&format_buf);
#if !defined(FMT_STATIC_THOUSANDS_SEPARATOR)
if (loc) output.imbue(loc.get<std::locale>());
output.imbue(std::locale::classic()); // The default is always unlocalized.
#endif
output << value;
output.exceptions(std::ios_base::failbit | std::ios_base::badbit);
}
template <typename T> struct streamed_view { const T& value; };
template <typename T> struct streamed_view {
const T& value;
};
} // namespace detail
@ -145,7 +147,7 @@ struct basic_ostream_formatter : formatter<basic_string_view<Char>, Char> {
auto format(const T& value, basic_format_context<OutputIt, Char>& ctx) const
-> OutputIt {
auto buffer = basic_memory_buffer<Char>();
format_value(buffer, value, ctx.locale());
detail::format_value(buffer, value);
return formatter<basic_string_view<Char>, Char>::format(
{buffer.data(), buffer.size()}, ctx);
}
@ -174,19 +176,12 @@ struct formatter<detail::streamed_view<T>, Char>
\endrst
*/
template <typename T>
auto streamed(const T& value) -> detail::streamed_view<T> {
constexpr auto streamed(const T& value) -> detail::streamed_view<T> {
return {value};
}
namespace detail {
// Formats an object of type T that has an overloaded ostream operator<<.
template <typename T, typename Char>
struct fallback_formatter<T, Char, enable_if_t<is_streamable<T, Char>::value>>
: basic_ostream_formatter<Char> {
using basic_ostream_formatter<Char>::format;
};
inline void vprint_directly(std::ostream& os, string_view format_str,
format_args args) {
auto buffer = memory_buffer();
@ -196,7 +191,7 @@ inline void vprint_directly(std::ostream& os, string_view format_str,
} // namespace detail
FMT_MODULE_EXPORT template <typename Char>
FMT_EXPORT template <typename Char>
void vprint(std::basic_ostream<Char>& os,
basic_string_view<type_identity_t<Char>> format_str,
basic_format_args<buffer_context<type_identity_t<Char>>> args) {
@ -215,7 +210,7 @@ void vprint(std::basic_ostream<Char>& os,
fmt::print(cerr, "Don't {}!", "panic");
\endrst
*/
FMT_MODULE_EXPORT template <typename... T>
FMT_EXPORT template <typename... T>
void print(std::ostream& os, format_string<T...> fmt, T&&... args) {
const auto& vargs = fmt::make_format_args(args...);
if (detail::is_utf8())
@ -224,7 +219,7 @@ void print(std::ostream& os, format_string<T...> fmt, T&&... args) {
detail::vprint_directly(os, fmt, vargs);
}
FMT_MODULE_EXPORT
FMT_EXPORT
template <typename... Args>
void print(std::wostream& os,
basic_format_string<wchar_t, type_identity_t<Args>...> fmt,
@ -232,6 +227,19 @@ void print(std::wostream& os,
vprint(os, fmt, fmt::make_format_args<buffer_context<wchar_t>>(args...));
}
FMT_EXPORT template <typename... T>
void println(std::ostream& os, format_string<T...> fmt, T&&... args) {
fmt::print(os, "{}\n", fmt::format(fmt, std::forward<T>(args)...));
}
FMT_EXPORT
template <typename... Args>
void println(std::wostream& os,
basic_format_string<wchar_t, type_identity_t<Args>...> fmt,
Args&&... args) {
print(os, L"{}\n", fmt::format(fmt, std::forward<Args>(args)...));
}
FMT_END_NAMESPACE
#endif // FMT_OSTREAM_H_

385
include/fmt/printf.h
View File

@ -14,24 +14,24 @@
#include "format.h"
FMT_BEGIN_NAMESPACE
FMT_MODULE_EXPORT_BEGIN
FMT_BEGIN_EXPORT
template <typename T> struct printf_formatter { printf_formatter() = delete; };
template <typename Char>
class basic_printf_parse_context : public basic_format_parse_context<Char> {
using basic_format_parse_context<Char>::basic_format_parse_context;
template <typename T> struct printf_formatter {
printf_formatter() = delete;
};
template <typename OutputIt, typename Char> class basic_printf_context {
template <typename Char> class basic_printf_context {
private:
OutputIt out_;
detail::buffer_appender<Char> out_;
basic_format_args<basic_printf_context> args_;
static_assert(std::is_same<Char, char>::value ||
std::is_same<Char, wchar_t>::value,
"Unsupported code unit type.");
public:
using char_type = Char;
using format_arg = basic_format_arg<basic_printf_context>;
using parse_context_type = basic_printf_parse_context<Char>;
using parse_context_type = basic_format_parse_context<Char>;
template <typename T> using formatter_type = printf_formatter<T>;
/**
@ -40,75 +40,77 @@ template <typename OutputIt, typename Char> class basic_printf_context {
stored in the context object so make sure they have appropriate lifetimes.
\endrst
*/
basic_printf_context(OutputIt out,
basic_printf_context(detail::buffer_appender<Char> out,
basic_format_args<basic_printf_context> args)
: out_(out), args_(args) {}
OutputIt out() { return out_; }
void advance_to(OutputIt it) { out_ = it; }
auto out() -> detail::buffer_appender<Char> { return out_; }
void advance_to(detail::buffer_appender<Char>) {}
detail::locale_ref locale() { return {}; }
auto locale() -> detail::locale_ref { return {}; }
format_arg arg(int id) const { return args_.get(id); }
auto arg(int id) const -> basic_format_arg<basic_printf_context> {
return args_.get(id);
}
FMT_CONSTEXPR void on_error(const char* message) {
detail::error_handler().on_error(message);
}
};
FMT_BEGIN_DETAIL_NAMESPACE
namespace detail {
// Checks if a value fits in int - used to avoid warnings about comparing
// signed and unsigned integers.
template <bool IsSigned> struct int_checker {
template <typename T> static bool fits_in_int(T value) {
template <typename T> static auto fits_in_int(T value) -> bool {
unsigned max = max_value<int>();
return value <= max;
}
static bool fits_in_int(bool) { return true; }
static auto fits_in_int(bool) -> bool { return true; }
};
template <> struct int_checker<true> {
template <typename T> static bool fits_in_int(T value) {
template <typename T> static auto fits_in_int(T value) -> bool {
return value >= (std::numeric_limits<int>::min)() &&
value <= max_value<int>();
}
static bool fits_in_int(int) { return true; }
static auto fits_in_int(int) -> bool { return true; }
};
class printf_precision_handler {
public:
struct printf_precision_handler {
template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
int operator()(T value) {
auto operator()(T value) -> int {
if (!int_checker<std::numeric_limits<T>::is_signed>::fits_in_int(value))
FMT_THROW(format_error("number is too big"));
throw_format_error("number is too big");
return (std::max)(static_cast<int>(value), 0);
}
template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
int operator()(T) {
FMT_THROW(format_error("precision is not integer"));
auto operator()(T) -> int {
throw_format_error("precision is not integer");
return 0;
}
};
// An argument visitor that returns true iff arg is a zero integer.
class is_zero_int {
public:
struct is_zero_int {
template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
bool operator()(T value) {
auto operator()(T value) -> bool {
return value == 0;
}
template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
bool operator()(T) {
auto operator()(T) -> bool {
return false;
}
};
template <typename T> struct make_unsigned_or_bool : std::make_unsigned<T> {};
template <> struct make_unsigned_or_bool<bool> { using type = bool; };
template <> struct make_unsigned_or_bool<bool> {
using type = bool;
};
template <typename T, typename Context> class arg_converter {
private:
@ -132,22 +134,23 @@ template <typename T, typename Context> class arg_converter {
if (const_check(sizeof(target_type) <= sizeof(int))) {
// Extra casts are used to silence warnings.
if (is_signed) {
arg_ = detail::make_arg<Context>(
static_cast<int>(static_cast<target_type>(value)));
auto n = static_cast<int>(static_cast<target_type>(value));
arg_ = detail::make_arg<Context>(n);
} else {
using unsigned_type = typename make_unsigned_or_bool<target_type>::type;
arg_ = detail::make_arg<Context>(
static_cast<unsigned>(static_cast<unsigned_type>(value)));
auto n = static_cast<unsigned>(static_cast<unsigned_type>(value));
arg_ = detail::make_arg<Context>(n);
}
} else {
if (is_signed) {
// glibc's printf doesn't sign extend arguments of smaller types:
// std::printf("%lld", -42); // prints "4294967254"
// but we don't have to do the same because it's a UB.
arg_ = detail::make_arg<Context>(static_cast<long long>(value));
auto n = static_cast<long long>(value);
arg_ = detail::make_arg<Context>(n);
} else {
arg_ = detail::make_arg<Context>(
static_cast<typename make_unsigned_or_bool<U>::type>(value));
auto n = static_cast<typename make_unsigned_or_bool<U>::type>(value);
arg_ = detail::make_arg<Context>(n);
}
}
}
@ -175,8 +178,8 @@ template <typename Context> class char_converter {
template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
void operator()(T value) {
arg_ = detail::make_arg<Context>(
static_cast<typename Context::char_type>(value));
auto c = static_cast<typename Context::char_type>(value);
arg_ = detail::make_arg<Context>(c);
}
template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
@ -186,122 +189,131 @@ template <typename Context> class char_converter {
// An argument visitor that return a pointer to a C string if argument is a
// string or null otherwise.
template <typename Char> struct get_cstring {
template <typename T> const Char* operator()(T) { return nullptr; }
const Char* operator()(const Char* s) { return s; }
template <typename T> auto operator()(T) -> const Char* { return nullptr; }
auto operator()(const Char* s) -> const Char* { return s; }
};
// Checks if an argument is a valid printf width specifier and sets
// left alignment if it is negative.
template <typename Char> class printf_width_handler {
private:
using format_specs = basic_format_specs<Char>;
format_specs& specs_;
format_specs<Char>& specs_;
public:
explicit printf_width_handler(format_specs& specs) : specs_(specs) {}
explicit printf_width_handler(format_specs<Char>& specs) : specs_(specs) {}
template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
unsigned operator()(T value) {
auto operator()(T value) -> unsigned {
auto width = static_cast<uint32_or_64_or_128_t<T>>(value);
if (detail::is_negative(value)) {
specs_.align = align::left;
width = 0 - width;
}
unsigned int_max = max_value<int>();
if (width > int_max) FMT_THROW(format_error("number is too big"));
if (width > int_max) throw_format_error("number is too big");
return static_cast<unsigned>(width);
}
template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
unsigned operator()(T) {
FMT_THROW(format_error("width is not integer"));
auto operator()(T) -> unsigned {
throw_format_error("width is not integer");
return 0;
}
};
// Workaround for a bug with the XL compiler when initializing
// printf_arg_formatter's base class.
template <typename Char>
auto make_arg_formatter(buffer_appender<Char> iter, format_specs<Char>& s)
-> arg_formatter<Char> {
return {iter, s, locale_ref()};
}
// The ``printf`` argument formatter.
template <typename OutputIt, typename Char>
template <typename Char>
class printf_arg_formatter : public arg_formatter<Char> {
private:
using base = arg_formatter<Char>;
using context_type = basic_printf_context<OutputIt, Char>;
using format_specs = basic_format_specs<Char>;
using context_type = basic_printf_context<Char>;
context_type& context_;
OutputIt write_null_pointer(bool is_string = false) {
void write_null_pointer(bool is_string = false) {
auto s = this->specs;
s.type = presentation_type::none;
return write_bytes(this->out, is_string ? "(null)" : "(nil)", s);
write_bytes(this->out, is_string ? "(null)" : "(nil)", s);
}
public:
printf_arg_formatter(OutputIt iter, format_specs& s, context_type& ctx)
: base{iter, s, locale_ref()}, context_(ctx) {}
printf_arg_formatter(buffer_appender<Char> iter, format_specs<Char>& s,
context_type& ctx)
: base(make_arg_formatter(iter, s)), context_(ctx) {}
OutputIt operator()(monostate value) { return base::operator()(value); }
void operator()(monostate value) { base::operator()(value); }
template <typename T, FMT_ENABLE_IF(detail::is_integral<T>::value)>
OutputIt operator()(T value) {
void operator()(T value) {
// MSVC2013 fails to compile separate overloads for bool and Char so use
// std::is_same instead.
if (std::is_same<T, Char>::value) {
format_specs fmt_specs = this->specs;
if (fmt_specs.type != presentation_type::none &&
fmt_specs.type != presentation_type::chr) {
return (*this)(static_cast<int>(value));
}
fmt_specs.sign = sign::none;
fmt_specs.alt = false;
fmt_specs.fill[0] = ' '; // Ignore '0' flag for char types.
// align::numeric needs to be overwritten here since the '0' flag is
// ignored for non-numeric types
if (fmt_specs.align == align::none || fmt_specs.align == align::numeric)
fmt_specs.align = align::right;
return write<Char>(this->out, static_cast<Char>(value), fmt_specs);
if (!std::is_same<T, Char>::value) {
base::operator()(value);
return;
}
return base::operator()(value);
format_specs<Char> fmt_specs = this->specs;
if (fmt_specs.type != presentation_type::none &&
fmt_specs.type != presentation_type::chr) {
return (*this)(static_cast<int>(value));
}
fmt_specs.sign = sign::none;
fmt_specs.alt = false;
fmt_specs.fill[0] = ' '; // Ignore '0' flag for char types.
// align::numeric needs to be overwritten here since the '0' flag is
// ignored for non-numeric types
if (fmt_specs.align == align::none || fmt_specs.align == align::numeric)
fmt_specs.align = align::right;
write<Char>(this->out, static_cast<Char>(value), fmt_specs);
}
template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
OutputIt operator()(T value) {
return base::operator()(value);
void operator()(T value) {
base::operator()(value);
}
/** Formats a null-terminated C string. */
OutputIt operator()(const char* value) {
if (value) return base::operator()(value);
return write_null_pointer(this->specs.type != presentation_type::pointer);
void operator()(const char* value) {
if (value)
base::operator()(value);
else
write_null_pointer(this->specs.type != presentation_type::pointer);
}
/** Formats a null-terminated wide C string. */
OutputIt operator()(const wchar_t* value) {
if (value) return base::operator()(value);
return write_null_pointer(this->specs.type != presentation_type::pointer);
void operator()(const wchar_t* value) {
if (value)
base::operator()(value);
else
write_null_pointer(this->specs.type != presentation_type::pointer);
}
OutputIt operator()(basic_string_view<Char> value) {
return base::operator()(value);
}
void operator()(basic_string_view<Char> value) { base::operator()(value); }
/** Formats a pointer. */
OutputIt operator()(const void* value) {
return value ? base::operator()(value) : write_null_pointer();
void operator()(const void* value) {
if (value)
base::operator()(value);
else
write_null_pointer();
}
/** Formats an argument of a custom (user-defined) type. */
OutputIt operator()(typename basic_format_arg<context_type>::handle handle) {
auto parse_ctx =
basic_printf_parse_context<Char>(basic_string_view<Char>());
void operator()(typename basic_format_arg<context_type>::handle handle) {
auto parse_ctx = basic_format_parse_context<Char>({});
handle.format(parse_ctx, context_);
return this->out;
}
};
template <typename Char>
void parse_flags(basic_format_specs<Char>& specs, const Char*& it,
const Char* end) {
void parse_flags(format_specs<Char>& specs, const Char*& it, const Char* end) {
for (; it != end; ++it) {
switch (*it) {
case '-':
@ -314,9 +326,7 @@ void parse_flags(basic_format_specs<Char>& specs, const Char*& it,
specs.fill[0] = '0';
break;
case ' ':
if (specs.sign != sign::plus) {
specs.sign = sign::space;
}
if (specs.sign != sign::plus) specs.sign = sign::space;
break;
case '#':
specs.alt = true;
@ -328,8 +338,8 @@ void parse_flags(basic_format_specs<Char>& specs, const Char*& it,
}
template <typename Char, typename GetArg>
int parse_header(const Char*& it, const Char* end,
basic_format_specs<Char>& specs, GetArg get_arg) {
auto parse_header(const Char*& it, const Char* end, format_specs<Char>& specs,
GetArg get_arg) -> int {
int arg_index = -1;
Char c = *it;
if (c >= '0' && c <= '9') {
@ -344,7 +354,7 @@ int parse_header(const Char*& it, const Char* end,
if (value != 0) {
// Nonzero value means that we parsed width and don't need to
// parse it or flags again, so return now.
if (value == -1) FMT_THROW(format_error("number is too big"));
if (value == -1) throw_format_error("number is too big");
specs.width = value;
return arg_index;
}
@ -355,7 +365,7 @@ int parse_header(const Char*& it, const Char* end,
if (it != end) {
if (*it >= '0' && *it <= '9') {
specs.width = parse_nonnegative_int(it, end, -1);
if (specs.width == -1) FMT_THROW(format_error("number is too big"));
if (specs.width == -1) throw_format_error("number is too big");
} else if (*it == '*') {
++it;
specs.width = static_cast<int>(visit_format_arg(
@ -365,13 +375,53 @@ int parse_header(const Char*& it, const Char* end,
return arg_index;
}
inline auto parse_printf_presentation_type(char c, type t)
-> presentation_type {
using pt = presentation_type;
constexpr auto integral_set = sint_set | uint_set | bool_set | char_set;
switch (c) {
case 'd':
return in(t, integral_set) ? pt::dec : pt::none;
case 'o':
return in(t, integral_set) ? pt::oct : pt::none;
case 'x':
return in(t, integral_set) ? pt::hex_lower : pt::none;
case 'X':
return in(t, integral_set) ? pt::hex_upper : pt::none;
case 'a':
return in(t, float_set) ? pt::hexfloat_lower : pt::none;
case 'A':
return in(t, float_set) ? pt::hexfloat_upper : pt::none;
case 'e':
return in(t, float_set) ? pt::exp_lower : pt::none;
case 'E':
return in(t, float_set) ? pt::exp_upper : pt::none;
case 'f':
return in(t, float_set) ? pt::fixed_lower : pt::none;
case 'F':
return in(t, float_set) ? pt::fixed_upper : pt::none;
case 'g':
return in(t, float_set) ? pt::general_lower : pt::none;
case 'G':
return in(t, float_set) ? pt::general_upper : pt::none;
case 'c':
return in(t, integral_set) ? pt::chr : pt::none;
case 's':
return in(t, string_set | cstring_set) ? pt::string : pt::none;
case 'p':
return in(t, pointer_set | cstring_set) ? pt::pointer : pt::none;
default:
return pt::none;
}
}
template <typename Char, typename Context>
void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
basic_format_args<Context> args) {
using OutputIt = buffer_appender<Char>;
auto out = OutputIt(buf);
auto context = basic_printf_context<OutputIt, Char>(out, args);
auto parse_ctx = basic_printf_parse_context<Char>(format);
using iterator = buffer_appender<Char>;
auto out = iterator(buf);
auto context = basic_printf_context<Char>(out, args);
auto parse_ctx = basic_format_parse_context<Char>(format);
// Returns the argument with specified index or, if arg_index is -1, the next
// argument.
@ -387,26 +437,24 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
const Char* end = parse_ctx.end();
auto it = start;
while (it != end) {
if (!detail::find<false, Char>(it, end, '%', it)) {
it = end; // detail::find leaves it == nullptr if it doesn't find '%'
if (!find<false, Char>(it, end, '%', it)) {
it = end; // find leaves it == nullptr if it doesn't find '%'.
break;
}
Char c = *it++;
if (it != end && *it == c) {
out = detail::write(
out, basic_string_view<Char>(start, detail::to_unsigned(it - start)));
write(out, basic_string_view<Char>(start, to_unsigned(it - start)));
start = ++it;
continue;
}
out = detail::write(out, basic_string_view<Char>(
start, detail::to_unsigned(it - 1 - start)));
write(out, basic_string_view<Char>(start, to_unsigned(it - 1 - start)));
basic_format_specs<Char> specs;
auto specs = format_specs<Char>();
specs.align = align::right;
// Parse argument index, flags and width.
int arg_index = parse_header(it, end, specs, get_arg);
if (arg_index == 0) parse_ctx.on_error("argument not found");
if (arg_index == 0) throw_format_error("argument not found");
// Parse precision.
if (it != end && *it == '.') {
@ -417,7 +465,7 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
} else if (c == '*') {
++it;
specs.precision = static_cast<int>(
visit_format_arg(detail::printf_precision_handler(), get_arg(-1)));
visit_format_arg(printf_precision_handler(), get_arg(-1)));
} else {
specs.precision = 0;
}
@ -426,20 +474,19 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
auto arg = get_arg(arg_index);
// For d, i, o, u, x, and X conversion specifiers, if a precision is
// specified, the '0' flag is ignored
if (specs.precision >= 0 && arg.is_integral())
specs.fill[0] =
' '; // Ignore '0' flag for non-numeric types or if '-' present.
if (specs.precision >= 0 && arg.type() == detail::type::cstring_type) {
auto str = visit_format_arg(detail::get_cstring<Char>(), arg);
if (specs.precision >= 0 && arg.is_integral()) {
// Ignore '0' for non-numeric types or if '-' present.
specs.fill[0] = ' ';
}
if (specs.precision >= 0 && arg.type() == type::cstring_type) {
auto str = visit_format_arg(get_cstring<Char>(), arg);
auto str_end = str + specs.precision;
auto nul = std::find(str, str_end, Char());
arg = detail::make_arg<basic_printf_context<OutputIt, Char>>(
basic_string_view<Char>(
str, detail::to_unsigned(nul != str_end ? nul - str
: specs.precision)));
auto sv = basic_string_view<Char>(
str, to_unsigned(nul != str_end ? nul - str : specs.precision));
arg = make_arg<basic_printf_context<Char>>(sv);
}
if (specs.alt && visit_format_arg(detail::is_zero_int(), arg))
specs.alt = false;
if (specs.alt && visit_format_arg(is_zero_int(), arg)) specs.alt = false;
if (specs.fill[0] == '0') {
if (arg.is_arithmetic() && specs.align != align::left)
specs.align = align::numeric;
@ -451,7 +498,6 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
// Parse length and convert the argument to the required type.
c = it != end ? *it++ : 0;
Char t = it != end ? *it : 0;
using detail::convert_arg;
switch (c) {
case 'h':
if (t == 'h') {
@ -490,7 +536,7 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
}
// Parse type.
if (it == end) FMT_THROW(format_error("invalid format string"));
if (it == end) throw_format_error("invalid format string");
char type = static_cast<char>(*it++);
if (arg.is_integral()) {
// Normalize type.
@ -500,32 +546,25 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
type = 'd';
break;
case 'c':
visit_format_arg(
detail::char_converter<basic_printf_context<OutputIt, Char>>(arg),
arg);
visit_format_arg(char_converter<basic_printf_context<Char>>(arg), arg);
break;
}
}
specs.type = parse_presentation_type(type);
specs.type = parse_printf_presentation_type(type, arg.type());
if (specs.type == presentation_type::none)
parse_ctx.on_error("invalid type specifier");
throw_format_error("invalid format specifier");
start = it;
// Format argument.
out = visit_format_arg(
detail::printf_arg_formatter<OutputIt, Char>(out, specs, context), arg);
visit_format_arg(printf_arg_formatter<Char>(out, specs, context), arg);
}
detail::write(out, basic_string_view<Char>(start, to_unsigned(it - start)));
write(out, basic_string_view<Char>(start, to_unsigned(it - start)));
}
FMT_END_DETAIL_NAMESPACE
} // namespace detail
template <typename Char>
using basic_printf_context_t =
basic_printf_context<detail::buffer_appender<Char>, Char>;
using printf_context = basic_printf_context_t<char>;
using wprintf_context = basic_printf_context_t<wchar_t>;
using printf_context = basic_printf_context<char>;
using wprintf_context = basic_printf_context<wchar_t>;
using printf_args = basic_format_args<printf_context>;
using wprintf_args = basic_format_args<wprintf_context>;
@ -542,26 +581,21 @@ inline auto make_printf_args(const T&... args)
return {args...};
}
/**
\rst
Constructs an `~fmt::format_arg_store` object that contains references to
arguments and can be implicitly converted to `~fmt::wprintf_args`.
\endrst
*/
// DEPRECATED!
template <typename... T>
inline auto make_wprintf_args(const T&... args)
-> format_arg_store<wprintf_context, T...> {
return {args...};
}
template <typename S, typename Char = char_t<S>>
template <typename Char>
inline auto vsprintf(
const S& fmt,
basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args)
basic_string_view<Char> fmt,
basic_format_args<basic_printf_context<type_identity_t<Char>>> args)
-> std::basic_string<Char> {
basic_memory_buffer<Char> buffer;
vprintf(buffer, detail::to_string_view(fmt), args);
return to_string(buffer);
auto buf = basic_memory_buffer<Char>();
detail::vprintf(buf, fmt, args);
return to_string(buf);
}
/**
@ -576,20 +610,19 @@ inline auto vsprintf(
template <typename S, typename... T,
typename Char = enable_if_t<detail::is_string<S>::value, char_t<S>>>
inline auto sprintf(const S& fmt, const T&... args) -> std::basic_string<Char> {
using context = basic_printf_context_t<Char>;
return vsprintf(detail::to_string_view(fmt),
fmt::make_format_args<context>(args...));
fmt::make_format_args<basic_printf_context<Char>>(args...));
}
template <typename S, typename Char = char_t<S>>
template <typename Char>
inline auto vfprintf(
std::FILE* f, const S& fmt,
basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args)
std::FILE* f, basic_string_view<Char> fmt,
basic_format_args<basic_printf_context<type_identity_t<Char>>> args)
-> int {
basic_memory_buffer<Char> buffer;
vprintf(buffer, detail::to_string_view(fmt), args);
size_t size = buffer.size();
return std::fwrite(buffer.data(), sizeof(Char), size, f) < size
auto buf = basic_memory_buffer<Char>();
detail::vprintf(buf, fmt, args);
size_t size = buf.size();
return std::fwrite(buf.data(), sizeof(Char), size, f) < size
? -1
: static_cast<int>(size);
}
@ -605,17 +638,16 @@ inline auto vfprintf(
*/
template <typename S, typename... T, typename Char = char_t<S>>
inline auto fprintf(std::FILE* f, const S& fmt, const T&... args) -> int {
using context = basic_printf_context_t<Char>;
return vfprintf(f, detail::to_string_view(fmt),
fmt::make_format_args<context>(args...));
fmt::make_format_args<basic_printf_context<Char>>(args...));
}
template <typename S, typename Char = char_t<S>>
inline auto vprintf(
const S& fmt,
basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args)
template <typename Char>
FMT_DEPRECATED inline auto vprintf(
basic_string_view<Char> fmt,
basic_format_args<basic_printf_context<type_identity_t<Char>>> args)
-> int {
return vfprintf(stdout, detail::to_string_view(fmt), args);
return vfprintf(stdout, fmt, args);
}
/**
@ -627,14 +659,17 @@ inline auto vprintf(
fmt::printf("Elapsed time: %.2f seconds", 1.23);
\endrst
*/
template <typename S, typename... T, FMT_ENABLE_IF(detail::is_string<S>::value)>
inline auto printf(const S& fmt, const T&... args) -> int {
return vprintf(
detail::to_string_view(fmt),
fmt::make_format_args<basic_printf_context_t<char_t<S>>>(args...));
template <typename... T>
inline auto printf(string_view fmt, const T&... args) -> int {
return vfprintf(stdout, fmt, make_printf_args(args...));
}
template <typename... T>
FMT_DEPRECATED inline auto printf(basic_string_view<wchar_t> fmt,
const T&... args) -> int {
return vfprintf(stdout, fmt, make_wprintf_args(args...));
}
FMT_MODULE_EXPORT_END
FMT_END_EXPORT
FMT_END_NAMESPACE
#endif // FMT_PRINTF_H_

324
include/fmt/ranges.h
View File

@ -1,13 +1,9 @@
// Formatting library for C++ - experimental range support
// Formatting library for C++ - range and tuple support
//
// Copyright (c) 2012 - present, Victor Zverovich
// Copyright (c) 2012 - present, Victor Zverovich and {fmt} contributors
// All rights reserved.
//
// For the license information refer to format.h.
//
// Copyright (c) 2018 - present, Remotion (Igor Schulz)
// All Rights Reserved
// {fmt} support for ranges, containers and types tuple interface.
#ifndef FMT_RANGES_H_
#define FMT_RANGES_H_
@ -22,27 +18,25 @@ FMT_BEGIN_NAMESPACE
namespace detail {
template <typename RangeT, typename OutputIterator>
OutputIterator copy(const RangeT& range, OutputIterator out) {
template <typename Range, typename OutputIt>
auto copy(const Range& range, OutputIt out) -> OutputIt {
for (auto it = range.begin(), end = range.end(); it != end; ++it)
*out++ = *it;
return out;
}
template <typename OutputIterator>
OutputIterator copy(const char* str, OutputIterator out) {
template <typename OutputIt>
auto copy(const char* str, OutputIt out) -> OutputIt {
while (*str) *out++ = *str++;
return out;
}
template <typename OutputIterator>
OutputIterator copy(char ch, OutputIterator out) {
template <typename OutputIt> auto copy(char ch, OutputIt out) -> OutputIt {
*out++ = ch;
return out;
}
template <typename OutputIterator>
OutputIterator copy(wchar_t ch, OutputIterator out) {
template <typename OutputIt> auto copy(wchar_t ch, OutputIt out) -> OutputIt {
*out++ = ch;
return out;
}
@ -69,7 +63,7 @@ template <typename T> class is_map {
template <typename> static void check(...);
public:
#ifdef FMT_FORMAT_MAP_AS_LIST
#ifdef FMT_FORMAT_MAP_AS_LIST // DEPRECATED!
static constexpr const bool value = false;
#else
static constexpr const bool value =
@ -82,7 +76,7 @@ template <typename T> class is_set {
template <typename> static void check(...);
public:
#ifdef FMT_FORMAT_SET_AS_LIST
#ifdef FMT_FORMAT_SET_AS_LIST // DEPRECATED!
static constexpr const bool value = false;
#else
static constexpr const bool value =
@ -157,8 +151,9 @@ template <typename T>
struct has_mutable_begin_end<
T, void_t<decltype(detail::range_begin(std::declval<T>())),
decltype(detail::range_end(std::declval<T>())),
enable_if_t<std::is_copy_constructible<T>::value>>>
: std::true_type {};
// the extra int here is because older versions of MSVC don't
// SFINAE properly unless there are distinct types
int>> : std::true_type {};
template <typename T>
struct is_range_<T, void>
@ -188,7 +183,7 @@ template <size_t N> using make_index_sequence = std::make_index_sequence<N>;
template <typename T, T... N> struct integer_sequence {
using value_type = T;
static FMT_CONSTEXPR size_t size() { return sizeof...(N); }
static FMT_CONSTEXPR auto size() -> size_t { return sizeof...(N); }
};
template <size_t... N> using index_sequence = integer_sequence<size_t, N...>;
@ -211,41 +206,61 @@ class is_tuple_formattable_ {
static constexpr const bool value = false;
};
template <typename T, typename C> class is_tuple_formattable_<T, C, true> {
template <std::size_t... I>
static std::true_type check2(index_sequence<I...>,
integer_sequence<bool, (I == I)...>);
static std::false_type check2(...);
template <std::size_t... I>
static decltype(check2(
index_sequence<I...>{},
integer_sequence<
bool, (is_formattable<typename std::tuple_element<I, T>::type,
C>::value)...>{})) check(index_sequence<I...>);
template <std::size_t... Is>
static auto check2(index_sequence<Is...>,
integer_sequence<bool, (Is == Is)...>) -> std::true_type;
static auto check2(...) -> std::false_type;
template <std::size_t... Is>
static auto check(index_sequence<Is...>) -> decltype(check2(
index_sequence<Is...>{},
integer_sequence<bool,
(is_formattable<typename std::tuple_element<Is, T>::type,
C>::value)...>{}));
public:
static constexpr const bool value =
decltype(check(tuple_index_sequence<T>{}))::value;
};
template <class Tuple, class F, size_t... Is>
void for_each(index_sequence<Is...>, Tuple&& tup, F&& f) noexcept {
template <typename Tuple, typename F, size_t... Is>
FMT_CONSTEXPR void for_each(index_sequence<Is...>, Tuple&& t, F&& f) {
using std::get;
// using free function get<I>(T) now.
const int _[] = {0, ((void)f(get<Is>(tup)), 0)...};
(void)_; // blocks warnings
// Using a free function get<Is>(Tuple) now.
const int unused[] = {0, ((void)f(get<Is>(t)), 0)...};
ignore_unused(unused);
}
template <class T>
FMT_CONSTEXPR make_index_sequence<std::tuple_size<T>::value> get_indexes(
T const&) {
return {};
template <typename Tuple, typename F>
FMT_CONSTEXPR void for_each(Tuple&& t, F&& f) {
for_each(tuple_index_sequence<remove_cvref_t<Tuple>>(),
std::forward<Tuple>(t), std::forward<F>(f));
}
template <class Tuple, class F> void for_each(Tuple&& tup, F&& f) {
const auto indexes = get_indexes(tup);
for_each(indexes, std::forward<Tuple>(tup), std::forward<F>(f));
template <typename Tuple1, typename Tuple2, typename F, size_t... Is>
void for_each2(index_sequence<Is...>, Tuple1&& t1, Tuple2&& t2, F&& f) {
using std::get;
const int unused[] = {0, ((void)f(get<Is>(t1), get<Is>(t2)), 0)...};
ignore_unused(unused);
}
template <typename Tuple1, typename Tuple2, typename F>
void for_each2(Tuple1&& t1, Tuple2&& t2, F&& f) {
for_each2(tuple_index_sequence<remove_cvref_t<Tuple1>>(),
std::forward<Tuple1>(t1), std::forward<Tuple2>(t2),
std::forward<F>(f));
}
namespace tuple {
// Workaround a bug in MSVC 2019 (v140).
template <typename Char, typename... T>
using result_t = std::tuple<formatter<remove_cvref_t<T>, Char>...>;
using std::get;
template <typename Tuple, typename Char, std::size_t... Is>
auto get_formatters(index_sequence<Is...>)
-> result_t<Char, decltype(get<Is>(std::declval<Tuple>()))...>;
} // namespace tuple
#if FMT_MSC_VERSION && FMT_MSC_VERSION < 1920
// Older MSVC doesn't get the reference type correctly for arrays.
template <typename R> struct range_reference_type_impl {
@ -269,45 +284,37 @@ using range_reference_type =
template <typename Range>
using uncvref_type = remove_cvref_t<range_reference_type<Range>>;
template <typename Range>
using uncvref_first_type =
remove_cvref_t<decltype(std::declval<range_reference_type<Range>>().first)>;
template <typename Range>
using uncvref_second_type = remove_cvref_t<
decltype(std::declval<range_reference_type<Range>>().second)>;
template <typename OutputIt> OutputIt write_delimiter(OutputIt out) {
*out++ = ',';
*out++ = ' ';
return out;
template <typename Formatter>
FMT_CONSTEXPR auto maybe_set_debug_format(Formatter& f, bool set)
-> decltype(f.set_debug_format(set)) {
f.set_debug_format(set);
}
template <typename Formatter>
FMT_CONSTEXPR void maybe_set_debug_format(Formatter&, ...) {}
template <typename Char, typename OutputIt>
auto write_range_entry(OutputIt out, basic_string_view<Char> str) -> OutputIt {
return write_escaped_string(out, str);
}
// These are not generic lambdas for compatibility with C++11.
template <typename ParseContext> struct parse_empty_specs {
template <typename Formatter> FMT_CONSTEXPR void operator()(Formatter& f) {
f.parse(ctx);
detail::maybe_set_debug_format(f, true);
}
ParseContext& ctx;
};
template <typename FormatContext> struct format_tuple_element {
using char_type = typename FormatContext::char_type;
template <typename Char, typename OutputIt, typename T,
FMT_ENABLE_IF(std::is_convertible<T, std_string_view<char>>::value)>
inline auto write_range_entry(OutputIt out, const T& str) -> OutputIt {
auto sv = std_string_view<Char>(str);
return write_range_entry<Char>(out, basic_string_view<Char>(sv));
}
template <typename T>
void operator()(const formatter<T, char_type>& f, const T& v) {
if (i > 0)
ctx.advance_to(detail::copy_str<char_type>(separator, ctx.out()));
ctx.advance_to(f.format(v, ctx));
++i;
}
template <typename Char, typename OutputIt, typename Arg,
FMT_ENABLE_IF(std::is_same<Arg, Char>::value)>
OutputIt write_range_entry(OutputIt out, const Arg v) {
return write_escaped_char(out, v);
}
template <
typename Char, typename OutputIt, typename Arg,
FMT_ENABLE_IF(!is_std_string_like<typename std::decay<Arg>::type>::value &&
!std::is_same<Arg, Char>::value)>
OutputIt write_range_entry(OutputIt out, const Arg& v) {
return write<Char>(out, v);
}
int i;
FormatContext& ctx;
basic_string_view<char_type> separator;
};
} // namespace detail
@ -321,29 +328,20 @@ template <typename T, typename C> struct is_tuple_formattable {
detail::is_tuple_formattable_<T, C>::value;
};
template <typename TupleT, typename Char>
struct formatter<TupleT, Char,
enable_if_t<fmt::is_tuple_like<TupleT>::value &&
fmt::is_tuple_formattable<TupleT, Char>::value>> {
template <typename Tuple, typename Char>
struct formatter<Tuple, Char,
enable_if_t<fmt::is_tuple_like<Tuple>::value &&
fmt::is_tuple_formattable<Tuple, Char>::value>> {
private:
decltype(detail::tuple::get_formatters<Tuple, Char>(
detail::tuple_index_sequence<Tuple>())) formatters_;
basic_string_view<Char> separator_ = detail::string_literal<Char, ',', ' '>{};
basic_string_view<Char> opening_bracket_ =
detail::string_literal<Char, '('>{};
basic_string_view<Char> closing_bracket_ =
detail::string_literal<Char, ')'>{};
// C++11 generic lambda for format().
template <typename FormatContext> struct format_each {
template <typename T> void operator()(const T& v) {
if (i > 0) out = detail::copy_str<Char>(separator, out);
out = detail::write_range_entry<Char>(out, v);
++i;
}
int i;
typename FormatContext::iterator& out;
basic_string_view<Char> separator;
};
public:
FMT_CONSTEXPR formatter() {}
@ -359,17 +357,21 @@ struct formatter<TupleT, Char,
template <typename ParseContext>
FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
return ctx.begin();
auto it = ctx.begin();
if (it != ctx.end() && *it != '}')
FMT_THROW(format_error("invalid format specifier"));
detail::for_each(formatters_, detail::parse_empty_specs<ParseContext>{ctx});
return it;
}
template <typename FormatContext = format_context>
auto format(const TupleT& values, FormatContext& ctx) const
template <typename FormatContext>
auto format(const Tuple& value, FormatContext& ctx) const
-> decltype(ctx.out()) {
auto out = ctx.out();
out = detail::copy_str<Char>(opening_bracket_, out);
detail::for_each(values, format_each<FormatContext>{0, out, separator_});
out = detail::copy_str<Char>(closing_bracket_, out);
return out;
ctx.advance_to(detail::copy_str<Char>(opening_bracket_, ctx.out()));
detail::for_each2(
formatters_, value,
detail::format_tuple_element<FormatContext>{0, ctx, separator_});
return detail::copy_str<Char>(closing_bracket_, ctx.out());
}
};
@ -398,12 +400,10 @@ template <typename Context> struct range_mapper {
};
template <typename Char, typename Element>
using range_formatter_type = conditional_t<
is_formattable<Element, Char>::value,
using range_formatter_type =
formatter<remove_cvref_t<decltype(range_mapper<buffer_context<Char>>{}.map(
std::declval<Element>()))>,
Char>,
fallback_formatter<Element, Char>>;
Char>;
template <typename R>
using maybe_const_range =
@ -413,45 +413,32 @@ using maybe_const_range =
#if !FMT_MSC_VERSION || FMT_MSC_VERSION >= 1910
template <typename R, typename Char>
struct is_formattable_delayed
: disjunction<
is_formattable<uncvref_type<maybe_const_range<R>>, Char>,
has_fallback_formatter<uncvref_type<maybe_const_range<R>>, Char>> {};
: is_formattable<uncvref_type<maybe_const_range<R>>, Char> {};
#endif
} // namespace detail
template <typename...> struct conjunction : std::true_type {};
template <typename P> struct conjunction<P> : P {};
template <typename P1, typename... Pn>
struct conjunction<P1, Pn...>
: conditional_t<bool(P1::value), conjunction<Pn...>, P1> {};
template <typename T, typename Char, typename Enable = void>
struct range_formatter;
template <typename T, typename Char>
struct range_formatter<
T, Char,
enable_if_t<conjunction<
std::is_same<T, remove_cvref_t<T>>,
disjunction<is_formattable<T, Char>,
detail::has_fallback_formatter<T, Char>>>::value>> {
enable_if_t<conjunction<std::is_same<T, remove_cvref_t<T>>,
is_formattable<T, Char>>::value>> {
private:
detail::range_formatter_type<Char, T> underlying_;
bool custom_specs_ = false;
basic_string_view<Char> separator_ = detail::string_literal<Char, ',', ' '>{};
basic_string_view<Char> opening_bracket_ =
detail::string_literal<Char, '['>{};
basic_string_view<Char> closing_bracket_ =
detail::string_literal<Char, ']'>{};
template <class U>
FMT_CONSTEXPR static auto maybe_set_debug_format(U& u, int)
-> decltype(u.set_debug_format()) {
u.set_debug_format();
}
template <class U>
FMT_CONSTEXPR static void maybe_set_debug_format(U&, ...) {}
FMT_CONSTEXPR void maybe_set_debug_format() {
maybe_set_debug_format(underlying_, 0);
}
public:
FMT_CONSTEXPR range_formatter() {}
@ -473,31 +460,24 @@ struct range_formatter<
FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
auto it = ctx.begin();
auto end = ctx.end();
if (it == end || *it == '}') {
maybe_set_debug_format();
return it;
}
if (*it == 'n') {
if (it != end && *it == 'n') {
set_brackets({}, {});
++it;
}
if (*it == '}') {
maybe_set_debug_format();
return it;
if (it != end && *it != '}') {
if (*it != ':') FMT_THROW(format_error("invalid format specifier"));
++it;
} else {
detail::maybe_set_debug_format(underlying_, true);
}
if (*it != ':')
FMT_THROW(format_error("no other top-level range formatters supported"));
custom_specs_ = true;
++it;
ctx.advance_to(it);
return underlying_.parse(ctx);
}
template <typename R, class FormatContext>
template <typename R, typename FormatContext>
auto format(R&& range, FormatContext& ctx) const -> decltype(ctx.out()) {
detail::range_mapper<buffer_context<Char>> mapper;
auto out = ctx.out();
@ -507,9 +487,9 @@ struct range_formatter<
auto end = detail::range_end(range);
for (; it != end; ++it) {
if (i > 0) out = detail::copy_str<Char>(separator_, out);
;
ctx.advance_to(out);
out = underlying_.format(mapper.map(*it), ctx);
auto&& item = *it;
out = underlying_.format(mapper.map(item), ctx);
++i;
}
out = detail::copy_str<Char>(closing_bracket_, out);
@ -520,13 +500,14 @@ struct range_formatter<
enum class range_format { disabled, map, set, sequence, string, debug_string };
namespace detail {
template <typename T> struct range_format_kind_ {
static constexpr auto value = std::is_same<range_reference_type<T>, T>::value
? range_format::disabled
: is_map<T>::value ? range_format::map
: is_set<T>::value ? range_format::set
: range_format::sequence;
};
template <typename T>
struct range_format_kind_
: std::integral_constant<range_format,
std::is_same<uncvref_type<T>, T>::value
? range_format::disabled
: is_map<T>::value ? range_format::map
: is_set<T>::value ? range_format::set
: range_format::sequence> {};
template <range_format K, typename R, typename Char, typename Enable = void>
struct range_default_formatter;
@ -601,9 +582,6 @@ template <typename Char, typename... T> struct tuple_join_view : detail::view {
: tuple(t), sep{s} {}
};
template <typename Char, typename... T>
using tuple_arg_join = tuple_join_view<Char, T...>;
// Define FMT_TUPLE_JOIN_SPECIFIERS to enable experimental format specifiers
// support in tuple_join. It is disabled by default because of issues with
// the dynamic width and precision.
@ -673,7 +651,45 @@ struct formatter<tuple_join_view<Char, T...>, Char> {
}
};
FMT_MODULE_EXPORT_BEGIN
namespace detail {
// Check if T has an interface like a container adaptor (e.g. std::stack,
// std::queue, std::priority_queue).
template <typename T> class is_container_adaptor_like {
template <typename U> static auto check(U* p) -> typename U::container_type;
template <typename> static void check(...);
public:
static constexpr const bool value =
!std::is_void<decltype(check<T>(nullptr))>::value;
};
template <typename Container> struct all {
const Container& c;
auto begin() const -> typename Container::const_iterator { return c.begin(); }
auto end() const -> typename Container::const_iterator { return c.end(); }
};
} // namespace detail
template <typename T, typename Char>
struct formatter<
T, Char,
enable_if_t<conjunction<detail::is_container_adaptor_like<T>,
bool_constant<range_format_kind<T, Char>::value ==
range_format::disabled>>::value>>
: formatter<detail::all<typename T::container_type>, Char> {
using all = detail::all<typename T::container_type>;
template <typename FormatContext>
auto format(const T& t, FormatContext& ctx) const -> decltype(ctx.out()) {
struct getter : T {
static auto get(const T& t) -> all {
return {t.*(&getter::c)}; // Access c through the derived class.
}
};
return formatter<all>::format(getter::get(t), ctx);
}
};
FMT_BEGIN_EXPORT
/**
\rst
@ -716,7 +732,7 @@ auto join(std::initializer_list<T> list, string_view sep)
return join(std::begin(list), std::end(list), sep);
}
FMT_MODULE_EXPORT_END
FMT_END_EXPORT
FMT_END_NAMESPACE
#endif // FMT_RANGES_H_

498
include/fmt/std.h
View File

@ -8,10 +8,18 @@
#ifndef FMT_STD_H_
#define FMT_STD_H_
#include <atomic>
#include <bitset>
#include <cstdlib>
#include <exception>
#include <memory>
#include <thread>
#include <type_traits>
#include <typeinfo>
#include <utility>
#include <vector>
#include "format.h"
#include "ostream.h"
#if FMT_HAS_INCLUDE(<version>)
@ -25,94 +33,258 @@
# if FMT_HAS_INCLUDE(<variant>)
# include <variant>
# endif
# if FMT_HAS_INCLUDE(<optional>)
# include <optional>
# endif
#endif
#ifdef __cpp_lib_filesystem
#if FMT_CPLUSPLUS > 201703L && FMT_HAS_INCLUDE(<source_location>)
# include <source_location>
#endif
// GCC 4 does not support FMT_HAS_INCLUDE.
#if FMT_HAS_INCLUDE(<cxxabi.h>) || defined(__GLIBCXX__)
# include <cxxabi.h>
// Android NDK with gabi++ library on some architectures does not implement
// abi::__cxa_demangle().
# ifndef __GABIXX_CXXABI_H__
# define FMT_HAS_ABI_CXA_DEMANGLE
# endif
#endif
// Check if typeid is available.
#ifndef FMT_USE_TYPEID
// __RTTI is for EDG compilers. In MSVC typeid is available without RTTI.
# if defined(__GXX_RTTI) || FMT_HAS_FEATURE(cxx_rtti) || FMT_MSC_VERSION || \
defined(__INTEL_RTTI__) || defined(__RTTI)
# define FMT_USE_TYPEID 1
# else
# define FMT_USE_TYPEID 0
# endif
#endif
// For older Xcode versions, __cpp_lib_xxx flags are inaccurately defined.
#ifndef FMT_CPP_LIB_FILESYSTEM
# ifdef __cpp_lib_filesystem
# define FMT_CPP_LIB_FILESYSTEM __cpp_lib_filesystem
# else
# define FMT_CPP_LIB_FILESYSTEM 0
# endif
#endif
#ifndef FMT_CPP_LIB_VARIANT
# ifdef __cpp_lib_variant
# define FMT_CPP_LIB_VARIANT __cpp_lib_variant
# else
# define FMT_CPP_LIB_VARIANT 0
# endif
#endif
#if FMT_CPP_LIB_FILESYSTEM
FMT_BEGIN_NAMESPACE
namespace detail {
template <typename Char>
template <typename Char, typename PathChar>
auto get_path_string(const std::filesystem::path& p,
const std::basic_string<PathChar>& native) {
if constexpr (std::is_same_v<Char, char> && std::is_same_v<PathChar, wchar_t>)
return to_utf8<wchar_t>(native, to_utf8_error_policy::replace);
else
return p.string<Char>();
}
template <typename Char, typename PathChar>
void write_escaped_path(basic_memory_buffer<Char>& quoted,
const std::filesystem::path& p) {
write_escaped_string<Char>(std::back_inserter(quoted), p.string<Char>());
}
# ifdef _WIN32
template <>
inline void write_escaped_path<char>(basic_memory_buffer<char>& quoted,
const std::filesystem::path& p) {
auto s = p.u8string();
write_escaped_string<char>(
std::back_inserter(quoted),
string_view(reinterpret_cast<const char*>(s.c_str()), s.size()));
}
# endif
template <>
inline void write_escaped_path<std::filesystem::path::value_type>(
basic_memory_buffer<std::filesystem::path::value_type>& quoted,
const std::filesystem::path& p) {
write_escaped_string<std::filesystem::path::value_type>(
std::back_inserter(quoted), p.native());
const std::filesystem::path& p,
const std::basic_string<PathChar>& native) {
if constexpr (std::is_same_v<Char, char> &&
std::is_same_v<PathChar, wchar_t>) {
auto buf = basic_memory_buffer<wchar_t>();
write_escaped_string<wchar_t>(std::back_inserter(buf), native);
bool valid = to_utf8<wchar_t>::convert(quoted, {buf.data(), buf.size()});
FMT_ASSERT(valid, "invalid utf16");
} else if constexpr (std::is_same_v<Char, PathChar>) {
write_escaped_string<std::filesystem::path::value_type>(
std::back_inserter(quoted), native);
} else {
write_escaped_string<Char>(std::back_inserter(quoted), p.string<Char>());
}
}
} // namespace detail
template <typename Char>
struct formatter<std::filesystem::path, Char>
: formatter<basic_string_view<Char>> {
FMT_EXPORT
template <typename Char> struct formatter<std::filesystem::path, Char> {
private:
format_specs<Char> specs_;
detail::arg_ref<Char> width_ref_;
bool debug_ = false;
char path_type_ = 0;
public:
FMT_CONSTEXPR void set_debug_format(bool set = true) { debug_ = set; }
template <typename ParseContext> FMT_CONSTEXPR auto parse(ParseContext& ctx) {
auto it = ctx.begin(), end = ctx.end();
if (it == end) return it;
it = detail::parse_align(it, end, specs_);
if (it == end) return it;
it = detail::parse_dynamic_spec(it, end, specs_.width, width_ref_, ctx);
if (it != end && *it == '?') {
debug_ = true;
++it;
}
if (it != end && (*it == 'g')) path_type_ = *it++;
return it;
}
template <typename FormatContext>
auto format(const std::filesystem::path& p, FormatContext& ctx) const ->
typename FormatContext::iterator {
basic_memory_buffer<Char> quoted;
detail::write_escaped_path(quoted, p);
return formatter<basic_string_view<Char>>::format(
basic_string_view<Char>(quoted.data(), quoted.size()), ctx);
auto format(const std::filesystem::path& p, FormatContext& ctx) const {
auto specs = specs_;
# ifdef _WIN32
auto path_string = !path_type_ ? p.native() : p.generic_wstring();
# else
auto path_string = !path_type_ ? p.native() : p.generic_string();
# endif
detail::handle_dynamic_spec<detail::width_checker>(specs.width, width_ref_,
ctx);
if (!debug_) {
auto s = detail::get_path_string<Char>(p, path_string);
return detail::write(ctx.out(), basic_string_view<Char>(s), specs);
}
auto quoted = basic_memory_buffer<Char>();
detail::write_escaped_path(quoted, p, path_string);
return detail::write(ctx.out(),
basic_string_view<Char>(quoted.data(), quoted.size()),
specs);
}
};
FMT_END_NAMESPACE
#endif // FMT_CPP_LIB_FILESYSTEM
FMT_BEGIN_NAMESPACE
FMT_EXPORT
template <std::size_t N, typename Char>
struct formatter<std::bitset<N>, Char> : nested_formatter<string_view> {
private:
// Functor because C++11 doesn't support generic lambdas.
struct writer {
const std::bitset<N>& bs;
template <typename OutputIt>
FMT_CONSTEXPR auto operator()(OutputIt out) -> OutputIt {
for (auto pos = N; pos > 0; --pos) {
out = detail::write<Char>(out, bs[pos - 1] ? Char('1') : Char('0'));
}
return out;
}
};
public:
template <typename FormatContext>
auto format(const std::bitset<N>& bs, FormatContext& ctx) const
-> decltype(ctx.out()) {
return write_padded(ctx, writer{bs});
}
};
FMT_EXPORT
template <typename Char>
struct formatter<std::thread::id, Char> : basic_ostream_formatter<Char> {};
FMT_END_NAMESPACE
#ifdef __cpp_lib_optional
FMT_BEGIN_NAMESPACE
FMT_EXPORT
template <typename T, typename Char>
struct formatter<std::optional<T>, Char,
std::enable_if_t<is_formattable<T, Char>::value>> {
private:
formatter<T, Char> underlying_;
static constexpr basic_string_view<Char> optional =
detail::string_literal<Char, 'o', 'p', 't', 'i', 'o', 'n', 'a', 'l',
'('>{};
static constexpr basic_string_view<Char> none =
detail::string_literal<Char, 'n', 'o', 'n', 'e'>{};
template <class U>
FMT_CONSTEXPR static auto maybe_set_debug_format(U& u, bool set)
-> decltype(u.set_debug_format(set)) {
u.set_debug_format(set);
}
template <class U>
FMT_CONSTEXPR static void maybe_set_debug_format(U&, ...) {}
public:
template <typename ParseContext> FMT_CONSTEXPR auto parse(ParseContext& ctx) {
maybe_set_debug_format(underlying_, true);
return underlying_.parse(ctx);
}
template <typename FormatContext>
auto format(const std::optional<T>& opt, FormatContext& ctx) const
-> decltype(ctx.out()) {
if (!opt) return detail::write<Char>(ctx.out(), none);
auto out = ctx.out();
out = detail::write<Char>(out, optional);
ctx.advance_to(out);
out = underlying_.format(*opt, ctx);
return detail::write(out, ')');
}
};
FMT_END_NAMESPACE
#endif // __cpp_lib_optional
#ifdef __cpp_lib_source_location
FMT_BEGIN_NAMESPACE
FMT_EXPORT
template <> struct formatter<std::source_location> {
template <typename ParseContext> FMT_CONSTEXPR auto parse(ParseContext& ctx) {
return ctx.begin();
}
template <typename FormatContext>
auto format(const std::source_location& loc, FormatContext& ctx) const
-> decltype(ctx.out()) {
auto out = ctx.out();
out = detail::write(out, loc.file_name());
out = detail::write(out, ':');
out = detail::write<char>(out, loc.line());
out = detail::write(out, ':');
out = detail::write<char>(out, loc.column());
out = detail::write(out, ": ");
out = detail::write(out, loc.function_name());
return out;
}
};
FMT_END_NAMESPACE
#endif
#if FMT_CPP_LIB_VARIANT
FMT_BEGIN_NAMESPACE
template <typename Char>
struct formatter<std::thread::id, Char> : basic_ostream_formatter<Char> {};
FMT_END_NAMESPACE
#ifdef __cpp_lib_variant
FMT_BEGIN_NAMESPACE
template <typename Char> struct formatter<std::monostate, Char> {
template <typename ParseContext>
FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
return ctx.begin();
}
template <typename FormatContext>
auto format(const std::monostate&, FormatContext& ctx) const
-> decltype(ctx.out()) {
auto out = ctx.out();
out = detail::write<Char>(out, "monostate");
return out;
}
};
namespace detail {
template <typename T>
using variant_index_sequence =
std::make_index_sequence<std::variant_size<T>::value>;
// variant_size and variant_alternative check.
template <typename T, typename U = void>
struct is_variant_like_ : std::false_type {};
template <typename T>
struct is_variant_like_<T, std::void_t<decltype(std::variant_size<T>::value)>>
: std::true_type {};
template <typename> struct is_variant_like_ : std::false_type {};
template <typename... Types>
struct is_variant_like_<std::variant<Types...>> : std::true_type {};
// formattable element check
// formattable element check.
template <typename T, typename C> class is_variant_formattable_ {
template <std::size_t... I>
template <std::size_t... Is>
static std::conjunction<
is_formattable<std::variant_alternative_t<I, T>, C>...>
check(std::index_sequence<I...>);
is_formattable<std::variant_alternative_t<Is, T>, C>...>
check(std::index_sequence<Is...>);
public:
static constexpr const bool value =
@ -140,6 +312,21 @@ template <typename T, typename C> struct is_variant_formattable {
detail::is_variant_formattable_<T, C>::value;
};
FMT_EXPORT
template <typename Char> struct formatter<std::monostate, Char> {
template <typename ParseContext>
FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
return ctx.begin();
}
template <typename FormatContext>
auto format(const std::monostate&, FormatContext& ctx) const
-> decltype(ctx.out()) {
return detail::write<Char>(ctx.out(), "monostate");
}
};
FMT_EXPORT
template <typename Variant, typename Char>
struct formatter<
Variant, Char,
@ -156,16 +343,195 @@ struct formatter<
auto out = ctx.out();
out = detail::write<Char>(out, "variant(");
std::visit(
[&](const auto& v) {
out = detail::write_variant_alternative<Char>(out, v);
},
value);
FMT_TRY {
std::visit(
[&](const auto& v) {
out = detail::write_variant_alternative<Char>(out, v);
},
value);
}
FMT_CATCH(const std::bad_variant_access&) {
detail::write<Char>(out, "valueless by exception");
}
*out++ = ')';
return out;
}
};
FMT_END_NAMESPACE
#endif // FMT_CPP_LIB_VARIANT
FMT_BEGIN_NAMESPACE
FMT_EXPORT
template <typename Char> struct formatter<std::error_code, Char> {
template <typename ParseContext>
FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
return ctx.begin();
}
template <typename FormatContext>
FMT_CONSTEXPR auto format(const std::error_code& ec, FormatContext& ctx) const
-> decltype(ctx.out()) {
auto out = ctx.out();
out = detail::write_bytes(out, ec.category().name(), format_specs<Char>());
out = detail::write<Char>(out, Char(':'));
out = detail::write<Char>(out, ec.value());
return out;
}
};
FMT_EXPORT
template <typename T, typename Char>
struct formatter<
T, Char, // DEPRECATED! Mixing code unit types.
typename std::enable_if<std::is_base_of<std::exception, T>::value>::type> {
private:
bool with_typename_ = false;
public:
FMT_CONSTEXPR auto parse(basic_format_parse_context<Char>& ctx)
-> decltype(ctx.begin()) {
auto it = ctx.begin();
auto end = ctx.end();
if (it == end || *it == '}') return it;
if (*it == 't') {
++it;
with_typename_ = FMT_USE_TYPEID != 0;
}
return it;
}
template <typename OutputIt>
auto format(const std::exception& ex,
basic_format_context<OutputIt, Char>& ctx) const -> OutputIt {
format_specs<Char> spec;
auto out = ctx.out();
if (!with_typename_)
return detail::write_bytes(out, string_view(ex.what()), spec);
#if FMT_USE_TYPEID
const std::type_info& ti = typeid(ex);
# ifdef FMT_HAS_ABI_CXA_DEMANGLE
int status = 0;
std::size_t size = 0;
std::unique_ptr<char, void (*)(void*)> demangled_name_ptr(
abi::__cxa_demangle(ti.name(), nullptr, &size, &status), &std::free);
string_view demangled_name_view;
if (demangled_name_ptr) {
demangled_name_view = demangled_name_ptr.get();
// Normalization of stdlib inline namespace names.
// libc++ inline namespaces.
// std::__1::* -> std::*
// std::__1::__fs::* -> std::*
// libstdc++ inline namespaces.
// std::__cxx11::* -> std::*
// std::filesystem::__cxx11::* -> std::filesystem::*
if (demangled_name_view.starts_with("std::")) {
char* begin = demangled_name_ptr.get();
char* to = begin + 5; // std::
for (char *from = to, *end = begin + demangled_name_view.size();
from < end;) {
// This is safe, because demangled_name is NUL-terminated.
if (from[0] == '_' && from[1] == '_') {
char* next = from + 1;
while (next < end && *next != ':') next++;
if (next[0] == ':' && next[1] == ':') {
from = next + 2;
continue;
}
}
*to++ = *from++;
}
demangled_name_view = {begin, detail::to_unsigned(to - begin)};
}
} else {
demangled_name_view = string_view(ti.name());
}
out = detail::write_bytes(out, demangled_name_view, spec);
# elif FMT_MSC_VERSION
string_view demangled_name_view(ti.name());
if (demangled_name_view.starts_with("class "))
demangled_name_view.remove_prefix(6);
else if (demangled_name_view.starts_with("struct "))
demangled_name_view.remove_prefix(7);
out = detail::write_bytes(out, demangled_name_view, spec);
# else
out = detail::write_bytes(out, string_view(ti.name()), spec);
# endif
*out++ = ':';
*out++ = ' ';
return detail::write_bytes(out, string_view(ex.what()), spec);
#endif
}
};
namespace detail {
template <typename T, typename Enable = void>
struct has_flip : std::false_type {};
template <typename T>
struct has_flip<T, void_t<decltype(std::declval<T>().flip())>>
: std::true_type {};
template <typename T> struct is_bit_reference_like {
static constexpr const bool value =
std::is_convertible<T, bool>::value &&
std::is_nothrow_assignable<T, bool>::value && has_flip<T>::value;
};
#ifdef _LIBCPP_VERSION
// Workaround for libc++ incompatibility with C++ standard.
// According to the Standard, `bitset::operator[] const` returns bool.
template <typename C>
struct is_bit_reference_like<std::__bit_const_reference<C>> {
static constexpr const bool value = true;
};
#endif
} // namespace detail
// We can't use std::vector<bool, Allocator>::reference and
// std::bitset<N>::reference because the compiler can't deduce Allocator and N
// in partial specialization.
FMT_EXPORT
template <typename BitRef, typename Char>
struct formatter<BitRef, Char,
enable_if_t<detail::is_bit_reference_like<BitRef>::value>>
: formatter<bool, Char> {
template <typename FormatContext>
FMT_CONSTEXPR auto format(const BitRef& v, FormatContext& ctx) const
-> decltype(ctx.out()) {
return formatter<bool, Char>::format(v, ctx);
}
};
FMT_EXPORT
template <typename T, typename Char>
struct formatter<std::atomic<T>, Char,
enable_if_t<is_formattable<T, Char>::value>>
: formatter<T, Char> {
template <typename FormatContext>
auto format(const std::atomic<T>& v, FormatContext& ctx) const
-> decltype(ctx.out()) {
return formatter<T, Char>::format(v.load(), ctx);
}
};
#ifdef __cpp_lib_atomic_flag_test
FMT_EXPORT
template <typename Char>
struct formatter<std::atomic_flag, Char> : formatter<bool, Char> {
template <typename FormatContext>
auto format(const std::atomic_flag& v, FormatContext& ctx) const
-> decltype(ctx.out()) {
return formatter<bool, Char>::format(v.test(), ctx);
}
};
#endif // __cpp_lib_atomic_flag_test
FMT_END_NAMESPACE
#endif // FMT_STD_H_

108
include/fmt/xchar.h
View File

@ -12,13 +12,32 @@
#include "format.h"
#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
# include <locale>
#endif
FMT_BEGIN_NAMESPACE
namespace detail {
template <typename T>
using is_exotic_char = bool_constant<!std::is_same<T, char>::value>;
}
FMT_MODULE_EXPORT_BEGIN
inline auto write_loc(std::back_insert_iterator<detail::buffer<wchar_t>> out,
loc_value value, const format_specs<wchar_t>& specs,
locale_ref loc) -> bool {
#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
auto& numpunct =
std::use_facet<std::numpunct<wchar_t>>(loc.get<std::locale>());
auto separator = std::wstring();
auto grouping = numpunct.grouping();
if (!grouping.empty()) separator = std::wstring(1, numpunct.thousands_sep());
return value.visit(loc_writer<wchar_t>{out, specs, separator, grouping, {}});
#endif
return false;
}
} // namespace detail
FMT_BEGIN_EXPORT
using wstring_view = basic_string_view<wchar_t>;
using wformat_parse_context = basic_format_parse_context<wchar_t>;
@ -33,7 +52,9 @@ inline auto runtime(wstring_view s) -> wstring_view { return s; }
#else
template <typename... Args>
using wformat_string = basic_format_string<wchar_t, type_identity_t<Args>...>;
inline auto runtime(wstring_view s) -> basic_runtime<wchar_t> { return {{s}}; }
inline auto runtime(wstring_view s) -> runtime_format_string<wchar_t> {
return {{s}};
}
#endif
template <> struct is_char<wchar_t> : std::true_type {};
@ -41,15 +62,16 @@ template <> struct is_char<detail::char8_type> : std::true_type {};
template <> struct is_char<char16_t> : std::true_type {};
template <> struct is_char<char32_t> : std::true_type {};
template <typename... Args>
constexpr format_arg_store<wformat_context, Args...> make_wformat_args(
const Args&... args) {
template <typename... T>
constexpr auto make_wformat_args(const T&... args)
-> format_arg_store<wformat_context, T...> {
return {args...};
}
inline namespace literals {
#if FMT_USE_USER_DEFINED_LITERALS && !FMT_USE_NONTYPE_TEMPLATE_ARGS
constexpr detail::udl_arg<wchar_t> operator"" _a(const wchar_t* s, size_t) {
constexpr auto operator""_a(const wchar_t* s, size_t)
-> detail::udl_arg<wchar_t> {
return {s};
}
#endif
@ -78,9 +100,9 @@ template <typename Char, FMT_ENABLE_IF(!std::is_same<Char, char>::value)>
auto vformat(basic_string_view<Char> format_str,
basic_format_args<buffer_context<type_identity_t<Char>>> args)
-> std::basic_string<Char> {
basic_memory_buffer<Char> buffer;
detail::vformat_to(buffer, format_str, args);
return to_string(buffer);
auto buf = basic_memory_buffer<Char>();
detail::vformat_to(buf, format_str, args);
return to_string(buf);
}
template <typename... T>
@ -90,10 +112,10 @@ auto format(wformat_string<T...> fmt, T&&... args) -> std::wstring {
// Pass char_t as a default template parameter instead of using
// std::basic_string<char_t<S>> to reduce the symbol size.
template <typename S, typename... Args, typename Char = char_t<S>,
template <typename S, typename... T, typename Char = char_t<S>,
FMT_ENABLE_IF(!std::is_same<Char, char>::value &&
!std::is_same<Char, wchar_t>::value)>
auto format(const S& format_str, Args&&... args) -> std::basic_string<Char> {
auto format(const S& format_str, T&&... args) -> std::basic_string<Char> {
return vformat(detail::to_string_view(format_str),
fmt::make_format_args<buffer_context<Char>>(args...));
}
@ -108,11 +130,10 @@ inline auto vformat(
return detail::vformat(loc, detail::to_string_view(format_str), args);
}
template <typename Locale, typename S, typename... Args,
typename Char = char_t<S>,
template <typename Locale, typename S, typename... T, typename Char = char_t<S>,
FMT_ENABLE_IF(detail::is_locale<Locale>::value&&
detail::is_exotic_char<Char>::value)>
inline auto format(const Locale& loc, const S& format_str, Args&&... args)
inline auto format(const Locale& loc, const S& format_str, T&&... args)
-> std::basic_string<Char> {
return detail::vformat(loc, detail::to_string_view(format_str),
fmt::make_format_args<buffer_context<Char>>(args...));
@ -126,14 +147,14 @@ auto vformat_to(OutputIt out, const S& format_str,
-> OutputIt {
auto&& buf = detail::get_buffer<Char>(out);
detail::vformat_to(buf, detail::to_string_view(format_str), args);
return detail::get_iterator(buf);
return detail::get_iterator(buf, out);
}
template <typename OutputIt, typename S, typename... Args,
template <typename OutputIt, typename S, typename... T,
typename Char = char_t<S>,
FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
detail::is_exotic_char<Char>::value)>
inline auto format_to(OutputIt out, const S& fmt, Args&&... args) -> OutputIt {
inline auto format_to(OutputIt out, const S& fmt, T&&... args) -> OutputIt {
return vformat_to(out, detail::to_string_view(fmt),
fmt::make_format_args<buffer_context<Char>>(args...));
}
@ -149,18 +170,18 @@ inline auto vformat_to(
auto&& buf = detail::get_buffer<Char>(out);
vformat_to(buf, detail::to_string_view(format_str), args,
detail::locale_ref(loc));
return detail::get_iterator(buf);
return detail::get_iterator(buf, out);
}
template <
typename OutputIt, typename Locale, typename S, typename... Args,
typename Char = char_t<S>,
bool enable = detail::is_output_iterator<OutputIt, Char>::value&&
detail::is_locale<Locale>::value&& detail::is_exotic_char<Char>::value>
template <typename OutputIt, typename Locale, typename S, typename... T,
typename Char = char_t<S>,
bool enable = detail::is_output_iterator<OutputIt, Char>::value &&
detail::is_locale<Locale>::value &&
detail::is_exotic_char<Char>::value>
inline auto format_to(OutputIt out, const Locale& loc, const S& format_str,
Args&&... args) ->
T&&... args) ->
typename std::enable_if<enable, OutputIt>::type {
return vformat_to(out, loc, to_string_view(format_str),
return vformat_to(out, loc, detail::to_string_view(format_str),
fmt::make_format_args<buffer_context<Char>>(args...));
}
@ -171,36 +192,36 @@ inline auto vformat_to_n(
OutputIt out, size_t n, basic_string_view<Char> format_str,
basic_format_args<buffer_context<type_identity_t<Char>>> args)
-> format_to_n_result<OutputIt> {
detail::iterator_buffer<OutputIt, Char, detail::fixed_buffer_traits> buf(out,
n);
using traits = detail::fixed_buffer_traits;
auto buf = detail::iterator_buffer<OutputIt, Char, traits>(out, n);
detail::vformat_to(buf, format_str, args);
return {buf.out(), buf.count()};
}
template <typename OutputIt, typename S, typename... Args,
template <typename OutputIt, typename S, typename... T,
typename Char = char_t<S>,
FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
detail::is_exotic_char<Char>::value)>
inline auto format_to_n(OutputIt out, size_t n, const S& fmt,
const Args&... args) -> format_to_n_result<OutputIt> {
inline auto format_to_n(OutputIt out, size_t n, const S& fmt, T&&... args)
-> format_to_n_result<OutputIt> {
return vformat_to_n(out, n, detail::to_string_view(fmt),
fmt::make_format_args<buffer_context<Char>>(args...));
}
template <typename S, typename... Args, typename Char = char_t<S>,
template <typename S, typename... T, typename Char = char_t<S>,
FMT_ENABLE_IF(detail::is_exotic_char<Char>::value)>
inline auto formatted_size(const S& fmt, Args&&... args) -> size_t {
detail::counting_buffer<Char> buf;
inline auto formatted_size(const S& fmt, T&&... args) -> size_t {
auto buf = detail::counting_buffer<Char>();
detail::vformat_to(buf, detail::to_string_view(fmt),
fmt::make_format_args<buffer_context<Char>>(args...));
return buf.count();
}
inline void vprint(std::FILE* f, wstring_view fmt, wformat_args args) {
wmemory_buffer buffer;
detail::vformat_to(buffer, fmt, args);
buffer.push_back(L'\0');
if (std::fputws(buffer.data(), f) == -1)
auto buf = wmemory_buffer();
detail::vformat_to(buf, fmt, args);
buf.push_back(L'\0');
if (std::fputws(buf.data(), f) == -1)
FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
}
@ -217,13 +238,22 @@ template <typename... T> void print(wformat_string<T...> fmt, T&&... args) {
return vprint(wstring_view(fmt), fmt::make_wformat_args(args...));
}
template <typename... T>
void println(std::FILE* f, wformat_string<T...> fmt, T&&... args) {
return print(f, L"{}\n", fmt::format(fmt, std::forward<T>(args)...));
}
template <typename... T> void println(wformat_string<T...> fmt, T&&... args) {
return print(L"{}\n", fmt::format(fmt, std::forward<T>(args)...));
}
/**
Converts *value* to ``std::wstring`` using the default format for type *T*.
*/
template <typename T> inline auto to_wstring(const T& value) -> std::wstring {
return format(FMT_STRING(L"{}"), value);
}
FMT_MODULE_EXPORT_END
FMT_END_EXPORT
FMT_END_NAMESPACE
#endif // FMT_XCHAR_H_

102
include/rapidjson/document.h
View File

@ -1,5 +1,5 @@
// Tencent is pleased to support the open source community by making RapidJSON available.
//
//
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
//
// Licensed under the MIT License (the "License"); you may not use this file except
@ -7,9 +7,9 @@
//
// http://opensource.org/licenses/MIT
//
// Unless required by applicable law or agreed to in writing, software distributed
// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
// CONDITIONS OF ANY KIND, either express or implied. See the License for the
// Unless required by applicable law or agreed to in writing, software distributed
// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
// CONDITIONS OF ANY KIND, either express or implied. See the License for the
// specific language governing permissions and limitations under the License.
#ifndef RAPIDJSON_DOCUMENT_H_
@ -67,8 +67,8 @@ class GenericDocument;
But a compiler (IBM XL C/C++ for AIX) have reported to have problem with that so it moved as a namespace scope struct.
https://code.google.com/p/rapidjson/issues/detail?id=64
*/
template <typename Encoding, typename Allocator>
struct GenericMember {
template <typename Encoding, typename Allocator>
struct GenericMember {
GenericValue<Encoding, Allocator> name; //!< name of member (must be a string)
GenericValue<Encoding, Allocator> value; //!< value of member.
};
@ -98,16 +98,19 @@ struct GenericMember {
\see GenericMember, GenericValue::MemberIterator, GenericValue::ConstMemberIterator
*/
template <bool Const, typename Encoding, typename Allocator>
class GenericMemberIterator
: public std::iterator<std::random_access_iterator_tag
, typename internal::MaybeAddConst<Const,GenericMember<Encoding,Allocator> >::Type> {
class GenericMemberIterator {
using iterator_category = std::random_access_iterator_tag;
using value_type = typename internal::MaybeAddConst<Const,GenericMember<Encoding,Allocator> >::Type;
using DifferenceType = ptrdiff_t;
using Pointer = value_type*;
using Reference = value_type&;
friend class GenericValue<Encoding,Allocator>;
template <bool, typename, typename> friend class GenericMemberIterator;
typedef GenericMember<Encoding,Allocator> PlainType;
typedef typename internal::MaybeAddConst<Const,PlainType>::Type ValueType;
typedef std::iterator<std::random_access_iterator_tag,ValueType> BaseType;
public:
//! Iterator type itself
@ -117,13 +120,6 @@ public:
//! Non-constant iterator type
typedef GenericMemberIterator<false,Encoding,Allocator> NonConstIterator;
//! Pointer to (const) GenericMember
typedef typename BaseType::pointer Pointer;
//! Reference to (const) GenericMember
typedef typename BaseType::reference Reference;
//! Signed integer type (e.g. \c ptrdiff_t)
typedef typename BaseType::difference_type DifferenceType;
//! Default constructor (singular value)
/*! Creates an iterator pointing to no element.
\note All operations, except for comparisons, are undefined on such values.
@ -410,7 +406,7 @@ namespace internal {
template <typename ValueType, typename T>
struct TypeHelper {};
template<typename ValueType>
template<typename ValueType>
struct TypeHelper<ValueType, bool> {
static bool Is(const ValueType& v) { return v.IsBool(); }
static bool Get(const ValueType& v) { return v.GetBool(); }
@ -418,7 +414,7 @@ struct TypeHelper<ValueType, bool> {
static ValueType& Set(ValueType& v, bool data, typename ValueType::AllocatorType&) { return v.SetBool(data); }
};
template<typename ValueType>
template<typename ValueType>
struct TypeHelper<ValueType, int> {
static bool Is(const ValueType& v) { return v.IsInt(); }
static int Get(const ValueType& v) { return v.GetInt(); }
@ -426,7 +422,7 @@ struct TypeHelper<ValueType, int> {
static ValueType& Set(ValueType& v, int data, typename ValueType::AllocatorType&) { return v.SetInt(data); }
};
template<typename ValueType>
template<typename ValueType>
struct TypeHelper<ValueType, unsigned> {
static bool Is(const ValueType& v) { return v.IsUint(); }
static unsigned Get(const ValueType& v) { return v.GetUint(); }
@ -434,7 +430,7 @@ struct TypeHelper<ValueType, unsigned> {
static ValueType& Set(ValueType& v, unsigned data, typename ValueType::AllocatorType&) { return v.SetUint(data); }
};
template<typename ValueType>
template<typename ValueType>
struct TypeHelper<ValueType, int64_t> {
static bool Is(const ValueType& v) { return v.IsInt64(); }
static int64_t Get(const ValueType& v) { return v.GetInt64(); }
@ -442,7 +438,7 @@ struct TypeHelper<ValueType, int64_t> {
static ValueType& Set(ValueType& v, int64_t data, typename ValueType::AllocatorType&) { return v.SetInt64(data); }
};
template<typename ValueType>
template<typename ValueType>
struct TypeHelper<ValueType, uint64_t> {
static bool Is(const ValueType& v) { return v.IsUint64(); }
static uint64_t Get(const ValueType& v) { return v.GetUint64(); }
@ -450,7 +446,7 @@ struct TypeHelper<ValueType, uint64_t> {
static ValueType& Set(ValueType& v, uint64_t data, typename ValueType::AllocatorType&) { return v.SetUint64(data); }
};
template<typename ValueType>
template<typename ValueType>
struct TypeHelper<ValueType, double> {
static bool Is(const ValueType& v) { return v.IsDouble(); }
static double Get(const ValueType& v) { return v.GetDouble(); }
@ -458,7 +454,7 @@ struct TypeHelper<ValueType, double> {
static ValueType& Set(ValueType& v, double data, typename ValueType::AllocatorType&) { return v.SetDouble(data); }
};
template<typename ValueType>
template<typename ValueType>
struct TypeHelper<ValueType, float> {
static bool Is(const ValueType& v) { return v.IsFloat(); }
static float Get(const ValueType& v) { return v.GetFloat(); }
@ -466,7 +462,7 @@ struct TypeHelper<ValueType, float> {
static ValueType& Set(ValueType& v, float data, typename ValueType::AllocatorType&) { return v.SetFloat(data); }
};
template<typename ValueType>
template<typename ValueType>
struct TypeHelper<ValueType, const typename ValueType::Ch*> {
typedef const typename ValueType::Ch* StringType;
static bool Is(const ValueType& v) { return v.IsString(); }
@ -476,7 +472,7 @@ struct TypeHelper<ValueType, const typename ValueType::Ch*> {
};
#if RAPIDJSON_HAS_STDSTRING
template<typename ValueType>
template<typename ValueType>
struct TypeHelper<ValueType, std::basic_string<typename ValueType::Ch> > {
typedef std::basic_string<typename ValueType::Ch> StringType;
static bool Is(const ValueType& v) { return v.IsString(); }
@ -485,7 +481,7 @@ struct TypeHelper<ValueType, std::basic_string<typename ValueType::Ch> > {
};
#endif
template<typename ValueType>
template<typename ValueType>
struct TypeHelper<ValueType, typename ValueType::Array> {
typedef typename ValueType::Array ArrayType;
static bool Is(const ValueType& v) { return v.IsArray(); }
@ -494,14 +490,14 @@ struct TypeHelper<ValueType, typename ValueType::Array> {
static ValueType& Set(ValueType& v, ArrayType data, typename ValueType::AllocatorType&) { return v = data; }
};
template<typename ValueType>
template<typename ValueType>
struct TypeHelper<ValueType, typename ValueType::ConstArray> {
typedef typename ValueType::ConstArray ArrayType;
static bool Is(const ValueType& v) { return v.IsArray(); }
static ArrayType Get(const ValueType& v) { return v.GetArray(); }
};
template<typename ValueType>
template<typename ValueType>
struct TypeHelper<ValueType, typename ValueType::Object> {
typedef typename ValueType::Object ObjectType;
static bool Is(const ValueType& v) { return v.IsObject(); }
@ -510,7 +506,7 @@ struct TypeHelper<ValueType, typename ValueType::Object> {
static ValueType& Set(ValueType& v, ObjectType data, typename ValueType::AllocatorType&) { v = data; }
};
template<typename ValueType>
template<typename ValueType>
struct TypeHelper<ValueType, typename ValueType::ConstObject> {
typedef typename ValueType::ConstObject ObjectType;
static bool Is(const ValueType& v) { return v.IsObject(); }
@ -536,7 +532,7 @@ template <bool, typename> class GenericObject;
\tparam Encoding Encoding of the value. (Even non-string values need to have the same encoding in a document)
\tparam Allocator Allocator type for allocating memory of object, array and string.
*/
template <typename Encoding, typename Allocator = MemoryPoolAllocator<> >
template <typename Encoding, typename Allocator = MemoryPoolAllocator<> >
class GenericValue {
public:
//! Name-value pair in an object.
@ -638,7 +634,7 @@ public:
//! Constructor for unsigned value.
explicit GenericValue(unsigned u) RAPIDJSON_NOEXCEPT : data_() {
data_.n.u64 = u;
data_.n.u64 = u;
data_.f.flags = (u & 0x80000000) ? kNumberUintFlag : (kNumberUintFlag | kIntFlag | kInt64Flag);
}
@ -857,14 +853,14 @@ public:
switch (GetType()) {
case kObjectType: // Warning: O(n^2) inner-loop
if (data_.o.size != rhs.data_.o.size)
return false;
return false;
for (ConstMemberIterator lhsMemberItr = MemberBegin(); lhsMemberItr != MemberEnd(); ++lhsMemberItr) {
typename RhsType::ConstMemberIterator rhsMemberItr = rhs.FindMember(lhsMemberItr->name);
if (rhsMemberItr == rhs.MemberEnd() || lhsMemberItr->value != rhsMemberItr->value)
return false;
}
return true;
case kArrayType:
if (data_.a.size != rhs.data_.a.size)
return false;
@ -1335,7 +1331,7 @@ public:
\note Linear time complexity.
*/
void RemoveAllMembers() {
RAPIDJSON_ASSERT(IsObject());
RAPIDJSON_ASSERT(IsObject());
for (MemberIterator m = MemberBegin(); m != MemberEnd(); ++m)
m->~Member();
data_.o.size = 0;
@ -1481,7 +1477,7 @@ public:
\note Linear time complexity.
*/
void Clear() {
RAPIDJSON_ASSERT(IsArray());
RAPIDJSON_ASSERT(IsArray());
GenericValue* e = GetElementsPointer();
for (GenericValue* v = e; v != e + data_.a.size; ++v)
v->~GenericValue();
@ -1628,7 +1624,7 @@ public:
RAPIDJSON_ASSERT(last <= End());
ValueIterator pos = Begin() + (first - Begin());
for (ValueIterator itr = pos; itr != last; ++itr)
itr->~GenericValue();
itr->~GenericValue();
std::memmove(pos, last, static_cast<size_t>(End() - last) * sizeof(GenericValue));
data_.a.size -= static_cast<SizeType>(last - first);
return pos;
@ -1687,7 +1683,7 @@ public:
//! Set this value as a string without copying source string.
/*! This version has better performance with supplied length, and also support string containing null character.
\param s source string pointer.
\param s source string pointer.
\param length The length of source string, excluding the trailing null terminator.
\return The value itself for fluent API.
\post IsString() == true && GetString() == s && GetStringLength() == length
@ -1704,7 +1700,7 @@ public:
//! Set this value as a string by copying from source string.
/*! This version has better performance with supplied length, and also support string containing null character.
\param s source string.
\param s source string.
\param length The length of source string, excluding the trailing null terminator.
\param allocator Allocator for allocating copied buffer. Commonly use GenericDocument::GetAllocator().
\return The value itself for fluent API.
@ -1713,7 +1709,7 @@ public:
GenericValue& SetString(const Ch* s, SizeType length, Allocator& allocator) { this->~GenericValue(); SetStringRaw(StringRef(s, length), allocator); return *this; }
//! Set this value as a string by copying from source string.
/*! \param s source string.
/*! \param s source string.
\param allocator Allocator for allocating copied buffer. Commonly use GenericDocument::GetAllocator().
\return The value itself for fluent API.
\post IsString() == true && GetString() != s && strcmp(GetString(),s) == 0 && GetStringLength() == length
@ -1790,10 +1786,10 @@ public:
if (RAPIDJSON_UNLIKELY(!v->Accept(handler)))
return false;
return handler.EndArray(data_.a.size);
case kStringType:
return handler.String(GetString(), GetStringLength(), (data_.f.flags & kCopyFlag) != 0);
default:
RAPIDJSON_ASSERT(GetType() == kNumberType);
if (IsDouble()) return handler.Double(data_.n.d);
@ -2010,7 +2006,7 @@ private:
typedef GenericValue<UTF8<> > Value;
///////////////////////////////////////////////////////////////////////////////
// GenericDocument
// GenericDocument
//! A document for parsing JSON text as DOM.
/*!
@ -2042,12 +2038,12 @@ public:
}
//! Constructor
/*! Creates an empty document which type is Null.
/*! Creates an empty document which type is Null.
\param allocator Optional allocator for allocating memory.
\param stackCapacity Optional initial capacity of stack in bytes.
\param stackAllocator Optional allocator for allocating memory for stack.
*/
GenericDocument(Allocator* allocator = 0, size_t stackCapacity = kDefaultStackCapacity, StackAllocator* stackAllocator = 0) :
GenericDocument(Allocator* allocator = 0, size_t stackCapacity = kDefaultStackCapacity, StackAllocator* stackAllocator = 0) :
allocator_(allocator), ownAllocator_(0), stack_(stackAllocator, stackCapacity), parseResult_()
{
if (!allocator_)
@ -2253,7 +2249,7 @@ public:
GenericDocument& Parse(const Ch* str, size_t length) {
return Parse<parseFlags, Encoding>(str, length);
}
GenericDocument& Parse(const Ch* str, size_t length) {
return Parse<kParseDefaultFlags>(str, length);
}
@ -2273,7 +2269,7 @@ public:
GenericDocument& Parse(const std::basic_string<Ch>& str) {
return Parse<kParseDefaultFlags>(str);
}
#endif // RAPIDJSON_HAS_STDSTRING
#endif // RAPIDJSON_HAS_STDSTRING
//!@}
@ -2338,16 +2334,16 @@ public:
bool Uint64(uint64_t i) { new (stack_.template Push<ValueType>()) ValueType(i); return true; }
bool Double(double d) { new (stack_.template Push<ValueType>()) ValueType(d); return true; }
bool RawNumber(const Ch* str, SizeType length, bool copy) {
if (copy)
bool RawNumber(const Ch* str, SizeType length, bool copy) {
if (copy)
new (stack_.template Push<ValueType>()) ValueType(str, length, GetAllocator());
else
new (stack_.template Push<ValueType>()) ValueType(str, length);
return true;
}
bool String(const Ch* str, SizeType length, bool copy) {
if (copy)
bool String(const Ch* str, SizeType length, bool copy) {
if (copy)
new (stack_.template Push<ValueType>()) ValueType(str, length, GetAllocator());
else
new (stack_.template Push<ValueType>()) ValueType(str, length);
@ -2355,7 +2351,7 @@ public:
}
bool StartObject() { new (stack_.template Push<ValueType>()) ValueType(kObjectType); return true; }
bool Key(const Ch* str, SizeType length, bool copy) { return String(str, length, copy); }
bool EndObject(SizeType memberCount) {
@ -2365,7 +2361,7 @@ public:
}
bool StartArray() { new (stack_.template Push<ValueType>()) ValueType(kArrayType); return true; }
bool EndArray(SizeType elementCount) {
ValueType* elements = stack_.template Pop<ValueType>(elementCount);
stack_.template Top<ValueType>()->SetArrayRaw(elements, elementCount, GetAllocator());

16
include/seiscomp/broker/client.h
View File

@ -107,6 +107,15 @@ class SC_BROKER_API Client {
bool setDiscardSelf(bool enable);
bool discardSelf() const;
/**
* @brief Sets whether to receive only status messages or all
* messages. The default is false.
* @param enable The enable flat
* @return Success flag
*/
bool setStatusOnly(bool enable);
bool statusOnly() const;
/**
* @brief Sets the number of messages required to send back an
* acknoledgement.
@ -171,10 +180,11 @@ class SC_BROKER_API Client {
std::string _name;
bool _wantsMembershipInformation{false};
bool _discardSelf{false};
bool _statusOnly{false};
SequenceNumber _sequenceNumber{0};
SequenceNumber _acknowledgeWindow{20};
SequenceNumber _acknowledgeCounter{20};
Core::Time _ackInitiated;
OPT(Core::Time) _ackInitiated;
int _inactivityCounter{0}; // The number of seconds
// of inactivity
@ -198,6 +208,10 @@ inline bool Client::discardSelf() const {
return _discardSelf;
}
inline bool Client::statusOnly() const {
return _statusOnly;
}
inline void *Client::memory(int offset) {
return _heap + offset;
}

1
include/seiscomp/broker/protocol.h
View File

@ -74,6 +74,7 @@ namespace Protocol {
#define SCMP_PROTO_CMD_CONNECT_HEADER_CLIENT_NAME "Client-Name"
#define SCMP_PROTO_CMD_CONNECT_HEADER_MEMBERSHIP_INFO "Membership-Info"
#define SCMP_PROTO_CMD_CONNECT_HEADER_SELF_DISCARD "Self-Discard"
#define SCMP_PROTO_CMD_CONNECT_HEADER_STATUS_ONLY "Status-Only"
#define SCMP_PROTO_CMD_CONNECT_HEADER_ACK_WINDOW "Ack-Window"
#define SCMP_PROTO_CMD_CONNECT_HEADER_SEQ_NUMBER "Seq-No"
#define SCMP_PROTO_CMD_CONNECT_HEADER_SUBSCRIPTIONS "Subscriptions"

2
include/seiscomp/broker/queue.h
View File

@ -387,7 +387,7 @@ class SC_BROKER_API Queue {
TaskQueue _tasks;
TaskQueue _results;
Core::Time _created;
Core::Time _lastSOHTimestamp;
OPT(Core::Time) _lastSOHTimestamp;
int _allocatedClientHeap;
int _sohInterval;
int _inactivityLimit;

26
include/seiscomp/client/application.h
View File

@ -87,7 +87,7 @@ class SC_SYSTEM_CLIENT_API ApplicationStatusMessage : public Core::Message {
public:
virtual bool empty() const;
virtual bool empty() const override;
const std::string &module() const;
const std::string &username() const;
@ -191,7 +191,7 @@ class SC_SYSTEM_CLIENT_API Application : public System::Application {
* Exit the application and set the returnCode.
* @param returnCode The value returned from exec()
*/
virtual void exit(int returnCode);
virtual void exit(int returnCode) override;
//! Returns the application's messaging connection interface
Client::Connection *connection() const;
@ -543,6 +543,14 @@ class SC_SYSTEM_CLIENT_API Application : public System::Application {
*/
virtual void handleTimeout();
/**
* This method is called when the internal SOH checks are performed
* as an additional state-of-health callback in derived classes.
* The default implementation does nothing.
* This method has been added with API 17.
*/
virtual void handleSOH();
/**
* This method is called when close event is sent to the application.
* The default handler returns true and causes the event queue to
@ -651,10 +659,6 @@ class SC_SYSTEM_CLIENT_API Application : public System::Application {
std::string customPublicIDPattern;
std::string configModuleName{"trunk"};
bool enableFetchDatabase{true};
bool enableLoadStations{false};
bool enableLoadInventory{false};
bool enableLoadConfigModule{false};
bool enableAutoApplyNotifier{true};
bool enableInterpretNotifier{true};
@ -672,6 +676,13 @@ class SC_SYSTEM_CLIENT_API Application : public System::Application {
struct Database {
void accept(SettingsLinker &linker);
// State variables
bool enableFetch{true};
bool enableStations{false};
bool enableInventory{false};
bool enableConfigModule{false};
// Configuration variables
bool enable{true};
bool showDrivers{false};
@ -736,6 +747,7 @@ class SC_SYSTEM_CLIENT_API Application : public System::Application {
StringVector agencyAllowlist;
StringVector agencyBlocklist;
Util::StringFirewall firewall;
StringVector amplitudeAliases;
StringVector magnitudeAliases;
} processing;
@ -762,7 +774,7 @@ class SC_SYSTEM_CLIENT_API Application : public System::Application {
IO::DatabaseInterfacePtr _database;
Util::Timer _userTimer;
Util::Timer _sohTimer;
Core::Time _sohLastUpdate;
OPT(Core::Time) _sohLastUpdate;
std::mutex _objectLogMutex;
};

16
include/seiscomp/client/streamapplication.h
View File

@ -55,8 +55,8 @@ class SC_SYSTEM_CLIENT_API StreamApplication : public Application {
const std::string& locationCode,
const std::string& channelCode);
void setStartTime(const Seiscomp::Core::Time&);
void setEndTime(const Seiscomp::Core::Time&);
void setStartTime(const OPT(Seiscomp::Core::Time) &);
void setEndTime(const OPT(Seiscomp::Core::Time) &);
bool setTimeWindow(const Seiscomp::Core::TimeWindow&);
//! Sets whether to start the acquisition automatically
@ -91,12 +91,12 @@ class SC_SYSTEM_CLIENT_API StreamApplication : public Application {
// Protected interface
// ----------------------------------------------------------------------
protected:
bool init();
bool run();
void done();
void exit(int returnCode);
bool init() override;
bool run() override;
void done() override;
void exit(int returnCode) override;
bool dispatch(Core::BaseObject* obj);
bool dispatch(Core::BaseObject* obj) override;
void readRecords(bool sendEndNotification);
@ -120,7 +120,7 @@ class SC_SYSTEM_CLIENT_API StreamApplication : public Application {
virtual void handleRecord(Record *rec) = 0;
//! Logs the received records for the last period
virtual void handleMonitorLog(const Core::Time &timestamp);
virtual void handleMonitorLog(const Core::Time &timestamp) override;
private:

154
include/seiscomp/config/config.h
View File

@ -18,8 +18,8 @@
***************************************************************************/
#ifndef __SEISCOMP_CONFIG_H__
#define __SEISCOMP_CONFIG_H__
#ifndef SEISCOMP_CONFIG_H
#define SEISCOMP_CONFIG_H
#include <iostream>
@ -34,13 +34,15 @@
#include <seiscomp/config/exceptions.h>
#include <seiscomp/config/symboltable.h>
namespace Seiscomp {
namespace Config {
/**
* Mapping of configuration variable to type
*/
typedef std::map<std::string, std::string> Variables;
using Variables = std::map<std::string, std::string>;
/**
@ -61,21 +63,13 @@ class SC_CONFIG_API Config {
// Public interface
// ------------------------------------------------------------------------
public:
/** When names are queried and this check is enabled, it will
* throw an exception if the same name is defined in a later stage
* with respect to case insensitive name comparison.
* This allows to check for parameter inconsistencies that are
* hard to track otherwise.
*/
void setCaseSensitivityCheck(bool);
/** Reads the given configuration file.
* @param file name of the configuration files
* @param stage Optional stage value to be set to each read symbol
* @param raw Raw mode which does not resolv references like ${var}
* @return true on success
*/
bool readConfig(const std::string& file, int stage=-1, bool raw=false);
bool readConfig(const std::string &file, int stage=-1, bool raw = false);
/** Writes the configuration to the given configuration file.
* @param file name of the configuarion files
@ -83,7 +77,7 @@ class SC_CONFIG_API Config {
* new entries
* @return true on success
*/
bool writeConfig(const std::string& file, bool localOny = true,
bool writeConfig(const std::string &file, bool localOny = true,
bool multilineLists = false);
/** Writes the configuration to the file which was given to
@ -110,70 +104,108 @@ class SC_CONFIG_API Config {
//! Gets an integer from the configuration file
//! @param name name of the element
//! @return value
int getInt(const std::string& name) const;
int getInt(const std::string& name, bool* error) const;
bool getInt(int& value, const std::string& name) const;
int getInt(const std::string &name) const;
int getInt(const std::string &name, bool *error) const;
bool getInt(int &value, const std::string &name) const;
bool setInt(const std::string& name, int value);
bool setInt(const std::string &name, int value);
/** Gets a double from the configuration file
* @param name name of the element
* @return double
*/
double getDouble(const std::string& name) const;
double getDouble(const std::string& name, bool* error) const;
bool getDouble(double& value, const std::string& name) const;
double getDouble(const std::string &name) const;
double getDouble(const std::string &name, bool *error) const;
bool getDouble(double& value, const std::string &name) const;
bool setDouble(const std::string& name, double value);
bool setDouble(const std::string &name, double value);
/** Gets an boolean from the configuration file
* @param name name of the element
* @return boolean
*/
bool getBool(const std::string& name) const;
bool getBool(const std::string& name, bool* error) const;
bool getBool(bool& value, const std::string& name) const;
bool getBool(const std::string &name) const;
bool getBool(const std::string &name, bool *error) const;
bool getBool(bool &value, const std::string &name) const;
bool setBool(const std::string& name, bool value);
bool setBool(const std::string &name, bool value);
/** Gets a string from the configuration file
* @param name name of the element
* @return string
*/
std::string getString(const std::string& name) const;
std::string getString(const std::string& name, bool* error) const;
bool getString(std::string& value, const std::string& name) const;
std::string getString(const std::string &name) const;
std::string getString(const std::string &name, bool *error) const;
bool getString(std::string &value, const std::string &name) const;
bool setString(const std::string& name, const std::string& value);
bool setString(const std::string &name, const std::string &value);
/** Removes the symbol with the given name from the symboltable.
* @param name Symbol to be removed
*/
bool remove(const std::string& name);
bool remove(const std::string &name);
std::vector<int> getInts(const std::string& name) const;
std::vector<int> getInts(const std::string &name) const;
std::vector<int> getInts(const std::string& name, bool* error) const;
std::vector<int> getInts(const std::string &name, bool *error) const;
bool setInts(const std::string& name, const std::vector<int>& values);
bool setInts(const std::string &name, const std::vector<int> &values);
std::vector<double> getDoubles(const std::string& name) const;
std::vector<double> getDoubles(const std::string &name) const;
std::vector<double> getDoubles(const std::string& name, bool* error) const;
std::vector<double> getDoubles(const std::string &name, bool *error) const;
bool setDoubles(const std::string& name, const std::vector<double>& values);
bool setDoubles(const std::string &name, const std::vector<double> &values);
std::vector<bool> getBools(const std::string& name) const;
std::vector<bool> getBools(const std::string &name) const;
std::vector<bool> getBools(const std::string& name, bool* error) const;
std::vector<bool> getBools(const std::string &name, bool *error) const;
bool setBools(const std::string& name, const std::vector<bool>& values);
bool setBools(const std::string &name, const std::vector<bool> &values);
std::vector<std::string> getStrings(const std::string& name) const;
std::vector<std::string> getStrings(const std::string& name, bool* error) const;
bool getStrings(std::vector<std::string>& value, const std::string& name) const;
std::vector<std::string> getStrings(const std::string &name) const;
std::vector<std::string> getStrings(const std::string &name, bool *error) const;
bool getStrings(std::vector<std::string> &value, const std::string &name) const;
bool setStrings(const std::string& name, const std::vector<std::string>& values);
bool setStrings(const std::string &name, const std::vector<std::string> &values);
/**
* @brief Returns a list of symbols with a name that starts with a
* given prefix.
* Alternatively a name of a symbol can be given. That symbol name must
* exist under the checked candidate. Example of configuration:
*
* @code
* profiles.A.enabled = false
* profiles.A.name = "Profile A"
* profiles.B.enabled = true
* profiles.B.name = "Profile B"
* profiles.C.name = "Profile C"
* @endcode
*
* @code
* auto symbols = cfg.findSymbols("profiles.", "enabled");
* assert(symbols.size() == 1)
* assert(symbols[0] == "profiles.B")
*
* symbols = cfg.findSymbols("profiles.");
* assert(symbols.size() == 3)
* assert(symbols[0] == "profiles.A")
* assert(symbols[1] == "profiles.B")
* assert(symbols[2] == "profiles.C")
* @endcode
*
* @param prefix The prefix of the returned symbol name
* @param enabledSymbol If not empty then a symbol is evaluated which
* holds a true boolean value. The name of the
* symbol is composed of the checked symbol name
* and this parameters joined with a dot.
* @return enabledDefault Default value for the enableSymbol.
* @return The list of matching symbols.
*/
std::vector<std::string> findSymbols(const std::string &prefix,
const std::string &enabledSymbol = {},
bool enabledDefault = true) const;
SymbolTable *symbolTable() const;
@ -268,17 +300,17 @@ class SC_CONFIG_API Config {
// ------------------------------------------------------------------------
private:
void init();
bool handleEntry(const std::string& entry, const std::string& comment);
bool handleInclude(const std::string& fileName);
void handleAssignment(const std::string& name, const std::string& content,
std::vector<std::string>& values,
const std::string& comment);
bool handleEntry(const std::string &entry, const std::string &comment);
bool handleInclude(const std::string &fileName);
void handleAssignment(const std::string &name, const std::string &content,
std::vector<std::string> &values,
const std::string &comment);
std::vector<std::string> tokenize(const std::string& entry);
static bool reference(const std::string &name,
std::vector<std::string> &value,
const SymbolTable *symtab);
static bool parseRValue(const std::string& entry,
std::vector<std::string>& parsedValues,
static bool parseRValue(const std::string &entry,
std::vector<std::string> &parsedValues,
const SymbolTable *symtab,
bool resolveReferences,
bool rawMode,
@ -289,34 +321,34 @@ class SC_CONFIG_API Config {
int stage = -1, bool raw = false);
template <typename T>
T get(const std::string& name) const;
T get(const std::string &name) const;
template <typename T>
T get(const std::string& name, bool* error) const;
T get(const std::string &name, bool *error) const;
template <typename T>
bool get(T& value, const std::string& name) const;
bool get(T &value, const std::string &name) const;
template <typename T>
std::vector<T> getVec(const std::string& name) const;
std::vector<T> getVec(const std::string &name) const;
template <typename T>
std::vector<T> getVec(const std::string& name, bool* error) const;
std::vector<T> getVec(const std::string &name, bool *error) const;
template <typename T>
void add(const std::string& name, const T& value);
void add(const std::string &name, const T &value);
template <typename T>
void add(const std::string& name, const std::vector<T>& values);
void add(const std::string &name, const std::vector<T> &values);
/** Sets an value in the configuration file
* @param element name of the element
* @param value value for the element */
template <typename T>
bool set(const std::string& name, const T& value);
bool set(const std::string &name, const T &value);
template <typename T>
bool set(const std::string& name, const std::vector<T>& values);
bool set(const std::string &name, const std::vector<T> &values);
inline void addVariable(const std::string &name, const char *type) const;
@ -327,7 +359,8 @@ class SC_CONFIG_API Config {
// Private data members
// ------------------------------------------------------------------------
private:
typedef std::deque<std::string> Namespaces;
using Namespaces = std::deque<std::string>;
int _stage;
int _line;
bool _resolveReferences;
@ -346,4 +379,5 @@ class SC_CONFIG_API Config {
} // namespace Config
} // namespace Seiscomp
#endif

2
include/seiscomp/config/exceptions.h
View File

@ -38,7 +38,7 @@ class SC_CONFIG_API Exception : public std::exception {
Exception(const char *str) : _what(str) {}
virtual ~Exception() throw() {}
const char *what() const throw() { return _what.c_str(); }
const char *what() const throw() override { return _what.c_str(); }
private:
std::string _what;

8
include/seiscomp/config/log.h
View File

@ -23,6 +23,7 @@
#include <seiscomp/config/api.h>
#include <fmt/printf.h>
#include <cstdio>
@ -44,13 +45,10 @@ struct SC_CONFIG_API Logger {
};
extern char log_msg_buffer[1024];
#define CONFIG_LOG_CHANNEL(chan, msg, ...) \
if ( _logger ) {\
snprintf(log_msg_buffer, 1023, msg, __VA_ARGS__);\
_logger->log(chan, _fileName.c_str(), _line, log_msg_buffer);\
auto line = fmt::sprintf(msg, __VA_ARGS__);\
_logger->log(chan, _fileName.c_str(), _line, line.c_str());\
}

44
include/seiscomp/config/symboltable.h
View File

@ -17,9 +17,11 @@
* gempa GmbH. *
***************************************************************************/
#ifndef __SEISCOMP_CONFIG_SYMBOLTABLE__
#define __SEISCOMP_CONFIG_SYMBOLTABLE__
#include <string>
#include <vector>
#include <map>
@ -28,6 +30,7 @@
#include <seiscomp/config/log.h>
namespace Seiscomp {
namespace Config {
@ -65,23 +68,22 @@ struct SC_CONFIG_API Symbol {
class SC_CONFIG_API SymbolTable {
private:
typedef std::map<std::string, Symbol> Symbols;
typedef std::vector<Symbol*> SymbolOrder;
typedef std::map<std::string, Symbols::iterator> CISymbols;
public:
typedef SymbolOrder::const_iterator iterator;
typedef std::set<std::string> IncludedFiles;
typedef IncludedFiles::iterator file_iterator;
public:
SymbolTable();
using Symbols = std::map<std::string, Symbol>;
using SymbolOrder = std::vector<Symbol*>;
public:
using iterator = SymbolOrder::const_iterator;
using IncludedFiles = std::set<std::string>;
using file_iterator = IncludedFiles::iterator;
public:
SymbolTable() = default;
public:
void setCaseSensitivityCheck(bool);
void setLogger(Logger *);
Logger *logger();
@ -114,22 +116,18 @@ class SC_CONFIG_API SymbolTable {
iterator begin();
iterator end();
private:
//! Returns true if an inconsistent definition has been found
bool checkCI(const std::string &name, const Symbol *) const;
private:
bool _csCheck;
Symbols _symbols;
CISymbols _cisymbols;
SymbolOrder _symbolOrder;
IncludedFiles _includedFiles;
int _objectCount;
Logger *_logger;
Symbols _symbols;
SymbolOrder _symbolOrder;
IncludedFiles _includedFiles;
int _objectCount{0};
Logger *_logger{nullptr};
};
} // namespace Config
} // namespace Seiscomp
#endif

30
include/seiscomp/core/archive.h
View File

@ -61,7 +61,7 @@ namespace Generic {
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
/** \brief A template archive interface
An archive offers an interface to read from and write to datasources.
An archive offers an interface to read from and write to datasources.
*/
template <typename ROOT_TYPE>
class Archive {
@ -130,7 +130,7 @@ class Archive {
//! Creates a new archive
virtual bool create(const char* dataSource);
virtual void close() = 0;
/**
@ -279,7 +279,7 @@ class Archive {
void read(::boost::intrusive_ptr<T> &object);
template <typename T>
void read(::boost::optional<T> &object);
void read(Optional<T> &object);
// ------------------------------------------------------------------
@ -347,7 +347,7 @@ class Archive {
void write(::boost::intrusive_ptr<T>&);
template <typename T>
void write(::boost::optional<T>&);
void write(Optional<T>&);
// ------------------------------------------------------------------
@ -361,7 +361,7 @@ class Archive {
//! Writes a smartpointer into the archive
template <typename T>
Archive& operator<<(::boost::intrusive_ptr<T>&);
//! Writes a named object into the archive
template <typename T>
Archive& operator<<(const ObjectNamer<T>&);
@ -416,12 +416,12 @@ class Archive {
//! Reads a list from the archive
template <typename T>
Archive& operator>>(const ObjectNamer<std::list<T> >&);
//! Stream operator that decides by means of the _isReading flag
//! whether a the object has to be written or to be read.
template <typename T>
Archive& operator&(ObjectNamer<T>);
// ------------------------------------------------------------------
@ -436,15 +436,15 @@ class Archive {
template <typename T>
struct TypedSerializeDispatcher : SerializeDispatcher {
TypedSerializeDispatcher(T* t = nullptr) : target(t) {}
TypedSerializeDispatcher& operator=(T* t) {
target = t;
return *this;
}
TypedSerializeDispatcher* operator->() { return this; }
virtual void operator()(Archive<ROOT_TYPE>& ar) {
virtual void operator()(Archive<ROOT_TYPE>& ar) override {
target->serialize(ar);
}
@ -454,7 +454,7 @@ class Archive {
};
bool findObject(const char *name, const char *targetClass, bool nullable);
//! Locates an object inside the archive. A derived class
//! must provide its specific location code.
virtual bool locateObjectByName(const char *name, const char *targetClass, bool nullable) = 0;
@ -510,7 +510,7 @@ class Archive {
template <typename T>
void readPtr(void*, T *&object);
//! Helper function to distinguish between pointer and non pointer
//! types to avoid nullptr pointer serialization.
template <typename T>
@ -523,8 +523,8 @@ class Archive {
void read(const char *name, ::boost::intrusive_ptr<T> &object, const char *targetClass);
template <typename T>
void read(const char *name, ::boost::optional<T> &object, const char *targetClass);
void read(const char *name, Optional<T> &object, const char *targetClass);
template <typename T>
void write(const char *name, T &object, const char *targetClass);
@ -538,7 +538,7 @@ class Archive {
//! Helper function to distinguish between C pointer and Optionals
template <typename T>
void write(const char *name, ::boost::optional<T> &object, const char *targetClass);
void write(const char *name, Optional<T> &object, const char *targetClass);
int setChildHint(int h);

40
include/seiscomp/core/archive.inl
View File

@ -47,10 +47,10 @@ namespace {
class IsTypeOf {
class No { };
class Yes { No no[2]; };
static Yes Test(BASECLASS*); // declared, but not defined
static No Test(...); // declared, but not defined
public:
enum { Value = sizeof(Test(static_cast<DERIVEDCLASS*>(0))) == sizeof(Yes) };
};
@ -155,7 +155,7 @@ struct ClassQuery<T,1> {
};
template <typename ROOT_TYPE, typename TYPE>
const char *checkClassName(const ::boost::optional<TYPE>*, const ::boost::optional<TYPE>&) {
const char *checkClassName(const Optional<TYPE>*, const Optional<TYPE>&) {
ClassQuery<TYPE, boost::is_base_of<ROOT_TYPE, TYPE>::value> query;
return query();
}
@ -367,7 +367,7 @@ inline Archive<ROOT_TYPE>& Archive<ROOT_TYPE>::operator>>(T*& object) {
return *this;
//_validObject = true;
read(classname, object, classname);
return *this;
@ -454,13 +454,13 @@ template <typename T>
inline Archive<ROOT_TYPE>& Archive<ROOT_TYPE>::operator>>(const ObjectNamer<T>& namedObject) {
int h = setChildHint(namedObject.hint());
//setHint(h | namedObject.hint());
//_validObject = true;
ContainerReader<ROOT_TYPE,T,boost::is_const<T>::value?1:0> reader;
reader(*this, namedObject);
setHint(h);
return *this;
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
@ -516,7 +516,7 @@ inline Archive<ROOT_TYPE>& Archive<ROOT_TYPE>::operator>>(const ObjectNamer<std:
//setHint(h | namedObject.hint());
typedef typename boost::remove_pointer<T>::type RAW_T;
//_validObject = true;
VectorReader<ROOT_TYPE,T,
@ -544,7 +544,7 @@ inline Archive<ROOT_TYPE>& Archive<ROOT_TYPE>::operator>>(const ObjectNamer<std:
reader(*this, namedObject);
setHint(h);
return *this;
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
@ -600,7 +600,7 @@ inline Archive<ROOT_TYPE>& Archive<ROOT_TYPE>::operator>>(const ObjectNamer<std:
//setHint(h | namedObject.hint());
typedef typename boost::remove_pointer<T>::type RAW_T;
//_validObject = true;
ListReader<ROOT_TYPE,T,
boost::is_class<RAW_T>::value?
@ -626,7 +626,7 @@ inline Archive<ROOT_TYPE>& Archive<ROOT_TYPE>::operator>>(const ObjectNamer<std:
reader(*this, namedObject);
setHint(h);
return *this;
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
@ -673,18 +673,20 @@ inline void Archive<ROOT_TYPE>::read(::boost::intrusive_ptr<T>& object) {
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
template <typename ROOT_TYPE>
template <typename T>
inline void Archive<ROOT_TYPE>::read(::boost::optional<T>& object) {
inline void Archive<ROOT_TYPE>::read(Optional<T>& object) {
bool oldState = success();
object = T();
read(*object);
if ( !success() )
object = boost::none;
if ( !success() ) {
object = None;
}
// Restore old state if not in strict mode otherwise pass it through
if ( !_strict )
if ( !_strict ) {
_validObject = oldState;
}
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
@ -698,7 +700,7 @@ inline void Archive<ROOT_TYPE>::readPtr(ROOT_TYPE*, T*& object) {
if ( (hint() & STATIC_TYPE) == 0 ) {
std::string className = determineClassName();
if ( className.empty() ) return;
if ( !ClassFactoryInterface<ROOT_TYPE>::IsTypeOf(T::ClassName(), className.c_str()) ) {
_validObject = false;
return;
@ -811,12 +813,12 @@ inline void Archive<ROOT_TYPE>::read(const char *name, ::boost::intrusive_ptr<T>
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
template <typename ROOT_TYPE>
template <typename T>
inline void Archive<ROOT_TYPE>::read(const char *name, ::boost::optional<T> &object, const char *targetClass) {
inline void Archive<ROOT_TYPE>::read(const char *name, Optional<T> &object, const char *targetClass) {
if ( findObject(name, targetClass, true) )
read(object);
else {
//_validObject = false;
object = boost::none;
object = None;
}
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
@ -897,7 +899,7 @@ inline void Archive<ROOT_TYPE>::write(const char *name, ::boost::intrusive_ptr<T
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
template <typename ROOT_TYPE>
template <typename T>
inline void Archive<ROOT_TYPE>::write(const char *name, ::boost::optional<T> &object, const char *targetClass) {
write(name, object.get_ptr(), targetClass);
inline void Archive<ROOT_TYPE>::write(const char *name, Optional<T> &object, const char *targetClass) {
write(name, object ? std::addressof(*object) : nullptr, targetClass);
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

2
include/seiscomp/core/array.h
View File

@ -63,7 +63,7 @@ class SC_SYSTEM_CORE_API Array : public Seiscomp::Core::BaseObject {
DataType dataType() const { return _datatype; }
//! Returns a clone of the array
Array* clone() const;
Array *clone() const override;
//! Returns a copy of the array of the specified data type.
virtual Array* copy(DataType dt) const = 0;

691
include/seiscomp/core/datetime.h
View File

@ -17,250 +17,448 @@
* gempa GmbH. *
***************************************************************************/
#ifndef SEISCOMP_CORE_DATETIME_H
#define SEISCOMP_CORE_DATETIME_H
#include <seiscomp/core.h>
#include <seiscomp/core/optional.h>
#ifdef WIN32
#include <winsock.h>
#else
#include <sys/time.h>
#endif
#include <string>
#include <cstdint>
#include <chrono>
#include <limits>
#include <iostream>
#include <cmath>
#include <string_view>
struct tm;
namespace Seiscomp {
namespace Core {
class SC_SYSTEM_CORE_API TimeSpan {
/**
* @brief The TimeSpan class holds the amount of microseconds passed between
* two times.
*
* Internally it is represented with a std::chrono::duration with microsecond
* precision. It can be constructed from a std::chrono::duration object
* Its binary represention is 64bit signed integer regardless of the
* underlying architecture.
*
* The limit of a representable time span is +/-32768 years.
*/
class TimeSpan {
public:
using Storage = int64_t;
using Weeks = std::chrono::duration<Storage, std::ratio<7*86400> >;
using Days = std::chrono::duration<Storage, std::ratio<86400> >;
using Hours = std::chrono::duration<Storage, std::ratio<3600> >;
using Minutes = std::chrono::duration<Storage, std::ratio<60> >;
using Seconds = std::chrono::duration<Storage, std::ratio<1> >;
using MilliSeconds = std::chrono::duration<Storage, std::milli>;
using MicroSeconds = std::chrono::duration<Storage, std::micro>;
using F1 = std::chrono::duration<Storage, std::ratio<1, 10> >;
using F2 = std::chrono::duration<Storage, std::ratio<1, 100> >;
using F3 = std::chrono::duration<Storage, std::ratio<1, 1000> >;
using F4 = std::chrono::duration<Storage, std::ratio<1, 10000> >;
using F5 = std::chrono::duration<Storage, std::ratio<1, 100000> >;
using F6 = std::chrono::duration<Storage, std::ratio<1, 1000000> >;
using Duration = MicroSeconds;
static const double MinSpan;
static const double MaxSpan;
static const Storage MinSeconds;
static const Storage MaxSeconds;
// ----------------------------------------------------------------------
// X'truction
// ----------------------------------------------------------------------
public:
TimeSpan() = default;
TimeSpan(const TimeSpan &other) = default;
constexpr TimeSpan(Storage secs, Storage usecs = 0);
TimeSpan(double ts);
template<typename Rep, typename Period>
constexpr TimeSpan(const std::chrono::duration<Rep, Period> &duration);
// ----------------------------------------------------------------------
// Assignment operators
// ----------------------------------------------------------------------
public:
//! Assigns integer epoch seconds
TimeSpan &operator=(int t);
//! Assigns integer epoch seconds
TimeSpan &operator=(Storage t);
//! Assigns floating point epoch seconds
TimeSpan &operator=(double t);
// ----------------------------------------------------------------------
// Comparison operators
// ----------------------------------------------------------------------
public:
constexpr bool operator==(const TimeSpan &other) const noexcept;
constexpr bool operator!=(const TimeSpan &other) const noexcept;
constexpr bool operator<=(const TimeSpan &other) const noexcept;
constexpr bool operator<(const TimeSpan &other) const noexcept;
constexpr bool operator>=(const TimeSpan &other) const noexcept;
constexpr bool operator>(const TimeSpan &other) const noexcept;
// ----------------------------------------------------------------------
// Arithmetic operators
// ----------------------------------------------------------------------
public:
constexpr TimeSpan operator+(const TimeSpan &other) const;
constexpr TimeSpan operator-(const TimeSpan &other) const;
constexpr TimeSpan operator*(int op) const;
constexpr TimeSpan operator*(size_t op) const;
constexpr TimeSpan operator*(double op) const;
constexpr TimeSpan operator/(int op) const;
constexpr TimeSpan operator/(size_t op) const;
constexpr TimeSpan operator/(double op) const;
constexpr TimeSpan operator-() const;
TimeSpan &operator+=(const TimeSpan &other);
TimeSpan &operator-=(const TimeSpan &other);
TimeSpan &operator*=(int op);
TimeSpan &operator*=(size_t op);
TimeSpan &operator*=(double op);
TimeSpan &operator/=(int op);
TimeSpan &operator/=(size_t op);
TimeSpan &operator/=(double op);
// ----------------------------------------------------------------------
// Conversion operators
// ----------------------------------------------------------------------
public:
constexpr explicit operator Duration() const noexcept;
constexpr explicit operator double() const noexcept;
//! Returns whether the timespan is empty or not.
constexpr explicit operator bool() const noexcept;
//! Returns an std::chrono::time_point
constexpr const Duration &repr() const noexcept;
// ----------------------------------------------------------------------
// Setter and getter
// ----------------------------------------------------------------------
public:
/**
* @brief Returns the maximum number of full seconds of this
* time span.
* @return Number of full seconds.
*/
constexpr Storage seconds() const;
/**
* @brief Returns the fractional part of the time span in
* microseconds.
* The number of microseconds returns is guaranteed to be less than
* one million (1000000).
* @return Fraction in microseconds.
*/
constexpr Storage microseconds() const noexcept;
/**
* @brief Returns this time span expressed in microseconds.
* @return Number of ticks in microseconds.
*/
constexpr Storage count() const noexcept;
//! Returns the absolute value of time
TimeSpan abs() const;
TimeSpan &set(Storage seconds, Storage usecs = 0);
void get(int *days, int *hours = nullptr,
int *minutes = nullptr, int *seconds = nullptr) const;
[[deprecated("Use get() instead")]]
void elapsedTime(int *days, int *hours = nullptr,
int *minutes = nullptr, int *seconds = nullptr) const;
//! Sets the microseconds
TimeSpan &setUSecs(Storage);
/**
* @brief Returns the time span in frational seconds.
* @return Fractional seconds as double.
*/
constexpr double length() const;
// ----------------------------------------------------------------------
// Public interface
// ----------------------------------------------------------------------
public:
/**
* @return A string representing the current time span.
*/
std::string toString() const;
/**
* @brief Converts a string to a time span representation.
* @param sv The input string_view
* @return The conversion result
*/
bool fromString(std::string_view sv);
// ----------------------------------------------------------------------
// Private members
// ----------------------------------------------------------------------
private:
Duration _repr{0};
friend class Time;
};
namespace Literals {
TimeSpan operator "" _weeks(long double weeks);
TimeSpan operator "" _weeks(unsigned long long int weeks);
TimeSpan operator "" _days(long double days);
TimeSpan operator "" _days(unsigned long long int days);
TimeSpan operator "" _hours(long double hours);
TimeSpan operator "" _hours(unsigned long long int hours);
TimeSpan operator "" _minutes(long double minutes);
TimeSpan operator "" _minutes(unsigned long long int minutes);
TimeSpan operator "" _seconds(long double seconds);
TimeSpan operator "" _seconds(unsigned long long int seconds);
TimeSpan operator "" _milliseconds(long double milliseconds);
TimeSpan operator "" _milliseconds(unsigned long long int milliseconds);
}
std::ostream &operator<<(std::ostream &os, const TimeSpan &ts);
/**
* @brief The Time class implements the representation of a point in time
* with microsecond precision.
*
* Internally it is represented with a date::time_point instance from the
* C++ date library of Howard Hinnant [1].
*
* Due to microseconds precision the valid date range is defined from
* -32768-01-01 to 32767-12-31.
*
* [1] https://github.com/HowardHinnant/date
*/
class Time {
// ----------------------------------------------------------------------
// Public types
// ----------------------------------------------------------------------
public:
using Storage = TimeSpan::Storage;
using Duration = TimeSpan::Duration;
using TimePoint = std::chrono::time_point<std::chrono::system_clock, Duration>;
static Time Null;
static const double MinTime;
static const double MaxTime;
// ----------------------------------------------------------------------
// Xstruction
// X'truction
// ----------------------------------------------------------------------
public:
TimeSpan();
TimeSpan(struct timeval*);
TimeSpan(const struct timeval&);
TimeSpan(double);
TimeSpan(long secs, long usecs);
//! Copy constructor
TimeSpan(const TimeSpan&);
// ----------------------------------------------------------------------
// Operators
// ----------------------------------------------------------------------
public:
//! Comparison
bool operator==(const TimeSpan&) const;
bool operator!=(const TimeSpan&) const;
bool operator< (const TimeSpan&) const;
bool operator<=(const TimeSpan&) const;
bool operator> (const TimeSpan&) const;
bool operator>=(const TimeSpan&) const;
//! Conversion
operator double() const;
operator const timeval&() const;
//! Assignment
TimeSpan& operator=(long t);
TimeSpan& operator=(double t);
TimeSpan& operator=(const TimeSpan& t);
//! Arithmetic
TimeSpan operator+(const TimeSpan&) const;
TimeSpan operator-(const TimeSpan&) const;
TimeSpan& operator+=(const TimeSpan&);
TimeSpan& operator-=(const TimeSpan&);
// ----------------------------------------------------------------------
// Interface
// ----------------------------------------------------------------------
public:
//! Returns the absolute value of time
TimeSpan abs() const;
//! Returns the seconds of the timespan
long seconds() const;
//! Returns the microseconds of the timespan
long microseconds() const;
//! Returns the (possibly negative) length of the timespan in seconds
double length() const;
//! Sets the seconds
TimeSpan& set(long seconds);
//! Sets the microseconds
TimeSpan& setUSecs(long);
//! Assigns the elapsed time to the passed out parameters
void elapsedTime(int* days, int* hours = nullptr,
int* minutes = nullptr, int* seconds = nullptr) const;
// ----------------------------------------------------------------------
// Implementation
// ----------------------------------------------------------------------
protected:
struct timeval _timeval;
};
class SC_SYSTEM_CORE_API Time : public TimeSpan {
// ----------------------------------------------------------------------
// Public static data members
// ----------------------------------------------------------------------
public:
static const Time Null;
// ----------------------------------------------------------------------
// Xstruction
// ----------------------------------------------------------------------
public:
Time();
Time(long secs, long usecs);
explicit Time(const TimeSpan&);
explicit Time(const struct timeval&);
explicit Time(struct timeval*);
Time() = default;
Time(const Time &other) = default;
explicit constexpr Time(const TimePoint &tp);
explicit constexpr Time(Storage epochSeconds, Storage microSeconds = 0);
explicit Time(double);
Time(int year, int month, int day,
int hour = 0, int min = 0, int sec = 0,
int usec = 0);
//! Copy constructor
Time(const Time&);
// ----------------------------------------------------------------------
// Operators
// Assignment operators
// ----------------------------------------------------------------------
public:
//! Conversion
operator bool() const;
operator time_t() const;
//! Assignment
Time& operator=(const struct timeval& t);
Time& operator=(struct timeval* t);
Time& operator=(time_t t);
Time& operator=(double t);
//! Arithmetic
Time operator+(const TimeSpan&) const;
Time operator-(const TimeSpan&) const;
TimeSpan operator-(const Time&) const;
Time& operator+=(const TimeSpan&);
Time& operator-=(const TimeSpan&);
Time &operator=(double epoch);
// ----------------------------------------------------------------------
// Interface
// Comparison operators
// ----------------------------------------------------------------------
public:
//! Sets the time
Time& set(int year, int month, int day,
constexpr bool operator==(const Time &other) const noexcept;
constexpr bool operator!=(const Time &other) const noexcept;
constexpr bool operator<(const Time &other) const noexcept;
constexpr bool operator<=(const Time &other) const noexcept;
constexpr bool operator>(const Time &other) const noexcept;
constexpr bool operator>=(const Time &other) const noexcept;
// ----------------------------------------------------------------------
// Arithmetic operators
// ----------------------------------------------------------------------
public:
Time &operator+=(const TimeSpan &ts);
Time &operator-=(const TimeSpan &ts);
constexpr Time operator+(const TimeSpan &ts) const;
constexpr Time operator-(const TimeSpan &ts) const;
constexpr TimeSpan operator-(const Time &tp) const;
// ----------------------------------------------------------------------
// Conversion operators
// ----------------------------------------------------------------------
public:
constexpr explicit operator TimePoint() const noexcept;
constexpr explicit operator double() const noexcept;
[[deprecated("Use OPT(Time) instead")]]
constexpr explicit operator bool() const noexcept;
constexpr const TimePoint &repr() const noexcept;
// ----------------------------------------------------------------------
// Public interface
// ----------------------------------------------------------------------
public:
/**
* @brief Returns whether the time object is a valid time or not.
* Internally the minimum possible value is used to declare an invalid
* time which is for backwards compatibility 1970-01-01 00:00:00.
* @return True if valid, false otherwise.
*/
[[deprecated("Use OPT(Time) instead")]]
constexpr bool valid() const;
/**
* @brief Sets the time object with y/m/d and h/m/s/u individually.
* The resulting time will be defined in seconds from Jan. 1, 1970 UTC.
* If local time is desired then call toLocalTime() afterwards.
* \code
* Time t;
* t.set(2020,1,1,12,00,00).toLocalTime()
* \endcode
* @param year The year between -32767 and 32768
* @param month The month between 1 and 12
* @param day The day between 1 and 31
* @param hour The hour of the day between 0 and 23
* @param min The minute of the hour between 0 and 59
* @param sec The second of the minute between 0 and 59
* @param usec The microseconds of the second between 0 and 999999
* @return this instance
*/
Time &set(int year, int month, int day,
int hour, int min, int sec,
int usec);
//! Sets the time with yday intepreted as the days since January 1st
//! (0-365)
Time& set2(int year, int yday,
int hour, int min, int sec,
int usec);
//! Fill the parameters with the currently set time values
//! @return The error flag
/**
* @brief Retrieves individual date and time components.
* @param year The year between -32767 and 32768
* @param month The month of the year between 1 and 12
* @param day The day of the month between 1 and 31
* @param hour The hour of the day between 0 and 23
* @param min The minute of the hour between 0 and 59
* @param sec The second of the minute between 0 and 59
* @param usec The microseconds of the second between 0 and 999999
* @return Success flag
*/
bool get(int *year, int *month = nullptr, int *day = nullptr,
int *hour = nullptr, int *min = nullptr, int *sec = nullptr,
int *usec = nullptr) const;
//! Fill the parameters with the currently set time values with yday
//! set to the days since January 1st (0-365)
//! @return The error flag
/**
* @brief Sets the time object with y/d and h/m/s/u individually.
* The resulting time will be defined in seconds from Jan. 1, 1970 UTC.
* If local time is desired then call toLocalTime() afterwards.
* \code
* Time t;
* t.set(2020,1,1,12,00,00).toLocalTime()
* \endcode
* @param year The year between -32767 and 32768
* @param yday The day of the year between 0 and 365
* @param hour The hour of the day between 0 and 23
* @param min The minute of the hour between 0 and 59
* @param sec The second of the minute between 0 and 59
* @param usec The microseconds of the second between 0 and 999999
* @return this instance
*/
Time &set2(int year, int yday,
int hour, int min, int sec,
int usec);
/**
* @brief Retrieves individual date and time components.
* @param year The year between -32767 and 32768
* @param yday The day of the year between 0 and 365
* @param hour The hour of the day between 0 and 23
* @param min The minute of the hour between 0 and 59
* @param sec The second of the minute between 0 and 59
* @param usec The microseconds of the second between 0 and 999999
* @return Success flag
*/
bool get2(int *year, int *yday = nullptr,
int *hour = nullptr, int *min = nullptr, int *sec = nullptr,
int *usec = nullptr) const;
//! Returns the current localtime
static Time LocalTime();
/**
* @brief Alias for utc()
* @return The current time in UTC
*/
Time &now();
/**
* @return A string containing the local time zone name/abbreviation
* This is an alias for utc().
* @return The current time in UTC
*/
static std::string LocalTimeZone();
//! Returns the current gmtime
static Time UTC();
//! Alias for UTC()
static Time GMT();
/** Creates a time from the year and the day of the year
@param year The year, including the century (for example, 1988)
@param year_day The day of the year [0..365]
@return The time value
*/
static Time FromYearDay(int year, int year_day);
/**
* @return The offset from UTC/GMT time to local time, essentially
* localtime minus GMT.
*/
TimeSpan localTimeZoneOffset() const;
//! Saves the current localtime in the calling object
Time &localtime();
//! Saves the current gmtime in the calling object
Time &utc();
//! Alias for utc()
Time &gmt();
//! Converts the time to localtime
Time toLocalTime() const;
//! Converts the time to gmtime
Time toUTC() const;
//! Alias for toUTC()
Time toGMT() const;
//! Returns whether the date is valid or not
bool valid() const;
/** Converts the time to string using format fmt.
@param fmt The format string can contain any specifiers
as allowed for strftime. Additional the '%f'
specifier is replaced by the fraction of the seconds.
Example:
toString("%FT%T.%fZ") = "1970-01-01T00:00:00.0000Z"
@return A formatted string
/**
* @return The current time in UTC
*/
std::string toString(const char* fmt) const;
Time &utc();
/**
* Converts the time to a string using the ISO time description
* @return A formatted string
* @return The ISO string of the time in UTC
*/
std::string iso() const;
/**
* @return A string representing the current time point without
* time zone information, UTC time.
*/
std::string toString(const char *format) const;
/**
* @brief Converts the time point to a string in the current
* system's time zone.
* @param format The string format.
* @return The formatted string
*/
std::string toLocalString(const char *format) const;
/**
* @brief Converts the time point to a string in a given
* time zone.
* This method may throw an std::runtime_error if the provided time
* zone does not exist.
* @param format The string format.
* @return The formatted string
*/
std::string toZonedString(const char *format, const std::string &tz) const;
/**
* Converts a string into a time representation.
* @param str The string representation of the time
* @return The conversion result
*/
bool fromString(std::string_view sv);
/**
* Converts a string into a time representation.
* @param str The string representation of the time
@ -268,43 +466,120 @@ class SC_SYSTEM_CORE_API Time : public TimeSpan {
* specification (-> toString)
* @return The conversion result
*/
bool fromString(const char* str, const char* fmt);
bool fromString(std::string_view sv, const char *format);
/**
* Converts a string into a time representation.
* @brief Converts a string to a Time object.
* This method throws a runtime_error if the input string cannot
* be parsed into a valid Time.
* @param str The string representation of the time
* @return The conversion result
* @return A Time object
*/
bool fromString(const char* str);
static Time FromString(const std::string &str);
/**
* Converts a string into a time representation.
* @brief Converts a string to a Time object.
* This method throws a runtime_error if the input string cannot
* be parsed into a valid Time given the format.
* @param str The string representation of the time
* @return The conversion result
* @param fmt The format string containing the conversion
* specification (-> toString)
* @return A Time object
*/
bool fromString(const std::string &str);
static Time FromString(const std::string &str, const char *format);
/**
* Static method to create a time value from a string.
* The parameters are the same as in Time::fromString.
*/
static Time FromString(const char* str, const char* fmt);
* @brief Constructs a time object from a year and the day of the year.
* @param year The year between -32767 and 32768
* @param doy The day of the year between 1 and 366. Note that in
* contrast to set2 and get2 the doy is not starting with 0
* at January 1st but with 1.
* @return
*/
static Time FromYearDay(int year, int doy);
/**
* Static method to convert a time from a string without
* an explicit format.
* @param str The string representation of the time.
* @return None if conversion failed, a valid instance otherwise.
* @return The number of seconds since Jan. 1, 1970.
*
* Backwards compatibility alias for epochSeconds().
*/
static OPT(Time) FromString(const char* str);
[[deprecated("Use epochSeconds() instead")]]
constexpr Storage seconds() const;
/**
* Convenience method for fromString(const char*).
* @return The number of seconds since Jan. 1, 1970.
*/
static OPT(Time) FromString(const std::string &str);
constexpr Storage epochSeconds() const;
/**
* @return The number of seconds with fractional seconds since
* Jan. 1, 1970.
*/
constexpr double epoch() const;
/**
* @return Seconds fraction.
*/
constexpr int microseconds() const;
Time &setUSecs(Storage ms);
static Time FromEpoch(Storage secs, Storage usecs);
static Time FromEpoch(double secs);
//! Returns the current time in UTC. This is an alias for UTC().
static Time Now();
//! Returns the current time in GMT. This is an alias for UTC().
[[deprecated("Use UTC() instead")]] static Time GMT();
//! Returns the current time in UTC
static Time UTC();
//! Returns the current time as UTC plus the time zone offset.
static Time LocalTime();
static std::string LocalTimeZone();
//! Converts the time of the UTC representation to local time.
//! This effectively adds the local timezone offset.
Time toLocalTime() const;
//! Converts the time of the local time representation to UTC. This
//! effectively removes the local timezone offset.
Time toUTC() const;
//! Converts the time of the local time representation to UTC. This
//! effectively removes the local timezone offset.
[[deprecated("Use toUTC() instead")]] Time toGMT() const;
/**
* @brief Returns the local timezone offset with respect to the
* time currently stored.
* @return The local timezone offset as @TimeSpan
*/
TimeSpan localTimeZoneOffset() const;
/**
* @brief Returns the timezone offset for a given timezone.
*
* If the timezone is unknown then a runtime_error will be thrown.
* @return The timezone offset as @TimeSpan
*/
TimeSpan timeZoneOffset(const std::string &tzName) const;
private:
TimePoint _repr{Duration{0}};
};
std::ostream &operator<<(std::ostream &os, const Time &time);
#include "datetime.ipp"
}
}

546
include/seiscomp/core/datetime.ipp Normal file
View File

@ -0,0 +1,546 @@
// --------------------------------------------------------------------------
// Implementation of inline functions
// --------------------------------------------------------------------------
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
inline constexpr TimeSpan::TimeSpan(Storage secs, Storage usecs)
: _repr(Seconds(secs) + MicroSeconds(usecs)) {}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
inline TimeSpan::TimeSpan(double ts) {
*this = ts;
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
template<typename Rep, typename Period>
inline constexpr TimeSpan::TimeSpan(const std::chrono::duration<Rep, Period> &duration)
: _repr(std::chrono::duration_cast<Duration>(duration)) {}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
inline constexpr bool TimeSpan::operator==(const TimeSpan &other) const noexcept {
return _repr == other._repr;
}
inline constexpr bool TimeSpan::operator!=(const TimeSpan &other) const noexcept {
return _repr != other._repr;
}
inline constexpr bool TimeSpan::operator<=(const TimeSpan &other) const noexcept {
return _repr <= other._repr;
}
inline constexpr bool TimeSpan::operator<(const TimeSpan &other) const noexcept {
return _repr < other._repr;
}
inline constexpr bool TimeSpan::operator>=(const TimeSpan &other) const noexcept {
return _repr >= other._repr;
}
inline constexpr bool TimeSpan::operator>(const TimeSpan &other) const noexcept {
return _repr > other._repr;
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
inline constexpr TimeSpan TimeSpan::operator+(const TimeSpan &other) const {
return TimeSpan(_repr + other._repr);
}
inline constexpr TimeSpan TimeSpan::operator-(const TimeSpan &other) const {
return TimeSpan(_repr - other._repr);
}
inline constexpr TimeSpan TimeSpan::operator*(int op) const {
return TimeSpan(Duration(Storage(_repr.count() * op)));
}
inline constexpr TimeSpan TimeSpan::operator*(size_t op) const {
return TimeSpan(Duration(Storage(_repr.count() * op)));
}
inline constexpr TimeSpan TimeSpan::operator*(double op) const {
return TimeSpan(Duration(Storage(_repr.count() * op)));
}
inline constexpr TimeSpan TimeSpan::operator/(int op) const {
return TimeSpan(Duration(Storage(_repr.count() / op)));
}
inline constexpr TimeSpan TimeSpan::operator/(size_t op) const {
return TimeSpan(Duration(Storage(_repr.count() / op)));
}
inline constexpr TimeSpan TimeSpan::operator/(double op) const {
return TimeSpan(Duration(Storage(_repr.count() / op)));
}
inline constexpr TimeSpan TimeSpan::operator-() const {
return TimeSpan(Duration(Storage(-_repr.count())));
}
inline TimeSpan &TimeSpan::operator+=(const TimeSpan &other) {
_repr += other._repr;
return *this;
}
inline TimeSpan &TimeSpan::operator-=(const TimeSpan &other) {
_repr -= other._repr;
return *this;
}
inline TimeSpan &TimeSpan::operator*=(int op) {
_repr = Duration(Storage(_repr.count() * op));
return *this;
}
inline TimeSpan &TimeSpan::operator*=(size_t op) {
_repr = Duration(Storage(_repr.count() * op));
return *this;
}
inline TimeSpan &TimeSpan::operator*=(double op) {
_repr = Duration(Storage(_repr.count() * op));
return *this;
}
inline TimeSpan &TimeSpan::operator/=(int op) {
_repr = Duration(Storage(_repr.count() / op));
return *this;
}
inline TimeSpan &TimeSpan::operator/=(size_t op) {
_repr = Duration(Storage(_repr.count() / op));
return *this;
}
inline TimeSpan &TimeSpan::operator/=(double op) {
_repr = Duration(Storage(_repr.count() / op));
return *this;
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
inline constexpr TimeSpan::operator Duration() const noexcept {
return _repr;
}
inline constexpr TimeSpan::operator double() const noexcept {
return length();
}
inline constexpr TimeSpan::operator bool() const noexcept {
return count() > 0;
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
inline constexpr const TimeSpan::Duration &TimeSpan::repr() const noexcept {
return _repr;
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
namespace Literals {
inline TimeSpan operator "" _weeks(long double weeks) {
using namespace std::chrono;
return duration_cast<TimeSpan::Duration>(duration<double, std::ratio<86400*7> >(weeks));
}
inline TimeSpan operator "" _weeks(unsigned long long int weeks) {
using namespace std::chrono;
return duration_cast<TimeSpan::Duration>(duration<unsigned long long int, std::ratio<86400*7> >(weeks));
}
inline TimeSpan operator "" _days(long double days) {
using namespace std::chrono;
return duration_cast<TimeSpan::Duration>(duration<double, std::ratio<86400> >(days));
}
inline TimeSpan operator "" _days(unsigned long long int days) {
using namespace std::chrono;
return duration_cast<TimeSpan::Duration>(duration<unsigned long long int, std::ratio<86400> >(days));
}
inline TimeSpan operator "" _hours(long double hours) {
using namespace std::chrono;
return duration_cast<TimeSpan::Duration>(duration<double, std::ratio<3600> >(hours));
}
inline TimeSpan operator "" _hours(unsigned long long int hours) {
using namespace std::chrono;
return duration_cast<TimeSpan::Duration>(duration<unsigned long long int, std::ratio<3600> >(hours));
}
inline TimeSpan operator "" _minutes(long double minutes) {
using namespace std::chrono;
return duration_cast<TimeSpan::Duration>(duration<double, std::ratio<60> >(minutes));
}
inline TimeSpan operator "" _minutes(unsigned long long int minutes) {
using namespace std::chrono;
return duration_cast<TimeSpan::Duration>(duration<unsigned long long int, std::ratio<60> >(minutes));
}
inline TimeSpan operator "" _seconds(long double seconds) {
using namespace std::chrono;
return duration_cast<TimeSpan::Duration>(duration<double, std::ratio<1> >(seconds));
}
inline TimeSpan operator "" _seconds(unsigned long long int seconds) {
using namespace std::chrono;
return duration_cast<TimeSpan::Duration>(duration<unsigned long long int, std::ratio<1> >(seconds));
}
inline TimeSpan operator "" _milliseconds(long double mseconds) {
using namespace std::chrono;
return duration_cast<TimeSpan::Duration>(duration<double, std::ratio<1, 1000> >(mseconds));
}
inline TimeSpan operator "" _milliseconds(unsigned long long int mseconds) {
using namespace std::chrono;
return duration_cast<TimeSpan::Duration>(duration<unsigned long long int, std::ratio<1, 1000> >(mseconds));
}
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
inline void TimeSpan::elapsedTime(int* days, int* hours,
int* minutes, int* seconds) const {
get(days, hours, minutes, seconds);
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
inline constexpr TimeSpan::Storage TimeSpan::seconds() const {
return std::chrono::duration_cast<Seconds>(_repr).count();
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
inline constexpr TimeSpan::Storage TimeSpan::microseconds() const noexcept {
// _repr is microseconds
return _repr.count() % 1000000;
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
inline constexpr TimeSpan::Storage TimeSpan::count() const noexcept {
return _repr.count();
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
inline TimeSpan &TimeSpan::set(Storage secs, Storage usecs) {
using namespace std::chrono;
_repr = MicroSeconds(secs * 1000000 + usecs);
return *this;
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
inline TimeSpan &TimeSpan::setUSecs(Storage usecs) {
using namespace std::chrono;
_repr = MicroSeconds(seconds() * 1000000 + usecs);
return *this;
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
inline constexpr double TimeSpan::length() const {
return std::chrono::duration_cast<MicroSeconds>(_repr).count() * 1E-6;
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
inline constexpr Time::Time(Storage epochSeconds, Storage epochMicroSeconds)
: _repr(TimePoint(TimeSpan::Seconds(epochSeconds) + TimeSpan::MicroSeconds(epochMicroSeconds)))
{}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
inline constexpr Time::Time(const TimePoint &tp) : _repr(tp) {}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
inline constexpr bool Time::operator==(const Time &other) const noexcept {
return _repr == other._repr;
}
inline constexpr bool Time::operator!=(const Time &other) const noexcept {
return _repr != other._repr;
}
inline constexpr bool Time::operator<(const Time &other) const noexcept {
return _repr < other._repr;
}
inline constexpr bool Time::operator<=(const Time &other) const noexcept {
return _repr <= other._repr;
}
inline constexpr bool Time::operator>(const Time &other) const noexcept {
return _repr > other._repr;
}
inline constexpr bool Time::operator>=(const Time &other) const noexcept {
return _repr >= other._repr;
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
inline Time &Time::operator+=(const TimeSpan &ts) {
_repr += ts._repr;
return *this;
}
inline Time &Time::operator-=(const TimeSpan &ts) {
_repr -= ts._repr;
return *this;
}
inline constexpr Time Time::operator+(const TimeSpan &ts) const {
return Time(_repr + ts._repr);
}
inline constexpr Time Time::operator-(const TimeSpan &ts) const {
return Time(_repr - ts._repr);
}
inline constexpr TimeSpan Time::operator-(const Time &tp) const {
return TimeSpan(_repr - tp._repr);
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
inline constexpr Time::operator TimePoint() const noexcept {
return _repr;
}
inline constexpr Time::operator double() const noexcept {
return epoch();
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
inline constexpr bool Time::valid() const {
return *this != Null;
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
inline constexpr Time::operator bool() const noexcept {
return *this != Null;
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
inline constexpr const Time::TimePoint &Time::repr() const noexcept {
return _repr;
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
inline constexpr Time::Storage Time::seconds() const {
return epochSeconds();
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
inline constexpr Time::Storage Time::epochSeconds() const {
return std::chrono::duration_cast<std::chrono::seconds>(_repr.time_since_epoch()).count();
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
inline constexpr double Time::epoch() const {
return std::chrono::duration_cast<std::chrono::microseconds>(_repr.time_since_epoch()).count() * 1E-6;
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
inline Time &Time::setUSecs(Storage usecs) {
using namespace std::chrono;
_repr = TimePoint(
std::chrono::duration_cast<Duration>(
TimeSpan::MicroSeconds(
static_cast<Storage>(
std::chrono::duration_cast<std::chrono::seconds>(
_repr.time_since_epoch()
).count() * 1000000 + usecs
)
)
)
);
return *this;
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
inline constexpr int Time::microseconds() const {
return std::chrono::duration_cast<std::chrono::microseconds>(_repr.time_since_epoch()).count() % 1000000;
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
inline Time &Time::gmt() {
return utc();
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
inline Time Time::UTC() {
return Now();
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
inline Time Time::LocalTime() {
return UTC().toLocalTime();
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
inline Time Time::GMT() {
return Now();
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
inline Time Time::Now() {
return Time().now();
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
inline Time Time::toLocalTime() const {
return *this + localTimeZoneOffset();
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
inline Time Time::toUTC() const {
return *this - localTimeZoneOffset();
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
inline Time Time::toGMT() const {
return toUTC();
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

8
include/seiscomp/core/defs.h
View File

@ -30,9 +30,7 @@ namespace Core {
template <typename T>
struct SmartPointer {
typedef ::boost::intrusive_ptr<T> Impl;
};
using SmartPointer = ::boost::intrusive_ptr<T>;
template <typename B, typename D>
@ -52,10 +50,10 @@ struct isTypeOf {
#define TYPEDEF_SMARTPOINTER(classname) \
typedef Seiscomp::Core::SmartPointer<classname>::Impl classname##Ptr
using classname##Ptr = Seiscomp::Core::SmartPointer<classname>
#define TYPEDEF_CONST_SMARTPOINTER(classname) \
typedef Seiscomp::Core::SmartPointer<const classname>::Impl classname##CPtr
using classname##CPtr = Seiscomp::Core::SmartPointer<const classname>
#define DEFINE_SMARTPOINTER(classname) \
class classname; \

5
include/seiscomp/core/enumeration.h
View File

@ -25,6 +25,7 @@
#include <seiscomp/core/io.h>
#include <ostream>
#include <string_view>
#include <fmt/ostream.h>
@ -48,7 +49,7 @@ class SC_SYSTEM_CORE_API Enumeration {
* case sensitive.
* @return The result of the conversion
*/
virtual bool fromString(const std::string &str) = 0;
virtual bool fromString(std::string_view sv) = 0;
/**
* Converts an enumeration value to an integer
@ -160,7 +161,7 @@ class Enum : public Enumeration {
// ------------------------------------------------------------------
public:
const char *toString() const override;
bool fromString(const std::string &str) override;
bool fromString(std::string_view sv) override;
int toInt() const override;
bool fromInt(int value) override;

8
include/seiscomp/core/enumeration.inl
View File

@ -90,13 +90,15 @@ inline const char* Enum<ENUMTYPE, END, NAMES>::toString() const {
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
template <typename ENUMTYPE, ENUMTYPE END, typename NAMES>
inline bool
Enum<ENUMTYPE, END, NAMES>::fromString(const std::string& str) {
Enum<ENUMTYPE, END, NAMES>::fromString(std::string_view sv) {
int index = int(0);
while( str != std::string(NAMES::name(index-0)) ) {
while ( sv != NAMES::name(index - 0) ) {
++index;
if ( index >= int(END) )
if ( index >= int(END) ) {
return false;
}
}
_value = static_cast<ENUMTYPE>(index);

4
include/seiscomp/core/exceptions.h
View File

@ -37,8 +37,8 @@ class SC_SYSTEM_CORE_API GeneralException : public std::exception {
GeneralException( const std::string& str);
virtual ~GeneralException() throw();
virtual const char* what( void ) const throw();
virtual const char* what( void ) const throw() override;
private:
std::string _descr;

18
include/seiscomp/core/factory.h
View File

@ -62,8 +62,9 @@ class ClassFactoryInterface {
using RootType = ROOT_TYPE;
using ClassPool = std::map<std::string, ClassFactoryInterface<ROOT_TYPE>*>;
using ClassNames = std::map<const RTTI*, std::string>;
using NameList = std::list<std::string>;
// ----------------------------------------------------------------------
// X'truction
// ----------------------------------------------------------------------
@ -93,12 +94,17 @@ class ClassFactoryInterface {
static const char* ClassName(const RTTI *rtti);
//! Looks up a class factory for a given class name
static ClassFactoryInterface* FindByClassName(const char *className);
static ClassFactoryInterface *FindByClassName(const char *className);
static ClassFactoryInterface *FindByClassName(const std::string &className);
static bool IsTypeOf(const char *baseName, const char *derivedName);
//! Returns the number of registered classes
static unsigned int NumberOfRegisteredClasses();
//! Returns the number of registered classes. This is equal to
//! Classes().size().
static size_t NumberOfRegisteredClasses();
//! Returns the registered classes.
static const ClassNames &RegisteredClasses();
//! Returns the name of the class (as given during construction) which can be created
//! by this factory
@ -167,7 +173,7 @@ class AbstractClassFactory : public ClassFactoryInterface<ROOT_TYPE> {
protected:
//! Always returns nullptr
ROOT_TYPE *create() const;
ROOT_TYPE *create() const override;
};
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
@ -200,7 +206,7 @@ class ClassFactory : public ClassFactoryInterface<ROOT_TYPE> {
protected:
//! The actual creation
ROOT_TYPE* create() const;
ROOT_TYPE* create() const override;
};

39
include/seiscomp/core/factory.ipp
View File

@ -124,12 +124,14 @@ const char *ClassFactoryInterface<ROOT_TYPE>::ClassName(const RTTI *info) {
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
template <typename ROOT_TYPE>
ClassFactoryInterface<ROOT_TYPE> *ClassFactoryInterface<ROOT_TYPE>::FindByClassName(const char *className) {
if ( !className )
if ( !className ) {
return nullptr;
}
typename ClassPool::iterator it = Classes().find(className);
if ( it == Classes().end() )
auto it = Classes().find(className);
if ( it == Classes().end() ) {
return nullptr;
}
return (*it).second;
}
@ -140,8 +142,33 @@ ClassFactoryInterface<ROOT_TYPE> *ClassFactoryInterface<ROOT_TYPE>::FindByClassN
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
template <typename ROOT_TYPE>
unsigned int ClassFactoryInterface<ROOT_TYPE>::NumberOfRegisteredClasses() {
return static_cast<unsigned int>(Classes().size());
ClassFactoryInterface<ROOT_TYPE> *
ClassFactoryInterface<ROOT_TYPE>::FindByClassName(const std::string &className) {
if ( auto it = Classes().find(className); it != Classes().end() ) {
return it->second;
}
return nullptr;
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
template <typename ROOT_TYPE>
size_t ClassFactoryInterface<ROOT_TYPE>::NumberOfRegisteredClasses() {
return Classes().size();
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
template <typename ROOT_TYPE>
const typename ClassFactoryInterface<ROOT_TYPE>::ClassNames &
ClassFactoryInterface<ROOT_TYPE>::RegisteredClasses() {
return Names();
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
@ -216,7 +243,7 @@ bool ClassFactoryInterface<ROOT_TYPE>::RegisterFactory(ClassFactoryInterface<ROO
Classes()[factory->className()] = factory;
Names()[factory->typeInfo()] = factory->className();
return true;
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

20
include/seiscomp/core/genericmessage.h
View File

@ -42,7 +42,7 @@ class GenericMessage : public ::Seiscomp::Core::Message {
// ----------------------------------------------------------------------
public:
using AttachmentType = T;
using AttachmentList = std::list<typename Seiscomp::Core::SmartPointer<T>::Impl>;
using AttachmentList = std::list<Seiscomp::Core::SmartPointer<T>>;
typedef typename AttachmentList::iterator iterator;
typedef typename AttachmentList::const_iterator const_iterator;
@ -70,8 +70,8 @@ class GenericMessage : public ::Seiscomp::Core::Message {
* @retval true The operation was successfull and the object has been attached properly
* @retval false The object is nullptr or the object has been attached already
*/
bool attach(AttachmentType* attachment);
bool attach(typename Seiscomp::Core::SmartPointer<AttachmentType>::Impl& attachment);
bool attach(AttachmentType *attachment);
bool attach(typename Seiscomp::Core::SmartPointer<AttachmentType> &attachment);
/**
* Detaches an already attached object from the message
@ -79,8 +79,8 @@ class GenericMessage : public ::Seiscomp::Core::Message {
* @retval true The object has been detached successfully
* @retval false The object has not been attached before
*/
bool detach(AttachmentType* attachment);
bool detach(typename Seiscomp::Core::SmartPointer<AttachmentType>::Impl& attachment);
bool detach(AttachmentType *attachment);
bool detach(typename Seiscomp::Core::SmartPointer<AttachmentType> &attachment);
/**
* Detaches an object from the message
@ -91,7 +91,7 @@ class GenericMessage : public ::Seiscomp::Core::Message {
iterator detach(iterator it);
//! Removes all attachments from the message
void clear();
virtual void clear() override;
//! Returns the iterators for begin and end of
//! the attachment list
@ -102,19 +102,19 @@ class GenericMessage : public ::Seiscomp::Core::Message {
const_iterator end() const;
//! Implemented from baseclass
bool empty() const;
bool empty() const override;
/**
* @return Returns the number of objects attached to a message
*/
int size() const;
int size() const override;
// ----------------------------------------------------------------------
// Protected interface
// ----------------------------------------------------------------------
protected:
MessageIterator::Impl* iterImpl() const;
MessageIterator::Impl* iterImpl() const override;
// ----------------------------------------------------------------------
// Implementation
@ -132,7 +132,7 @@ class GenericMessage : public ::Seiscomp::Core::Message {
class APIDef TYPENAME : public ::Seiscomp::Core::GenericMessage<CLASS> { \
DECLARE_SC_CLASS(TYPENAME); \
}; \
typedef ::Seiscomp::Core::SmartPointer<TYPENAME>::Impl TYPENAME##Ptr
using TYPENAME##Ptr = ::Seiscomp::Core::SmartPointer<TYPENAME>
#define IMPLEMENT_MESSAGE_FOR(CLASS, TYPENAME, NAME) \
IMPLEMENT_SC_CLASS_DERIVED(TYPENAME, ::Seiscomp::Core::Message, NAME)

18
include/seiscomp/core/genericmessage.ipp
View File

@ -26,15 +26,15 @@ class MessageIteratorImplT : public MessageIterator::Impl {
: _it(it), _end(end) {}
public:
MessageIterator::Impl* clone() const {
MessageIterator::Impl* clone() const override {
return new MessageIteratorImplT<T>(_it, _end);
}
Seiscomp::Core::BaseObject* get() const {
Seiscomp::Core::BaseObject* get() const override {
return _it == _end?nullptr:(*_it).get();
}
void next() {
void next() override {
++_it;
}
@ -86,10 +86,10 @@ inline bool GenericMessage<T>::attach(AttachmentType* attachment) {
iterator it = std::find(_attachments.begin(), _attachments.end(), attachment);
if ( it != _attachments.end() )
return false;
_attachments.push_back(attachment);
return true;
return true;
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
@ -98,9 +98,9 @@ inline bool GenericMessage<T>::attach(AttachmentType* attachment) {
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
template <typename T>
inline bool GenericMessage<T>::attach(typename Seiscomp::Core::SmartPointer<AttachmentType>::Impl& attachment) {
inline bool GenericMessage<T>::attach(typename Seiscomp::Core::SmartPointer<AttachmentType> &attachment) {
return attach(attachment.get());
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
@ -124,7 +124,7 @@ inline bool GenericMessage<T>::detach(AttachmentType* attachment) {
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
template <typename T>
inline bool GenericMessage<T>::detach(typename Seiscomp::Core::SmartPointer<AttachmentType>::Impl& attachment) {
inline bool GenericMessage<T>::detach(typename Seiscomp::Core::SmartPointer<AttachmentType> &attachment) {
return detach(attachment.get());
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

30
include/seiscomp/core/genericrecord.h
View File

@ -44,23 +44,23 @@ class SC_SYSTEM_CORE_API GenericRecord : public Record {
public:
//! Default Constructor
GenericRecord(Array::DataType dt = Array::DOUBLE, Hint h = DATA_ONLY);
//! Initializing Constructor
GenericRecord(std::string net, std::string sta,
std::string loc, std::string cha,
Core::Time stime, double fsamp, int tqual = -1,
Array::DataType dt = Array::DOUBLE,
Hint h = DATA_ONLY);
//! Copy Constructor
GenericRecord(const GenericRecord& rec);
//! Another Constructor
GenericRecord(const Record& rec);
//! Destructor
virtual ~GenericRecord();
// ----------------------------------------------------------------------
// Operators
@ -68,7 +68,7 @@ class SC_SYSTEM_CORE_API GenericRecord : public Record {
public:
//! Assignment operator
GenericRecord& operator=(const GenericRecord& rec);
// ----------------------------------------------------------------------
// Public interface
@ -78,20 +78,20 @@ class SC_SYSTEM_CORE_API GenericRecord : public Record {
void setSamplingFrequency(double freq);
//! Returns the data samples if the data is available; otherwise 0
Array* data();
Array *data();
//! Returns the data samples if the data is available; otherwise 0
const Array* data() const;
const Array* data() const override;
//! Same as data()
const Array* raw() const;
const Array* raw() const override;
//! Returns the clipmask. The size of the clipmask matches the size
//! of the data array and each element (bit) is set to one if the
//! sample at the same index is clipped. The returned pointer is
//! managed by this instance and must not be deleted. But it is safe
//! to store it in a smart pointer.
const BitSet *clipMask() const;
const BitSet *clipMask() const override;
//! Sets the data sample array. The ownership goes over to the record.
//! Note that this call will remove any clip mask set with previous
@ -113,14 +113,14 @@ class SC_SYSTEM_CORE_API GenericRecord : public Record {
void dataUpdated();
//! This method does nothing.
void saveSpace() const;
void saveSpace() const override;
//! Returns a deep copy of the calling object.
Record* copy() const;
Record* copy() const override;
void read(std::istream &in) override;
void write(std::ostream &out) override;
void read(std::istream &in);
void write(std::ostream &out);
// ----------------------------------------------------------------------
// Private members
@ -129,7 +129,7 @@ class SC_SYSTEM_CORE_API GenericRecord : public Record {
ArrayPtr _data;
BitSetPtr _clipMask;
};
}
#endif

2
include/seiscomp/core/interfacefactory.h
View File

@ -114,7 +114,7 @@ class InterfaceFactory : public InterfaceFactoryInterface<T> {
public:
//! The actual creation
typename InterfaceFactoryInterface<T>::Interface* create() const { return new TYPE; }
typename InterfaceFactoryInterface<T>::Interface* create() const override { return new TYPE; }
};
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

14
include/seiscomp/core/metaobject.h
View File

@ -39,7 +39,19 @@ namespace Core {
class BaseObject;
typedef boost::any MetaValue;
using MetaValue = boost::any;
template<typename ValueType>
inline ValueType metaValueCast(const MetaValue &operand) {
return boost::any_cast<ValueType>(operand);
}
template<typename ValueType>
inline ValueType metaValueCast(MetaValue &&operand) {
return boost::any_cast<ValueType>(operand);
}
using BadMetaValueCast = boost::bad_any_cast;
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

34
include/seiscomp/core/metaproperty.h
View File

@ -36,7 +36,7 @@ class Yes { No no[2]; };
template <typename T>
Yes isOptionalTester(boost::optional<T>*);
Yes isOptionalTester(Optional<T>*);
No isOptionalTester(void*);
@ -84,13 +84,13 @@ class MetaEnumImpl : public MetaEnum {
MetaEnumImpl() : MetaEnum() {}
public:
int keyCount() const { return T::Quantity; }
int keyCount() const override { return T::Quantity; }
//! Returns the key name at a given index
const char *key(int index) const;
const char *key(int index) const override;
const char *valueToKey(int value) const;
int keyToValue(const char *key) const;
const char *valueToKey(int value) const override;
int keyToValue(const char *key) const override;
};
#define DECLARE_METAENUM(CLASS, var) Seiscomp::Core::MetaEnumImpl<CLASS> var
@ -148,7 +148,7 @@ class MetaClassProperty : public MetaProperty {
public:
BaseObject *createClass() const {
BaseObject *createClass() const override {
return new T();
}
};
@ -235,14 +235,14 @@ class SimplePropertyHelper<T,U,F1,F2,0> : public MetaProperty {
SimplePropertyHelper(F1 setter, F2 getter)
: _setter(setter), _getter(getter) {}
bool write(BaseObject *object, MetaValue value) const {
bool write(BaseObject *object, MetaValue value) const override {
T *target = T::Cast(object);
if ( !target ) return false;
(target->*_setter)(boost::any_cast<U>(value));
(target->*_setter)(metaValueCast<U>(value));
return true;
}
bool writeString(BaseObject *object, const std::string &value) const {
bool writeString(BaseObject *object, const std::string &value) const override {
T *target = T::Cast(object);
if ( !target ) return false;
@ -254,13 +254,13 @@ class SimplePropertyHelper<T,U,F1,F2,0> : public MetaProperty {
return true;
}
MetaValue read(const BaseObject *object) const {
MetaValue read(const BaseObject *object) const override {
const T *target = T::ConstCast(object);
if ( !target ) throw GeneralException("invalid object");
return (target->*_getter)();
}
std::string readString(const BaseObject *object) const {
std::string readString(const BaseObject *object) const override {
const T *target = T::ConstCast(object);
if ( !target ) throw GeneralException("invalid object");
return toString((target->*_getter)());
@ -277,18 +277,18 @@ class SimplePropertyHelper<T,U,F1,F2,1> : public MetaProperty {
SimplePropertyHelper(F1 setter, F2 getter)
: _setter(setter), _getter(getter) {}
bool write(BaseObject *object, MetaValue value) const {
bool write(BaseObject *object, MetaValue value) const override {
T *target = T::Cast(object);
if ( !target ) return false;
if ( value.empty() )
(target->*_setter)(Core::None);
else
(target->*_setter)(boost::any_cast<U>(value));
(target->*_setter)(metaValueCast<U>(value));
return true;
}
bool writeString(BaseObject *object, const std::string &value) const {
bool writeString(BaseObject *object, const std::string &value) const override {
T *target = T::Cast(object);
if ( !target ) return false;
@ -298,19 +298,19 @@ class SimplePropertyHelper<T,U,F1,F2,1> : public MetaProperty {
typename Core::Generic::remove_optional<U>::type tmp;
if ( !fromString(tmp, value) )
return false;
(target->*_setter)(tmp);
}
return true;
}
MetaValue read(const BaseObject *object) const {
MetaValue read(const BaseObject *object) const override {
const T *target = T::ConstCast(object);
if ( !target ) throw GeneralException("invalid object");
return (target->*_getter)();
}
std::string readString(const BaseObject *object) const {
std::string readString(const BaseObject *object) const override {
const T *target = T::ConstCast(object);
if ( !target ) throw GeneralException("invalid object");
return toString((target->*_getter)());

54
include/seiscomp/core/optional.h
View File

@ -21,41 +21,66 @@
#ifndef SEISCOMP_CORE_OPTIONAL_H
#define SEISCOMP_CORE_OPTIONAL_H
#include <seiscomp/core.h>
#include <exception>
#include <boost/optional.hpp>
#include <boost/none.hpp>
#include <exception>
#include <optional>
#include <type_traits>
namespace Seiscomp {
namespace Core {
/** \brief Redefines boost::optional<T>
/** \brief Redefines std::optional<T>
* Optional values can be set or unset.
* \code
* void print(const Optional<int>::Impl& v) {
* void print(const Optional<int> &v) {
* if ( !v )
* cout << "value of v is not set" << endl;
* else
* cout << *v << endl;
* }
*
* Optional<int>::Impl a = 5;
* Optional<int> a = 5;
* print(a); // output: "5"
* a = None;
* print(a); // output: "value of v is not set"
* \endcode
*/
template <typename T>
struct Optional {
typedef ::boost::optional<T> Impl;
};
using Optional = ::std::optional<T>;
using NoneType = ::std::nullopt_t;
/** Defines None */
SC_SYSTEM_CORE_API extern ::boost::none_t const None;
SC_SYSTEM_CORE_API extern NoneType const None;
template <class...>
struct False : std::integral_constant<bool, false> {};
template <class...>
struct True : std::integral_constant<bool, true> {};
// Checks whether a type is wrapped with optional or not.
template <typename>
struct isOptional : std::false_type {};
template<template<class...> class U, typename ...Args>
struct isOptional<U<Args...>>
: std::integral_constant<
bool,
std::is_base_of<std::optional<Args...>, U<Args...>>::value
|| std::is_base_of<boost::optional<Args...>, U<Args...>>::value
> {};
template <typename T>
T value(const boost::optional<T>&);
T value(const Optional<T>&);
class SC_SYSTEM_CORE_API ValueError : public std::exception {
public:
@ -63,16 +88,19 @@ class SC_SYSTEM_CORE_API ValueError : public std::exception {
~ValueError() throw();
public:
const char* what() const throw();
const char* what() const throw() override;
};
/** Macro to use optional values easily */
#define OPT(T) Seiscomp::Core::Optional<T>::Impl
#define OPT(T) Seiscomp::Core::Optional<T>
/** Macro to use optional values as const reference */
#define OPT_CR(T) const Seiscomp::Core::Optional<T>::Impl&
#define OPT_CR(T) const Seiscomp::Core::Optional<T>&
#include <seiscomp/core/optional.inl>
}
}

2
include/seiscomp/core/optional.inl
View File

@ -19,7 +19,7 @@
template <typename T>
T value(const boost::optional<T>& v) {
T value(const Optional<T>& v) {
if ( v )
return *v;

50
include/seiscomp/core/recordsequence.h
View File

@ -43,8 +43,8 @@ class SC_SYSTEM_CORE_API RecordSequence : public std::deque<RecordCPtr> {
// Public types
// ----------------------------------------------------------------------
public:
typedef std::deque<Core::TimeWindow> TimeWindowArray;
typedef std::pair<double,double> Range;
using TimeWindowArray = std::deque<Core::TimeWindow>;
using Range = std::pair<double,double>;
// ----------------------------------------------------------------------
@ -81,28 +81,36 @@ class SC_SYSTEM_CORE_API RecordSequence : public std::deque<RecordCPtr> {
//! Set the time tolerance in samples
void setTolerance(double);
/**
* @brief Returns the lowest iterator to the element which intersects
* or is after a given timestamp.
* @param ts The timestamp.
* @return The iterator
*/
const_iterator lowerBound(const Core::Time &ts) const;
/**
* @brief Returns a highest iterator to the element which intersects
* or is before a given timestamp.
* @param ts The timestamp.
* @return The iterator.
*/
const_iterator upperBound(const Core::Time &ts) const;
//! Return Record's as one contiguous record. Compiled in is support for
//! float, double and int. If interpolation is enabled gaps will be linearly
//! interpolated between the last and the next sample.
template <typename T>
GenericRecord *contiguousRecord(const Seiscomp::Core::TimeWindow *tw = nullptr,
GenericRecord *contiguousRecord(const Core::TimeWindow *tw = nullptr,
bool interpolate = false) const;
//! DECPRECATED: For backward compatibility, does exactly the same as
//! contiguousRecord. Please use contiguousRecord in your
//! code. This method will be removed in future releases.
template <typename T>
GenericRecord *continuousRecord(const Seiscomp::Core::TimeWindow *tw = nullptr,
bool interpolate = false) const;
//! Time window currently in buffer, irrespective of gaps
Core::TimeWindow timeWindow() const;
//! The amplitude range in a given time window.
//! Returns (0,0) if the sequence is empty or no records fall inside
//! the given optional time window.
Range amplitudeRange(const Seiscomp::Core::TimeWindow *tw = nullptr) const;
Range amplitudeRange(const Core::TimeWindow *tw = nullptr) const;
//! returns the continuous time windows available
//! This is usually one time window but may be split into
@ -163,9 +171,9 @@ class SC_SYSTEM_CORE_API TimeWindowBuffer : public RecordSequence {
// Public RecordSequence interface overrides
// ----------------------------------------------------------------------
public:
virtual bool feed(const Record*);
virtual RecordSequence *copy() const;
virtual RecordSequence *clone() const;
virtual bool feed(const Record*) override;
virtual RecordSequence *copy() const override;
virtual RecordSequence *clone() const override;
// ----------------------------------------------------------------------
@ -215,9 +223,9 @@ class SC_SYSTEM_CORE_API RingBuffer : public RecordSequence {
// Public RecordSequence interface overrides
// ----------------------------------------------------------------------
public:
virtual bool feed(const Record*);
virtual RecordSequence *copy() const;
virtual RecordSequence *clone() const;
virtual bool feed(const Record*) override;
virtual RecordSequence *copy() const override;
virtual RecordSequence *clone() const override;
// ----------------------------------------------------------------------
@ -229,7 +237,7 @@ class SC_SYSTEM_CORE_API RingBuffer : public RecordSequence {
//! Return the maximum number of records the RingBuffer stores
unsigned int numberOfRecordsToStore() const;
//! Return the TimeSpan the RingBuffer stores
const Core::TimeSpan &timeSpanToStore() const;
@ -266,11 +274,11 @@ inline const Core::TimeWindow &TimeWindowBuffer::timeWindowToStore() const {
inline unsigned int RingBuffer::numberOfRecordsToStore() const {
return _nmax;
}
inline const Core::TimeSpan &RingBuffer::timeSpanToStore() const {
return _span;
}
}
#endif

8
include/seiscomp/core/serialization.h
View File

@ -131,13 +131,13 @@ class ObjectContainer {
typedef T Type;
//typedef C<T, std::allocator<T> > ContainerType;
typedef C ContainerType;
ObjectContainer(ContainerType& c, ADD a) : _container(&c), _add(a) {}
ContainerType& container() const {
return *_container;
}
bool add(T& v) const {
_add(v);
return true;
@ -188,9 +188,9 @@ ObjectContainer<C<T, std::allocator<T> >, T, ADD> containerMember(C<T, std::allo
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
template <typename Tgt, class ret, class T>
std::function<ret (const typename Core::SmartPointer<Tgt>::Impl &ptr)>
std::function<ret (const Core::SmartPointer<Tgt> &ptr)>
bindMemberFunction(ret (T::*f)(Tgt*), T* c) {
return [c,f](const typename Core::SmartPointer<Tgt>::Impl &ptr) {
return [c,f](const Core::SmartPointer<Tgt> &ptr) {
return (c->*f)(ptr.get());
};
}

98
include/seiscomp/core/strings.h
View File

@ -32,6 +32,7 @@
#include <limits>
#include <string>
#include <string_view>
#include <vector>
#include <complex>
@ -72,10 +73,10 @@ template <typename ENUMTYPE, ENUMTYPE END, typename NAMES>
std::string toString(const Enum<ENUMTYPE, END, NAMES> &value);
template <typename T>
std::string toString(const std::vector<T> &v);
std::string toString(const std::vector<T> &v, char delimiter = ' ');
template <typename T>
std::string toString(const ::boost::optional<T> &v);
std::string toString(const Optional<T> &v);
template <typename T>
@ -102,20 +103,28 @@ std::ostream &operator<<(std::ostream &os, const Number<double> &s);
* @param str The source string
*/
template <typename T>
bool fromString(T &value, const std::string &str);
bool fromString(T &value, std::string_view sv);
template <typename T>
bool fromString(std::complex<T> &value, const std::string &str);
bool fromString(std::complex<T> &value, std::string_view sv);
SC_SYSTEM_CORE_API bool fromString(Time &value, const std::string &str);
SC_SYSTEM_CORE_API bool fromString(Enumeration &value, const std::string &str);
SC_SYSTEM_CORE_API bool fromString(std::string &value, const std::string &str);
template <>
bool fromString(TimeSpan &value, std::string_view sv);
template <>
bool fromString(Time &value, std::string_view sv);
template <>
bool fromString(Enumeration &value, std::string_view sv);
template <>
bool fromString(std::string &value, std::string_view sv);
template <typename ENUMTYPE, ENUMTYPE END, typename NAMES>
bool fromString(Enum<ENUMTYPE, END, NAMES> &value, const std::string &str);
bool fromString(Enum<ENUMTYPE, END, NAMES> &value, std::string_view sv);
template <typename T>
bool fromString(std::vector<T> &vec, const std::string &str);
bool fromString(std::vector<T> &vec, std::string_view sv, char delimiter = ' ');
/**
@ -142,12 +151,12 @@ int split(std::vector<std::string> &tokens, const char *source,
const char *delimiter, bool compressOn = true);
/**
* @brief Convenience function which takes an std::string as source parameter
* @brief Convenience function which takes an std::string_view as source parameter
* rather than a const char pointer.
* See @ref split(std::vector<std::string> &, const char *, const char *, bool).
*/
SC_SYSTEM_CORE_API
int split(std::vector<std::string> &tokens, const std::string &source,
int split(std::vector<std::string> &tokens, std::string_view source,
const char *delimiter, bool compressOn = true);
/**
@ -205,13 +214,7 @@ SC_SYSTEM_CORE_API bool isEmpty(const char*);
* A case-insensitive comparison.
* @return Result as defined by strcmp
*/
SC_SYSTEM_CORE_API int compareNoCase(const std::string &a, const std::string &b);
/** Removes whitespace at the beginning and end of the string.
* @param string to be trimmed (in/out parameter)
* @return returns the trimmed string
*/
SC_SYSTEM_CORE_API std::string &trim(std::string &str);
SC_SYSTEM_CORE_API int compareNoCase(std::string_view a, std::string_view b);
template <typename T>
void toHex(std::string &target, T source);
@ -237,25 +240,17 @@ SC_SYSTEM_CORE_API bool wildcmp(const std::string &wild, const std::string &str)
SC_SYSTEM_CORE_API bool wildicmp(const char *wild, const char *str);
SC_SYSTEM_CORE_API bool wildicmp(const std::string &wild, const std::string &str);
// -------------------------------------------------------------------------
// Plain C string functions which do not modify the input string and work
// mostly with length rather than an terminating null byte.
// -------------------------------------------------------------------------
/**
* @brief Tokenizes an input string. Empty tokens will be skipped and not
* returned (also referred to as compression).
* @param str The input string. The address is modified that it will point to
* the next token.
* @param sv The input string. The address is modified that it will point to
* the next token.
* @param delim A string of characters of allowed delimiters
* @param len_source The source length. This parameter will be modified
* to match the remaining length of the string.
* @param len_tok The length of the returned token.
* @return The address to the token found or nullptr.
* @return The matching substring as string_view. If the data pointer is
* nullptr then no further matches are possible.
*/
template <typename T>
T *tokenize(T *&str, const char *delim, size_t &len_source, size_t &len_tok);
SC_SYSTEM_CORE_API
std::string_view tokenize(std::string_view &sv, const char *delim);
/**
* @brief Works like tokenize but does not compress empty tokens.
@ -267,6 +262,18 @@ T *tokenize(T *&str, const char *delim, size_t &len_source, size_t &len_tok);
* @param len_tok The length of the returned token.
* @return The address to the token found or nullptr.
*/
SC_SYSTEM_CORE_API
std::string_view tokenize2(std::string_view &sv, const char *delim);
// -------------------------------------------------------------------------
// Plain C string functions which do not modify the input string and work
// mostly with length rather than an terminating null byte.
// -------------------------------------------------------------------------
template <typename T>
T *tokenize(T *&str, const char *delim, size_t &len_source, size_t &len_tok);
template <typename T>
T *tokenize2(T *&str, const char *delim, size_t &len_source, size_t &len_tok);
@ -298,7 +305,7 @@ const char *tokenizeExt(size_t &lenTok, size_t &lenSource, const char *&source,
const char *whitespaces = " \t\n\v\f\r",
const char *quotes = "\"'");
/**
/**split(
* @brief Splits a string into several tokens separated by one of the specified
* delimiter characters. A delimiter character is ignored if it occurs in
* a quoted string or if it is protected by a backslash. Likewise quotes
@ -343,6 +350,7 @@ SC_SYSTEM_CORE_API bool isEmpty(const char*);
*/
char *trimFront(char *&data, size_t &len);
const char *trimFront(const char *&data, size_t &len);
SC_SYSTEM_CORE_API std::string_view trimFront(std::string_view sv);
/**
* @brief Removes whitespaces from the back of a string.
@ -353,6 +361,7 @@ const char *trimFront(const char *&data, size_t &len);
*/
char *trimBack(char *data, size_t &len);
const char *trimBack(const char *data, size_t &len);
SC_SYSTEM_CORE_API std::string_view trimBack(std::string_view sv);
/**
* @brief Strips whitespaces from the front and the back of the string.
@ -364,6 +373,9 @@ const char *trimBack(const char *data, size_t &len);
*/
char *trim(char *&data, size_t &len);
const char *trim(const char *&data, size_t &len);
SC_SYSTEM_CORE_API std::string_view trim(std::string_view sv);
SC_SYSTEM_CORE_API std::string &trim(std::string &str);
char *strnchr(char *p, size_t n, char c);
const char *strnchr(const char *p, size_t n, char c);
@ -460,6 +472,26 @@ class ContainerSource {
};
struct InputStringViewBuf : std::streambuf {
InputStringViewBuf(std::string_view sv) {
auto d = const_cast<char*>(sv.data());
this->setg(d, d, d + sv.size());
}
virtual pos_type seekoff(off_type off, std::ios_base::seekdir,
std::ios_base::openmode) override {
return off ? -1 : gptr() - eback();
}
};
struct InputStringViewStream : virtual InputStringViewBuf, std::istream {
InputStringViewStream(std::string_view sv)
: InputStringViewBuf(sv)
, std::istream(static_cast<std::streambuf*>(this)) {}
};
}
}

89
include/seiscomp/core/strings.ipp
View File

@ -18,11 +18,8 @@
***************************************************************************/
#include <seiscomp/core/enumeration.h>
#include <cctype>
#include <sstream>
#include <complex>
namespace Seiscomp {
@ -92,18 +89,20 @@ std::string toString(const Enum<ENUMTYPE, END, NAMES>& value) {
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
template <typename T>
inline std::string toString(const std::vector<T>& v) {
typename std::vector<T>::const_iterator it = v.begin();
inline std::string toString(const std::vector<T>& v, char delimiter) {
auto it = v.begin();
std::string str;
if ( it != v.end() )
if ( it != v.end() ) {
str += toString(*it);
else
}
else {
return "";
}
++it;
while ( it != v.end() ) {
str += " ";
str += delimiter;
str += toString(*it);
++it;
}
@ -117,7 +116,7 @@ inline std::string toString(const std::vector<T>& v) {
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
template <typename T>
inline std::string toString(const ::boost::optional<T>& v) {
inline std::string toString(const Seiscomp::Core::Optional<T> &v) {
if ( !v )
return "None";
@ -128,6 +127,36 @@ inline std::string toString(const ::boost::optional<T>& v) {
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
#if __cplusplus >= 201703L
template <typename T>
bool fromString(boost::optional<T> &value, const std::string &str) {
static_assert(
False<T>::value,
"String conversion for boost optional values is not supported"
);
return false;
}
#endif
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
template <typename T>
bool fromString(Optional<T> &value, const std::string &str) {
static_assert(
False<T>::value,
"String conversion for optional values is not supported"
);
return false;
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
template <typename ENUMTYPE, ENUMTYPE END, typename NAMES>
bool fromString(Enum<ENUMTYPE, END, NAMES>& value, const std::string& str) {
@ -154,7 +183,7 @@ inline bool fromString(std::complex<T>& value, const std::string& str) {
return false;
T realPart, imgPart;
if ( !fromString(realPart, str.substr(s+1, delimPos-s-1)) ) return false;
if ( !fromString(imgPart, str.substr(delimPos+1, e-delimPos-1)) ) return false;
@ -169,13 +198,16 @@ inline bool fromString(std::complex<T>& value, const std::string& str) {
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
template <typename T>
inline bool fromString(std::vector<T>& vec, const std::string& str) {
inline bool fromString(std::vector<T>& vec, std::string_view sv, char delimiter) {
std::vector<std::string> tokens;
split(tokens, str.c_str(), " ");
char tmp[2] = { delimiter, '\0' };
split(tokens, sv, tmp);
vec.clear();
for ( size_t i = 0; i < tokens.size(); ++i ) {
T v;
if ( !fromString(v, tokens[i]) )
if ( !fromString(v, tokens[i]) ) {
return false;
}
vec.push_back(v);
}
@ -188,28 +220,39 @@ inline bool fromString(std::vector<T>& vec, const std::string& str) {
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
template <typename T>
inline bool fromString(std::vector<std::complex<T> >& vec, const std::string& str) {
inline bool fromString(std::vector<std::complex<T> >& vec, std::string_view sv, char delimiter) {
std::vector<std::string> tokens;
split(tokens, str.c_str(), " ");
char tmp[2] = { delimiter, '\0' };
split(tokens, sv, tmp);
vec.clear();
for ( size_t i = 0; i < tokens.size(); ++i ) {
std::complex<T> v;
int count = 1;
size_t countPos = tokens[i].find_first_not_of(' ');
size_t countPos = tokens[i].find_first_not_of(delimiter);
if ( countPos != std::string::npos ) {
if ( tokens[i][countPos] != '(' ) {
size_t bracketPos = tokens[i].find('(', countPos);
// Invalid complex string
if ( bracketPos == std::string::npos ) continue;
if ( !fromString(count, tokens[i].substr(countPos, bracketPos-countPos)) )
if ( bracketPos == std::string::npos ) {
continue;
}
if ( !fromString(count, tokens[i].substr(countPos, bracketPos-countPos)) ) {
return false;
}
tokens[i] = tokens[i].substr(bracketPos);
}
}
if ( !fromString(v, tokens[i]) ) return false;
for ( int i = 0; i < count; ++i )
if ( !fromString(v, tokens[i]) ) {
return false;
}
for ( int c = 0; c < count; ++c ) {
vec.push_back(v);
}
}
return true;
@ -428,7 +471,7 @@ std::string join(const CONT &tokens, const std::string &separator) {
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
template <typename S, typename... Args>
inline std::string stringify(const S &format, Args &&...args) {
return fmt::vsprintf(format, fmt::make_printf_args(args...));
return fmt::sprintf(format, args...);
}
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

209
include/seiscomp/core/timewindow.h
View File

@ -21,44 +21,80 @@
#ifndef SC_CORE_TIMESPAN_H
#define SC_CORE_TIMESPAN_H
#include<seiscomp/core.h>
#include<seiscomp/core/datetime.h>
#include <seiscomp/core.h>
#include <seiscomp/core/datetime.h>
#include <seiscomp/core/optional.h>
#include <ostream>
namespace Seiscomp {
namespace Core {
class SC_SYSTEM_CORE_API TimeWindow {
// Xstruction
// ----------------------------------------------------------------------
// X'truction
// ----------------------------------------------------------------------
public:
TimeWindow();
TimeWindow() = default;
TimeWindow(const Time &startTime, double length);
TimeWindow(const Time &startTime, const TimeSpan length);
TimeWindow(const Time &startTime, const Time &endTime);
TimeWindow(const TimeWindow &tw);
~TimeWindow() {}
TimeWindow(const TimeWindow &other);
// Operators
// ----------------------------------------------------------------------
// Assignment operators
// ----------------------------------------------------------------------
public:
TimeWindow &operator=(const TimeWindow&);
// ----------------------------------------------------------------------
// Comparison operators
// ----------------------------------------------------------------------
public:
bool operator==(const TimeWindow&) const;
bool operator!=(const TimeWindow&) const;
// ----------------------------------------------------------------------
// Arithmetic operators
// ----------------------------------------------------------------------
public:
//! Returns the minimal timewindow including this and other
TimeWindow operator|(const TimeWindow &other) const;
//! Sets the minimal timewindow including this and other
TimeWindow &operator|=(const TimeWindow &other);
//! Returns the intersection of this and other
TimeWindow operator&(const TimeWindow &other) const;
//! Sets the intersection of this and other
TimeWindow &operator&=(const TimeWindow &other);
// ----------------------------------------------------------------------
// Cast operators
// ----------------------------------------------------------------------
public:
//! Returns if the time window has length larger than 0.
operator bool() const;
//! Returns the minimal timewindow including this and other
TimeWindow operator|(const TimeWindow &other) const;
// more operators :-)
// Interface
// ----------------------------------------------------------------------
// Public interface
// ----------------------------------------------------------------------
public:
Time startTime() const;
Time endTime() const;
double length() const;
TimeSpan length() const;
void set(const Time &t1, const Time &t2);
void setStartTime(const Time &t);
void setEndTime(const Time &t);
//! set length in seconds, affects endTime
void setLength(double length);
void setLength(TimeSpan length);
//! does it contain time t?
bool contains(const Time &t) const;
@ -68,111 +104,102 @@ class SC_SYSTEM_CORE_API TimeWindow {
//! is equal to time window?
//! +/- tolerance in seconds
bool equals(const TimeWindow &tw, double tolerance=0.0) const;
bool equals(const TimeWindow &tw, TimeSpan tolerance = TimeSpan(0, 0)) const;
//! does it overlap with time window tw?
bool overlaps(const TimeWindow &tw) const;
//! compute overlap with time window tw
TimeWindow overlap(const TimeWindow &tw) const;
//! test if this+other would form a contiguous time window
bool contiguous(const TimeWindow&, double tolerance=0) const;
bool contiguous(const TimeWindow &, TimeSpan tolerance = TimeSpan(0, 0)) const;
//! extend time window by appending the other (without check!)
void extend(const TimeWindow&);
//! Sets the intersection time window with this and other
TimeWindow &overlap(const TimeWindow &other);
//! merges this and other to the minimal timewindow overlapping both
TimeWindow merge(const TimeWindow&) const;
//! Computes the intersection with time window other
TimeWindow overlapped(const TimeWindow &other) const;
// Implementation
//! Merges other into this to the minimal timewindow overlapping both.
TimeWindow &merge(const TimeWindow &other);
//! Returns the minimal timewindow including this and other
TimeWindow merged(const TimeWindow &other) const;
// ----------------------------------------------------------------------
// Private members
// ----------------------------------------------------------------------
private:
Time _startTime, _endTime;
Time _startTime;
Time _endTime;
};
inline TimeWindow::TimeWindow()
{
set(Time(), Time());
}
inline TimeWindow::TimeWindow(const Time &startTime, double length)
{
set(startTime, startTime + Time(length)); // FIXME
}
class SC_SYSTEM_CORE_API OpenTimeWindow {
// ----------------------------------------------------------------------
// X'truction
// ----------------------------------------------------------------------
public:
OpenTimeWindow() = default;
OpenTimeWindow(const OPT(Time) &startTime, const OPT(Time) &endTime);
OpenTimeWindow(const OpenTimeWindow &other);
inline TimeWindow::TimeWindow(const Time &startTime, const Time &endTime)
{
set(startTime, endTime);
}
inline TimeWindow::TimeWindow(const TimeWindow &tw)
{
set(tw._startTime, tw._endTime);
}
// ----------------------------------------------------------------------
// Assignment operators
// ----------------------------------------------------------------------
public:
OpenTimeWindow &operator=(const OpenTimeWindow&);
inline bool TimeWindow::operator==(const TimeWindow &tw) const
{
return _startTime == tw._startTime && _endTime == tw._endTime;
}
inline bool TimeWindow::operator!=(const TimeWindow &tw) const
{
return _startTime != tw._startTime || _endTime != tw._endTime;
}
// ----------------------------------------------------------------------
// Comparison operators
// ----------------------------------------------------------------------
public:
bool operator==(const OpenTimeWindow&) const;
bool operator!=(const OpenTimeWindow&) const;
inline TimeWindow::operator bool() const
{
return (bool)_startTime && (bool)_endTime;
}
inline Time TimeWindow::startTime() const
{
return _startTime;
}
// ----------------------------------------------------------------------
// Public interface
// ----------------------------------------------------------------------
public:
OPT(Time) startTime() const;
OPT(Time) endTime() const;
OPT(TimeSpan) length() const;
inline Time TimeWindow::endTime() const
{
return _endTime;
}
void set(const OPT(Time) &t1, const OPT(Time) &t2);
void setStartTime(const OPT(Time) &t);
void setEndTime(const OPT(Time) &t);
inline double TimeWindow::length() const
{
return (double)(_endTime-_startTime);
}
//! does it contain time t?
bool contains(const Time &t) const;
inline void TimeWindow::set(const Time &startTime, const Time &endTime)
{
_startTime = startTime;
_endTime = endTime;
}
//! does it contain time window tw completely?
bool contains(const OpenTimeWindow &tw) const;
inline void TimeWindow::setStartTime(const Time &t)
{
_startTime = t;
}
//! does it overlap with time window tw?
bool overlaps(const OpenTimeWindow &tw) const;
inline void TimeWindow::setEndTime(const Time &t)
{
_endTime = t;
}
inline void TimeWindow::setLength(double length)
{
_endTime = _startTime + Time(length); // FIXME
}
// ----------------------------------------------------------------------
// Private members
// ----------------------------------------------------------------------
private:
OPT(Time) _startTime;
OPT(Time) _endTime;
};
inline bool TimeWindow::contains(const Time &t) const
{
return t >= _startTime && t < _endTime;
}
inline bool TimeWindow::contains(const TimeWindow &tw) const
{
return tw._startTime >= _startTime && tw._endTime <= _endTime;
}
std::ostream &operator<<(std::ostream &os, const TimeWindow &timeWindow);
std::ostream &operator<<(std::ostream &os, const OpenTimeWindow &timeWindow);
#include "timewindow.ipp"
}
}
#endif

60
include/seiscomp/core/version.h
View File

@ -31,12 +31,12 @@ namespace Seiscomp {
namespace Core {
/* #if (SC_API_VERSION >= SC_API_VERSION_CHECK(16, 4, 0)) */
/* #if (SC_API_VERSION >= SC_API_VERSION_CHECK(17, 0, 0)) */
#define SC_API_VERSION_CHECK(major, minor, patch) ((major<<16)|(minor<<8)|(patch))
/* SC_API_VERSION is (major << 16) + (minor << 8) + patch. */
#define SC_API_VERSION 0x100400
#define SC_API_VERSION 0x110000
#define SC_API_VERSION_MAJOR(v) (v >> 16)
#define SC_API_VERSION_MINOR(v) ((v >> 8) & 0xff)
@ -46,6 +46,62 @@ namespace Core {
/******************************************************************************
API Changelog
******************************************************************************
"17.0.0" 0x110000
- Added Seiscomp::Gui::Scheme::records.showEngineeringValues
- Added Seiscomp::Gui::RecordView::showEngineeringValues(bool)
- Added Seiscomp::Gui::RecordWidget::showEngineeringValues(bool)
- Added Seiscomp::Client::Application::handleSOH
- Added Seiscomp::Processing::MagnitudeProcessor_MLc _c6, _H and _minDepth.
- Added Seiscomp::Processing::AmplitudeProcessor::parameter
- Made Seiscomp::IO::DatabaseInterface::escape a const method
- Increased TILESTORE_API version to 5
- Added Seiscomp::Processing::WaveformProcessor::Status enumeration PeriodOutOfRange
- Renamed Seiscomp::Core::Time::seconds() to Time::epochSeconds()
- Added Seiscomp::Core::Time::epoch()
- Deprecated Seiscomp::Core::Time::valid()
- Removed implicit Seiscomp::Core::TimeSpan and Seiscomp::Core::Time double cast
- Removed Seiscomp::System::CommandLine::parse(inv argc, char **argv, *)
- Added Seiscomp::System::CommandLine::parse(std::vector<std::string>, *)
- Changed Seiscomp::Core::Time in Seiscomp::IO::RecordStream::addStream,
Seiscomp::IO::RecordStream::setStartTime and
Seiscomp::IO::RecordStream::setEndTime to OPT(Seiscomp::Core::Time)
- Changed Seiscomp::Core::Time in Seiscomp::Client::StreamApplication::setStartTime
and Seiscomp::Client::StreamApplication::setEndTime to OPT(Seiscomp::Core::Time)
- Rename Seiscomp::Wired::ClientSession::inAvail to outputBufferSize and
remove virtual declaration
- Added abstract virtual function MagnitudeProcessor::setDefaults() which must
be implemented by all derived classes.
- Changed Seiscomp::Core::TimeWindow cast to bool semantic
- Changed Seiscomp::Core::TimeWindow::length return type, from double to
Seiscomp::Core::TimeSpan
- Changed Seiscomp::Core::TimeWindow::setLength length argument from double
to Seiscomp::Core::TimeSpan
- Changed Seiscomp::Core::TimeWindow::equals tolerance argument from double
to Seiscomp::Core::TimeSpan
- Changed Seiscomp::Core::TimeWindow::contiguous tolerance argument from double
to Seiscomp::Core::TimeSpan
- Added Seiscomp::Core::metaValueCast
- Removed typedef Seiscomp::Core::SmartPointer::Impl
- Added Seiscomp::Core::SmartPointer as typedef for boost::instrusive_ptr
- Removed typedef Seiscomp::Core::Optional::Impl
- Added Seiscomp::Core::Optional as typedef for boost::optional
- Added Seiscomp::Math::Geo::WGS84_MEAN_RADIUS
- Added Seiscomp::Math::Geo::WGS84_KM_OF_DEGREE
- Added Seiscomp::Math::Geo::WGS84_SEMI_MAJOR_AXIS
- Added Seiscomp::Math::Geo::WGS84_FLATTENING
- Removed defined KM_OF_DEGREE
- Renamed Seiscomp::ellipcorr to Seiscomp::ellipticityCorrection
- Removed Seiscomp::DataModel::DatabaseQuery::getStation
- Added Seiscomp::Geo::readFEP
- Added Seiscomp::Geo::writeGeoJSON
- Added Seiscomp::Math::Matrix3<T> ostream output operator
- Added Seiscomp::Math::Vector3<T> ostream output operator
- Added Seiscomp::Math::Matrix3<T>::operator*
- Added Seiscomp::Math::Matrix3<T>::operator=
- Added static Seiscomp::Math::Matrix3<T>::Rotate[X|Y|Z]
- Added unary Seiscomp::Math::Vector3<T>::operator+
- Added unary Seiscomp::Math::Vector3<T>::operator-
- Added Seiscomp::Math::Vector3<T>::normalized
"16.4.0" 0x100400
- Added Seiscomp::Math::double2frac

20
include/seiscomp/datamodel/access.h
View File

@ -92,25 +92,25 @@ class SC_SYSTEM_CORE_API Access : public Object {
Access();
//! Copy constructor
Access(const Access& other);
Access(const Access &other);
//! Destructor
~Access() override;
// ------------------------------------------------------------------
// Operators
// ------------------------------------------------------------------
public:
//! Copies the metadata of other to this
Access& operator=(const Access& other);
Access &operator=(const Access &other);
//! Checks for equality of two objects. Child objects
//! are not part of the check.
bool operator==(const Access& other) const;
bool operator!=(const Access& other) const;
bool operator==(const Access &other) const;
bool operator!=(const Access &other) const;
//! Wrapper that calls operator==
bool equal(const Access& other) const;
bool equal(const Access &other) const;
// ------------------------------------------------------------------
@ -151,17 +151,17 @@ class SC_SYSTEM_CORE_API Access : public Object {
// ------------------------------------------------------------------
public:
//! Returns the object's index
const AccessIndex& index() const;
const AccessIndex &index() const;
//! Checks two objects for equality regarding their index
bool equalIndex(const Access* lhs) const;
bool equalIndex(const Access *lhs) const;
// ------------------------------------------------------------------
// Public interface
// ------------------------------------------------------------------
public:
Routing* routing() const;
Routing *routing() const;
//! Implement Object interface
bool assign(Object *other) override;

32
include/seiscomp/datamodel/amplitude.h
View File

@ -67,28 +67,28 @@ class SC_SYSTEM_CORE_API Amplitude : public PublicObject {
public:
//! Copy constructor
Amplitude(const Amplitude& other);
Amplitude(const Amplitude &other);
//! Constructor with publicID
Amplitude(const std::string& publicID);
//! Destructor
~Amplitude() override;
// ------------------------------------------------------------------
// Creators
// ------------------------------------------------------------------
public:
static Amplitude* Create();
static Amplitude* Create(const std::string& publicID);
static Amplitude *Create();
static Amplitude *Create(const std::string& publicID);
// ------------------------------------------------------------------
// Lookup
// ------------------------------------------------------------------
public:
static Amplitude* Find(const std::string& publicID);
static Amplitude *Find(const std::string& publicID);
// ------------------------------------------------------------------
@ -97,14 +97,14 @@ class SC_SYSTEM_CORE_API Amplitude : public PublicObject {
public:
//! Copies the metadata of other to this
//! No changes regarding child objects are made
Amplitude& operator=(const Amplitude& other);
Amplitude &operator=(const Amplitude &other);
//! Checks for equality of two objects. Child objects
//! are not part of the check.
bool operator==(const Amplitude& other) const;
bool operator!=(const Amplitude& other) const;
bool operator==(const Amplitude &other) const;
bool operator!=(const Amplitude &other) const;
//! Wrapper that calls operator==
bool equal(const Amplitude& other) const;
bool equal(const Amplitude &other) const;
// ------------------------------------------------------------------
@ -219,7 +219,7 @@ class SC_SYSTEM_CORE_API Amplitude : public PublicObject {
CreationInfo& creationInfo();
const CreationInfo& creationInfo() const;
// ------------------------------------------------------------------
// Public interface
// ------------------------------------------------------------------
@ -232,7 +232,7 @@ class SC_SYSTEM_CORE_API Amplitude : public PublicObject {
* because it already exists in the list
* or it already has another parent
*/
bool add(Comment* obj);
bool add(Comment *obj);
/**
* Removes an object.
@ -241,7 +241,7 @@ class SC_SYSTEM_CORE_API Amplitude : public PublicObject {
* @return false The object has not been removed
* because it does not exist in the list
*/
bool remove(Comment* obj);
bool remove(Comment *obj);
/**
* Removes an object of a particular class.
@ -250,19 +250,19 @@ class SC_SYSTEM_CORE_API Amplitude : public PublicObject {
* @return false The index is out of bounds
*/
bool removeComment(size_t i);
bool removeComment(const CommentIndex& i);
bool removeComment(const CommentIndex &i);
//! Retrieve the number of objects of a particular class
size_t commentCount() const;
//! Index access
//! @return The object at index i
Comment* comment(size_t i) const;
Comment* comment(const CommentIndex& i) const;
Comment *comment(size_t i) const;
Comment *comment(const CommentIndex &i) const;
//! Find an object by its unique attribute(s)
EventParameters* eventParameters() const;
EventParameters *eventParameters() const;
//! Implement Object interface
bool assign(Object *other) override;

20
include/seiscomp/datamodel/amplitudereference.h
View File

@ -78,28 +78,28 @@ class SC_SYSTEM_CORE_API AmplitudeReference : public Object {
AmplitudeReference();
//! Copy constructor
AmplitudeReference(const AmplitudeReference& other);
AmplitudeReference(const AmplitudeReference &other);
//! Custom constructor
AmplitudeReference(const std::string& amplitudeID);
//! Destructor
~AmplitudeReference() override;
// ------------------------------------------------------------------
// Operators
// ------------------------------------------------------------------
public:
//! Copies the metadata of other to this
AmplitudeReference& operator=(const AmplitudeReference& other);
AmplitudeReference &operator=(const AmplitudeReference &other);
//! Checks for equality of two objects. Child objects
//! are not part of the check.
bool operator==(const AmplitudeReference& other) const;
bool operator!=(const AmplitudeReference& other) const;
bool operator==(const AmplitudeReference &other) const;
bool operator!=(const AmplitudeReference &other) const;
//! Wrapper that calls operator==
bool equal(const AmplitudeReference& other) const;
bool equal(const AmplitudeReference &other) const;
// ------------------------------------------------------------------
@ -115,17 +115,17 @@ class SC_SYSTEM_CORE_API AmplitudeReference : public Object {
// ------------------------------------------------------------------
public:
//! Returns the object's index
const AmplitudeReferenceIndex& index() const;
const AmplitudeReferenceIndex &index() const;
//! Checks two objects for equality regarding their index
bool equalIndex(const AmplitudeReference* lhs) const;
bool equalIndex(const AmplitudeReference *lhs) const;
// ------------------------------------------------------------------
// Public interface
// ------------------------------------------------------------------
public:
Reading* reading() const;
Reading *reading() const;
//! Implement Object interface
bool assign(Object *other) override;

38
include/seiscomp/datamodel/arclinklog.h
View File

@ -52,11 +52,11 @@ class SC_SYSTEM_CORE_API ArclinkLog : public PublicObject {
ArclinkLog();
//! Copy constructor
ArclinkLog(const ArclinkLog& other);
ArclinkLog(const ArclinkLog &other);
//! Destructor
~ArclinkLog() override;
// ------------------------------------------------------------------
// Operators
@ -64,16 +64,16 @@ class SC_SYSTEM_CORE_API ArclinkLog : public PublicObject {
public:
//! Copies the metadata of other to this
//! No changes regarding child objects are made
ArclinkLog& operator=(const ArclinkLog& other);
ArclinkLog &operator=(const ArclinkLog &other);
//! Checks for equality of two objects. Child objects
//! are not part of the check.
bool operator==(const ArclinkLog& other) const;
bool operator!=(const ArclinkLog& other) const;
bool operator==(const ArclinkLog &other) const;
bool operator!=(const ArclinkLog &other) const;
//! Wrapper that calls operator==
bool equal(const ArclinkLog& other) const;
bool equal(const ArclinkLog &other) const;
// ------------------------------------------------------------------
// Public interface
// ------------------------------------------------------------------
@ -86,8 +86,8 @@ class SC_SYSTEM_CORE_API ArclinkLog : public PublicObject {
* because it already exists in the list
* or it already has another parent
*/
bool add(ArclinkRequest* obj);
bool add(ArclinkUser* obj);
bool add(ArclinkRequest *obj);
bool add(ArclinkUser *obj);
/**
* Removes an object.
@ -96,8 +96,8 @@ class SC_SYSTEM_CORE_API ArclinkLog : public PublicObject {
* @return false The object has not been removed
* because it does not exist in the list
*/
bool remove(ArclinkRequest* obj);
bool remove(ArclinkUser* obj);
bool remove(ArclinkRequest *obj);
bool remove(ArclinkUser *obj);
/**
* Removes an object of a particular class.
@ -106,9 +106,9 @@ class SC_SYSTEM_CORE_API ArclinkLog : public PublicObject {
* @return false The index is out of bounds
*/
bool removeArclinkRequest(size_t i);
bool removeArclinkRequest(const ArclinkRequestIndex& i);
bool removeArclinkRequest(const ArclinkRequestIndex &i);
bool removeArclinkUser(size_t i);
bool removeArclinkUser(const ArclinkUserIndex& i);
bool removeArclinkUser(const ArclinkUserIndex &i);
//! Retrieve the number of objects of a particular class
size_t arclinkRequestCount() const;
@ -116,15 +116,15 @@ class SC_SYSTEM_CORE_API ArclinkLog : public PublicObject {
//! Index access
//! @return The object at index i
ArclinkRequest* arclinkRequest(size_t i) const;
ArclinkRequest* arclinkRequest(const ArclinkRequestIndex& i) const;
ArclinkRequest *arclinkRequest(size_t i) const;
ArclinkRequest *arclinkRequest(const ArclinkRequestIndex &i) const;
ArclinkUser* arclinkUser(size_t i) const;
ArclinkUser* arclinkUser(const ArclinkUserIndex& i) const;
ArclinkUser *arclinkUser(size_t i) const;
ArclinkUser *arclinkUser(const ArclinkUserIndex &i) const;
//! Find an object by its unique attribute(s)
ArclinkRequest* findArclinkRequest(const std::string& publicID) const;
ArclinkUser* findArclinkUser(const std::string& publicID) const;
ArclinkRequest *findArclinkRequest(const std::string& publicID) const;
ArclinkUser *findArclinkUser(const std::string& publicID) const;
//! Implement Object interface
bool assign(Object *other) override;

46
include/seiscomp/datamodel/arclinkrequest.h
View File

@ -91,28 +91,28 @@ class SC_SYSTEM_CORE_API ArclinkRequest : public PublicObject {
public:
//! Copy constructor
ArclinkRequest(const ArclinkRequest& other);
ArclinkRequest(const ArclinkRequest &other);
//! Constructor with publicID
ArclinkRequest(const std::string& publicID);
//! Destructor
~ArclinkRequest() override;
// ------------------------------------------------------------------
// Creators
// ------------------------------------------------------------------
public:
static ArclinkRequest* Create();
static ArclinkRequest* Create(const std::string& publicID);
static ArclinkRequest *Create();
static ArclinkRequest *Create(const std::string& publicID);
// ------------------------------------------------------------------
// Lookup
// ------------------------------------------------------------------
public:
static ArclinkRequest* Find(const std::string& publicID);
static ArclinkRequest *Find(const std::string& publicID);
// ------------------------------------------------------------------
@ -121,14 +121,14 @@ class SC_SYSTEM_CORE_API ArclinkRequest : public PublicObject {
public:
//! Copies the metadata of other to this
//! No changes regarding child objects are made
ArclinkRequest& operator=(const ArclinkRequest& other);
ArclinkRequest &operator=(const ArclinkRequest &other);
//! Checks for equality of two objects. Child objects
//! are not part of the check.
bool operator==(const ArclinkRequest& other) const;
bool operator!=(const ArclinkRequest& other) const;
bool operator==(const ArclinkRequest &other) const;
bool operator!=(const ArclinkRequest &other) const;
//! Wrapper that calls operator==
bool equal(const ArclinkRequest& other) const;
bool equal(const ArclinkRequest &other) const;
// ------------------------------------------------------------------
@ -178,12 +178,12 @@ class SC_SYSTEM_CORE_API ArclinkRequest : public PublicObject {
// ------------------------------------------------------------------
public:
//! Returns the object's index
const ArclinkRequestIndex& index() const;
const ArclinkRequestIndex &index() const;
//! Checks two objects for equality regarding their index
bool equalIndex(const ArclinkRequest* lhs) const;
bool equalIndex(const ArclinkRequest *lhs) const;
// ------------------------------------------------------------------
// Public interface
// ------------------------------------------------------------------
@ -196,8 +196,8 @@ class SC_SYSTEM_CORE_API ArclinkRequest : public PublicObject {
* because it already exists in the list
* or it already has another parent
*/
bool add(ArclinkStatusLine* obj);
bool add(ArclinkRequestLine* obj);
bool add(ArclinkStatusLine *obj);
bool add(ArclinkRequestLine *obj);
/**
* Removes an object.
@ -206,8 +206,8 @@ class SC_SYSTEM_CORE_API ArclinkRequest : public PublicObject {
* @return false The object has not been removed
* because it does not exist in the list
*/
bool remove(ArclinkStatusLine* obj);
bool remove(ArclinkRequestLine* obj);
bool remove(ArclinkStatusLine *obj);
bool remove(ArclinkRequestLine *obj);
/**
* Removes an object of a particular class.
@ -216,9 +216,9 @@ class SC_SYSTEM_CORE_API ArclinkRequest : public PublicObject {
* @return false The index is out of bounds
*/
bool removeArclinkStatusLine(size_t i);
bool removeArclinkStatusLine(const ArclinkStatusLineIndex& i);
bool removeArclinkStatusLine(const ArclinkStatusLineIndex &i);
bool removeArclinkRequestLine(size_t i);
bool removeArclinkRequestLine(const ArclinkRequestLineIndex& i);
bool removeArclinkRequestLine(const ArclinkRequestLineIndex &i);
//! Retrieve the number of objects of a particular class
size_t arclinkStatusLineCount() const;
@ -226,15 +226,15 @@ class SC_SYSTEM_CORE_API ArclinkRequest : public PublicObject {
//! Index access
//! @return The object at index i
ArclinkStatusLine* arclinkStatusLine(size_t i) const;
ArclinkStatusLine* arclinkStatusLine(const ArclinkStatusLineIndex& i) const;
ArclinkStatusLine *arclinkStatusLine(size_t i) const;
ArclinkStatusLine *arclinkStatusLine(const ArclinkStatusLineIndex &i) const;
ArclinkRequestLine* arclinkRequestLine(size_t i) const;
ArclinkRequestLine* arclinkRequestLine(const ArclinkRequestLineIndex& i) const;
ArclinkRequestLine *arclinkRequestLine(size_t i) const;
ArclinkRequestLine *arclinkRequestLine(const ArclinkRequestLineIndex &i) const;
//! Find an object by its unique attribute(s)
ArclinkLog* arclinkLog() const;
ArclinkLog *arclinkLog() const;
//! Implement Object interface
bool assign(Object *other) override;

20
include/seiscomp/datamodel/arclinkrequestline.h
View File

@ -85,25 +85,25 @@ class SC_SYSTEM_CORE_API ArclinkRequestLine : public Object {
ArclinkRequestLine();
//! Copy constructor
ArclinkRequestLine(const ArclinkRequestLine& other);
ArclinkRequestLine(const ArclinkRequestLine &other);
//! Destructor
~ArclinkRequestLine() override;
// ------------------------------------------------------------------
// Operators
// ------------------------------------------------------------------
public:
//! Copies the metadata of other to this
ArclinkRequestLine& operator=(const ArclinkRequestLine& other);
ArclinkRequestLine &operator=(const ArclinkRequestLine &other);
//! Checks for equality of two objects. Child objects
//! are not part of the check.
bool operator==(const ArclinkRequestLine& other) const;
bool operator!=(const ArclinkRequestLine& other) const;
bool operator==(const ArclinkRequestLine &other) const;
bool operator!=(const ArclinkRequestLine &other) const;
//! Wrapper that calls operator==
bool equal(const ArclinkRequestLine& other) const;
bool equal(const ArclinkRequestLine &other) const;
// ------------------------------------------------------------------
@ -142,17 +142,17 @@ class SC_SYSTEM_CORE_API ArclinkRequestLine : public Object {
// ------------------------------------------------------------------
public:
//! Returns the object's index
const ArclinkRequestLineIndex& index() const;
const ArclinkRequestLineIndex &index() const;
//! Checks two objects for equality regarding their index
bool equalIndex(const ArclinkRequestLine* lhs) const;
bool equalIndex(const ArclinkRequestLine *lhs) const;
// ------------------------------------------------------------------
// Public interface
// ------------------------------------------------------------------
public:
ArclinkRequest* arclinkRequest() const;
ArclinkRequest *arclinkRequest() const;
//! Implement Object interface
bool assign(Object *other) override;

12
include/seiscomp/datamodel/arclinkrequestsummary.h
View File

@ -47,25 +47,25 @@ class SC_SYSTEM_CORE_API ArclinkRequestSummary : public Core::BaseObject {
ArclinkRequestSummary();
//! Copy constructor
ArclinkRequestSummary(const ArclinkRequestSummary& other);
ArclinkRequestSummary(const ArclinkRequestSummary &other);
//! Destructor
~ArclinkRequestSummary() override;
// ------------------------------------------------------------------
// Operators
// ------------------------------------------------------------------
public:
//! Copies the metadata of other to this
ArclinkRequestSummary& operator=(const ArclinkRequestSummary& other);
ArclinkRequestSummary &operator=(const ArclinkRequestSummary &other);
//! Checks for equality of two objects. Child objects
//! are not part of the check.
bool operator==(const ArclinkRequestSummary& other) const;
bool operator!=(const ArclinkRequestSummary& other) const;
bool operator==(const ArclinkRequestSummary &other) const;
bool operator!=(const ArclinkRequestSummary &other) const;
//! Wrapper that calls operator==
bool equal(const ArclinkRequestSummary& other) const;
bool equal(const ArclinkRequestSummary &other) const;
// ------------------------------------------------------------------

20
include/seiscomp/datamodel/arclinkstatusline.h
View File

@ -82,25 +82,25 @@ class SC_SYSTEM_CORE_API ArclinkStatusLine : public Object {
ArclinkStatusLine();
//! Copy constructor
ArclinkStatusLine(const ArclinkStatusLine& other);
ArclinkStatusLine(const ArclinkStatusLine &other);
//! Destructor
~ArclinkStatusLine() override;
// ------------------------------------------------------------------
// Operators
// ------------------------------------------------------------------
public:
//! Copies the metadata of other to this
ArclinkStatusLine& operator=(const ArclinkStatusLine& other);
ArclinkStatusLine &operator=(const ArclinkStatusLine &other);
//! Checks for equality of two objects. Child objects
//! are not part of the check.
bool operator==(const ArclinkStatusLine& other) const;
bool operator!=(const ArclinkStatusLine& other) const;
bool operator==(const ArclinkStatusLine &other) const;
bool operator!=(const ArclinkStatusLine &other) const;
//! Wrapper that calls operator==
bool equal(const ArclinkStatusLine& other) const;
bool equal(const ArclinkStatusLine &other) const;
// ------------------------------------------------------------------
@ -128,17 +128,17 @@ class SC_SYSTEM_CORE_API ArclinkStatusLine : public Object {
// ------------------------------------------------------------------
public:
//! Returns the object's index
const ArclinkStatusLineIndex& index() const;
const ArclinkStatusLineIndex &index() const;
//! Checks two objects for equality regarding their index
bool equalIndex(const ArclinkStatusLine* lhs) const;
bool equalIndex(const ArclinkStatusLine *lhs) const;
// ------------------------------------------------------------------
// Public interface
// ------------------------------------------------------------------
public:
ArclinkRequest* arclinkRequest() const;
ArclinkRequest *arclinkRequest() const;
//! Implement Object interface
bool assign(Object *other) override;

26
include/seiscomp/datamodel/arclinkuser.h
View File

@ -81,28 +81,28 @@ class SC_SYSTEM_CORE_API ArclinkUser : public PublicObject {
public:
//! Copy constructor
ArclinkUser(const ArclinkUser& other);
ArclinkUser(const ArclinkUser &other);
//! Constructor with publicID
ArclinkUser(const std::string& publicID);
//! Destructor
~ArclinkUser() override;
// ------------------------------------------------------------------
// Creators
// ------------------------------------------------------------------
public:
static ArclinkUser* Create();
static ArclinkUser* Create(const std::string& publicID);
static ArclinkUser *Create();
static ArclinkUser *Create(const std::string& publicID);
// ------------------------------------------------------------------
// Lookup
// ------------------------------------------------------------------
public:
static ArclinkUser* Find(const std::string& publicID);
static ArclinkUser *Find(const std::string& publicID);
// ------------------------------------------------------------------
@ -111,14 +111,14 @@ class SC_SYSTEM_CORE_API ArclinkUser : public PublicObject {
public:
//! Copies the metadata of other to this
//! No changes regarding child objects are made
ArclinkUser& operator=(const ArclinkUser& other);
ArclinkUser &operator=(const ArclinkUser &other);
//! Checks for equality of two objects. Child objects
//! are not part of the check.
bool operator==(const ArclinkUser& other) const;
bool operator!=(const ArclinkUser& other) const;
bool operator==(const ArclinkUser &other) const;
bool operator!=(const ArclinkUser &other) const;
//! Wrapper that calls operator==
bool equal(const ArclinkUser& other) const;
bool equal(const ArclinkUser &other) const;
// ------------------------------------------------------------------
@ -140,17 +140,17 @@ class SC_SYSTEM_CORE_API ArclinkUser : public PublicObject {
// ------------------------------------------------------------------
public:
//! Returns the object's index
const ArclinkUserIndex& index() const;
const ArclinkUserIndex &index() const;
//! Checks two objects for equality regarding their index
bool equalIndex(const ArclinkUser* lhs) const;
bool equalIndex(const ArclinkUser *lhs) const;
// ------------------------------------------------------------------
// Public interface
// ------------------------------------------------------------------
public:
ArclinkLog* arclinkLog() const;
ArclinkLog *arclinkLog() const;
//! Implement Object interface
bool assign(Object *other) override;

20
include/seiscomp/datamodel/arrival.h
View File

@ -100,25 +100,25 @@ class SC_SYSTEM_CORE_API Arrival : public Object {
Arrival();
//! Copy constructor
Arrival(const Arrival& other);
Arrival(const Arrival &other);
//! Destructor
~Arrival() override;
// ------------------------------------------------------------------
// Operators
// ------------------------------------------------------------------
public:
//! Copies the metadata of other to this
Arrival& operator=(const Arrival& other);
Arrival &operator=(const Arrival &other);
//! Checks for equality of two objects. Child objects
//! are not part of the check.
bool operator==(const Arrival& other) const;
bool operator!=(const Arrival& other) const;
bool operator==(const Arrival &other) const;
bool operator!=(const Arrival &other) const;
//! Wrapper that calls operator==
bool equal(const Arrival& other) const;
bool equal(const Arrival &other) const;
// ------------------------------------------------------------------
@ -221,17 +221,17 @@ class SC_SYSTEM_CORE_API Arrival : public Object {
// ------------------------------------------------------------------
public:
//! Returns the object's index
const ArrivalIndex& index() const;
const ArrivalIndex &index() const;
//! Checks two objects for equality regarding their index
bool equalIndex(const Arrival* lhs) const;
bool equalIndex(const Arrival *lhs) const;
// ------------------------------------------------------------------
// Public interface
// ------------------------------------------------------------------
public:
Origin* origin() const;
Origin *origin() const;
//! Implement Object interface
bool assign(Object *other) override;

36
include/seiscomp/datamodel/auxdevice.h
View File

@ -87,28 +87,28 @@ class SC_SYSTEM_CORE_API AuxDevice : public PublicObject {
public:
//! Copy constructor
AuxDevice(const AuxDevice& other);
AuxDevice(const AuxDevice &other);
//! Constructor with publicID
AuxDevice(const std::string& publicID);
//! Destructor
~AuxDevice() override;
// ------------------------------------------------------------------
// Creators
// ------------------------------------------------------------------
public:
static AuxDevice* Create();
static AuxDevice* Create(const std::string& publicID);
static AuxDevice *Create();
static AuxDevice *Create(const std::string& publicID);
// ------------------------------------------------------------------
// Lookup
// ------------------------------------------------------------------
public:
static AuxDevice* Find(const std::string& publicID);
static AuxDevice *Find(const std::string& publicID);
// ------------------------------------------------------------------
@ -117,14 +117,14 @@ class SC_SYSTEM_CORE_API AuxDevice : public PublicObject {
public:
//! Copies the metadata of other to this
//! No changes regarding child objects are made
AuxDevice& operator=(const AuxDevice& other);
AuxDevice &operator=(const AuxDevice &other);
//! Checks for equality of two objects. Child objects
//! are not part of the check.
bool operator==(const AuxDevice& other) const;
bool operator!=(const AuxDevice& other) const;
bool operator==(const AuxDevice &other) const;
bool operator!=(const AuxDevice &other) const;
//! Wrapper that calls operator==
bool equal(const AuxDevice& other) const;
bool equal(const AuxDevice &other) const;
// ------------------------------------------------------------------
@ -157,12 +157,12 @@ class SC_SYSTEM_CORE_API AuxDevice : public PublicObject {
// ------------------------------------------------------------------
public:
//! Returns the object's index
const AuxDeviceIndex& index() const;
const AuxDeviceIndex &index() const;
//! Checks two objects for equality regarding their index
bool equalIndex(const AuxDevice* lhs) const;
bool equalIndex(const AuxDevice *lhs) const;
// ------------------------------------------------------------------
// Public interface
// ------------------------------------------------------------------
@ -175,7 +175,7 @@ class SC_SYSTEM_CORE_API AuxDevice : public PublicObject {
* because it already exists in the list
* or it already has another parent
*/
bool add(AuxSource* obj);
bool add(AuxSource *obj);
/**
* Removes an object.
@ -184,7 +184,7 @@ class SC_SYSTEM_CORE_API AuxDevice : public PublicObject {
* @return false The object has not been removed
* because it does not exist in the list
*/
bool remove(AuxSource* obj);
bool remove(AuxSource *obj);
/**
* Removes an object of a particular class.
@ -193,19 +193,19 @@ class SC_SYSTEM_CORE_API AuxDevice : public PublicObject {
* @return false The index is out of bounds
*/
bool removeAuxSource(size_t i);
bool removeAuxSource(const AuxSourceIndex& i);
bool removeAuxSource(const AuxSourceIndex &i);
//! Retrieve the number of objects of a particular class
size_t auxSourceCount() const;
//! Index access
//! @return The object at index i
AuxSource* auxSource(size_t i) const;
AuxSource* auxSource(const AuxSourceIndex& i) const;
AuxSource *auxSource(size_t i) const;
AuxSource *auxSource(const AuxSourceIndex &i) const;
//! Find an object by its unique attribute(s)
Inventory* inventory() const;
Inventory *inventory() const;
//! Implement Object interface
bool assign(Object *other) override;

20
include/seiscomp/datamodel/auxsource.h
View File

@ -82,7 +82,7 @@ class SC_SYSTEM_CORE_API AuxSource : public Object {
AuxSource();
//! Copy constructor
AuxSource(const AuxSource& other);
AuxSource(const AuxSource &other);
//! Custom constructor
AuxSource(const std::string& name);
@ -96,21 +96,21 @@ class SC_SYSTEM_CORE_API AuxSource : public Object {
//! Destructor
~AuxSource() override;
// ------------------------------------------------------------------
// Operators
// ------------------------------------------------------------------
public:
//! Copies the metadata of other to this
AuxSource& operator=(const AuxSource& other);
AuxSource &operator=(const AuxSource &other);
//! Checks for equality of two objects. Child objects
//! are not part of the check.
bool operator==(const AuxSource& other) const;
bool operator!=(const AuxSource& other) const;
bool operator==(const AuxSource &other) const;
bool operator!=(const AuxSource &other) const;
//! Wrapper that calls operator==
bool equal(const AuxSource& other) const;
bool equal(const AuxSource &other) const;
// ------------------------------------------------------------------
@ -153,17 +153,17 @@ class SC_SYSTEM_CORE_API AuxSource : public Object {
// ------------------------------------------------------------------
public:
//! Returns the object's index
const AuxSourceIndex& index() const;
const AuxSourceIndex &index() const;
//! Checks two objects for equality regarding their index
bool equalIndex(const AuxSource* lhs) const;
bool equalIndex(const AuxSource *lhs) const;
// ------------------------------------------------------------------
// Public interface
// ------------------------------------------------------------------
public:
AuxDevice* auxDevice() const;
AuxDevice *auxDevice() const;
//! Implement Object interface
bool assign(Object *other) override;

20
include/seiscomp/datamodel/auxstream.h
View File

@ -85,25 +85,25 @@ class SC_SYSTEM_CORE_API AuxStream : public Object {
AuxStream();
//! Copy constructor
AuxStream(const AuxStream& other);
AuxStream(const AuxStream &other);
//! Destructor
~AuxStream() override;
// ------------------------------------------------------------------
// Operators
// ------------------------------------------------------------------
public:
//! Copies the metadata of other to this
AuxStream& operator=(const AuxStream& other);
AuxStream &operator=(const AuxStream &other);
//! Checks for equality of two objects. Child objects
//! are not part of the check.
bool operator==(const AuxStream& other) const;
bool operator!=(const AuxStream& other) const;
bool operator==(const AuxStream &other) const;
bool operator!=(const AuxStream &other) const;
//! Wrapper that calls operator==
bool equal(const AuxStream& other) const;
bool equal(const AuxStream &other) const;
// ------------------------------------------------------------------
@ -157,17 +157,17 @@ class SC_SYSTEM_CORE_API AuxStream : public Object {
// ------------------------------------------------------------------
public:
//! Returns the object's index
const AuxStreamIndex& index() const;
const AuxStreamIndex &index() const;
//! Checks two objects for equality regarding their index
bool equalIndex(const AuxStream* lhs) const;
bool equalIndex(const AuxStream *lhs) const;
// ------------------------------------------------------------------
// Public interface
// ------------------------------------------------------------------
public:
SensorLocation* sensorLocation() const;
SensorLocation *sensorLocation() const;
//! Implement Object interface
bool assign(Object *other) override;

12
include/seiscomp/datamodel/axis.h
View File

@ -55,25 +55,25 @@ class SC_SYSTEM_CORE_API Axis : public Core::BaseObject {
Axis();
//! Copy constructor
Axis(const Axis& other);
Axis(const Axis &other);
//! Destructor
~Axis() override;
// ------------------------------------------------------------------
// Operators
// ------------------------------------------------------------------
public:
//! Copies the metadata of other to this
Axis& operator=(const Axis& other);
Axis &operator=(const Axis &other);
//! Checks for equality of two objects. Child objects
//! are not part of the check.
bool operator==(const Axis& other) const;
bool operator!=(const Axis& other) const;
bool operator==(const Axis &other) const;
bool operator!=(const Axis &other) const;
//! Wrapper that calls operator==
bool equal(const Axis& other) const;
bool equal(const Axis &other) const;
// ------------------------------------------------------------------

12
include/seiscomp/datamodel/blob.h
View File

@ -48,25 +48,25 @@ class SC_SYSTEM_CORE_API Blob : public Core::BaseObject {
Blob();
//! Copy constructor
Blob(const Blob& other);
Blob(const Blob &other);
//! Destructor
~Blob() override;
// ------------------------------------------------------------------
// Operators
// ------------------------------------------------------------------
public:
//! Copies the metadata of other to this
Blob& operator=(const Blob& other);
Blob &operator=(const Blob &other);
//! Checks for equality of two objects. Child objects
//! are not part of the check.
bool operator==(const Blob& other) const;
bool operator!=(const Blob& other) const;
bool operator==(const Blob &other) const;
bool operator!=(const Blob &other) const;
//! Wrapper that calls operator==
bool equal(const Blob& other) const;
bool equal(const Blob &other) const;
// ------------------------------------------------------------------

217
include/seiscomp/datamodel/catalog.h Normal file
View File

@ -0,0 +1,217 @@
/***************************************************************************
* Copyright (C) gempa GmbH *
* All rights reserved. *
* Contact: gempa GmbH (seiscomp-dev@gempa.de) *
* *
* GNU Affero General Public License Usage *
* This file may be used under the terms of the GNU Affero *
* Public License version 3.0 as published by the Free Software Foundation *
* and appearing in the file LICENSE included in the packaging of this *
* file. Please review the following information to ensure the GNU Affero *
* Public License version 3.0 requirements will be met: *
* https://www.gnu.org/licenses/agpl-3.0.html. *
* *
* Other Usage *
* Alternatively, this file may be used in accordance with the terms and *
* conditions contained in a signed written agreement between you and *
* gempa GmbH. *
***************************************************************************/
#ifndef SEISCOMP_DATAMODEL_CATALOG_H
#define SEISCOMP_DATAMODEL_CATALOG_H
#include <string>
#include <seiscomp/datamodel/creationinfo.h>
#include <seiscomp/core/datetime.h>
#include <vector>
#include <seiscomp/datamodel/comment.h>
#include <seiscomp/datamodel/notifier.h>
#include <seiscomp/datamodel/publicobject.h>
#include <seiscomp/core/exceptions.h>
namespace Seiscomp {
namespace DataModel {
DEFINE_SMARTPOINTER(Catalog);
DEFINE_SMARTPOINTER(Comment);
DEFINE_SMARTPOINTER(Event);
class EventParameters;
class SC_SYSTEM_CORE_API Catalog : public PublicObject {
DECLARE_SC_CLASS(Catalog)
DECLARE_SERIALIZATION;
DECLARE_METAOBJECT;
// ------------------------------------------------------------------
// Xstruction
// ------------------------------------------------------------------
protected:
//! Protected constructor
Catalog();
public:
//! Copy constructor
Catalog(const Catalog &other);
//! Constructor with publicID
Catalog(const std::string& publicID);
//! Destructor
~Catalog() override;
// ------------------------------------------------------------------
// Creators
// ------------------------------------------------------------------
public:
static Catalog *Create();
static Catalog *Create(const std::string& publicID);
// ------------------------------------------------------------------
// Lookup
// ------------------------------------------------------------------
public:
static Catalog *Find(const std::string& publicID);
// ------------------------------------------------------------------
// Operators
// ------------------------------------------------------------------
public:
//! Copies the metadata of other to this
//! No changes regarding child objects are made
Catalog &operator=(const Catalog &other);
//! Checks for equality of two objects. Child objects
//! are not part of the check.
bool operator==(const Catalog &other) const;
bool operator!=(const Catalog &other) const;
//! Wrapper that calls operator==
bool equal(const Catalog &other) const;
// ------------------------------------------------------------------
// Setters/Getters
// ------------------------------------------------------------------
public:
void setName(const std::string& name);
const std::string& name() const;
//! Catalog description
void setDescription(const std::string& description);
const std::string& description() const;
//! CreationInfo for the Catalog object.
void setCreationInfo(const OPT(CreationInfo)& creationInfo);
CreationInfo& creationInfo();
const CreationInfo& creationInfo() const;
//! Start of epoch in ISO datetime format
void setStart(Seiscomp::Core::Time start);
Seiscomp::Core::Time start() const;
//! End of epoch (empty if the catalog epoch is open)
void setEnd(const OPT(Seiscomp::Core::Time)& end);
Seiscomp::Core::Time end() const;
void setDynamic(bool dynamic);
bool dynamic() const;
// ------------------------------------------------------------------
// Public interface
// ------------------------------------------------------------------
public:
/**
* Add an object.
* @param obj The object pointer
* @return true The object has been added
* @return false The object has not been added
* because it already exists in the list
* or it already has another parent
*/
bool add(Comment *obj);
bool add(Event *obj);
/**
* Removes an object.
* @param obj The object pointer
* @return true The object has been removed
* @return false The object has not been removed
* because it does not exist in the list
*/
bool remove(Comment *obj);
bool remove(Event *obj);
/**
* Removes an object of a particular class.
* @param i The object index
* @return true The object has been removed
* @return false The index is out of bounds
*/
bool removeComment(size_t i);
bool removeComment(const CommentIndex &i);
bool removeEvent(size_t i);
//! Retrieve the number of objects of a particular class
size_t commentCount() const;
size_t eventCount() const;
//! Index access
//! @return The object at index i
Comment *comment(size_t i) const;
Comment *comment(const CommentIndex &i) const;
Event *event(size_t i) const;
//! Find an object by its unique attribute(s)
Event *findEvent(const std::string& publicID) const;
EventParameters *eventParameters() const;
//! Implement Object interface
bool assign(Object *other) override;
bool attachTo(PublicObject *parent) override;
bool detachFrom(PublicObject *parent) override;
bool detach() override;
//! Creates a clone
Object *clone() const override;
//! Implement PublicObject interface
bool updateChild(Object *child) override;
void accept(Visitor *visitor) override;
// ------------------------------------------------------------------
// Implementation
// ------------------------------------------------------------------
private:
// Attributes
std::string _name;
std::string _description;
OPT(CreationInfo) _creationInfo;
Seiscomp::Core::Time _start;
OPT(Seiscomp::Core::Time) _end;
bool _dynamic;
// Aggregations
std::vector<CommentPtr> _comments;
std::vector<EventPtr> _events;
DECLARE_SC_CLASSFACTORY_FRIEND(Catalog);
};
}
}
#endif

48
include/seiscomp/datamodel/comment.h
View File

@ -42,6 +42,7 @@ class Magnitude;
class StationMagnitude;
class Pick;
class Event;
class Catalog;
class Origin;
class Parameter;
class ParameterSet;
@ -97,25 +98,25 @@ class SC_SYSTEM_CORE_API Comment : public Object {
Comment();
//! Copy constructor
Comment(const Comment& other);
Comment(const Comment &other);
//! Destructor
~Comment() override;
// ------------------------------------------------------------------
// Operators
// ------------------------------------------------------------------
public:
//! Copies the metadata of other to this
Comment& operator=(const Comment& other);
Comment &operator=(const Comment &other);
//! Checks for equality of two objects. Child objects
//! are not part of the check.
bool operator==(const Comment& other) const;
bool operator!=(const Comment& other) const;
bool operator==(const Comment &other) const;
bool operator!=(const Comment &other) const;
//! Wrapper that calls operator==
bool equal(const Comment& other) const;
bool equal(const Comment &other) const;
// ------------------------------------------------------------------
@ -149,12 +150,12 @@ class SC_SYSTEM_CORE_API Comment : public Object {
// ------------------------------------------------------------------
public:
//! Returns the object's index
const CommentIndex& index() const;
const CommentIndex &index() const;
//! Checks two objects for equality regarding their index
bool equalIndex(const Comment* lhs) const;
bool equalIndex(const Comment *lhs) const;
// ------------------------------------------------------------------
// Public interface
// ------------------------------------------------------------------
@ -164,20 +165,21 @@ class SC_SYSTEM_CORE_API Comment : public Object {
* Because different parent types are possible, just one
* of these methods will return a valid pointer at a time.
*/
MomentTensor* momentTensor() const;
FocalMechanism* focalMechanism() const;
Amplitude* amplitude() const;
Magnitude* magnitude() const;
StationMagnitude* stationMagnitude() const;
Pick* pick() const;
Event* event() const;
Origin* origin() const;
Parameter* parameter() const;
ParameterSet* parameterSet() const;
Stream* stream() const;
SensorLocation* sensorLocation() const;
Station* station() const;
Network* network() const;
MomentTensor *momentTensor() const;
FocalMechanism *focalMechanism() const;
Amplitude *amplitude() const;
Magnitude *magnitude() const;
StationMagnitude *stationMagnitude() const;
Pick *pick() const;
Event *event() const;
Catalog *catalog() const;
Origin *origin() const;
Parameter *parameter() const;
ParameterSet *parameterSet() const;
Stream *stream() const;
SensorLocation *sensorLocation() const;
Station *station() const;
Network *network() const;
//! Implement Object interface
bool assign(Object *other) override;

16
include/seiscomp/datamodel/complexarray.h
View File

@ -49,25 +49,25 @@ class SC_SYSTEM_CORE_API ComplexArray : public Core::BaseObject {
ComplexArray();
//! Copy constructor
ComplexArray(const ComplexArray& other);
ComplexArray(const ComplexArray &other);
//! Destructor
~ComplexArray() override;
// ------------------------------------------------------------------
// Operators
// ------------------------------------------------------------------
public:
//! Copies the metadata of other to this
ComplexArray& operator=(const ComplexArray& other);
ComplexArray &operator=(const ComplexArray &other);
//! Checks for equality of two objects. Child objects
//! are not part of the check.
bool operator==(const ComplexArray& other) const;
bool operator!=(const ComplexArray& other) const;
bool operator==(const ComplexArray &other) const;
bool operator!=(const ComplexArray &other) const;
//! Wrapper that calls operator==
bool equal(const ComplexArray& other) const;
bool equal(const ComplexArray &other) const;
// ------------------------------------------------------------------
@ -75,8 +75,8 @@ class SC_SYSTEM_CORE_API ComplexArray : public Core::BaseObject {
// ------------------------------------------------------------------
public:
void setContent(const std::vector< std::complex<double> >&);
const std::vector< std::complex<double> >& content() const;
std::vector< std::complex<double> >& content();
const std::vector< std::complex<double> > &content() const;
std::vector< std::complex<double> > &content();
// ------------------------------------------------------------------

16
include/seiscomp/datamodel/compositetime.h
View File

@ -83,25 +83,25 @@ class SC_SYSTEM_CORE_API CompositeTime : public Object {
CompositeTime();
//! Copy constructor
CompositeTime(const CompositeTime& other);
CompositeTime(const CompositeTime &other);
//! Destructor
~CompositeTime() override;
// ------------------------------------------------------------------
// Operators
// ------------------------------------------------------------------
public:
//! Copies the metadata of other to this
CompositeTime& operator=(const CompositeTime& other);
CompositeTime &operator=(const CompositeTime &other);
//! Checks for equality of two objects. Child objects
//! are not part of the check.
bool operator==(const CompositeTime& other) const;
bool operator!=(const CompositeTime& other) const;
bool operator==(const CompositeTime &other) const;
bool operator!=(const CompositeTime &other) const;
//! Wrapper that calls operator==
bool equal(const CompositeTime& other) const;
bool equal(const CompositeTime &other) const;
// ------------------------------------------------------------------
@ -139,12 +139,12 @@ class SC_SYSTEM_CORE_API CompositeTime : public Object {
RealQuantity& second();
const RealQuantity& second() const;
// ------------------------------------------------------------------
// Public interface
// ------------------------------------------------------------------
public:
Origin* origin() const;
Origin *origin() const;
//! Implement Object interface
bool assign(Object *other) override;

12
include/seiscomp/datamodel/confidenceellipsoid.h
View File

@ -101,25 +101,25 @@ class SC_SYSTEM_CORE_API ConfidenceEllipsoid : public Core::BaseObject {
ConfidenceEllipsoid();
//! Copy constructor
ConfidenceEllipsoid(const ConfidenceEllipsoid& other);
ConfidenceEllipsoid(const ConfidenceEllipsoid &other);
//! Destructor
~ConfidenceEllipsoid() override;
// ------------------------------------------------------------------
// Operators
// ------------------------------------------------------------------
public:
//! Copies the metadata of other to this
ConfidenceEllipsoid& operator=(const ConfidenceEllipsoid& other);
ConfidenceEllipsoid &operator=(const ConfidenceEllipsoid &other);
//! Checks for equality of two objects. Child objects
//! are not part of the check.
bool operator==(const ConfidenceEllipsoid& other) const;
bool operator!=(const ConfidenceEllipsoid& other) const;
bool operator==(const ConfidenceEllipsoid &other) const;
bool operator!=(const ConfidenceEllipsoid &other) const;
//! Wrapper that calls operator==
bool equal(const ConfidenceEllipsoid& other) const;
bool equal(const ConfidenceEllipsoid &other) const;
// ------------------------------------------------------------------

30
include/seiscomp/datamodel/config.h
View File

@ -50,11 +50,11 @@ class SC_SYSTEM_CORE_API Config : public PublicObject {
Config();
//! Copy constructor
Config(const Config& other);
Config(const Config &other);
//! Destructor
~Config() override;
// ------------------------------------------------------------------
// Operators
@ -62,16 +62,16 @@ class SC_SYSTEM_CORE_API Config : public PublicObject {
public:
//! Copies the metadata of other to this
//! No changes regarding child objects are made
Config& operator=(const Config& other);
Config &operator=(const Config &other);
//! Checks for equality of two objects. Child objects
//! are not part of the check.
bool operator==(const Config& other) const;
bool operator!=(const Config& other) const;
bool operator==(const Config &other) const;
bool operator!=(const Config &other) const;
//! Wrapper that calls operator==
bool equal(const Config& other) const;
bool equal(const Config &other) const;
// ------------------------------------------------------------------
// Public interface
// ------------------------------------------------------------------
@ -84,8 +84,8 @@ class SC_SYSTEM_CORE_API Config : public PublicObject {
* because it already exists in the list
* or it already has another parent
*/
bool add(ParameterSet* obj);
bool add(ConfigModule* obj);
bool add(ParameterSet *obj);
bool add(ConfigModule *obj);
/**
* Removes an object.
@ -94,8 +94,8 @@ class SC_SYSTEM_CORE_API Config : public PublicObject {
* @return false The object has not been removed
* because it does not exist in the list
*/
bool remove(ParameterSet* obj);
bool remove(ConfigModule* obj);
bool remove(ParameterSet *obj);
bool remove(ConfigModule *obj);
/**
* Removes an object of a particular class.
@ -112,12 +112,12 @@ class SC_SYSTEM_CORE_API Config : public PublicObject {
//! Index access
//! @return The object at index i
ParameterSet* parameterSet(size_t i) const;
ConfigModule* configModule(size_t i) const;
ParameterSet *parameterSet(size_t i) const;
ConfigModule *configModule(size_t i) const;
//! Find an object by its unique attribute(s)
ParameterSet* findParameterSet(const std::string& publicID) const;
ConfigModule* findConfigModule(const std::string& publicID) const;
ParameterSet *findParameterSet(const std::string& publicID) const;
ConfigModule *findConfigModule(const std::string& publicID) const;
//! Implement Object interface
bool assign(Object *other) override;

34
include/seiscomp/datamodel/configmodule.h
View File

@ -54,28 +54,28 @@ class SC_SYSTEM_CORE_API ConfigModule : public PublicObject {
public:
//! Copy constructor
ConfigModule(const ConfigModule& other);
ConfigModule(const ConfigModule &other);
//! Constructor with publicID
ConfigModule(const std::string& publicID);
//! Destructor
~ConfigModule() override;
// ------------------------------------------------------------------
// Creators
// ------------------------------------------------------------------
public:
static ConfigModule* Create();
static ConfigModule* Create(const std::string& publicID);
static ConfigModule *Create();
static ConfigModule *Create(const std::string& publicID);
// ------------------------------------------------------------------
// Lookup
// ------------------------------------------------------------------
public:
static ConfigModule* Find(const std::string& publicID);
static ConfigModule *Find(const std::string& publicID);
// ------------------------------------------------------------------
@ -84,14 +84,14 @@ class SC_SYSTEM_CORE_API ConfigModule : public PublicObject {
public:
//! Copies the metadata of other to this
//! No changes regarding child objects are made
ConfigModule& operator=(const ConfigModule& other);
ConfigModule &operator=(const ConfigModule &other);
//! Checks for equality of two objects. Child objects
//! are not part of the check.
bool operator==(const ConfigModule& other) const;
bool operator!=(const ConfigModule& other) const;
bool operator==(const ConfigModule &other) const;
bool operator!=(const ConfigModule &other) const;
//! Wrapper that calls operator==
bool equal(const ConfigModule& other) const;
bool equal(const ConfigModule &other) const;
// ------------------------------------------------------------------
@ -107,7 +107,7 @@ class SC_SYSTEM_CORE_API ConfigModule : public PublicObject {
void setEnabled(bool enabled);
bool enabled() const;
// ------------------------------------------------------------------
// Public interface
// ------------------------------------------------------------------
@ -120,7 +120,7 @@ class SC_SYSTEM_CORE_API ConfigModule : public PublicObject {
* because it already exists in the list
* or it already has another parent
*/
bool add(ConfigStation* obj);
bool add(ConfigStation *obj);
/**
* Removes an object.
@ -129,7 +129,7 @@ class SC_SYSTEM_CORE_API ConfigModule : public PublicObject {
* @return false The object has not been removed
* because it does not exist in the list
*/
bool remove(ConfigStation* obj);
bool remove(ConfigStation *obj);
/**
* Removes an object of a particular class.
@ -138,20 +138,20 @@ class SC_SYSTEM_CORE_API ConfigModule : public PublicObject {
* @return false The index is out of bounds
*/
bool removeConfigStation(size_t i);
bool removeConfigStation(const ConfigStationIndex& i);
bool removeConfigStation(const ConfigStationIndex &i);
//! Retrieve the number of objects of a particular class
size_t configStationCount() const;
//! Index access
//! @return The object at index i
ConfigStation* configStation(size_t i) const;
ConfigStation* configStation(const ConfigStationIndex& i) const;
ConfigStation *configStation(size_t i) const;
ConfigStation *configStation(const ConfigStationIndex &i) const;
//! Find an object by its unique attribute(s)
ConfigStation* findConfigStation(const std::string& publicID) const;
ConfigStation *findConfigStation(const std::string& publicID) const;
Config* config() const;
Config *config() const;
//! Implement Object interface
bool assign(Object *other) override;

36
include/seiscomp/datamodel/configstation.h
View File

@ -86,28 +86,28 @@ class SC_SYSTEM_CORE_API ConfigStation : public PublicObject {
public:
//! Copy constructor
ConfigStation(const ConfigStation& other);
ConfigStation(const ConfigStation &other);
//! Constructor with publicID
ConfigStation(const std::string& publicID);
//! Destructor
~ConfigStation() override;
// ------------------------------------------------------------------
// Creators
// ------------------------------------------------------------------
public:
static ConfigStation* Create();
static ConfigStation* Create(const std::string& publicID);
static ConfigStation *Create();
static ConfigStation *Create(const std::string& publicID);
// ------------------------------------------------------------------
// Lookup
// ------------------------------------------------------------------
public:
static ConfigStation* Find(const std::string& publicID);
static ConfigStation *Find(const std::string& publicID);
// ------------------------------------------------------------------
@ -116,14 +116,14 @@ class SC_SYSTEM_CORE_API ConfigStation : public PublicObject {
public:
//! Copies the metadata of other to this
//! No changes regarding child objects are made
ConfigStation& operator=(const ConfigStation& other);
ConfigStation &operator=(const ConfigStation &other);
//! Checks for equality of two objects. Child objects
//! are not part of the check.
bool operator==(const ConfigStation& other) const;
bool operator!=(const ConfigStation& other) const;
bool operator==(const ConfigStation &other) const;
bool operator!=(const ConfigStation &other) const;
//! Wrapper that calls operator==
bool equal(const ConfigStation& other) const;
bool equal(const ConfigStation &other) const;
// ------------------------------------------------------------------
@ -150,12 +150,12 @@ class SC_SYSTEM_CORE_API ConfigStation : public PublicObject {
// ------------------------------------------------------------------
public:
//! Returns the object's index
const ConfigStationIndex& index() const;
const ConfigStationIndex &index() const;
//! Checks two objects for equality regarding their index
bool equalIndex(const ConfigStation* lhs) const;
bool equalIndex(const ConfigStation *lhs) const;
// ------------------------------------------------------------------
// Public interface
// ------------------------------------------------------------------
@ -168,7 +168,7 @@ class SC_SYSTEM_CORE_API ConfigStation : public PublicObject {
* because it already exists in the list
* or it already has another parent
*/
bool add(Setup* obj);
bool add(Setup *obj);
/**
* Removes an object.
@ -177,7 +177,7 @@ class SC_SYSTEM_CORE_API ConfigStation : public PublicObject {
* @return false The object has not been removed
* because it does not exist in the list
*/
bool remove(Setup* obj);
bool remove(Setup *obj);
/**
* Removes an object of a particular class.
@ -186,19 +186,19 @@ class SC_SYSTEM_CORE_API ConfigStation : public PublicObject {
* @return false The index is out of bounds
*/
bool removeSetup(size_t i);
bool removeSetup(const SetupIndex& i);
bool removeSetup(const SetupIndex &i);
//! Retrieve the number of objects of a particular class
size_t setupCount() const;
//! Index access
//! @return The object at index i
Setup* setup(size_t i) const;
Setup* setup(const SetupIndex& i) const;
Setup *setup(size_t i) const;
Setup *setup(const SetupIndex &i) const;
//! Find an object by its unique attribute(s)
ConfigModule* configModule() const;
ConfigModule *configModule() const;
//! Implement Object interface
bool assign(Object *other) override;

12
include/seiscomp/datamodel/creationinfo.h
View File

@ -53,25 +53,25 @@ class SC_SYSTEM_CORE_API CreationInfo : public Core::BaseObject {
CreationInfo();
//! Copy constructor
CreationInfo(const CreationInfo& other);
CreationInfo(const CreationInfo &other);
//! Destructor
~CreationInfo() override;
// ------------------------------------------------------------------
// Operators
// ------------------------------------------------------------------
public:
//! Copies the metadata of other to this
CreationInfo& operator=(const CreationInfo& other);
CreationInfo &operator=(const CreationInfo &other);
//! Checks for equality of two objects. Child objects
//! are not part of the check.
bool operator==(const CreationInfo& other) const;
bool operator!=(const CreationInfo& other) const;
bool operator==(const CreationInfo &other) const;
bool operator!=(const CreationInfo &other) const;
//! Wrapper that calls operator==
bool equal(const CreationInfo& other) const;
bool equal(const CreationInfo &other) const;
// ------------------------------------------------------------------

20
include/seiscomp/datamodel/dataattributeextent.h
View File

@ -81,25 +81,25 @@ class SC_SYSTEM_CORE_API DataAttributeExtent : public Object {
DataAttributeExtent();
//! Copy constructor
DataAttributeExtent(const DataAttributeExtent& other);
DataAttributeExtent(const DataAttributeExtent &other);
//! Destructor
~DataAttributeExtent() override;
// ------------------------------------------------------------------
// Operators
// ------------------------------------------------------------------
public:
//! Copies the metadata of other to this
DataAttributeExtent& operator=(const DataAttributeExtent& other);
DataAttributeExtent &operator=(const DataAttributeExtent &other);
//! Checks for equality of two objects. Child objects
//! are not part of the check.
bool operator==(const DataAttributeExtent& other) const;
bool operator!=(const DataAttributeExtent& other) const;
bool operator==(const DataAttributeExtent &other) const;
bool operator!=(const DataAttributeExtent &other) const;
//! Wrapper that calls operator==
bool equal(const DataAttributeExtent& other) const;
bool equal(const DataAttributeExtent &other) const;
// ------------------------------------------------------------------
@ -138,17 +138,17 @@ class SC_SYSTEM_CORE_API DataAttributeExtent : public Object {
// ------------------------------------------------------------------
public:
//! Returns the object's index
const DataAttributeExtentIndex& index() const;
const DataAttributeExtentIndex &index() const;
//! Checks two objects for equality regarding their index
bool equalIndex(const DataAttributeExtent* lhs) const;
bool equalIndex(const DataAttributeExtent *lhs) const;
// ------------------------------------------------------------------
// Public interface
// ------------------------------------------------------------------
public:
DataExtent* dataExtent() const;
DataExtent *dataExtent() const;
//! Implement Object interface
bool assign(Object *other) override;

26
include/seiscomp/datamodel/dataavailability.h
View File

@ -54,11 +54,11 @@ class SC_SYSTEM_CORE_API DataAvailability : public PublicObject {
DataAvailability();
//! Copy constructor
DataAvailability(const DataAvailability& other);
DataAvailability(const DataAvailability &other);
//! Destructor
~DataAvailability() override;
// ------------------------------------------------------------------
// Operators
@ -66,16 +66,16 @@ class SC_SYSTEM_CORE_API DataAvailability : public PublicObject {
public:
//! Copies the metadata of other to this
//! No changes regarding child objects are made
DataAvailability& operator=(const DataAvailability& other);
DataAvailability &operator=(const DataAvailability &other);
//! Checks for equality of two objects. Child objects
//! are not part of the check.
bool operator==(const DataAvailability& other) const;
bool operator!=(const DataAvailability& other) const;
bool operator==(const DataAvailability &other) const;
bool operator!=(const DataAvailability &other) const;
//! Wrapper that calls operator==
bool equal(const DataAvailability& other) const;
bool equal(const DataAvailability &other) const;
// ------------------------------------------------------------------
// Public interface
// ------------------------------------------------------------------
@ -88,7 +88,7 @@ class SC_SYSTEM_CORE_API DataAvailability : public PublicObject {
* because it already exists in the list
* or it already has another parent
*/
bool add(DataExtent* obj);
bool add(DataExtent *obj);
/**
* Removes an object.
@ -97,7 +97,7 @@ class SC_SYSTEM_CORE_API DataAvailability : public PublicObject {
* @return false The object has not been removed
* because it does not exist in the list
*/
bool remove(DataExtent* obj);
bool remove(DataExtent *obj);
/**
* Removes an object of a particular class.
@ -106,18 +106,18 @@ class SC_SYSTEM_CORE_API DataAvailability : public PublicObject {
* @return false The index is out of bounds
*/
bool removeDataExtent(size_t i);
bool removeDataExtent(const DataExtentIndex& i);
bool removeDataExtent(const DataExtentIndex &i);
//! Retrieve the number of objects of a particular class
size_t dataExtentCount() const;
//! Index access
//! @return The object at index i
DataExtent* dataExtent(size_t i) const;
DataExtent* dataExtent(const DataExtentIndex& i) const;
DataExtent *dataExtent(size_t i) const;
DataExtent *dataExtent(const DataExtentIndex &i) const;
//! Find an object by its unique attribute(s)
DataExtent* findDataExtent(const std::string& publicID) const;
DataExtent *findDataExtent(const std::string& publicID) const;
//! Implement Object interface
bool assign(Object *other) override;

144
include/seiscomp/datamodel/databasearchive.h
View File

@ -241,10 +241,10 @@ class SC_SYSTEM_CORE_API DatabaseArchive : protected Core::Archive,
//! Implements derived method
//! @param dataSource user:password@host:port/database
bool open(const char* dataSource);
bool open(const char* dataSource) override;
//! Implements derived method
void close();
void close() override;
//! Returns the used database driver
Seiscomp::IO::DatabaseInterface* driver() const;
@ -261,6 +261,22 @@ class SC_SYSTEM_CORE_API DatabaseArchive : protected Core::Archive,
void benchmarkQueries(int count);
/**
* @brief Returns the query to fetch objects of a particular type.
* @param parentID The publicID of the parent object. When empty then
* it won't be included in the query.
* @param classType The type of the object to be read.
* @param ignorePublicObject If true then the PublicObject table will
* not be joined. That might be important if
* during a schema evolution an objectsturned
* into a PublicObject but an old version
* should be read.
* @return The query and a flag if a where clause is present.
*/
std::pair<std::string,bool> getObjectsQuery(const std::string &parentID,
const Seiscomp::Core::RTTI &classType,
bool ignorePublicObject = false);
/**
* Reads a public object from the database.
* @param classType The type of the object to be read. The type has
@ -269,8 +285,8 @@ class SC_SYSTEM_CORE_API DatabaseArchive : protected Core::Archive,
* @return An unmanaged object pointer. The ownership goes over
* to the caller.
*/
PublicObject* getObject(const Seiscomp::Core::RTTI& classType,
const std::string& publicID);
PublicObject* getObject(const Seiscomp::Core::RTTI &classType,
const std::string &publicID);
/**
* Returns an iterator over all objects of a given type.
@ -285,8 +301,8 @@ class SC_SYSTEM_CORE_API DatabaseArchive : protected Core::Archive,
* should be read.
* @return The database iterator
*/
DatabaseIterator getObjects(const std::string& parentID,
const Seiscomp::Core::RTTI& classType,
DatabaseIterator getObjects(const std::string &parentID,
const Seiscomp::Core::RTTI &classType,
bool ignorePublicObject = false);
/**
@ -302,8 +318,8 @@ class SC_SYSTEM_CORE_API DatabaseArchive : protected Core::Archive,
* should be read.
* @return The database iterator
*/
DatabaseIterator getObjects(const PublicObject* parent,
const Seiscomp::Core::RTTI& classType,
DatabaseIterator getObjects(const PublicObject *parent,
const Seiscomp::Core::RTTI &classType,
bool ignorePublicObject = false);
/**
@ -314,8 +330,8 @@ class SC_SYSTEM_CORE_API DatabaseArchive : protected Core::Archive,
* @param classType The type of the objects to iterate over.
* @return The object count
*/
size_t getObjectCount(const std::string& parentID,
const Seiscomp::Core::RTTI& classType);
size_t getObjectCount(const std::string &parentID,
const Seiscomp::Core::RTTI &classType);
/**
* Returns the number of objects of a given type for a parent
@ -325,7 +341,7 @@ class SC_SYSTEM_CORE_API DatabaseArchive : protected Core::Archive,
* @param classType The type of the objects to iterate over.
* @return The object count
*/
size_t getObjectCount(const PublicObject* parent,
size_t getObjectCount(const PublicObject *parent,
const Seiscomp::Core::RTTI &classType);
@ -338,7 +354,7 @@ class SC_SYSTEM_CORE_API DatabaseArchive : protected Core::Archive,
* @param object The PublicObject whose parent is queried.
* @return The publicID of the parent or an empty string.
*/
std::string parentPublicID(const PublicObject* object);
std::string parentPublicID(const PublicObject *object);
/**
* Inserts an object into the database.
@ -390,7 +406,7 @@ class SC_SYSTEM_CORE_API DatabaseArchive : protected Core::Archive,
// ----------------------------------------------------------------------
protected:
//! Implements derived method
bool create(const char* dataSource);
bool create(const char* dataSource) override;
// ----------------------------------------------------------------------
@ -398,40 +414,40 @@ class SC_SYSTEM_CORE_API DatabaseArchive : protected Core::Archive,
// ----------------------------------------------------------------------
protected:
//! Reads an integer
virtual void read(std::int8_t& value);
virtual void read(std::int16_t& value);
virtual void read(std::int32_t& value);
virtual void read(std::int64_t& value);
virtual void read(std::int8_t& value) override;
virtual void read(std::int16_t& value) override;
virtual void read(std::int32_t& value) override;
virtual void read(std::int64_t& value) override;
//! Reads a float
virtual void read(float& value);
virtual void read(float& value) override;
//! Reads a double
virtual void read(double& value);
virtual void read(double& value) override;
//! Reads a float complex
virtual void read(std::complex<float>& value);
virtual void read(std::complex<float>& value) override;
//! Reads a double complex
virtual void read(std::complex<double>& value);
virtual void read(std::complex<double>& value) override;
//! Reads a boolean
virtual void read(bool& value);
virtual void read(bool& value) override;
//! Reads a vector of native types
virtual void read(std::vector<char>& value);
virtual void read(std::vector<int8_t>& value);
virtual void read(std::vector<int16_t>& value);
virtual void read(std::vector<int32_t>& value);
virtual void read(std::vector<int64_t>& value);
virtual void read(std::vector<float>& value);
virtual void read(std::vector<double>& value);
virtual void read(std::vector<std::string>& value);
virtual void read(std::vector<Core::Time>& value);
virtual void read(std::vector<char>& value) override;
virtual void read(std::vector<int8_t>& value) override;
virtual void read(std::vector<int16_t>& value) override;
virtual void read(std::vector<int32_t>& value) override;
virtual void read(std::vector<int64_t>& value) override;
virtual void read(std::vector<float>& value) override;
virtual void read(std::vector<double>& value) override;
virtual void read(std::vector<std::string>& value) override;
virtual void read(std::vector<Core::Time>& value) override;
//! Reads a vector of complex doubles
virtual void read(std::vector<std::complex<double> >& value);
virtual void read(std::vector<std::complex<double> >& value) override;
//! Reads a string
virtual void read(std::string& value);
virtual void read(std::string& value) override;
//! Reads a time
virtual void read(Seiscomp::Core::Time& value);
virtual void read(Seiscomp::Core::Time& value) override;
// ------------------------------------------------------------------
@ -439,47 +455,47 @@ class SC_SYSTEM_CORE_API DatabaseArchive : protected Core::Archive,
// ------------------------------------------------------------------
protected:
//! Writes an integer
virtual void write(std::int8_t value);
virtual void write(std::int16_t value);
virtual void write(std::int32_t value);
virtual void write(std::int64_t value);
virtual void write(std::int8_t value) override;
virtual void write(std::int16_t value) override;
virtual void write(std::int32_t value) override;
virtual void write(std::int64_t value) override;
//! Writes a float
virtual void write(float value);
virtual void write(float value) override;
//! Writes a double
virtual void write(double value);
virtual void write(double value) override;
//! Writes a float complex
virtual void write(std::complex<float>& value);
virtual void write(std::complex<float>& value) override;
//! Writes a double complex
virtual void write(std::complex<double>& value);
virtual void write(std::complex<double>& value) override;
//! Writes a boolean
virtual void write(bool value);
virtual void write(bool value) override;
//! Writes a vector of native types
virtual void write(std::vector<char>& value);
virtual void write(std::vector<int8_t>& value);
virtual void write(std::vector<int16_t>& value);
virtual void write(std::vector<int32_t>& value);
virtual void write(std::vector<int64_t>& value);
virtual void write(std::vector<float>& value);
virtual void write(std::vector<double>& value);
virtual void write(std::vector<std::string>& value);
virtual void write(std::vector<Core::Time>& value);
virtual void write(std::vector<char>& value) override;
virtual void write(std::vector<int8_t>& value) override;
virtual void write(std::vector<int16_t>& value) override;
virtual void write(std::vector<int32_t>& value) override;
virtual void write(std::vector<int64_t>& value) override;
virtual void write(std::vector<float>& value) override;
virtual void write(std::vector<double>& value) override;
virtual void write(std::vector<std::string>& value) override;
virtual void write(std::vector<Core::Time>& value) override;
//! Writes a vector of complex doubles
virtual void write(std::vector<std::complex<double> >& value);
virtual void write(std::vector<std::complex<double> >& value) override;
//! Writes a string
virtual void write(std::string& value);
virtual void write(std::string& value) override;
//! Writes a time
virtual void write(Seiscomp::Core::Time& value);
virtual void write(Seiscomp::Core::Time& value) override;
// ------------------------------------------------------------------
// Protected observer interface
// ------------------------------------------------------------------
protected:
virtual void onObjectDestroyed(Object* object);
virtual void onObjectDestroyed(Object* object) override;
// ------------------------------------------------------------------
@ -487,23 +503,23 @@ class SC_SYSTEM_CORE_API DatabaseArchive : protected Core::Archive,
// ------------------------------------------------------------------
protected:
//! Implements derived method
virtual bool locateObjectByName(const char* name, const char* targetClass, bool nullable);
virtual bool locateObjectByName(const char* name, const char* targetClass, bool nullable) override;
//! Implements derived method
virtual bool locateNextObjectByName(const char* name, const char* targetClass);
virtual bool locateNextObjectByName(const char* name, const char* targetClass) override;
//! Implements derived method
virtual void locateNullObjectByName(const char* name, const char* targetClass, bool first);
virtual void locateNullObjectByName(const char* name, const char* targetClass, bool first) override;
//! Implements derived method
virtual std::string determineClassName();
virtual std::string determineClassName() override;
//! Implements derived method
virtual void setClassName(const char*);
virtual void setClassName(const char*) override;
//! Implements derived method
void serialize(RootType* object);
void serialize(RootType* object) override;
//! Implements derived method
void serialize(SerializeDispatcher&);
void serialize(SerializeDispatcher&) override;
std::string buildQuery(const std::string& table,
const std::string& filter = "");
@ -546,7 +562,7 @@ class SC_SYSTEM_CORE_API DatabaseArchive : protected Core::Archive,
//! Removes an objects from the id cache
void removeId(Object*);
//! Returns the current field content
const char* cfield() const { return _field; }

15
include/seiscomp/datamodel/databasequery.h
View File

@ -74,10 +74,6 @@ class SC_SYSTEM_CORE_API DatabaseQuery : public DatabaseReader {
// Query interface
// ----------------------------------------------------------------------
public:
Station* getStation(const std::string& network_code,
const std::string& station_code,
Seiscomp::Core::Time time);
/**
* Returns the Event referencing a particular Origin.
* @param originID The publicID of the Origin
@ -324,6 +320,17 @@ class SC_SYSTEM_CORE_API DatabaseQuery : public DatabaseReader {
DatabaseIterator getEvents(Seiscomp::Core::Time startTime,
Seiscomp::Core::Time endTime);
/**
* Returns events in a given time range
* @param catalogID the publicID of the parent catalog
* @param startTime start time
* @param endTime end time
* @return An iterator to iterate over the events
*/
DatabaseIterator getEvents(const std::string& catalogID,
Seiscomp::Core::Time startTime,
Seiscomp::Core::Time endTime);
/**
* Returns origins for a given event ordered by creation date
* the oldest first.

38
include/seiscomp/datamodel/databasereader.h
View File

@ -48,6 +48,7 @@ class DataUsed;
class MomentTensorPhaseSetting;
class MomentTensorStationContribution;
class MomentTensorComponentContribution;
class Catalog;
class Event;
class EventDescription;
class OriginReference;
@ -132,16 +133,17 @@ class SC_SYSTEM_CORE_API DatabaseReader : public DatabaseArchive {
* over to the caller. If no object has been found, NULL
* is returned.
*/
PublicObject* loadObject(const Seiscomp::Core::RTTI& classType,
PublicObject *loadObject(const Seiscomp::Core::RTTI& classType,
const std::string& publicID);
EventParameters* loadEventParameters();
EventParameters *loadEventParameters();
int load(EventParameters*);
int loadPicks(EventParameters*);
int loadAmplitudes(EventParameters*);
int loadReadings(EventParameters*);
int loadOrigins(EventParameters*);
int loadFocalMechanisms(EventParameters*);
int loadCatalogs(EventParameters*);
int loadEvents(EventParameters*);
int load(Pick*);
int loadComments(Pick*);
@ -171,13 +173,16 @@ class SC_SYSTEM_CORE_API DatabaseReader : public DatabaseArchive {
int loadMomentTensorStationContributions(MomentTensor*);
int load(MomentTensorStationContribution*);
int loadMomentTensorComponentContributions(MomentTensorStationContribution*);
int load(Catalog*);
int loadComments(Catalog*);
int loadEvents(Catalog*);
int load(Event*);
int loadEventDescriptions(Event*);
int loadComments(Event*);
int loadOriginReferences(Event*);
int loadFocalMechanismReferences(Event*);
Config* loadConfig();
Config *loadConfig();
int load(Config*);
int loadParameterSets(Config*);
int loadConfigModules(Config*);
@ -190,14 +195,14 @@ class SC_SYSTEM_CORE_API DatabaseReader : public DatabaseArchive {
int loadConfigStations(ConfigModule*);
int load(ConfigStation*);
int loadSetups(ConfigStation*);
QualityControl* loadQualityControl();
QualityControl *loadQualityControl();
int load(QualityControl*);
int loadQCLogs(QualityControl*);
int loadWaveformQualitys(QualityControl*);
int loadOutages(QualityControl*);
Inventory* loadInventory();
Inventory *loadInventory();
int load(Inventory*);
int loadStationGroups(Inventory*);
int loadAuxDevices(Inventory*);
@ -230,34 +235,33 @@ class SC_SYSTEM_CORE_API DatabaseReader : public DatabaseArchive {
int loadStreams(SensorLocation*);
int load(Stream*);
int loadComments(Stream*);
Routing* loadRouting();
Routing *loadRouting();
int load(Routing*);
int loadRoutes(Routing*);
int loadAccesss(Routing*);
int load(Route*);
int loadRouteArclinks(Route*);
int loadRouteSeedlinks(Route*);
Journaling* loadJournaling();
Journaling *loadJournaling();
int load(Journaling*);
int loadJournalEntrys(Journaling*);
ArclinkLog* loadArclinkLog();
ArclinkLog *loadArclinkLog();
int load(ArclinkLog*);
int loadArclinkRequests(ArclinkLog*);
int loadArclinkUsers(ArclinkLog*);
int load(ArclinkRequest*);
int loadArclinkStatusLines(ArclinkRequest*);
int loadArclinkRequestLines(ArclinkRequest*);
DataAvailability* loadDataAvailability();
DataAvailability *loadDataAvailability();
int load(DataAvailability*);
int loadDataExtents(DataAvailability*);
int load(DataExtent*);
int loadDataSegments(DataExtent*);
int loadDataAttributeExtents(DataExtent*);
};
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

46
include/seiscomp/datamodel/dataextent.h
View File

@ -86,28 +86,28 @@ class SC_SYSTEM_CORE_API DataExtent : public PublicObject {
public:
//! Copy constructor
DataExtent(const DataExtent& other);
DataExtent(const DataExtent &other);
//! Constructor with publicID
DataExtent(const std::string& publicID);
//! Destructor
~DataExtent() override;
// ------------------------------------------------------------------
// Creators
// ------------------------------------------------------------------
public:
static DataExtent* Create();
static DataExtent* Create(const std::string& publicID);
static DataExtent *Create();
static DataExtent *Create(const std::string& publicID);
// ------------------------------------------------------------------
// Lookup
// ------------------------------------------------------------------
public:
static DataExtent* Find(const std::string& publicID);
static DataExtent *Find(const std::string& publicID);
// ------------------------------------------------------------------
@ -116,14 +116,14 @@ class SC_SYSTEM_CORE_API DataExtent : public PublicObject {
public:
//! Copies the metadata of other to this
//! No changes regarding child objects are made
DataExtent& operator=(const DataExtent& other);
DataExtent &operator=(const DataExtent &other);
//! Checks for equality of two objects. Child objects
//! are not part of the check.
bool operator==(const DataExtent& other) const;
bool operator!=(const DataExtent& other) const;
bool operator==(const DataExtent &other) const;
bool operator!=(const DataExtent &other) const;
//! Wrapper that calls operator==
bool equal(const DataExtent& other) const;
bool equal(const DataExtent &other) const;
// ------------------------------------------------------------------
@ -160,12 +160,12 @@ class SC_SYSTEM_CORE_API DataExtent : public PublicObject {
// ------------------------------------------------------------------
public:
//! Returns the object's index
const DataExtentIndex& index() const;
const DataExtentIndex &index() const;
//! Checks two objects for equality regarding their index
bool equalIndex(const DataExtent* lhs) const;
bool equalIndex(const DataExtent *lhs) const;
// ------------------------------------------------------------------
// Public interface
// ------------------------------------------------------------------
@ -178,8 +178,8 @@ class SC_SYSTEM_CORE_API DataExtent : public PublicObject {
* because it already exists in the list
* or it already has another parent
*/
bool add(DataSegment* obj);
bool add(DataAttributeExtent* obj);
bool add(DataSegment *obj);
bool add(DataAttributeExtent *obj);
/**
* Removes an object.
@ -188,8 +188,8 @@ class SC_SYSTEM_CORE_API DataExtent : public PublicObject {
* @return false The object has not been removed
* because it does not exist in the list
*/
bool remove(DataSegment* obj);
bool remove(DataAttributeExtent* obj);
bool remove(DataSegment *obj);
bool remove(DataAttributeExtent *obj);
/**
* Removes an object of a particular class.
@ -198,9 +198,9 @@ class SC_SYSTEM_CORE_API DataExtent : public PublicObject {
* @return false The index is out of bounds
*/
bool removeDataSegment(size_t i);
bool removeDataSegment(const DataSegmentIndex& i);
bool removeDataSegment(const DataSegmentIndex &i);
bool removeDataAttributeExtent(size_t i);
bool removeDataAttributeExtent(const DataAttributeExtentIndex& i);
bool removeDataAttributeExtent(const DataAttributeExtentIndex &i);
//! Retrieve the number of objects of a particular class
size_t dataSegmentCount() const;
@ -208,15 +208,15 @@ class SC_SYSTEM_CORE_API DataExtent : public PublicObject {
//! Index access
//! @return The object at index i
DataSegment* dataSegment(size_t i) const;
DataSegment* dataSegment(const DataSegmentIndex& i) const;
DataSegment *dataSegment(size_t i) const;
DataSegment *dataSegment(const DataSegmentIndex &i) const;
DataAttributeExtent* dataAttributeExtent(size_t i) const;
DataAttributeExtent* dataAttributeExtent(const DataAttributeExtentIndex& i) const;
DataAttributeExtent *dataAttributeExtent(size_t i) const;
DataAttributeExtent *dataAttributeExtent(const DataAttributeExtentIndex &i) const;
//! Find an object by its unique attribute(s)
DataAvailability* dataAvailability() const;
DataAvailability *dataAvailability() const;
//! Implement Object interface
bool assign(Object *other) override;

46
include/seiscomp/datamodel/datalogger.h
View File

@ -89,28 +89,28 @@ class SC_SYSTEM_CORE_API Datalogger : public PublicObject {
public:
//! Copy constructor
Datalogger(const Datalogger& other);
Datalogger(const Datalogger &other);
//! Constructor with publicID
Datalogger(const std::string& publicID);
//! Destructor
~Datalogger() override;
// ------------------------------------------------------------------
// Creators
// ------------------------------------------------------------------
public:
static Datalogger* Create();
static Datalogger* Create(const std::string& publicID);
static Datalogger *Create();
static Datalogger *Create(const std::string& publicID);
// ------------------------------------------------------------------
// Lookup
// ------------------------------------------------------------------
public:
static Datalogger* Find(const std::string& publicID);
static Datalogger *Find(const std::string& publicID);
// ------------------------------------------------------------------
@ -119,14 +119,14 @@ class SC_SYSTEM_CORE_API Datalogger : public PublicObject {
public:
//! Copies the metadata of other to this
//! No changes regarding child objects are made
Datalogger& operator=(const Datalogger& other);
Datalogger &operator=(const Datalogger &other);
//! Checks for equality of two objects. Child objects
//! are not part of the check.
bool operator==(const Datalogger& other) const;
bool operator!=(const Datalogger& other) const;
bool operator==(const Datalogger &other) const;
bool operator!=(const Datalogger &other) const;
//! Wrapper that calls operator==
bool equal(const Datalogger& other) const;
bool equal(const Datalogger &other) const;
// ------------------------------------------------------------------
@ -188,12 +188,12 @@ class SC_SYSTEM_CORE_API Datalogger : public PublicObject {
// ------------------------------------------------------------------
public:
//! Returns the object's index
const DataloggerIndex& index() const;
const DataloggerIndex &index() const;
//! Checks two objects for equality regarding their index
bool equalIndex(const Datalogger* lhs) const;
bool equalIndex(const Datalogger *lhs) const;
// ------------------------------------------------------------------
// Public interface
// ------------------------------------------------------------------
@ -206,8 +206,8 @@ class SC_SYSTEM_CORE_API Datalogger : public PublicObject {
* because it already exists in the list
* or it already has another parent
*/
bool add(DataloggerCalibration* obj);
bool add(Decimation* obj);
bool add(DataloggerCalibration *obj);
bool add(Decimation *obj);
/**
* Removes an object.
@ -216,8 +216,8 @@ class SC_SYSTEM_CORE_API Datalogger : public PublicObject {
* @return false The object has not been removed
* because it does not exist in the list
*/
bool remove(DataloggerCalibration* obj);
bool remove(Decimation* obj);
bool remove(DataloggerCalibration *obj);
bool remove(Decimation *obj);
/**
* Removes an object of a particular class.
@ -226,9 +226,9 @@ class SC_SYSTEM_CORE_API Datalogger : public PublicObject {
* @return false The index is out of bounds
*/
bool removeDataloggerCalibration(size_t i);
bool removeDataloggerCalibration(const DataloggerCalibrationIndex& i);
bool removeDataloggerCalibration(const DataloggerCalibrationIndex &i);
bool removeDecimation(size_t i);
bool removeDecimation(const DecimationIndex& i);
bool removeDecimation(const DecimationIndex &i);
//! Retrieve the number of objects of a particular class
size_t dataloggerCalibrationCount() const;
@ -236,15 +236,15 @@ class SC_SYSTEM_CORE_API Datalogger : public PublicObject {
//! Index access
//! @return The object at index i
DataloggerCalibration* dataloggerCalibration(size_t i) const;
DataloggerCalibration* dataloggerCalibration(const DataloggerCalibrationIndex& i) const;
DataloggerCalibration *dataloggerCalibration(size_t i) const;
DataloggerCalibration *dataloggerCalibration(const DataloggerCalibrationIndex &i) const;
Decimation* decimation(size_t i) const;
Decimation* decimation(const DecimationIndex& i) const;
Decimation *decimation(size_t i) const;
Decimation *decimation(const DecimationIndex &i) const;
//! Find an object by its unique attribute(s)
Inventory* inventory() const;
Inventory *inventory() const;
//! Implement Object interface
bool assign(Object *other) override;

20
include/seiscomp/datamodel/dataloggercalibration.h
View File

@ -87,25 +87,25 @@ class SC_SYSTEM_CORE_API DataloggerCalibration : public Object {
DataloggerCalibration();
//! Copy constructor
DataloggerCalibration(const DataloggerCalibration& other);
DataloggerCalibration(const DataloggerCalibration &other);
//! Destructor
~DataloggerCalibration() override;
// ------------------------------------------------------------------
// Operators
// ------------------------------------------------------------------
public:
//! Copies the metadata of other to this
DataloggerCalibration& operator=(const DataloggerCalibration& other);
DataloggerCalibration &operator=(const DataloggerCalibration &other);
//! Checks for equality of two objects. Child objects
//! are not part of the check.
bool operator==(const DataloggerCalibration& other) const;
bool operator!=(const DataloggerCalibration& other) const;
bool operator==(const DataloggerCalibration &other) const;
bool operator!=(const DataloggerCalibration &other) const;
//! Wrapper that calls operator==
bool equal(const DataloggerCalibration& other) const;
bool equal(const DataloggerCalibration &other) const;
// ------------------------------------------------------------------
@ -147,17 +147,17 @@ class SC_SYSTEM_CORE_API DataloggerCalibration : public Object {
// ------------------------------------------------------------------
public:
//! Returns the object's index
const DataloggerCalibrationIndex& index() const;
const DataloggerCalibrationIndex &index() const;
//! Checks two objects for equality regarding their index
bool equalIndex(const DataloggerCalibration* lhs) const;
bool equalIndex(const DataloggerCalibration *lhs) const;
// ------------------------------------------------------------------
// Public interface
// ------------------------------------------------------------------
public:
Datalogger* datalogger() const;
Datalogger *datalogger() const;
//! Implement Object interface
bool assign(Object *other) override;

20
include/seiscomp/datamodel/datasegment.h
View File

@ -79,25 +79,25 @@ class SC_SYSTEM_CORE_API DataSegment : public Object {
DataSegment();
//! Copy constructor
DataSegment(const DataSegment& other);
DataSegment(const DataSegment &other);
//! Destructor
~DataSegment() override;
// ------------------------------------------------------------------
// Operators
// ------------------------------------------------------------------
public:
//! Copies the metadata of other to this
DataSegment& operator=(const DataSegment& other);
DataSegment &operator=(const DataSegment &other);
//! Checks for equality of two objects. Child objects
//! are not part of the check.
bool operator==(const DataSegment& other) const;
bool operator!=(const DataSegment& other) const;
bool operator==(const DataSegment &other) const;
bool operator!=(const DataSegment &other) const;
//! Wrapper that calls operator==
bool equal(const DataSegment& other) const;
bool equal(const DataSegment &other) const;
// ------------------------------------------------------------------
@ -135,17 +135,17 @@ class SC_SYSTEM_CORE_API DataSegment : public Object {
// ------------------------------------------------------------------
public:
//! Returns the object's index
const DataSegmentIndex& index() const;
const DataSegmentIndex &index() const;
//! Checks two objects for equality regarding their index
bool equalIndex(const DataSegment* lhs) const;
bool equalIndex(const DataSegment *lhs) const;
// ------------------------------------------------------------------
// Public interface
// ------------------------------------------------------------------
public:
DataExtent* dataExtent() const;
DataExtent *dataExtent() const;
//! Implement Object interface
bool assign(Object *other) override;

16
include/seiscomp/datamodel/dataused.h
View File

@ -54,25 +54,25 @@ class SC_SYSTEM_CORE_API DataUsed : public Object {
DataUsed();
//! Copy constructor
DataUsed(const DataUsed& other);
DataUsed(const DataUsed &other);
//! Destructor
~DataUsed() override;
// ------------------------------------------------------------------
// Operators
// ------------------------------------------------------------------
public:
//! Copies the metadata of other to this
DataUsed& operator=(const DataUsed& other);
DataUsed &operator=(const DataUsed &other);
//! Checks for equality of two objects. Child objects
//! are not part of the check.
bool operator==(const DataUsed& other) const;
bool operator!=(const DataUsed& other) const;
bool operator==(const DataUsed &other) const;
bool operator!=(const DataUsed &other) const;
//! Wrapper that calls operator==
bool equal(const DataUsed& other) const;
bool equal(const DataUsed &other) const;
// ------------------------------------------------------------------
@ -96,12 +96,12 @@ class SC_SYSTEM_CORE_API DataUsed : public Object {
void setShortestPeriod(const OPT(double)& shortestPeriod);
double shortestPeriod() const;
// ------------------------------------------------------------------
// Public interface
// ------------------------------------------------------------------
public:
MomentTensor* momentTensor() const;
MomentTensor *momentTensor() const;
//! Implement Object interface
bool assign(Object *other) override;

20
include/seiscomp/datamodel/decimation.h
View File

@ -83,25 +83,25 @@ class SC_SYSTEM_CORE_API Decimation : public Object {
Decimation();
//! Copy constructor
Decimation(const Decimation& other);
Decimation(const Decimation &other);
//! Destructor
~Decimation() override;
// ------------------------------------------------------------------
// Operators
// ------------------------------------------------------------------
public:
//! Copies the metadata of other to this
Decimation& operator=(const Decimation& other);
Decimation &operator=(const Decimation &other);
//! Checks for equality of two objects. Child objects
//! are not part of the check.
bool operator==(const Decimation& other) const;
bool operator!=(const Decimation& other) const;
bool operator==(const Decimation &other) const;
bool operator!=(const Decimation &other) const;
//! Wrapper that calls operator==
bool equal(const Decimation& other) const;
bool equal(const Decimation &other) const;
// ------------------------------------------------------------------
@ -138,17 +138,17 @@ class SC_SYSTEM_CORE_API Decimation : public Object {
// ------------------------------------------------------------------
public:
//! Returns the object's index
const DecimationIndex& index() const;
const DecimationIndex &index() const;
//! Checks two objects for equality regarding their index
bool equalIndex(const Decimation* lhs) const;
bool equalIndex(const Decimation *lhs) const;
// ------------------------------------------------------------------
// Public interface
// ------------------------------------------------------------------
public:
Datalogger* datalogger() const;
Datalogger *datalogger() const;
//! Implement Object interface
bool assign(Object *other) override;

69
include/seiscomp/datamodel/event.h
View File

@ -45,6 +45,7 @@ DEFINE_SMARTPOINTER(Comment);
DEFINE_SMARTPOINTER(OriginReference);
DEFINE_SMARTPOINTER(FocalMechanismReference);
class Catalog;
class EventParameters;
@ -79,28 +80,28 @@ class SC_SYSTEM_CORE_API Event : public PublicObject {
public:
//! Copy constructor
Event(const Event& other);
Event(const Event &other);
//! Constructor with publicID
Event(const std::string& publicID);
//! Destructor
~Event() override;
// ------------------------------------------------------------------
// Creators
// ------------------------------------------------------------------
public:
static Event* Create();
static Event* Create(const std::string& publicID);
static Event *Create();
static Event *Create(const std::string& publicID);
// ------------------------------------------------------------------
// Lookup
// ------------------------------------------------------------------
public:
static Event* Find(const std::string& publicID);
static Event *Find(const std::string& publicID);
// ------------------------------------------------------------------
@ -109,14 +110,14 @@ class SC_SYSTEM_CORE_API Event : public PublicObject {
public:
//! Copies the metadata of other to this
//! No changes regarding child objects are made
Event& operator=(const Event& other);
Event &operator=(const Event &other);
//! Checks for equality of two objects. Child objects
//! are not part of the check.
bool operator==(const Event& other) const;
bool operator!=(const Event& other) const;
bool operator==(const Event &other) const;
bool operator!=(const Event &other) const;
//! Wrapper that calls operator==
bool equal(const Event& other) const;
bool equal(const Event &other) const;
// ------------------------------------------------------------------
@ -150,7 +151,7 @@ class SC_SYSTEM_CORE_API Event : public PublicObject {
CreationInfo& creationInfo();
const CreationInfo& creationInfo() const;
// ------------------------------------------------------------------
// Public interface
// ------------------------------------------------------------------
@ -163,10 +164,10 @@ class SC_SYSTEM_CORE_API Event : public PublicObject {
* because it already exists in the list
* or it already has another parent
*/
bool add(EventDescription* obj);
bool add(Comment* obj);
bool add(OriginReference* obj);
bool add(FocalMechanismReference* obj);
bool add(EventDescription *obj);
bool add(Comment *obj);
bool add(OriginReference *obj);
bool add(FocalMechanismReference *obj);
/**
* Removes an object.
@ -175,10 +176,10 @@ class SC_SYSTEM_CORE_API Event : public PublicObject {
* @return false The object has not been removed
* because it does not exist in the list
*/
bool remove(EventDescription* obj);
bool remove(Comment* obj);
bool remove(OriginReference* obj);
bool remove(FocalMechanismReference* obj);
bool remove(EventDescription *obj);
bool remove(Comment *obj);
bool remove(OriginReference *obj);
bool remove(FocalMechanismReference *obj);
/**
* Removes an object of a particular class.
@ -187,13 +188,13 @@ class SC_SYSTEM_CORE_API Event : public PublicObject {
* @return false The index is out of bounds
*/
bool removeEventDescription(size_t i);
bool removeEventDescription(const EventDescriptionIndex& i);
bool removeEventDescription(const EventDescriptionIndex &i);
bool removeComment(size_t i);
bool removeComment(const CommentIndex& i);
bool removeComment(const CommentIndex &i);
bool removeOriginReference(size_t i);
bool removeOriginReference(const OriginReferenceIndex& i);
bool removeOriginReference(const OriginReferenceIndex &i);
bool removeFocalMechanismReference(size_t i);
bool removeFocalMechanismReference(const FocalMechanismReferenceIndex& i);
bool removeFocalMechanismReference(const FocalMechanismReferenceIndex &i);
//! Retrieve the number of objects of a particular class
size_t eventDescriptionCount() const;
@ -203,21 +204,27 @@ class SC_SYSTEM_CORE_API Event : public PublicObject {
//! Index access
//! @return The object at index i
EventDescription* eventDescription(size_t i) const;
EventDescription* eventDescription(const EventDescriptionIndex& i) const;
EventDescription *eventDescription(size_t i) const;
EventDescription *eventDescription(const EventDescriptionIndex &i) const;
Comment* comment(size_t i) const;
Comment* comment(const CommentIndex& i) const;
Comment *comment(size_t i) const;
Comment *comment(const CommentIndex &i) const;
OriginReference* originReference(size_t i) const;
OriginReference* originReference(const OriginReferenceIndex& i) const;
OriginReference *originReference(size_t i) const;
OriginReference *originReference(const OriginReferenceIndex &i) const;
FocalMechanismReference* focalMechanismReference(size_t i) const;
FocalMechanismReference* focalMechanismReference(const FocalMechanismReferenceIndex& i) const;
FocalMechanismReference *focalMechanismReference(size_t i) const;
FocalMechanismReference *focalMechanismReference(const FocalMechanismReferenceIndex &i) const;
//! Find an object by its unique attribute(s)
EventParameters* eventParameters() const;
/**
* The following methods return the parent object by type.
* Because different parent types are possible, just one
* of these methods will return a valid pointer at a time.
*/
Catalog *catalog() const;
EventParameters *eventParameters() const;
//! Implement Object interface
bool assign(Object *other) override;

20
include/seiscomp/datamodel/eventdescription.h
View File

@ -86,7 +86,7 @@ class SC_SYSTEM_CORE_API EventDescription : public Object {
EventDescription();
//! Copy constructor
EventDescription(const EventDescription& other);
EventDescription(const EventDescription &other);
//! Custom constructor
EventDescription(const std::string& text);
@ -95,21 +95,21 @@ class SC_SYSTEM_CORE_API EventDescription : public Object {
//! Destructor
~EventDescription() override;
// ------------------------------------------------------------------
// Operators
// ------------------------------------------------------------------
public:
//! Copies the metadata of other to this
EventDescription& operator=(const EventDescription& other);
EventDescription &operator=(const EventDescription &other);
//! Checks for equality of two objects. Child objects
//! are not part of the check.
bool operator==(const EventDescription& other) const;
bool operator!=(const EventDescription& other) const;
bool operator==(const EventDescription &other) const;
bool operator!=(const EventDescription &other) const;
//! Wrapper that calls operator==
bool equal(const EventDescription& other) const;
bool equal(const EventDescription &other) const;
// ------------------------------------------------------------------
@ -130,17 +130,17 @@ class SC_SYSTEM_CORE_API EventDescription : public Object {
// ------------------------------------------------------------------
public:
//! Returns the object's index
const EventDescriptionIndex& index() const;
const EventDescriptionIndex &index() const;
//! Checks two objects for equality regarding their index
bool equalIndex(const EventDescription* lhs) const;
bool equalIndex(const EventDescription *lhs) const;
// ------------------------------------------------------------------
// Public interface
// ------------------------------------------------------------------
public:
Event* event() const;
Event *event() const;
//! Implement Object interface
bool assign(Object *other) override;

70
include/seiscomp/datamodel/eventparameters.h
View File

@ -38,6 +38,7 @@ DEFINE_SMARTPOINTER(Amplitude);
DEFINE_SMARTPOINTER(Reading);
DEFINE_SMARTPOINTER(Origin);
DEFINE_SMARTPOINTER(FocalMechanism);
DEFINE_SMARTPOINTER(Catalog);
DEFINE_SMARTPOINTER(Event);
@ -59,11 +60,11 @@ class SC_SYSTEM_CORE_API EventParameters : public PublicObject {
EventParameters();
//! Copy constructor
EventParameters(const EventParameters& other);
EventParameters(const EventParameters &other);
//! Destructor
~EventParameters() override;
// ------------------------------------------------------------------
// Operators
@ -71,16 +72,16 @@ class SC_SYSTEM_CORE_API EventParameters : public PublicObject {
public:
//! Copies the metadata of other to this
//! No changes regarding child objects are made
EventParameters& operator=(const EventParameters& other);
EventParameters &operator=(const EventParameters &other);
//! Checks for equality of two objects. Child objects
//! are not part of the check.
bool operator==(const EventParameters& other) const;
bool operator!=(const EventParameters& other) const;
bool operator==(const EventParameters &other) const;
bool operator!=(const EventParameters &other) const;
//! Wrapper that calls operator==
bool equal(const EventParameters& other) const;
bool equal(const EventParameters &other) const;
// ------------------------------------------------------------------
// Public interface
// ------------------------------------------------------------------
@ -93,12 +94,13 @@ class SC_SYSTEM_CORE_API EventParameters : public PublicObject {
* because it already exists in the list
* or it already has another parent
*/
bool add(Pick* obj);
bool add(Amplitude* obj);
bool add(Reading* obj);
bool add(Origin* obj);
bool add(FocalMechanism* obj);
bool add(Event* obj);
bool add(Pick *obj);
bool add(Amplitude *obj);
bool add(Reading *obj);
bool add(Origin *obj);
bool add(FocalMechanism *obj);
bool add(Catalog *obj);
bool add(Event *obj);
/**
* Removes an object.
@ -107,12 +109,13 @@ class SC_SYSTEM_CORE_API EventParameters : public PublicObject {
* @return false The object has not been removed
* because it does not exist in the list
*/
bool remove(Pick* obj);
bool remove(Amplitude* obj);
bool remove(Reading* obj);
bool remove(Origin* obj);
bool remove(FocalMechanism* obj);
bool remove(Event* obj);
bool remove(Pick *obj);
bool remove(Amplitude *obj);
bool remove(Reading *obj);
bool remove(Origin *obj);
bool remove(FocalMechanism *obj);
bool remove(Catalog *obj);
bool remove(Event *obj);
/**
* Removes an object of a particular class.
@ -125,6 +128,7 @@ class SC_SYSTEM_CORE_API EventParameters : public PublicObject {
bool removeReading(size_t i);
bool removeOrigin(size_t i);
bool removeFocalMechanism(size_t i);
bool removeCatalog(size_t i);
bool removeEvent(size_t i);
//! Retrieve the number of objects of a particular class
@ -133,24 +137,27 @@ class SC_SYSTEM_CORE_API EventParameters : public PublicObject {
size_t readingCount() const;
size_t originCount() const;
size_t focalMechanismCount() const;
size_t catalogCount() const;
size_t eventCount() const;
//! Index access
//! @return The object at index i
Pick* pick(size_t i) const;
Amplitude* amplitude(size_t i) const;
Reading* reading(size_t i) const;
Origin* origin(size_t i) const;
FocalMechanism* focalMechanism(size_t i) const;
Event* event(size_t i) const;
Pick *pick(size_t i) const;
Amplitude *amplitude(size_t i) const;
Reading *reading(size_t i) const;
Origin *origin(size_t i) const;
FocalMechanism *focalMechanism(size_t i) const;
Catalog *catalog(size_t i) const;
Event *event(size_t i) const;
//! Find an object by its unique attribute(s)
Pick* findPick(const std::string& publicID) const;
Amplitude* findAmplitude(const std::string& publicID) const;
Reading* findReading(const std::string& publicID) const;
Origin* findOrigin(const std::string& publicID) const;
FocalMechanism* findFocalMechanism(const std::string& publicID) const;
Event* findEvent(const std::string& publicID) const;
Pick *findPick(const std::string& publicID) const;
Amplitude *findAmplitude(const std::string& publicID) const;
Reading *findReading(const std::string& publicID) const;
Origin *findOrigin(const std::string& publicID) const;
FocalMechanism *findFocalMechanism(const std::string& publicID) const;
Catalog *findCatalog(const std::string& publicID) const;
Event *findEvent(const std::string& publicID) const;
//! Implement Object interface
bool assign(Object *other) override;
@ -177,6 +184,7 @@ class SC_SYSTEM_CORE_API EventParameters : public PublicObject {
std::vector<ReadingPtr> _readings;
std::vector<OriginPtr> _origins;
std::vector<FocalMechanismPtr> _focalMechanisms;
std::vector<CatalogPtr> _catalogs;
std::vector<EventPtr> _events;
DECLARE_SC_CLASSFACTORY_FRIEND(EventParameters);

2
include/seiscomp/datamodel/eventparameters_package.h
View File

@ -23,6 +23,7 @@
#include <seiscomp/datamodel/eventdescription.h>
#include <seiscomp/datamodel/comment.h>
#include <seiscomp/datamodel/dataused.h>
#include <seiscomp/datamodel/compositetime.h>
#include <seiscomp/datamodel/pickreference.h>
@ -41,6 +42,7 @@
#include <seiscomp/datamodel/originreference.h>
#include <seiscomp/datamodel/focalmechanismreference.h>
#include <seiscomp/datamodel/event.h>
#include <seiscomp/datamodel/catalog.h>
#include <seiscomp/datamodel/arrival.h>
#include <seiscomp/datamodel/origin.h>
#include <seiscomp/datamodel/eventparameters.h>

8
include/seiscomp/datamodel/exchange/binary.h
View File

@ -77,8 +77,8 @@ class ExporterBinary : public IO::XML::Exporter {
// Exporter interface
// ------------------------------------------------------------------
protected:
bool put(std::streambuf* buf, Core::BaseObject *);
bool put(std::streambuf* buf, const IO::ExportObjectList &objects);
bool put(std::streambuf* buf, Core::BaseObject *) override;
bool put(std::streambuf* buf, const IO::ExportObjectList &objects) override;
};
@ -95,8 +95,8 @@ class ExporterVBinary : public IO::XML::Exporter {
// Exporter interface
// ------------------------------------------------------------------
protected:
bool put(std::streambuf* buf, Core::BaseObject *);
bool put(std::streambuf* buf, const IO::ExportObjectList &objects);
bool put(std::streambuf* buf, Core::BaseObject *) override;
bool put(std::streambuf* buf, const IO::ExportObjectList &objects) override;
};

6
include/seiscomp/datamodel/exchange/bson.h
View File

@ -43,7 +43,7 @@ class ImporterBSON : public IO::Importer {
// Importer interface
// ------------------------------------------------------------------
protected:
Core::BaseObject *get(std::streambuf* buf);
Core::BaseObject *get(std::streambuf* buf) override;
};
@ -60,7 +60,7 @@ class ExporterBSON : public IO::Exporter {
// Exporter interface
// ------------------------------------------------------------------
protected:
bool put(std::streambuf* buf, Core::BaseObject *);
bool put(std::streambuf* buf, Core::BaseObject *) override;
};
@ -77,7 +77,7 @@ class ExporterBSONJSON : public IO::Exporter {
// Exporter interface
// ------------------------------------------------------------------
protected:
bool put(std::streambuf* buf, Core::BaseObject *);
bool put(std::streambuf* buf, Core::BaseObject *) override;
};

2
include/seiscomp/datamodel/exchange/csv.h
View File

@ -45,7 +45,7 @@ class ExporterCSV : public IO::Exporter {
// Exporter interface
// ------------------------------------------------------------------
protected:
bool put(std::streambuf* buf, Core::BaseObject *);
bool put(std::streambuf* buf, Core::BaseObject *) override;
private:
std::string _delim;

2
include/seiscomp/datamodel/exchange/hyp71sum2k.h
View File

@ -42,7 +42,7 @@ class ExporterHYP71SUM2K : public IO::Exporter {
// Exporter interface
// ------------------------------------------------------------------
protected:
bool put(std::streambuf* buf, Core::BaseObject *);
bool put(std::streambuf* buf, Core::BaseObject *) override;
};

2
include/seiscomp/datamodel/exchange/ims10.h
View File

@ -46,7 +46,7 @@ class ExporterIMS10 : public IO::Exporter {
// Exporter interface
// ------------------------------------------------------------------
protected:
bool put(std::streambuf* buf, Core::BaseObject *);
bool put(std::streambuf* buf, Core::BaseObject *) override;
private:
// ------------------------------------------------------------------
// Members

4
include/seiscomp/datamodel/exchange/json.h
View File

@ -43,7 +43,7 @@ class ImporterJSON : public IO::Importer {
// Importer interface
// ------------------------------------------------------------------
protected:
Core::BaseObject *get(std::streambuf* buf);
Core::BaseObject *get(std::streambuf* buf) override;
};
@ -60,7 +60,7 @@ class ExporterJSON : public IO::Exporter {
// Exporter interface
// ------------------------------------------------------------------
protected:
bool put(std::streambuf* buf, Core::BaseObject *);
bool put(std::streambuf* buf, Core::BaseObject *) override;
};

6
include/seiscomp/datamodel/exchange/trunk.h
View File

@ -43,7 +43,7 @@ class ImporterTrunk : public IO::Importer {
// Importer interface
// ------------------------------------------------------------------
protected:
Core::BaseObject *get(std::streambuf* buf);
Core::BaseObject *get(std::streambuf* buf) override;
};
@ -60,8 +60,8 @@ class ExporterTrunk : public IO::Exporter {
// Exporter interface
// ------------------------------------------------------------------
protected:
bool put(std::streambuf* buf, Core::BaseObject *);
bool put(std::streambuf* buf, const IO::ExportObjectList &objects);
bool put(std::streambuf* buf, Core::BaseObject *) override;
bool put(std::streambuf* buf, const IO::ExportObjectList &objects) override;
};

40
include/seiscomp/datamodel/focalmechanism.h
View File

@ -69,28 +69,28 @@ class SC_SYSTEM_CORE_API FocalMechanism : public PublicObject {
public:
//! Copy constructor
FocalMechanism(const FocalMechanism& other);
FocalMechanism(const FocalMechanism &other);
//! Constructor with publicID
FocalMechanism(const std::string& publicID);
//! Destructor
~FocalMechanism() override;
// ------------------------------------------------------------------
// Creators
// ------------------------------------------------------------------
public:
static FocalMechanism* Create();
static FocalMechanism* Create(const std::string& publicID);
static FocalMechanism *Create();
static FocalMechanism *Create(const std::string& publicID);
// ------------------------------------------------------------------
// Lookup
// ------------------------------------------------------------------
public:
static FocalMechanism* Find(const std::string& publicID);
static FocalMechanism *Find(const std::string& publicID);
// ------------------------------------------------------------------
@ -99,14 +99,14 @@ class SC_SYSTEM_CORE_API FocalMechanism : public PublicObject {
public:
//! Copies the metadata of other to this
//! No changes regarding child objects are made
FocalMechanism& operator=(const FocalMechanism& other);
FocalMechanism &operator=(const FocalMechanism &other);
//! Checks for equality of two objects. Child objects
//! are not part of the check.
bool operator==(const FocalMechanism& other) const;
bool operator!=(const FocalMechanism& other) const;
bool operator==(const FocalMechanism &other) const;
bool operator!=(const FocalMechanism &other) const;
//! Wrapper that calls operator==
bool equal(const FocalMechanism& other) const;
bool equal(const FocalMechanism &other) const;
// ------------------------------------------------------------------
@ -169,7 +169,7 @@ class SC_SYSTEM_CORE_API FocalMechanism : public PublicObject {
CreationInfo& creationInfo();
const CreationInfo& creationInfo() const;
// ------------------------------------------------------------------
// Public interface
// ------------------------------------------------------------------
@ -182,8 +182,8 @@ class SC_SYSTEM_CORE_API FocalMechanism : public PublicObject {
* because it already exists in the list
* or it already has another parent
*/
bool add(Comment* obj);
bool add(MomentTensor* obj);
bool add(Comment *obj);
bool add(MomentTensor *obj);
/**
* Removes an object.
@ -192,8 +192,8 @@ class SC_SYSTEM_CORE_API FocalMechanism : public PublicObject {
* @return false The object has not been removed
* because it does not exist in the list
*/
bool remove(Comment* obj);
bool remove(MomentTensor* obj);
bool remove(Comment *obj);
bool remove(MomentTensor *obj);
/**
* Removes an object of a particular class.
@ -202,7 +202,7 @@ class SC_SYSTEM_CORE_API FocalMechanism : public PublicObject {
* @return false The index is out of bounds
*/
bool removeComment(size_t i);
bool removeComment(const CommentIndex& i);
bool removeComment(const CommentIndex &i);
bool removeMomentTensor(size_t i);
//! Retrieve the number of objects of a particular class
@ -211,14 +211,14 @@ class SC_SYSTEM_CORE_API FocalMechanism : public PublicObject {
//! Index access
//! @return The object at index i
Comment* comment(size_t i) const;
Comment* comment(const CommentIndex& i) const;
MomentTensor* momentTensor(size_t i) const;
Comment *comment(size_t i) const;
Comment *comment(const CommentIndex &i) const;
MomentTensor *momentTensor(size_t i) const;
//! Find an object by its unique attribute(s)
MomentTensor* findMomentTensor(const std::string& publicID) const;
MomentTensor *findMomentTensor(const std::string& publicID) const;
EventParameters* eventParameters() const;
EventParameters *eventParameters() const;
//! Implement Object interface
bool assign(Object *other) override;

20
include/seiscomp/datamodel/focalmechanismreference.h
View File

@ -78,28 +78,28 @@ class SC_SYSTEM_CORE_API FocalMechanismReference : public Object {
FocalMechanismReference();
//! Copy constructor
FocalMechanismReference(const FocalMechanismReference& other);
FocalMechanismReference(const FocalMechanismReference &other);
//! Custom constructor
FocalMechanismReference(const std::string& focalMechanismID);
//! Destructor
~FocalMechanismReference() override;
// ------------------------------------------------------------------
// Operators
// ------------------------------------------------------------------
public:
//! Copies the metadata of other to this
FocalMechanismReference& operator=(const FocalMechanismReference& other);
FocalMechanismReference &operator=(const FocalMechanismReference &other);
//! Checks for equality of two objects. Child objects
//! are not part of the check.
bool operator==(const FocalMechanismReference& other) const;
bool operator!=(const FocalMechanismReference& other) const;
bool operator==(const FocalMechanismReference &other) const;
bool operator!=(const FocalMechanismReference &other) const;
//! Wrapper that calls operator==
bool equal(const FocalMechanismReference& other) const;
bool equal(const FocalMechanismReference &other) const;
// ------------------------------------------------------------------
@ -115,17 +115,17 @@ class SC_SYSTEM_CORE_API FocalMechanismReference : public Object {
// ------------------------------------------------------------------
public:
//! Returns the object's index
const FocalMechanismReferenceIndex& index() const;
const FocalMechanismReferenceIndex &index() const;
//! Checks two objects for equality regarding their index
bool equalIndex(const FocalMechanismReference* lhs) const;
bool equalIndex(const FocalMechanismReference *lhs) const;
// ------------------------------------------------------------------
// Public interface
// ------------------------------------------------------------------
public:
Event* event() const;
Event *event() const;
//! Implement Object interface
bool assign(Object *other) override;

12
include/seiscomp/datamodel/integerquantity.h
View File

@ -66,7 +66,7 @@ class SC_SYSTEM_CORE_API IntegerQuantity : public Core::BaseObject {
IntegerQuantity();
//! Copy constructor
IntegerQuantity(const IntegerQuantity& other);
IntegerQuantity(const IntegerQuantity &other);
//! Custom constructor
IntegerQuantity(int value,
@ -77,7 +77,7 @@ class SC_SYSTEM_CORE_API IntegerQuantity : public Core::BaseObject {
//! Destructor
~IntegerQuantity() override;
// ------------------------------------------------------------------
// Operators
@ -87,14 +87,14 @@ class SC_SYSTEM_CORE_API IntegerQuantity : public Core::BaseObject {
operator int() const;
//! Copies the metadata of other to this
IntegerQuantity& operator=(const IntegerQuantity& other);
IntegerQuantity &operator=(const IntegerQuantity &other);
//! Checks for equality of two objects. Child objects
//! are not part of the check.
bool operator==(const IntegerQuantity& other) const;
bool operator!=(const IntegerQuantity& other) const;
bool operator==(const IntegerQuantity &other) const;
bool operator!=(const IntegerQuantity &other) const;
//! Wrapper that calls operator==
bool equal(const IntegerQuantity& other) const;
bool equal(const IntegerQuantity &other) const;
// ------------------------------------------------------------------

134
include/seiscomp/datamodel/inventory.h
View File

@ -68,11 +68,11 @@ class SC_SYSTEM_CORE_API Inventory : public PublicObject {
Inventory();
//! Copy constructor
Inventory(const Inventory& other);
Inventory(const Inventory &other);
//! Destructor
~Inventory() override;
// ------------------------------------------------------------------
// Operators
@ -80,16 +80,16 @@ class SC_SYSTEM_CORE_API Inventory : public PublicObject {
public:
//! Copies the metadata of other to this
//! No changes regarding child objects are made
Inventory& operator=(const Inventory& other);
Inventory &operator=(const Inventory &other);
//! Checks for equality of two objects. Child objects
//! are not part of the check.
bool operator==(const Inventory& other) const;
bool operator!=(const Inventory& other) const;
bool operator==(const Inventory &other) const;
bool operator!=(const Inventory &other) const;
//! Wrapper that calls operator==
bool equal(const Inventory& other) const;
bool equal(const Inventory &other) const;
// ------------------------------------------------------------------
// Public interface
// ------------------------------------------------------------------
@ -102,16 +102,16 @@ class SC_SYSTEM_CORE_API Inventory : public PublicObject {
* because it already exists in the list
* or it already has another parent
*/
bool add(StationGroup* obj);
bool add(AuxDevice* obj);
bool add(Sensor* obj);
bool add(Datalogger* obj);
bool add(ResponsePAZ* obj);
bool add(ResponseFIR* obj);
bool add(ResponseIIR* obj);
bool add(ResponsePolynomial* obj);
bool add(ResponseFAP* obj);
bool add(Network* obj);
bool add(StationGroup *obj);
bool add(AuxDevice *obj);
bool add(Sensor *obj);
bool add(Datalogger *obj);
bool add(ResponsePAZ *obj);
bool add(ResponseFIR *obj);
bool add(ResponseIIR *obj);
bool add(ResponsePolynomial *obj);
bool add(ResponseFAP *obj);
bool add(Network *obj);
/**
* Removes an object.
@ -120,16 +120,16 @@ class SC_SYSTEM_CORE_API Inventory : public PublicObject {
* @return false The object has not been removed
* because it does not exist in the list
*/
bool remove(StationGroup* obj);
bool remove(AuxDevice* obj);
bool remove(Sensor* obj);
bool remove(Datalogger* obj);
bool remove(ResponsePAZ* obj);
bool remove(ResponseFIR* obj);
bool remove(ResponseIIR* obj);
bool remove(ResponsePolynomial* obj);
bool remove(ResponseFAP* obj);
bool remove(Network* obj);
bool remove(StationGroup *obj);
bool remove(AuxDevice *obj);
bool remove(Sensor *obj);
bool remove(Datalogger *obj);
bool remove(ResponsePAZ *obj);
bool remove(ResponseFIR *obj);
bool remove(ResponseIIR *obj);
bool remove(ResponsePolynomial *obj);
bool remove(ResponseFAP *obj);
bool remove(Network *obj);
/**
* Removes an object of a particular class.
@ -138,25 +138,25 @@ class SC_SYSTEM_CORE_API Inventory : public PublicObject {
* @return false The index is out of bounds
*/
bool removeStationGroup(size_t i);
bool removeStationGroup(const StationGroupIndex& i);
bool removeStationGroup(const StationGroupIndex &i);
bool removeAuxDevice(size_t i);
bool removeAuxDevice(const AuxDeviceIndex& i);
bool removeAuxDevice(const AuxDeviceIndex &i);
bool removeSensor(size_t i);
bool removeSensor(const SensorIndex& i);
bool removeSensor(const SensorIndex &i);
bool removeDatalogger(size_t i);
bool removeDatalogger(const DataloggerIndex& i);
bool removeDatalogger(const DataloggerIndex &i);
bool removeResponsePAZ(size_t i);
bool removeResponsePAZ(const ResponsePAZIndex& i);
bool removeResponsePAZ(const ResponsePAZIndex &i);
bool removeResponseFIR(size_t i);
bool removeResponseFIR(const ResponseFIRIndex& i);
bool removeResponseFIR(const ResponseFIRIndex &i);
bool removeResponseIIR(size_t i);
bool removeResponseIIR(const ResponseIIRIndex& i);
bool removeResponseIIR(const ResponseIIRIndex &i);
bool removeResponsePolynomial(size_t i);
bool removeResponsePolynomial(const ResponsePolynomialIndex& i);
bool removeResponsePolynomial(const ResponsePolynomialIndex &i);
bool removeResponseFAP(size_t i);
bool removeResponseFAP(const ResponseFAPIndex& i);
bool removeResponseFAP(const ResponseFAPIndex &i);
bool removeNetwork(size_t i);
bool removeNetwork(const NetworkIndex& i);
bool removeNetwork(const NetworkIndex &i);
//! Retrieve the number of objects of a particular class
size_t stationGroupCount() const;
@ -172,47 +172,47 @@ class SC_SYSTEM_CORE_API Inventory : public PublicObject {
//! Index access
//! @return The object at index i
StationGroup* stationGroup(size_t i) const;
StationGroup* stationGroup(const StationGroupIndex& i) const;
StationGroup *stationGroup(size_t i) const;
StationGroup *stationGroup(const StationGroupIndex &i) const;
AuxDevice* auxDevice(size_t i) const;
AuxDevice* auxDevice(const AuxDeviceIndex& i) const;
AuxDevice *auxDevice(size_t i) const;
AuxDevice *auxDevice(const AuxDeviceIndex &i) const;
Sensor* sensor(size_t i) const;
Sensor* sensor(const SensorIndex& i) const;
Sensor *sensor(size_t i) const;
Sensor *sensor(const SensorIndex &i) const;
Datalogger* datalogger(size_t i) const;
Datalogger* datalogger(const DataloggerIndex& i) const;
Datalogger *datalogger(size_t i) const;
Datalogger *datalogger(const DataloggerIndex &i) const;
ResponsePAZ* responsePAZ(size_t i) const;
ResponsePAZ* responsePAZ(const ResponsePAZIndex& i) const;
ResponsePAZ *responsePAZ(size_t i) const;
ResponsePAZ *responsePAZ(const ResponsePAZIndex &i) const;
ResponseFIR* responseFIR(size_t i) const;
ResponseFIR* responseFIR(const ResponseFIRIndex& i) const;
ResponseFIR *responseFIR(size_t i) const;
ResponseFIR *responseFIR(const ResponseFIRIndex &i) const;
ResponseIIR* responseIIR(size_t i) const;
ResponseIIR* responseIIR(const ResponseIIRIndex& i) const;
ResponseIIR *responseIIR(size_t i) const;
ResponseIIR *responseIIR(const ResponseIIRIndex &i) const;
ResponsePolynomial* responsePolynomial(size_t i) const;
ResponsePolynomial* responsePolynomial(const ResponsePolynomialIndex& i) const;
ResponsePolynomial *responsePolynomial(size_t i) const;
ResponsePolynomial *responsePolynomial(const ResponsePolynomialIndex &i) const;
ResponseFAP* responseFAP(size_t i) const;
ResponseFAP* responseFAP(const ResponseFAPIndex& i) const;
ResponseFAP *responseFAP(size_t i) const;
ResponseFAP *responseFAP(const ResponseFAPIndex &i) const;
Network* network(size_t i) const;
Network* network(const NetworkIndex& i) const;
Network *network(size_t i) const;
Network *network(const NetworkIndex &i) const;
//! Find an object by its unique attribute(s)
StationGroup* findStationGroup(const std::string& publicID) const;
AuxDevice* findAuxDevice(const std::string& publicID) const;
Sensor* findSensor(const std::string& publicID) const;
Datalogger* findDatalogger(const std::string& publicID) const;
ResponsePAZ* findResponsePAZ(const std::string& publicID) const;
ResponseFIR* findResponseFIR(const std::string& publicID) const;
ResponseIIR* findResponseIIR(const std::string& publicID) const;
ResponsePolynomial* findResponsePolynomial(const std::string& publicID) const;
ResponseFAP* findResponseFAP(const std::string& publicID) const;
Network* findNetwork(const std::string& publicID) const;
StationGroup *findStationGroup(const std::string& publicID) const;
AuxDevice *findAuxDevice(const std::string& publicID) const;
Sensor *findSensor(const std::string& publicID) const;
Datalogger *findDatalogger(const std::string& publicID) const;
ResponsePAZ *findResponsePAZ(const std::string& publicID) const;
ResponseFIR *findResponseFIR(const std::string& publicID) const;
ResponseIIR *findResponseIIR(const std::string& publicID) const;
ResponsePolynomial *findResponsePolynomial(const std::string& publicID) const;
ResponseFAP *findResponseFAP(const std::string& publicID) const;
Network *findNetwork(const std::string& publicID) const;
//! Implement Object interface
bool assign(Object *other) override;

16
include/seiscomp/datamodel/journalentry.h
View File

@ -50,25 +50,25 @@ class SC_SYSTEM_CORE_API JournalEntry : public Object {
JournalEntry();
//! Copy constructor
JournalEntry(const JournalEntry& other);
JournalEntry(const JournalEntry &other);
//! Destructor
~JournalEntry() override;
// ------------------------------------------------------------------
// Operators
// ------------------------------------------------------------------
public:
//! Copies the metadata of other to this
JournalEntry& operator=(const JournalEntry& other);
JournalEntry &operator=(const JournalEntry &other);
//! Checks for equality of two objects. Child objects
//! are not part of the check.
bool operator==(const JournalEntry& other) const;
bool operator!=(const JournalEntry& other) const;
bool operator==(const JournalEntry &other) const;
bool operator!=(const JournalEntry &other) const;
//! Wrapper that calls operator==
bool equal(const JournalEntry& other) const;
bool equal(const JournalEntry &other) const;
// ------------------------------------------------------------------
@ -90,12 +90,12 @@ class SC_SYSTEM_CORE_API JournalEntry : public Object {
void setParameters(const std::string& parameters);
const std::string& parameters() const;
// ------------------------------------------------------------------
// Public interface
// ------------------------------------------------------------------
public:
Journaling* journaling() const;
Journaling *journaling() const;
//! Implement Object interface
bool assign(Object *other) override;

22
include/seiscomp/datamodel/journaling.h
View File

@ -49,11 +49,11 @@ class SC_SYSTEM_CORE_API Journaling : public PublicObject {
Journaling();
//! Copy constructor
Journaling(const Journaling& other);
Journaling(const Journaling &other);
//! Destructor
~Journaling() override;
// ------------------------------------------------------------------
// Operators
@ -61,16 +61,16 @@ class SC_SYSTEM_CORE_API Journaling : public PublicObject {
public:
//! Copies the metadata of other to this
//! No changes regarding child objects are made
Journaling& operator=(const Journaling& other);
Journaling &operator=(const Journaling &other);
//! Checks for equality of two objects. Child objects
//! are not part of the check.
bool operator==(const Journaling& other) const;
bool operator!=(const Journaling& other) const;
bool operator==(const Journaling &other) const;
bool operator!=(const Journaling &other) const;
//! Wrapper that calls operator==
bool equal(const Journaling& other) const;
bool equal(const Journaling &other) const;
// ------------------------------------------------------------------
// Public interface
// ------------------------------------------------------------------
@ -83,7 +83,7 @@ class SC_SYSTEM_CORE_API Journaling : public PublicObject {
* because it already exists in the list
* or it already has another parent
*/
bool add(JournalEntry* obj);
bool add(JournalEntry *obj);
/**
* Removes an object.
@ -92,7 +92,7 @@ class SC_SYSTEM_CORE_API Journaling : public PublicObject {
* @return false The object has not been removed
* because it does not exist in the list
*/
bool remove(JournalEntry* obj);
bool remove(JournalEntry *obj);
/**
* Removes an object of a particular class.
@ -107,10 +107,10 @@ class SC_SYSTEM_CORE_API Journaling : public PublicObject {
//! Index access
//! @return The object at index i
JournalEntry* journalEntry(size_t i) const;
JournalEntry *journalEntry(size_t i) const;
//! Find an object by its unique attribute(s)
JournalEntry* findJournalEntry(JournalEntry* journalEntry) const;
JournalEntry *findJournalEntry(JournalEntry *journalEntry) const;
//! Implement Object interface
bool assign(Object *other) override;

Some files were not shown because too many files have changed in this diff Show More