vecDef.h

Go to the documentation of this file.

/* SPDX-License-Identifier: LGPL-3.0-or-later
   SPDX-FileCopyrightText: Copyright © 2022 Erez Geva <ErezGeva2@gmail.com> */
 
#ifndef __PTPMGMT_VEC_DEF_H
#define __PTPMGMT_VEC_DEF_H
 
#include "mngTlvs.h"
#include "sigTlvs.h"
 
__PTPMGMT_NAMESPACE_BEGIN
 
class FaultRecord_v
{
  private:
    std::vector<FaultRecord_t> elements;
  public:
    FaultRecord_v();
    FaultRecord_v(size_t size);
    FaultRecord_v(size_t size, const FaultRecord_t &value);
    FaultRecord_v(const FaultRecord_v &container);
    size_t size() const;
    bool empty() const;
    void clear();
    void push(const FaultRecord_t &value);
    FaultRecord_t pop();
    void pop_back();
    FaultRecord_t back();
    FaultRecord_t front();
    FaultRecord_t &get(size_t position) const;
    void set(size_t position, FaultRecord_t &value);
    FaultRecord_t &operator[](size_t position);
    size_t capacity() const;
    void reserve(size_t new_cap);
    size_t max_size() const;
};
class ClockIdentity_v
{
  private:
    std::vector<ClockIdentity_t> elements;
  public:
    ClockIdentity_v();
    ClockIdentity_v(size_t size);
    ClockIdentity_v(size_t size, const ClockIdentity_t &value);
    ClockIdentity_v(const ClockIdentity_v &container);
    size_t size() const;
    bool empty() const;
    void clear();
    void push(const ClockIdentity_t &value);
    ClockIdentity_t pop();
    void pop_back();
    ClockIdentity_t back();
    ClockIdentity_t front();
    ClockIdentity_t &get(size_t position) const;
    void set(size_t position, ClockIdentity_t &value);
    ClockIdentity_t &operator[](size_t position);
    size_t capacity() const;
    void reserve(size_t new_cap);
    size_t max_size() const;
};
class PortAddress_v
{
  private:
    std::vector<PortAddress_t> elements;
  public:
    PortAddress_v();
    PortAddress_v(size_t size);
    PortAddress_v(size_t size, const PortAddress_t &value);
    PortAddress_v(const PortAddress_v &container);
    size_t size() const;
    bool empty() const;
    void clear();
    void push(const PortAddress_t &value);
    PortAddress_t pop();
    void pop_back();
    PortAddress_t back();
    PortAddress_t front();
    PortAddress_t &get(size_t position) const;
    void set(size_t position, PortAddress_t &value);
    PortAddress_t &operator[](size_t position);
    size_t capacity() const;
    void reserve(size_t new_cap);
    size_t max_size() const;
};
class AcceptableMaster_v
{
  private:
    std::vector<AcceptableMaster_t> elements;
  public:
    AcceptableMaster_v();
    AcceptableMaster_v(size_t size);
    AcceptableMaster_v(size_t size, const AcceptableMaster_t &value);
    AcceptableMaster_v(const AcceptableMaster_v &container);
    size_t size() const;
    bool empty() const;
    void clear();
    void push(const AcceptableMaster_t &value);
    AcceptableMaster_t pop();
    void pop_back();
    AcceptableMaster_t back();
    AcceptableMaster_t front();
    AcceptableMaster_t &get(size_t position) const;
    void set(size_t position, AcceptableMaster_t &value);
    AcceptableMaster_t &operator[](size_t position);
    size_t capacity() const;
    void reserve(size_t new_cap);
    size_t max_size() const;
};
class LinuxptpUnicastMaster_v
{
  private:
    std::vector<LinuxptpUnicastMaster_t> elements;
  public:
    LinuxptpUnicastMaster_v();
    LinuxptpUnicastMaster_v(size_t size);
    LinuxptpUnicastMaster_v(size_t size, const LinuxptpUnicastMaster_t &value);
    LinuxptpUnicastMaster_v(const LinuxptpUnicastMaster_v &container);
    size_t size() const;
    bool empty() const;
    void clear();
    void push(const LinuxptpUnicastMaster_t &value);
    LinuxptpUnicastMaster_t pop();
    void pop_back();
    LinuxptpUnicastMaster_t back();
    LinuxptpUnicastMaster_t front();
    LinuxptpUnicastMaster_t &get(size_t position) const;
    void set(size_t position, LinuxptpUnicastMaster_t &value);
    LinuxptpUnicastMaster_t &operator[](size_t position);
    size_t capacity() const;
    void reserve(size_t new_cap);
    size_t max_size() const;
};
class PtpEvent_v
{
  private:
    std::vector<PtpEvent_t> elements;
  public:
    PtpEvent_v();
    PtpEvent_v(size_t size);
    PtpEvent_v(size_t size, const PtpEvent_t &value);
    PtpEvent_v(const PtpEvent_v &container);
    size_t size() const;
    bool empty() const;
    void clear();
    void push(const PtpEvent_t &value);
    PtpEvent_t pop();
    void pop_back();
    PtpEvent_t back();
    PtpEvent_t front();
    PtpEvent_t &get(size_t position) const;
    void set(size_t position, PtpEvent_t &value);
    PtpEvent_t &operator[](size_t position);
    size_t capacity() const;
    void reserve(size_t new_cap);
    size_t max_size() const;
};
class PtpSample_v
{
  private:
    std::vector<PtpSample_t> elements;
  public:
    PtpSample_v();
    PtpSample_v(size_t size);
    PtpSample_v(size_t size, const PtpSample_t &value);
    PtpSample_v(const PtpSample_v &container);
    size_t size() const;
    bool empty() const;
    void clear();
    void push(const PtpSample_t &value);
    PtpSample_t pop();
    void pop_back();
    PtpSample_t back();
    PtpSample_t front();
    PtpSample_t &get(size_t position) const;
    void set(size_t position, PtpSample_t &value);
    PtpSample_t &operator[](size_t position);
    size_t capacity() const;
    void reserve(size_t new_cap);
    size_t max_size() const;
};
class PtpSampleExt_v
{
  private:
    std::vector<PtpSampleExt_t> elements;
  public:
    PtpSampleExt_v();
    PtpSampleExt_v(size_t size);
    PtpSampleExt_v(size_t size, const PtpSampleExt_t &value);
    PtpSampleExt_v(const PtpSampleExt_v &container);
    size_t size() const;
    bool empty() const;
    void clear();
    void push(const PtpSampleExt_t &value);
    PtpSampleExt_t pop();
    void pop_back();
    PtpSampleExt_t back();
    PtpSampleExt_t front();
    PtpSampleExt_t &get(size_t position) const;
    void set(size_t position, PtpSampleExt_t &value);
    PtpSampleExt_t &operator[](size_t position);
    size_t capacity() const;
    void reserve(size_t new_cap);
    size_t max_size() const;
};
class SigTime
{
  private:
    std::vector<SLAVE_RX_SYNC_TIMING_DATA_rec_t> elements;
  public:
    SigTime();
    SigTime(size_t size);
    SigTime(size_t size, const SLAVE_RX_SYNC_TIMING_DATA_rec_t &value);
    SigTime(const SigTime &container);
    size_t size() const;
    bool empty() const;
    void clear();
    void push(const SLAVE_RX_SYNC_TIMING_DATA_rec_t &value);
    SLAVE_RX_SYNC_TIMING_DATA_rec_t pop();
    void pop_back();
    SLAVE_RX_SYNC_TIMING_DATA_rec_t back();
    SLAVE_RX_SYNC_TIMING_DATA_rec_t front();
    SLAVE_RX_SYNC_TIMING_DATA_rec_t &get(size_t position) const;
    void set(size_t position, SLAVE_RX_SYNC_TIMING_DATA_rec_t &value);
    SLAVE_RX_SYNC_TIMING_DATA_rec_t &operator[](size_t position);
    size_t capacity() const;
    void reserve(size_t new_cap);
    size_t max_size() const;
};
class SigComp
{
  private:
    std::vector<SLAVE_RX_SYNC_COMPUTED_DATA_rec_t> elements;
  public:
    SigComp();
    SigComp(size_t size);
    SigComp(size_t size, const SLAVE_RX_SYNC_COMPUTED_DATA_rec_t &value);
    SigComp(const SigComp &container);
    size_t size() const;
    bool empty() const;
    void clear();
    void push(const SLAVE_RX_SYNC_COMPUTED_DATA_rec_t &value);
    SLAVE_RX_SYNC_COMPUTED_DATA_rec_t pop();
    void pop_back();
    SLAVE_RX_SYNC_COMPUTED_DATA_rec_t back();
    SLAVE_RX_SYNC_COMPUTED_DATA_rec_t front();
    SLAVE_RX_SYNC_COMPUTED_DATA_rec_t &get(size_t position) const;
    void set(size_t position, SLAVE_RX_SYNC_COMPUTED_DATA_rec_t &value);
    SLAVE_RX_SYNC_COMPUTED_DATA_rec_t &operator[](size_t position);
    size_t capacity() const;
    void reserve(size_t new_cap);
    size_t max_size() const;
};
class SigEvent
{
  private:
    std::vector<SLAVE_TX_EVENT_TIMESTAMPS_rec_t> elements;
  public:
    SigEvent();
    SigEvent(size_t size);
    SigEvent(size_t size, const SLAVE_TX_EVENT_TIMESTAMPS_rec_t &value);
    SigEvent(const SigEvent &container);
    size_t size() const;
    bool empty() const;
    void clear();
    void push(const SLAVE_TX_EVENT_TIMESTAMPS_rec_t &value);
    SLAVE_TX_EVENT_TIMESTAMPS_rec_t pop();
    void pop_back();
    SLAVE_TX_EVENT_TIMESTAMPS_rec_t back();
    SLAVE_TX_EVENT_TIMESTAMPS_rec_t front();
    SLAVE_TX_EVENT_TIMESTAMPS_rec_t &get(size_t position) const;
    void set(size_t position, SLAVE_TX_EVENT_TIMESTAMPS_rec_t &value);
    SLAVE_TX_EVENT_TIMESTAMPS_rec_t &operator[](size_t position);
    size_t capacity() const;
    void reserve(size_t new_cap);
    size_t max_size() const;
};
class SigDelay
{
  private:
    std::vector<SLAVE_DELAY_TIMING_DATA_NP_rec_t> elements;
  public:
    SigDelay();
    SigDelay(size_t size);
    SigDelay(size_t size, const SLAVE_DELAY_TIMING_DATA_NP_rec_t &value);
    SigDelay(const SigDelay &container);
    size_t size() const;
    bool empty() const;
    void clear();
    void push(const SLAVE_DELAY_TIMING_DATA_NP_rec_t &value);
    SLAVE_DELAY_TIMING_DATA_NP_rec_t pop();
    void pop_back();
    SLAVE_DELAY_TIMING_DATA_NP_rec_t back();
    SLAVE_DELAY_TIMING_DATA_NP_rec_t front();
    SLAVE_DELAY_TIMING_DATA_NP_rec_t &get(size_t position) const;
    void set(size_t position, SLAVE_DELAY_TIMING_DATA_NP_rec_t &value);
    SLAVE_DELAY_TIMING_DATA_NP_rec_t &operator[](size_t position);
    size_t capacity() const;
    void reserve(size_t new_cap);
    size_t max_size() const;
};
 
__PTPMGMT_NAMESPACE_END
 
#endif /* __PTPMGMT_VEC_DEF_H */