statnull.h

// Copyright 2009-2025 NTESS. Under the terms
// of Contract DE-NA0003525 with NTESS, the U.S.
// Government retains certain rights in this software.
//
// Copyright (c) 2009-2025, NTESS
// All rights reserved.
//
// This file is part of the SST software package. For license
// information, see the LICENSE file in the top level directory of the
// distribution.

#ifndef SST_CORE_STATAPI_STATNULL_H
#define SST_CORE_STATAPI_STATNULL_H

#include "sst/core/sst_types.h"
#include "sst/core/statapi/statbase.h"
#include "sst/core/warnmacros.h"

#include <tuple>

namespace SST::Statistics {

// NOTE: When calling base class members of classes derived from
//       a templated base class.  The user must use "this->" in
//       order to call base class members (to avoid a compiler
//       error) because they are "nondependant named" and the
//       templated base class is a "dependant named".  The
//       compiler will not look in dependant named base classes
//       when looking up indepenedent names.
// See: http://www.parashift.com/c++-faq-lite/nondependent-name-lookup-members.html

/**
    \class NullStatistic

    An empty statistic place holder.

    @tparam T A template for holding the main data type of this statistic
*/
template <class T, bool = std::is_arithmetic_v<T>>
class NullStatisticBase;

template <class T>
class NullStatisticBase<T, true> : public Statistic<T>
{
public:
    NullStatisticBase(
        BaseComponent* comp, const std::string& stat_name, const std::string& stat_sub_id, Params& stat_params) :
        Statistic<T>(comp, stat_name, stat_sub_id, stat_params)
    {}

    void addData_impl(T UNUSED(data)) override {}

    void addData_impl_Ntimes(uint64_t UNUSED(N), T UNUSED(data)) override {}

    virtual const std::string& getStatTypeName() const override { return stat_type_; }

private:
    inline static const std::string stat_type_ = "NULL";
};

template <class... Args>
class NullStatisticBase<std::tuple<Args...>, false> : public Statistic<std::tuple<Args...>>
{
public:
    NullStatisticBase(
        BaseComponent* comp, const std::string& stat_name, const std::string& stat_sub_id, Params& stat_params) :
        Statistic<std::tuple<Args...>>(comp, stat_name, stat_sub_id, stat_params)
    {}

    void addData_impl(Args... UNUSED(data)) override {}

    void addData_impl_Ntimes(uint64_t UNUSED(N), Args... UNUSED(data)) override {}

    virtual const std::string& getStatTypeName() const override { return stat_type_; }

private:
    inline static const std::string stat_type_ = "NULL";
};

template <class T>
class NullStatisticBase<T, false> : public Statistic<T>
{
public:
    NullStatisticBase(
        BaseComponent* comp, const std::string& stat_name, const std::string& stat_sub_id, Params& stat_params) :
        Statistic<T>(comp, stat_name, stat_sub_id, stat_params)
    {}

    void addData_impl(T&& UNUSED(data)) override {}
    void addData_impl(const T& UNUSED(data)) override {}

    void addData_impl_Ntimes(uint64_t UNUSED(N), T&& UNUSED(data)) override {}
    void addData_impl_Ntimes(uint64_t UNUSED(N), const T& UNUSED(data)) override {}

    virtual const std::string& getStatTypeName() const override { return stat_type_; }

private:
    inline static const std::string stat_type_ = "NULL";
};

template <class T>
class NullStatistic : public NullStatisticBase<T>
{
public:
    SST_ELI_DECLARE_STATISTIC_TEMPLATE(
        NullStatistic,
        "sst",
        "NullStatistic",
        SST_ELI_ELEMENT_VERSION(1,0,0),
        "Null object that ignores all collections",
        "SST::Statistic<T>"
    )

    NullStatistic(
        BaseComponent* comp, const std::string& stat_name, const std::string& stat_sub_id, Params& stat_params) :
        NullStatisticBase<T>(comp, stat_name, stat_sub_id, stat_params)
    {}

    ~NullStatistic() {}

    void clearStatisticData() override
    {
        // Do Nothing
    }

    void registerOutputFields(StatisticFieldsOutput* UNUSED(stat_output)) override
    {
        // Do Nothing
    }

    void outputStatisticFields(StatisticFieldsOutput* UNUSED(stat_output), bool UNUSED(end_of_sim_flag)) override
    {
        // Do Nothing
    }

    bool isReady() const override { return true; }

    bool isNullStatistic() const override { return true; }

    static bool isLoaded() { return true; }
};

template <>
class NullStatistic<void> : public Statistic<void>
{
public:
    SST_ELI_REGISTER_DERIVED(
        Statistic<void>,
        NullStatistic<void>,
        "sst",
        "NullStatistic",
        SST_ELI_ELEMENT_VERSION(1,0,0),
        "Null statistic for custom (void) stats"
    )

    SST_ELI_INTERFACE_INFO("Statistic<void>")

    NullStatistic(
        BaseComponent* comp, const std::string& stat_name, const std::string& stat_sub_id, Params& stat_params) :
        Statistic<void>(comp, stat_name, stat_sub_id, stat_params)
    {}

    virtual std::string getELIName() const override { return "sst.NullStatistic"; }

    virtual const std::string& getStatTypeName() const override { return stat_type_; }

private:
    inline static const std::string stat_type_ = "NULL";
};

} // namespace SST::Statistics

#endif // SST_CORE_STATAPI_STATNULL_H