scope.hpp

浏览该文件的文档.

/*
 * @Description: 作用域 头文件及其实现
 * @Version:
 * @Autor: dreamy-xay
 * @date: 2023-12-06
 * @LastEditors: dreamy-xay
 * @LastEditTime: 2024-03-04
 */
 
#ifndef COMMON_SCOPE_HPP
#define COMMON_SCOPE_HPP
 
#include <iostream>
#include <stack>
#include <string>
#include <unordered_map>
 
#include "common/enum.h"
#include "common/macro.h"
#include "common/type.h"
 
namespace cm {
 
template <typename T>
class Scope {
   private:
    std::unordered_map<std::string, T> scope_table;  // 作用域表
    std::string activated_scope_name;                // 当前被激活的作用域名称
    std::string initial_scope_name;                  // 最初的作用域名称（构造函数构造时的初始化作用域）
 
    std::stack<std::string> scope_switch_record;  // 作用域切换记录栈
 
   public:
    Scope(const std::string& scope_name = "__INITIAL__");
    Scope(const Scope<T>& scope);
    ~Scope();
 
    template <typename U>
    friend std::ostream& operator<<(std::ostream& out, const Scope<U>& scope);
 
    T& Value();
    Scope& Set(const std::string& scope_name, T value);
    Scope& Switch(const std::string& scope_name);
    Scope& Finish();
    Scope& Exit();
    bool Has(const std::string& scope_name) const;
    bool IsInitial() const;
};
 
template <typename T>
inline Scope<T>::Scope(const std::string& initial_scope_name) : activated_scope_name(initial_scope_name), initial_scope_name(initial_scope_name) {
    scope_table[initial_scope_name] = T();            // 更新作用域表，默认激活初始作用域
    scope_switch_record.emplace(initial_scope_name);  // 最初的作用域入栈
}
 
template <typename T>
inline Scope<T>::Scope(const Scope<T>& scope) : scope_table(scope.scope_table), activated_scope_name(scope.activated_scope_name), initial_scope_name(scope.initial_scope_name), scope_switch_record(scope.scope_switch_record) {}
 
template <typename T>
inline Scope<T>::~Scope() {}
 
template <typename U>
inline std::ostream& operator<<(std::ostream& out, const Scope<U>& scope) {
    out << "{ activated scope: \"" << scope.activated_scope_name << "\" }";
 
    return out;
}
 
template <typename T>
inline T& Scope<T>::Value() {
    return scope_table[activated_scope_name];  // 返回引用值，可修改
}
 
template <typename T>
inline Scope<T>& Scope<T>::Set(const std::string& scope_name, T value) {
    scope_table[scope_name] = value;  // 如果存在作用域，则修改，如果不存在，则添加
 
    return *this;
}
 
template <typename T>
inline Scope<T>& Scope<T>::Switch(const std::string& scope_name) {
    if (!scope_table.count(scope_name))  // 如果不存在该作用域
        scope_table[scope_name] = T();   // 作用域将被创建，值为T的默认构造
 
    activated_scope_name = scope_name;                  // 激活被切换的作用域
    scope_switch_record.emplace(activated_scope_name);  // 被激活的作用域入栈
 
    return *this;
}
 
template <typename T>
inline Scope<T>& Scope<T>::Finish() {
    if (scope_switch_record.size() <= 1)  // 保证栈底始终存在一个元素，即最初的作用域始终不出栈
        return *this;
 
    scope_switch_record.pop();                         // 作用域切换记录栈 栈顶元素出栈
    activated_scope_name = scope_switch_record.top();  // 激活出栈后的栈顶作用域
 
    return *this;
}
 
template <typename T>
inline Scope<T>& Scope<T>::Exit() {
    activated_scope_name = initial_scope_name;  // 激活最初作用域
 
    while (scope_switch_record.size() > 1)  // 清空作用域切换记录栈，保证栈底始终存在一个元素，即最初的作用域始终在栈底
        scope_switch_record.pop();
 
    return *this;
}
 
template <typename T>
inline bool Scope<T>::Has(const std::string& scope_name) const {
    return scope_table.count(scope_name);
}
 
template <typename T>
inline bool Scope<T>::IsInitial() const {
    return activated_scope_name == initial_scope_name;
}
 
}  // namespace cm
 
#endif