/** \file dnx/swstate/auto_generated/diagnostic/dnx_algo_port_commandline.c
 *
 * sw state functions definitions
 *
 * DO NOT EDIT THIS FILE!
 * This file is auto-generated.
 * Edits to this file will be lost when it is regenerated.
 */
/*
 * This license is set out in https://raw.githubusercontent.com/Broadcom-Network-Switching-Software/OpenBCM/master/Legal/LICENSE file.
 * 
 * Copyright 2007-2020 Broadcom Inc. All rights reserved.
 */

#ifdef BSL_LOG_MODULE
#error "BSL_LOG_MODULE redefined"
#endif
#define BSL_LOG_MODULE BSL_LS_SWSTATEDNX_GENERAL

#include <shared/error.h>
#include <shared/bsl.h>
#include <appl/diag/sand/diag_sand_framework.h>
#include <appl/diag/sand/diag_sand_utils.h>
#include <soc/dnxc/swstate/dnxc_sw_state_c_includes.h>
#include <bcm_int/dnx/algo/swstate/auto_generated/diagnostic/dnx_algo_port_diagnostic.h>
#include "dnx_algo_port_commandline.h"
#include <bcm_int/dnx/algo/swstate/auto_generated/access/dnx_algo_port_access.h>
#include <soc/dnx/dnx_data/auto_generated/dnx_data_nif.h>
#if defined(DNX_SW_STATE_DIAGNOSTIC)
sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_cmds[] = {
    {"general", NULL, sh_dnx_swstate_dnx_algo_port_general_cmds, NULL, &dnx_swstate_dnx_algo_port_general_man},
    {"logical", NULL, sh_dnx_swstate_dnx_algo_port_logical_cmds, NULL, &dnx_swstate_dnx_algo_port_logical_man},
    {"nif", NULL, sh_dnx_swstate_dnx_algo_port_nif_cmds, NULL, &dnx_swstate_dnx_algo_port_nif_man},
    {"tm", NULL, sh_dnx_swstate_dnx_algo_port_tm_cmds, NULL, &dnx_swstate_dnx_algo_port_tm_man},
    {"sch", NULL, sh_dnx_swstate_dnx_algo_port_sch_cmds, NULL, &dnx_swstate_dnx_algo_port_sch_man},
    {"pp", NULL, sh_dnx_swstate_dnx_algo_port_pp_cmds, NULL, &dnx_swstate_dnx_algo_port_pp_man},
    {"pp_alloc", NULL, sh_dnx_swstate_dnx_algo_port_pp_alloc_cmds, NULL, &dnx_swstate_dnx_algo_port_pp_alloc_man},
    {"ilkn", NULL, sh_dnx_swstate_dnx_algo_port_ilkn_cmds, NULL, &dnx_swstate_dnx_algo_port_ilkn_man},
    {"flexe", NULL, sh_dnx_swstate_dnx_algo_port_flexe_cmds, NULL, &dnx_swstate_dnx_algo_port_flexe_man},
    {"fabric", NULL, sh_dnx_swstate_dnx_algo_port_fabric_cmds, NULL, &dnx_swstate_dnx_algo_port_fabric_man},
    {"tm_interface", NULL, sh_dnx_swstate_dnx_algo_port_tm_interface_cmds, NULL, &dnx_swstate_dnx_algo_port_tm_interface_man},
    {"interface", NULL, sh_dnx_swstate_dnx_algo_port_interface_cmds, NULL, &dnx_swstate_dnx_algo_port_interface_man},
    {"sch_interface", NULL, sh_dnx_swstate_dnx_algo_port_sch_interface_cmds, NULL, &dnx_swstate_dnx_algo_port_sch_interface_man},
    {"skip_first_user_defined_header_size_profile_data", NULL, sh_dnx_swstate_dnx_algo_port_skip_first_user_defined_header_size_profile_data_cmds, NULL, &dnx_swstate_dnx_algo_port_skip_first_user_defined_header_size_profile_data_man},
    {"prd", NULL, sh_dnx_swstate_dnx_algo_port_prd_cmds, NULL, &dnx_swstate_dnx_algo_port_prd_man},
    {"dump", sh_dnx_swstate_dnx_algo_port_dump_cmd, NULL, dnx_swstate_dnx_algo_port_dump_options, &dnx_swstate_dnx_algo_port_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_size_get_options, &dnx_swstate_dnx_algo_port_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_diagnostic_operation_counters_man},
    {NULL}
};


shr_error_e sh_dnx_swstate_dnx_algo_port_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    uint8 is_init;
    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    dnx_algo_port_db.is_init(unit, &is_init);
    if (is_init) {
        SHR_IF_ERR_EXIT(dnx_algo_port_db_dump(unit, filters));
        if (!filters.nocontent)
        {
            dnx_sw_state_dump_detach_file(unit);
        }
    }
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_dump_options[] = {
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_dump_man = {
    "swstate dnx_algo_port dump",
    "print the module's content",
    "swstate dnx_algo_port dump",
    "swstate dnx_algo_port dump nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    uint32 size = 0;
    SHR_FUNC_INIT_VARS(unit);

    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~", 0);
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_size_get_man = {
    "swstate dnx_algo_port size_get",
    "print the module's size",
    "swstate dnx_algo_port size_get",
    "swstate dnx_algo_port size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{


    SHR_FUNC_INIT_VARS(unit);

    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_diagnostic_operation_counters_man = {
    "swstate dnx_algo_port diagnostic_operation_counters",
    "print the module's diagnostic operation counters",
    "swstate dnx_algo_port diagnostic_operation_counters",
    "swstate dnx_algo_port diagnostic_operation_counters",
};


sh_sand_man_t dnx_swstate_dnx_algo_port_man = {
    cmd_dnx_swstate_dnx_algo_port_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_desc[] = "swstate dnx_algo_port commands";



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_general_cmds[] = {
    {"dummy", NULL, sh_dnx_swstate_dnx_algo_port_general_dummy_cmds, NULL, &dnx_swstate_dnx_algo_port_general_dummy_man},
    {"dump", sh_dnx_swstate_dnx_algo_port_general_dump_cmd, NULL, dnx_swstate_dnx_algo_port_general_dump_options, &dnx_swstate_dnx_algo_port_general_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_general_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_general_size_get_options, &dnx_swstate_dnx_algo_port_general_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_general_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_general_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_general_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_general_man = {
    cmd_dnx_swstate_dnx_algo_port_general_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_general_desc[] = "dnx_algo_port_db general commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_general_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);


    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_general_dump(unit, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_general_dump_options[] = {
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_general_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db general dump []\n",
    "dnx_algo_port_db general dump nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_general_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~GENERAL~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->general));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_general_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_general_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db general size_get",
    "dnx_algo_port_db general size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_general_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~GENERAL~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_general_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_general_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db general diagnostic_operation_counters",
    "dnx_algo_port_db general diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_general_dummy_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_general_dummy_dump_cmd, NULL, dnx_swstate_dnx_algo_port_general_dummy_dump_options, &dnx_swstate_dnx_algo_port_general_dummy_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_general_dummy_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_general_dummy_size_get_options, &dnx_swstate_dnx_algo_port_general_dummy_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_general_dummy_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_general_dummy_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_general_dummy_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_general_dummy_man = {
    cmd_dnx_swstate_dnx_algo_port_general_dummy_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_general_dummy_desc[] = "dnx_algo_port_db general dummy commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_general_dummy_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);


    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_general_dummy_dump(unit, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_general_dummy_dump_options[] = {
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_general_dummy_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db general dummy dump []\n",
    "dnx_algo_port_db general dummy dump nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_general_dummy_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~GENERAL~DUMMY~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->general.dummy));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_general_dummy_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_general_dummy_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db general dummy size_get",
    "dnx_algo_port_db general dummy size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_general_dummy_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~GENERAL~DUMMY~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_general_dummy_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_general_dummy_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db general dummy diagnostic_operation_counters",
    "dnx_algo_port_db general dummy diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_logical_cmds[] = {
    {"state", NULL, sh_dnx_swstate_dnx_algo_port_logical_state_cmds, NULL, &dnx_swstate_dnx_algo_port_logical_state_man},
    {"info", NULL, sh_dnx_swstate_dnx_algo_port_logical_info_cmds, NULL, &dnx_swstate_dnx_algo_port_logical_info_man},
    {"interface_type", NULL, sh_dnx_swstate_dnx_algo_port_logical_interface_type_cmds, NULL, &dnx_swstate_dnx_algo_port_logical_interface_type_man},
    {"interface_offset", NULL, sh_dnx_swstate_dnx_algo_port_logical_interface_offset_cmds, NULL, &dnx_swstate_dnx_algo_port_logical_interface_offset_man},
    {"nif_handle", NULL, sh_dnx_swstate_dnx_algo_port_logical_nif_handle_cmds, NULL, &dnx_swstate_dnx_algo_port_logical_nif_handle_man},
    {"tm_handle", NULL, sh_dnx_swstate_dnx_algo_port_logical_tm_handle_cmds, NULL, &dnx_swstate_dnx_algo_port_logical_tm_handle_man},
    {"sch_handle", NULL, sh_dnx_swstate_dnx_algo_port_logical_sch_handle_cmds, NULL, &dnx_swstate_dnx_algo_port_logical_sch_handle_man},
    {"sch_if_handle", NULL, sh_dnx_swstate_dnx_algo_port_logical_sch_if_handle_cmds, NULL, &dnx_swstate_dnx_algo_port_logical_sch_if_handle_man},
    {"pp_handle", NULL, sh_dnx_swstate_dnx_algo_port_logical_pp_handle_cmds, NULL, &dnx_swstate_dnx_algo_port_logical_pp_handle_man},
    {"ilkn_handle", NULL, sh_dnx_swstate_dnx_algo_port_logical_ilkn_handle_cmds, NULL, &dnx_swstate_dnx_algo_port_logical_ilkn_handle_man},
    {"flexe_client_handle", NULL, sh_dnx_swstate_dnx_algo_port_logical_flexe_client_handle_cmds, NULL, &dnx_swstate_dnx_algo_port_logical_flexe_client_handle_man},
    {"flexe_mac_handle", NULL, sh_dnx_swstate_dnx_algo_port_logical_flexe_mac_handle_cmds, NULL, &dnx_swstate_dnx_algo_port_logical_flexe_mac_handle_man},
    {"flexe_sar_handle", NULL, sh_dnx_swstate_dnx_algo_port_logical_flexe_sar_handle_cmds, NULL, &dnx_swstate_dnx_algo_port_logical_flexe_sar_handle_man},
    {"flexe_phy_handle", NULL, sh_dnx_swstate_dnx_algo_port_logical_flexe_phy_handle_cmds, NULL, &dnx_swstate_dnx_algo_port_logical_flexe_phy_handle_man},
    {"tm_interface_handle", NULL, sh_dnx_swstate_dnx_algo_port_logical_tm_interface_handle_cmds, NULL, &dnx_swstate_dnx_algo_port_logical_tm_interface_handle_man},
    {"interface_handle", NULL, sh_dnx_swstate_dnx_algo_port_logical_interface_handle_cmds, NULL, &dnx_swstate_dnx_algo_port_logical_interface_handle_man},
    {"fabric_handle", NULL, sh_dnx_swstate_dnx_algo_port_logical_fabric_handle_cmds, NULL, &dnx_swstate_dnx_algo_port_logical_fabric_handle_man},
    {"channel", NULL, sh_dnx_swstate_dnx_algo_port_logical_channel_cmds, NULL, &dnx_swstate_dnx_algo_port_logical_channel_man},
    {"dump", sh_dnx_swstate_dnx_algo_port_logical_dump_cmd, NULL, dnx_swstate_dnx_algo_port_logical_dump_options, &dnx_swstate_dnx_algo_port_logical_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_logical_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_logical_size_get_options, &dnx_swstate_dnx_algo_port_logical_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_logical_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_logical_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_logical_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_man = {
    cmd_dnx_swstate_dnx_algo_port_logical_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_logical_desc[] = "dnx_algo_port_db logical commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  logical_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("logical_idx_0", logical_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_logical_dump(unit, logical_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_dump_options[] = {
    {"logical_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db logical dump [,logical_idx_0=<int>]\n",
    "dnx_algo_port_db logical dump logical_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->logical));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db logical size_get",
    "dnx_algo_port_db logical size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db logical diagnostic_operation_counters",
    "dnx_algo_port_db logical diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_logical_state_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_logical_state_dump_cmd, NULL, dnx_swstate_dnx_algo_port_logical_state_dump_options, &dnx_swstate_dnx_algo_port_logical_state_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_logical_state_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_logical_state_size_get_options, &dnx_swstate_dnx_algo_port_logical_state_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_logical_state_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_logical_state_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_logical_state_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_state_man = {
    cmd_dnx_swstate_dnx_algo_port_logical_state_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_logical_state_desc[] = "dnx_algo_port_db logical state commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_state_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  logical_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("logical_idx_0", logical_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_logical_state_dump(unit, logical_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_state_dump_options[] = {
    {"logical_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_state_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db logical state dump [,logical_idx_0=<int>]\n",
    "dnx_algo_port_db logical state dump logical_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_state_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~STATE~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->logical[0].state));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_state_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_state_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db logical state size_get",
    "dnx_algo_port_db logical state size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_state_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~STATE~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_state_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_state_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db logical state diagnostic_operation_counters",
    "dnx_algo_port_db logical state diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_logical_info_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_logical_info_dump_cmd, NULL, dnx_swstate_dnx_algo_port_logical_info_dump_options, &dnx_swstate_dnx_algo_port_logical_info_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_logical_info_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_logical_info_size_get_options, &dnx_swstate_dnx_algo_port_logical_info_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_logical_info_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_logical_info_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_logical_info_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_info_man = {
    cmd_dnx_swstate_dnx_algo_port_logical_info_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_logical_info_desc[] = "dnx_algo_port_db logical info commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_info_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  logical_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("logical_idx_0", logical_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_logical_info_dump(unit, logical_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_info_dump_options[] = {
    {"logical_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_info_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db logical info dump [,logical_idx_0=<int>]\n",
    "dnx_algo_port_db logical info dump logical_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_info_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~INFO~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->logical[0].info));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_info_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_info_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db logical info size_get",
    "dnx_algo_port_db logical info size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_info_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~INFO~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_info_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_info_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db logical info diagnostic_operation_counters",
    "dnx_algo_port_db logical info diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_logical_interface_type_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_logical_interface_type_dump_cmd, NULL, dnx_swstate_dnx_algo_port_logical_interface_type_dump_options, &dnx_swstate_dnx_algo_port_logical_interface_type_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_logical_interface_type_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_logical_interface_type_size_get_options, &dnx_swstate_dnx_algo_port_logical_interface_type_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_logical_interface_type_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_logical_interface_type_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_logical_interface_type_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_interface_type_man = {
    cmd_dnx_swstate_dnx_algo_port_logical_interface_type_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_logical_interface_type_desc[] = "dnx_algo_port_db logical interface_type commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_interface_type_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  logical_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("logical_idx_0", logical_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_logical_interface_type_dump(unit, logical_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_interface_type_dump_options[] = {
    {"logical_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_interface_type_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db logical interface_type dump [,logical_idx_0=<int>]\n",
    "dnx_algo_port_db logical interface_type dump logical_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_interface_type_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~INTERFACE_TYPE~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->logical[0].interface_type));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_interface_type_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_interface_type_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db logical interface_type size_get",
    "dnx_algo_port_db logical interface_type size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_interface_type_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~INTERFACE_TYPE~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_interface_type_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_interface_type_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db logical interface_type diagnostic_operation_counters",
    "dnx_algo_port_db logical interface_type diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_logical_interface_offset_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_logical_interface_offset_dump_cmd, NULL, dnx_swstate_dnx_algo_port_logical_interface_offset_dump_options, &dnx_swstate_dnx_algo_port_logical_interface_offset_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_logical_interface_offset_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_logical_interface_offset_size_get_options, &dnx_swstate_dnx_algo_port_logical_interface_offset_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_logical_interface_offset_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_logical_interface_offset_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_logical_interface_offset_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_interface_offset_man = {
    cmd_dnx_swstate_dnx_algo_port_logical_interface_offset_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_logical_interface_offset_desc[] = "dnx_algo_port_db logical interface_offset commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_interface_offset_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  logical_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("logical_idx_0", logical_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_logical_interface_offset_dump(unit, logical_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_interface_offset_dump_options[] = {
    {"logical_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_interface_offset_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db logical interface_offset dump [,logical_idx_0=<int>]\n",
    "dnx_algo_port_db logical interface_offset dump logical_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_interface_offset_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~INTERFACE_OFFSET~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->logical[0].interface_offset));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_interface_offset_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_interface_offset_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db logical interface_offset size_get",
    "dnx_algo_port_db logical interface_offset size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_interface_offset_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~INTERFACE_OFFSET~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_interface_offset_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_interface_offset_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db logical interface_offset diagnostic_operation_counters",
    "dnx_algo_port_db logical interface_offset diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_logical_nif_handle_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_logical_nif_handle_dump_cmd, NULL, dnx_swstate_dnx_algo_port_logical_nif_handle_dump_options, &dnx_swstate_dnx_algo_port_logical_nif_handle_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_logical_nif_handle_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_logical_nif_handle_size_get_options, &dnx_swstate_dnx_algo_port_logical_nif_handle_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_logical_nif_handle_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_logical_nif_handle_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_logical_nif_handle_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_nif_handle_man = {
    cmd_dnx_swstate_dnx_algo_port_logical_nif_handle_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_logical_nif_handle_desc[] = "dnx_algo_port_db logical nif_handle commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_nif_handle_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  logical_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("logical_idx_0", logical_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_logical_nif_handle_dump(unit, logical_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_nif_handle_dump_options[] = {
    {"logical_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_nif_handle_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db logical nif_handle dump [,logical_idx_0=<int>]\n",
    "dnx_algo_port_db logical nif_handle dump logical_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_nif_handle_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~NIF_HANDLE~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->logical[0].nif_handle));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_nif_handle_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_nif_handle_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db logical nif_handle size_get",
    "dnx_algo_port_db logical nif_handle size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_nif_handle_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~NIF_HANDLE~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_nif_handle_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_nif_handle_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db logical nif_handle diagnostic_operation_counters",
    "dnx_algo_port_db logical nif_handle diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_logical_tm_handle_cmds[] = {
    {"h0", NULL, sh_dnx_swstate_dnx_algo_port_logical_tm_handle_h0_cmds, NULL, &dnx_swstate_dnx_algo_port_logical_tm_handle_h0_man},
    {"h1", NULL, sh_dnx_swstate_dnx_algo_port_logical_tm_handle_h1_cmds, NULL, &dnx_swstate_dnx_algo_port_logical_tm_handle_h1_man},
    {"dump", sh_dnx_swstate_dnx_algo_port_logical_tm_handle_dump_cmd, NULL, dnx_swstate_dnx_algo_port_logical_tm_handle_dump_options, &dnx_swstate_dnx_algo_port_logical_tm_handle_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_logical_tm_handle_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_logical_tm_handle_size_get_options, &dnx_swstate_dnx_algo_port_logical_tm_handle_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_logical_tm_handle_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_logical_tm_handle_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_logical_tm_handle_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_tm_handle_man = {
    cmd_dnx_swstate_dnx_algo_port_logical_tm_handle_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_logical_tm_handle_desc[] = "dnx_algo_port_db logical tm_handle commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_tm_handle_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  logical_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("logical_idx_0", logical_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_logical_tm_handle_dump(unit, logical_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_tm_handle_dump_options[] = {
    {"logical_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_tm_handle_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db logical tm_handle dump [,logical_idx_0=<int>]\n",
    "dnx_algo_port_db logical tm_handle dump logical_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_tm_handle_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~TM_HANDLE~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->logical[0].tm_handle));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_tm_handle_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_tm_handle_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db logical tm_handle size_get",
    "dnx_algo_port_db logical tm_handle size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_tm_handle_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~TM_HANDLE~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_tm_handle_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_tm_handle_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db logical tm_handle diagnostic_operation_counters",
    "dnx_algo_port_db logical tm_handle diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_logical_tm_handle_h0_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_logical_tm_handle_h0_dump_cmd, NULL, dnx_swstate_dnx_algo_port_logical_tm_handle_h0_dump_options, &dnx_swstate_dnx_algo_port_logical_tm_handle_h0_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_logical_tm_handle_h0_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_logical_tm_handle_h0_size_get_options, &dnx_swstate_dnx_algo_port_logical_tm_handle_h0_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_logical_tm_handle_h0_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_logical_tm_handle_h0_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_logical_tm_handle_h0_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_tm_handle_h0_man = {
    cmd_dnx_swstate_dnx_algo_port_logical_tm_handle_h0_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_logical_tm_handle_h0_desc[] = "dnx_algo_port_db logical tm_handle h0 commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_tm_handle_h0_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  logical_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("logical_idx_0", logical_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_logical_tm_handle_h0_dump(unit, logical_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_tm_handle_h0_dump_options[] = {
    {"logical_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_tm_handle_h0_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db logical tm_handle h0 dump [,logical_idx_0=<int>]\n",
    "dnx_algo_port_db logical tm_handle h0 dump logical_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_tm_handle_h0_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~TM_HANDLE~H0~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->logical[0].tm_handle.h0));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_tm_handle_h0_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_tm_handle_h0_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db logical tm_handle h0 size_get",
    "dnx_algo_port_db logical tm_handle h0 size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_tm_handle_h0_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~TM_HANDLE~H0~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_tm_handle_h0_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_tm_handle_h0_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db logical tm_handle h0 diagnostic_operation_counters",
    "dnx_algo_port_db logical tm_handle h0 diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_logical_tm_handle_h1_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_logical_tm_handle_h1_dump_cmd, NULL, dnx_swstate_dnx_algo_port_logical_tm_handle_h1_dump_options, &dnx_swstate_dnx_algo_port_logical_tm_handle_h1_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_logical_tm_handle_h1_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_logical_tm_handle_h1_size_get_options, &dnx_swstate_dnx_algo_port_logical_tm_handle_h1_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_logical_tm_handle_h1_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_logical_tm_handle_h1_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_logical_tm_handle_h1_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_tm_handle_h1_man = {
    cmd_dnx_swstate_dnx_algo_port_logical_tm_handle_h1_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_logical_tm_handle_h1_desc[] = "dnx_algo_port_db logical tm_handle h1 commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_tm_handle_h1_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  logical_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("logical_idx_0", logical_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_logical_tm_handle_h1_dump(unit, logical_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_tm_handle_h1_dump_options[] = {
    {"logical_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_tm_handle_h1_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db logical tm_handle h1 dump [,logical_idx_0=<int>]\n",
    "dnx_algo_port_db logical tm_handle h1 dump logical_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_tm_handle_h1_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~TM_HANDLE~H1~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->logical[0].tm_handle.h1));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_tm_handle_h1_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_tm_handle_h1_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db logical tm_handle h1 size_get",
    "dnx_algo_port_db logical tm_handle h1 size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_tm_handle_h1_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~TM_HANDLE~H1~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_tm_handle_h1_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_tm_handle_h1_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db logical tm_handle h1 diagnostic_operation_counters",
    "dnx_algo_port_db logical tm_handle h1 diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_logical_sch_handle_cmds[] = {
    {"h0", NULL, sh_dnx_swstate_dnx_algo_port_logical_sch_handle_h0_cmds, NULL, &dnx_swstate_dnx_algo_port_logical_sch_handle_h0_man},
    {"h1", NULL, sh_dnx_swstate_dnx_algo_port_logical_sch_handle_h1_cmds, NULL, &dnx_swstate_dnx_algo_port_logical_sch_handle_h1_man},
    {"dump", sh_dnx_swstate_dnx_algo_port_logical_sch_handle_dump_cmd, NULL, dnx_swstate_dnx_algo_port_logical_sch_handle_dump_options, &dnx_swstate_dnx_algo_port_logical_sch_handle_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_logical_sch_handle_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_logical_sch_handle_size_get_options, &dnx_swstate_dnx_algo_port_logical_sch_handle_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_logical_sch_handle_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_logical_sch_handle_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_logical_sch_handle_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_sch_handle_man = {
    cmd_dnx_swstate_dnx_algo_port_logical_sch_handle_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_logical_sch_handle_desc[] = "dnx_algo_port_db logical sch_handle commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_sch_handle_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  logical_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("logical_idx_0", logical_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_logical_sch_handle_dump(unit, logical_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_sch_handle_dump_options[] = {
    {"logical_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_sch_handle_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db logical sch_handle dump [,logical_idx_0=<int>]\n",
    "dnx_algo_port_db logical sch_handle dump logical_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_sch_handle_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~SCH_HANDLE~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->logical[0].sch_handle));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_sch_handle_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_sch_handle_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db logical sch_handle size_get",
    "dnx_algo_port_db logical sch_handle size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_sch_handle_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~SCH_HANDLE~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_sch_handle_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_sch_handle_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db logical sch_handle diagnostic_operation_counters",
    "dnx_algo_port_db logical sch_handle diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_logical_sch_handle_h0_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_logical_sch_handle_h0_dump_cmd, NULL, dnx_swstate_dnx_algo_port_logical_sch_handle_h0_dump_options, &dnx_swstate_dnx_algo_port_logical_sch_handle_h0_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_logical_sch_handle_h0_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_logical_sch_handle_h0_size_get_options, &dnx_swstate_dnx_algo_port_logical_sch_handle_h0_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_logical_sch_handle_h0_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_logical_sch_handle_h0_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_logical_sch_handle_h0_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_sch_handle_h0_man = {
    cmd_dnx_swstate_dnx_algo_port_logical_sch_handle_h0_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_logical_sch_handle_h0_desc[] = "dnx_algo_port_db logical sch_handle h0 commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_sch_handle_h0_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  logical_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("logical_idx_0", logical_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_logical_sch_handle_h0_dump(unit, logical_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_sch_handle_h0_dump_options[] = {
    {"logical_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_sch_handle_h0_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db logical sch_handle h0 dump [,logical_idx_0=<int>]\n",
    "dnx_algo_port_db logical sch_handle h0 dump logical_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_sch_handle_h0_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~SCH_HANDLE~H0~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->logical[0].sch_handle.h0));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_sch_handle_h0_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_sch_handle_h0_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db logical sch_handle h0 size_get",
    "dnx_algo_port_db logical sch_handle h0 size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_sch_handle_h0_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~SCH_HANDLE~H0~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_sch_handle_h0_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_sch_handle_h0_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db logical sch_handle h0 diagnostic_operation_counters",
    "dnx_algo_port_db logical sch_handle h0 diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_logical_sch_handle_h1_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_logical_sch_handle_h1_dump_cmd, NULL, dnx_swstate_dnx_algo_port_logical_sch_handle_h1_dump_options, &dnx_swstate_dnx_algo_port_logical_sch_handle_h1_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_logical_sch_handle_h1_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_logical_sch_handle_h1_size_get_options, &dnx_swstate_dnx_algo_port_logical_sch_handle_h1_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_logical_sch_handle_h1_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_logical_sch_handle_h1_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_logical_sch_handle_h1_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_sch_handle_h1_man = {
    cmd_dnx_swstate_dnx_algo_port_logical_sch_handle_h1_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_logical_sch_handle_h1_desc[] = "dnx_algo_port_db logical sch_handle h1 commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_sch_handle_h1_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  logical_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("logical_idx_0", logical_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_logical_sch_handle_h1_dump(unit, logical_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_sch_handle_h1_dump_options[] = {
    {"logical_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_sch_handle_h1_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db logical sch_handle h1 dump [,logical_idx_0=<int>]\n",
    "dnx_algo_port_db logical sch_handle h1 dump logical_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_sch_handle_h1_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~SCH_HANDLE~H1~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->logical[0].sch_handle.h1));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_sch_handle_h1_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_sch_handle_h1_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db logical sch_handle h1 size_get",
    "dnx_algo_port_db logical sch_handle h1 size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_sch_handle_h1_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~SCH_HANDLE~H1~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_sch_handle_h1_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_sch_handle_h1_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db logical sch_handle h1 diagnostic_operation_counters",
    "dnx_algo_port_db logical sch_handle h1 diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_logical_sch_if_handle_cmds[] = {
    {"h0", NULL, sh_dnx_swstate_dnx_algo_port_logical_sch_if_handle_h0_cmds, NULL, &dnx_swstate_dnx_algo_port_logical_sch_if_handle_h0_man},
    {"h1", NULL, sh_dnx_swstate_dnx_algo_port_logical_sch_if_handle_h1_cmds, NULL, &dnx_swstate_dnx_algo_port_logical_sch_if_handle_h1_man},
    {"dump", sh_dnx_swstate_dnx_algo_port_logical_sch_if_handle_dump_cmd, NULL, dnx_swstate_dnx_algo_port_logical_sch_if_handle_dump_options, &dnx_swstate_dnx_algo_port_logical_sch_if_handle_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_logical_sch_if_handle_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_logical_sch_if_handle_size_get_options, &dnx_swstate_dnx_algo_port_logical_sch_if_handle_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_logical_sch_if_handle_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_logical_sch_if_handle_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_logical_sch_if_handle_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_sch_if_handle_man = {
    cmd_dnx_swstate_dnx_algo_port_logical_sch_if_handle_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_logical_sch_if_handle_desc[] = "dnx_algo_port_db logical sch_if_handle commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_sch_if_handle_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  logical_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("logical_idx_0", logical_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_logical_sch_if_handle_dump(unit, logical_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_sch_if_handle_dump_options[] = {
    {"logical_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_sch_if_handle_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db logical sch_if_handle dump [,logical_idx_0=<int>]\n",
    "dnx_algo_port_db logical sch_if_handle dump logical_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_sch_if_handle_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~SCH_IF_HANDLE~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->logical[0].sch_if_handle));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_sch_if_handle_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_sch_if_handle_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db logical sch_if_handle size_get",
    "dnx_algo_port_db logical sch_if_handle size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_sch_if_handle_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~SCH_IF_HANDLE~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_sch_if_handle_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_sch_if_handle_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db logical sch_if_handle diagnostic_operation_counters",
    "dnx_algo_port_db logical sch_if_handle diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_logical_sch_if_handle_h0_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_logical_sch_if_handle_h0_dump_cmd, NULL, dnx_swstate_dnx_algo_port_logical_sch_if_handle_h0_dump_options, &dnx_swstate_dnx_algo_port_logical_sch_if_handle_h0_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_logical_sch_if_handle_h0_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_logical_sch_if_handle_h0_size_get_options, &dnx_swstate_dnx_algo_port_logical_sch_if_handle_h0_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_logical_sch_if_handle_h0_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_logical_sch_if_handle_h0_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_logical_sch_if_handle_h0_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_sch_if_handle_h0_man = {
    cmd_dnx_swstate_dnx_algo_port_logical_sch_if_handle_h0_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_logical_sch_if_handle_h0_desc[] = "dnx_algo_port_db logical sch_if_handle h0 commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_sch_if_handle_h0_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  logical_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("logical_idx_0", logical_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_logical_sch_if_handle_h0_dump(unit, logical_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_sch_if_handle_h0_dump_options[] = {
    {"logical_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_sch_if_handle_h0_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db logical sch_if_handle h0 dump [,logical_idx_0=<int>]\n",
    "dnx_algo_port_db logical sch_if_handle h0 dump logical_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_sch_if_handle_h0_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~SCH_IF_HANDLE~H0~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->logical[0].sch_if_handle.h0));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_sch_if_handle_h0_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_sch_if_handle_h0_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db logical sch_if_handle h0 size_get",
    "dnx_algo_port_db logical sch_if_handle h0 size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_sch_if_handle_h0_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~SCH_IF_HANDLE~H0~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_sch_if_handle_h0_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_sch_if_handle_h0_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db logical sch_if_handle h0 diagnostic_operation_counters",
    "dnx_algo_port_db logical sch_if_handle h0 diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_logical_sch_if_handle_h1_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_logical_sch_if_handle_h1_dump_cmd, NULL, dnx_swstate_dnx_algo_port_logical_sch_if_handle_h1_dump_options, &dnx_swstate_dnx_algo_port_logical_sch_if_handle_h1_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_logical_sch_if_handle_h1_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_logical_sch_if_handle_h1_size_get_options, &dnx_swstate_dnx_algo_port_logical_sch_if_handle_h1_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_logical_sch_if_handle_h1_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_logical_sch_if_handle_h1_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_logical_sch_if_handle_h1_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_sch_if_handle_h1_man = {
    cmd_dnx_swstate_dnx_algo_port_logical_sch_if_handle_h1_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_logical_sch_if_handle_h1_desc[] = "dnx_algo_port_db logical sch_if_handle h1 commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_sch_if_handle_h1_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  logical_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("logical_idx_0", logical_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_logical_sch_if_handle_h1_dump(unit, logical_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_sch_if_handle_h1_dump_options[] = {
    {"logical_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_sch_if_handle_h1_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db logical sch_if_handle h1 dump [,logical_idx_0=<int>]\n",
    "dnx_algo_port_db logical sch_if_handle h1 dump logical_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_sch_if_handle_h1_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~SCH_IF_HANDLE~H1~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->logical[0].sch_if_handle.h1));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_sch_if_handle_h1_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_sch_if_handle_h1_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db logical sch_if_handle h1 size_get",
    "dnx_algo_port_db logical sch_if_handle h1 size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_sch_if_handle_h1_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~SCH_IF_HANDLE~H1~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_sch_if_handle_h1_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_sch_if_handle_h1_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db logical sch_if_handle h1 diagnostic_operation_counters",
    "dnx_algo_port_db logical sch_if_handle h1 diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_logical_pp_handle_cmds[] = {
    {"h0", NULL, sh_dnx_swstate_dnx_algo_port_logical_pp_handle_h0_cmds, NULL, &dnx_swstate_dnx_algo_port_logical_pp_handle_h0_man},
    {"h1", NULL, sh_dnx_swstate_dnx_algo_port_logical_pp_handle_h1_cmds, NULL, &dnx_swstate_dnx_algo_port_logical_pp_handle_h1_man},
    {"dump", sh_dnx_swstate_dnx_algo_port_logical_pp_handle_dump_cmd, NULL, dnx_swstate_dnx_algo_port_logical_pp_handle_dump_options, &dnx_swstate_dnx_algo_port_logical_pp_handle_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_logical_pp_handle_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_logical_pp_handle_size_get_options, &dnx_swstate_dnx_algo_port_logical_pp_handle_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_logical_pp_handle_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_logical_pp_handle_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_logical_pp_handle_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_pp_handle_man = {
    cmd_dnx_swstate_dnx_algo_port_logical_pp_handle_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_logical_pp_handle_desc[] = "dnx_algo_port_db logical pp_handle commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_pp_handle_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  logical_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("logical_idx_0", logical_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_logical_pp_handle_dump(unit, logical_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_pp_handle_dump_options[] = {
    {"logical_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_pp_handle_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db logical pp_handle dump [,logical_idx_0=<int>]\n",
    "dnx_algo_port_db logical pp_handle dump logical_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_pp_handle_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~PP_HANDLE~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->logical[0].pp_handle));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_pp_handle_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_pp_handle_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db logical pp_handle size_get",
    "dnx_algo_port_db logical pp_handle size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_pp_handle_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~PP_HANDLE~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_pp_handle_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_pp_handle_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db logical pp_handle diagnostic_operation_counters",
    "dnx_algo_port_db logical pp_handle diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_logical_pp_handle_h0_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_logical_pp_handle_h0_dump_cmd, NULL, dnx_swstate_dnx_algo_port_logical_pp_handle_h0_dump_options, &dnx_swstate_dnx_algo_port_logical_pp_handle_h0_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_logical_pp_handle_h0_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_logical_pp_handle_h0_size_get_options, &dnx_swstate_dnx_algo_port_logical_pp_handle_h0_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_logical_pp_handle_h0_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_logical_pp_handle_h0_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_logical_pp_handle_h0_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_pp_handle_h0_man = {
    cmd_dnx_swstate_dnx_algo_port_logical_pp_handle_h0_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_logical_pp_handle_h0_desc[] = "dnx_algo_port_db logical pp_handle h0 commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_pp_handle_h0_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  logical_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("logical_idx_0", logical_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_logical_pp_handle_h0_dump(unit, logical_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_pp_handle_h0_dump_options[] = {
    {"logical_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_pp_handle_h0_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db logical pp_handle h0 dump [,logical_idx_0=<int>]\n",
    "dnx_algo_port_db logical pp_handle h0 dump logical_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_pp_handle_h0_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~PP_HANDLE~H0~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->logical[0].pp_handle.h0));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_pp_handle_h0_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_pp_handle_h0_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db logical pp_handle h0 size_get",
    "dnx_algo_port_db logical pp_handle h0 size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_pp_handle_h0_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~PP_HANDLE~H0~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_pp_handle_h0_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_pp_handle_h0_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db logical pp_handle h0 diagnostic_operation_counters",
    "dnx_algo_port_db logical pp_handle h0 diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_logical_pp_handle_h1_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_logical_pp_handle_h1_dump_cmd, NULL, dnx_swstate_dnx_algo_port_logical_pp_handle_h1_dump_options, &dnx_swstate_dnx_algo_port_logical_pp_handle_h1_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_logical_pp_handle_h1_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_logical_pp_handle_h1_size_get_options, &dnx_swstate_dnx_algo_port_logical_pp_handle_h1_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_logical_pp_handle_h1_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_logical_pp_handle_h1_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_logical_pp_handle_h1_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_pp_handle_h1_man = {
    cmd_dnx_swstate_dnx_algo_port_logical_pp_handle_h1_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_logical_pp_handle_h1_desc[] = "dnx_algo_port_db logical pp_handle h1 commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_pp_handle_h1_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  logical_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("logical_idx_0", logical_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_logical_pp_handle_h1_dump(unit, logical_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_pp_handle_h1_dump_options[] = {
    {"logical_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_pp_handle_h1_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db logical pp_handle h1 dump [,logical_idx_0=<int>]\n",
    "dnx_algo_port_db logical pp_handle h1 dump logical_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_pp_handle_h1_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~PP_HANDLE~H1~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->logical[0].pp_handle.h1));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_pp_handle_h1_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_pp_handle_h1_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db logical pp_handle h1 size_get",
    "dnx_algo_port_db logical pp_handle h1 size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_pp_handle_h1_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~PP_HANDLE~H1~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_pp_handle_h1_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_pp_handle_h1_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db logical pp_handle h1 diagnostic_operation_counters",
    "dnx_algo_port_db logical pp_handle h1 diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_logical_ilkn_handle_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_logical_ilkn_handle_dump_cmd, NULL, dnx_swstate_dnx_algo_port_logical_ilkn_handle_dump_options, &dnx_swstate_dnx_algo_port_logical_ilkn_handle_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_logical_ilkn_handle_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_logical_ilkn_handle_size_get_options, &dnx_swstate_dnx_algo_port_logical_ilkn_handle_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_logical_ilkn_handle_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_logical_ilkn_handle_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_logical_ilkn_handle_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_ilkn_handle_man = {
    cmd_dnx_swstate_dnx_algo_port_logical_ilkn_handle_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_logical_ilkn_handle_desc[] = "dnx_algo_port_db logical ilkn_handle commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_ilkn_handle_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  logical_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("logical_idx_0", logical_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_logical_ilkn_handle_dump(unit, logical_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_ilkn_handle_dump_options[] = {
    {"logical_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_ilkn_handle_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db logical ilkn_handle dump [,logical_idx_0=<int>]\n",
    "dnx_algo_port_db logical ilkn_handle dump logical_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_ilkn_handle_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~ILKN_HANDLE~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->logical[0].ilkn_handle));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_ilkn_handle_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_ilkn_handle_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db logical ilkn_handle size_get",
    "dnx_algo_port_db logical ilkn_handle size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_ilkn_handle_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~ILKN_HANDLE~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_ilkn_handle_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_ilkn_handle_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db logical ilkn_handle diagnostic_operation_counters",
    "dnx_algo_port_db logical ilkn_handle diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_logical_flexe_client_handle_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_logical_flexe_client_handle_dump_cmd, NULL, dnx_swstate_dnx_algo_port_logical_flexe_client_handle_dump_options, &dnx_swstate_dnx_algo_port_logical_flexe_client_handle_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_logical_flexe_client_handle_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_logical_flexe_client_handle_size_get_options, &dnx_swstate_dnx_algo_port_logical_flexe_client_handle_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_logical_flexe_client_handle_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_logical_flexe_client_handle_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_logical_flexe_client_handle_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_flexe_client_handle_man = {
    cmd_dnx_swstate_dnx_algo_port_logical_flexe_client_handle_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_logical_flexe_client_handle_desc[] = "dnx_algo_port_db logical flexe_client_handle commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_flexe_client_handle_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  logical_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("logical_idx_0", logical_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_logical_flexe_client_handle_dump(unit, logical_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_flexe_client_handle_dump_options[] = {
    {"logical_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_flexe_client_handle_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db logical flexe_client_handle dump [,logical_idx_0=<int>]\n",
    "dnx_algo_port_db logical flexe_client_handle dump logical_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_flexe_client_handle_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~FLEXE_CLIENT_HANDLE~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->logical[0].flexe_client_handle));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_flexe_client_handle_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_flexe_client_handle_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db logical flexe_client_handle size_get",
    "dnx_algo_port_db logical flexe_client_handle size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_flexe_client_handle_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~FLEXE_CLIENT_HANDLE~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_flexe_client_handle_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_flexe_client_handle_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db logical flexe_client_handle diagnostic_operation_counters",
    "dnx_algo_port_db logical flexe_client_handle diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_logical_flexe_mac_handle_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_logical_flexe_mac_handle_dump_cmd, NULL, dnx_swstate_dnx_algo_port_logical_flexe_mac_handle_dump_options, &dnx_swstate_dnx_algo_port_logical_flexe_mac_handle_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_logical_flexe_mac_handle_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_logical_flexe_mac_handle_size_get_options, &dnx_swstate_dnx_algo_port_logical_flexe_mac_handle_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_logical_flexe_mac_handle_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_logical_flexe_mac_handle_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_logical_flexe_mac_handle_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_flexe_mac_handle_man = {
    cmd_dnx_swstate_dnx_algo_port_logical_flexe_mac_handle_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_logical_flexe_mac_handle_desc[] = "dnx_algo_port_db logical flexe_mac_handle commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_flexe_mac_handle_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  logical_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("logical_idx_0", logical_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_logical_flexe_mac_handle_dump(unit, logical_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_flexe_mac_handle_dump_options[] = {
    {"logical_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_flexe_mac_handle_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db logical flexe_mac_handle dump [,logical_idx_0=<int>]\n",
    "dnx_algo_port_db logical flexe_mac_handle dump logical_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_flexe_mac_handle_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~FLEXE_MAC_HANDLE~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->logical[0].flexe_mac_handle));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_flexe_mac_handle_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_flexe_mac_handle_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db logical flexe_mac_handle size_get",
    "dnx_algo_port_db logical flexe_mac_handle size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_flexe_mac_handle_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~FLEXE_MAC_HANDLE~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_flexe_mac_handle_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_flexe_mac_handle_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db logical flexe_mac_handle diagnostic_operation_counters",
    "dnx_algo_port_db logical flexe_mac_handle diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_logical_flexe_sar_handle_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_logical_flexe_sar_handle_dump_cmd, NULL, dnx_swstate_dnx_algo_port_logical_flexe_sar_handle_dump_options, &dnx_swstate_dnx_algo_port_logical_flexe_sar_handle_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_logical_flexe_sar_handle_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_logical_flexe_sar_handle_size_get_options, &dnx_swstate_dnx_algo_port_logical_flexe_sar_handle_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_logical_flexe_sar_handle_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_logical_flexe_sar_handle_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_logical_flexe_sar_handle_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_flexe_sar_handle_man = {
    cmd_dnx_swstate_dnx_algo_port_logical_flexe_sar_handle_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_logical_flexe_sar_handle_desc[] = "dnx_algo_port_db logical flexe_sar_handle commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_flexe_sar_handle_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  logical_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("logical_idx_0", logical_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_logical_flexe_sar_handle_dump(unit, logical_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_flexe_sar_handle_dump_options[] = {
    {"logical_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_flexe_sar_handle_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db logical flexe_sar_handle dump [,logical_idx_0=<int>]\n",
    "dnx_algo_port_db logical flexe_sar_handle dump logical_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_flexe_sar_handle_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~FLEXE_SAR_HANDLE~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->logical[0].flexe_sar_handle));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_flexe_sar_handle_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_flexe_sar_handle_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db logical flexe_sar_handle size_get",
    "dnx_algo_port_db logical flexe_sar_handle size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_flexe_sar_handle_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~FLEXE_SAR_HANDLE~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_flexe_sar_handle_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_flexe_sar_handle_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db logical flexe_sar_handle diagnostic_operation_counters",
    "dnx_algo_port_db logical flexe_sar_handle diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_logical_flexe_phy_handle_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_logical_flexe_phy_handle_dump_cmd, NULL, dnx_swstate_dnx_algo_port_logical_flexe_phy_handle_dump_options, &dnx_swstate_dnx_algo_port_logical_flexe_phy_handle_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_logical_flexe_phy_handle_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_logical_flexe_phy_handle_size_get_options, &dnx_swstate_dnx_algo_port_logical_flexe_phy_handle_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_logical_flexe_phy_handle_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_logical_flexe_phy_handle_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_logical_flexe_phy_handle_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_flexe_phy_handle_man = {
    cmd_dnx_swstate_dnx_algo_port_logical_flexe_phy_handle_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_logical_flexe_phy_handle_desc[] = "dnx_algo_port_db logical flexe_phy_handle commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_flexe_phy_handle_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  logical_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("logical_idx_0", logical_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_logical_flexe_phy_handle_dump(unit, logical_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_flexe_phy_handle_dump_options[] = {
    {"logical_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_flexe_phy_handle_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db logical flexe_phy_handle dump [,logical_idx_0=<int>]\n",
    "dnx_algo_port_db logical flexe_phy_handle dump logical_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_flexe_phy_handle_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~FLEXE_PHY_HANDLE~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->logical[0].flexe_phy_handle));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_flexe_phy_handle_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_flexe_phy_handle_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db logical flexe_phy_handle size_get",
    "dnx_algo_port_db logical flexe_phy_handle size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_flexe_phy_handle_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~FLEXE_PHY_HANDLE~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_flexe_phy_handle_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_flexe_phy_handle_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db logical flexe_phy_handle diagnostic_operation_counters",
    "dnx_algo_port_db logical flexe_phy_handle diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_logical_tm_interface_handle_cmds[] = {
    {"h0", NULL, sh_dnx_swstate_dnx_algo_port_logical_tm_interface_handle_h0_cmds, NULL, &dnx_swstate_dnx_algo_port_logical_tm_interface_handle_h0_man},
    {"h1", NULL, sh_dnx_swstate_dnx_algo_port_logical_tm_interface_handle_h1_cmds, NULL, &dnx_swstate_dnx_algo_port_logical_tm_interface_handle_h1_man},
    {"dump", sh_dnx_swstate_dnx_algo_port_logical_tm_interface_handle_dump_cmd, NULL, dnx_swstate_dnx_algo_port_logical_tm_interface_handle_dump_options, &dnx_swstate_dnx_algo_port_logical_tm_interface_handle_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_logical_tm_interface_handle_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_logical_tm_interface_handle_size_get_options, &dnx_swstate_dnx_algo_port_logical_tm_interface_handle_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_logical_tm_interface_handle_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_logical_tm_interface_handle_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_logical_tm_interface_handle_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_tm_interface_handle_man = {
    cmd_dnx_swstate_dnx_algo_port_logical_tm_interface_handle_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_logical_tm_interface_handle_desc[] = "dnx_algo_port_db logical tm_interface_handle commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_tm_interface_handle_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  logical_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("logical_idx_0", logical_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_logical_tm_interface_handle_dump(unit, logical_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_tm_interface_handle_dump_options[] = {
    {"logical_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_tm_interface_handle_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db logical tm_interface_handle dump [,logical_idx_0=<int>]\n",
    "dnx_algo_port_db logical tm_interface_handle dump logical_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_tm_interface_handle_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~TM_INTERFACE_HANDLE~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->logical[0].tm_interface_handle));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_tm_interface_handle_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_tm_interface_handle_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db logical tm_interface_handle size_get",
    "dnx_algo_port_db logical tm_interface_handle size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_tm_interface_handle_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~TM_INTERFACE_HANDLE~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_tm_interface_handle_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_tm_interface_handle_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db logical tm_interface_handle diagnostic_operation_counters",
    "dnx_algo_port_db logical tm_interface_handle diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_logical_tm_interface_handle_h0_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_logical_tm_interface_handle_h0_dump_cmd, NULL, dnx_swstate_dnx_algo_port_logical_tm_interface_handle_h0_dump_options, &dnx_swstate_dnx_algo_port_logical_tm_interface_handle_h0_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_logical_tm_interface_handle_h0_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_logical_tm_interface_handle_h0_size_get_options, &dnx_swstate_dnx_algo_port_logical_tm_interface_handle_h0_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_logical_tm_interface_handle_h0_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_logical_tm_interface_handle_h0_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_logical_tm_interface_handle_h0_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_tm_interface_handle_h0_man = {
    cmd_dnx_swstate_dnx_algo_port_logical_tm_interface_handle_h0_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_logical_tm_interface_handle_h0_desc[] = "dnx_algo_port_db logical tm_interface_handle h0 commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_tm_interface_handle_h0_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  logical_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("logical_idx_0", logical_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_logical_tm_interface_handle_h0_dump(unit, logical_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_tm_interface_handle_h0_dump_options[] = {
    {"logical_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_tm_interface_handle_h0_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db logical tm_interface_handle h0 dump [,logical_idx_0=<int>]\n",
    "dnx_algo_port_db logical tm_interface_handle h0 dump logical_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_tm_interface_handle_h0_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~TM_INTERFACE_HANDLE~H0~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->logical[0].tm_interface_handle.h0));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_tm_interface_handle_h0_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_tm_interface_handle_h0_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db logical tm_interface_handle h0 size_get",
    "dnx_algo_port_db logical tm_interface_handle h0 size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_tm_interface_handle_h0_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~TM_INTERFACE_HANDLE~H0~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_tm_interface_handle_h0_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_tm_interface_handle_h0_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db logical tm_interface_handle h0 diagnostic_operation_counters",
    "dnx_algo_port_db logical tm_interface_handle h0 diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_logical_tm_interface_handle_h1_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_logical_tm_interface_handle_h1_dump_cmd, NULL, dnx_swstate_dnx_algo_port_logical_tm_interface_handle_h1_dump_options, &dnx_swstate_dnx_algo_port_logical_tm_interface_handle_h1_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_logical_tm_interface_handle_h1_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_logical_tm_interface_handle_h1_size_get_options, &dnx_swstate_dnx_algo_port_logical_tm_interface_handle_h1_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_logical_tm_interface_handle_h1_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_logical_tm_interface_handle_h1_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_logical_tm_interface_handle_h1_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_tm_interface_handle_h1_man = {
    cmd_dnx_swstate_dnx_algo_port_logical_tm_interface_handle_h1_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_logical_tm_interface_handle_h1_desc[] = "dnx_algo_port_db logical tm_interface_handle h1 commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_tm_interface_handle_h1_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  logical_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("logical_idx_0", logical_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_logical_tm_interface_handle_h1_dump(unit, logical_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_tm_interface_handle_h1_dump_options[] = {
    {"logical_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_tm_interface_handle_h1_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db logical tm_interface_handle h1 dump [,logical_idx_0=<int>]\n",
    "dnx_algo_port_db logical tm_interface_handle h1 dump logical_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_tm_interface_handle_h1_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~TM_INTERFACE_HANDLE~H1~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->logical[0].tm_interface_handle.h1));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_tm_interface_handle_h1_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_tm_interface_handle_h1_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db logical tm_interface_handle h1 size_get",
    "dnx_algo_port_db logical tm_interface_handle h1 size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_tm_interface_handle_h1_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~TM_INTERFACE_HANDLE~H1~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_tm_interface_handle_h1_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_tm_interface_handle_h1_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db logical tm_interface_handle h1 diagnostic_operation_counters",
    "dnx_algo_port_db logical tm_interface_handle h1 diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_logical_interface_handle_cmds[] = {
    {"h0", NULL, sh_dnx_swstate_dnx_algo_port_logical_interface_handle_h0_cmds, NULL, &dnx_swstate_dnx_algo_port_logical_interface_handle_h0_man},
    {"h1", NULL, sh_dnx_swstate_dnx_algo_port_logical_interface_handle_h1_cmds, NULL, &dnx_swstate_dnx_algo_port_logical_interface_handle_h1_man},
    {"dump", sh_dnx_swstate_dnx_algo_port_logical_interface_handle_dump_cmd, NULL, dnx_swstate_dnx_algo_port_logical_interface_handle_dump_options, &dnx_swstate_dnx_algo_port_logical_interface_handle_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_logical_interface_handle_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_logical_interface_handle_size_get_options, &dnx_swstate_dnx_algo_port_logical_interface_handle_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_logical_interface_handle_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_logical_interface_handle_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_logical_interface_handle_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_interface_handle_man = {
    cmd_dnx_swstate_dnx_algo_port_logical_interface_handle_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_logical_interface_handle_desc[] = "dnx_algo_port_db logical interface_handle commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_interface_handle_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  logical_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("logical_idx_0", logical_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_logical_interface_handle_dump(unit, logical_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_interface_handle_dump_options[] = {
    {"logical_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_interface_handle_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db logical interface_handle dump [,logical_idx_0=<int>]\n",
    "dnx_algo_port_db logical interface_handle dump logical_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_interface_handle_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~INTERFACE_HANDLE~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->logical[0].interface_handle));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_interface_handle_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_interface_handle_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db logical interface_handle size_get",
    "dnx_algo_port_db logical interface_handle size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_interface_handle_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~INTERFACE_HANDLE~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_interface_handle_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_interface_handle_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db logical interface_handle diagnostic_operation_counters",
    "dnx_algo_port_db logical interface_handle diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_logical_interface_handle_h0_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_logical_interface_handle_h0_dump_cmd, NULL, dnx_swstate_dnx_algo_port_logical_interface_handle_h0_dump_options, &dnx_swstate_dnx_algo_port_logical_interface_handle_h0_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_logical_interface_handle_h0_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_logical_interface_handle_h0_size_get_options, &dnx_swstate_dnx_algo_port_logical_interface_handle_h0_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_logical_interface_handle_h0_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_logical_interface_handle_h0_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_logical_interface_handle_h0_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_interface_handle_h0_man = {
    cmd_dnx_swstate_dnx_algo_port_logical_interface_handle_h0_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_logical_interface_handle_h0_desc[] = "dnx_algo_port_db logical interface_handle h0 commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_interface_handle_h0_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  logical_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("logical_idx_0", logical_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_logical_interface_handle_h0_dump(unit, logical_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_interface_handle_h0_dump_options[] = {
    {"logical_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_interface_handle_h0_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db logical interface_handle h0 dump [,logical_idx_0=<int>]\n",
    "dnx_algo_port_db logical interface_handle h0 dump logical_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_interface_handle_h0_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~INTERFACE_HANDLE~H0~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->logical[0].interface_handle.h0));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_interface_handle_h0_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_interface_handle_h0_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db logical interface_handle h0 size_get",
    "dnx_algo_port_db logical interface_handle h0 size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_interface_handle_h0_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~INTERFACE_HANDLE~H0~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_interface_handle_h0_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_interface_handle_h0_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db logical interface_handle h0 diagnostic_operation_counters",
    "dnx_algo_port_db logical interface_handle h0 diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_logical_interface_handle_h1_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_logical_interface_handle_h1_dump_cmd, NULL, dnx_swstate_dnx_algo_port_logical_interface_handle_h1_dump_options, &dnx_swstate_dnx_algo_port_logical_interface_handle_h1_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_logical_interface_handle_h1_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_logical_interface_handle_h1_size_get_options, &dnx_swstate_dnx_algo_port_logical_interface_handle_h1_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_logical_interface_handle_h1_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_logical_interface_handle_h1_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_logical_interface_handle_h1_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_interface_handle_h1_man = {
    cmd_dnx_swstate_dnx_algo_port_logical_interface_handle_h1_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_logical_interface_handle_h1_desc[] = "dnx_algo_port_db logical interface_handle h1 commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_interface_handle_h1_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  logical_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("logical_idx_0", logical_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_logical_interface_handle_h1_dump(unit, logical_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_interface_handle_h1_dump_options[] = {
    {"logical_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_interface_handle_h1_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db logical interface_handle h1 dump [,logical_idx_0=<int>]\n",
    "dnx_algo_port_db logical interface_handle h1 dump logical_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_interface_handle_h1_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~INTERFACE_HANDLE~H1~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->logical[0].interface_handle.h1));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_interface_handle_h1_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_interface_handle_h1_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db logical interface_handle h1 size_get",
    "dnx_algo_port_db logical interface_handle h1 size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_interface_handle_h1_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~INTERFACE_HANDLE~H1~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_interface_handle_h1_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_interface_handle_h1_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db logical interface_handle h1 diagnostic_operation_counters",
    "dnx_algo_port_db logical interface_handle h1 diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_logical_fabric_handle_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_logical_fabric_handle_dump_cmd, NULL, dnx_swstate_dnx_algo_port_logical_fabric_handle_dump_options, &dnx_swstate_dnx_algo_port_logical_fabric_handle_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_logical_fabric_handle_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_logical_fabric_handle_size_get_options, &dnx_swstate_dnx_algo_port_logical_fabric_handle_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_logical_fabric_handle_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_logical_fabric_handle_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_logical_fabric_handle_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_fabric_handle_man = {
    cmd_dnx_swstate_dnx_algo_port_logical_fabric_handle_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_logical_fabric_handle_desc[] = "dnx_algo_port_db logical fabric_handle commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_fabric_handle_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  logical_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("logical_idx_0", logical_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_logical_fabric_handle_dump(unit, logical_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_fabric_handle_dump_options[] = {
    {"logical_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_fabric_handle_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db logical fabric_handle dump [,logical_idx_0=<int>]\n",
    "dnx_algo_port_db logical fabric_handle dump logical_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_fabric_handle_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~FABRIC_HANDLE~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->logical[0].fabric_handle));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_fabric_handle_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_fabric_handle_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db logical fabric_handle size_get",
    "dnx_algo_port_db logical fabric_handle size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_fabric_handle_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~FABRIC_HANDLE~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_fabric_handle_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_fabric_handle_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db logical fabric_handle diagnostic_operation_counters",
    "dnx_algo_port_db logical fabric_handle diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_logical_channel_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_logical_channel_dump_cmd, NULL, dnx_swstate_dnx_algo_port_logical_channel_dump_options, &dnx_swstate_dnx_algo_port_logical_channel_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_logical_channel_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_logical_channel_size_get_options, &dnx_swstate_dnx_algo_port_logical_channel_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_logical_channel_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_logical_channel_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_logical_channel_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_channel_man = {
    cmd_dnx_swstate_dnx_algo_port_logical_channel_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_logical_channel_desc[] = "dnx_algo_port_db logical channel commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_channel_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  logical_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("logical_idx_0", logical_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_logical_channel_dump(unit, logical_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_channel_dump_options[] = {
    {"logical_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_channel_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db logical channel dump [,logical_idx_0=<int>]\n",
    "dnx_algo_port_db logical channel dump logical_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_channel_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~CHANNEL~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->logical[0].channel));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_channel_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_channel_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db logical channel size_get",
    "dnx_algo_port_db logical channel size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_logical_channel_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~LOGICAL~CHANNEL~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_logical_channel_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_logical_channel_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db logical channel diagnostic_operation_counters",
    "dnx_algo_port_db logical channel diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_nif_cmds[] = {
    {"valid", NULL, sh_dnx_swstate_dnx_algo_port_nif_valid_cmds, NULL, &dnx_swstate_dnx_algo_port_nif_valid_man},
    {"phys", NULL, sh_dnx_swstate_dnx_algo_port_nif_phys_cmds, NULL, &dnx_swstate_dnx_algo_port_nif_phys_man},
    {"first_phy", NULL, sh_dnx_swstate_dnx_algo_port_nif_first_phy_cmds, NULL, &dnx_swstate_dnx_algo_port_nif_first_phy_man},
    {"master_logical_port", NULL, sh_dnx_swstate_dnx_algo_port_nif_master_logical_port_cmds, NULL, &dnx_swstate_dnx_algo_port_nif_master_logical_port_man},
    {"logical_fifos", NULL, sh_dnx_swstate_dnx_algo_port_nif_logical_fifos_cmds, NULL, &dnx_swstate_dnx_algo_port_nif_logical_fifos_man},
    {"latch_down", NULL, sh_dnx_swstate_dnx_algo_port_nif_latch_down_cmds, NULL, &dnx_swstate_dnx_algo_port_nif_latch_down_man},
    {"loopback_original_link_training", NULL, sh_dnx_swstate_dnx_algo_port_nif_loopback_original_link_training_cmds, NULL, &dnx_swstate_dnx_algo_port_nif_loopback_original_link_training_man},
    {"loopback_original_phy_lane_config", NULL, sh_dnx_swstate_dnx_algo_port_nif_loopback_original_phy_lane_config_cmds, NULL, &dnx_swstate_dnx_algo_port_nif_loopback_original_phy_lane_config_man},
    {"dump", sh_dnx_swstate_dnx_algo_port_nif_dump_cmd, NULL, dnx_swstate_dnx_algo_port_nif_dump_options, &dnx_swstate_dnx_algo_port_nif_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_nif_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_nif_size_get_options, &dnx_swstate_dnx_algo_port_nif_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_nif_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_nif_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_nif_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_nif_man = {
    cmd_dnx_swstate_dnx_algo_port_nif_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_nif_desc[] = "dnx_algo_port_db nif commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_nif_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  nif_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("nif_idx_0", nif_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_nif_dump(unit, nif_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_nif_dump_options[] = {
    {"nif_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_nif_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db nif dump [,nif_idx_0=<int>]\n",
    "dnx_algo_port_db nif dump nif_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_nif_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~NIF~", 0);
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_nif_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_nif_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db nif size_get",
    "dnx_algo_port_db nif size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_nif_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~NIF~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_nif_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_nif_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db nif diagnostic_operation_counters",
    "dnx_algo_port_db nif diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_nif_valid_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_nif_valid_dump_cmd, NULL, dnx_swstate_dnx_algo_port_nif_valid_dump_options, &dnx_swstate_dnx_algo_port_nif_valid_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_nif_valid_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_nif_valid_size_get_options, &dnx_swstate_dnx_algo_port_nif_valid_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_nif_valid_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_nif_valid_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_nif_valid_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_nif_valid_man = {
    cmd_dnx_swstate_dnx_algo_port_nif_valid_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_nif_valid_desc[] = "dnx_algo_port_db nif valid commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_nif_valid_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  nif_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("nif_idx_0", nif_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_nif_valid_dump(unit, nif_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_nif_valid_dump_options[] = {
    {"nif_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_nif_valid_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db nif valid dump [,nif_idx_0=<int>]\n",
    "dnx_algo_port_db nif valid dump nif_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_nif_valid_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~NIF~VALID~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->nif[0].valid));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_nif_valid_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_nif_valid_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db nif valid size_get",
    "dnx_algo_port_db nif valid size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_nif_valid_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~NIF~VALID~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_nif_valid_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_nif_valid_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db nif valid diagnostic_operation_counters",
    "dnx_algo_port_db nif valid diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_nif_phys_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_nif_phys_dump_cmd, NULL, dnx_swstate_dnx_algo_port_nif_phys_dump_options, &dnx_swstate_dnx_algo_port_nif_phys_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_nif_phys_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_nif_phys_size_get_options, &dnx_swstate_dnx_algo_port_nif_phys_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_nif_phys_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_nif_phys_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_nif_phys_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_nif_phys_man = {
    cmd_dnx_swstate_dnx_algo_port_nif_phys_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_nif_phys_desc[] = "dnx_algo_port_db nif phys commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_nif_phys_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  nif_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("nif_idx_0", nif_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_nif_phys_dump(unit, nif_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_nif_phys_dump_options[] = {
    {"nif_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_nif_phys_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db nif phys dump [,nif_idx_0=<int>]\n",
    "dnx_algo_port_db nif phys dump nif_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_nif_phys_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~NIF~PHYS~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->nif[0].phys));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_nif_phys_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_nif_phys_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db nif phys size_get",
    "dnx_algo_port_db nif phys size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_nif_phys_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~NIF~PHYS~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_nif_phys_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_nif_phys_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db nif phys diagnostic_operation_counters",
    "dnx_algo_port_db nif phys diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_nif_first_phy_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_nif_first_phy_dump_cmd, NULL, dnx_swstate_dnx_algo_port_nif_first_phy_dump_options, &dnx_swstate_dnx_algo_port_nif_first_phy_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_nif_first_phy_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_nif_first_phy_size_get_options, &dnx_swstate_dnx_algo_port_nif_first_phy_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_nif_first_phy_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_nif_first_phy_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_nif_first_phy_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_nif_first_phy_man = {
    cmd_dnx_swstate_dnx_algo_port_nif_first_phy_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_nif_first_phy_desc[] = "dnx_algo_port_db nif first_phy commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_nif_first_phy_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  nif_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("nif_idx_0", nif_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_nif_first_phy_dump(unit, nif_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_nif_first_phy_dump_options[] = {
    {"nif_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_nif_first_phy_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db nif first_phy dump [,nif_idx_0=<int>]\n",
    "dnx_algo_port_db nif first_phy dump nif_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_nif_first_phy_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~NIF~FIRST_PHY~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->nif[0].first_phy));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_nif_first_phy_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_nif_first_phy_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db nif first_phy size_get",
    "dnx_algo_port_db nif first_phy size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_nif_first_phy_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~NIF~FIRST_PHY~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_nif_first_phy_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_nif_first_phy_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db nif first_phy diagnostic_operation_counters",
    "dnx_algo_port_db nif first_phy diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_nif_master_logical_port_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_nif_master_logical_port_dump_cmd, NULL, dnx_swstate_dnx_algo_port_nif_master_logical_port_dump_options, &dnx_swstate_dnx_algo_port_nif_master_logical_port_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_nif_master_logical_port_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_nif_master_logical_port_size_get_options, &dnx_swstate_dnx_algo_port_nif_master_logical_port_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_nif_master_logical_port_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_nif_master_logical_port_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_nif_master_logical_port_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_nif_master_logical_port_man = {
    cmd_dnx_swstate_dnx_algo_port_nif_master_logical_port_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_nif_master_logical_port_desc[] = "dnx_algo_port_db nif master_logical_port commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_nif_master_logical_port_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  nif_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("nif_idx_0", nif_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_nif_master_logical_port_dump(unit, nif_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_nif_master_logical_port_dump_options[] = {
    {"nif_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_nif_master_logical_port_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db nif master_logical_port dump [,nif_idx_0=<int>]\n",
    "dnx_algo_port_db nif master_logical_port dump nif_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_nif_master_logical_port_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~NIF~MASTER_LOGICAL_PORT~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->nif[0].master_logical_port));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_nif_master_logical_port_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_nif_master_logical_port_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db nif master_logical_port size_get",
    "dnx_algo_port_db nif master_logical_port size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_nif_master_logical_port_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~NIF~MASTER_LOGICAL_PORT~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_nif_master_logical_port_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_nif_master_logical_port_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db nif master_logical_port diagnostic_operation_counters",
    "dnx_algo_port_db nif master_logical_port diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_nif_logical_fifos_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_nif_logical_fifos_dump_cmd, NULL, dnx_swstate_dnx_algo_port_nif_logical_fifos_dump_options, &dnx_swstate_dnx_algo_port_nif_logical_fifos_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_nif_logical_fifos_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_nif_logical_fifos_size_get_options, &dnx_swstate_dnx_algo_port_nif_logical_fifos_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_nif_logical_fifos_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_nif_logical_fifos_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_nif_logical_fifos_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_nif_logical_fifos_man = {
    cmd_dnx_swstate_dnx_algo_port_nif_logical_fifos_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_nif_logical_fifos_desc[] = "dnx_algo_port_db nif logical_fifos commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_nif_logical_fifos_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  nif_idx_0 = 0;
    int  logical_fifos_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("nif_idx_0", nif_idx_0);
    SH_SAND_GET_INT32("logical_fifos_idx_0", logical_fifos_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_nif_logical_fifos_dump(unit, nif_idx_0, logical_fifos_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_nif_logical_fifos_dump_options[] = {
    {"nif_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"logical_fifos_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_nif_logical_fifos_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db nif logical_fifos dump [,nif_idx_0=<int>,logical_fifos_idx_0=<int>]\n",
    "dnx_algo_port_db nif logical_fifos dump nif_idx_0=0 logical_fifos_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_nif_logical_fifos_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~NIF~LOGICAL_FIFOS~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->nif[0].logical_fifos));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_nif_logical_fifos_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_nif_logical_fifos_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db nif logical_fifos size_get",
    "dnx_algo_port_db nif logical_fifos size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_nif_logical_fifos_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~NIF~LOGICAL_FIFOS~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_nif_logical_fifos_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_nif_logical_fifos_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db nif logical_fifos diagnostic_operation_counters",
    "dnx_algo_port_db nif logical_fifos diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_nif_latch_down_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_nif_latch_down_dump_cmd, NULL, dnx_swstate_dnx_algo_port_nif_latch_down_dump_options, &dnx_swstate_dnx_algo_port_nif_latch_down_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_nif_latch_down_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_nif_latch_down_size_get_options, &dnx_swstate_dnx_algo_port_nif_latch_down_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_nif_latch_down_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_nif_latch_down_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_nif_latch_down_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_nif_latch_down_man = {
    cmd_dnx_swstate_dnx_algo_port_nif_latch_down_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_nif_latch_down_desc[] = "dnx_algo_port_db nif latch_down commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_nif_latch_down_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  nif_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("nif_idx_0", nif_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_nif_latch_down_dump(unit, nif_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_nif_latch_down_dump_options[] = {
    {"nif_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_nif_latch_down_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db nif latch_down dump [,nif_idx_0=<int>]\n",
    "dnx_algo_port_db nif latch_down dump nif_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_nif_latch_down_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~NIF~LATCH_DOWN~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->nif[0].latch_down));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_nif_latch_down_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_nif_latch_down_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db nif latch_down size_get",
    "dnx_algo_port_db nif latch_down size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_nif_latch_down_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~NIF~LATCH_DOWN~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_nif_latch_down_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_nif_latch_down_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db nif latch_down diagnostic_operation_counters",
    "dnx_algo_port_db nif latch_down diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_nif_loopback_original_link_training_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_nif_loopback_original_link_training_dump_cmd, NULL, dnx_swstate_dnx_algo_port_nif_loopback_original_link_training_dump_options, &dnx_swstate_dnx_algo_port_nif_loopback_original_link_training_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_nif_loopback_original_link_training_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_nif_loopback_original_link_training_size_get_options, &dnx_swstate_dnx_algo_port_nif_loopback_original_link_training_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_nif_loopback_original_link_training_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_nif_loopback_original_link_training_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_nif_loopback_original_link_training_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_nif_loopback_original_link_training_man = {
    cmd_dnx_swstate_dnx_algo_port_nif_loopback_original_link_training_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_nif_loopback_original_link_training_desc[] = "dnx_algo_port_db nif loopback_original_link_training commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_nif_loopback_original_link_training_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  nif_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("nif_idx_0", nif_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_nif_loopback_original_link_training_dump(unit, nif_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_nif_loopback_original_link_training_dump_options[] = {
    {"nif_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_nif_loopback_original_link_training_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db nif loopback_original_link_training dump [,nif_idx_0=<int>]\n",
    "dnx_algo_port_db nif loopback_original_link_training dump nif_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_nif_loopback_original_link_training_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~NIF~LOOPBACK_ORIGINAL_LINK_TRAINING~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->nif[0].loopback_original_link_training));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_nif_loopback_original_link_training_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_nif_loopback_original_link_training_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db nif loopback_original_link_training size_get",
    "dnx_algo_port_db nif loopback_original_link_training size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_nif_loopback_original_link_training_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~NIF~LOOPBACK_ORIGINAL_LINK_TRAINING~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_nif_loopback_original_link_training_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_nif_loopback_original_link_training_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db nif loopback_original_link_training diagnostic_operation_counters",
    "dnx_algo_port_db nif loopback_original_link_training diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_nif_loopback_original_phy_lane_config_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_nif_loopback_original_phy_lane_config_dump_cmd, NULL, dnx_swstate_dnx_algo_port_nif_loopback_original_phy_lane_config_dump_options, &dnx_swstate_dnx_algo_port_nif_loopback_original_phy_lane_config_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_nif_loopback_original_phy_lane_config_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_nif_loopback_original_phy_lane_config_size_get_options, &dnx_swstate_dnx_algo_port_nif_loopback_original_phy_lane_config_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_nif_loopback_original_phy_lane_config_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_nif_loopback_original_phy_lane_config_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_nif_loopback_original_phy_lane_config_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_nif_loopback_original_phy_lane_config_man = {
    cmd_dnx_swstate_dnx_algo_port_nif_loopback_original_phy_lane_config_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_nif_loopback_original_phy_lane_config_desc[] = "dnx_algo_port_db nif loopback_original_phy_lane_config commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_nif_loopback_original_phy_lane_config_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  nif_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("nif_idx_0", nif_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_nif_loopback_original_phy_lane_config_dump(unit, nif_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_nif_loopback_original_phy_lane_config_dump_options[] = {
    {"nif_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_nif_loopback_original_phy_lane_config_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db nif loopback_original_phy_lane_config dump [,nif_idx_0=<int>]\n",
    "dnx_algo_port_db nif loopback_original_phy_lane_config dump nif_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_nif_loopback_original_phy_lane_config_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~NIF~LOOPBACK_ORIGINAL_PHY_LANE_CONFIG~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->nif[0].loopback_original_phy_lane_config));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_nif_loopback_original_phy_lane_config_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_nif_loopback_original_phy_lane_config_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db nif loopback_original_phy_lane_config size_get",
    "dnx_algo_port_db nif loopback_original_phy_lane_config size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_nif_loopback_original_phy_lane_config_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~NIF~LOOPBACK_ORIGINAL_PHY_LANE_CONFIG~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_nif_loopback_original_phy_lane_config_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_nif_loopback_original_phy_lane_config_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db nif loopback_original_phy_lane_config diagnostic_operation_counters",
    "dnx_algo_port_db nif loopback_original_phy_lane_config diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_tm_cmds[] = {
    {"ref_count", NULL, sh_dnx_swstate_dnx_algo_port_tm_ref_count_cmds, NULL, &dnx_swstate_dnx_algo_port_tm_ref_count_man},
    {"tm_port", NULL, sh_dnx_swstate_dnx_algo_port_tm_tm_port_cmds, NULL, &dnx_swstate_dnx_algo_port_tm_tm_port_man},
    {"core", NULL, sh_dnx_swstate_dnx_algo_port_tm_core_cmds, NULL, &dnx_swstate_dnx_algo_port_tm_core_man},
    {"base_q_pair", NULL, sh_dnx_swstate_dnx_algo_port_tm_base_q_pair_cmds, NULL, &dnx_swstate_dnx_algo_port_tm_base_q_pair_man},
    {"port_app_flags", NULL, sh_dnx_swstate_dnx_algo_port_tm_port_app_flags_cmds, NULL, &dnx_swstate_dnx_algo_port_tm_port_app_flags_man},
    {"priorities", NULL, sh_dnx_swstate_dnx_algo_port_tm_priorities_cmds, NULL, &dnx_swstate_dnx_algo_port_tm_priorities_man},
    {"tdm_mode", NULL, sh_dnx_swstate_dnx_algo_port_tm_tdm_mode_cmds, NULL, &dnx_swstate_dnx_algo_port_tm_tdm_mode_man},
    {"header_type_in", NULL, sh_dnx_swstate_dnx_algo_port_tm_header_type_in_cmds, NULL, &dnx_swstate_dnx_algo_port_tm_header_type_in_man},
    {"header_type_out", NULL, sh_dnx_swstate_dnx_algo_port_tm_header_type_out_cmds, NULL, &dnx_swstate_dnx_algo_port_tm_header_type_out_man},
    {"master_logical_port", NULL, sh_dnx_swstate_dnx_algo_port_tm_master_logical_port_cmds, NULL, &dnx_swstate_dnx_algo_port_tm_master_logical_port_man},
    {"dump", sh_dnx_swstate_dnx_algo_port_tm_dump_cmd, NULL, dnx_swstate_dnx_algo_port_tm_dump_options, &dnx_swstate_dnx_algo_port_tm_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_tm_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_tm_size_get_options, &dnx_swstate_dnx_algo_port_tm_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_tm_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_tm_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_tm_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_man = {
    cmd_dnx_swstate_dnx_algo_port_tm_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_tm_desc[] = "dnx_algo_port_db tm commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  tm_idx_0 = 0;
    int  tm_idx_1 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("tm_idx_0", tm_idx_0);
    SH_SAND_GET_INT32("tm_idx_1", tm_idx_1);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_tm_dump(unit, tm_idx_0, tm_idx_1, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_dump_options[] = {
    {"tm_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"tm_idx_1", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db tm dump [,tm_idx_0=<int>,tm_idx_1=<int>]\n",
    "dnx_algo_port_db tm dump tm_idx_0=0 tm_idx_1=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~TM~", 0);
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db tm size_get",
    "dnx_algo_port_db tm size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~TM~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db tm diagnostic_operation_counters",
    "dnx_algo_port_db tm diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_tm_ref_count_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_tm_ref_count_dump_cmd, NULL, dnx_swstate_dnx_algo_port_tm_ref_count_dump_options, &dnx_swstate_dnx_algo_port_tm_ref_count_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_tm_ref_count_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_tm_ref_count_size_get_options, &dnx_swstate_dnx_algo_port_tm_ref_count_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_tm_ref_count_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_tm_ref_count_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_tm_ref_count_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_ref_count_man = {
    cmd_dnx_swstate_dnx_algo_port_tm_ref_count_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_tm_ref_count_desc[] = "dnx_algo_port_db tm ref_count commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_ref_count_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  tm_idx_0 = 0;
    int  tm_idx_1 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("tm_idx_0", tm_idx_0);
    SH_SAND_GET_INT32("tm_idx_1", tm_idx_1);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_tm_ref_count_dump(unit, tm_idx_0, tm_idx_1, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_ref_count_dump_options[] = {
    {"tm_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"tm_idx_1", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_ref_count_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db tm ref_count dump [,tm_idx_0=<int>,tm_idx_1=<int>]\n",
    "dnx_algo_port_db tm ref_count dump tm_idx_0=0 tm_idx_1=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_ref_count_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~TM~REF_COUNT~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->tm[0][0].ref_count));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_ref_count_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_ref_count_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db tm ref_count size_get",
    "dnx_algo_port_db tm ref_count size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_ref_count_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~TM~REF_COUNT~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_ref_count_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_ref_count_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db tm ref_count diagnostic_operation_counters",
    "dnx_algo_port_db tm ref_count diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_tm_tm_port_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_tm_tm_port_dump_cmd, NULL, dnx_swstate_dnx_algo_port_tm_tm_port_dump_options, &dnx_swstate_dnx_algo_port_tm_tm_port_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_tm_tm_port_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_tm_tm_port_size_get_options, &dnx_swstate_dnx_algo_port_tm_tm_port_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_tm_tm_port_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_tm_tm_port_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_tm_tm_port_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_tm_port_man = {
    cmd_dnx_swstate_dnx_algo_port_tm_tm_port_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_tm_tm_port_desc[] = "dnx_algo_port_db tm tm_port commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_tm_port_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  tm_idx_0 = 0;
    int  tm_idx_1 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("tm_idx_0", tm_idx_0);
    SH_SAND_GET_INT32("tm_idx_1", tm_idx_1);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_tm_tm_port_dump(unit, tm_idx_0, tm_idx_1, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_tm_port_dump_options[] = {
    {"tm_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"tm_idx_1", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_tm_port_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db tm tm_port dump [,tm_idx_0=<int>,tm_idx_1=<int>]\n",
    "dnx_algo_port_db tm tm_port dump tm_idx_0=0 tm_idx_1=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_tm_port_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~TM~TM_PORT~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->tm[0][0].tm_port));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_tm_port_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_tm_port_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db tm tm_port size_get",
    "dnx_algo_port_db tm tm_port size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_tm_port_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~TM~TM_PORT~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_tm_port_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_tm_port_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db tm tm_port diagnostic_operation_counters",
    "dnx_algo_port_db tm tm_port diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_tm_core_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_tm_core_dump_cmd, NULL, dnx_swstate_dnx_algo_port_tm_core_dump_options, &dnx_swstate_dnx_algo_port_tm_core_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_tm_core_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_tm_core_size_get_options, &dnx_swstate_dnx_algo_port_tm_core_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_tm_core_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_tm_core_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_tm_core_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_core_man = {
    cmd_dnx_swstate_dnx_algo_port_tm_core_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_tm_core_desc[] = "dnx_algo_port_db tm core commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_core_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  tm_idx_0 = 0;
    int  tm_idx_1 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("tm_idx_0", tm_idx_0);
    SH_SAND_GET_INT32("tm_idx_1", tm_idx_1);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_tm_core_dump(unit, tm_idx_0, tm_idx_1, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_core_dump_options[] = {
    {"tm_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"tm_idx_1", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_core_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db tm core dump [,tm_idx_0=<int>,tm_idx_1=<int>]\n",
    "dnx_algo_port_db tm core dump tm_idx_0=0 tm_idx_1=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_core_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~TM~CORE~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->tm[0][0].core));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_core_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_core_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db tm core size_get",
    "dnx_algo_port_db tm core size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_core_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~TM~CORE~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_core_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_core_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db tm core diagnostic_operation_counters",
    "dnx_algo_port_db tm core diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_tm_base_q_pair_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_tm_base_q_pair_dump_cmd, NULL, dnx_swstate_dnx_algo_port_tm_base_q_pair_dump_options, &dnx_swstate_dnx_algo_port_tm_base_q_pair_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_tm_base_q_pair_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_tm_base_q_pair_size_get_options, &dnx_swstate_dnx_algo_port_tm_base_q_pair_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_tm_base_q_pair_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_tm_base_q_pair_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_tm_base_q_pair_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_base_q_pair_man = {
    cmd_dnx_swstate_dnx_algo_port_tm_base_q_pair_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_tm_base_q_pair_desc[] = "dnx_algo_port_db tm base_q_pair commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_base_q_pair_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  tm_idx_0 = 0;
    int  tm_idx_1 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("tm_idx_0", tm_idx_0);
    SH_SAND_GET_INT32("tm_idx_1", tm_idx_1);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_tm_base_q_pair_dump(unit, tm_idx_0, tm_idx_1, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_base_q_pair_dump_options[] = {
    {"tm_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"tm_idx_1", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_base_q_pair_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db tm base_q_pair dump [,tm_idx_0=<int>,tm_idx_1=<int>]\n",
    "dnx_algo_port_db tm base_q_pair dump tm_idx_0=0 tm_idx_1=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_base_q_pair_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~TM~BASE_Q_PAIR~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->tm[0][0].base_q_pair));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_base_q_pair_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_base_q_pair_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db tm base_q_pair size_get",
    "dnx_algo_port_db tm base_q_pair size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_base_q_pair_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~TM~BASE_Q_PAIR~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_base_q_pair_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_base_q_pair_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db tm base_q_pair diagnostic_operation_counters",
    "dnx_algo_port_db tm base_q_pair diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_tm_port_app_flags_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_tm_port_app_flags_dump_cmd, NULL, dnx_swstate_dnx_algo_port_tm_port_app_flags_dump_options, &dnx_swstate_dnx_algo_port_tm_port_app_flags_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_tm_port_app_flags_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_tm_port_app_flags_size_get_options, &dnx_swstate_dnx_algo_port_tm_port_app_flags_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_tm_port_app_flags_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_tm_port_app_flags_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_tm_port_app_flags_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_port_app_flags_man = {
    cmd_dnx_swstate_dnx_algo_port_tm_port_app_flags_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_tm_port_app_flags_desc[] = "dnx_algo_port_db tm port_app_flags commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_port_app_flags_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  tm_idx_0 = 0;
    int  tm_idx_1 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("tm_idx_0", tm_idx_0);
    SH_SAND_GET_INT32("tm_idx_1", tm_idx_1);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_tm_port_app_flags_dump(unit, tm_idx_0, tm_idx_1, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_port_app_flags_dump_options[] = {
    {"tm_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"tm_idx_1", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_port_app_flags_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db tm port_app_flags dump [,tm_idx_0=<int>,tm_idx_1=<int>]\n",
    "dnx_algo_port_db tm port_app_flags dump tm_idx_0=0 tm_idx_1=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_port_app_flags_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~TM~PORT_APP_FLAGS~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->tm[0][0].port_app_flags));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_port_app_flags_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_port_app_flags_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db tm port_app_flags size_get",
    "dnx_algo_port_db tm port_app_flags size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_port_app_flags_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~TM~PORT_APP_FLAGS~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_port_app_flags_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_port_app_flags_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db tm port_app_flags diagnostic_operation_counters",
    "dnx_algo_port_db tm port_app_flags diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_tm_priorities_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_tm_priorities_dump_cmd, NULL, dnx_swstate_dnx_algo_port_tm_priorities_dump_options, &dnx_swstate_dnx_algo_port_tm_priorities_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_tm_priorities_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_tm_priorities_size_get_options, &dnx_swstate_dnx_algo_port_tm_priorities_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_tm_priorities_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_tm_priorities_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_tm_priorities_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_priorities_man = {
    cmd_dnx_swstate_dnx_algo_port_tm_priorities_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_tm_priorities_desc[] = "dnx_algo_port_db tm priorities commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_priorities_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  tm_idx_0 = 0;
    int  tm_idx_1 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("tm_idx_0", tm_idx_0);
    SH_SAND_GET_INT32("tm_idx_1", tm_idx_1);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_tm_priorities_dump(unit, tm_idx_0, tm_idx_1, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_priorities_dump_options[] = {
    {"tm_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"tm_idx_1", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_priorities_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db tm priorities dump [,tm_idx_0=<int>,tm_idx_1=<int>]\n",
    "dnx_algo_port_db tm priorities dump tm_idx_0=0 tm_idx_1=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_priorities_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~TM~PRIORITIES~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->tm[0][0].priorities));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_priorities_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_priorities_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db tm priorities size_get",
    "dnx_algo_port_db tm priorities size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_priorities_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~TM~PRIORITIES~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_priorities_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_priorities_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db tm priorities diagnostic_operation_counters",
    "dnx_algo_port_db tm priorities diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_tm_tdm_mode_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_tm_tdm_mode_dump_cmd, NULL, dnx_swstate_dnx_algo_port_tm_tdm_mode_dump_options, &dnx_swstate_dnx_algo_port_tm_tdm_mode_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_tm_tdm_mode_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_tm_tdm_mode_size_get_options, &dnx_swstate_dnx_algo_port_tm_tdm_mode_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_tm_tdm_mode_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_tm_tdm_mode_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_tm_tdm_mode_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_tdm_mode_man = {
    cmd_dnx_swstate_dnx_algo_port_tm_tdm_mode_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_tm_tdm_mode_desc[] = "dnx_algo_port_db tm tdm_mode commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_tdm_mode_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  tm_idx_0 = 0;
    int  tm_idx_1 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("tm_idx_0", tm_idx_0);
    SH_SAND_GET_INT32("tm_idx_1", tm_idx_1);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_tm_tdm_mode_dump(unit, tm_idx_0, tm_idx_1, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_tdm_mode_dump_options[] = {
    {"tm_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"tm_idx_1", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_tdm_mode_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db tm tdm_mode dump [,tm_idx_0=<int>,tm_idx_1=<int>]\n",
    "dnx_algo_port_db tm tdm_mode dump tm_idx_0=0 tm_idx_1=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_tdm_mode_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~TM~TDM_MODE~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->tm[0][0].tdm_mode));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_tdm_mode_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_tdm_mode_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db tm tdm_mode size_get",
    "dnx_algo_port_db tm tdm_mode size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_tdm_mode_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~TM~TDM_MODE~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_tdm_mode_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_tdm_mode_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db tm tdm_mode diagnostic_operation_counters",
    "dnx_algo_port_db tm tdm_mode diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_tm_header_type_in_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_tm_header_type_in_dump_cmd, NULL, dnx_swstate_dnx_algo_port_tm_header_type_in_dump_options, &dnx_swstate_dnx_algo_port_tm_header_type_in_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_tm_header_type_in_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_tm_header_type_in_size_get_options, &dnx_swstate_dnx_algo_port_tm_header_type_in_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_tm_header_type_in_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_tm_header_type_in_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_tm_header_type_in_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_header_type_in_man = {
    cmd_dnx_swstate_dnx_algo_port_tm_header_type_in_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_tm_header_type_in_desc[] = "dnx_algo_port_db tm header_type_in commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_header_type_in_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  tm_idx_0 = 0;
    int  tm_idx_1 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("tm_idx_0", tm_idx_0);
    SH_SAND_GET_INT32("tm_idx_1", tm_idx_1);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_tm_header_type_in_dump(unit, tm_idx_0, tm_idx_1, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_header_type_in_dump_options[] = {
    {"tm_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"tm_idx_1", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_header_type_in_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db tm header_type_in dump [,tm_idx_0=<int>,tm_idx_1=<int>]\n",
    "dnx_algo_port_db tm header_type_in dump tm_idx_0=0 tm_idx_1=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_header_type_in_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~TM~HEADER_TYPE_IN~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->tm[0][0].header_type_in));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_header_type_in_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_header_type_in_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db tm header_type_in size_get",
    "dnx_algo_port_db tm header_type_in size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_header_type_in_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~TM~HEADER_TYPE_IN~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_header_type_in_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_header_type_in_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db tm header_type_in diagnostic_operation_counters",
    "dnx_algo_port_db tm header_type_in diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_tm_header_type_out_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_tm_header_type_out_dump_cmd, NULL, dnx_swstate_dnx_algo_port_tm_header_type_out_dump_options, &dnx_swstate_dnx_algo_port_tm_header_type_out_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_tm_header_type_out_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_tm_header_type_out_size_get_options, &dnx_swstate_dnx_algo_port_tm_header_type_out_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_tm_header_type_out_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_tm_header_type_out_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_tm_header_type_out_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_header_type_out_man = {
    cmd_dnx_swstate_dnx_algo_port_tm_header_type_out_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_tm_header_type_out_desc[] = "dnx_algo_port_db tm header_type_out commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_header_type_out_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  tm_idx_0 = 0;
    int  tm_idx_1 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("tm_idx_0", tm_idx_0);
    SH_SAND_GET_INT32("tm_idx_1", tm_idx_1);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_tm_header_type_out_dump(unit, tm_idx_0, tm_idx_1, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_header_type_out_dump_options[] = {
    {"tm_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"tm_idx_1", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_header_type_out_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db tm header_type_out dump [,tm_idx_0=<int>,tm_idx_1=<int>]\n",
    "dnx_algo_port_db tm header_type_out dump tm_idx_0=0 tm_idx_1=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_header_type_out_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~TM~HEADER_TYPE_OUT~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->tm[0][0].header_type_out));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_header_type_out_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_header_type_out_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db tm header_type_out size_get",
    "dnx_algo_port_db tm header_type_out size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_header_type_out_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~TM~HEADER_TYPE_OUT~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_header_type_out_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_header_type_out_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db tm header_type_out diagnostic_operation_counters",
    "dnx_algo_port_db tm header_type_out diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_tm_master_logical_port_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_tm_master_logical_port_dump_cmd, NULL, dnx_swstate_dnx_algo_port_tm_master_logical_port_dump_options, &dnx_swstate_dnx_algo_port_tm_master_logical_port_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_tm_master_logical_port_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_tm_master_logical_port_size_get_options, &dnx_swstate_dnx_algo_port_tm_master_logical_port_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_tm_master_logical_port_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_tm_master_logical_port_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_tm_master_logical_port_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_master_logical_port_man = {
    cmd_dnx_swstate_dnx_algo_port_tm_master_logical_port_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_tm_master_logical_port_desc[] = "dnx_algo_port_db tm master_logical_port commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_master_logical_port_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  tm_idx_0 = 0;
    int  tm_idx_1 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("tm_idx_0", tm_idx_0);
    SH_SAND_GET_INT32("tm_idx_1", tm_idx_1);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_tm_master_logical_port_dump(unit, tm_idx_0, tm_idx_1, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_master_logical_port_dump_options[] = {
    {"tm_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"tm_idx_1", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_master_logical_port_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db tm master_logical_port dump [,tm_idx_0=<int>,tm_idx_1=<int>]\n",
    "dnx_algo_port_db tm master_logical_port dump tm_idx_0=0 tm_idx_1=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_master_logical_port_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~TM~MASTER_LOGICAL_PORT~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->tm[0][0].master_logical_port));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_master_logical_port_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_master_logical_port_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db tm master_logical_port size_get",
    "dnx_algo_port_db tm master_logical_port size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_master_logical_port_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~TM~MASTER_LOGICAL_PORT~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_master_logical_port_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_master_logical_port_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db tm master_logical_port diagnostic_operation_counters",
    "dnx_algo_port_db tm master_logical_port diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_sch_cmds[] = {
    {"valid", NULL, sh_dnx_swstate_dnx_algo_port_sch_valid_cmds, NULL, &dnx_swstate_dnx_algo_port_sch_valid_man},
    {"base_hr", NULL, sh_dnx_swstate_dnx_algo_port_sch_base_hr_cmds, NULL, &dnx_swstate_dnx_algo_port_sch_base_hr_man},
    {"sch_priorities", NULL, sh_dnx_swstate_dnx_algo_port_sch_sch_priorities_cmds, NULL, &dnx_swstate_dnx_algo_port_sch_sch_priorities_man},
    {"master_logical_port", NULL, sh_dnx_swstate_dnx_algo_port_sch_master_logical_port_cmds, NULL, &dnx_swstate_dnx_algo_port_sch_master_logical_port_man},
    {"dump", sh_dnx_swstate_dnx_algo_port_sch_dump_cmd, NULL, dnx_swstate_dnx_algo_port_sch_dump_options, &dnx_swstate_dnx_algo_port_sch_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_sch_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_sch_size_get_options, &dnx_swstate_dnx_algo_port_sch_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_sch_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_sch_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_sch_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_sch_man = {
    cmd_dnx_swstate_dnx_algo_port_sch_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_sch_desc[] = "dnx_algo_port_db sch commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_sch_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  sch_idx_0 = 0;
    int  sch_idx_1 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("sch_idx_0", sch_idx_0);
    SH_SAND_GET_INT32("sch_idx_1", sch_idx_1);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_sch_dump(unit, sch_idx_0, sch_idx_1, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_sch_dump_options[] = {
    {"sch_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"sch_idx_1", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_sch_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db sch dump [,sch_idx_0=<int>,sch_idx_1=<int>]\n",
    "dnx_algo_port_db sch dump sch_idx_0=0 sch_idx_1=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_sch_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~SCH~", 0);
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_sch_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_sch_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db sch size_get",
    "dnx_algo_port_db sch size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_sch_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~SCH~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_sch_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_sch_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db sch diagnostic_operation_counters",
    "dnx_algo_port_db sch diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_sch_valid_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_sch_valid_dump_cmd, NULL, dnx_swstate_dnx_algo_port_sch_valid_dump_options, &dnx_swstate_dnx_algo_port_sch_valid_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_sch_valid_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_sch_valid_size_get_options, &dnx_swstate_dnx_algo_port_sch_valid_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_sch_valid_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_sch_valid_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_sch_valid_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_sch_valid_man = {
    cmd_dnx_swstate_dnx_algo_port_sch_valid_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_sch_valid_desc[] = "dnx_algo_port_db sch valid commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_sch_valid_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  sch_idx_0 = 0;
    int  sch_idx_1 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("sch_idx_0", sch_idx_0);
    SH_SAND_GET_INT32("sch_idx_1", sch_idx_1);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_sch_valid_dump(unit, sch_idx_0, sch_idx_1, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_sch_valid_dump_options[] = {
    {"sch_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"sch_idx_1", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_sch_valid_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db sch valid dump [,sch_idx_0=<int>,sch_idx_1=<int>]\n",
    "dnx_algo_port_db sch valid dump sch_idx_0=0 sch_idx_1=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_sch_valid_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~SCH~VALID~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->sch[0][0].valid));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_sch_valid_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_sch_valid_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db sch valid size_get",
    "dnx_algo_port_db sch valid size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_sch_valid_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~SCH~VALID~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_sch_valid_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_sch_valid_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db sch valid diagnostic_operation_counters",
    "dnx_algo_port_db sch valid diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_sch_base_hr_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_sch_base_hr_dump_cmd, NULL, dnx_swstate_dnx_algo_port_sch_base_hr_dump_options, &dnx_swstate_dnx_algo_port_sch_base_hr_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_sch_base_hr_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_sch_base_hr_size_get_options, &dnx_swstate_dnx_algo_port_sch_base_hr_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_sch_base_hr_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_sch_base_hr_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_sch_base_hr_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_sch_base_hr_man = {
    cmd_dnx_swstate_dnx_algo_port_sch_base_hr_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_sch_base_hr_desc[] = "dnx_algo_port_db sch base_hr commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_sch_base_hr_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  sch_idx_0 = 0;
    int  sch_idx_1 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("sch_idx_0", sch_idx_0);
    SH_SAND_GET_INT32("sch_idx_1", sch_idx_1);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_sch_base_hr_dump(unit, sch_idx_0, sch_idx_1, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_sch_base_hr_dump_options[] = {
    {"sch_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"sch_idx_1", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_sch_base_hr_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db sch base_hr dump [,sch_idx_0=<int>,sch_idx_1=<int>]\n",
    "dnx_algo_port_db sch base_hr dump sch_idx_0=0 sch_idx_1=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_sch_base_hr_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~SCH~BASE_HR~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->sch[0][0].base_hr));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_sch_base_hr_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_sch_base_hr_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db sch base_hr size_get",
    "dnx_algo_port_db sch base_hr size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_sch_base_hr_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~SCH~BASE_HR~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_sch_base_hr_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_sch_base_hr_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db sch base_hr diagnostic_operation_counters",
    "dnx_algo_port_db sch base_hr diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_sch_sch_priorities_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_sch_sch_priorities_dump_cmd, NULL, dnx_swstate_dnx_algo_port_sch_sch_priorities_dump_options, &dnx_swstate_dnx_algo_port_sch_sch_priorities_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_sch_sch_priorities_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_sch_sch_priorities_size_get_options, &dnx_swstate_dnx_algo_port_sch_sch_priorities_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_sch_sch_priorities_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_sch_sch_priorities_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_sch_sch_priorities_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_sch_sch_priorities_man = {
    cmd_dnx_swstate_dnx_algo_port_sch_sch_priorities_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_sch_sch_priorities_desc[] = "dnx_algo_port_db sch sch_priorities commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_sch_sch_priorities_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  sch_idx_0 = 0;
    int  sch_idx_1 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("sch_idx_0", sch_idx_0);
    SH_SAND_GET_INT32("sch_idx_1", sch_idx_1);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_sch_sch_priorities_dump(unit, sch_idx_0, sch_idx_1, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_sch_sch_priorities_dump_options[] = {
    {"sch_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"sch_idx_1", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_sch_sch_priorities_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db sch sch_priorities dump [,sch_idx_0=<int>,sch_idx_1=<int>]\n",
    "dnx_algo_port_db sch sch_priorities dump sch_idx_0=0 sch_idx_1=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_sch_sch_priorities_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~SCH~SCH_PRIORITIES~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->sch[0][0].sch_priorities));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_sch_sch_priorities_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_sch_sch_priorities_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db sch sch_priorities size_get",
    "dnx_algo_port_db sch sch_priorities size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_sch_sch_priorities_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~SCH~SCH_PRIORITIES~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_sch_sch_priorities_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_sch_sch_priorities_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db sch sch_priorities diagnostic_operation_counters",
    "dnx_algo_port_db sch sch_priorities diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_sch_master_logical_port_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_sch_master_logical_port_dump_cmd, NULL, dnx_swstate_dnx_algo_port_sch_master_logical_port_dump_options, &dnx_swstate_dnx_algo_port_sch_master_logical_port_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_sch_master_logical_port_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_sch_master_logical_port_size_get_options, &dnx_swstate_dnx_algo_port_sch_master_logical_port_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_sch_master_logical_port_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_sch_master_logical_port_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_sch_master_logical_port_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_sch_master_logical_port_man = {
    cmd_dnx_swstate_dnx_algo_port_sch_master_logical_port_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_sch_master_logical_port_desc[] = "dnx_algo_port_db sch master_logical_port commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_sch_master_logical_port_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  sch_idx_0 = 0;
    int  sch_idx_1 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("sch_idx_0", sch_idx_0);
    SH_SAND_GET_INT32("sch_idx_1", sch_idx_1);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_sch_master_logical_port_dump(unit, sch_idx_0, sch_idx_1, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_sch_master_logical_port_dump_options[] = {
    {"sch_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"sch_idx_1", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_sch_master_logical_port_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db sch master_logical_port dump [,sch_idx_0=<int>,sch_idx_1=<int>]\n",
    "dnx_algo_port_db sch master_logical_port dump sch_idx_0=0 sch_idx_1=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_sch_master_logical_port_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~SCH~MASTER_LOGICAL_PORT~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->sch[0][0].master_logical_port));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_sch_master_logical_port_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_sch_master_logical_port_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db sch master_logical_port size_get",
    "dnx_algo_port_db sch master_logical_port size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_sch_master_logical_port_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~SCH~MASTER_LOGICAL_PORT~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_sch_master_logical_port_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_sch_master_logical_port_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db sch master_logical_port diagnostic_operation_counters",
    "dnx_algo_port_db sch master_logical_port diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_pp_cmds[] = {
    {"ref_count", NULL, sh_dnx_swstate_dnx_algo_port_pp_ref_count_cmds, NULL, &dnx_swstate_dnx_algo_port_pp_ref_count_man},
    {"pp_port", NULL, sh_dnx_swstate_dnx_algo_port_pp_pp_port_cmds, NULL, &dnx_swstate_dnx_algo_port_pp_pp_port_man},
    {"core", NULL, sh_dnx_swstate_dnx_algo_port_pp_core_cmds, NULL, &dnx_swstate_dnx_algo_port_pp_core_man},
    {"is_lag", NULL, sh_dnx_swstate_dnx_algo_port_pp_is_lag_cmds, NULL, &dnx_swstate_dnx_algo_port_pp_is_lag_man},
    {"lag_id", NULL, sh_dnx_swstate_dnx_algo_port_pp_lag_id_cmds, NULL, &dnx_swstate_dnx_algo_port_pp_lag_id_man},
    {"master_logical_port", NULL, sh_dnx_swstate_dnx_algo_port_pp_master_logical_port_cmds, NULL, &dnx_swstate_dnx_algo_port_pp_master_logical_port_man},
    {"header_mode", NULL, sh_dnx_swstate_dnx_algo_port_pp_header_mode_cmds, NULL, &dnx_swstate_dnx_algo_port_pp_header_mode_man},
    {"ingress_llvp_profile_valid", NULL, sh_dnx_swstate_dnx_algo_port_pp_ingress_llvp_profile_valid_cmds, NULL, &dnx_swstate_dnx_algo_port_pp_ingress_llvp_profile_valid_man},
    {"egress_llvp_profile_valid", NULL, sh_dnx_swstate_dnx_algo_port_pp_egress_llvp_profile_valid_cmds, NULL, &dnx_swstate_dnx_algo_port_pp_egress_llvp_profile_valid_man},
    {"dump", sh_dnx_swstate_dnx_algo_port_pp_dump_cmd, NULL, dnx_swstate_dnx_algo_port_pp_dump_options, &dnx_swstate_dnx_algo_port_pp_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_pp_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_pp_size_get_options, &dnx_swstate_dnx_algo_port_pp_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_pp_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_pp_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_pp_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_pp_man = {
    cmd_dnx_swstate_dnx_algo_port_pp_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_pp_desc[] = "dnx_algo_port_db pp commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_pp_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  pp_idx_0 = 0;
    int  pp_idx_1 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("pp_idx_0", pp_idx_0);
    SH_SAND_GET_INT32("pp_idx_1", pp_idx_1);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_pp_dump(unit, pp_idx_0, pp_idx_1, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_pp_dump_options[] = {
    {"pp_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"pp_idx_1", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_pp_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db pp dump [,pp_idx_0=<int>,pp_idx_1=<int>]\n",
    "dnx_algo_port_db pp dump pp_idx_0=0 pp_idx_1=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_pp_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~PP~", 0);
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_pp_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_pp_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db pp size_get",
    "dnx_algo_port_db pp size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_pp_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~PP~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_pp_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_pp_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db pp diagnostic_operation_counters",
    "dnx_algo_port_db pp diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_pp_ref_count_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_pp_ref_count_dump_cmd, NULL, dnx_swstate_dnx_algo_port_pp_ref_count_dump_options, &dnx_swstate_dnx_algo_port_pp_ref_count_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_pp_ref_count_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_pp_ref_count_size_get_options, &dnx_swstate_dnx_algo_port_pp_ref_count_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_pp_ref_count_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_pp_ref_count_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_pp_ref_count_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_pp_ref_count_man = {
    cmd_dnx_swstate_dnx_algo_port_pp_ref_count_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_pp_ref_count_desc[] = "dnx_algo_port_db pp ref_count commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_pp_ref_count_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  pp_idx_0 = 0;
    int  pp_idx_1 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("pp_idx_0", pp_idx_0);
    SH_SAND_GET_INT32("pp_idx_1", pp_idx_1);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_pp_ref_count_dump(unit, pp_idx_0, pp_idx_1, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_pp_ref_count_dump_options[] = {
    {"pp_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"pp_idx_1", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_pp_ref_count_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db pp ref_count dump [,pp_idx_0=<int>,pp_idx_1=<int>]\n",
    "dnx_algo_port_db pp ref_count dump pp_idx_0=0 pp_idx_1=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_pp_ref_count_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~PP~REF_COUNT~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->pp[0][0].ref_count));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_pp_ref_count_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_pp_ref_count_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db pp ref_count size_get",
    "dnx_algo_port_db pp ref_count size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_pp_ref_count_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~PP~REF_COUNT~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_pp_ref_count_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_pp_ref_count_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db pp ref_count diagnostic_operation_counters",
    "dnx_algo_port_db pp ref_count diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_pp_pp_port_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_pp_pp_port_dump_cmd, NULL, dnx_swstate_dnx_algo_port_pp_pp_port_dump_options, &dnx_swstate_dnx_algo_port_pp_pp_port_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_pp_pp_port_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_pp_pp_port_size_get_options, &dnx_swstate_dnx_algo_port_pp_pp_port_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_pp_pp_port_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_pp_pp_port_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_pp_pp_port_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_pp_pp_port_man = {
    cmd_dnx_swstate_dnx_algo_port_pp_pp_port_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_pp_pp_port_desc[] = "dnx_algo_port_db pp pp_port commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_pp_pp_port_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  pp_idx_0 = 0;
    int  pp_idx_1 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("pp_idx_0", pp_idx_0);
    SH_SAND_GET_INT32("pp_idx_1", pp_idx_1);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_pp_pp_port_dump(unit, pp_idx_0, pp_idx_1, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_pp_pp_port_dump_options[] = {
    {"pp_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"pp_idx_1", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_pp_pp_port_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db pp pp_port dump [,pp_idx_0=<int>,pp_idx_1=<int>]\n",
    "dnx_algo_port_db pp pp_port dump pp_idx_0=0 pp_idx_1=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_pp_pp_port_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~PP~PP_PORT~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->pp[0][0].pp_port));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_pp_pp_port_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_pp_pp_port_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db pp pp_port size_get",
    "dnx_algo_port_db pp pp_port size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_pp_pp_port_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~PP~PP_PORT~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_pp_pp_port_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_pp_pp_port_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db pp pp_port diagnostic_operation_counters",
    "dnx_algo_port_db pp pp_port diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_pp_core_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_pp_core_dump_cmd, NULL, dnx_swstate_dnx_algo_port_pp_core_dump_options, &dnx_swstate_dnx_algo_port_pp_core_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_pp_core_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_pp_core_size_get_options, &dnx_swstate_dnx_algo_port_pp_core_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_pp_core_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_pp_core_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_pp_core_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_pp_core_man = {
    cmd_dnx_swstate_dnx_algo_port_pp_core_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_pp_core_desc[] = "dnx_algo_port_db pp core commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_pp_core_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  pp_idx_0 = 0;
    int  pp_idx_1 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("pp_idx_0", pp_idx_0);
    SH_SAND_GET_INT32("pp_idx_1", pp_idx_1);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_pp_core_dump(unit, pp_idx_0, pp_idx_1, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_pp_core_dump_options[] = {
    {"pp_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"pp_idx_1", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_pp_core_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db pp core dump [,pp_idx_0=<int>,pp_idx_1=<int>]\n",
    "dnx_algo_port_db pp core dump pp_idx_0=0 pp_idx_1=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_pp_core_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~PP~CORE~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->pp[0][0].core));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_pp_core_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_pp_core_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db pp core size_get",
    "dnx_algo_port_db pp core size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_pp_core_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~PP~CORE~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_pp_core_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_pp_core_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db pp core diagnostic_operation_counters",
    "dnx_algo_port_db pp core diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_pp_is_lag_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_pp_is_lag_dump_cmd, NULL, dnx_swstate_dnx_algo_port_pp_is_lag_dump_options, &dnx_swstate_dnx_algo_port_pp_is_lag_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_pp_is_lag_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_pp_is_lag_size_get_options, &dnx_swstate_dnx_algo_port_pp_is_lag_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_pp_is_lag_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_pp_is_lag_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_pp_is_lag_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_pp_is_lag_man = {
    cmd_dnx_swstate_dnx_algo_port_pp_is_lag_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_pp_is_lag_desc[] = "dnx_algo_port_db pp is_lag commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_pp_is_lag_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  pp_idx_0 = 0;
    int  pp_idx_1 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("pp_idx_0", pp_idx_0);
    SH_SAND_GET_INT32("pp_idx_1", pp_idx_1);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_pp_is_lag_dump(unit, pp_idx_0, pp_idx_1, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_pp_is_lag_dump_options[] = {
    {"pp_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"pp_idx_1", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_pp_is_lag_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db pp is_lag dump [,pp_idx_0=<int>,pp_idx_1=<int>]\n",
    "dnx_algo_port_db pp is_lag dump pp_idx_0=0 pp_idx_1=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_pp_is_lag_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~PP~IS_LAG~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->pp[0][0].is_lag));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_pp_is_lag_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_pp_is_lag_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db pp is_lag size_get",
    "dnx_algo_port_db pp is_lag size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_pp_is_lag_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~PP~IS_LAG~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_pp_is_lag_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_pp_is_lag_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db pp is_lag diagnostic_operation_counters",
    "dnx_algo_port_db pp is_lag diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_pp_lag_id_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_pp_lag_id_dump_cmd, NULL, dnx_swstate_dnx_algo_port_pp_lag_id_dump_options, &dnx_swstate_dnx_algo_port_pp_lag_id_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_pp_lag_id_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_pp_lag_id_size_get_options, &dnx_swstate_dnx_algo_port_pp_lag_id_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_pp_lag_id_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_pp_lag_id_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_pp_lag_id_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_pp_lag_id_man = {
    cmd_dnx_swstate_dnx_algo_port_pp_lag_id_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_pp_lag_id_desc[] = "dnx_algo_port_db pp lag_id commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_pp_lag_id_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  pp_idx_0 = 0;
    int  pp_idx_1 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("pp_idx_0", pp_idx_0);
    SH_SAND_GET_INT32("pp_idx_1", pp_idx_1);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_pp_lag_id_dump(unit, pp_idx_0, pp_idx_1, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_pp_lag_id_dump_options[] = {
    {"pp_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"pp_idx_1", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_pp_lag_id_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db pp lag_id dump [,pp_idx_0=<int>,pp_idx_1=<int>]\n",
    "dnx_algo_port_db pp lag_id dump pp_idx_0=0 pp_idx_1=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_pp_lag_id_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~PP~LAG_ID~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->pp[0][0].lag_id));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_pp_lag_id_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_pp_lag_id_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db pp lag_id size_get",
    "dnx_algo_port_db pp lag_id size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_pp_lag_id_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~PP~LAG_ID~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_pp_lag_id_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_pp_lag_id_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db pp lag_id diagnostic_operation_counters",
    "dnx_algo_port_db pp lag_id diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_pp_master_logical_port_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_pp_master_logical_port_dump_cmd, NULL, dnx_swstate_dnx_algo_port_pp_master_logical_port_dump_options, &dnx_swstate_dnx_algo_port_pp_master_logical_port_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_pp_master_logical_port_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_pp_master_logical_port_size_get_options, &dnx_swstate_dnx_algo_port_pp_master_logical_port_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_pp_master_logical_port_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_pp_master_logical_port_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_pp_master_logical_port_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_pp_master_logical_port_man = {
    cmd_dnx_swstate_dnx_algo_port_pp_master_logical_port_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_pp_master_logical_port_desc[] = "dnx_algo_port_db pp master_logical_port commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_pp_master_logical_port_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  pp_idx_0 = 0;
    int  pp_idx_1 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("pp_idx_0", pp_idx_0);
    SH_SAND_GET_INT32("pp_idx_1", pp_idx_1);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_pp_master_logical_port_dump(unit, pp_idx_0, pp_idx_1, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_pp_master_logical_port_dump_options[] = {
    {"pp_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"pp_idx_1", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_pp_master_logical_port_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db pp master_logical_port dump [,pp_idx_0=<int>,pp_idx_1=<int>]\n",
    "dnx_algo_port_db pp master_logical_port dump pp_idx_0=0 pp_idx_1=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_pp_master_logical_port_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~PP~MASTER_LOGICAL_PORT~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->pp[0][0].master_logical_port));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_pp_master_logical_port_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_pp_master_logical_port_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db pp master_logical_port size_get",
    "dnx_algo_port_db pp master_logical_port size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_pp_master_logical_port_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~PP~MASTER_LOGICAL_PORT~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_pp_master_logical_port_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_pp_master_logical_port_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db pp master_logical_port diagnostic_operation_counters",
    "dnx_algo_port_db pp master_logical_port diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_pp_header_mode_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_pp_header_mode_dump_cmd, NULL, dnx_swstate_dnx_algo_port_pp_header_mode_dump_options, &dnx_swstate_dnx_algo_port_pp_header_mode_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_pp_header_mode_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_pp_header_mode_size_get_options, &dnx_swstate_dnx_algo_port_pp_header_mode_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_pp_header_mode_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_pp_header_mode_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_pp_header_mode_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_pp_header_mode_man = {
    cmd_dnx_swstate_dnx_algo_port_pp_header_mode_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_pp_header_mode_desc[] = "dnx_algo_port_db pp header_mode commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_pp_header_mode_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  pp_idx_0 = 0;
    int  pp_idx_1 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("pp_idx_0", pp_idx_0);
    SH_SAND_GET_INT32("pp_idx_1", pp_idx_1);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_pp_header_mode_dump(unit, pp_idx_0, pp_idx_1, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_pp_header_mode_dump_options[] = {
    {"pp_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"pp_idx_1", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_pp_header_mode_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db pp header_mode dump [,pp_idx_0=<int>,pp_idx_1=<int>]\n",
    "dnx_algo_port_db pp header_mode dump pp_idx_0=0 pp_idx_1=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_pp_header_mode_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~PP~HEADER_MODE~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->pp[0][0].header_mode));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_pp_header_mode_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_pp_header_mode_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db pp header_mode size_get",
    "dnx_algo_port_db pp header_mode size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_pp_header_mode_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~PP~HEADER_MODE~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_pp_header_mode_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_pp_header_mode_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db pp header_mode diagnostic_operation_counters",
    "dnx_algo_port_db pp header_mode diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_pp_ingress_llvp_profile_valid_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_pp_ingress_llvp_profile_valid_dump_cmd, NULL, dnx_swstate_dnx_algo_port_pp_ingress_llvp_profile_valid_dump_options, &dnx_swstate_dnx_algo_port_pp_ingress_llvp_profile_valid_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_pp_ingress_llvp_profile_valid_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_pp_ingress_llvp_profile_valid_size_get_options, &dnx_swstate_dnx_algo_port_pp_ingress_llvp_profile_valid_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_pp_ingress_llvp_profile_valid_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_pp_ingress_llvp_profile_valid_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_pp_ingress_llvp_profile_valid_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_pp_ingress_llvp_profile_valid_man = {
    cmd_dnx_swstate_dnx_algo_port_pp_ingress_llvp_profile_valid_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_pp_ingress_llvp_profile_valid_desc[] = "dnx_algo_port_db pp ingress_llvp_profile_valid commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_pp_ingress_llvp_profile_valid_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  pp_idx_0 = 0;
    int  pp_idx_1 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("pp_idx_0", pp_idx_0);
    SH_SAND_GET_INT32("pp_idx_1", pp_idx_1);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_pp_ingress_llvp_profile_valid_dump(unit, pp_idx_0, pp_idx_1, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_pp_ingress_llvp_profile_valid_dump_options[] = {
    {"pp_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"pp_idx_1", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_pp_ingress_llvp_profile_valid_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db pp ingress_llvp_profile_valid dump [,pp_idx_0=<int>,pp_idx_1=<int>]\n",
    "dnx_algo_port_db pp ingress_llvp_profile_valid dump pp_idx_0=0 pp_idx_1=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_pp_ingress_llvp_profile_valid_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~PP~INGRESS_LLVP_PROFILE_VALID~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->pp[0][0].ingress_llvp_profile_valid));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_pp_ingress_llvp_profile_valid_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_pp_ingress_llvp_profile_valid_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db pp ingress_llvp_profile_valid size_get",
    "dnx_algo_port_db pp ingress_llvp_profile_valid size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_pp_ingress_llvp_profile_valid_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~PP~INGRESS_LLVP_PROFILE_VALID~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_pp_ingress_llvp_profile_valid_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_pp_ingress_llvp_profile_valid_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db pp ingress_llvp_profile_valid diagnostic_operation_counters",
    "dnx_algo_port_db pp ingress_llvp_profile_valid diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_pp_egress_llvp_profile_valid_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_pp_egress_llvp_profile_valid_dump_cmd, NULL, dnx_swstate_dnx_algo_port_pp_egress_llvp_profile_valid_dump_options, &dnx_swstate_dnx_algo_port_pp_egress_llvp_profile_valid_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_pp_egress_llvp_profile_valid_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_pp_egress_llvp_profile_valid_size_get_options, &dnx_swstate_dnx_algo_port_pp_egress_llvp_profile_valid_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_pp_egress_llvp_profile_valid_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_pp_egress_llvp_profile_valid_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_pp_egress_llvp_profile_valid_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_pp_egress_llvp_profile_valid_man = {
    cmd_dnx_swstate_dnx_algo_port_pp_egress_llvp_profile_valid_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_pp_egress_llvp_profile_valid_desc[] = "dnx_algo_port_db pp egress_llvp_profile_valid commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_pp_egress_llvp_profile_valid_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  pp_idx_0 = 0;
    int  pp_idx_1 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("pp_idx_0", pp_idx_0);
    SH_SAND_GET_INT32("pp_idx_1", pp_idx_1);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_pp_egress_llvp_profile_valid_dump(unit, pp_idx_0, pp_idx_1, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_pp_egress_llvp_profile_valid_dump_options[] = {
    {"pp_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"pp_idx_1", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_pp_egress_llvp_profile_valid_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db pp egress_llvp_profile_valid dump [,pp_idx_0=<int>,pp_idx_1=<int>]\n",
    "dnx_algo_port_db pp egress_llvp_profile_valid dump pp_idx_0=0 pp_idx_1=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_pp_egress_llvp_profile_valid_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~PP~EGRESS_LLVP_PROFILE_VALID~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->pp[0][0].egress_llvp_profile_valid));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_pp_egress_llvp_profile_valid_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_pp_egress_llvp_profile_valid_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db pp egress_llvp_profile_valid size_get",
    "dnx_algo_port_db pp egress_llvp_profile_valid size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_pp_egress_llvp_profile_valid_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~PP~EGRESS_LLVP_PROFILE_VALID~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_pp_egress_llvp_profile_valid_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_pp_egress_llvp_profile_valid_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db pp egress_llvp_profile_valid diagnostic_operation_counters",
    "dnx_algo_port_db pp egress_llvp_profile_valid diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_pp_alloc_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_pp_alloc_dump_cmd, NULL, dnx_swstate_dnx_algo_port_pp_alloc_dump_options, &dnx_swstate_dnx_algo_port_pp_alloc_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_pp_alloc_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_pp_alloc_size_get_options, &dnx_swstate_dnx_algo_port_pp_alloc_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_pp_alloc_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_pp_alloc_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_pp_alloc_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_pp_alloc_man = {
    cmd_dnx_swstate_dnx_algo_port_pp_alloc_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_pp_alloc_desc[] = "dnx_algo_port_db pp_alloc commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_pp_alloc_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  pp_alloc_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("pp_alloc_idx_0", pp_alloc_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_pp_alloc_dump(unit, pp_alloc_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_pp_alloc_dump_options[] = {
    {"pp_alloc_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_pp_alloc_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db pp_alloc dump [,pp_alloc_idx_0=<int>]\n",
    "dnx_algo_port_db pp_alloc dump pp_alloc_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_pp_alloc_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~PP_ALLOC~", 0);
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_pp_alloc_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_pp_alloc_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db pp_alloc size_get",
    "dnx_algo_port_db pp_alloc size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_pp_alloc_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~PP_ALLOC~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_pp_alloc_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_pp_alloc_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db pp_alloc diagnostic_operation_counters",
    "dnx_algo_port_db pp_alloc diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_ilkn_cmds[] = {
    {"valid", NULL, sh_dnx_swstate_dnx_algo_port_ilkn_valid_cmds, NULL, &dnx_swstate_dnx_algo_port_ilkn_valid_man},
    {"master_logical_port", NULL, sh_dnx_swstate_dnx_algo_port_ilkn_master_logical_port_cmds, NULL, &dnx_swstate_dnx_algo_port_ilkn_master_logical_port_man},
    {"nof_segments", NULL, sh_dnx_swstate_dnx_algo_port_ilkn_nof_segments_cmds, NULL, &dnx_swstate_dnx_algo_port_ilkn_nof_segments_man},
    {"is_over_fabric", NULL, sh_dnx_swstate_dnx_algo_port_ilkn_is_over_fabric_cmds, NULL, &dnx_swstate_dnx_algo_port_ilkn_is_over_fabric_man},
    {"is_elk", NULL, sh_dnx_swstate_dnx_algo_port_ilkn_is_elk_cmds, NULL, &dnx_swstate_dnx_algo_port_ilkn_is_elk_man},
    {"lanes", NULL, sh_dnx_swstate_dnx_algo_port_ilkn_lanes_cmds, NULL, &dnx_swstate_dnx_algo_port_ilkn_lanes_man},
    {"priority", NULL, sh_dnx_swstate_dnx_algo_port_ilkn_priority_cmds, NULL, &dnx_swstate_dnx_algo_port_ilkn_priority_man},
    {"dump", sh_dnx_swstate_dnx_algo_port_ilkn_dump_cmd, NULL, dnx_swstate_dnx_algo_port_ilkn_dump_options, &dnx_swstate_dnx_algo_port_ilkn_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_ilkn_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_ilkn_size_get_options, &dnx_swstate_dnx_algo_port_ilkn_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_ilkn_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_ilkn_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_ilkn_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_ilkn_man = {
    cmd_dnx_swstate_dnx_algo_port_ilkn_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_ilkn_desc[] = "dnx_algo_port_db ilkn commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_ilkn_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  ilkn_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("ilkn_idx_0", ilkn_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_ilkn_dump(unit, ilkn_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_ilkn_dump_options[] = {
    {"ilkn_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_ilkn_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db ilkn dump [,ilkn_idx_0=<int>]\n",
    "dnx_algo_port_db ilkn dump ilkn_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_ilkn_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~ILKN~", 0);
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_ilkn_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_ilkn_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db ilkn size_get",
    "dnx_algo_port_db ilkn size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_ilkn_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~ILKN~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_ilkn_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_ilkn_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db ilkn diagnostic_operation_counters",
    "dnx_algo_port_db ilkn diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_ilkn_valid_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_ilkn_valid_dump_cmd, NULL, dnx_swstate_dnx_algo_port_ilkn_valid_dump_options, &dnx_swstate_dnx_algo_port_ilkn_valid_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_ilkn_valid_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_ilkn_valid_size_get_options, &dnx_swstate_dnx_algo_port_ilkn_valid_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_ilkn_valid_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_ilkn_valid_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_ilkn_valid_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_ilkn_valid_man = {
    cmd_dnx_swstate_dnx_algo_port_ilkn_valid_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_ilkn_valid_desc[] = "dnx_algo_port_db ilkn valid commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_ilkn_valid_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  ilkn_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("ilkn_idx_0", ilkn_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_ilkn_valid_dump(unit, ilkn_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_ilkn_valid_dump_options[] = {
    {"ilkn_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_ilkn_valid_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db ilkn valid dump [,ilkn_idx_0=<int>]\n",
    "dnx_algo_port_db ilkn valid dump ilkn_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_ilkn_valid_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~ILKN~VALID~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->ilkn[0].valid));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_ilkn_valid_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_ilkn_valid_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db ilkn valid size_get",
    "dnx_algo_port_db ilkn valid size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_ilkn_valid_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~ILKN~VALID~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_ilkn_valid_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_ilkn_valid_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db ilkn valid diagnostic_operation_counters",
    "dnx_algo_port_db ilkn valid diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_ilkn_master_logical_port_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_ilkn_master_logical_port_dump_cmd, NULL, dnx_swstate_dnx_algo_port_ilkn_master_logical_port_dump_options, &dnx_swstate_dnx_algo_port_ilkn_master_logical_port_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_ilkn_master_logical_port_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_ilkn_master_logical_port_size_get_options, &dnx_swstate_dnx_algo_port_ilkn_master_logical_port_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_ilkn_master_logical_port_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_ilkn_master_logical_port_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_ilkn_master_logical_port_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_ilkn_master_logical_port_man = {
    cmd_dnx_swstate_dnx_algo_port_ilkn_master_logical_port_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_ilkn_master_logical_port_desc[] = "dnx_algo_port_db ilkn master_logical_port commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_ilkn_master_logical_port_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  ilkn_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("ilkn_idx_0", ilkn_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_ilkn_master_logical_port_dump(unit, ilkn_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_ilkn_master_logical_port_dump_options[] = {
    {"ilkn_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_ilkn_master_logical_port_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db ilkn master_logical_port dump [,ilkn_idx_0=<int>]\n",
    "dnx_algo_port_db ilkn master_logical_port dump ilkn_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_ilkn_master_logical_port_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~ILKN~MASTER_LOGICAL_PORT~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->ilkn[0].master_logical_port));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_ilkn_master_logical_port_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_ilkn_master_logical_port_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db ilkn master_logical_port size_get",
    "dnx_algo_port_db ilkn master_logical_port size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_ilkn_master_logical_port_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~ILKN~MASTER_LOGICAL_PORT~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_ilkn_master_logical_port_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_ilkn_master_logical_port_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db ilkn master_logical_port diagnostic_operation_counters",
    "dnx_algo_port_db ilkn master_logical_port diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_ilkn_nof_segments_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_ilkn_nof_segments_dump_cmd, NULL, dnx_swstate_dnx_algo_port_ilkn_nof_segments_dump_options, &dnx_swstate_dnx_algo_port_ilkn_nof_segments_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_ilkn_nof_segments_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_ilkn_nof_segments_size_get_options, &dnx_swstate_dnx_algo_port_ilkn_nof_segments_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_ilkn_nof_segments_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_ilkn_nof_segments_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_ilkn_nof_segments_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_ilkn_nof_segments_man = {
    cmd_dnx_swstate_dnx_algo_port_ilkn_nof_segments_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_ilkn_nof_segments_desc[] = "dnx_algo_port_db ilkn nof_segments commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_ilkn_nof_segments_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  ilkn_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("ilkn_idx_0", ilkn_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_ilkn_nof_segments_dump(unit, ilkn_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_ilkn_nof_segments_dump_options[] = {
    {"ilkn_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_ilkn_nof_segments_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db ilkn nof_segments dump [,ilkn_idx_0=<int>]\n",
    "dnx_algo_port_db ilkn nof_segments dump ilkn_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_ilkn_nof_segments_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~ILKN~NOF_SEGMENTS~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->ilkn[0].nof_segments));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_ilkn_nof_segments_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_ilkn_nof_segments_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db ilkn nof_segments size_get",
    "dnx_algo_port_db ilkn nof_segments size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_ilkn_nof_segments_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~ILKN~NOF_SEGMENTS~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_ilkn_nof_segments_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_ilkn_nof_segments_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db ilkn nof_segments diagnostic_operation_counters",
    "dnx_algo_port_db ilkn nof_segments diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_ilkn_is_over_fabric_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_ilkn_is_over_fabric_dump_cmd, NULL, dnx_swstate_dnx_algo_port_ilkn_is_over_fabric_dump_options, &dnx_swstate_dnx_algo_port_ilkn_is_over_fabric_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_ilkn_is_over_fabric_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_ilkn_is_over_fabric_size_get_options, &dnx_swstate_dnx_algo_port_ilkn_is_over_fabric_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_ilkn_is_over_fabric_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_ilkn_is_over_fabric_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_ilkn_is_over_fabric_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_ilkn_is_over_fabric_man = {
    cmd_dnx_swstate_dnx_algo_port_ilkn_is_over_fabric_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_ilkn_is_over_fabric_desc[] = "dnx_algo_port_db ilkn is_over_fabric commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_ilkn_is_over_fabric_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  ilkn_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("ilkn_idx_0", ilkn_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_ilkn_is_over_fabric_dump(unit, ilkn_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_ilkn_is_over_fabric_dump_options[] = {
    {"ilkn_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_ilkn_is_over_fabric_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db ilkn is_over_fabric dump [,ilkn_idx_0=<int>]\n",
    "dnx_algo_port_db ilkn is_over_fabric dump ilkn_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_ilkn_is_over_fabric_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~ILKN~IS_OVER_FABRIC~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->ilkn[0].is_over_fabric));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_ilkn_is_over_fabric_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_ilkn_is_over_fabric_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db ilkn is_over_fabric size_get",
    "dnx_algo_port_db ilkn is_over_fabric size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_ilkn_is_over_fabric_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~ILKN~IS_OVER_FABRIC~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_ilkn_is_over_fabric_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_ilkn_is_over_fabric_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db ilkn is_over_fabric diagnostic_operation_counters",
    "dnx_algo_port_db ilkn is_over_fabric diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_ilkn_is_elk_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_ilkn_is_elk_dump_cmd, NULL, dnx_swstate_dnx_algo_port_ilkn_is_elk_dump_options, &dnx_swstate_dnx_algo_port_ilkn_is_elk_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_ilkn_is_elk_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_ilkn_is_elk_size_get_options, &dnx_swstate_dnx_algo_port_ilkn_is_elk_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_ilkn_is_elk_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_ilkn_is_elk_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_ilkn_is_elk_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_ilkn_is_elk_man = {
    cmd_dnx_swstate_dnx_algo_port_ilkn_is_elk_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_ilkn_is_elk_desc[] = "dnx_algo_port_db ilkn is_elk commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_ilkn_is_elk_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  ilkn_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("ilkn_idx_0", ilkn_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_ilkn_is_elk_dump(unit, ilkn_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_ilkn_is_elk_dump_options[] = {
    {"ilkn_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_ilkn_is_elk_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db ilkn is_elk dump [,ilkn_idx_0=<int>]\n",
    "dnx_algo_port_db ilkn is_elk dump ilkn_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_ilkn_is_elk_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~ILKN~IS_ELK~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->ilkn[0].is_elk));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_ilkn_is_elk_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_ilkn_is_elk_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db ilkn is_elk size_get",
    "dnx_algo_port_db ilkn is_elk size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_ilkn_is_elk_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~ILKN~IS_ELK~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_ilkn_is_elk_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_ilkn_is_elk_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db ilkn is_elk diagnostic_operation_counters",
    "dnx_algo_port_db ilkn is_elk diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_ilkn_lanes_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_ilkn_lanes_dump_cmd, NULL, dnx_swstate_dnx_algo_port_ilkn_lanes_dump_options, &dnx_swstate_dnx_algo_port_ilkn_lanes_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_ilkn_lanes_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_ilkn_lanes_size_get_options, &dnx_swstate_dnx_algo_port_ilkn_lanes_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_ilkn_lanes_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_ilkn_lanes_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_ilkn_lanes_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_ilkn_lanes_man = {
    cmd_dnx_swstate_dnx_algo_port_ilkn_lanes_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_ilkn_lanes_desc[] = "dnx_algo_port_db ilkn lanes commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_ilkn_lanes_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  ilkn_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("ilkn_idx_0", ilkn_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_ilkn_lanes_dump(unit, ilkn_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_ilkn_lanes_dump_options[] = {
    {"ilkn_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_ilkn_lanes_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db ilkn lanes dump [,ilkn_idx_0=<int>]\n",
    "dnx_algo_port_db ilkn lanes dump ilkn_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_ilkn_lanes_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~ILKN~LANES~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->ilkn[0].lanes));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_ilkn_lanes_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_ilkn_lanes_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db ilkn lanes size_get",
    "dnx_algo_port_db ilkn lanes size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_ilkn_lanes_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~ILKN~LANES~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_ilkn_lanes_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_ilkn_lanes_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db ilkn lanes diagnostic_operation_counters",
    "dnx_algo_port_db ilkn lanes diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_ilkn_priority_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_ilkn_priority_dump_cmd, NULL, dnx_swstate_dnx_algo_port_ilkn_priority_dump_options, &dnx_swstate_dnx_algo_port_ilkn_priority_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_ilkn_priority_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_ilkn_priority_size_get_options, &dnx_swstate_dnx_algo_port_ilkn_priority_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_ilkn_priority_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_ilkn_priority_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_ilkn_priority_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_ilkn_priority_man = {
    cmd_dnx_swstate_dnx_algo_port_ilkn_priority_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_ilkn_priority_desc[] = "dnx_algo_port_db ilkn priority commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_ilkn_priority_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  ilkn_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("ilkn_idx_0", ilkn_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_ilkn_priority_dump(unit, ilkn_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_ilkn_priority_dump_options[] = {
    {"ilkn_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_ilkn_priority_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db ilkn priority dump [,ilkn_idx_0=<int>]\n",
    "dnx_algo_port_db ilkn priority dump ilkn_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_ilkn_priority_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~ILKN~PRIORITY~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->ilkn[0].priority));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_ilkn_priority_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_ilkn_priority_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db ilkn priority size_get",
    "dnx_algo_port_db ilkn priority size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_ilkn_priority_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~ILKN~PRIORITY~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_ilkn_priority_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_ilkn_priority_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db ilkn priority diagnostic_operation_counters",
    "dnx_algo_port_db ilkn priority diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_flexe_cmds[] = {
    {"client", NULL, sh_dnx_swstate_dnx_algo_port_flexe_client_cmds, NULL, &dnx_swstate_dnx_algo_port_flexe_client_man},
    {"mac", NULL, sh_dnx_swstate_dnx_algo_port_flexe_mac_cmds, NULL, &dnx_swstate_dnx_algo_port_flexe_mac_man},
    {"sar", NULL, sh_dnx_swstate_dnx_algo_port_flexe_sar_cmds, NULL, &dnx_swstate_dnx_algo_port_flexe_sar_man},
    {"phy", NULL, sh_dnx_swstate_dnx_algo_port_flexe_phy_cmds, NULL, &dnx_swstate_dnx_algo_port_flexe_phy_man},
    {"dump", sh_dnx_swstate_dnx_algo_port_flexe_dump_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_dump_options, &dnx_swstate_dnx_algo_port_flexe_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_flexe_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_size_get_options, &dnx_swstate_dnx_algo_port_flexe_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_flexe_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_flexe_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_man = {
    cmd_dnx_swstate_dnx_algo_port_flexe_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_flexe_desc[] = "dnx_algo_port_db flexe commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);


    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_flexe_dump(unit, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_dump_options[] = {
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db flexe dump []\n",
    "dnx_algo_port_db flexe dump nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FLEXE~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->flexe));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db flexe size_get",
    "dnx_algo_port_db flexe size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FLEXE~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db flexe diagnostic_operation_counters",
    "dnx_algo_port_db flexe diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_flexe_client_cmds[] = {
    {"valid", NULL, sh_dnx_swstate_dnx_algo_port_flexe_client_valid_cmds, NULL, &dnx_swstate_dnx_algo_port_flexe_client_valid_man},
    {"client_index", NULL, sh_dnx_swstate_dnx_algo_port_flexe_client_client_index_cmds, NULL, &dnx_swstate_dnx_algo_port_flexe_client_client_index_man},
    {"client_id", NULL, sh_dnx_swstate_dnx_algo_port_flexe_client_client_id_cmds, NULL, &dnx_swstate_dnx_algo_port_flexe_client_client_id_man},
    {"master_logical_port", NULL, sh_dnx_swstate_dnx_algo_port_flexe_client_master_logical_port_cmds, NULL, &dnx_swstate_dnx_algo_port_flexe_client_master_logical_port_man},
    {"is_bypass", NULL, sh_dnx_swstate_dnx_algo_port_flexe_client_is_bypass_cmds, NULL, &dnx_swstate_dnx_algo_port_flexe_client_is_bypass_man},
    {"dump", sh_dnx_swstate_dnx_algo_port_flexe_client_dump_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_client_dump_options, &dnx_swstate_dnx_algo_port_flexe_client_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_flexe_client_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_client_size_get_options, &dnx_swstate_dnx_algo_port_flexe_client_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_flexe_client_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_client_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_flexe_client_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_client_man = {
    cmd_dnx_swstate_dnx_algo_port_flexe_client_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_flexe_client_desc[] = "dnx_algo_port_db flexe client commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_client_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  client_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("client_idx_0", client_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_flexe_client_dump(unit, client_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_client_dump_options[] = {
    {"client_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_client_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db flexe client dump [,client_idx_0=<int>]\n",
    "dnx_algo_port_db flexe client dump client_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_client_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FLEXE~CLIENT~", 0);
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_client_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_client_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db flexe client size_get",
    "dnx_algo_port_db flexe client size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_client_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FLEXE~CLIENT~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_client_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_client_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db flexe client diagnostic_operation_counters",
    "dnx_algo_port_db flexe client diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_flexe_client_valid_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_flexe_client_valid_dump_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_client_valid_dump_options, &dnx_swstate_dnx_algo_port_flexe_client_valid_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_flexe_client_valid_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_client_valid_size_get_options, &dnx_swstate_dnx_algo_port_flexe_client_valid_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_flexe_client_valid_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_client_valid_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_flexe_client_valid_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_client_valid_man = {
    cmd_dnx_swstate_dnx_algo_port_flexe_client_valid_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_flexe_client_valid_desc[] = "dnx_algo_port_db flexe client valid commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_client_valid_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  client_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("client_idx_0", client_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_flexe_client_valid_dump(unit, client_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_client_valid_dump_options[] = {
    {"client_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_client_valid_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db flexe client valid dump [,client_idx_0=<int>]\n",
    "dnx_algo_port_db flexe client valid dump client_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_client_valid_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FLEXE~CLIENT~VALID~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->flexe.client[0].valid));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_client_valid_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_client_valid_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db flexe client valid size_get",
    "dnx_algo_port_db flexe client valid size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_client_valid_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FLEXE~CLIENT~VALID~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_client_valid_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_client_valid_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db flexe client valid diagnostic_operation_counters",
    "dnx_algo_port_db flexe client valid diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_flexe_client_client_index_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_flexe_client_client_index_dump_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_client_client_index_dump_options, &dnx_swstate_dnx_algo_port_flexe_client_client_index_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_flexe_client_client_index_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_client_client_index_size_get_options, &dnx_swstate_dnx_algo_port_flexe_client_client_index_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_flexe_client_client_index_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_client_client_index_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_flexe_client_client_index_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_client_client_index_man = {
    cmd_dnx_swstate_dnx_algo_port_flexe_client_client_index_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_flexe_client_client_index_desc[] = "dnx_algo_port_db flexe client client_index commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_client_client_index_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  client_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("client_idx_0", client_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_flexe_client_client_index_dump(unit, client_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_client_client_index_dump_options[] = {
    {"client_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_client_client_index_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db flexe client client_index dump [,client_idx_0=<int>]\n",
    "dnx_algo_port_db flexe client client_index dump client_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_client_client_index_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FLEXE~CLIENT~CLIENT_INDEX~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->flexe.client[0].client_index));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_client_client_index_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_client_client_index_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db flexe client client_index size_get",
    "dnx_algo_port_db flexe client client_index size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_client_client_index_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FLEXE~CLIENT~CLIENT_INDEX~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_client_client_index_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_client_client_index_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db flexe client client_index diagnostic_operation_counters",
    "dnx_algo_port_db flexe client client_index diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_flexe_client_client_id_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_flexe_client_client_id_dump_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_client_client_id_dump_options, &dnx_swstate_dnx_algo_port_flexe_client_client_id_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_flexe_client_client_id_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_client_client_id_size_get_options, &dnx_swstate_dnx_algo_port_flexe_client_client_id_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_flexe_client_client_id_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_client_client_id_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_flexe_client_client_id_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_client_client_id_man = {
    cmd_dnx_swstate_dnx_algo_port_flexe_client_client_id_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_flexe_client_client_id_desc[] = "dnx_algo_port_db flexe client client_id commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_client_client_id_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  client_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("client_idx_0", client_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_flexe_client_client_id_dump(unit, client_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_client_client_id_dump_options[] = {
    {"client_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_client_client_id_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db flexe client client_id dump [,client_idx_0=<int>]\n",
    "dnx_algo_port_db flexe client client_id dump client_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_client_client_id_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FLEXE~CLIENT~CLIENT_ID~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->flexe.client[0].client_id));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_client_client_id_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_client_client_id_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db flexe client client_id size_get",
    "dnx_algo_port_db flexe client client_id size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_client_client_id_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FLEXE~CLIENT~CLIENT_ID~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_client_client_id_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_client_client_id_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db flexe client client_id diagnostic_operation_counters",
    "dnx_algo_port_db flexe client client_id diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_flexe_client_master_logical_port_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_flexe_client_master_logical_port_dump_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_client_master_logical_port_dump_options, &dnx_swstate_dnx_algo_port_flexe_client_master_logical_port_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_flexe_client_master_logical_port_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_client_master_logical_port_size_get_options, &dnx_swstate_dnx_algo_port_flexe_client_master_logical_port_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_flexe_client_master_logical_port_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_client_master_logical_port_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_flexe_client_master_logical_port_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_client_master_logical_port_man = {
    cmd_dnx_swstate_dnx_algo_port_flexe_client_master_logical_port_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_flexe_client_master_logical_port_desc[] = "dnx_algo_port_db flexe client master_logical_port commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_client_master_logical_port_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  client_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("client_idx_0", client_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_flexe_client_master_logical_port_dump(unit, client_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_client_master_logical_port_dump_options[] = {
    {"client_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_client_master_logical_port_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db flexe client master_logical_port dump [,client_idx_0=<int>]\n",
    "dnx_algo_port_db flexe client master_logical_port dump client_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_client_master_logical_port_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FLEXE~CLIENT~MASTER_LOGICAL_PORT~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->flexe.client[0].master_logical_port));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_client_master_logical_port_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_client_master_logical_port_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db flexe client master_logical_port size_get",
    "dnx_algo_port_db flexe client master_logical_port size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_client_master_logical_port_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FLEXE~CLIENT~MASTER_LOGICAL_PORT~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_client_master_logical_port_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_client_master_logical_port_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db flexe client master_logical_port diagnostic_operation_counters",
    "dnx_algo_port_db flexe client master_logical_port diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_flexe_client_is_bypass_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_flexe_client_is_bypass_dump_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_client_is_bypass_dump_options, &dnx_swstate_dnx_algo_port_flexe_client_is_bypass_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_flexe_client_is_bypass_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_client_is_bypass_size_get_options, &dnx_swstate_dnx_algo_port_flexe_client_is_bypass_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_flexe_client_is_bypass_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_client_is_bypass_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_flexe_client_is_bypass_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_client_is_bypass_man = {
    cmd_dnx_swstate_dnx_algo_port_flexe_client_is_bypass_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_flexe_client_is_bypass_desc[] = "dnx_algo_port_db flexe client is_bypass commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_client_is_bypass_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  client_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("client_idx_0", client_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_flexe_client_is_bypass_dump(unit, client_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_client_is_bypass_dump_options[] = {
    {"client_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_client_is_bypass_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db flexe client is_bypass dump [,client_idx_0=<int>]\n",
    "dnx_algo_port_db flexe client is_bypass dump client_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_client_is_bypass_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FLEXE~CLIENT~IS_BYPASS~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->flexe.client[0].is_bypass));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_client_is_bypass_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_client_is_bypass_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db flexe client is_bypass size_get",
    "dnx_algo_port_db flexe client is_bypass size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_client_is_bypass_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FLEXE~CLIENT~IS_BYPASS~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_client_is_bypass_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_client_is_bypass_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db flexe client is_bypass diagnostic_operation_counters",
    "dnx_algo_port_db flexe client is_bypass diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_flexe_mac_cmds[] = {
    {"valid", NULL, sh_dnx_swstate_dnx_algo_port_flexe_mac_valid_cmds, NULL, &dnx_swstate_dnx_algo_port_flexe_mac_valid_man},
    {"master_logical_port", NULL, sh_dnx_swstate_dnx_algo_port_flexe_mac_master_logical_port_cmds, NULL, &dnx_swstate_dnx_algo_port_flexe_mac_master_logical_port_man},
    {"client_index", NULL, sh_dnx_swstate_dnx_algo_port_flexe_mac_client_index_cmds, NULL, &dnx_swstate_dnx_algo_port_flexe_mac_client_index_man},
    {"logical_fifos", NULL, sh_dnx_swstate_dnx_algo_port_flexe_mac_logical_fifos_cmds, NULL, &dnx_swstate_dnx_algo_port_flexe_mac_logical_fifos_man},
    {"timeslot_bitmap", NULL, sh_dnx_swstate_dnx_algo_port_flexe_mac_timeslot_bitmap_cmds, NULL, &dnx_swstate_dnx_algo_port_flexe_mac_timeslot_bitmap_man},
    {"dump", sh_dnx_swstate_dnx_algo_port_flexe_mac_dump_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_mac_dump_options, &dnx_swstate_dnx_algo_port_flexe_mac_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_flexe_mac_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_mac_size_get_options, &dnx_swstate_dnx_algo_port_flexe_mac_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_flexe_mac_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_mac_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_flexe_mac_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_mac_man = {
    cmd_dnx_swstate_dnx_algo_port_flexe_mac_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_flexe_mac_desc[] = "dnx_algo_port_db flexe mac commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_mac_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  mac_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("mac_idx_0", mac_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_flexe_mac_dump(unit, mac_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_mac_dump_options[] = {
    {"mac_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_mac_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db flexe mac dump [,mac_idx_0=<int>]\n",
    "dnx_algo_port_db flexe mac dump mac_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_mac_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FLEXE~MAC~", 0);
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_mac_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_mac_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db flexe mac size_get",
    "dnx_algo_port_db flexe mac size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_mac_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FLEXE~MAC~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_mac_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_mac_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db flexe mac diagnostic_operation_counters",
    "dnx_algo_port_db flexe mac diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_flexe_mac_valid_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_flexe_mac_valid_dump_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_mac_valid_dump_options, &dnx_swstate_dnx_algo_port_flexe_mac_valid_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_flexe_mac_valid_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_mac_valid_size_get_options, &dnx_swstate_dnx_algo_port_flexe_mac_valid_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_flexe_mac_valid_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_mac_valid_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_flexe_mac_valid_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_mac_valid_man = {
    cmd_dnx_swstate_dnx_algo_port_flexe_mac_valid_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_flexe_mac_valid_desc[] = "dnx_algo_port_db flexe mac valid commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_mac_valid_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  mac_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("mac_idx_0", mac_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_flexe_mac_valid_dump(unit, mac_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_mac_valid_dump_options[] = {
    {"mac_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_mac_valid_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db flexe mac valid dump [,mac_idx_0=<int>]\n",
    "dnx_algo_port_db flexe mac valid dump mac_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_mac_valid_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FLEXE~MAC~VALID~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->flexe.mac[0].valid));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_mac_valid_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_mac_valid_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db flexe mac valid size_get",
    "dnx_algo_port_db flexe mac valid size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_mac_valid_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FLEXE~MAC~VALID~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_mac_valid_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_mac_valid_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db flexe mac valid diagnostic_operation_counters",
    "dnx_algo_port_db flexe mac valid diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_flexe_mac_master_logical_port_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_flexe_mac_master_logical_port_dump_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_mac_master_logical_port_dump_options, &dnx_swstate_dnx_algo_port_flexe_mac_master_logical_port_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_flexe_mac_master_logical_port_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_mac_master_logical_port_size_get_options, &dnx_swstate_dnx_algo_port_flexe_mac_master_logical_port_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_flexe_mac_master_logical_port_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_mac_master_logical_port_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_flexe_mac_master_logical_port_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_mac_master_logical_port_man = {
    cmd_dnx_swstate_dnx_algo_port_flexe_mac_master_logical_port_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_flexe_mac_master_logical_port_desc[] = "dnx_algo_port_db flexe mac master_logical_port commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_mac_master_logical_port_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  mac_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("mac_idx_0", mac_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_flexe_mac_master_logical_port_dump(unit, mac_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_mac_master_logical_port_dump_options[] = {
    {"mac_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_mac_master_logical_port_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db flexe mac master_logical_port dump [,mac_idx_0=<int>]\n",
    "dnx_algo_port_db flexe mac master_logical_port dump mac_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_mac_master_logical_port_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FLEXE~MAC~MASTER_LOGICAL_PORT~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->flexe.mac[0].master_logical_port));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_mac_master_logical_port_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_mac_master_logical_port_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db flexe mac master_logical_port size_get",
    "dnx_algo_port_db flexe mac master_logical_port size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_mac_master_logical_port_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FLEXE~MAC~MASTER_LOGICAL_PORT~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_mac_master_logical_port_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_mac_master_logical_port_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db flexe mac master_logical_port diagnostic_operation_counters",
    "dnx_algo_port_db flexe mac master_logical_port diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_flexe_mac_client_index_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_flexe_mac_client_index_dump_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_mac_client_index_dump_options, &dnx_swstate_dnx_algo_port_flexe_mac_client_index_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_flexe_mac_client_index_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_mac_client_index_size_get_options, &dnx_swstate_dnx_algo_port_flexe_mac_client_index_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_flexe_mac_client_index_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_mac_client_index_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_flexe_mac_client_index_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_mac_client_index_man = {
    cmd_dnx_swstate_dnx_algo_port_flexe_mac_client_index_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_flexe_mac_client_index_desc[] = "dnx_algo_port_db flexe mac client_index commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_mac_client_index_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  mac_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("mac_idx_0", mac_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_flexe_mac_client_index_dump(unit, mac_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_mac_client_index_dump_options[] = {
    {"mac_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_mac_client_index_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db flexe mac client_index dump [,mac_idx_0=<int>]\n",
    "dnx_algo_port_db flexe mac client_index dump mac_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_mac_client_index_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FLEXE~MAC~CLIENT_INDEX~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->flexe.mac[0].client_index));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_mac_client_index_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_mac_client_index_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db flexe mac client_index size_get",
    "dnx_algo_port_db flexe mac client_index size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_mac_client_index_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FLEXE~MAC~CLIENT_INDEX~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_mac_client_index_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_mac_client_index_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db flexe mac client_index diagnostic_operation_counters",
    "dnx_algo_port_db flexe mac client_index diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_flexe_mac_logical_fifos_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_flexe_mac_logical_fifos_dump_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_mac_logical_fifos_dump_options, &dnx_swstate_dnx_algo_port_flexe_mac_logical_fifos_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_flexe_mac_logical_fifos_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_mac_logical_fifos_size_get_options, &dnx_swstate_dnx_algo_port_flexe_mac_logical_fifos_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_flexe_mac_logical_fifos_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_mac_logical_fifos_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_flexe_mac_logical_fifos_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_mac_logical_fifos_man = {
    cmd_dnx_swstate_dnx_algo_port_flexe_mac_logical_fifos_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_flexe_mac_logical_fifos_desc[] = "dnx_algo_port_db flexe mac logical_fifos commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_mac_logical_fifos_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  mac_idx_0 = 0;
    int  logical_fifos_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("mac_idx_0", mac_idx_0);
    SH_SAND_GET_INT32("logical_fifos_idx_0", logical_fifos_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_flexe_mac_logical_fifos_dump(unit, mac_idx_0, logical_fifos_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_mac_logical_fifos_dump_options[] = {
    {"mac_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"logical_fifos_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_mac_logical_fifos_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db flexe mac logical_fifos dump [,mac_idx_0=<int>,logical_fifos_idx_0=<int>]\n",
    "dnx_algo_port_db flexe mac logical_fifos dump mac_idx_0=0 logical_fifos_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_mac_logical_fifos_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FLEXE~MAC~LOGICAL_FIFOS~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->flexe.mac[0].logical_fifos));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_mac_logical_fifos_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_mac_logical_fifos_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db flexe mac logical_fifos size_get",
    "dnx_algo_port_db flexe mac logical_fifos size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_mac_logical_fifos_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FLEXE~MAC~LOGICAL_FIFOS~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_mac_logical_fifos_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_mac_logical_fifos_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db flexe mac logical_fifos diagnostic_operation_counters",
    "dnx_algo_port_db flexe mac logical_fifos diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_flexe_mac_timeslot_bitmap_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_flexe_mac_timeslot_bitmap_dump_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_mac_timeslot_bitmap_dump_options, &dnx_swstate_dnx_algo_port_flexe_mac_timeslot_bitmap_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_flexe_mac_timeslot_bitmap_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_mac_timeslot_bitmap_size_get_options, &dnx_swstate_dnx_algo_port_flexe_mac_timeslot_bitmap_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_flexe_mac_timeslot_bitmap_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_mac_timeslot_bitmap_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_flexe_mac_timeslot_bitmap_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_mac_timeslot_bitmap_man = {
    cmd_dnx_swstate_dnx_algo_port_flexe_mac_timeslot_bitmap_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_flexe_mac_timeslot_bitmap_desc[] = "dnx_algo_port_db flexe mac timeslot_bitmap commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_mac_timeslot_bitmap_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  mac_idx_0 = 0;
    int  timeslot_bitmap_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("mac_idx_0", mac_idx_0);
    SH_SAND_GET_INT32("timeslot_bitmap_idx_0", timeslot_bitmap_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_flexe_mac_timeslot_bitmap_dump(unit, mac_idx_0, timeslot_bitmap_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_mac_timeslot_bitmap_dump_options[] = {
    {"mac_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"timeslot_bitmap_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_mac_timeslot_bitmap_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db flexe mac timeslot_bitmap dump [,mac_idx_0=<int>,timeslot_bitmap_idx_0=<int>]\n",
    "dnx_algo_port_db flexe mac timeslot_bitmap dump mac_idx_0=0 timeslot_bitmap_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_mac_timeslot_bitmap_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FLEXE~MAC~TIMESLOT_BITMAP~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->flexe.mac[0].timeslot_bitmap));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_mac_timeslot_bitmap_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_mac_timeslot_bitmap_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db flexe mac timeslot_bitmap size_get",
    "dnx_algo_port_db flexe mac timeslot_bitmap size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_mac_timeslot_bitmap_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FLEXE~MAC~TIMESLOT_BITMAP~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_mac_timeslot_bitmap_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_mac_timeslot_bitmap_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db flexe mac timeslot_bitmap diagnostic_operation_counters",
    "dnx_algo_port_db flexe mac timeslot_bitmap diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_flexe_sar_cmds[] = {
    {"valid", NULL, sh_dnx_swstate_dnx_algo_port_flexe_sar_valid_cmds, NULL, &dnx_swstate_dnx_algo_port_flexe_sar_valid_man},
    {"master_logical_port", NULL, sh_dnx_swstate_dnx_algo_port_flexe_sar_master_logical_port_cmds, NULL, &dnx_swstate_dnx_algo_port_flexe_sar_master_logical_port_man},
    {"client_index", NULL, sh_dnx_swstate_dnx_algo_port_flexe_sar_client_index_cmds, NULL, &dnx_swstate_dnx_algo_port_flexe_sar_client_index_man},
    {"timeslot_bitmap", NULL, sh_dnx_swstate_dnx_algo_port_flexe_sar_timeslot_bitmap_cmds, NULL, &dnx_swstate_dnx_algo_port_flexe_sar_timeslot_bitmap_man},
    {"dump", sh_dnx_swstate_dnx_algo_port_flexe_sar_dump_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_sar_dump_options, &dnx_swstate_dnx_algo_port_flexe_sar_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_flexe_sar_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_sar_size_get_options, &dnx_swstate_dnx_algo_port_flexe_sar_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_flexe_sar_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_sar_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_flexe_sar_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_sar_man = {
    cmd_dnx_swstate_dnx_algo_port_flexe_sar_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_flexe_sar_desc[] = "dnx_algo_port_db flexe sar commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_sar_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  sar_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("sar_idx_0", sar_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_flexe_sar_dump(unit, sar_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_sar_dump_options[] = {
    {"sar_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_sar_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db flexe sar dump [,sar_idx_0=<int>]\n",
    "dnx_algo_port_db flexe sar dump sar_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_sar_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FLEXE~SAR~", 0);
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_sar_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_sar_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db flexe sar size_get",
    "dnx_algo_port_db flexe sar size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_sar_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FLEXE~SAR~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_sar_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_sar_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db flexe sar diagnostic_operation_counters",
    "dnx_algo_port_db flexe sar diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_flexe_sar_valid_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_flexe_sar_valid_dump_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_sar_valid_dump_options, &dnx_swstate_dnx_algo_port_flexe_sar_valid_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_flexe_sar_valid_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_sar_valid_size_get_options, &dnx_swstate_dnx_algo_port_flexe_sar_valid_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_flexe_sar_valid_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_sar_valid_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_flexe_sar_valid_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_sar_valid_man = {
    cmd_dnx_swstate_dnx_algo_port_flexe_sar_valid_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_flexe_sar_valid_desc[] = "dnx_algo_port_db flexe sar valid commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_sar_valid_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  sar_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("sar_idx_0", sar_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_flexe_sar_valid_dump(unit, sar_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_sar_valid_dump_options[] = {
    {"sar_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_sar_valid_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db flexe sar valid dump [,sar_idx_0=<int>]\n",
    "dnx_algo_port_db flexe sar valid dump sar_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_sar_valid_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FLEXE~SAR~VALID~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->flexe.sar[0].valid));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_sar_valid_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_sar_valid_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db flexe sar valid size_get",
    "dnx_algo_port_db flexe sar valid size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_sar_valid_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FLEXE~SAR~VALID~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_sar_valid_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_sar_valid_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db flexe sar valid diagnostic_operation_counters",
    "dnx_algo_port_db flexe sar valid diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_flexe_sar_master_logical_port_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_flexe_sar_master_logical_port_dump_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_sar_master_logical_port_dump_options, &dnx_swstate_dnx_algo_port_flexe_sar_master_logical_port_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_flexe_sar_master_logical_port_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_sar_master_logical_port_size_get_options, &dnx_swstate_dnx_algo_port_flexe_sar_master_logical_port_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_flexe_sar_master_logical_port_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_sar_master_logical_port_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_flexe_sar_master_logical_port_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_sar_master_logical_port_man = {
    cmd_dnx_swstate_dnx_algo_port_flexe_sar_master_logical_port_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_flexe_sar_master_logical_port_desc[] = "dnx_algo_port_db flexe sar master_logical_port commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_sar_master_logical_port_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  sar_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("sar_idx_0", sar_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_flexe_sar_master_logical_port_dump(unit, sar_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_sar_master_logical_port_dump_options[] = {
    {"sar_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_sar_master_logical_port_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db flexe sar master_logical_port dump [,sar_idx_0=<int>]\n",
    "dnx_algo_port_db flexe sar master_logical_port dump sar_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_sar_master_logical_port_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FLEXE~SAR~MASTER_LOGICAL_PORT~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->flexe.sar[0].master_logical_port));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_sar_master_logical_port_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_sar_master_logical_port_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db flexe sar master_logical_port size_get",
    "dnx_algo_port_db flexe sar master_logical_port size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_sar_master_logical_port_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FLEXE~SAR~MASTER_LOGICAL_PORT~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_sar_master_logical_port_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_sar_master_logical_port_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db flexe sar master_logical_port diagnostic_operation_counters",
    "dnx_algo_port_db flexe sar master_logical_port diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_flexe_sar_client_index_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_flexe_sar_client_index_dump_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_sar_client_index_dump_options, &dnx_swstate_dnx_algo_port_flexe_sar_client_index_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_flexe_sar_client_index_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_sar_client_index_size_get_options, &dnx_swstate_dnx_algo_port_flexe_sar_client_index_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_flexe_sar_client_index_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_sar_client_index_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_flexe_sar_client_index_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_sar_client_index_man = {
    cmd_dnx_swstate_dnx_algo_port_flexe_sar_client_index_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_flexe_sar_client_index_desc[] = "dnx_algo_port_db flexe sar client_index commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_sar_client_index_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  sar_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("sar_idx_0", sar_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_flexe_sar_client_index_dump(unit, sar_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_sar_client_index_dump_options[] = {
    {"sar_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_sar_client_index_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db flexe sar client_index dump [,sar_idx_0=<int>]\n",
    "dnx_algo_port_db flexe sar client_index dump sar_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_sar_client_index_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FLEXE~SAR~CLIENT_INDEX~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->flexe.sar[0].client_index));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_sar_client_index_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_sar_client_index_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db flexe sar client_index size_get",
    "dnx_algo_port_db flexe sar client_index size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_sar_client_index_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FLEXE~SAR~CLIENT_INDEX~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_sar_client_index_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_sar_client_index_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db flexe sar client_index diagnostic_operation_counters",
    "dnx_algo_port_db flexe sar client_index diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_flexe_sar_timeslot_bitmap_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_flexe_sar_timeslot_bitmap_dump_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_sar_timeslot_bitmap_dump_options, &dnx_swstate_dnx_algo_port_flexe_sar_timeslot_bitmap_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_flexe_sar_timeslot_bitmap_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_sar_timeslot_bitmap_size_get_options, &dnx_swstate_dnx_algo_port_flexe_sar_timeslot_bitmap_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_flexe_sar_timeslot_bitmap_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_sar_timeslot_bitmap_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_flexe_sar_timeslot_bitmap_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_sar_timeslot_bitmap_man = {
    cmd_dnx_swstate_dnx_algo_port_flexe_sar_timeslot_bitmap_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_flexe_sar_timeslot_bitmap_desc[] = "dnx_algo_port_db flexe sar timeslot_bitmap commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_sar_timeslot_bitmap_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  sar_idx_0 = 0;
    int  timeslot_bitmap_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("sar_idx_0", sar_idx_0);
    SH_SAND_GET_INT32("timeslot_bitmap_idx_0", timeslot_bitmap_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_flexe_sar_timeslot_bitmap_dump(unit, sar_idx_0, timeslot_bitmap_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_sar_timeslot_bitmap_dump_options[] = {
    {"sar_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"timeslot_bitmap_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_sar_timeslot_bitmap_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db flexe sar timeslot_bitmap dump [,sar_idx_0=<int>,timeslot_bitmap_idx_0=<int>]\n",
    "dnx_algo_port_db flexe sar timeslot_bitmap dump sar_idx_0=0 timeslot_bitmap_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_sar_timeslot_bitmap_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FLEXE~SAR~TIMESLOT_BITMAP~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->flexe.sar[0].timeslot_bitmap));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_sar_timeslot_bitmap_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_sar_timeslot_bitmap_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db flexe sar timeslot_bitmap size_get",
    "dnx_algo_port_db flexe sar timeslot_bitmap size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_sar_timeslot_bitmap_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FLEXE~SAR~TIMESLOT_BITMAP~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_sar_timeslot_bitmap_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_sar_timeslot_bitmap_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db flexe sar timeslot_bitmap diagnostic_operation_counters",
    "dnx_algo_port_db flexe sar timeslot_bitmap diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_flexe_phy_cmds[] = {
    {"valid", NULL, sh_dnx_swstate_dnx_algo_port_flexe_phy_valid_cmds, NULL, &dnx_swstate_dnx_algo_port_flexe_phy_valid_man},
    {"master_logical_port", NULL, sh_dnx_swstate_dnx_algo_port_flexe_phy_master_logical_port_cmds, NULL, &dnx_swstate_dnx_algo_port_flexe_phy_master_logical_port_man},
    {"logical_phy_id", NULL, sh_dnx_swstate_dnx_algo_port_flexe_phy_logical_phy_id_cmds, NULL, &dnx_swstate_dnx_algo_port_flexe_phy_logical_phy_id_man},
    {"core_port", NULL, sh_dnx_swstate_dnx_algo_port_flexe_phy_core_port_cmds, NULL, &dnx_swstate_dnx_algo_port_flexe_phy_core_port_man},
    {"instance_base", NULL, sh_dnx_swstate_dnx_algo_port_flexe_phy_instance_base_cmds, NULL, &dnx_swstate_dnx_algo_port_flexe_phy_instance_base_man},
    {"lphy_bitmap", NULL, sh_dnx_swstate_dnx_algo_port_flexe_phy_lphy_bitmap_cmds, NULL, &dnx_swstate_dnx_algo_port_flexe_phy_lphy_bitmap_man},
    {"dump", sh_dnx_swstate_dnx_algo_port_flexe_phy_dump_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_phy_dump_options, &dnx_swstate_dnx_algo_port_flexe_phy_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_flexe_phy_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_phy_size_get_options, &dnx_swstate_dnx_algo_port_flexe_phy_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_flexe_phy_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_phy_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_flexe_phy_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_phy_man = {
    cmd_dnx_swstate_dnx_algo_port_flexe_phy_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_flexe_phy_desc[] = "dnx_algo_port_db flexe phy commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_phy_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  phy_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("phy_idx_0", phy_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_flexe_phy_dump(unit, phy_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_phy_dump_options[] = {
    {"phy_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_phy_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db flexe phy dump [,phy_idx_0=<int>]\n",
    "dnx_algo_port_db flexe phy dump phy_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_phy_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FLEXE~PHY~", 0);
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_phy_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_phy_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db flexe phy size_get",
    "dnx_algo_port_db flexe phy size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_phy_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FLEXE~PHY~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_phy_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_phy_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db flexe phy diagnostic_operation_counters",
    "dnx_algo_port_db flexe phy diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_flexe_phy_valid_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_flexe_phy_valid_dump_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_phy_valid_dump_options, &dnx_swstate_dnx_algo_port_flexe_phy_valid_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_flexe_phy_valid_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_phy_valid_size_get_options, &dnx_swstate_dnx_algo_port_flexe_phy_valid_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_flexe_phy_valid_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_phy_valid_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_flexe_phy_valid_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_phy_valid_man = {
    cmd_dnx_swstate_dnx_algo_port_flexe_phy_valid_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_flexe_phy_valid_desc[] = "dnx_algo_port_db flexe phy valid commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_phy_valid_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  phy_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("phy_idx_0", phy_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_flexe_phy_valid_dump(unit, phy_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_phy_valid_dump_options[] = {
    {"phy_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_phy_valid_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db flexe phy valid dump [,phy_idx_0=<int>]\n",
    "dnx_algo_port_db flexe phy valid dump phy_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_phy_valid_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FLEXE~PHY~VALID~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->flexe.phy[0].valid));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_phy_valid_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_phy_valid_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db flexe phy valid size_get",
    "dnx_algo_port_db flexe phy valid size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_phy_valid_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FLEXE~PHY~VALID~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_phy_valid_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_phy_valid_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db flexe phy valid diagnostic_operation_counters",
    "dnx_algo_port_db flexe phy valid diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_flexe_phy_master_logical_port_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_flexe_phy_master_logical_port_dump_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_phy_master_logical_port_dump_options, &dnx_swstate_dnx_algo_port_flexe_phy_master_logical_port_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_flexe_phy_master_logical_port_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_phy_master_logical_port_size_get_options, &dnx_swstate_dnx_algo_port_flexe_phy_master_logical_port_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_flexe_phy_master_logical_port_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_phy_master_logical_port_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_flexe_phy_master_logical_port_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_phy_master_logical_port_man = {
    cmd_dnx_swstate_dnx_algo_port_flexe_phy_master_logical_port_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_flexe_phy_master_logical_port_desc[] = "dnx_algo_port_db flexe phy master_logical_port commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_phy_master_logical_port_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  phy_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("phy_idx_0", phy_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_flexe_phy_master_logical_port_dump(unit, phy_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_phy_master_logical_port_dump_options[] = {
    {"phy_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_phy_master_logical_port_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db flexe phy master_logical_port dump [,phy_idx_0=<int>]\n",
    "dnx_algo_port_db flexe phy master_logical_port dump phy_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_phy_master_logical_port_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FLEXE~PHY~MASTER_LOGICAL_PORT~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->flexe.phy[0].master_logical_port));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_phy_master_logical_port_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_phy_master_logical_port_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db flexe phy master_logical_port size_get",
    "dnx_algo_port_db flexe phy master_logical_port size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_phy_master_logical_port_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FLEXE~PHY~MASTER_LOGICAL_PORT~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_phy_master_logical_port_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_phy_master_logical_port_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db flexe phy master_logical_port diagnostic_operation_counters",
    "dnx_algo_port_db flexe phy master_logical_port diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_flexe_phy_logical_phy_id_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_flexe_phy_logical_phy_id_dump_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_phy_logical_phy_id_dump_options, &dnx_swstate_dnx_algo_port_flexe_phy_logical_phy_id_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_flexe_phy_logical_phy_id_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_phy_logical_phy_id_size_get_options, &dnx_swstate_dnx_algo_port_flexe_phy_logical_phy_id_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_flexe_phy_logical_phy_id_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_phy_logical_phy_id_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_flexe_phy_logical_phy_id_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_phy_logical_phy_id_man = {
    cmd_dnx_swstate_dnx_algo_port_flexe_phy_logical_phy_id_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_flexe_phy_logical_phy_id_desc[] = "dnx_algo_port_db flexe phy logical_phy_id commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_phy_logical_phy_id_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  phy_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("phy_idx_0", phy_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_flexe_phy_logical_phy_id_dump(unit, phy_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_phy_logical_phy_id_dump_options[] = {
    {"phy_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_phy_logical_phy_id_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db flexe phy logical_phy_id dump [,phy_idx_0=<int>]\n",
    "dnx_algo_port_db flexe phy logical_phy_id dump phy_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_phy_logical_phy_id_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FLEXE~PHY~LOGICAL_PHY_ID~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->flexe.phy[0].logical_phy_id));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_phy_logical_phy_id_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_phy_logical_phy_id_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db flexe phy logical_phy_id size_get",
    "dnx_algo_port_db flexe phy logical_phy_id size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_phy_logical_phy_id_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FLEXE~PHY~LOGICAL_PHY_ID~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_phy_logical_phy_id_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_phy_logical_phy_id_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db flexe phy logical_phy_id diagnostic_operation_counters",
    "dnx_algo_port_db flexe phy logical_phy_id diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_flexe_phy_core_port_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_flexe_phy_core_port_dump_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_phy_core_port_dump_options, &dnx_swstate_dnx_algo_port_flexe_phy_core_port_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_flexe_phy_core_port_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_phy_core_port_size_get_options, &dnx_swstate_dnx_algo_port_flexe_phy_core_port_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_flexe_phy_core_port_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_phy_core_port_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_flexe_phy_core_port_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_phy_core_port_man = {
    cmd_dnx_swstate_dnx_algo_port_flexe_phy_core_port_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_flexe_phy_core_port_desc[] = "dnx_algo_port_db flexe phy core_port commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_phy_core_port_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  phy_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("phy_idx_0", phy_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_flexe_phy_core_port_dump(unit, phy_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_phy_core_port_dump_options[] = {
    {"phy_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_phy_core_port_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db flexe phy core_port dump [,phy_idx_0=<int>]\n",
    "dnx_algo_port_db flexe phy core_port dump phy_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_phy_core_port_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FLEXE~PHY~CORE_PORT~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->flexe.phy[0].core_port));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_phy_core_port_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_phy_core_port_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db flexe phy core_port size_get",
    "dnx_algo_port_db flexe phy core_port size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_phy_core_port_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FLEXE~PHY~CORE_PORT~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_phy_core_port_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_phy_core_port_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db flexe phy core_port diagnostic_operation_counters",
    "dnx_algo_port_db flexe phy core_port diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_flexe_phy_instance_base_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_flexe_phy_instance_base_dump_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_phy_instance_base_dump_options, &dnx_swstate_dnx_algo_port_flexe_phy_instance_base_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_flexe_phy_instance_base_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_phy_instance_base_size_get_options, &dnx_swstate_dnx_algo_port_flexe_phy_instance_base_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_flexe_phy_instance_base_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_phy_instance_base_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_flexe_phy_instance_base_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_phy_instance_base_man = {
    cmd_dnx_swstate_dnx_algo_port_flexe_phy_instance_base_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_flexe_phy_instance_base_desc[] = "dnx_algo_port_db flexe phy instance_base commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_phy_instance_base_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  phy_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("phy_idx_0", phy_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_flexe_phy_instance_base_dump(unit, phy_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_phy_instance_base_dump_options[] = {
    {"phy_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_phy_instance_base_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db flexe phy instance_base dump [,phy_idx_0=<int>]\n",
    "dnx_algo_port_db flexe phy instance_base dump phy_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_phy_instance_base_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FLEXE~PHY~INSTANCE_BASE~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->flexe.phy[0].instance_base));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_phy_instance_base_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_phy_instance_base_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db flexe phy instance_base size_get",
    "dnx_algo_port_db flexe phy instance_base size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_phy_instance_base_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FLEXE~PHY~INSTANCE_BASE~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_phy_instance_base_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_phy_instance_base_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db flexe phy instance_base diagnostic_operation_counters",
    "dnx_algo_port_db flexe phy instance_base diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_flexe_phy_lphy_bitmap_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_flexe_phy_lphy_bitmap_dump_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_phy_lphy_bitmap_dump_options, &dnx_swstate_dnx_algo_port_flexe_phy_lphy_bitmap_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_flexe_phy_lphy_bitmap_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_phy_lphy_bitmap_size_get_options, &dnx_swstate_dnx_algo_port_flexe_phy_lphy_bitmap_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_flexe_phy_lphy_bitmap_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_flexe_phy_lphy_bitmap_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_flexe_phy_lphy_bitmap_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_phy_lphy_bitmap_man = {
    cmd_dnx_swstate_dnx_algo_port_flexe_phy_lphy_bitmap_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_flexe_phy_lphy_bitmap_desc[] = "dnx_algo_port_db flexe phy lphy_bitmap commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_phy_lphy_bitmap_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  phy_idx_0 = 0;
    int  lphy_bitmap_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("phy_idx_0", phy_idx_0);
    SH_SAND_GET_INT32("lphy_bitmap_idx_0", lphy_bitmap_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_flexe_phy_lphy_bitmap_dump(unit, phy_idx_0, lphy_bitmap_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_phy_lphy_bitmap_dump_options[] = {
    {"phy_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"lphy_bitmap_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_phy_lphy_bitmap_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db flexe phy lphy_bitmap dump [,phy_idx_0=<int>,lphy_bitmap_idx_0=<int>]\n",
    "dnx_algo_port_db flexe phy lphy_bitmap dump phy_idx_0=0 lphy_bitmap_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_phy_lphy_bitmap_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FLEXE~PHY~LPHY_BITMAP~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->flexe.phy[0].lphy_bitmap));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_phy_lphy_bitmap_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_phy_lphy_bitmap_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db flexe phy lphy_bitmap size_get",
    "dnx_algo_port_db flexe phy lphy_bitmap size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_flexe_phy_lphy_bitmap_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FLEXE~PHY~LPHY_BITMAP~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_flexe_phy_lphy_bitmap_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_flexe_phy_lphy_bitmap_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db flexe phy lphy_bitmap diagnostic_operation_counters",
    "dnx_algo_port_db flexe phy lphy_bitmap diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_fabric_cmds[] = {
    {"valid", NULL, sh_dnx_swstate_dnx_algo_port_fabric_valid_cmds, NULL, &dnx_swstate_dnx_algo_port_fabric_valid_man},
    {"link", NULL, sh_dnx_swstate_dnx_algo_port_fabric_link_cmds, NULL, &dnx_swstate_dnx_algo_port_fabric_link_man},
    {"master_logical_port", NULL, sh_dnx_swstate_dnx_algo_port_fabric_master_logical_port_cmds, NULL, &dnx_swstate_dnx_algo_port_fabric_master_logical_port_man},
    {"prbs_mode", NULL, sh_dnx_swstate_dnx_algo_port_fabric_prbs_mode_cmds, NULL, &dnx_swstate_dnx_algo_port_fabric_prbs_mode_man},
    {"speed", NULL, sh_dnx_swstate_dnx_algo_port_fabric_speed_cmds, NULL, &dnx_swstate_dnx_algo_port_fabric_speed_man},
    {"loopback_original_link_training", NULL, sh_dnx_swstate_dnx_algo_port_fabric_loopback_original_link_training_cmds, NULL, &dnx_swstate_dnx_algo_port_fabric_loopback_original_link_training_man},
    {"loopback_original_phy_lane_config", NULL, sh_dnx_swstate_dnx_algo_port_fabric_loopback_original_phy_lane_config_cmds, NULL, &dnx_swstate_dnx_algo_port_fabric_loopback_original_phy_lane_config_man},
    {"dump", sh_dnx_swstate_dnx_algo_port_fabric_dump_cmd, NULL, dnx_swstate_dnx_algo_port_fabric_dump_options, &dnx_swstate_dnx_algo_port_fabric_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_fabric_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_fabric_size_get_options, &dnx_swstate_dnx_algo_port_fabric_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_fabric_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_fabric_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_fabric_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_fabric_man = {
    cmd_dnx_swstate_dnx_algo_port_fabric_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_fabric_desc[] = "dnx_algo_port_db fabric commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_fabric_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  fabric_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("fabric_idx_0", fabric_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_fabric_dump(unit, fabric_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_fabric_dump_options[] = {
    {"fabric_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_fabric_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db fabric dump [,fabric_idx_0=<int>]\n",
    "dnx_algo_port_db fabric dump fabric_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_fabric_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FABRIC~", 0);
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_fabric_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_fabric_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db fabric size_get",
    "dnx_algo_port_db fabric size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_fabric_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FABRIC~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_fabric_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_fabric_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db fabric diagnostic_operation_counters",
    "dnx_algo_port_db fabric diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_fabric_valid_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_fabric_valid_dump_cmd, NULL, dnx_swstate_dnx_algo_port_fabric_valid_dump_options, &dnx_swstate_dnx_algo_port_fabric_valid_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_fabric_valid_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_fabric_valid_size_get_options, &dnx_swstate_dnx_algo_port_fabric_valid_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_fabric_valid_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_fabric_valid_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_fabric_valid_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_fabric_valid_man = {
    cmd_dnx_swstate_dnx_algo_port_fabric_valid_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_fabric_valid_desc[] = "dnx_algo_port_db fabric valid commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_fabric_valid_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  fabric_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("fabric_idx_0", fabric_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_fabric_valid_dump(unit, fabric_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_fabric_valid_dump_options[] = {
    {"fabric_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_fabric_valid_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db fabric valid dump [,fabric_idx_0=<int>]\n",
    "dnx_algo_port_db fabric valid dump fabric_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_fabric_valid_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FABRIC~VALID~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->fabric[0].valid));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_fabric_valid_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_fabric_valid_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db fabric valid size_get",
    "dnx_algo_port_db fabric valid size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_fabric_valid_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FABRIC~VALID~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_fabric_valid_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_fabric_valid_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db fabric valid diagnostic_operation_counters",
    "dnx_algo_port_db fabric valid diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_fabric_link_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_fabric_link_dump_cmd, NULL, dnx_swstate_dnx_algo_port_fabric_link_dump_options, &dnx_swstate_dnx_algo_port_fabric_link_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_fabric_link_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_fabric_link_size_get_options, &dnx_swstate_dnx_algo_port_fabric_link_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_fabric_link_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_fabric_link_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_fabric_link_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_fabric_link_man = {
    cmd_dnx_swstate_dnx_algo_port_fabric_link_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_fabric_link_desc[] = "dnx_algo_port_db fabric link commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_fabric_link_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  fabric_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("fabric_idx_0", fabric_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_fabric_link_dump(unit, fabric_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_fabric_link_dump_options[] = {
    {"fabric_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_fabric_link_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db fabric link dump [,fabric_idx_0=<int>]\n",
    "dnx_algo_port_db fabric link dump fabric_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_fabric_link_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FABRIC~LINK~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->fabric[0].link));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_fabric_link_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_fabric_link_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db fabric link size_get",
    "dnx_algo_port_db fabric link size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_fabric_link_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FABRIC~LINK~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_fabric_link_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_fabric_link_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db fabric link diagnostic_operation_counters",
    "dnx_algo_port_db fabric link diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_fabric_master_logical_port_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_fabric_master_logical_port_dump_cmd, NULL, dnx_swstate_dnx_algo_port_fabric_master_logical_port_dump_options, &dnx_swstate_dnx_algo_port_fabric_master_logical_port_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_fabric_master_logical_port_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_fabric_master_logical_port_size_get_options, &dnx_swstate_dnx_algo_port_fabric_master_logical_port_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_fabric_master_logical_port_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_fabric_master_logical_port_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_fabric_master_logical_port_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_fabric_master_logical_port_man = {
    cmd_dnx_swstate_dnx_algo_port_fabric_master_logical_port_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_fabric_master_logical_port_desc[] = "dnx_algo_port_db fabric master_logical_port commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_fabric_master_logical_port_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  fabric_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("fabric_idx_0", fabric_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_fabric_master_logical_port_dump(unit, fabric_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_fabric_master_logical_port_dump_options[] = {
    {"fabric_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_fabric_master_logical_port_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db fabric master_logical_port dump [,fabric_idx_0=<int>]\n",
    "dnx_algo_port_db fabric master_logical_port dump fabric_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_fabric_master_logical_port_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FABRIC~MASTER_LOGICAL_PORT~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->fabric[0].master_logical_port));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_fabric_master_logical_port_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_fabric_master_logical_port_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db fabric master_logical_port size_get",
    "dnx_algo_port_db fabric master_logical_port size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_fabric_master_logical_port_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FABRIC~MASTER_LOGICAL_PORT~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_fabric_master_logical_port_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_fabric_master_logical_port_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db fabric master_logical_port diagnostic_operation_counters",
    "dnx_algo_port_db fabric master_logical_port diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_fabric_prbs_mode_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_fabric_prbs_mode_dump_cmd, NULL, dnx_swstate_dnx_algo_port_fabric_prbs_mode_dump_options, &dnx_swstate_dnx_algo_port_fabric_prbs_mode_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_fabric_prbs_mode_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_fabric_prbs_mode_size_get_options, &dnx_swstate_dnx_algo_port_fabric_prbs_mode_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_fabric_prbs_mode_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_fabric_prbs_mode_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_fabric_prbs_mode_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_fabric_prbs_mode_man = {
    cmd_dnx_swstate_dnx_algo_port_fabric_prbs_mode_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_fabric_prbs_mode_desc[] = "dnx_algo_port_db fabric prbs_mode commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_fabric_prbs_mode_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  fabric_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("fabric_idx_0", fabric_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_fabric_prbs_mode_dump(unit, fabric_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_fabric_prbs_mode_dump_options[] = {
    {"fabric_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_fabric_prbs_mode_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db fabric prbs_mode dump [,fabric_idx_0=<int>]\n",
    "dnx_algo_port_db fabric prbs_mode dump fabric_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_fabric_prbs_mode_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FABRIC~PRBS_MODE~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->fabric[0].prbs_mode));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_fabric_prbs_mode_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_fabric_prbs_mode_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db fabric prbs_mode size_get",
    "dnx_algo_port_db fabric prbs_mode size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_fabric_prbs_mode_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FABRIC~PRBS_MODE~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_fabric_prbs_mode_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_fabric_prbs_mode_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db fabric prbs_mode diagnostic_operation_counters",
    "dnx_algo_port_db fabric prbs_mode diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_fabric_speed_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_fabric_speed_dump_cmd, NULL, dnx_swstate_dnx_algo_port_fabric_speed_dump_options, &dnx_swstate_dnx_algo_port_fabric_speed_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_fabric_speed_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_fabric_speed_size_get_options, &dnx_swstate_dnx_algo_port_fabric_speed_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_fabric_speed_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_fabric_speed_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_fabric_speed_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_fabric_speed_man = {
    cmd_dnx_swstate_dnx_algo_port_fabric_speed_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_fabric_speed_desc[] = "dnx_algo_port_db fabric speed commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_fabric_speed_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  fabric_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("fabric_idx_0", fabric_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_fabric_speed_dump(unit, fabric_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_fabric_speed_dump_options[] = {
    {"fabric_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_fabric_speed_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db fabric speed dump [,fabric_idx_0=<int>]\n",
    "dnx_algo_port_db fabric speed dump fabric_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_fabric_speed_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FABRIC~SPEED~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->fabric[0].speed));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_fabric_speed_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_fabric_speed_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db fabric speed size_get",
    "dnx_algo_port_db fabric speed size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_fabric_speed_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FABRIC~SPEED~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_fabric_speed_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_fabric_speed_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db fabric speed diagnostic_operation_counters",
    "dnx_algo_port_db fabric speed diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_fabric_loopback_original_link_training_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_fabric_loopback_original_link_training_dump_cmd, NULL, dnx_swstate_dnx_algo_port_fabric_loopback_original_link_training_dump_options, &dnx_swstate_dnx_algo_port_fabric_loopback_original_link_training_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_fabric_loopback_original_link_training_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_fabric_loopback_original_link_training_size_get_options, &dnx_swstate_dnx_algo_port_fabric_loopback_original_link_training_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_fabric_loopback_original_link_training_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_fabric_loopback_original_link_training_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_fabric_loopback_original_link_training_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_fabric_loopback_original_link_training_man = {
    cmd_dnx_swstate_dnx_algo_port_fabric_loopback_original_link_training_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_fabric_loopback_original_link_training_desc[] = "dnx_algo_port_db fabric loopback_original_link_training commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_fabric_loopback_original_link_training_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  fabric_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("fabric_idx_0", fabric_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_fabric_loopback_original_link_training_dump(unit, fabric_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_fabric_loopback_original_link_training_dump_options[] = {
    {"fabric_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_fabric_loopback_original_link_training_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db fabric loopback_original_link_training dump [,fabric_idx_0=<int>]\n",
    "dnx_algo_port_db fabric loopback_original_link_training dump fabric_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_fabric_loopback_original_link_training_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FABRIC~LOOPBACK_ORIGINAL_LINK_TRAINING~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->fabric[0].loopback_original_link_training));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_fabric_loopback_original_link_training_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_fabric_loopback_original_link_training_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db fabric loopback_original_link_training size_get",
    "dnx_algo_port_db fabric loopback_original_link_training size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_fabric_loopback_original_link_training_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FABRIC~LOOPBACK_ORIGINAL_LINK_TRAINING~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_fabric_loopback_original_link_training_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_fabric_loopback_original_link_training_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db fabric loopback_original_link_training diagnostic_operation_counters",
    "dnx_algo_port_db fabric loopback_original_link_training diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_fabric_loopback_original_phy_lane_config_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_fabric_loopback_original_phy_lane_config_dump_cmd, NULL, dnx_swstate_dnx_algo_port_fabric_loopback_original_phy_lane_config_dump_options, &dnx_swstate_dnx_algo_port_fabric_loopback_original_phy_lane_config_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_fabric_loopback_original_phy_lane_config_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_fabric_loopback_original_phy_lane_config_size_get_options, &dnx_swstate_dnx_algo_port_fabric_loopback_original_phy_lane_config_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_fabric_loopback_original_phy_lane_config_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_fabric_loopback_original_phy_lane_config_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_fabric_loopback_original_phy_lane_config_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_fabric_loopback_original_phy_lane_config_man = {
    cmd_dnx_swstate_dnx_algo_port_fabric_loopback_original_phy_lane_config_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_fabric_loopback_original_phy_lane_config_desc[] = "dnx_algo_port_db fabric loopback_original_phy_lane_config commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_fabric_loopback_original_phy_lane_config_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  fabric_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("fabric_idx_0", fabric_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_fabric_loopback_original_phy_lane_config_dump(unit, fabric_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_fabric_loopback_original_phy_lane_config_dump_options[] = {
    {"fabric_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_fabric_loopback_original_phy_lane_config_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db fabric loopback_original_phy_lane_config dump [,fabric_idx_0=<int>]\n",
    "dnx_algo_port_db fabric loopback_original_phy_lane_config dump fabric_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_fabric_loopback_original_phy_lane_config_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FABRIC~LOOPBACK_ORIGINAL_PHY_LANE_CONFIG~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->fabric[0].loopback_original_phy_lane_config));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_fabric_loopback_original_phy_lane_config_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_fabric_loopback_original_phy_lane_config_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db fabric loopback_original_phy_lane_config size_get",
    "dnx_algo_port_db fabric loopback_original_phy_lane_config size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_fabric_loopback_original_phy_lane_config_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~FABRIC~LOOPBACK_ORIGINAL_PHY_LANE_CONFIG~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_fabric_loopback_original_phy_lane_config_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_fabric_loopback_original_phy_lane_config_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db fabric loopback_original_phy_lane_config diagnostic_operation_counters",
    "dnx_algo_port_db fabric loopback_original_phy_lane_config diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_tm_interface_cmds[] = {
    {"valid", NULL, sh_dnx_swstate_dnx_algo_port_tm_interface_valid_cmds, NULL, &dnx_swstate_dnx_algo_port_tm_interface_valid_man},
    {"is_channelized", NULL, sh_dnx_swstate_dnx_algo_port_tm_interface_is_channelized_cmds, NULL, &dnx_swstate_dnx_algo_port_tm_interface_is_channelized_man},
    {"is_ingress_interleave", NULL, sh_dnx_swstate_dnx_algo_port_tm_interface_is_ingress_interleave_cmds, NULL, &dnx_swstate_dnx_algo_port_tm_interface_is_ingress_interleave_man},
    {"is_egress_interleave", NULL, sh_dnx_swstate_dnx_algo_port_tm_interface_is_egress_interleave_cmds, NULL, &dnx_swstate_dnx_algo_port_tm_interface_is_egress_interleave_man},
    {"egr_if", NULL, sh_dnx_swstate_dnx_algo_port_tm_interface_egr_if_cmds, NULL, &dnx_swstate_dnx_algo_port_tm_interface_egr_if_man},
    {"tdm_mode", NULL, sh_dnx_swstate_dnx_algo_port_tm_interface_tdm_mode_cmds, NULL, &dnx_swstate_dnx_algo_port_tm_interface_tdm_mode_man},
    {"master_tdm_logical_port", NULL, sh_dnx_swstate_dnx_algo_port_tm_interface_master_tdm_logical_port_cmds, NULL, &dnx_swstate_dnx_algo_port_tm_interface_master_tdm_logical_port_man},
    {"master_non_tdm_logical_port", NULL, sh_dnx_swstate_dnx_algo_port_tm_interface_master_non_tdm_logical_port_cmds, NULL, &dnx_swstate_dnx_algo_port_tm_interface_master_non_tdm_logical_port_man},
    {"master_logical_port", NULL, sh_dnx_swstate_dnx_algo_port_tm_interface_master_logical_port_cmds, NULL, &dnx_swstate_dnx_algo_port_tm_interface_master_logical_port_man},
    {"dump", sh_dnx_swstate_dnx_algo_port_tm_interface_dump_cmd, NULL, dnx_swstate_dnx_algo_port_tm_interface_dump_options, &dnx_swstate_dnx_algo_port_tm_interface_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_tm_interface_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_tm_interface_size_get_options, &dnx_swstate_dnx_algo_port_tm_interface_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_tm_interface_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_tm_interface_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_tm_interface_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_interface_man = {
    cmd_dnx_swstate_dnx_algo_port_tm_interface_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_tm_interface_desc[] = "dnx_algo_port_db tm_interface commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_interface_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  tm_interface_idx_0 = 0;
    int  tm_interface_idx_1 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("tm_interface_idx_0", tm_interface_idx_0);
    SH_SAND_GET_INT32("tm_interface_idx_1", tm_interface_idx_1);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_tm_interface_dump(unit, tm_interface_idx_0, tm_interface_idx_1, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_interface_dump_options[] = {
    {"tm_interface_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"tm_interface_idx_1", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_interface_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db tm_interface dump [,tm_interface_idx_0=<int>,tm_interface_idx_1=<int>]\n",
    "dnx_algo_port_db tm_interface dump tm_interface_idx_0=0 tm_interface_idx_1=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_interface_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~TM_INTERFACE~", 0);
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_interface_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_interface_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db tm_interface size_get",
    "dnx_algo_port_db tm_interface size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_interface_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~TM_INTERFACE~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_interface_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_interface_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db tm_interface diagnostic_operation_counters",
    "dnx_algo_port_db tm_interface diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_tm_interface_valid_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_tm_interface_valid_dump_cmd, NULL, dnx_swstate_dnx_algo_port_tm_interface_valid_dump_options, &dnx_swstate_dnx_algo_port_tm_interface_valid_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_tm_interface_valid_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_tm_interface_valid_size_get_options, &dnx_swstate_dnx_algo_port_tm_interface_valid_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_tm_interface_valid_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_tm_interface_valid_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_tm_interface_valid_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_interface_valid_man = {
    cmd_dnx_swstate_dnx_algo_port_tm_interface_valid_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_tm_interface_valid_desc[] = "dnx_algo_port_db tm_interface valid commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_interface_valid_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  tm_interface_idx_0 = 0;
    int  tm_interface_idx_1 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("tm_interface_idx_0", tm_interface_idx_0);
    SH_SAND_GET_INT32("tm_interface_idx_1", tm_interface_idx_1);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_tm_interface_valid_dump(unit, tm_interface_idx_0, tm_interface_idx_1, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_interface_valid_dump_options[] = {
    {"tm_interface_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"tm_interface_idx_1", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_interface_valid_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db tm_interface valid dump [,tm_interface_idx_0=<int>,tm_interface_idx_1=<int>]\n",
    "dnx_algo_port_db tm_interface valid dump tm_interface_idx_0=0 tm_interface_idx_1=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_interface_valid_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~TM_INTERFACE~VALID~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->tm_interface[0][0].valid));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_interface_valid_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_interface_valid_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db tm_interface valid size_get",
    "dnx_algo_port_db tm_interface valid size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_interface_valid_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~TM_INTERFACE~VALID~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_interface_valid_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_interface_valid_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db tm_interface valid diagnostic_operation_counters",
    "dnx_algo_port_db tm_interface valid diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_tm_interface_is_channelized_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_tm_interface_is_channelized_dump_cmd, NULL, dnx_swstate_dnx_algo_port_tm_interface_is_channelized_dump_options, &dnx_swstate_dnx_algo_port_tm_interface_is_channelized_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_tm_interface_is_channelized_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_tm_interface_is_channelized_size_get_options, &dnx_swstate_dnx_algo_port_tm_interface_is_channelized_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_tm_interface_is_channelized_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_tm_interface_is_channelized_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_tm_interface_is_channelized_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_interface_is_channelized_man = {
    cmd_dnx_swstate_dnx_algo_port_tm_interface_is_channelized_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_tm_interface_is_channelized_desc[] = "dnx_algo_port_db tm_interface is_channelized commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_interface_is_channelized_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  tm_interface_idx_0 = 0;
    int  tm_interface_idx_1 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("tm_interface_idx_0", tm_interface_idx_0);
    SH_SAND_GET_INT32("tm_interface_idx_1", tm_interface_idx_1);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_tm_interface_is_channelized_dump(unit, tm_interface_idx_0, tm_interface_idx_1, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_interface_is_channelized_dump_options[] = {
    {"tm_interface_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"tm_interface_idx_1", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_interface_is_channelized_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db tm_interface is_channelized dump [,tm_interface_idx_0=<int>,tm_interface_idx_1=<int>]\n",
    "dnx_algo_port_db tm_interface is_channelized dump tm_interface_idx_0=0 tm_interface_idx_1=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_interface_is_channelized_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~TM_INTERFACE~IS_CHANNELIZED~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->tm_interface[0][0].is_channelized));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_interface_is_channelized_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_interface_is_channelized_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db tm_interface is_channelized size_get",
    "dnx_algo_port_db tm_interface is_channelized size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_interface_is_channelized_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~TM_INTERFACE~IS_CHANNELIZED~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_interface_is_channelized_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_interface_is_channelized_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db tm_interface is_channelized diagnostic_operation_counters",
    "dnx_algo_port_db tm_interface is_channelized diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_tm_interface_is_ingress_interleave_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_tm_interface_is_ingress_interleave_dump_cmd, NULL, dnx_swstate_dnx_algo_port_tm_interface_is_ingress_interleave_dump_options, &dnx_swstate_dnx_algo_port_tm_interface_is_ingress_interleave_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_tm_interface_is_ingress_interleave_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_tm_interface_is_ingress_interleave_size_get_options, &dnx_swstate_dnx_algo_port_tm_interface_is_ingress_interleave_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_tm_interface_is_ingress_interleave_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_tm_interface_is_ingress_interleave_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_tm_interface_is_ingress_interleave_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_interface_is_ingress_interleave_man = {
    cmd_dnx_swstate_dnx_algo_port_tm_interface_is_ingress_interleave_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_tm_interface_is_ingress_interleave_desc[] = "dnx_algo_port_db tm_interface is_ingress_interleave commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_interface_is_ingress_interleave_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  tm_interface_idx_0 = 0;
    int  tm_interface_idx_1 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("tm_interface_idx_0", tm_interface_idx_0);
    SH_SAND_GET_INT32("tm_interface_idx_1", tm_interface_idx_1);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_tm_interface_is_ingress_interleave_dump(unit, tm_interface_idx_0, tm_interface_idx_1, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_interface_is_ingress_interleave_dump_options[] = {
    {"tm_interface_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"tm_interface_idx_1", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_interface_is_ingress_interleave_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db tm_interface is_ingress_interleave dump [,tm_interface_idx_0=<int>,tm_interface_idx_1=<int>]\n",
    "dnx_algo_port_db tm_interface is_ingress_interleave dump tm_interface_idx_0=0 tm_interface_idx_1=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_interface_is_ingress_interleave_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~TM_INTERFACE~IS_INGRESS_INTERLEAVE~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->tm_interface[0][0].is_ingress_interleave));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_interface_is_ingress_interleave_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_interface_is_ingress_interleave_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db tm_interface is_ingress_interleave size_get",
    "dnx_algo_port_db tm_interface is_ingress_interleave size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_interface_is_ingress_interleave_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~TM_INTERFACE~IS_INGRESS_INTERLEAVE~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_interface_is_ingress_interleave_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_interface_is_ingress_interleave_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db tm_interface is_ingress_interleave diagnostic_operation_counters",
    "dnx_algo_port_db tm_interface is_ingress_interleave diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_tm_interface_is_egress_interleave_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_tm_interface_is_egress_interleave_dump_cmd, NULL, dnx_swstate_dnx_algo_port_tm_interface_is_egress_interleave_dump_options, &dnx_swstate_dnx_algo_port_tm_interface_is_egress_interleave_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_tm_interface_is_egress_interleave_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_tm_interface_is_egress_interleave_size_get_options, &dnx_swstate_dnx_algo_port_tm_interface_is_egress_interleave_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_tm_interface_is_egress_interleave_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_tm_interface_is_egress_interleave_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_tm_interface_is_egress_interleave_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_interface_is_egress_interleave_man = {
    cmd_dnx_swstate_dnx_algo_port_tm_interface_is_egress_interleave_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_tm_interface_is_egress_interleave_desc[] = "dnx_algo_port_db tm_interface is_egress_interleave commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_interface_is_egress_interleave_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  tm_interface_idx_0 = 0;
    int  tm_interface_idx_1 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("tm_interface_idx_0", tm_interface_idx_0);
    SH_SAND_GET_INT32("tm_interface_idx_1", tm_interface_idx_1);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_tm_interface_is_egress_interleave_dump(unit, tm_interface_idx_0, tm_interface_idx_1, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_interface_is_egress_interleave_dump_options[] = {
    {"tm_interface_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"tm_interface_idx_1", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_interface_is_egress_interleave_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db tm_interface is_egress_interleave dump [,tm_interface_idx_0=<int>,tm_interface_idx_1=<int>]\n",
    "dnx_algo_port_db tm_interface is_egress_interleave dump tm_interface_idx_0=0 tm_interface_idx_1=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_interface_is_egress_interleave_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~TM_INTERFACE~IS_EGRESS_INTERLEAVE~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->tm_interface[0][0].is_egress_interleave));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_interface_is_egress_interleave_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_interface_is_egress_interleave_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db tm_interface is_egress_interleave size_get",
    "dnx_algo_port_db tm_interface is_egress_interleave size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_interface_is_egress_interleave_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~TM_INTERFACE~IS_EGRESS_INTERLEAVE~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_interface_is_egress_interleave_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_interface_is_egress_interleave_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db tm_interface is_egress_interleave diagnostic_operation_counters",
    "dnx_algo_port_db tm_interface is_egress_interleave diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_tm_interface_egr_if_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_tm_interface_egr_if_dump_cmd, NULL, dnx_swstate_dnx_algo_port_tm_interface_egr_if_dump_options, &dnx_swstate_dnx_algo_port_tm_interface_egr_if_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_tm_interface_egr_if_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_tm_interface_egr_if_size_get_options, &dnx_swstate_dnx_algo_port_tm_interface_egr_if_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_tm_interface_egr_if_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_tm_interface_egr_if_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_tm_interface_egr_if_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_interface_egr_if_man = {
    cmd_dnx_swstate_dnx_algo_port_tm_interface_egr_if_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_tm_interface_egr_if_desc[] = "dnx_algo_port_db tm_interface egr_if commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_interface_egr_if_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  tm_interface_idx_0 = 0;
    int  tm_interface_idx_1 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("tm_interface_idx_0", tm_interface_idx_0);
    SH_SAND_GET_INT32("tm_interface_idx_1", tm_interface_idx_1);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_tm_interface_egr_if_dump(unit, tm_interface_idx_0, tm_interface_idx_1, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_interface_egr_if_dump_options[] = {
    {"tm_interface_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"tm_interface_idx_1", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_interface_egr_if_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db tm_interface egr_if dump [,tm_interface_idx_0=<int>,tm_interface_idx_1=<int>]\n",
    "dnx_algo_port_db tm_interface egr_if dump tm_interface_idx_0=0 tm_interface_idx_1=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_interface_egr_if_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~TM_INTERFACE~EGR_IF~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->tm_interface[0][0].egr_if));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_interface_egr_if_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_interface_egr_if_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db tm_interface egr_if size_get",
    "dnx_algo_port_db tm_interface egr_if size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_interface_egr_if_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~TM_INTERFACE~EGR_IF~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_interface_egr_if_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_interface_egr_if_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db tm_interface egr_if diagnostic_operation_counters",
    "dnx_algo_port_db tm_interface egr_if diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_tm_interface_tdm_mode_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_tm_interface_tdm_mode_dump_cmd, NULL, dnx_swstate_dnx_algo_port_tm_interface_tdm_mode_dump_options, &dnx_swstate_dnx_algo_port_tm_interface_tdm_mode_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_tm_interface_tdm_mode_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_tm_interface_tdm_mode_size_get_options, &dnx_swstate_dnx_algo_port_tm_interface_tdm_mode_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_tm_interface_tdm_mode_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_tm_interface_tdm_mode_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_tm_interface_tdm_mode_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_interface_tdm_mode_man = {
    cmd_dnx_swstate_dnx_algo_port_tm_interface_tdm_mode_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_tm_interface_tdm_mode_desc[] = "dnx_algo_port_db tm_interface tdm_mode commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_interface_tdm_mode_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  tm_interface_idx_0 = 0;
    int  tm_interface_idx_1 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("tm_interface_idx_0", tm_interface_idx_0);
    SH_SAND_GET_INT32("tm_interface_idx_1", tm_interface_idx_1);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_tm_interface_tdm_mode_dump(unit, tm_interface_idx_0, tm_interface_idx_1, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_interface_tdm_mode_dump_options[] = {
    {"tm_interface_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"tm_interface_idx_1", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_interface_tdm_mode_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db tm_interface tdm_mode dump [,tm_interface_idx_0=<int>,tm_interface_idx_1=<int>]\n",
    "dnx_algo_port_db tm_interface tdm_mode dump tm_interface_idx_0=0 tm_interface_idx_1=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_interface_tdm_mode_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~TM_INTERFACE~TDM_MODE~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->tm_interface[0][0].tdm_mode));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_interface_tdm_mode_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_interface_tdm_mode_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db tm_interface tdm_mode size_get",
    "dnx_algo_port_db tm_interface tdm_mode size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_interface_tdm_mode_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~TM_INTERFACE~TDM_MODE~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_interface_tdm_mode_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_interface_tdm_mode_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db tm_interface tdm_mode diagnostic_operation_counters",
    "dnx_algo_port_db tm_interface tdm_mode diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_tm_interface_master_tdm_logical_port_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_tm_interface_master_tdm_logical_port_dump_cmd, NULL, dnx_swstate_dnx_algo_port_tm_interface_master_tdm_logical_port_dump_options, &dnx_swstate_dnx_algo_port_tm_interface_master_tdm_logical_port_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_tm_interface_master_tdm_logical_port_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_tm_interface_master_tdm_logical_port_size_get_options, &dnx_swstate_dnx_algo_port_tm_interface_master_tdm_logical_port_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_tm_interface_master_tdm_logical_port_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_tm_interface_master_tdm_logical_port_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_tm_interface_master_tdm_logical_port_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_interface_master_tdm_logical_port_man = {
    cmd_dnx_swstate_dnx_algo_port_tm_interface_master_tdm_logical_port_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_tm_interface_master_tdm_logical_port_desc[] = "dnx_algo_port_db tm_interface master_tdm_logical_port commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_interface_master_tdm_logical_port_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  tm_interface_idx_0 = 0;
    int  tm_interface_idx_1 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("tm_interface_idx_0", tm_interface_idx_0);
    SH_SAND_GET_INT32("tm_interface_idx_1", tm_interface_idx_1);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_tm_interface_master_tdm_logical_port_dump(unit, tm_interface_idx_0, tm_interface_idx_1, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_interface_master_tdm_logical_port_dump_options[] = {
    {"tm_interface_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"tm_interface_idx_1", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_interface_master_tdm_logical_port_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db tm_interface master_tdm_logical_port dump [,tm_interface_idx_0=<int>,tm_interface_idx_1=<int>]\n",
    "dnx_algo_port_db tm_interface master_tdm_logical_port dump tm_interface_idx_0=0 tm_interface_idx_1=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_interface_master_tdm_logical_port_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~TM_INTERFACE~MASTER_TDM_LOGICAL_PORT~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->tm_interface[0][0].master_tdm_logical_port));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_interface_master_tdm_logical_port_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_interface_master_tdm_logical_port_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db tm_interface master_tdm_logical_port size_get",
    "dnx_algo_port_db tm_interface master_tdm_logical_port size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_interface_master_tdm_logical_port_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~TM_INTERFACE~MASTER_TDM_LOGICAL_PORT~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_interface_master_tdm_logical_port_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_interface_master_tdm_logical_port_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db tm_interface master_tdm_logical_port diagnostic_operation_counters",
    "dnx_algo_port_db tm_interface master_tdm_logical_port diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_tm_interface_master_non_tdm_logical_port_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_tm_interface_master_non_tdm_logical_port_dump_cmd, NULL, dnx_swstate_dnx_algo_port_tm_interface_master_non_tdm_logical_port_dump_options, &dnx_swstate_dnx_algo_port_tm_interface_master_non_tdm_logical_port_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_tm_interface_master_non_tdm_logical_port_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_tm_interface_master_non_tdm_logical_port_size_get_options, &dnx_swstate_dnx_algo_port_tm_interface_master_non_tdm_logical_port_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_tm_interface_master_non_tdm_logical_port_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_tm_interface_master_non_tdm_logical_port_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_tm_interface_master_non_tdm_logical_port_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_interface_master_non_tdm_logical_port_man = {
    cmd_dnx_swstate_dnx_algo_port_tm_interface_master_non_tdm_logical_port_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_tm_interface_master_non_tdm_logical_port_desc[] = "dnx_algo_port_db tm_interface master_non_tdm_logical_port commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_interface_master_non_tdm_logical_port_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  tm_interface_idx_0 = 0;
    int  tm_interface_idx_1 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("tm_interface_idx_0", tm_interface_idx_0);
    SH_SAND_GET_INT32("tm_interface_idx_1", tm_interface_idx_1);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_tm_interface_master_non_tdm_logical_port_dump(unit, tm_interface_idx_0, tm_interface_idx_1, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_interface_master_non_tdm_logical_port_dump_options[] = {
    {"tm_interface_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"tm_interface_idx_1", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_interface_master_non_tdm_logical_port_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db tm_interface master_non_tdm_logical_port dump [,tm_interface_idx_0=<int>,tm_interface_idx_1=<int>]\n",
    "dnx_algo_port_db tm_interface master_non_tdm_logical_port dump tm_interface_idx_0=0 tm_interface_idx_1=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_interface_master_non_tdm_logical_port_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~TM_INTERFACE~MASTER_NON_TDM_LOGICAL_PORT~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->tm_interface[0][0].master_non_tdm_logical_port));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_interface_master_non_tdm_logical_port_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_interface_master_non_tdm_logical_port_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db tm_interface master_non_tdm_logical_port size_get",
    "dnx_algo_port_db tm_interface master_non_tdm_logical_port size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_interface_master_non_tdm_logical_port_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~TM_INTERFACE~MASTER_NON_TDM_LOGICAL_PORT~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_interface_master_non_tdm_logical_port_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_interface_master_non_tdm_logical_port_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db tm_interface master_non_tdm_logical_port diagnostic_operation_counters",
    "dnx_algo_port_db tm_interface master_non_tdm_logical_port diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_tm_interface_master_logical_port_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_tm_interface_master_logical_port_dump_cmd, NULL, dnx_swstate_dnx_algo_port_tm_interface_master_logical_port_dump_options, &dnx_swstate_dnx_algo_port_tm_interface_master_logical_port_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_tm_interface_master_logical_port_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_tm_interface_master_logical_port_size_get_options, &dnx_swstate_dnx_algo_port_tm_interface_master_logical_port_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_tm_interface_master_logical_port_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_tm_interface_master_logical_port_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_tm_interface_master_logical_port_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_interface_master_logical_port_man = {
    cmd_dnx_swstate_dnx_algo_port_tm_interface_master_logical_port_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_tm_interface_master_logical_port_desc[] = "dnx_algo_port_db tm_interface master_logical_port commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_interface_master_logical_port_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  tm_interface_idx_0 = 0;
    int  tm_interface_idx_1 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("tm_interface_idx_0", tm_interface_idx_0);
    SH_SAND_GET_INT32("tm_interface_idx_1", tm_interface_idx_1);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_tm_interface_master_logical_port_dump(unit, tm_interface_idx_0, tm_interface_idx_1, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_interface_master_logical_port_dump_options[] = {
    {"tm_interface_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"tm_interface_idx_1", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_interface_master_logical_port_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db tm_interface master_logical_port dump [,tm_interface_idx_0=<int>,tm_interface_idx_1=<int>]\n",
    "dnx_algo_port_db tm_interface master_logical_port dump tm_interface_idx_0=0 tm_interface_idx_1=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_interface_master_logical_port_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~TM_INTERFACE~MASTER_LOGICAL_PORT~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->tm_interface[0][0].master_logical_port));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_interface_master_logical_port_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_interface_master_logical_port_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db tm_interface master_logical_port size_get",
    "dnx_algo_port_db tm_interface master_logical_port size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_tm_interface_master_logical_port_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~TM_INTERFACE~MASTER_LOGICAL_PORT~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_tm_interface_master_logical_port_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_tm_interface_master_logical_port_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db tm_interface master_logical_port diagnostic_operation_counters",
    "dnx_algo_port_db tm_interface master_logical_port diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_interface_cmds[] = {
    {"valid", NULL, sh_dnx_swstate_dnx_algo_port_interface_valid_cmds, NULL, &dnx_swstate_dnx_algo_port_interface_valid_man},
    {"core", NULL, sh_dnx_swstate_dnx_algo_port_interface_core_cmds, NULL, &dnx_swstate_dnx_algo_port_interface_core_man},
    {"rx_speed", NULL, sh_dnx_swstate_dnx_algo_port_interface_rx_speed_cmds, NULL, &dnx_swstate_dnx_algo_port_interface_rx_speed_man},
    {"tx_speed", NULL, sh_dnx_swstate_dnx_algo_port_interface_tx_speed_cmds, NULL, &dnx_swstate_dnx_algo_port_interface_tx_speed_man},
    {"master_logical_port", NULL, sh_dnx_swstate_dnx_algo_port_interface_master_logical_port_cmds, NULL, &dnx_swstate_dnx_algo_port_interface_master_logical_port_man},
    {"dump", sh_dnx_swstate_dnx_algo_port_interface_dump_cmd, NULL, dnx_swstate_dnx_algo_port_interface_dump_options, &dnx_swstate_dnx_algo_port_interface_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_interface_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_interface_size_get_options, &dnx_swstate_dnx_algo_port_interface_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_interface_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_interface_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_interface_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_interface_man = {
    cmd_dnx_swstate_dnx_algo_port_interface_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_interface_desc[] = "dnx_algo_port_db interface commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_interface_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  interface_idx_0 = 0;
    int  interface_idx_1 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("interface_idx_0", interface_idx_0);
    SH_SAND_GET_INT32("interface_idx_1", interface_idx_1);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_interface_dump(unit, interface_idx_0, interface_idx_1, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_interface_dump_options[] = {
    {"interface_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"interface_idx_1", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_interface_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db interface dump [,interface_idx_0=<int>,interface_idx_1=<int>]\n",
    "dnx_algo_port_db interface dump interface_idx_0=0 interface_idx_1=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_interface_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~INTERFACE~", 0);
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_interface_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_interface_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db interface size_get",
    "dnx_algo_port_db interface size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_interface_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~INTERFACE~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_interface_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_interface_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db interface diagnostic_operation_counters",
    "dnx_algo_port_db interface diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_interface_valid_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_interface_valid_dump_cmd, NULL, dnx_swstate_dnx_algo_port_interface_valid_dump_options, &dnx_swstate_dnx_algo_port_interface_valid_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_interface_valid_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_interface_valid_size_get_options, &dnx_swstate_dnx_algo_port_interface_valid_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_interface_valid_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_interface_valid_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_interface_valid_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_interface_valid_man = {
    cmd_dnx_swstate_dnx_algo_port_interface_valid_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_interface_valid_desc[] = "dnx_algo_port_db interface valid commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_interface_valid_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  interface_idx_0 = 0;
    int  interface_idx_1 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("interface_idx_0", interface_idx_0);
    SH_SAND_GET_INT32("interface_idx_1", interface_idx_1);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_interface_valid_dump(unit, interface_idx_0, interface_idx_1, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_interface_valid_dump_options[] = {
    {"interface_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"interface_idx_1", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_interface_valid_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db interface valid dump [,interface_idx_0=<int>,interface_idx_1=<int>]\n",
    "dnx_algo_port_db interface valid dump interface_idx_0=0 interface_idx_1=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_interface_valid_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~INTERFACE~VALID~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->interface[0][0].valid));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_interface_valid_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_interface_valid_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db interface valid size_get",
    "dnx_algo_port_db interface valid size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_interface_valid_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~INTERFACE~VALID~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_interface_valid_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_interface_valid_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db interface valid diagnostic_operation_counters",
    "dnx_algo_port_db interface valid diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_interface_core_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_interface_core_dump_cmd, NULL, dnx_swstate_dnx_algo_port_interface_core_dump_options, &dnx_swstate_dnx_algo_port_interface_core_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_interface_core_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_interface_core_size_get_options, &dnx_swstate_dnx_algo_port_interface_core_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_interface_core_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_interface_core_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_interface_core_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_interface_core_man = {
    cmd_dnx_swstate_dnx_algo_port_interface_core_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_interface_core_desc[] = "dnx_algo_port_db interface core commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_interface_core_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  interface_idx_0 = 0;
    int  interface_idx_1 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("interface_idx_0", interface_idx_0);
    SH_SAND_GET_INT32("interface_idx_1", interface_idx_1);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_interface_core_dump(unit, interface_idx_0, interface_idx_1, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_interface_core_dump_options[] = {
    {"interface_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"interface_idx_1", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_interface_core_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db interface core dump [,interface_idx_0=<int>,interface_idx_1=<int>]\n",
    "dnx_algo_port_db interface core dump interface_idx_0=0 interface_idx_1=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_interface_core_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~INTERFACE~CORE~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->interface[0][0].core));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_interface_core_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_interface_core_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db interface core size_get",
    "dnx_algo_port_db interface core size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_interface_core_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~INTERFACE~CORE~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_interface_core_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_interface_core_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db interface core diagnostic_operation_counters",
    "dnx_algo_port_db interface core diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_interface_rx_speed_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_interface_rx_speed_dump_cmd, NULL, dnx_swstate_dnx_algo_port_interface_rx_speed_dump_options, &dnx_swstate_dnx_algo_port_interface_rx_speed_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_interface_rx_speed_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_interface_rx_speed_size_get_options, &dnx_swstate_dnx_algo_port_interface_rx_speed_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_interface_rx_speed_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_interface_rx_speed_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_interface_rx_speed_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_interface_rx_speed_man = {
    cmd_dnx_swstate_dnx_algo_port_interface_rx_speed_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_interface_rx_speed_desc[] = "dnx_algo_port_db interface rx_speed commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_interface_rx_speed_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  interface_idx_0 = 0;
    int  interface_idx_1 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("interface_idx_0", interface_idx_0);
    SH_SAND_GET_INT32("interface_idx_1", interface_idx_1);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_interface_rx_speed_dump(unit, interface_idx_0, interface_idx_1, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_interface_rx_speed_dump_options[] = {
    {"interface_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"interface_idx_1", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_interface_rx_speed_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db interface rx_speed dump [,interface_idx_0=<int>,interface_idx_1=<int>]\n",
    "dnx_algo_port_db interface rx_speed dump interface_idx_0=0 interface_idx_1=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_interface_rx_speed_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~INTERFACE~RX_SPEED~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->interface[0][0].rx_speed));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_interface_rx_speed_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_interface_rx_speed_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db interface rx_speed size_get",
    "dnx_algo_port_db interface rx_speed size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_interface_rx_speed_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~INTERFACE~RX_SPEED~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_interface_rx_speed_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_interface_rx_speed_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db interface rx_speed diagnostic_operation_counters",
    "dnx_algo_port_db interface rx_speed diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_interface_tx_speed_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_interface_tx_speed_dump_cmd, NULL, dnx_swstate_dnx_algo_port_interface_tx_speed_dump_options, &dnx_swstate_dnx_algo_port_interface_tx_speed_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_interface_tx_speed_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_interface_tx_speed_size_get_options, &dnx_swstate_dnx_algo_port_interface_tx_speed_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_interface_tx_speed_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_interface_tx_speed_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_interface_tx_speed_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_interface_tx_speed_man = {
    cmd_dnx_swstate_dnx_algo_port_interface_tx_speed_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_interface_tx_speed_desc[] = "dnx_algo_port_db interface tx_speed commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_interface_tx_speed_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  interface_idx_0 = 0;
    int  interface_idx_1 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("interface_idx_0", interface_idx_0);
    SH_SAND_GET_INT32("interface_idx_1", interface_idx_1);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_interface_tx_speed_dump(unit, interface_idx_0, interface_idx_1, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_interface_tx_speed_dump_options[] = {
    {"interface_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"interface_idx_1", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_interface_tx_speed_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db interface tx_speed dump [,interface_idx_0=<int>,interface_idx_1=<int>]\n",
    "dnx_algo_port_db interface tx_speed dump interface_idx_0=0 interface_idx_1=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_interface_tx_speed_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~INTERFACE~TX_SPEED~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->interface[0][0].tx_speed));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_interface_tx_speed_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_interface_tx_speed_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db interface tx_speed size_get",
    "dnx_algo_port_db interface tx_speed size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_interface_tx_speed_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~INTERFACE~TX_SPEED~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_interface_tx_speed_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_interface_tx_speed_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db interface tx_speed diagnostic_operation_counters",
    "dnx_algo_port_db interface tx_speed diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_interface_master_logical_port_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_interface_master_logical_port_dump_cmd, NULL, dnx_swstate_dnx_algo_port_interface_master_logical_port_dump_options, &dnx_swstate_dnx_algo_port_interface_master_logical_port_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_interface_master_logical_port_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_interface_master_logical_port_size_get_options, &dnx_swstate_dnx_algo_port_interface_master_logical_port_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_interface_master_logical_port_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_interface_master_logical_port_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_interface_master_logical_port_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_interface_master_logical_port_man = {
    cmd_dnx_swstate_dnx_algo_port_interface_master_logical_port_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_interface_master_logical_port_desc[] = "dnx_algo_port_db interface master_logical_port commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_interface_master_logical_port_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  interface_idx_0 = 0;
    int  interface_idx_1 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("interface_idx_0", interface_idx_0);
    SH_SAND_GET_INT32("interface_idx_1", interface_idx_1);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_interface_master_logical_port_dump(unit, interface_idx_0, interface_idx_1, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_interface_master_logical_port_dump_options[] = {
    {"interface_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"interface_idx_1", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_interface_master_logical_port_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db interface master_logical_port dump [,interface_idx_0=<int>,interface_idx_1=<int>]\n",
    "dnx_algo_port_db interface master_logical_port dump interface_idx_0=0 interface_idx_1=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_interface_master_logical_port_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~INTERFACE~MASTER_LOGICAL_PORT~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->interface[0][0].master_logical_port));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_interface_master_logical_port_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_interface_master_logical_port_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db interface master_logical_port size_get",
    "dnx_algo_port_db interface master_logical_port size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_interface_master_logical_port_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~INTERFACE~MASTER_LOGICAL_PORT~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_interface_master_logical_port_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_interface_master_logical_port_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db interface master_logical_port diagnostic_operation_counters",
    "dnx_algo_port_db interface master_logical_port diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_sch_interface_cmds[] = {
    {"valid", NULL, sh_dnx_swstate_dnx_algo_port_sch_interface_valid_cmds, NULL, &dnx_swstate_dnx_algo_port_sch_interface_valid_man},
    {"sch_if", NULL, sh_dnx_swstate_dnx_algo_port_sch_interface_sch_if_cmds, NULL, &dnx_swstate_dnx_algo_port_sch_interface_sch_if_man},
    {"priority_propagation_enable", NULL, sh_dnx_swstate_dnx_algo_port_sch_interface_priority_propagation_enable_cmds, NULL, &dnx_swstate_dnx_algo_port_sch_interface_priority_propagation_enable_man},
    {"master_logical_port", NULL, sh_dnx_swstate_dnx_algo_port_sch_interface_master_logical_port_cmds, NULL, &dnx_swstate_dnx_algo_port_sch_interface_master_logical_port_man},
    {"dump", sh_dnx_swstate_dnx_algo_port_sch_interface_dump_cmd, NULL, dnx_swstate_dnx_algo_port_sch_interface_dump_options, &dnx_swstate_dnx_algo_port_sch_interface_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_sch_interface_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_sch_interface_size_get_options, &dnx_swstate_dnx_algo_port_sch_interface_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_sch_interface_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_sch_interface_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_sch_interface_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_sch_interface_man = {
    cmd_dnx_swstate_dnx_algo_port_sch_interface_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_sch_interface_desc[] = "dnx_algo_port_db sch_interface commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_sch_interface_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  sch_interface_idx_0 = 0;
    int  sch_interface_idx_1 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("sch_interface_idx_0", sch_interface_idx_0);
    SH_SAND_GET_INT32("sch_interface_idx_1", sch_interface_idx_1);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_sch_interface_dump(unit, sch_interface_idx_0, sch_interface_idx_1, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_sch_interface_dump_options[] = {
    {"sch_interface_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"sch_interface_idx_1", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_sch_interface_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db sch_interface dump [,sch_interface_idx_0=<int>,sch_interface_idx_1=<int>]\n",
    "dnx_algo_port_db sch_interface dump sch_interface_idx_0=0 sch_interface_idx_1=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_sch_interface_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~SCH_INTERFACE~", 0);
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_sch_interface_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_sch_interface_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db sch_interface size_get",
    "dnx_algo_port_db sch_interface size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_sch_interface_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~SCH_INTERFACE~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_sch_interface_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_sch_interface_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db sch_interface diagnostic_operation_counters",
    "dnx_algo_port_db sch_interface diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_sch_interface_valid_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_sch_interface_valid_dump_cmd, NULL, dnx_swstate_dnx_algo_port_sch_interface_valid_dump_options, &dnx_swstate_dnx_algo_port_sch_interface_valid_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_sch_interface_valid_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_sch_interface_valid_size_get_options, &dnx_swstate_dnx_algo_port_sch_interface_valid_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_sch_interface_valid_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_sch_interface_valid_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_sch_interface_valid_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_sch_interface_valid_man = {
    cmd_dnx_swstate_dnx_algo_port_sch_interface_valid_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_sch_interface_valid_desc[] = "dnx_algo_port_db sch_interface valid commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_sch_interface_valid_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  sch_interface_idx_0 = 0;
    int  sch_interface_idx_1 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("sch_interface_idx_0", sch_interface_idx_0);
    SH_SAND_GET_INT32("sch_interface_idx_1", sch_interface_idx_1);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_sch_interface_valid_dump(unit, sch_interface_idx_0, sch_interface_idx_1, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_sch_interface_valid_dump_options[] = {
    {"sch_interface_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"sch_interface_idx_1", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_sch_interface_valid_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db sch_interface valid dump [,sch_interface_idx_0=<int>,sch_interface_idx_1=<int>]\n",
    "dnx_algo_port_db sch_interface valid dump sch_interface_idx_0=0 sch_interface_idx_1=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_sch_interface_valid_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~SCH_INTERFACE~VALID~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->sch_interface[0][0].valid));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_sch_interface_valid_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_sch_interface_valid_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db sch_interface valid size_get",
    "dnx_algo_port_db sch_interface valid size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_sch_interface_valid_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~SCH_INTERFACE~VALID~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_sch_interface_valid_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_sch_interface_valid_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db sch_interface valid diagnostic_operation_counters",
    "dnx_algo_port_db sch_interface valid diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_sch_interface_sch_if_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_sch_interface_sch_if_dump_cmd, NULL, dnx_swstate_dnx_algo_port_sch_interface_sch_if_dump_options, &dnx_swstate_dnx_algo_port_sch_interface_sch_if_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_sch_interface_sch_if_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_sch_interface_sch_if_size_get_options, &dnx_swstate_dnx_algo_port_sch_interface_sch_if_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_sch_interface_sch_if_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_sch_interface_sch_if_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_sch_interface_sch_if_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_sch_interface_sch_if_man = {
    cmd_dnx_swstate_dnx_algo_port_sch_interface_sch_if_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_sch_interface_sch_if_desc[] = "dnx_algo_port_db sch_interface sch_if commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_sch_interface_sch_if_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  sch_interface_idx_0 = 0;
    int  sch_interface_idx_1 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("sch_interface_idx_0", sch_interface_idx_0);
    SH_SAND_GET_INT32("sch_interface_idx_1", sch_interface_idx_1);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_sch_interface_sch_if_dump(unit, sch_interface_idx_0, sch_interface_idx_1, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_sch_interface_sch_if_dump_options[] = {
    {"sch_interface_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"sch_interface_idx_1", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_sch_interface_sch_if_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db sch_interface sch_if dump [,sch_interface_idx_0=<int>,sch_interface_idx_1=<int>]\n",
    "dnx_algo_port_db sch_interface sch_if dump sch_interface_idx_0=0 sch_interface_idx_1=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_sch_interface_sch_if_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~SCH_INTERFACE~SCH_IF~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->sch_interface[0][0].sch_if));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_sch_interface_sch_if_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_sch_interface_sch_if_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db sch_interface sch_if size_get",
    "dnx_algo_port_db sch_interface sch_if size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_sch_interface_sch_if_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~SCH_INTERFACE~SCH_IF~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_sch_interface_sch_if_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_sch_interface_sch_if_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db sch_interface sch_if diagnostic_operation_counters",
    "dnx_algo_port_db sch_interface sch_if diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_sch_interface_priority_propagation_enable_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_sch_interface_priority_propagation_enable_dump_cmd, NULL, dnx_swstate_dnx_algo_port_sch_interface_priority_propagation_enable_dump_options, &dnx_swstate_dnx_algo_port_sch_interface_priority_propagation_enable_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_sch_interface_priority_propagation_enable_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_sch_interface_priority_propagation_enable_size_get_options, &dnx_swstate_dnx_algo_port_sch_interface_priority_propagation_enable_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_sch_interface_priority_propagation_enable_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_sch_interface_priority_propagation_enable_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_sch_interface_priority_propagation_enable_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_sch_interface_priority_propagation_enable_man = {
    cmd_dnx_swstate_dnx_algo_port_sch_interface_priority_propagation_enable_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_sch_interface_priority_propagation_enable_desc[] = "dnx_algo_port_db sch_interface priority_propagation_enable commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_sch_interface_priority_propagation_enable_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  sch_interface_idx_0 = 0;
    int  sch_interface_idx_1 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("sch_interface_idx_0", sch_interface_idx_0);
    SH_SAND_GET_INT32("sch_interface_idx_1", sch_interface_idx_1);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_sch_interface_priority_propagation_enable_dump(unit, sch_interface_idx_0, sch_interface_idx_1, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_sch_interface_priority_propagation_enable_dump_options[] = {
    {"sch_interface_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"sch_interface_idx_1", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_sch_interface_priority_propagation_enable_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db sch_interface priority_propagation_enable dump [,sch_interface_idx_0=<int>,sch_interface_idx_1=<int>]\n",
    "dnx_algo_port_db sch_interface priority_propagation_enable dump sch_interface_idx_0=0 sch_interface_idx_1=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_sch_interface_priority_propagation_enable_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~SCH_INTERFACE~PRIORITY_PROPAGATION_ENABLE~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->sch_interface[0][0].priority_propagation_enable));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_sch_interface_priority_propagation_enable_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_sch_interface_priority_propagation_enable_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db sch_interface priority_propagation_enable size_get",
    "dnx_algo_port_db sch_interface priority_propagation_enable size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_sch_interface_priority_propagation_enable_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~SCH_INTERFACE~PRIORITY_PROPAGATION_ENABLE~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_sch_interface_priority_propagation_enable_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_sch_interface_priority_propagation_enable_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db sch_interface priority_propagation_enable diagnostic_operation_counters",
    "dnx_algo_port_db sch_interface priority_propagation_enable diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_sch_interface_master_logical_port_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_sch_interface_master_logical_port_dump_cmd, NULL, dnx_swstate_dnx_algo_port_sch_interface_master_logical_port_dump_options, &dnx_swstate_dnx_algo_port_sch_interface_master_logical_port_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_sch_interface_master_logical_port_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_sch_interface_master_logical_port_size_get_options, &dnx_swstate_dnx_algo_port_sch_interface_master_logical_port_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_sch_interface_master_logical_port_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_sch_interface_master_logical_port_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_sch_interface_master_logical_port_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_sch_interface_master_logical_port_man = {
    cmd_dnx_swstate_dnx_algo_port_sch_interface_master_logical_port_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_sch_interface_master_logical_port_desc[] = "dnx_algo_port_db sch_interface master_logical_port commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_sch_interface_master_logical_port_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  sch_interface_idx_0 = 0;
    int  sch_interface_idx_1 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("sch_interface_idx_0", sch_interface_idx_0);
    SH_SAND_GET_INT32("sch_interface_idx_1", sch_interface_idx_1);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_sch_interface_master_logical_port_dump(unit, sch_interface_idx_0, sch_interface_idx_1, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_sch_interface_master_logical_port_dump_options[] = {
    {"sch_interface_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"sch_interface_idx_1", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_sch_interface_master_logical_port_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db sch_interface master_logical_port dump [,sch_interface_idx_0=<int>,sch_interface_idx_1=<int>]\n",
    "dnx_algo_port_db sch_interface master_logical_port dump sch_interface_idx_0=0 sch_interface_idx_1=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_sch_interface_master_logical_port_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~SCH_INTERFACE~MASTER_LOGICAL_PORT~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->sch_interface[0][0].master_logical_port));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_sch_interface_master_logical_port_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_sch_interface_master_logical_port_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db sch_interface master_logical_port size_get",
    "dnx_algo_port_db sch_interface master_logical_port size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_sch_interface_master_logical_port_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~SCH_INTERFACE~MASTER_LOGICAL_PORT~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_sch_interface_master_logical_port_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_sch_interface_master_logical_port_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db sch_interface master_logical_port diagnostic_operation_counters",
    "dnx_algo_port_db sch_interface master_logical_port diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_skip_first_user_defined_header_size_profile_data_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_skip_first_user_defined_header_size_profile_data_dump_cmd, NULL, dnx_swstate_dnx_algo_port_skip_first_user_defined_header_size_profile_data_dump_options, &dnx_swstate_dnx_algo_port_skip_first_user_defined_header_size_profile_data_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_skip_first_user_defined_header_size_profile_data_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_skip_first_user_defined_header_size_profile_data_size_get_options, &dnx_swstate_dnx_algo_port_skip_first_user_defined_header_size_profile_data_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_skip_first_user_defined_header_size_profile_data_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_skip_first_user_defined_header_size_profile_data_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_skip_first_user_defined_header_size_profile_data_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_skip_first_user_defined_header_size_profile_data_man = {
    cmd_dnx_swstate_dnx_algo_port_skip_first_user_defined_header_size_profile_data_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_skip_first_user_defined_header_size_profile_data_desc[] = "dnx_algo_port_db skip_first_user_defined_header_size_profile_data commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_skip_first_user_defined_header_size_profile_data_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);


    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_skip_first_user_defined_header_size_profile_data_dump(unit, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_skip_first_user_defined_header_size_profile_data_dump_options[] = {
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_skip_first_user_defined_header_size_profile_data_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db skip_first_user_defined_header_size_profile_data dump []\n",
    "dnx_algo_port_db skip_first_user_defined_header_size_profile_data dump nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_skip_first_user_defined_header_size_profile_data_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~SKIP_FIRST_USER_DEFINED_HEADER_SIZE_PROFILE_DATA~", 0);
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_skip_first_user_defined_header_size_profile_data_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_skip_first_user_defined_header_size_profile_data_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db skip_first_user_defined_header_size_profile_data size_get",
    "dnx_algo_port_db skip_first_user_defined_header_size_profile_data size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_skip_first_user_defined_header_size_profile_data_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~SKIP_FIRST_USER_DEFINED_HEADER_SIZE_PROFILE_DATA~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_skip_first_user_defined_header_size_profile_data_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_skip_first_user_defined_header_size_profile_data_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db skip_first_user_defined_header_size_profile_data diagnostic_operation_counters",
    "dnx_algo_port_db skip_first_user_defined_header_size_profile_data diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_prd_cmds[] = {
    {"port_to_profile_map", NULL, sh_dnx_swstate_dnx_algo_port_prd_port_to_profile_map_cmds, NULL, &dnx_swstate_dnx_algo_port_prd_port_to_profile_map_man},
    {"dump", sh_dnx_swstate_dnx_algo_port_prd_dump_cmd, NULL, dnx_swstate_dnx_algo_port_prd_dump_options, &dnx_swstate_dnx_algo_port_prd_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_prd_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_prd_size_get_options, &dnx_swstate_dnx_algo_port_prd_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_prd_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_prd_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_prd_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_prd_man = {
    cmd_dnx_swstate_dnx_algo_port_prd_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_prd_desc[] = "dnx_algo_port_db prd commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_prd_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  prd_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("prd_idx_0", prd_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_prd_dump(unit, prd_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_prd_dump_options[] = {
    {"prd_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_prd_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db prd dump [,prd_idx_0=<int>]\n",
    "dnx_algo_port_db prd dump prd_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_prd_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~PRD~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->prd));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_prd_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_prd_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db prd size_get",
    "dnx_algo_port_db prd size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_prd_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~PRD~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_prd_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_prd_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db prd diagnostic_operation_counters",
    "dnx_algo_port_db prd diagnostic_operation_counters",
};



sh_sand_cmd_t sh_dnx_swstate_dnx_algo_port_prd_port_to_profile_map_cmds[] = {
    {"dump", sh_dnx_swstate_dnx_algo_port_prd_port_to_profile_map_dump_cmd, NULL, dnx_swstate_dnx_algo_port_prd_port_to_profile_map_dump_options, &dnx_swstate_dnx_algo_port_prd_port_to_profile_map_dump_man},
    {"size_get", sh_dnx_swstate_dnx_algo_port_prd_port_to_profile_map_size_get_cmd, NULL, dnx_swstate_dnx_algo_port_prd_port_to_profile_map_size_get_options, &dnx_swstate_dnx_algo_port_prd_port_to_profile_map_size_get_man},
    {"diagnostic_operation_counters", sh_dnx_swstate_dnx_algo_port_prd_port_to_profile_map_diagnostic_operation_counters_cmd, NULL, dnx_swstate_dnx_algo_port_prd_port_to_profile_map_diagnostic_operation_counters_options, &dnx_swstate_dnx_algo_port_prd_port_to_profile_map_diagnostic_operation_counters_man},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_prd_port_to_profile_map_man = {
    cmd_dnx_swstate_dnx_algo_port_prd_port_to_profile_map_desc,
    NULL,
    NULL,
    NULL,
};


const char cmd_dnx_swstate_dnx_algo_port_prd_port_to_profile_map_desc[] = "dnx_algo_port_db prd port_to_profile_map commands";


shr_error_e sh_dnx_swstate_dnx_algo_port_prd_port_to_profile_map_dump_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    int  prd_idx_0 = 0;

    dnx_sw_state_dump_filters_t filters;

    SHR_FUNC_INIT_VARS(unit);

    SH_SAND_GET_INT32("prd_idx_0", prd_idx_0);

    SH_SAND_GET_BOOL("nocontent", filters.nocontent);
    SH_SAND_GET_STR("typefilter", filters.typefilter);
    SH_SAND_GET_STR("namefilter", filters.namefilter);

    SHR_IF_ERR_EXIT(dnx_algo_port_db_prd_port_to_profile_map_dump(unit, prd_idx_0, filters));

    if (!filters.nocontent)
    {
        dnx_sw_state_dump_detach_file(unit);

    }

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_prd_port_to_profile_map_dump_options[] = {
    {"prd_idx_0", SAL_FIELD_TYPE_INT32, "index", NULL},
    {"nocontent",      SAL_FIELD_TYPE_BOOL, "Decision if to perform content dump or to print the access tree.",  "false"},
    {"typefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable type.",         ""},
    {"namefilter",     SAL_FIELD_TYPE_STR,  "Filter for the variable name.",         ""},
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_prd_port_to_profile_map_dump_man = {
    "swstate dump",
    "print the variable value",
    "dnx_algo_port_db prd port_to_profile_map dump [,prd_idx_0=<int>]\n",
    "dnx_algo_port_db prd port_to_profile_map dump prd_idx_0=0 nocontent=false typefilter="" namefilter="" ",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_prd_port_to_profile_map_size_get_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{
    uint32 size = 0;

    SHR_FUNC_INIT_VARS(unit);


    size = dnx_sw_state_info_size_get(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~PRD~PORT_TO_PROFILE_MAP~", sizeof(((dnx_algo_port_db_t*)sw_state_roots_array[unit][DNX_ALGO_PORT_MODULE_ID])->prd[0].port_to_profile_map));
    dnx_sw_state_size_print(size);

    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_prd_port_to_profile_map_size_get_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_prd_port_to_profile_map_size_get_man = {
    "swstate size_get",
    "print the variable size",
    "dnx_algo_port_db prd port_to_profile_map size_get",
    "dnx_algo_port_db prd port_to_profile_map size_get",
};


shr_error_e sh_dnx_swstate_dnx_algo_port_prd_port_to_profile_map_diagnostic_operation_counters_cmd(int unit, args_t *args, sh_sand_control_t *sand_control)
{

    SHR_FUNC_INIT_VARS(unit);


    dnx_sw_state_diagnostic_operation_counters_print(dnx_algo_port_db_info[unit], dnx_algo_port_db_layout_str, DNX_ALGO_PORT_DB_INFO_NOF_ENTRIES, "DNX_ALGO_PORT_DB~PRD~PORT_TO_PROFILE_MAP~");
    SHR_EXIT();
exit:
    SHR_FUNC_EXIT;
}



sh_sand_option_t dnx_swstate_dnx_algo_port_prd_port_to_profile_map_diagnostic_operation_counters_options[] = {
    {NULL}
};


sh_sand_man_t dnx_swstate_dnx_algo_port_prd_port_to_profile_map_diagnostic_operation_counters_man = {
    "swstate diagnostic_operation_counters",
    "print the diagnostic operation counters",
    "dnx_algo_port_db prd port_to_profile_map diagnostic_operation_counters",
    "dnx_algo_port_db prd port_to_profile_map diagnostic_operation_counters",
};


#endif /* DNX_SW_STATE_DIAGNOSTIC */
#undef BSL_LOG_MODULE
