C++

template<typename T>
class Channel

Public Functions

Channel(const std::string &hostname, int port, std::unique_ptr<PayloadType<T>> payloadType)

~Channel()

Channel(const Channel&) = delete

Channel(Channel&&) = delete

Channel &operator=(const Channel&) = delete

Channel &operator=(Channel&&) = delete

Response connect()

Response close()

void setTimeout(std::chrono::duration<int64_t, std::milli> timeout)

void setMemoryLimit(size_t limit)

Response put(const RecordsSet<T> &data)

Response puta(const RecordsSet<T> &data)

ResponseGet<T> get(const Key &keyMin, const Key &keyMax)

ResponseAcq getAcq(const Key &keyMin, const Key &keyMax)

ResponseAcq getStream(const Key &keyMin, const Key &keyMax, std::function<void(RecordsSet<T>&)> callback)

Private Members

std::unique_ptr<PayloadType<T>> mPayloadType

struct Key

Public Functions

inline Key()

inline Key(int32_t pCid, int64_t pMid, int32_t pMoid, int64_t pCap = Timestamp::now(), int64_t pAcq = 0)

Public Members

int32_t cid

int64_t mid

int32_t moid

int64_t cap

int64_t acq

template<typename T>
class PayloadType

Public Functions

virtual ~PayloadType() = default

PayloadType(const PayloadType&) = default

PayloadType(PayloadType&&) = default

PayloadType &operator=(const PayloadType&) = default

PayloadType &operator=(PayloadType&&) = default

virtual size_t toBytes(const T &val, void *outputBuffer, size_t size) = 0

virtual bool fromBytes(T &outputVar, const void *buffer, size_t size) = 0

template<typename T>
struct Record

Public Functions

Record() = default

template<typename ...U>
inline Record(Key pKey, U&&... args)

Public Members

Key key

T value

template<typename T>
class RecordsSet

Public Types

using iterator = typename container::const_iterator

using const_iterator = typename container::const_iterator

Public Functions

inline iterator begin()

inline iterator end()

inline const_iterator begin() const

inline const_iterator end() const

inline const_iterator cbegin() const

inline const_iterator cend() const

template<typename ...U>
inline void append(U&&... args)

inline size_t size() const

Private Types

using container = std::vector<Record<T>>

Private Members

container mRecords

class Response

Subclassed by tstorage::ResponseAcq

Public Functions

inline Response(result_t status)

inline operator bool() const

inline result_t status() const

inline bool success() const

inline bool error() const

Private Members

result_t mStatus

class ResponseAcq : public tstorage::Response

Subclassed by tstorage::ResponseGet< T >

Public Functions

inline ResponseAcq(result_t errorCode)

inline ResponseAcq(result_t statusCode, int64_t acq)

inline int64_t acq() const

Private Members

int64_t mAcq

template<typename T>
class ResponseGet : public tstorage::ResponseAcq

Public Functions

inline ResponseGet(result_t errorCode)

inline ResponseGet(result_t statusCode, const RecordsSet<T> &records, int64_t acq)

inline ResponseGet(result_t statusCode, RecordsSet<T> &&records, int64_t acq)

inline RecordsSet<T> &records()

inline const RecordsSet<T> &records() const

Private Members

RecordsSet<T> mResponse

namespace tstorage

Enums

enum class result_t : int32_t

Values:

enumerator OK

enumerator ERROR

namespace Timestamp

Typedefs

template<typename UnitT = std::chrono::seconds>
using UnixTime = std::chrono::time_point<std::chrono::system_clock, UnitT>

Functions

template<typename UnitT = std::chrono::seconds>
UnixTime<UnitT> toUnix(int64_t tstorageTimestamp)

template<typename UnitT = std::chrono::seconds>
int64_t fromUnix(UnixTime<UnitT> unixTimestamp)

int64_t now()

file Channel.h

#include <chrono>

#include <functional>

#include <memory>

#include <string>

#include “PayloadType.h”

#include “Response.h”

#include “ResponseAcq.h”

#include “ResponseGet.h”

file DataTypes.h

#include <cstdint>

#include <utility>

#include “Timestamp.h”

file PayloadType.h

#include <cstddef>

file RecordsSet.h

#include <vector>

#include “DataTypes.h”

file Response.h

#include “DataTypes.h”

file ResponseAcq.h

#include “DataTypes.h”

#include “Response.h”

file ResponseGet.h

#include “DataTypes.h”

#include “RecordsSet.h”

#include “ResponseAcq.h”

file Timestamp.h

#include <chrono>

#include <cstdint>

dir libtstorageclient++/include

dir libtstorageclient++

dir libtstorageclient++/include/tstorageclient++