hierarchical-object.h

Go to the documentation of this file.

// -*- mode: C++; c-file-style: "virtutech-c++" -*-
 
/*
  © 2022 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_HIERARCHICAL_OBJECT_H
#define SIMICS_HIERARCHICAL_OBJECT_H
 
#include <cstdint>
#include <string>
#include <string_view>
 
#include "simics/conf-object.h"  // ConfObjectRef
#include "simics/hierarchical-object-interface.h"
#include "simics/mappable-conf-object.h"
 
namespace simics {
 
class FieldInterface;
class RegisterInterface;
class BankInterface;
 
constexpr static const char &SEPARATOR = '.';
 
class HierarchicalObject : public HierarchicalObjectInterface {
  public:
    HierarchicalObject(MappableConfObject *dev_obj, const std::string &name);
 
    virtual ~HierarchicalObject();
 
    // No duplication
    HierarchicalObject(const HierarchicalObject&) = delete;
    HierarchicalObject& operator=(const HierarchicalObject&) = delete;
 
    HierarchicalObject(HierarchicalObject &&rhs) noexcept;
    HierarchicalObject& operator=(HierarchicalObject&& rhs) noexcept;
 
    static bool is_valid_hierarchical_name(std::string_view name);
 
    static std::string_view::size_type level_of_hierarchical_name(
            std::string_view name);
 
    static const uint64_t Register_Read {1};
    static const uint64_t Register_Write {2};
    static const uint64_t Register_Read_Exception {3};
    static const uint64_t Register_Write_Exception {4};
 
    template<typename T> T *dev_ptr() {
        static_assert(std::is_base_of<MappableConfObject, T>::value,
                      "T needs be a MappableConfObject");
        return dynamic_cast<T *>(dev_obj());
    }
 
    // see HierarchicalObjectInterface
    const std::string &hierarchical_name() const override;
    std::string_view name() const override;
    const std::string &description() const override;
    void set_description(std::string_view desc) override;
    Level hierarchy_level() const override;
    std::string_view bank_name() const override;
    MappableConfObject *dev_obj() const override;
    ConfObjectRef bank_obj_ref() const override;
    std::string_view parent_name() const override;
    FieldInterface *lookup_field(const std::string &name) const override;
    RegisterInterface *lookup_register(const std::string &name) const override;
    BankInterface *lookup_bank(const std::string &name) const override;
 
  private:
    void init();
    // Ensure that a bank port is created before the initialization of
    // HierarchicalObject.
    void ensureBankPortExists(const std::string &bank_name);
 
    MappableConfObject *dev_obj_ {nullptr};
    std::string hierarchical_name_;
    std::string desc_;
    ConfObjectRef bank_obj_ref_;
    Level level_;
};
 
}  // namespace simics
 
#endif