eckit namespace

Namespaces

namespace codec

namespace distributed

namespace geo

namespace geometry

namespace linalg

namespace literals

namespace log

namespace mars

namespace maths

namespace memory

namespace message

namespace mpi

namespace net

namespace option

namespace runtime

namespace sql

namespace system

namespace testing

namespace types

Classes

class Abort

class AECCompressor

class AgentResource

class AIOHandle

class AliasCmd

class Application

class Arg

class AssertionFailed

class AsyncHandle

class AutoAlarm

class AutoClose

template<typename T>

class AutoCloser

class AutoIndent

template<class T>

class AutoLock

template<class T>

class AutoLockTag

template<class T>

class AutoSharedLock

class AutoState

class AutoStdFile

class AutoStdPipe

class AutoTiming

class AutoUmask

class BackTrace

class BadCast

class BadParameter

class BadTag

class BadTime

class BadValue

class Base64

class BasePathName

template<class T>

class BasePathNameT

class BigNum

Class used to print large numbers.

class BitIO

class Bless

template<typename T>

class BloomFilter

class BoolContent

template<class Point>

class BSPHyperPlane

template<class Traits, class Partition>

class BSPNode

template<class Traits, class Partition>

class BSPTreeMapped

template<class Traits, class Partition>

class BSPTreeMemory

template<class Traits, class Partition>

class BSPTreeX

template<class K, class V, int S, class L = BTreeNoLock>

class BTree

class BTreeLock

class BTreeNoLock

class Buffer

Simple class to implement memory buffers.

class BufferCache

class BufferedHandle

template<class T>

class BufferedReader

template<class T>

class BufferedWriter

class BufferList

A class to aggregate buffers into a single object that can be read as a whole.

class Builder

template<class Base>

class BuilderT0

template<class Base>

class BuilderT1

template<class Base>

class BuilderT2

class Bytes

template<int T>

struct ByteSwap

ByteSwap selects the swap function based on data type size.

template<>

struct ByteSwap<2>

template<>

struct ByteSwap<4>

template<>

struct ByteSwap<8>

class BZip2Compressor

template<typename K, typename V>

class Cache

template<typename K, typename V>

class CacheLRU

template<class Traits>

class CacheManager

class CacheManagerBase

Filesystem Cache Manager.

class CacheManagerFileFlock

class CacheManagerFileSemaphoreLock

class CacheManagerNoLock

class CallbackTarget

class Cancel

class CantOpenFile

class CgiResource

class Channel

Output channel that is an std::ostream but more functional.

class ChannelBuffer

Stream buffer to be usedby Channel.

class CircularBuffer

template<class T>

class ClassExtent

struct ClassSpec

class ClimateDate

class Clock

class CloseError

class ClusterDisks

class ClusterNode

class ClusterNodes

class CmdApplication

class CmdArg

class CmdParser

class CmdResource

class CodeLocation

class CollectMetrics

class Colour

class ColouringTarget

class CommandStream

class CompositeParams

class Compress

class Compressor

template<class T>

class CompressorBuilder

class CompressorBuilderBase

class CompressorFactory

template<class Base, class T>

class ConcreteBuilderT0

template<class Base, class T>

class ConcreteBuilderT1

template<class Base, class T>

class ConcreteBuilderT2

class ConfigCmd

class Configurable

class Configuration

class Configured

template<class PAYLOAD>

class Consumer

class Content

class Coord

class Counted

class CountedBuffer

class CSVParser

class DataHandle

class Date

class DateContent

class DateTime

class DateTimeContent

class DayOfYear

class DblBuffer

template<class Request>

struct DefaultHandler

template<typename K, typename V>

class DenseMap

template<typename V>

class DenseSet

template<class Request>

struct DequeuePicker

class DirCmd

template<class Traits>

class Dispatcher

template<class Traits>

class DispatchInfo

template<class Derived>

class DispatchParams

template<class Traits>

class DispatchTask

class Double

class DoubleContent

class DumpLoad

class EasyCURL

class EasyCURLResponse

class EchoCmd

class EckitTool

class EmptyHandle

class EnvironmentCmd

class ETA

class EtcKeyTable

class EtcStartWithTable

class EtcTable

class Evolve

class Exception

Base class for all ECMWF exceptions. All exception types shall inherit from this class, either directly or indirectly.

class ExportCmd

class Exporter

template<class T>

class Factory

class FailedLibraryCall

class FailedSystemCall

template<class T>

class FileBase

class FileDescHandle

class FileError

class FileHandle

class FileLock

class FileLocker

class FileMode

class FilePool

class FileResource

class FileSpace

class FileSpaceStrategies

class FileStream

Stream to serialise to FILE*.

class FileSystem

struct FileSystemSize

class FileTarget

template<int SIZE>

class FixedString

class Fraction

class FstreamStream

class FTPHandle

class FtpRequest

class FunctionalityNotSupported

class Grid

class HandleBuf

class HandleHolder

class HandleStream

class Hash

template<class T>

class HashBuilder

class HashBuilderBase

class HashFactory

class HistoryCmd

class Hour

class Html

class HtmlObject

class HtmlResource

class HttpError

class HttpHeader

class HttpResource

class HttpServer

class HttpService

class HttpStream

class HttpUser

class HyperCube

class IfstreamStream

class IndentTarget

struct Info

template<class T>

class Inited

class InstantTCPSocketHandle

template<class T>

class IOBuffer

class Isa

template<typename From, typename To, class = void>

struct IsTranslatable

template<typename From, typename To>

struct IsTranslatable<From, To, std::void_t<decltype(Translator<From, To>{}(std::declval<const From&>()))>>

class JavaAgent

class JavaResource

class JavaServer

class JavaService

class JavaUser

class JSON

class JSONCmd

class JSONParser

class JSONResource

class KDMapped

struct KDMappedHeader

struct KDMemory

template<class Traits>

class KDNode

template<class Traits>

class KDTreeMapped

template<class Traits>

class KDTreeMemory

template<class Traits>

class KDTreeX

class KillCmd

class Latitude

class Length

class LibEcKit

class LibEcKitCmd

class LibEcKitGeo

class Library

template<class T, class LIB>

class LibResource

class LineBasedTarget

class ListContent

class Loader

class LocalConfiguration

class LocalFileManager

class LocalPathName

LocalPathName represents a UNIX path.

class LockCmd

class Log

class LogFormatSetter

class LogTarget

class Longitude

class LZ4Compressor

class Main

class ManCmd

class MapAllocator

class MapAllocatorTooSmall

class MapContent

template<class T>

class MappedArray

class MD4

class MD5

class MemoryBuffer

class MemoryCmd

class MemoryHandle

class MemoryStream

class MessageTarget

class Metrics

class MetricsPrefix

class MMap

class MMappedFileHandle

class Monitor

class Monitorable

class MonitorTarget

class Month

class MoverTransfer

class MoverTransferSelection

class MultiHandle

class MultiSocketHandle

class Mutex

class MutexCond

template<typename TYPE>

struct NewAlloc0

template<typename TYPE, typename P1>

struct NewAlloc1

template<class T>

struct NewArrayDealloc

template<class T>

struct NewDealloc

class NilContent

class NoCompressor

class NodeInfo

class NonCopyable

Inherit from this class to make a NonCopyable class.

struct None

class NotImplemented

class NumberContent

class ObjectParser

class Offset

template<class T>

class Once

template<class PAYLOAD>

struct OnePayload

class OnlyMovable

Inherit from this class to make a NonCopyable class.

template<typename T>

class Optional

template<typename T, typename Enable = void>

class OptionalBase

template<typename T>

class OptionalBase<T, typename std::enable_if<std::is_trivially_destructible<T>::value>::type>

class OrderedMapContent

class OStreamTarget

class OutOfMemory

class OutOfRange

struct output_iterator

template<class T>

class output_list

template<class T>

class output_list_iterator

template<typename... Ts>

struct Overloaded

template<typename LOCK>

class OwnedT

template<class T, int size>

class Padded

class Parametrisation

class Params

Params provides a value-based behaviour for parametrisations of objects.

class PartFileHandle

class PartHandle

class Password

class PathExpander

class PathName

template<typename T>

class PathNameBuilder

class PathNameBuilderBase

class PathNameFactory

class PeekHandle

template<class PAYLOAD>

class Pipe

class PipeApplication

class PipeHandle

template<class Request>

class PipeHandler

class Pipeline

class PipeStream

template<class PAYLOAD>

class PipeTask

class Plural

class PooledFile

class PooledFileDescriptor

class PooledFileError

class PooledHandle

class PrefixTarget

class ProcessControler

template<class PAYLOAD>

class Producer

template<class PAYLOAD>

class ProducerConsumer

template<class PAYLOAD>

class ProducerConsumerTask

class Progress

class ProgressTimer

class Prompter

class Properties

class ProxiedTCPClient

class ProxiedTCPServer

class PsCmd

template<typename ELEM>

class Queue

class QueueInterruptedError

class QuitCmd

class RadosAttributes

class RadosCluster

class RadosHandle

class RadosObject

class RadosReadHandle

class RadosWriteHandle

class RawFileHandle

class ReadError

template<class T>

class Reanimator

class ReanimatorBase

template<class T>

class Recycler

class Regex

class RemoteCmd

class RemoteCommandable

A RemoteCommand-able object.

class RemoteCommander

class RemoteCommandUser

class RemoteException

class RendezvousHash

class ResizableMemoryStream

template<class T>

class Resource

class ResourceBase

class ResourceMgr

class ResourceQualifier

class ResourceUsage

class RestartTransfer

class Retry

class RotationTarget

class Rsync

class SavedStatus

Saves and Restores Monitor status line.

class Schema

template<typename T>

class ScopedPtr

class ScopeParams

Wraps the parameters within a given scope.

class Seconds

class SeekableHandle

class Select

Wraps calls to select.

class SemanticVersion

class Semaphore

class SemLocker

class SeriousBug

class SessionID

class SHA1

class SharedBuffer

class SharedHandle

class SharedInt

template<class T>

class SharedMemArray

Maps an array to shared memory.

template<class T, class ALLOC = NewDealloc<T>>

class SharedPtr

class Shmget

class ShortFile

class SignalHandler

class SleepCmd

class SnappyCompressor

class SockBuf

template<class Traits, class NodeType>

class SPIterator

template<class Traits>

struct SPMetadata

template<class Traits, class NodeType>

class SPNode

template<class Traits, class NodeType>

struct SPNodeInfo

template<class Traits, class NodeType>

class SPNodeQueue

template<class Traits, class NodeType>

class SPTree

template<class Traits>

class SPTreeIterator

template<class Traits>

class SPValue

class StartCmd

struct Stat

struct to manage differences between stat and stat64 different OS's

struct StatCollector

class StaticMutex

Class meant to be used only for static mutexes protecting local resources inside a single compilation unit.

class Statistics

class StatsHandle

class StatusCmd

class StatusTarget

class StdDir

class StdFile

class StdioBuf

class StdPipe

Simple wrapper for pipes.

class Stop

class StopCmd

class Stream

class Streamable

class StreamParser

class StringContent

class StringTools

class StrStream

class SysLog

SysLog implements the RFC 5424 format for logging.

class System

class TailCmd

class Task

class TaskInfo

class TCPHandle

class TCPSocketHandle

class TeeHandle

class TeeTarget

class TempFile

class TermBuf

class Thread

class ThreadControler

class ThreadPool

class ThreadPoolTask

template<typename T, typename A = NewAlloc0<T>>

class ThreadSingleton

class Time

class TimeContent

template<class T>

class TimedAutoLock

class TimeInterval

class TimeOut

class Timer

class TimeStamp

class TimeStampTarget

struct Timing

class TmpDir

class TmpFile

class Tokenizer

class Tool

class TooManyRetries

template<class T, class U>

class TraceAutoLock

template<class T>

class TraceResourceUsage

template<class T>

class TraceTimer

class TransferWatcher

template<class From, class To>

struct Translator

template<>

struct Translator<bool, std::string>

template<>

struct Translator<char, std::string>

template<>

struct Translator<double, std::string>

template<>

struct Translator<float, std::string>

template<>

struct Translator<int, std::string>

template<>

struct Translator<long long, std::string>

template<>

struct Translator<long, std::string>

template<>

struct Translator<short, std::string>

template<>

struct Translator<signed char, std::string>

template<>

struct Translator<std::set<std::string>, std::string>

template<>

struct Translator<std::string, bool>

template<>

struct Translator<std::string, char>

template<>

struct Translator<std::string, double>

template<>

struct Translator<std::string, float>

template<>

struct Translator<std::string, int>

template<>

struct Translator<std::string, long>

template<>

struct Translator<std::string, long long>

template<>

struct Translator<std::string, short>

template<>

struct Translator<std::string, std::set<std::string>>

template<>

struct Translator<std::string, std::vector<long>>

template<>

struct Translator<std::string, std::vector<std::string>>

template<>

struct Translator<std::string, unsigned char>

template<>

struct Translator<std::string, unsigned int>

template<>

struct Translator<std::string, unsigned long>

template<>

struct Translator<std::string, unsigned long long>

template<>

struct Translator<std::vector<long>, std::string>

template<>

struct Translator<std::vector<std::string>, std::string>

template<>

struct Translator<unsigned char, std::string>

template<>

struct Translator<unsigned int, std::string>

template<>

struct Translator<unsigned long long, std::string>

template<>

struct Translator<unsigned long, std::string>

template<class T>

class Trie

template<class T, class A>

struct TT

class TxnEvent

template<class T>

struct TxnFinder

template<class T>

class TxnLog

template<class T>

struct TxnRecoverer

class UnexpectedState

class UpTimeCmd

class URI

class URIManager

class Url

class UrlAccess

class URLException

class URLHandle

class UserChannel

class UserError

class UserInput

class UserMsg

class UUID

class Value

class VectorPrintContracted

template<typename T>

struct VectorPrintSelector

template<>

struct VectorPrintSelector<double>

template<>

struct VectorPrintSelector<LocalConfiguration>

template<>

struct VectorPrintSelector<LocalPathName>

template<>

struct VectorPrintSelector<PathName>

template<typename K, typename V>

struct VectorPrintSelector<std::pair<K, V>>

template<>

struct VectorPrintSelector<std::string>

template<>

struct VectorPrintSelector<Value>

class VectorPrintSimple

class VerifyingDate

class Voidify

Optimisation for DEBUG with elision of stream code. For performance critical code blocks.

class Watcher

class WrapperTarget

class WriteError

class xxHash

class YAMLConfiguration

class YAMLParser

Typedefs

using JSONConfiguration = YAMLConfiguration

using abort_handler_t = void(*)()

using EasyCURLHeaders = std::map<std::string, std::string>

using LengthList = std::vector<Length>

using OffsetList = std::vector<Offset>

using ResizableBuffer = Buffer

using channel_callback_t = void(*)(void*data, const char*msg)

using OwnedLock = OwnedT<memory::detail::ThreadedLock>

Owned object without thread lockable resource.

using OwnedNoLock = OwnedT<memory::detail::NoLock>

Owned object with thread lockable resource.

using Owned = OwnedNoLock

using TaskID = unsigned long long

using TxnID = unsigned long long

using CoordList = std::vector<Coord>

using Second = double

using Ordinal = unsigned long

for counting

using OrdinalList = std::vector<Ordinal>

using StringList = std::vector<std::string>

using StringSet = std::set<std::string>

using StringDict = std::map<std::string, std::string>

using EncodingClock = std::chrono::steady_clock

using ValueList = std::vector<Value>

using ValueMap = std::map<Value, Value>

Functions

void destroy(LockCmd**)

template<class T>

auto operator<<(std::ostream& os, const Resource<T>& r) -> std::ostream&

void handle_panic(const char*, const CodeLocation& = {})

void handle_panic_no_log(const char*, const CodeLocation& = {})

void handle_assert(const std::string&, const CodeLocation& = {})

template<class T>

auto SysCall(T code, const char* msg, const char* file, int line, const char* func) -> T

template<class T>

auto SysCall(long long code, const char* msg, const T& ctx, const char* file, int line, const char* func) -> long long

void ThrCall(int code, const char* msg, const char* file, int line, const char* func)

void Assert(int code, const char* msg, const char* file, int line, const char* func)

void Assert(int code, const std::string& msg, const char* file, int line, const char* func)

void Panic(int code, const char* msg, const CodeLocation& loc)

void PanicNoLog(int code, const char* msg, const CodeLocation& loc)

template<typename T>

auto closer(T& obj) -> AutoCloser<T>

auto version(NodeInfo*) -> unsigned long

auto fsync(int fd) -> int

An fsync that retries when interrupted by system.

auto fdatasync(int fd) -> int

A platform independent fdatasync.

void sort(OffsetList&, LengthList&)

auto compress(OffsetList&, LengthList&) -> bool

void accumulate(const LengthList&, OffsetList&, const Offset& = 0)

static auto rados_call(int code, const char* msg, const char* file, int line, const char* func) -> int

auto format(std::ostream&) -> int

Format manipulators.

void format(std::ostream&, int)

auto setformat(std::ostream& s, int f) -> std::ostream&

auto setformat(int format) -> LogFormatSetter

auto newl(std::ostream& out) -> std::ostream&

auto operator>>(Stream&, Timing&) -> Stream&

auto operator<<(Stream&, const Timing&) -> Stream&

auto operator<<(std::ostream&, const Timing&) -> std::ostream&

auto operator-(const ::timeval&, const ::timeval&) -> ::timeval

auto round(size_t x, size_t n) -> size_t

template<typename T>

auto sign(T v) -> int

template<typename T>

void swap(ScopedPtr<T>& a, ScopedPtr<T>& b)

non-member function overload

template<class T>

void delete_ptr(T*& p)

Deletes a pointer and makes sure it is set to 0 afterwards Do not use this function with data allocate with new [].

template<class T>

void delete_ptr_array(T*& p)

Deletes a pointer and makes sure it is set to 0 afterwards Do not use this function with data allocate with new.

template<class T>

void zero(T& p)

void _startObject(eckit::Exporter&, unsigned long long type, unsigned long long location, unsigned long long id, size_t count)

void _endObject(eckit::Exporter&, unsigned long long type, unsigned long long location, unsigned long long id, size_t count)

void _startSubObject(eckit::Exporter&)

void _endSubObject(eckit::Exporter&)

void _nextSubObject(eckit::Exporter&)

void _startClass(eckit::Exporter&, const std::string& name)

void _endClass(eckit::Exporter&, const std::string& name)

void _startClass(eckit::Exporter&, const char* name)

void _endClass(eckit::Exporter&, const char* name)

void _startMember(eckit::Exporter&, const char* name)

void _endMember(eckit::Exporter&, const char* name)

template<class T>

void _export(eckit::Exporter& h, const T& what)

void _export(eckit::Exporter&, int what)

void _export(eckit::Exporter&, unsigned int what)

void _export(eckit::Exporter&, short what)

void _export(eckit::Exporter&, bool what)

void _export(eckit::Exporter&, unsigned short what)

void _export(eckit::Exporter&, long what)

void _export(eckit::Exporter&, long long what)

void _export(eckit::Exporter&, unsigned long long what)

void _export(eckit::Exporter&, unsigned long what)

void _export(eckit::Exporter&, char what)

void _export(eckit::Exporter&, unsigned char what)

void _export(eckit::Exporter&, double what)

template<class T>

void _export(eckit::Exporter& s, const char* name, const T& what)

template<class T>

void load(DumpLoad& a, T& b)

void load(DumpLoad& a, std::string& b)

void load(DumpLoad& a, float& b)

void load(DumpLoad& a, double& b)

void load(DumpLoad& a, int& b)

void load(DumpLoad& a, unsigned int& b)

void load(DumpLoad& a, long& b)

void load(DumpLoad& a, unsigned long& b)

void load(DumpLoad& a, long long& b)

void load(DumpLoad& a, unsigned long long& b)

void load(DumpLoad& a, char& b)

void load(DumpLoad& a, unsigned char& b)

template<class T>

void dump(DumpLoad& a, const T& b)

void dump(DumpLoad& a, const std::string& b)

void dump(DumpLoad& a, float b)

void dump(DumpLoad& a, double b)

void dump(DumpLoad& a, int b)

void dump(DumpLoad& a, unsigned int b)

void dump(DumpLoad& a, long b)

void dump(DumpLoad& a, unsigned long b)

void dump(DumpLoad& a, long long b)

void dump(DumpLoad& a, unsigned long long b)

void dump(DumpLoad& a, char b)

void dump(DumpLoad& a, unsigned char b)

template<class T>

void _describe(std::ostream& s, int depth, const T& what)

void _describe(std::ostream& s, int depth, int what)

void _describe(std::ostream& s, int depth, unsigned int what)

void _describe(std::ostream& s, int depth, short what)

void _describe(std::ostream& s, int depth, bool what)

void _describe(std::ostream& s, int depth, unsigned short what)

void _describe(std::ostream& s, int depth, long what)

void _describe(std::ostream& s, int depth, long long what)

void _describe(std::ostream& s, int depth, unsigned long long what)

void _describe(std::ostream& s, int depth, unsigned long what)

void _describe(std::ostream& s, int depth, char what)

void _describe(std::ostream& s, int depth, unsigned char what)

void _describe(std::ostream& s, int depth, double what)

void _startClass(std::ostream& s, int depth, const std::string& name)

void _endClass(std::ostream& s, int depth, const std::string& name)

void _startMember(std::ostream& s, int depth, const std::string& name)

void _endMember(std::ostream& s, int depth, const std::string& name)

template<class T>

void _describe(std::ostream& s, int depth, const std::string& name, const T& what)

auto version(TaskInfo*) -> unsigned long

template<class T>

auto operator+(T n, const Fraction& f) -> Fraction

template<class T>

auto operator-(T n, const Fraction& f) -> Fraction

template<class T>

auto operator/(T n, const Fraction& f) -> Fraction

template<class T>

auto operator*(T n, const Fraction& f) -> Fraction

template<class T>

auto operator==(T n, const Fraction& f) -> bool

template<class T>

auto operator<(T n, const Fraction& f) -> bool

template<class T>

auto operator<=(T n, const Fraction& f) -> bool

template<class T>

auto operator!=(T n, const Fraction& f) -> bool

template<class T>

auto operator>(T n, const Fraction& f) -> bool

template<class T>

auto operator>=(T n, const Fraction& f) -> bool

template<typename S, typename T>

auto operator<<(std::ostream& s, const std::pair<S, T>& p) -> std::ostream&

template<class T>

auto __print_list(std::ostream& s, const T& t, VectorPrintContracted) -> std::ostream&

template<typename T>

auto __print_list(std::ostream& s, const std::vector<T>& t, VectorPrintSimple) -> std::ostream&

template<typename T, std::size_t N>

auto __print_list(std::ostream& s, const std::array<T, N>& t, VectorPrintSimple) -> std::ostream&

template<typename K, typename V, typename C>

auto __print_container(std::ostream& s, const std::map<K, V, C>& m) -> std::ostream&

template<typename T>

auto __print_container(std::ostream& s, const std::set<T>& m) -> std::ostream&

template<class T>

auto operator<<(Stream&, const std::vector<T>&) -> Stream&

Operators to send vectors in streams.

template<class T>

auto operator>>(Stream&, std::vector<T>&) -> Stream&

template<class K, class V>

auto operator<<(Stream&, const std::map<K, V>&) -> Stream&

template<class K, class V>

auto operator>>(Stream&, std::map<K, V>&) -> Stream&

auto operator==(UUID const& lhs, UUID const& rhs) -> bool

auto operator!=(UUID const& lhs, UUID const& rhs) -> bool

auto operator<(UUID const& lhs, UUID const& rhs) -> bool

auto operator>(UUID const& lhs, UUID const& rhs) -> bool

auto operator<=(UUID const& lhs, UUID const& rhs) -> bool

auto operator>=(UUID const& lhs, UUID const& rhs) -> bool

auto bitswap16(uint16_t a) -> uint16_t

auto bitswap32(uint32_t a) -> uint32_t

auto bitswap64(uint64_t a) -> uint64_t

template<typename T>

void byteswap(T& i)

Scalar bitswap template function uses ByteSwap to select based on type T size.

template<typename T>

void byteswap(T data[], size_t size)

C-array bitswap template function uses ByteSwap to select based on type T size.

template<typename T>

void byteswap(std::vector<T>& vi)

std::vector bitswap template function uses ByteSwap to select based on type T size

template<typename T>

auto bits_to_str(T v) -> std::string

template<typename... Ts>

Overloaded(Ts...) -> Overloaded< Ts... >

template<class InputIterator, class OutputIterator>

auto RLEencode2(InputIterator first, InputIterator last, OutputIterator result, long long maxloop) -> long long

template<class InputIterator, class OutputIterator>

auto RLEencode2(InputIterator first, InputIterator last, OutputIterator result, long long maxloop, const EncodingClock::duration timelimit) -> long long

template<class InputIterator, class OutputIterator>

void RLEdecode2(InputIterator first, InputIterator last, OutputIterator result)

template<class InputIterator>

void RLEprint(std::ostream&, InputIterator first, InputIterator last)

template<class InputIterator, class OutputIterator>

auto DIFFencode(InputIterator first, InputIterator last, OutputIterator result) -> bool

template<class InputIterator, class OutputIterator>

void DIFFdecode(InputIterator first, InputIterator last, OutputIterator result)

template<class InputIterator>

auto RLEwrite(Stream&, InputIterator, InputIterator, long long) -> Stream&

template<class OutputIterator, class T>

auto RLEread(Stream&, OutputIterator, T*) -> Stream&

template<class InputIterator>

auto RLEDIFFwrite(Stream&, InputIterator, InputIterator, long long) -> Stream&

template<class OutputIterator, class T>

auto RLEDIFFread(Stream&, OutputIterator, T*) -> Stream&

template<typename To, typename From>

auto translate(From&& from) -> decltype(auto)

template<class Derived>

auto getValue(const DispatchParams<Derived>& p, const Params::key_t& key) -> Params::value_t

template<class Derived>

void print(const DispatchParams<Derived>&, std::ostream&)

template<class Derived>

void encode(const DispatchParams<Derived>&, Stream&)

template<typename T>

auto toValue(const T& v) -> Value

template<typename T>

auto toValue(const std::set<T>& l) -> Value

template<typename T>

auto toValue(const std::list<T>& l) -> Value

template<typename T>

auto toValue(const std::vector<T>& l) -> Value

template<typename T, typename U>

auto toValue(const std::pair<T, U>& v) -> Value

template<typename K, typename V>

auto toValue(const std::map<K, V>& l) -> Value

template<typename T>

auto makeVectorValue(const std::vector<T>& v) -> Value

template<typename T>

auto makeVectorValue(const std::list<T>& v) -> Value

template<typename T>

void fromValue(T& v, const Value& value)

template<typename T>

void fromValue(std::vector<T>& v, const Value& value)

template<typename T, typename U>

void fromValue(std::pair<T, U>& v, const Value& value)

template<typename T>

void fromValue(std::set<T>& v, const Value& value)

template<typename K, typename V>

void fromValue(std::map<K, V>& v, const Value& value)

Variables

template<class T>

ClassExtent<T>::Extent ClassExtent< T >::extent_

template<class T>

pthread_once_t Once< T >::once_

template<class T>

pthread_mutex_t Once< T >::mutex_

template<typename T, typename A>

pthread_once_t ThreadSingleton< T, A >::once_

template<typename T, typename A>

pthread_key_t ThreadSingleton< T, A >::key_

None nullopt constexpr

template<typename From, typename To>

bool IsTranslatable_v constexpr

Typedef documentation

Function documentation

Variable documentation