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 <simics/base/sim-exception.h>  // SIM_clear_exception
 
#include <string>
#include <memory>  // unique_ptr
#include <vector>
 
#include "object-factory.h"
#include "iface/interface-info.h"
#include "attribute.h"
#include "init-class.h"
#include "log.h"
#include "event.h"
 
namespace simics {
 
using ConfClassPtr = std::unique_ptr<ConfClass>;
 
int array_index(const std::string &name);
 
std::vector<std::string> expand_names(const std::string &name,
                                      const char delimiter = '.');
 
// coverity[rule_of_three_violation:FALSE]
class ConfClass {
  public:
    virtual ~ConfClass();
 
    ConfClass(const ConfClass&) = delete;
    ConfClass& operator=(const ConfClass&) = delete;
 
    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);
 
    operator conf_class_t*() const { return cls_; }
 
    const std::string &name() const { return name_; }
 
    const std::string &description() const { return description_; }
 
    const std::vector<std::string> &log_groups() const { return log_groups_; }
 
    ConfClass *add(const iface::InterfaceInfo &iface);
 
    ConfClass *add(const Attribute &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;
 
    conf_class_t *cls_;
    std::string name_;
    std::string description_;
    std::vector<std::string> log_groups_;
};
 
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;
}
 
}  // namespace simics
 
#endif