hierarchical-object-name.h

Go to the documentation of this file.

// -*- mode: C++; c-file-style: "virtutech-c++" -*-
 
/*
  © 2023 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_TYPE_HIERARCHICAL_OBJECT_NAME_H
#define SIMICS_TYPE_HIERARCHICAL_OBJECT_NAME_H
 
#ifdef __GNUC__
#include <cctype>  // isalpha
#endif
#include <cstddef>
#include <map>
#include <stdexcept>
#include <string>
#include <string_view>
#include <utility>  // pair
#include <vector>
 
namespace simics {
namespace detail {
 
class HierarchicalObjectName : public std::string_view {
  public:
    constexpr HierarchicalObjectName() noexcept
        : std::string_view() {}
    constexpr HierarchicalObjectName(
            const HierarchicalObjectName& other) noexcept = default;
    constexpr HierarchicalObjectName(const_pointer s, size_type count)
        : std::string_view(s, count) {
        validate_name(*this);
    }
    constexpr HierarchicalObjectName(
            const_pointer s)  // NOLINT(runtime/explicit)
        : std::string_view(s) {
        validate_name(*this);
    }
 
    static constexpr void validate_name(std::string_view name) {
#ifdef __GNUC__
        using std::isalpha;
        using std::isalnum;
#endif
        if (name.empty()) {
            throw std::invalid_argument("Empty name is not allowed");
        }
        if (!isalpha(name.front())) {
            throw std::invalid_argument(
                std::string("Name (") + name.data() \
                + ") does not begin with an alphabetic character");
        }
 
        // Validate base_name
        for (const auto &c : name.substr(0, name.find('['))) {
            if (c != '_' && !isalnum(c)) {
                throw std::invalid_argument(
                        std::string("Character (") + c \
                        + ") is not allowed to use in a name");
            }
        }
    }
 
    constexpr std::string_view base_name() const {
        return substr(0, find('['));
    }
 
    constexpr std::string_view array_str() const {
        auto pos = find('[');
        if (pos != npos) {
            return substr(pos);
        }
        return {};
    }
 
    std::map<std::string, size_t> arrayNamesToOffsets(size_t width) const {
        if (width == 0) {
            throw std::invalid_argument("Invalid width 0");
        }
 
        if (array_str().empty()) {
            return {};
        }
 
        auto sizes_and_strides = arraySizesAndStrides();
        // Update strides for all dimensions
        for (auto it = sizes_and_strides.rbegin();
             it != sizes_and_strides.rend(); ++it) {
            if (it->second != 0) {
                continue;
            }
            if (it == sizes_and_strides.rbegin()) {
                // The innermost dimension, use width as the stride
                it->second = width;
            } else {
                // Use the sum of distances of inner dimension elements
                it->second = (it - 1)->first * (it - 1)->second;
            }
        }
 
        std::map<std::string, size_t> names_to_offsets;
        std::vector<size_t> indices(sizes_and_strides.size(), 0);
        generateNamesToOffsets(sizes_and_strides, 0, &indices,
                               &names_to_offsets);
        return names_to_offsets;
    }
 
    std::vector<std::pair<size_t, size_t>> arraySizesAndStrides() const {
        auto s = array_str();
        if (s.empty()) {
            return {};
        }
 
        std::size_t content_pos = npos;
        std::vector<std::pair<size_t, size_t>> dims_;
        for (size_t i = 0; i < s.size(); ++i) {
            auto c = s[i];
            if (c == '[') {
                if (content_pos != npos) {
                    throw std::logic_error("Name has unbalanced brackets");
                }
                content_pos = i + 1;
            } else if (c == ']') {
                if (content_pos == npos) {
                    throw std::logic_error("Name has unbalanced brackets");
                }
                if (content_pos == i) {
                    throw std::logic_error("Name has nothing in brackets");
                }
                const auto &[size, stride] = sizeAndStride(
                        s.substr(content_pos, i - content_pos));
                if (size == 0) {
                    throw std::logic_error("Dimension size is 0");
                }
                dims_.push_back({size, stride});
                content_pos = npos;
            }
        }
 
        if (content_pos != npos) {
            throw std::logic_error("Name has unbalanced brackets");
        }
 
        return dims_;
    }
 
  private:
#ifndef __GNUC__
    // Microsoft Visual Studio 2022 treat these functions as non-constexpr and
    // generates C3615 error
    static constexpr bool isalpha(value_type c) {
        return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
    }
 
    static constexpr bool isalnum(value_type c) {
        return isalpha(c) || (c >= '0' && c <= '9');
    }
#endif
 
    std::pair<size_t, size_t> sizeAndStride(std::string_view s) const {
        auto stride_pos = s.find(" stride ");
        size_t size;
        size_t stride = 0;
 
        try {
            if (stride_pos != npos) {
                size = std::stoi(s.substr(0, stride_pos).data());
                stride = std::stoi(s.substr(stride_pos + 8).data());
            } else {
                if (s.find_first_not_of("0123456789") != npos) {
                    throw std::invalid_argument("non-digit character");
                }
                size = std::stoi(s.data());
            }
        } catch (const std::exception &e) {
            throw std::invalid_argument(
                    std::string("Array contents are malformed: ") + e.what());
        }
 
        return {size, stride};
    }
 
    void generateNamesToOffsets(const std::vector<std::pair<size_t, size_t>>
                                &dims_info,
                                size_t current_dim,
                                std::vector<size_t> *indices,
                                std::map<std::string, size_t>
                                *names_to_offsets) const {
        if (current_dim == dims_info.size()) {
            // We have reached the innermost dimension, so generate the name
            // and offset and add it to the vector
            std::string name {base_name()};
            size_t offset = 0;
            for (size_t i = 0; i < indices->size(); i++) {
                name += "[" + std::to_string((*indices)[i]) + "]";
                offset += (*indices)[i] * dims_info[i].second;
            }
            (*names_to_offsets)[name] = offset;
        } else {
            // Iterate over each index of the current dimension and recurse
            for (size_t i = 0; i < dims_info[current_dim].first; i++) {
                (*indices)[current_dim] = i;
                generateNamesToOffsets(dims_info, current_dim + 1,
                                       indices, names_to_offsets);
            }
        }
    }
};
 
}  // namespace detail
}  // namespace simics
 
#endif