conf-class.h

Go to the documentation of this file.

// -*- mode: C++; c-file-style: "virtutech-c++" -*-
 
/*
  © 2021 Intel Corporation
 
  This software and the related documents are Intel copyrighted materials, and
  your use of them is governed by the express license under which they were
  provided to you ("License"). Unless the License provides otherwise, you may
  not use, modify, copy, publish, distribute, disclose or transmit this software
  or the related documents without Intel's prior written permission.
 
  This software and the related documents are provided as is, with no express or
  implied warranties, other than those that are expressly stated in the License.
*/
 
#ifndef SIMICS_CONF_CLASS_H
#define SIMICS_CONF_CLASS_H
 
#include <simics/base/conf-object.h>  // class_kind_t
 
#include <map>
#include <memory>  // unique_ptr
#include <string>
#include <vector>
 
#include "simics/attribute.h"
#include "simics/event.h"
#include "simics/init-class.h"
#include "simics/iface/interface-info.h"
#if defined INTC_EXT
#include "simics/iface/object-factory-interface.h"
#endif
#include "simics/log.h"  // LogGroups
#include "simics/object-factory.h"
 
namespace simics {
 
using ConfClassPtr = std::unique_ptr<ConfClass>;
 
class ConfClass {
  public:
    static ConfClassPtr createInstance(
            const std::string &name,
            const std::string &short_desc,
            const std::string &description,
            const class_kind_t kind,
            const ObjectFactoryInterface &factory);
 
#if defined INTC_EXT
    static ConfClassPtr createInstance(
            const std::string &name,
            const std::string &short_desc,
            const std::string &description,
            const class_kind_t kind,
            const iface::ObjectFactoryInterface &factory);
#endif
 
    ConfClass(const ConfClass&) = delete;
    ConfClass& operator=(const ConfClass&) = delete;
 
    virtual ~ConfClass();
 
    static uint64 getGroupId(conf_class_t *cls, const std::string &name);
 
    operator conf_class_t*() const;
 
    const std::string &name() const;
 
    const std::string &description() const;
 
    const std::vector<std::string> &log_groups() const;
 
    ConfClass *add(const iface::InterfaceInfo &iface);
 
    ConfClass *add(const Attribute &attr);
    ConfClass *add(const ClassAttribute &attr);
 
    ConfClass *add(const char * const *names);
    ConfClass *add(const LogGroups &names);
 
    ConfClass *add(ConfClass *port, const std::string &name);
    ConfClass *add(const ConfClassPtr &port, const std::string &name);
 
    ConfClass *add(EventInfo &&event);
 
  protected:
    explicit ConfClass(conf_class_t *cls, const std::string &name,
                       const std::string &description)
        : cls_(cls), name_(name), description_(description) {}
 
  private:
    void register_log_groups() const noexcept;
 
    void register_interfaces() noexcept;
 
    conf_class_t *cls_ {nullptr};
    std::string name_;
    std::string description_;
    std::vector<std::string> log_groups_;
    std::map<std::string, const interface_t *> pending_interfaces_;
};
 
template <typename T>
void decorate_class(...) {}
 
template <typename T> ConfClassPtr
make_class(const std::string &name, const std::string &short_desc,
           const std::string &description,
           const class_kind_t kind = Sim_Class_Kind_Vanilla) {
    auto cls = ConfClass::createInstance(name, short_desc, description, kind,
                                         ObjectFactory<T>());
    detail::init_class<T>(cls.get());
    decorate_class<T>(nullptr, cls.get());
    return cls;
}
 
template <typename T, typename A> ConfClassPtr
make_class(const std::string &name, const std::string &short_desc,
           const std::string &description, A *constructor_arg,
           const class_kind_t kind = Sim_Class_Kind_Vanilla) {
    auto cls = ConfClass::createInstance(name, short_desc, description, kind,
                                         ObjectFactoryWithArg<T, A>(
                                                 constructor_arg));
    detail::init_class<T>(cls.get());
    decorate_class<T>(nullptr, cls.get());
    return cls;
}
 
// Custom empty class used as a placeholder for "no additional argument"
class None {};
 
template <typename T, typename A = None>
class RegisterClassWithSimics {
    // This type is defined (as int) only when A is None
    template <typename U = A>
    using EnableIfNone = std::enable_if_t<std::is_same<U, None>::value, int>;
 
    // This type is defined (as int) only when A is not None
    template <typename U = A>
    using EnableIfNotNone = std::enable_if_t<!std::is_same<U, None>::value,
                                             int>;
 
  public:
    // Constructor for classes without additional arguments
    template <typename U = A, EnableIfNone<U> = 0> constexpr
    RegisterClassWithSimics(const std::string &name,
                            const std::string &short_desc,
                            const std::string &description,
                            const class_kind_t kind = Sim_Class_Kind_Vanilla) {
        make_class<T>(name, short_desc, description, kind);
    }
 
    // Constructor for classes with additional arguments
    template <typename U = A, EnableIfNotNone<U> = 0> constexpr
    RegisterClassWithSimics(const std::string &name,
                            const std::string &short_desc,
                            const std::string &description,
                            A *constructor_arg,
                            const class_kind_t kind = Sim_Class_Kind_Vanilla) {
        make_class<T, A>(name, short_desc, description, constructor_arg, kind);
    }
};
 
#define GROUP_ID(...) \
    IMPL(GET_MACRO(__VA_ARGS__, GROUP_ID_TWO_ARGS, \
                   GROUP_ID_ONE_ARG)(__VA_ARGS__))
 
#define GROUP_ID_ONE_ARG(NAME) \
    simics::ConfClass::getGroupId(SIM_object_class(obj()), #NAME)
 
#define GROUP_ID_TWO_ARGS(OBJ, NAME) \
    simics::ConfClass::getGroupId(SIM_object_class(OBJ), #NAME)
 
}  // namespace simics
 
#endif