eckit namespace

Namespaces

namespace codec

namespace distributed

namespace geo

namespace geometry

namespace linalg

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 Loader

class Watcher

class AliasCmd

class Arg

class CmdApplication

class CmdArg

class Prompter

class CmdParser

class CmdResource

class ConfigCmd

class DirCmd

class EchoCmd

class EnvironmentCmd

class ExportCmd

class HistoryCmd

class JSONCmd

class KillCmd

class LibEcKitCmd

class LockCmd

class ManCmd

class MemoryCmd

class PsCmd

class QuitCmd

class RemoteCmd

class RemoteCommandable

A RemoteCommand-able object.

class RemoteCommander

class RemoteCommandUser

class SleepCmd

class StartCmd

class StatusCmd

class StopCmd

class TailCmd

class TermBuf

class UpTimeCmd

class UserInput

template<class T>

class Inited

class StrStream

class Configurable

class Configuration

class Configured

class EtcTable

class EtcKeyTable

class EtcStartWithTable

class LibEcKit

class LocalConfiguration

template<>

struct VectorPrintSelector<LocalConfiguration>

class Parametrisation

template<class T>

class Resource

template<class T, class LIB>

class LibResource

class ResourceBase

class ResourceQualifier

class ResourceMgr

class YAMLConfiguration

template<typename T>

class BloomFilter

template<class Point>

class BSPHyperPlane

template<class Traits, class Partition>

class BSPNode

template<class Traits, class Partition>

class BSPTreeX

template<class Traits, class Partition>

class BSPTreeMemory

template<class Traits, class Partition>

class BSPTreeMapped

class BTreeLock

class BTreeNoLock

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

class BTree

template<typename K, typename V>

class Cache

template<typename K, typename V>

class CacheLRU

class CacheManagerBase

Filesystem Cache Manager.

class CacheManagerNoLock

class CacheManagerFileSemaphoreLock

class CacheManagerFileFlock

template<class Traits>

class CacheManager

template<class T>

class ClassExtent

template<typename K, typename V>

class DenseMap

template<typename V>

class DenseSet

struct KDMappedHeader

class KDMapped

struct KDMemory

template<class T, class A>

struct TT

template<class Traits>

class KDNode

template<class Traits>

class KDTreeX

template<class Traits>

class KDTreeMemory

template<class Traits>

class KDTreeMapped

template<class T>

class MappedArray

class QueueInterruptedError

template<typename ELEM>

class Queue

template<class T>

class Recycler

template<class T>

class SharedMemArray

Maps an array to shared memory.

template<class Traits, class NodeType>

class SPIterator

template<class Traits>

struct SPMetadata

template<class Traits, class NodeType>

class SPNode

template<class Traits>

class SPTreeIterator

template<class Traits>

class SPValue

template<class Traits, class NodeType>

struct SPNodeInfo

template<class Traits, class NodeType>

class SPNodeQueue

template<class Traits, class NodeType>

class SPTree

struct StatCollector

template<class T>

class Trie

class Exception

General purpose exception Derive other exceptions from this class and implement then in the class that throws them.

class SeriousBug

class TooManyRetries

class TimeOut

class FailedLibraryCall

class FailedSystemCall

class AssertionFailed

class BadParameter

class BadCast

class BadValue

class NotImplemented

class Stop

class Abort

class Cancel

class Retry

class UserError

class OutOfRange

class FunctionalityNotSupported

class FileError

class CantOpenFile

class WriteError

class ReadError

class CloseError

class ShortFile

class RemoteException

class UnexpectedState

class OutOfMemory

For compatibility.

class BasePathName

template<class T>

class BasePathNameT

class FileMode

class FileSpace

class FileSpaceStrategies

class FileSystem

struct FileSystemSize

class LocalFileManager

class LocalPathName

LocalPathName represents a UNIX path.

template<>

struct VectorPrintSelector<LocalPathName>

class PathExpander

class PathName

template<>

struct VectorPrintSelector<PathName>

class PathNameFactory

class PathNameBuilderBase

template<typename T>

class PathNameBuilder

class StdDir

class TempFile

class TmpDir

class TmpFile

class URI

class URIManager

class LibEcKitGeo

class AIOHandle

class AsyncHandle

template<typename T>

class AutoCloser

class Base64

class BitIO

class Buffer

Simple class to implement memory buffers.

class BufferCache

class BufferedHandle

class BufferList

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

class CircularBuffer

class ClusterDisks

class ClusterNode

class ClusterNodes

class NodeInfo

class CommandStream

class Compress

class RestartTransfer

class DataHandle

class AutoClose

class DblBuffer

class EasyCURLResponse

class EasyCURL

class EmptyHandle

template<class T>

class FileBase

class FileDescHandle

class FileHandle

class FileLock

class FileLocker

class FilePool

class FTPHandle

class HandleBuf

class HandleHolder

class Length

class MemoryHandle

class MMappedFileHandle

class MoverTransfer

class MoverTransferSelection

class MultiHandle

class MultiSocketHandle

class Offset

class PartFileHandle

class PartHandle

class PeekHandle

class PipeHandle

class Pipeline

class PooledFile

class PooledFileError

class PooledFileDescriptor

class PooledHandle

class RadosAttributes

class RadosCluster

class RadosHandle

class RadosObject

class RadosReadHandle

class RadosWriteHandle

class RawFileHandle

class SeekableHandle

class Select

Wraps calls to select.

class CountedBuffer

class SharedBuffer

class SharedHandle

class SockBuf

class StatsHandle

class StdFile

class AutoStdFile

class StdioBuf

class StdPipe

Simple wrapper for pipes.

class AutoStdPipe

class TCPHandle

class InstantTCPSocketHandle

class TCPSocketHandle

class TeeHandle

class TransferWatcher

class URLException

class URLHandle

class BigNum

Class used to print large numbers.

class Bytes

class CallbackTarget

class Channel

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

class AutoIndent

class ChannelBuffer

Stream buffer to be usedby Channel.

class CodeLocation

class Colour

class ColouringTarget

class ETA

class FileTarget

class IndentTarget

class JSON

class LineBasedTarget

class Log

class LogFormatSetter

class Voidify

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

class LogTarget

class MessageTarget

class MonitorTarget

class OStreamTarget

class Plural

class PrefixTarget

class Progress

class ProgressTimer

class ResourceUsage

template<class T>

class TraceResourceUsage

class RotationTarget

class SavedStatus

Saves and Restores Monitor status line.

class Seconds

struct Timing

class Statistics

class AutoTiming

class StatusTarget

class SysLog

SysLog implements the RFC 5424 format for logging.

class TeeTarget

class Timer

class TimeStamp

class TimeStampTarget

template<class T>

class TraceTimer

class UserMsg

class UserChannel

class WrapperTarget

class Builder

template<class Base>

class BuilderT0

template<class Base>

class BuilderT1

template<class Base>

class BuilderT2

template<class Base, class T>

class ConcreteBuilderT0

template<class Base, class T>

class ConcreteBuilderT1

template<class Base, class T>

class ConcreteBuilderT2

class Counted

template<class T>

class Factory

class MapAllocatorTooSmall

class MapAllocator

class MemoryBuffer

class MMap

class NonCopyable

Inherit from this class to make a NonCopyable class.

class OnlyMovable

Inherit from this class to make a NonCopyable class.

template<typename LOCK>

class OwnedT

template<class T, int size>

class Padded

template<typename T>

class ScopedPtr

template<class T>

struct NewDealloc

template<class T>

struct NewArrayDealloc

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

class SharedPtr

class Shmget

class HttpError

class HttpHeader

class ProxiedTCPClient

class ProxiedTCPServer

class EckitTool

class AutoAlarm

class AutoUmask

class BackTrace

class Password

class Semaphore

class SemLocker

class SharedInt

class SignalHandler

struct Stat

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

class System

class CSVParser

class JSONParser

class ObjectParser

class StreamParser

class YAMLParser

class Bless

class Evolve

class DumpLoad

class Exporter

class Isa

class Schema

class Application

template<class Request>

struct DefaultHandler

template<class Request>

struct DequeuePicker

template<class Traits>

class Dispatcher

template<class Traits>

class DispatchTask

template<class Traits>

class DispatchInfo

class Library

class Main

class Metrics

class CollectMetrics

class MetricsPrefix

class Monitor

class AutoState

template<class T>

class AutoLockTag

class Monitorable

template<class PAYLOAD>

class PipeTask

template<class PAYLOAD>

struct OnePayload

template<class PAYLOAD>

class Pipe

class PipeApplication

template<class Request>

class PipeHandler

class ProcessControler

template<class PAYLOAD>

class Producer

template<class PAYLOAD>

class Consumer

template<class PAYLOAD>

class ProducerConsumerTask

template<class PAYLOAD>

class ProducerConsumer

class SessionID

class Task

struct Info

class TaskInfo

class Tool

class BadTag

class FileStream

Stream to serialise to FILE*.

class FstreamStream

class HandleStream

class IfstreamStream

class MemoryStream

class PipeStream

struct ClassSpec

class ReanimatorBase

template<class T>

class Reanimator

class ResizableMemoryStream

template<class T>

class BufferedWriter

template<class T>

class BufferedReader

template<class T>

class IOBuffer

class Stream

class Streamable

template<class T>

class AutoLock

template<class T>

class AutoSharedLock

template<class T>

class TimedAutoLock

template<class T, class U>

class TraceAutoLock

class Mutex

class MutexCond

template<class T>

class Once

class StaticMutex

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

class Thread

class ThreadControler

class ThreadPoolTask

class ThreadPool

template<typename TYPE>

struct NewAlloc0

template<typename TYPE, typename P1>

struct NewAlloc1

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

class ThreadSingleton

class TxnEvent

template<class T>

struct TxnRecoverer

template<class T>

struct TxnFinder

template<class T>

class TxnLog

class ClimateDate

class Coord

class Longitude

class Latitude

class Date

class DateTime

class DayOfYear

class Double

template<int SIZE>

class FixedString

class Fraction

class Grid

class Hour

class Month

class SemanticVersion

class Time

class BadTime

class TimeInterval

template<class T>

class output_list

struct output_iterator

template<class T>

class output_list_iterator

class VectorPrintSimple

class VectorPrintContracted

template<typename T>

struct VectorPrintSelector

template<>

struct VectorPrintSelector<std::string>

template<>

struct VectorPrintSelector<double>

template<typename K, typename V>

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

class UUID

class VerifyingDate

class AECCompressor

template<int T>

struct ByteSwap

ByteSwap selects the swap function based on data type size.

template<>

struct ByteSwap<8>

template<>

struct ByteSwap<4>

template<>

struct ByteSwap<2>

class BZip2Compressor

class Clock

class Compressor

class NoCompressor

class CompressorBuilderBase

template<class T>

class CompressorBuilder

class CompressorFactory

class Hash

class HashBuilderBase

template<class T>

class HashBuilder

class HashFactory

class HyperCube

class LZ4Compressor

class MD4

class MD5

struct None

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>

template<typename... Ts>

struct Overloaded

class Regex

class RendezvousHash

class Rsync

class SHA1

class SnappyCompressor

class StringTools

class Tokenizer

template<class From, class To>

struct Translator

template<>

struct Translator<bool, std::string>

template<>

struct Translator<std::string, bool>

template<>

struct Translator<unsigned char, std::string>

template<>

struct Translator<float, std::string>

template<>

struct Translator<short, std::string>

template<>

struct Translator<int, std::string>

template<>

struct Translator<unsigned int, std::string>

template<>

struct Translator<std::string, int>

template<>

struct Translator<std::string, unsigned int>

template<>

struct Translator<double, std::string>

template<>

struct Translator<std::string, double>

template<>

struct Translator<std::string, float>

template<>

struct Translator<long, std::string>

template<>

struct Translator<std::string, long>

template<>

struct Translator<std::string, short>

template<>

struct Translator<unsigned long, std::string>

template<>

struct Translator<std::string, unsigned long>

template<>

struct Translator<std::string, unsigned char>

template<>

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

template<>

struct Translator<std::string, long long>

template<>

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

template<>

struct Translator<long long, std::string>

template<>

struct Translator<std::string, char>

template<>

struct Translator<char, std::string>

template<>

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

template<>

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

template<>

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

template<>

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

template<>

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

template<>

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

template<>

struct Translator<signed char, std::string>

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 xxHash

class BoolContent

class CompositeParams

class Content

class DateContent

class DateTimeContent

template<class Derived>

class DispatchParams

class DoubleContent

class ListContent

class MapContent

class NilContent

class NumberContent

class OrderedMapContent

class Params

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

class Properties

class ScopeParams

Wraps the parameters within a given scope.

class StringContent

class TimeContent

class Value

template<>

struct VectorPrintSelector<Value>

class AgentResource

class CgiResource

class FileResource

class FtpRequest

class Html

class HtmlObject

class HtmlResource

class HttpResource

class HttpServer

class HttpService

class HttpStream

class HttpUser

class JavaAgent

class JavaResource

class JavaServer

class JavaService

class JavaUser

class JSONResource

class UrlAccess

class Url

Typedefs

using JSONConfiguration = YAMLConfiguration

using abort_handler_t = void(*)()

using MethodNotYetImplemented = NotImplemented

For compatibility.

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 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*)

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>

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

None nullopt constexpr

template<typename From, typename To>

bool IsTranslatable_v constexpr

Typedef documentation

Function documentation

Variable documentation