#include <modbuscpp/details/data-table.hpp>
template<template<class...> class base_container_t, typename data_t, typename read_count_t, typename write_count_t>
modbus::block::base class

base block class

Template parameters
base_container_t base container type
data_t data type
read_count_t
write_count_t

Contents

Public types

using data_type = data_t
using container_type = base_container_t<data_type>
using mutable_iterator_type = container_type::iterator
using iterator_type = container_type::const_iterator
using slice_type = std::pair<iterator_type, iterator_type>
using mutable_slice_type = std::pair<mutable_iterator_type, mutable_iterator_type>
using size_type = container_type::size_type
using data_reference = container_type::reference
using const_data_reference = container_type::const_reference

Public static variables

static size_type max_capacity constexpr

Constructors, destructors, conversion operators

base(const address_t& starting_address, size_type capacity = max_capacity, data_type default_value = 0) explicit noexcept
base(const address_t& starting_address, const container_type& container) explicit noexcept

Public functions

auto ref(const address_t& address) -> data_reference pure virtual
auto ref(const address_t& address, size_type count) -> mutable_slice_type pure virtual
auto get(const address_t& address, const read_count_t& count) const -> slice_type pure virtual
auto get(const address_t& address) const -> const_data_reference pure virtual
void set(const address_t& address, const container_type& buffer) pure virtual
void set(const address_t& address, data_t value) pure virtual
void reset() pure virtual
auto validate(const address_t& address) const -> bool virtual
auto validate(const address_t& address, const read_count_t& count) const -> bool virtual
auto validate(const address_t& address, const write_count_t& count) const -> bool virtual
auto validate_sz(const address_t& address, size_type count = 1) const -> bool virtual
auto starting_address() const -> const address_t&
auto container() -> container_type&
auto container() const -> const container_type&
auto default_value() const -> const data_t&
auto capacity() const -> size_type virtual

Protected variables

std::shared_mutex mutex_
const address_t starting_address_
container_type container_
const size_type capacity_
const data_t default_value_

Friends

template<typename ostream>
auto operator<<(ostream& os, const base& obj) -> ostream&

Typedef documentation

template<template<class...> class base_container_t, typename data_t, typename read_count_t, typename write_count_t>
typedef data_t modbus::block::base<base_container_t, data_t, read_count_t, write_count_t>::data_type

Data type

template<template<class...> class base_container_t, typename data_t, typename read_count_t, typename write_count_t>
typedef base_container_t<data_type> modbus::block::base<base_container_t, data_t, read_count_t, write_count_t>::container_type

Container type

template<template<class...> class base_container_t, typename data_t, typename read_count_t, typename write_count_t>
typedef container_type::iterator modbus::block::base<base_container_t, data_t, read_count_t, write_count_t>::mutable_iterator_type

Mutable iterator type

template<template<class...> class base_container_t, typename data_t, typename read_count_t, typename write_count_t>
typedef container_type::const_iterator modbus::block::base<base_container_t, data_t, read_count_t, write_count_t>::iterator_type

Iterator type

template<template<class...> class base_container_t, typename data_t, typename read_count_t, typename write_count_t>
typedef std::pair<iterator_type, iterator_type> modbus::block::base<base_container_t, data_t, read_count_t, write_count_t>::slice_type

Slice type

Containing begin and end that denotes slice of container

template<template<class...> class base_container_t, typename data_t, typename read_count_t, typename write_count_t>
typedef std::pair<mutable_iterator_type, mutable_iterator_type> modbus::block::base<base_container_t, data_t, read_count_t, write_count_t>::mutable_slice_type

Mutable slice type

Containing begin and end that denotes mutable slice of container

template<template<class...> class base_container_t, typename data_t, typename read_count_t, typename write_count_t>
typedef container_type::size_type modbus::block::base<base_container_t, data_t, read_count_t, write_count_t>::size_type

Size type

template<template<class...> class base_container_t, typename data_t, typename read_count_t, typename write_count_t>
typedef container_type::reference modbus::block::base<base_container_t, data_t, read_count_t, write_count_t>::data_reference

Reference

template<template<class...> class base_container_t, typename data_t, typename read_count_t, typename write_count_t>
typedef container_type::const_reference modbus::block::base<base_container_t, data_t, read_count_t, write_count_t>::const_data_reference

Const reference

Function documentation

template<template<class...> class base_container_t, typename data_t, typename read_count_t, typename write_count_t>
modbus::block::base<base_container_t, data_t, read_count_t, write_count_t>::base(const address_t& starting_address, size_type capacity = max_capacity, data_type default_value = 0) explicit noexcept

Parameters
starting_address starting address of container
capacity
default_value default value of container

Base constructor

base block

template<template<class...> class base_container_t, typename data_t, typename read_count_t, typename write_count_t>
modbus::block::base<base_container_t, data_t, read_count_t, write_count_t>::base(const address_t& starting_address, const container_type& container) explicit noexcept

Parameters
starting_address starting address of container
container container initializer

Base constructor

template<template<class...> class base_container_t, typename data_t, typename read_count_t, typename write_count_t>
data_reference modbus::block::base<base_container_t, data_t, read_count_t, write_count_t>::ref(const address_t& address) pure virtual

Parameters
address look-up address
Returns reference of single data from container

Get reference of single data from container

template<template<class...> class base_container_t, typename data_t, typename read_count_t, typename write_count_t>
mutable_slice_type modbus::block::base<base_container_t, data_t, read_count_t, write_count_t>::ref(const address_t& address, size_type count) pure virtual

Parameters
address look-up address
count number of slice
Returns pair of mutable iterator (begin and end) slice of data from container

Get reference of data from container

template<template<class...> class base_container_t, typename data_t, typename read_count_t, typename write_count_t>
slice_type modbus::block::base<base_container_t, data_t, read_count_t, write_count_t>::get(const address_t& address, const read_count_t& count) const pure virtual

Parameters
address look-up address
count number of slice
Returns pair of iterator (begin and end) slice of data from container

Get slice of data from container

template<template<class...> class base_container_t, typename data_t, typename read_count_t, typename write_count_t>
const_data_reference modbus::block::base<base_container_t, data_t, read_count_t, write_count_t>::get(const address_t& address) const pure virtual

Parameters
address starting address
Returns single value from container

Get single value from container

template<template<class...> class base_container_t, typename data_t, typename read_count_t, typename write_count_t>
void modbus::block::base<base_container_t, data_t, read_count_t, write_count_t>::set(const address_t& address, const container_type& buffer) pure virtual

Parameters
address look-up address
buffer

Set slice of data from container

template<template<class...> class base_container_t, typename data_t, typename read_count_t, typename write_count_t>
void modbus::block::base<base_container_t, data_t, read_count_t, write_count_t>::set(const address_t& address, data_t value) pure virtual

Parameters
address look-up address
value value to add

Set single data to container at specific address

template<template<class...> class base_container_t, typename data_t, typename read_count_t, typename write_count_t>
void modbus::block::base<base_container_t, data_t, read_count_t, write_count_t>::reset() pure virtual

Reset container

template<template<class...> class base_container_t, typename data_t, typename read_count_t, typename write_count_t>
bool modbus::block::base<base_container_t, data_t, read_count_t, write_count_t>::validate(const address_t& address) const virtual

Parameters
address look-up address

Validate address with only 1 amount of data

template<template<class...> class base_container_t, typename data_t, typename read_count_t, typename write_count_t>
bool modbus::block::base<base_container_t, data_t, read_count_t, write_count_t>::validate(const address_t& address, const read_count_t& count) const virtual

Parameters
address look-up address
count number of slice

Validate with read_count_t

template<template<class...> class base_container_t, typename data_t, typename read_count_t, typename write_count_t>
bool modbus::block::base<base_container_t, data_t, read_count_t, write_count_t>::validate(const address_t& address, const write_count_t& count) const virtual

Parameters
address look-up address
count number of slice

Validate with write_count_t

template<template<class...> class base_container_t, typename data_t, typename read_count_t, typename write_count_t>
bool modbus::block::base<base_container_t, data_t, read_count_t, write_count_t>::validate_sz(const address_t& address, size_type count = 1) const virtual

Parameters
address look-up address
count number of slice

Validate size type

template<template<class...> class base_container_t, typename data_t, typename read_count_t, typename write_count_t>
const address_t& modbus::block::base<base_container_t, data_t, read_count_t, write_count_t>::starting_address() const

Returns starting address

Get starting address

template<template<class...> class base_container_t, typename data_t, typename read_count_t, typename write_count_t>
container_type& modbus::block::base<base_container_t, data_t, read_count_t, write_count_t>::container()

Returns container

Get container

template<template<class...> class base_container_t, typename data_t, typename read_count_t, typename write_count_t>
const container_type& modbus::block::base<base_container_t, data_t, read_count_t, write_count_t>::container() const

Returns container (const)

Get container (const)

template<template<class...> class base_container_t, typename data_t, typename read_count_t, typename write_count_t>
const data_t& modbus::block::base<base_container_t, data_t, read_count_t, write_count_t>::default_value() const

Returns default value

Get default value

template<template<class...> class base_container_t, typename data_t, typename read_count_t, typename write_count_t>
size_type modbus::block::base<base_container_t, data_t, read_count_t, write_count_t>::capacity() const virtual

Returns capacity

Get capacity

template<template<class...> class base_container_t, typename data_t, typename read_count_t, typename write_count_t> template<typename ostream>
ostream& operator<<(ostream& os, const base& obj)

Parameters
os ostream
obj base instance
Returns stream

Ostream operator

Variable documentation

template<template<class...> class base_container_t, typename data_t, typename read_count_t, typename write_count_t>
static size_type modbus::block::base<base_container_t, data_t, read_count_t, write_count_t>::max_capacity constexpr

Max capacity

template<template<class...> class base_container_t, typename data_t, typename read_count_t, typename write_count_t>
std::shared_mutex modbus::block::base<base_container_t, data_t, read_count_t, write_count_t>::mutex_ protected

Mutex

template<template<class...> class base_container_t, typename data_t, typename read_count_t, typename write_count_t>
const address_t modbus::block::base<base_container_t, data_t, read_count_t, write_count_t>::starting_address_ protected

Starting address of container

template<template<class...> class base_container_t, typename data_t, typename read_count_t, typename write_count_t>
container_type modbus::block::base<base_container_t, data_t, read_count_t, write_count_t>::container_ protected

Container

template<template<class...> class base_container_t, typename data_t, typename read_count_t, typename write_count_t>
const size_type modbus::block::base<base_container_t, data_t, read_count_t, write_count_t>::capacity_ protected

Capacity

template<template<class...> class base_container_t, typename data_t, typename read_count_t, typename write_count_t>
const data_t modbus::block::base<base_container_t, data_t, read_count_t, write_count_t>::default_value_ protected

Default value