callDef.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_CALL_DEFS_H
#define __PTPMGMT_CALL_DEFS_H
 
#ifdef __cplusplus
#include "msg.h"
 
__PTPMGMT_NAMESPACE_BEGIN
 
class BaseMngDispatchCallback
{
  private:
    bool _nc; 
  protected:
    /* To improve backward compatibility
       Call virtual functions here in this inline function,
       so we compile it in the application
       and avoid using virtual function table in the library code */
    const char *iCallHandler(const Message &msg, mng_vals_e tlv_id,
        const BaseMngTlv *tlv) {
        const char *idStr = nullptr;
        _nc = false;
        switch(tlv_id) {
            case CLOCK_DESCRIPTION: {
                idStr = "CLOCK_DESCRIPTION";
                auto d = dynamic_cast
                    <const CLOCK_DESCRIPTION_t *>(tlv);
                if(d != nullptr)
                    CLOCK_DESCRIPTION_h(msg, *d, idStr);
                break;
            }
            case USER_DESCRIPTION: {
                idStr = "USER_DESCRIPTION";
                auto d = dynamic_cast
                    <const USER_DESCRIPTION_t *>(tlv);
                if(d != nullptr)
                    USER_DESCRIPTION_h(msg, *d, idStr);
                break;
            }
            case INITIALIZE: {
                idStr = "INITIALIZE";
                auto d = dynamic_cast
                    <const INITIALIZE_t *>(tlv);
                if(d != nullptr)
                    INITIALIZE_h(msg, *d, idStr);
                break;
            }
            case FAULT_LOG: {
                idStr = "FAULT_LOG";
                auto d = dynamic_cast
                    <const FAULT_LOG_t *>(tlv);
                if(d != nullptr)
                    FAULT_LOG_h(msg, *d, idStr);
                break;
            }
            case DEFAULT_DATA_SET: {
                idStr = "DEFAULT_DATA_SET";
                auto d = dynamic_cast
                    <const DEFAULT_DATA_SET_t *>(tlv);
                if(d != nullptr)
                    DEFAULT_DATA_SET_h(msg, *d, idStr);
                break;
            }
            case CURRENT_DATA_SET: {
                idStr = "CURRENT_DATA_SET";
                auto d = dynamic_cast
                    <const CURRENT_DATA_SET_t *>(tlv);
                if(d != nullptr)
                    CURRENT_DATA_SET_h(msg, *d, idStr);
                break;
            }
            case PARENT_DATA_SET: {
                idStr = "PARENT_DATA_SET";
                auto d = dynamic_cast
                    <const PARENT_DATA_SET_t *>(tlv);
                if(d != nullptr)
                    PARENT_DATA_SET_h(msg, *d, idStr);
                break;
            }
            case TIME_PROPERTIES_DATA_SET: {
                idStr = "TIME_PROPERTIES_DATA_SET";
                auto d = dynamic_cast
                    <const TIME_PROPERTIES_DATA_SET_t *>(tlv);
                if(d != nullptr)
                    TIME_PROPERTIES_DATA_SET_h(msg, *d, idStr);
                break;
            }
            case PORT_DATA_SET: {
                idStr = "PORT_DATA_SET";
                auto d = dynamic_cast
                    <const PORT_DATA_SET_t *>(tlv);
                if(d != nullptr)
                    PORT_DATA_SET_h(msg, *d, idStr);
                break;
            }
            case PRIORITY1: {
                idStr = "PRIORITY1";
                auto d = dynamic_cast
                    <const PRIORITY1_t *>(tlv);
                if(d != nullptr)
                    PRIORITY1_h(msg, *d, idStr);
                break;
            }
            case PRIORITY2: {
                idStr = "PRIORITY2";
                auto d = dynamic_cast
                    <const PRIORITY2_t *>(tlv);
                if(d != nullptr)
                    PRIORITY2_h(msg, *d, idStr);
                break;
            }
            case DOMAIN: {
                idStr = "DOMAIN";
                auto d = dynamic_cast
                    <const DOMAIN_t *>(tlv);
                if(d != nullptr)
                    DOMAIN_h(msg, *d, idStr);
                break;
            }
            case SLAVE_ONLY: {
                idStr = "SLAVE_ONLY";
                auto d = dynamic_cast
                    <const SLAVE_ONLY_t *>(tlv);
                if(d != nullptr)
                    SLAVE_ONLY_h(msg, *d, idStr);
                break;
            }
            case LOG_ANNOUNCE_INTERVAL: {
                idStr = "LOG_ANNOUNCE_INTERVAL";
                auto d = dynamic_cast
                    <const LOG_ANNOUNCE_INTERVAL_t *>(tlv);
                if(d != nullptr)
                    LOG_ANNOUNCE_INTERVAL_h(msg, *d, idStr);
                break;
            }
            case ANNOUNCE_RECEIPT_TIMEOUT: {
                idStr = "ANNOUNCE_RECEIPT_TIMEOUT";
                auto d = dynamic_cast
                    <const ANNOUNCE_RECEIPT_TIMEOUT_t *>(tlv);
                if(d != nullptr)
                    ANNOUNCE_RECEIPT_TIMEOUT_h(msg, *d, idStr);
                break;
            }
            case LOG_SYNC_INTERVAL: {
                idStr = "LOG_SYNC_INTERVAL";
                auto d = dynamic_cast
                    <const LOG_SYNC_INTERVAL_t *>(tlv);
                if(d != nullptr)
                    LOG_SYNC_INTERVAL_h(msg, *d, idStr);
                break;
            }
            case VERSION_NUMBER: {
                idStr = "VERSION_NUMBER";
                auto d = dynamic_cast
                    <const VERSION_NUMBER_t *>(tlv);
                if(d != nullptr)
                    VERSION_NUMBER_h(msg, *d, idStr);
                break;
            }
            case TIME: {
                idStr = "TIME";
                auto d = dynamic_cast
                    <const TIME_t *>(tlv);
                if(d != nullptr)
                    TIME_h(msg, *d, idStr);
                break;
            }
            case CLOCK_ACCURACY: {
                idStr = "CLOCK_ACCURACY";
                auto d = dynamic_cast
                    <const CLOCK_ACCURACY_t *>(tlv);
                if(d != nullptr)
                    CLOCK_ACCURACY_h(msg, *d, idStr);
                break;
            }
            case UTC_PROPERTIES: {
                idStr = "UTC_PROPERTIES";
                auto d = dynamic_cast
                    <const UTC_PROPERTIES_t *>(tlv);
                if(d != nullptr)
                    UTC_PROPERTIES_h(msg, *d, idStr);
                break;
            }
            case TRACEABILITY_PROPERTIES: {
                idStr = "TRACEABILITY_PROPERTIES";
                auto d = dynamic_cast
                    <const TRACEABILITY_PROPERTIES_t *>(tlv);
                if(d != nullptr)
                    TRACEABILITY_PROPERTIES_h(msg, *d, idStr);
                break;
            }
            case TIMESCALE_PROPERTIES: {
                idStr = "TIMESCALE_PROPERTIES";
                auto d = dynamic_cast
                    <const TIMESCALE_PROPERTIES_t *>(tlv);
                if(d != nullptr)
                    TIMESCALE_PROPERTIES_h(msg, *d, idStr);
                break;
            }
            case UNICAST_NEGOTIATION_ENABLE: {
                idStr = "UNICAST_NEGOTIATION_ENABLE";
                auto d = dynamic_cast
                    <const UNICAST_NEGOTIATION_ENABLE_t *>(tlv);
                if(d != nullptr)
                    UNICAST_NEGOTIATION_ENABLE_h(msg, *d, idStr);
                break;
            }
            case PATH_TRACE_LIST: {
                idStr = "PATH_TRACE_LIST";
                auto d = dynamic_cast
                    <const PATH_TRACE_LIST_t *>(tlv);
                if(d != nullptr)
                    PATH_TRACE_LIST_h(msg, *d, idStr);
                break;
            }
            case PATH_TRACE_ENABLE: {
                idStr = "PATH_TRACE_ENABLE";
                auto d = dynamic_cast
                    <const PATH_TRACE_ENABLE_t *>(tlv);
                if(d != nullptr)
                    PATH_TRACE_ENABLE_h(msg, *d, idStr);
                break;
            }
            case GRANDMASTER_CLUSTER_TABLE: {
                idStr = "GRANDMASTER_CLUSTER_TABLE";
                auto d = dynamic_cast
                    <const GRANDMASTER_CLUSTER_TABLE_t *>(tlv);
                if(d != nullptr)
                    GRANDMASTER_CLUSTER_TABLE_h(msg, *d, idStr);
                break;
            }
            case UNICAST_MASTER_TABLE: {
                idStr = "UNICAST_MASTER_TABLE";
                auto d = dynamic_cast
                    <const UNICAST_MASTER_TABLE_t *>(tlv);
                if(d != nullptr)
                    UNICAST_MASTER_TABLE_h(msg, *d, idStr);
                break;
            }
            case UNICAST_MASTER_MAX_TABLE_SIZE: {
                idStr = "UNICAST_MASTER_MAX_TABLE_SIZE";
                auto d = dynamic_cast
                    <const UNICAST_MASTER_MAX_TABLE_SIZE_t *>(tlv);
                if(d != nullptr)
                    UNICAST_MASTER_MAX_TABLE_SIZE_h(msg, *d, idStr);
                break;
            }
            case ACCEPTABLE_MASTER_TABLE: {
                idStr = "ACCEPTABLE_MASTER_TABLE";
                auto d = dynamic_cast
                    <const ACCEPTABLE_MASTER_TABLE_t *>(tlv);
                if(d != nullptr)
                    ACCEPTABLE_MASTER_TABLE_h(msg, *d, idStr);
                break;
            }
            case ACCEPTABLE_MASTER_TABLE_ENABLED: {
                idStr = "ACCEPTABLE_MASTER_TABLE_ENABLED";
                auto d = dynamic_cast
                    <const ACCEPTABLE_MASTER_TABLE_ENABLED_t *>(tlv);
                if(d != nullptr)
                    ACCEPTABLE_MASTER_TABLE_ENABLED_h(msg, *d, idStr);
                break;
            }
            case ACCEPTABLE_MASTER_MAX_TABLE_SIZE: {
                idStr = "ACCEPTABLE_MASTER_MAX_TABLE_SIZE";
                auto d = dynamic_cast
                    <const ACCEPTABLE_MASTER_MAX_TABLE_SIZE_t *>(tlv);
                if(d != nullptr)
                    ACCEPTABLE_MASTER_MAX_TABLE_SIZE_h(msg, *d, idStr);
                break;
            }
            case ALTERNATE_MASTER: {
                idStr = "ALTERNATE_MASTER";
                auto d = dynamic_cast
                    <const ALTERNATE_MASTER_t *>(tlv);
                if(d != nullptr)
                    ALTERNATE_MASTER_h(msg, *d, idStr);
                break;
            }
            case ALTERNATE_TIME_OFFSET_ENABLE: {
                idStr = "ALTERNATE_TIME_OFFSET_ENABLE";
                auto d = dynamic_cast
                    <const ALTERNATE_TIME_OFFSET_ENABLE_t *>(tlv);
                if(d != nullptr)
                    ALTERNATE_TIME_OFFSET_ENABLE_h(msg, *d, idStr);
                break;
            }
            case ALTERNATE_TIME_OFFSET_NAME: {
                idStr = "ALTERNATE_TIME_OFFSET_NAME";
                auto d = dynamic_cast
                    <const ALTERNATE_TIME_OFFSET_NAME_t *>(tlv);
                if(d != nullptr)
                    ALTERNATE_TIME_OFFSET_NAME_h(msg, *d, idStr);
                break;
            }
            case ALTERNATE_TIME_OFFSET_MAX_KEY: {
                idStr = "ALTERNATE_TIME_OFFSET_MAX_KEY";
                auto d = dynamic_cast
                    <const ALTERNATE_TIME_OFFSET_MAX_KEY_t *>(tlv);
                if(d != nullptr)
                    ALTERNATE_TIME_OFFSET_MAX_KEY_h(msg, *d, idStr);
                break;
            }
            case ALTERNATE_TIME_OFFSET_PROPERTIES: {
                idStr = "ALTERNATE_TIME_OFFSET_PROPERTIES";
                auto d = dynamic_cast
                    <const ALTERNATE_TIME_OFFSET_PROPERTIES_t *>(tlv);
                if(d != nullptr)
                    ALTERNATE_TIME_OFFSET_PROPERTIES_h(msg, *d, idStr);
                break;
            }
            case TRANSPARENT_CLOCK_PORT_DATA_SET: {
                idStr = "TRANSPARENT_CLOCK_PORT_DATA_SET";
                auto d = dynamic_cast
                    <const TRANSPARENT_CLOCK_PORT_DATA_SET_t *>(tlv);
                if(d != nullptr)
                    TRANSPARENT_CLOCK_PORT_DATA_SET_h(msg, *d, idStr);
                break;
            }
            case LOG_MIN_PDELAY_REQ_INTERVAL: {
                idStr = "LOG_MIN_PDELAY_REQ_INTERVAL";
                auto d = dynamic_cast
                    <const LOG_MIN_PDELAY_REQ_INTERVAL_t *>(tlv);
                if(d != nullptr)
                    LOG_MIN_PDELAY_REQ_INTERVAL_h(msg, *d, idStr);
                break;
            }
            case TRANSPARENT_CLOCK_DEFAULT_DATA_SET: {
                idStr = "TRANSPARENT_CLOCK_DEFAULT_DATA_SET";
                auto d = dynamic_cast
                    <const TRANSPARENT_CLOCK_DEFAULT_DATA_SET_t *>(tlv);
                if(d != nullptr)
                    TRANSPARENT_CLOCK_DEFAULT_DATA_SET_h(msg, *d, idStr);
                break;
            }
            case PRIMARY_DOMAIN: {
                idStr = "PRIMARY_DOMAIN";
                auto d = dynamic_cast
                    <const PRIMARY_DOMAIN_t *>(tlv);
                if(d != nullptr)
                    PRIMARY_DOMAIN_h(msg, *d, idStr);
                break;
            }
            case DELAY_MECHANISM: {
                idStr = "DELAY_MECHANISM";
                auto d = dynamic_cast
                    <const DELAY_MECHANISM_t *>(tlv);
                if(d != nullptr)
                    DELAY_MECHANISM_h(msg, *d, idStr);
                break;
            }
            case EXTERNAL_PORT_CONFIGURATION_ENABLED: {
                idStr = "EXTERNAL_PORT_CONFIGURATION_ENABLED";
                auto d = dynamic_cast
                    <const EXTERNAL_PORT_CONFIGURATION_ENABLED_t *>(tlv);
                if(d != nullptr)
                    EXTERNAL_PORT_CONFIGURATION_ENABLED_h(msg, *d, idStr);
                break;
            }
            case MASTER_ONLY: {
                idStr = "MASTER_ONLY";
                auto d = dynamic_cast
                    <const MASTER_ONLY_t *>(tlv);
                if(d != nullptr)
                    MASTER_ONLY_h(msg, *d, idStr);
                break;
            }
            case HOLDOVER_UPGRADE_ENABLE: {
                idStr = "HOLDOVER_UPGRADE_ENABLE";
                auto d = dynamic_cast
                    <const HOLDOVER_UPGRADE_ENABLE_t *>(tlv);
                if(d != nullptr)
                    HOLDOVER_UPGRADE_ENABLE_h(msg, *d, idStr);
                break;
            }
            case EXT_PORT_CONFIG_PORT_DATA_SET: {
                idStr = "EXT_PORT_CONFIG_PORT_DATA_SET";
                auto d = dynamic_cast
                    <const EXT_PORT_CONFIG_PORT_DATA_SET_t *>(tlv);
                if(d != nullptr)
                    EXT_PORT_CONFIG_PORT_DATA_SET_h(msg, *d, idStr);
                break;
            }
            case TIME_STATUS_NP: {
                idStr = "TIME_STATUS_NP";
                auto d = dynamic_cast
                    <const TIME_STATUS_NP_t *>(tlv);
                if(d != nullptr)
                    TIME_STATUS_NP_h(msg, *d, idStr);
                break;
            }
            case GRANDMASTER_SETTINGS_NP: {
                idStr = "GRANDMASTER_SETTINGS_NP";
                auto d = dynamic_cast
                    <const GRANDMASTER_SETTINGS_NP_t *>(tlv);
                if(d != nullptr)
                    GRANDMASTER_SETTINGS_NP_h(msg, *d, idStr);
                break;
            }
            case PORT_DATA_SET_NP: {
                idStr = "PORT_DATA_SET_NP";
                auto d = dynamic_cast
                    <const PORT_DATA_SET_NP_t *>(tlv);
                if(d != nullptr)
                    PORT_DATA_SET_NP_h(msg, *d, idStr);
                break;
            }
            case SUBSCRIBE_EVENTS_NP: {
                idStr = "SUBSCRIBE_EVENTS_NP";
                auto d = dynamic_cast
                    <const SUBSCRIBE_EVENTS_NP_t *>(tlv);
                if(d != nullptr)
                    SUBSCRIBE_EVENTS_NP_h(msg, *d, idStr);
                break;
            }
            case PORT_PROPERTIES_NP: {
                idStr = "PORT_PROPERTIES_NP";
                auto d = dynamic_cast
                    <const PORT_PROPERTIES_NP_t *>(tlv);
                if(d != nullptr)
                    PORT_PROPERTIES_NP_h(msg, *d, idStr);
                break;
            }
            case PORT_STATS_NP: {
                idStr = "PORT_STATS_NP";
                auto d = dynamic_cast
                    <const PORT_STATS_NP_t *>(tlv);
                if(d != nullptr)
                    PORT_STATS_NP_h(msg, *d, idStr);
                break;
            }
            case SYNCHRONIZATION_UNCERTAIN_NP: {
                idStr = "SYNCHRONIZATION_UNCERTAIN_NP";
                auto d = dynamic_cast
                    <const SYNCHRONIZATION_UNCERTAIN_NP_t *>(tlv);
                if(d != nullptr)
                    SYNCHRONIZATION_UNCERTAIN_NP_h(msg, *d, idStr);
                break;
            }
            case PORT_SERVICE_STATS_NP: {
                idStr = "PORT_SERVICE_STATS_NP";
                auto d = dynamic_cast
                    <const PORT_SERVICE_STATS_NP_t *>(tlv);
                if(d != nullptr)
                    PORT_SERVICE_STATS_NP_h(msg, *d, idStr);
                break;
            }
            case UNICAST_MASTER_TABLE_NP: {
                idStr = "UNICAST_MASTER_TABLE_NP";
                auto d = dynamic_cast
                    <const UNICAST_MASTER_TABLE_NP_t *>(tlv);
                if(d != nullptr)
                    UNICAST_MASTER_TABLE_NP_h(msg, *d, idStr);
                break;
            }
            case PORT_HWCLOCK_NP: {
                idStr = "PORT_HWCLOCK_NP";
                auto d = dynamic_cast
                    <const PORT_HWCLOCK_NP_t *>(tlv);
                if(d != nullptr)
                    PORT_HWCLOCK_NP_h(msg, *d, idStr);
                break;
            }
            case POWER_PROFILE_SETTINGS_NP: {
                idStr = "POWER_PROFILE_SETTINGS_NP";
                auto d = dynamic_cast
                    <const POWER_PROFILE_SETTINGS_NP_t *>(tlv);
                if(d != nullptr)
                    POWER_PROFILE_SETTINGS_NP_h(msg, *d, idStr);
                break;
            }
            case CMLDS_INFO_NP: {
                idStr = "CMLDS_INFO_NP";
                auto d = dynamic_cast
                    <const CMLDS_INFO_NP_t *>(tlv);
                if(d != nullptr)
                    CMLDS_INFO_NP_h(msg, *d, idStr);
                break;
            }
            case PORT_CORRECTIONS_NP: {
                idStr = "PORT_CORRECTIONS_NP";
                auto d = dynamic_cast
                    <const PORT_CORRECTIONS_NP_t *>(tlv);
                if(d != nullptr)
                    PORT_CORRECTIONS_NP_h(msg, *d, idStr);
                break;
            }
            case EXTERNAL_GRANDMASTER_PROPERTIES_NP: {
                idStr = "EXTERNAL_GRANDMASTER_PROPERTIES_NP";
                auto d = dynamic_cast
                    <const EXTERNAL_GRANDMASTER_PROPERTIES_NP_t *>(tlv);
                if(d != nullptr)
                    EXTERNAL_GRANDMASTER_PROPERTIES_NP_h(msg, *d, idStr);
                break;
            }
            default:
                break;
        }
        return idStr;
    }
    bool isNoTlv() { return _nc; }
  public:
    BaseMngDispatchCallback() = default;
    virtual ~BaseMngDispatchCallback() = default;
    virtual void CLOCK_DESCRIPTION_h(const Message &msg,
        const CLOCK_DESCRIPTION_t &tlv, const char *idStr)
    {_nc = true;}
    virtual void USER_DESCRIPTION_h(const Message &msg,
        const USER_DESCRIPTION_t &tlv, const char *idStr)
    {_nc = true;}
    virtual void INITIALIZE_h(const Message &msg,
        const INITIALIZE_t &tlv, const char *idStr)
    {_nc = true;}
    virtual void FAULT_LOG_h(const Message &msg,
        const FAULT_LOG_t &tlv, const char *idStr)
    {_nc = true;}
    virtual void DEFAULT_DATA_SET_h(const Message &msg,
        const DEFAULT_DATA_SET_t &tlv, const char *idStr)
    {_nc = true;}
    virtual void CURRENT_DATA_SET_h(const Message &msg,
        const CURRENT_DATA_SET_t &tlv, const char *idStr)
    {_nc = true;}
    virtual void PARENT_DATA_SET_h(const Message &msg,
        const PARENT_DATA_SET_t &tlv, const char *idStr)
    {_nc = true;}
    virtual void TIME_PROPERTIES_DATA_SET_h(const Message &msg,
        const TIME_PROPERTIES_DATA_SET_t &tlv, const char *idStr)
    {_nc = true;}
    virtual void PORT_DATA_SET_h(const Message &msg,
        const PORT_DATA_SET_t &tlv, const char *idStr)
    {_nc = true;}
    virtual void PRIORITY1_h(const Message &msg,
        const PRIORITY1_t &tlv, const char *idStr)
    {_nc = true;}
    virtual void PRIORITY2_h(const Message &msg,
        const PRIORITY2_t &tlv, const char *idStr)
    {_nc = true;}
    virtual void DOMAIN_h(const Message &msg,
        const DOMAIN_t &tlv, const char *idStr)
    {_nc = true;}
    virtual void SLAVE_ONLY_h(const Message &msg,
        const SLAVE_ONLY_t &tlv, const char *idStr)
    {_nc = true;}
    virtual void LOG_ANNOUNCE_INTERVAL_h(const Message &msg,
        const LOG_ANNOUNCE_INTERVAL_t &tlv, const char *idStr)
    {_nc = true;}
    virtual void ANNOUNCE_RECEIPT_TIMEOUT_h(const Message &msg,
        const ANNOUNCE_RECEIPT_TIMEOUT_t &tlv, const char *idStr)
    {_nc = true;}
    virtual void LOG_SYNC_INTERVAL_h(const Message &msg,
        const LOG_SYNC_INTERVAL_t &tlv, const char *idStr)
    {_nc = true;}
    virtual void VERSION_NUMBER_h(const Message &msg,
        const VERSION_NUMBER_t &tlv, const char *idStr)
    {_nc = true;}
    virtual void TIME_h(const Message &msg,
        const TIME_t &tlv, const char *idStr)
    {_nc = true;}
    virtual void CLOCK_ACCURACY_h(const Message &msg,
        const CLOCK_ACCURACY_t &tlv, const char *idStr)
    {_nc = true;}
    virtual void UTC_PROPERTIES_h(const Message &msg,
        const UTC_PROPERTIES_t &tlv, const char *idStr)
    {_nc = true;}
    virtual void TRACEABILITY_PROPERTIES_h(const Message &msg,
        const TRACEABILITY_PROPERTIES_t &tlv, const char *idStr)
    {_nc = true;}
    virtual void TIMESCALE_PROPERTIES_h(const Message &msg,
        const TIMESCALE_PROPERTIES_t &tlv, const char *idStr)
    {_nc = true;}
    virtual void UNICAST_NEGOTIATION_ENABLE_h(const Message &msg,
        const UNICAST_NEGOTIATION_ENABLE_t &tlv, const char *idStr)
    {_nc = true;}
    virtual void PATH_TRACE_LIST_h(const Message &msg,
        const PATH_TRACE_LIST_t &tlv, const char *idStr)
    {_nc = true;}
    virtual void PATH_TRACE_ENABLE_h(const Message &msg,
        const PATH_TRACE_ENABLE_t &tlv, const char *idStr)
    {_nc = true;}
    virtual void GRANDMASTER_CLUSTER_TABLE_h(const Message &msg,
        const GRANDMASTER_CLUSTER_TABLE_t &tlv, const char *idStr)
    {_nc = true;}
    virtual void UNICAST_MASTER_TABLE_h(const Message &msg,
        const UNICAST_MASTER_TABLE_t &tlv, const char *idStr)
    {_nc = true;}
    virtual void UNICAST_MASTER_MAX_TABLE_SIZE_h(const Message &msg,
        const UNICAST_MASTER_MAX_TABLE_SIZE_t &tlv, const char *idStr)
    {_nc = true;}
    virtual void ACCEPTABLE_MASTER_TABLE_h(const Message &msg,
        const ACCEPTABLE_MASTER_TABLE_t &tlv, const char *idStr)
    {_nc = true;}
    virtual void ACCEPTABLE_MASTER_TABLE_ENABLED_h(const Message &msg,
        const ACCEPTABLE_MASTER_TABLE_ENABLED_t &tlv, const char *idStr)
    {_nc = true;}
    virtual void ACCEPTABLE_MASTER_MAX_TABLE_SIZE_h(const Message &msg,
        const ACCEPTABLE_MASTER_MAX_TABLE_SIZE_t &tlv, const char *idStr)
    {_nc = true;}
    virtual void ALTERNATE_MASTER_h(const Message &msg,
        const ALTERNATE_MASTER_t &tlv, const char *idStr)
    {_nc = true;}
    virtual void ALTERNATE_TIME_OFFSET_ENABLE_h(const Message &msg,
        const ALTERNATE_TIME_OFFSET_ENABLE_t &tlv, const char *idStr)
    {_nc = true;}
    virtual void ALTERNATE_TIME_OFFSET_NAME_h(const Message &msg,
        const ALTERNATE_TIME_OFFSET_NAME_t &tlv, const char *idStr)
    {_nc = true;}
    virtual void ALTERNATE_TIME_OFFSET_MAX_KEY_h(const Message &msg,
        const ALTERNATE_TIME_OFFSET_MAX_KEY_t &tlv, const char *idStr)
    {_nc = true;}
    virtual void ALTERNATE_TIME_OFFSET_PROPERTIES_h(const Message &msg,
        const ALTERNATE_TIME_OFFSET_PROPERTIES_t &tlv, const char *idStr)
    {_nc = true;}
    virtual void TRANSPARENT_CLOCK_PORT_DATA_SET_h(const Message &msg,
        const TRANSPARENT_CLOCK_PORT_DATA_SET_t &tlv, const char *idStr)
    {_nc = true;}
    virtual void LOG_MIN_PDELAY_REQ_INTERVAL_h(const Message &msg,
        const LOG_MIN_PDELAY_REQ_INTERVAL_t &tlv, const char *idStr)
    {_nc = true;}
    virtual void TRANSPARENT_CLOCK_DEFAULT_DATA_SET_h(const Message &msg,
        const TRANSPARENT_CLOCK_DEFAULT_DATA_SET_t &tlv, const char *idStr)
    {_nc = true;}
    virtual void PRIMARY_DOMAIN_h(const Message &msg,
        const PRIMARY_DOMAIN_t &tlv, const char *idStr)
    {_nc = true;}
    virtual void DELAY_MECHANISM_h(const Message &msg,
        const DELAY_MECHANISM_t &tlv, const char *idStr)
    {_nc = true;}
    virtual void EXTERNAL_PORT_CONFIGURATION_ENABLED_h(const Message &msg,
        const EXTERNAL_PORT_CONFIGURATION_ENABLED_t &tlv, const char *idStr)
    {_nc = true;}
    virtual void MASTER_ONLY_h(const Message &msg,
        const MASTER_ONLY_t &tlv, const char *idStr)
    {_nc = true;}
    virtual void HOLDOVER_UPGRADE_ENABLE_h(const Message &msg,
        const HOLDOVER_UPGRADE_ENABLE_t &tlv, const char *idStr)
    {_nc = true;}
    virtual void EXT_PORT_CONFIG_PORT_DATA_SET_h(const Message &msg,
        const EXT_PORT_CONFIG_PORT_DATA_SET_t &tlv, const char *idStr)
    {_nc = true;}
    virtual void TIME_STATUS_NP_h(const Message &msg,
        const TIME_STATUS_NP_t &tlv, const char *idStr)
    {_nc = true;}
    virtual void GRANDMASTER_SETTINGS_NP_h(const Message &msg,
        const GRANDMASTER_SETTINGS_NP_t &tlv, const char *idStr)
    {_nc = true;}
    virtual void PORT_DATA_SET_NP_h(const Message &msg,
        const PORT_DATA_SET_NP_t &tlv, const char *idStr)
    {_nc = true;}
    virtual void SUBSCRIBE_EVENTS_NP_h(const Message &msg,
        const SUBSCRIBE_EVENTS_NP_t &tlv, const char *idStr)
    {_nc = true;}
    virtual void PORT_PROPERTIES_NP_h(const Message &msg,
        const PORT_PROPERTIES_NP_t &tlv, const char *idStr)
    {_nc = true;}
    virtual void PORT_STATS_NP_h(const Message &msg,
        const PORT_STATS_NP_t &tlv, const char *idStr)
    {_nc = true;}
    virtual void SYNCHRONIZATION_UNCERTAIN_NP_h(const Message &msg,
        const SYNCHRONIZATION_UNCERTAIN_NP_t &tlv, const char *idStr)
    {_nc = true;}
    virtual void PORT_SERVICE_STATS_NP_h(const Message &msg,
        const PORT_SERVICE_STATS_NP_t &tlv, const char *idStr)
    {_nc = true;}
    virtual void UNICAST_MASTER_TABLE_NP_h(const Message &msg,
        const UNICAST_MASTER_TABLE_NP_t &tlv, const char *idStr)
    {_nc = true;}
    virtual void PORT_HWCLOCK_NP_h(const Message &msg,
        const PORT_HWCLOCK_NP_t &tlv, const char *idStr)
    {_nc = true;}
    virtual void POWER_PROFILE_SETTINGS_NP_h(const Message &msg,
        const POWER_PROFILE_SETTINGS_NP_t &tlv, const char *idStr)
    {_nc = true;}
    virtual void CMLDS_INFO_NP_h(const Message &msg,
        const CMLDS_INFO_NP_t &tlv, const char *idStr)
    {_nc = true;}
    virtual void PORT_CORRECTIONS_NP_h(const Message &msg,
        const PORT_CORRECTIONS_NP_t &tlv, const char *idStr)
    {_nc = true;}
    virtual void EXTERNAL_GRANDMASTER_PROPERTIES_NP_h(const Message &msg,
        const EXTERNAL_GRANDMASTER_PROPERTIES_NP_t &tlv, const char *idStr)
    {_nc = true;}
};
 
class BaseMngBuildCallback
{
  protected:
    /* To improve backward compatibility
       Call virtual functions here in this inline function,
       so we compile it in the application
       and avoid using virtual function table in the library code */
    BaseMngTlv *iBuild(Message &msg, mng_vals_e tlv_id) {
        switch(tlv_id) {
            case USER_DESCRIPTION: {
                auto d = new USER_DESCRIPTION_t;
                if(d != nullptr) {
                    if(USER_DESCRIPTION_b(msg, *d))
                        return d;
                    delete d;
                }
                break;
            }
            case INITIALIZE: {
                auto d = new INITIALIZE_t;
                if(d != nullptr) {
                    if(INITIALIZE_b(msg, *d))
                        return d;
                    delete d;
                }
                break;
            }
            case PRIORITY1: {
                auto d = new PRIORITY1_t;
                if(d != nullptr) {
                    if(PRIORITY1_b(msg, *d))
                        return d;
                    delete d;
                }
                break;
            }
            case PRIORITY2: {
                auto d = new PRIORITY2_t;
                if(d != nullptr) {
                    if(PRIORITY2_b(msg, *d))
                        return d;
                    delete d;
                }
                break;
            }
            case DOMAIN: {
                auto d = new DOMAIN_t;
                if(d != nullptr) {
                    if(DOMAIN_b(msg, *d))
                        return d;
                    delete d;
                }
                break;
            }
            case SLAVE_ONLY: {
                auto d = new SLAVE_ONLY_t;
                if(d != nullptr) {
                    if(SLAVE_ONLY_b(msg, *d))
                        return d;
                    delete d;
                }
                break;
            }
            case LOG_ANNOUNCE_INTERVAL: {
                auto d = new LOG_ANNOUNCE_INTERVAL_t;
                if(d != nullptr) {
                    if(LOG_ANNOUNCE_INTERVAL_b(msg, *d))
                        return d;
                    delete d;
                }
                break;
            }
            case ANNOUNCE_RECEIPT_TIMEOUT: {
                auto d = new ANNOUNCE_RECEIPT_TIMEOUT_t;
                if(d != nullptr) {
                    if(ANNOUNCE_RECEIPT_TIMEOUT_b(msg, *d))
                        return d;
                    delete d;
                }
                break;
            }
            case LOG_SYNC_INTERVAL: {
                auto d = new LOG_SYNC_INTERVAL_t;
                if(d != nullptr) {
                    if(LOG_SYNC_INTERVAL_b(msg, *d))
                        return d;
                    delete d;
                }
                break;
            }
            case VERSION_NUMBER: {
                auto d = new VERSION_NUMBER_t;
                if(d != nullptr) {
                    if(VERSION_NUMBER_b(msg, *d))
                        return d;
                    delete d;
                }
                break;
            }
            case TIME: {
                auto d = new TIME_t;
                if(d != nullptr) {
                    if(TIME_b(msg, *d))
                        return d;
                    delete d;
                }
                break;
            }
            case CLOCK_ACCURACY: {
                auto d = new CLOCK_ACCURACY_t;
                if(d != nullptr) {
                    if(CLOCK_ACCURACY_b(msg, *d))
                        return d;
                    delete d;
                }
                break;
            }
            case UTC_PROPERTIES: {
                auto d = new UTC_PROPERTIES_t;
                if(d != nullptr) {
                    if(UTC_PROPERTIES_b(msg, *d))
                        return d;
                    delete d;
                }
                break;
            }
            case TRACEABILITY_PROPERTIES: {
                auto d = new TRACEABILITY_PROPERTIES_t;
                if(d != nullptr) {
                    if(TRACEABILITY_PROPERTIES_b(msg, *d))
                        return d;
                    delete d;
                }
                break;
            }
            case TIMESCALE_PROPERTIES: {
                auto d = new TIMESCALE_PROPERTIES_t;
                if(d != nullptr) {
                    if(TIMESCALE_PROPERTIES_b(msg, *d))
                        return d;
                    delete d;
                }
                break;
            }
            case UNICAST_NEGOTIATION_ENABLE: {
                auto d = new UNICAST_NEGOTIATION_ENABLE_t;
                if(d != nullptr) {
                    if(UNICAST_NEGOTIATION_ENABLE_b(msg, *d))
                        return d;
                    delete d;
                }
                break;
            }
            case PATH_TRACE_ENABLE: {
                auto d = new PATH_TRACE_ENABLE_t;
                if(d != nullptr) {
                    if(PATH_TRACE_ENABLE_b(msg, *d))
                        return d;
                    delete d;
                }
                break;
            }
            case GRANDMASTER_CLUSTER_TABLE: {
                auto d = new GRANDMASTER_CLUSTER_TABLE_t;
                if(d != nullptr) {
                    if(GRANDMASTER_CLUSTER_TABLE_b(msg, *d))
                        return d;
                    delete d;
                }
                break;
            }
            case UNICAST_MASTER_TABLE: {
                auto d = new UNICAST_MASTER_TABLE_t;
                if(d != nullptr) {
                    if(UNICAST_MASTER_TABLE_b(msg, *d))
                        return d;
                    delete d;
                }
                break;
            }
            case ACCEPTABLE_MASTER_TABLE: {
                auto d = new ACCEPTABLE_MASTER_TABLE_t;
                if(d != nullptr) {
                    if(ACCEPTABLE_MASTER_TABLE_b(msg, *d))
                        return d;
                    delete d;
                }
                break;
            }
            case ACCEPTABLE_MASTER_TABLE_ENABLED: {
                auto d = new ACCEPTABLE_MASTER_TABLE_ENABLED_t;
                if(d != nullptr) {
                    if(ACCEPTABLE_MASTER_TABLE_ENABLED_b(msg, *d))
                        return d;
                    delete d;
                }
                break;
            }
            case ALTERNATE_MASTER: {
                auto d = new ALTERNATE_MASTER_t;
                if(d != nullptr) {
                    if(ALTERNATE_MASTER_b(msg, *d))
                        return d;
                    delete d;
                }
                break;
            }
            case ALTERNATE_TIME_OFFSET_ENABLE: {
                auto d = new ALTERNATE_TIME_OFFSET_ENABLE_t;
                if(d != nullptr) {
                    if(ALTERNATE_TIME_OFFSET_ENABLE_b(msg, *d))
                        return d;
                    delete d;
                }
                break;
            }
            case ALTERNATE_TIME_OFFSET_NAME: {
                auto d = new ALTERNATE_TIME_OFFSET_NAME_t;
                if(d != nullptr) {
                    if(ALTERNATE_TIME_OFFSET_NAME_b(msg, *d))
                        return d;
                    delete d;
                }
                break;
            }
            case ALTERNATE_TIME_OFFSET_PROPERTIES: {
                auto d = new ALTERNATE_TIME_OFFSET_PROPERTIES_t;
                if(d != nullptr) {
                    if(ALTERNATE_TIME_OFFSET_PROPERTIES_b(msg, *d))
                        return d;
                    delete d;
                }
                break;
            }
            case LOG_MIN_PDELAY_REQ_INTERVAL: {
                auto d = new LOG_MIN_PDELAY_REQ_INTERVAL_t;
                if(d != nullptr) {
                    if(LOG_MIN_PDELAY_REQ_INTERVAL_b(msg, *d))
                        return d;
                    delete d;
                }
                break;
            }
            case PRIMARY_DOMAIN: {
                auto d = new PRIMARY_DOMAIN_t;
                if(d != nullptr) {
                    if(PRIMARY_DOMAIN_b(msg, *d))
                        return d;
                    delete d;
                }
                break;
            }
            case DELAY_MECHANISM: {
                auto d = new DELAY_MECHANISM_t;
                if(d != nullptr) {
                    if(DELAY_MECHANISM_b(msg, *d))
                        return d;
                    delete d;
                }
                break;
            }
            case EXTERNAL_PORT_CONFIGURATION_ENABLED: {
                auto d = new EXTERNAL_PORT_CONFIGURATION_ENABLED_t;
                if(d != nullptr) {
                    if(EXTERNAL_PORT_CONFIGURATION_ENABLED_b(msg, *d))
                        return d;
                    delete d;
                }
                break;
            }
            case MASTER_ONLY: {
                auto d = new MASTER_ONLY_t;
                if(d != nullptr) {
                    if(MASTER_ONLY_b(msg, *d))
                        return d;
                    delete d;
                }
                break;
            }
            case HOLDOVER_UPGRADE_ENABLE: {
                auto d = new HOLDOVER_UPGRADE_ENABLE_t;
                if(d != nullptr) {
                    if(HOLDOVER_UPGRADE_ENABLE_b(msg, *d))
                        return d;
                    delete d;
                }
                break;
            }
            case EXT_PORT_CONFIG_PORT_DATA_SET: {
                auto d = new EXT_PORT_CONFIG_PORT_DATA_SET_t;
                if(d != nullptr) {
                    if(EXT_PORT_CONFIG_PORT_DATA_SET_b(msg, *d))
                        return d;
                    delete d;
                }
                break;
            }
            case GRANDMASTER_SETTINGS_NP: {
                auto d = new GRANDMASTER_SETTINGS_NP_t;
                if(d != nullptr) {
                    if(GRANDMASTER_SETTINGS_NP_b(msg, *d))
                        return d;
                    delete d;
                }
                break;
            }
            case PORT_DATA_SET_NP: {
                auto d = new PORT_DATA_SET_NP_t;
                if(d != nullptr) {
                    if(PORT_DATA_SET_NP_b(msg, *d))
                        return d;
                    delete d;
                }
                break;
            }
            case SUBSCRIBE_EVENTS_NP: {
                auto d = new SUBSCRIBE_EVENTS_NP_t;
                if(d != nullptr) {
                    if(SUBSCRIBE_EVENTS_NP_b(msg, *d))
                        return d;
                    delete d;
                }
                break;
            }
            case SYNCHRONIZATION_UNCERTAIN_NP: {
                auto d = new SYNCHRONIZATION_UNCERTAIN_NP_t;
                if(d != nullptr) {
                    if(SYNCHRONIZATION_UNCERTAIN_NP_b(msg, *d))
                        return d;
                    delete d;
                }
                break;
            }
            case POWER_PROFILE_SETTINGS_NP: {
                auto d = new POWER_PROFILE_SETTINGS_NP_t;
                if(d != nullptr) {
                    if(POWER_PROFILE_SETTINGS_NP_b(msg, *d))
                        return d;
                    delete d;
                }
                break;
            }
            case PORT_CORRECTIONS_NP: {
                auto d = new PORT_CORRECTIONS_NP_t;
                if(d != nullptr) {
                    if(PORT_CORRECTIONS_NP_b(msg, *d))
                        return d;
                    delete d;
                }
                break;
            }
            case EXTERNAL_GRANDMASTER_PROPERTIES_NP: {
                auto d = new EXTERNAL_GRANDMASTER_PROPERTIES_NP_t;
                if(d != nullptr) {
                    if(EXTERNAL_GRANDMASTER_PROPERTIES_NP_b(msg, *d))
                        return d;
                    delete d;
                }
                break;
            }
            default:
                break;
        }
        return nullptr;
    }
  public:
    BaseMngBuildCallback() = default;
    virtual ~BaseMngBuildCallback() = default;
    virtual bool USER_DESCRIPTION_b(const Message &msg,
        USER_DESCRIPTION_t &tlv)
    {return false;}
    virtual bool INITIALIZE_b(const Message &msg,
        INITIALIZE_t &tlv)
    {return false;}
    virtual bool PRIORITY1_b(const Message &msg,
        PRIORITY1_t &tlv)
    {return false;}
    virtual bool PRIORITY2_b(const Message &msg,
        PRIORITY2_t &tlv)
    {return false;}
    virtual bool DOMAIN_b(const Message &msg,
        DOMAIN_t &tlv)
    {return false;}
    virtual bool SLAVE_ONLY_b(const Message &msg,
        SLAVE_ONLY_t &tlv)
    {return false;}
    virtual bool LOG_ANNOUNCE_INTERVAL_b(const Message &msg,
        LOG_ANNOUNCE_INTERVAL_t &tlv)
    {return false;}
    virtual bool ANNOUNCE_RECEIPT_TIMEOUT_b(const Message &msg,
        ANNOUNCE_RECEIPT_TIMEOUT_t &tlv)
    {return false;}
    virtual bool LOG_SYNC_INTERVAL_b(const Message &msg,
        LOG_SYNC_INTERVAL_t &tlv)
    {return false;}
    virtual bool VERSION_NUMBER_b(const Message &msg,
        VERSION_NUMBER_t &tlv)
    {return false;}
    virtual bool TIME_b(const Message &msg,
        TIME_t &tlv)
    {return false;}
    virtual bool CLOCK_ACCURACY_b(const Message &msg,
        CLOCK_ACCURACY_t &tlv)
    {return false;}
    virtual bool UTC_PROPERTIES_b(const Message &msg,
        UTC_PROPERTIES_t &tlv)
    {return false;}
    virtual bool TRACEABILITY_PROPERTIES_b(const Message &msg,
        TRACEABILITY_PROPERTIES_t &tlv)
    {return false;}
    virtual bool TIMESCALE_PROPERTIES_b(const Message &msg,
        TIMESCALE_PROPERTIES_t &tlv)
    {return false;}
    virtual bool UNICAST_NEGOTIATION_ENABLE_b(const Message &msg,
        UNICAST_NEGOTIATION_ENABLE_t &tlv)
    {return false;}
    virtual bool PATH_TRACE_ENABLE_b(const Message &msg,
        PATH_TRACE_ENABLE_t &tlv)
    {return false;}
    virtual bool GRANDMASTER_CLUSTER_TABLE_b(const Message &msg,
        GRANDMASTER_CLUSTER_TABLE_t &tlv)
    {return false;}
    virtual bool UNICAST_MASTER_TABLE_b(const Message &msg,
        UNICAST_MASTER_TABLE_t &tlv)
    {return false;}
    virtual bool ACCEPTABLE_MASTER_TABLE_b(const Message &msg,
        ACCEPTABLE_MASTER_TABLE_t &tlv)
    {return false;}
    virtual bool ACCEPTABLE_MASTER_TABLE_ENABLED_b(const Message &msg,
        ACCEPTABLE_MASTER_TABLE_ENABLED_t &tlv)
    {return false;}
    virtual bool ALTERNATE_MASTER_b(const Message &msg,
        ALTERNATE_MASTER_t &tlv)
    {return false;}
    virtual bool ALTERNATE_TIME_OFFSET_ENABLE_b(const Message &msg,
        ALTERNATE_TIME_OFFSET_ENABLE_t &tlv)
    {return false;}
    virtual bool ALTERNATE_TIME_OFFSET_NAME_b(const Message &msg,
        ALTERNATE_TIME_OFFSET_NAME_t &tlv)
    {return false;}
    virtual bool ALTERNATE_TIME_OFFSET_PROPERTIES_b(const Message &msg,
        ALTERNATE_TIME_OFFSET_PROPERTIES_t &tlv)
    {return false;}
    virtual bool LOG_MIN_PDELAY_REQ_INTERVAL_b(const Message &msg,
        LOG_MIN_PDELAY_REQ_INTERVAL_t &tlv)
    {return false;}
    virtual bool PRIMARY_DOMAIN_b(const Message &msg,
        PRIMARY_DOMAIN_t &tlv)
    {return false;}
    virtual bool DELAY_MECHANISM_b(const Message &msg,
        DELAY_MECHANISM_t &tlv)
    {return false;}
    virtual bool EXTERNAL_PORT_CONFIGURATION_ENABLED_b(const Message &msg,
        EXTERNAL_PORT_CONFIGURATION_ENABLED_t &tlv)
    {return false;}
    virtual bool MASTER_ONLY_b(const Message &msg,
        MASTER_ONLY_t &tlv)
    {return false;}
    virtual bool HOLDOVER_UPGRADE_ENABLE_b(const Message &msg,
        HOLDOVER_UPGRADE_ENABLE_t &tlv)
    {return false;}
    virtual bool EXT_PORT_CONFIG_PORT_DATA_SET_b(const Message &msg,
        EXT_PORT_CONFIG_PORT_DATA_SET_t &tlv)
    {return false;}
    virtual bool GRANDMASTER_SETTINGS_NP_b(const Message &msg,
        GRANDMASTER_SETTINGS_NP_t &tlv)
    {return false;}
    virtual bool PORT_DATA_SET_NP_b(const Message &msg,
        PORT_DATA_SET_NP_t &tlv)
    {return false;}
    virtual bool SUBSCRIBE_EVENTS_NP_b(const Message &msg,
        SUBSCRIBE_EVENTS_NP_t &tlv)
    {return false;}
    virtual bool SYNCHRONIZATION_UNCERTAIN_NP_b(const Message &msg,
        SYNCHRONIZATION_UNCERTAIN_NP_t &tlv)
    {return false;}
    virtual bool POWER_PROFILE_SETTINGS_NP_b(const Message &msg,
        POWER_PROFILE_SETTINGS_NP_t &tlv)
    {return false;}
    virtual bool PORT_CORRECTIONS_NP_b(const Message &msg,
        PORT_CORRECTIONS_NP_t &tlv)
    {return false;}
    virtual bool EXTERNAL_GRANDMASTER_PROPERTIES_NP_b(const Message &msg,
        EXTERNAL_GRANDMASTER_PROPERTIES_NP_t &tlv)
    {return false;}
};
 
__PTPMGMT_NAMESPACE_END
#else /* __cplusplus */
#error "this header is for C++ and scripts use only, NOT for C"
#endif /* __cplusplus */
 
#endif /* __PTPMGMT_CALL_DEFS_H */