statfieldinfo.h

// Copyright 2009-2023 NTESS. Under the terms
// of Contract DE-NA0003525 with NTESS, the U.S.
// Government retains certain rights in this software.
//
// Copyright (c) 2009-2023, 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_STATFIELDINFO_H
#define SST_CORE_STATAPI_STATFIELDINFO_H

#include "sst/core/sst_types.h"

#include <map>
#include <string>

namespace SST {
namespace Statistics {

using fieldType_t = uint32_t;

/**
    \class StatisticFieldInfo

    The class for representing Statistic Output Fields
*/

class StatisticFieldTypeBase
{
public:
    virtual const char* fieldName() const = 0;
    virtual const char* shortName() const = 0;

    virtual ~StatisticFieldTypeBase() {}

    static StatisticFieldTypeBase* getField(fieldType_t fieldType);

    static void checkRegisterConflict(const char* oldName, const char* newName);

    static fieldType_t allocateFieldEnum();

protected:
    static void addField(fieldType_t id, StatisticFieldTypeBase* base);

private:
    static std::map<fieldType_t, StatisticFieldTypeBase*>* fields_;
    static fieldType_t                                     enumCounter_;
};

template <class T>
class StatisticFieldType : public StatisticFieldTypeBase
{
public:
    // constructor for initializing data
    StatisticFieldType(const char* name, const char* shortName)
    {
        checkRegisterConflict(fieldName_, name);
        checkRegisterConflict(shortName_, shortName);
        fieldName_ = name;
        shortName_ = shortName;
        if ( fieldEnum_ == 0 ) { fieldEnum_ = allocateFieldEnum(); }

        fieldName_ = name;
        shortName_ = shortName;
        addField(fieldEnum_, this);
    }

    static const char* getFieldName() { return fieldName_; }

    static const char* getShortName() { return shortName_; }

    static fieldType_t id() { return fieldEnum_; }

    const char* fieldName() const override { return getFieldName(); }

    const char* shortName() const override { return getShortName(); }

private:
    static Statistics::fieldType_t fieldEnum_;
    static const char*             fieldName_;
    static const char*             shortName_;
};
template <class T>
fieldType_t StatisticFieldType<T>::fieldEnum_ = 0;
template <class T>
const char* StatisticFieldType<T>::fieldName_ = nullptr;
template <class T>
const char* StatisticFieldType<T>::shortName_ = nullptr;

class StatisticFieldInfo
{
public:
    using fieldType_t   = ::SST::Statistics::fieldType_t;
    using fieldHandle_t = int32_t;

public:
    /** Construct a StatisticFieldInfo
     * @param statName - Name of the statistic registering this field.
     * @param fieldName - Name of the Field to be assigned.
     * @param fieldType - Data type of the field.
     */
    StatisticFieldInfo(const char* statName, const char* fieldName, fieldType_t fieldType);

    // Get Field Data
    /** Return the statistic name related to this field info */
    inline const std::string& getStatName() const { return m_statName; }
    /** Return the field name related to this field info */
    inline const std::string& getFieldName() const { return m_fieldName; }
    /** Return the field type related to this field info */
    fieldType_t               getFieldType() const { return m_fieldType; }
    /** Return the field type related to this field info */
    std::string               getFieldUniqueName() const;

    /** Compare two field info structures
     * @param FieldInfo1 - a FieldInfo to compare against.
     * @return True if the Field Info structures are the same.
     */
    bool operator==(StatisticFieldInfo& FieldInfo1);

    /** Set the field handle
     * @param handle - The assigned field handle for this FieldInfo
     */
    void setFieldHandle(fieldHandle_t handle) { m_fieldHandle = handle; }

    /** Get the field handle
     * @return The assigned field handle.
     */
    fieldHandle_t getFieldHandle() { return m_fieldHandle; }

    static const char* getFieldTypeShortName(fieldType_t type)
    {
        return StatisticFieldTypeBase::getField(type)->shortName();
    }

    static const char* getFieldTypeFullName(fieldType_t type)
    {
        return StatisticFieldTypeBase::getField(type)->fieldName();
    }

    template <typename T>
    static fieldType_t getFieldTypeFromTemplate()
    {
        return StatisticFieldType<T>::id();
    }

protected:
    StatisticFieldInfo() {} // For serialization only

private:
    std::string   m_statName;
    std::string   m_fieldName;
    fieldType_t   m_fieldType;
    fieldHandle_t m_fieldHandle;
};

} // namespace Statistics
} // namespace SST

#endif // SST_CORE_STATAPI_STATFIELDINFO_H