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