#pragma once
#include <iostream>
#include "pugixml
.hpp"
#include <vector>
#include <unordered_map>
#include <memory>
#include <mutex>
extern pugi::xml_document doc; //存储配置文件信息
extern bool parse_config
();
//上下文管理
struct Context
{
std::mutex mtx;
public:
void set
(const std::string& key, const std::string& value)
{
ContextMap[key] = value;
}
void safeMethod
() {
// 安全操作
...
}
std::string get
(const std::string& key)const
{
auto it = ContextMap
.find
(key
);
if
(it == ContextMap
.end
())
{
throw std::runtime_error
("key : " + key + " not found"
);
}
return it->second;
}
private:
std::unordered_map<std::string, std::string> ContextMap;
};
#pragma once
#include "Context
.h"
#include <iostream>
class any
{
public :
any
() = default;
~any
() = default;
//any禁止左值引用的拷贝和左值引用的赋值
any
(const any&) = delete;
any& operator=
(const any&) = delete;
//any允许右值引用的拷贝和右值引用的赋值
any
(any&&) = default;
any& operator=
(any&&) = default;
//any的构造函数写成模板，传过来的任意数据类型通过基类指针传给派生类
template <typename T>
any
(T data) : base_
(std::make_unique<Derive<T>>
(data)) {};
//提取出any对象中的data_数据
template <typename T>
T cast_
()
{
//cast_函数功能：从base_指向的Derive对象取出data_
//基类指针 转为 派生类指针。需要确保该基类指针确实指向某派生类
//get
()方法为库函数，旨在获取智能指针中的裸指针
Derive<T>* pd =
dynamic_cast<Derive<T*>>
(base_
.get
()
);
if
(pd == nullptr)
{
throw "cast_ : 请提供正确的类型！";
}
return pd->data_;
}
private :
//基类类型
class Base
{
virtual ~Base
() = default;
};
//派生类类型，定于为模板才可以接收任意数据类型
template <typename T>
class Derive : public Base
{
public:
Derive
(T data) : data_
(data) {};
T data_;//存放实际接受的数据
};
private :
std::unique_ptr<Base> base_;
};
//组件基类
class Component
{
public:
virtual ~Component
() = default;
virtual bool execute
(Context& ctx) = 0;
};
using ComponentPtr = std::shared_ptr<Component>; #pragma once
#include "component
.hpp"
#include <unordered_map>
#include <mutex>
//组件注册表
class ComponentRegistry
{
public:
static ComponentRegistry& instance
()
{
static ComponentRegistry registry;
return registry;
}
template <typename T>
void registerComponent
(const std::string& name)
{
std::lock_guard<std::mutex> lock
(m_mutex
);
components
()[name] = std::make_unique<T>
();
}
Component* getComponent
(const std::string& name)
{
std::lock_guard<std::mutex> lock
(m_mutex
);
auto it = components
()
.find
(name
);
return
(it != components
()
.end
()) ? it->second
.get
() : nullptr;
}
// 禁止拷贝和赋值
ComponentRegistry
(const ComponentRegistry&) = delete;
ComponentRegistry& operator=
(const ComponentRegistry&) = delete;
private:
// 私有构造函数（单例模式）
ComponentRegistry
() = default;
~ComponentRegistry
() = default;
// 存储组件的线程安全容器
using ComponentMap = std::unordered_map<std::string, std::unique_ptr<Component>>;
ComponentMap& components
() {
static ComponentMap instance;
return instance;
}
std::mutex m_mutex; // 互斥锁
};
#pragma once
#include "Context
.h"
//EL表达式基类
class ExpressionNode
{
public:
virtual ~ExpressionNode
() = default;
virtual void execute
(Context& ctx) = 0;
};
#include "IfNode
.h"
IfNode::IfNode
(std::string name,std::unique_ptr<ExpressionNode> thenBranch, std::unique_ptr<ExpressionNode> elseBranch)
:thenBranch
(std::move
(thenBranch)),
elseBranch
(std::move
(elseBranch))
{
component = ComponentRegistry::instance
()
.getComponent
(name
);
if
(!component)
{
std::cerr << "no component ! " << std::endl;
}
}
void IfNode::execute
(Context& ctx)
{
if
(component->execute
(ctx))
{
thenBranch->execute
(ctx
);
}
else
{
elseBranch->execute
(ctx
);
}
}
#include "SingleNode
.h"
SingleNode::SingleNode
(const std::string& name)
{
component = ComponentRegistry::instance
()
.getComponent
(name
);
if
(!component)
{
std::cerr << "no component ! " << std::endl;
}
}
void SingleNode::execute
(Context& ctx)
{
component->execute
(ctx
);
}
#include "ThenNode
.h"
ThenNode::ThenNode
(std::vector<std::unique_ptr<ExpressionNode>>&& nodes)
:children
(std::move
(nodes))
{
}
void ThenNode::execute
(Context& ctx)
{
for
(auto& child : children)
{
child->execute
(ctx
);
}
}
#include "WhenNode
.h"
WhenNode::WhenNode
(std::vector<std::unique_ptr<ExpressionNode>> children)
: children_
(std::move
(children))
{
}
void WhenNode::execute
(Context& ctx) {
std::vector<std::future<void>> futures;
// 并行执行所有子节点
for
(auto& child : children_) {
futures
.emplace_back
(std::async
(std::launch::async,
[&] { child->execute
(ctx
); })
);
}
// 等待所有任务完成
for
(auto& future : futures) {
future
.get
();
}
} #include "Parser
.h"
#include <algorithm>
#include <stdexcept>
#include <sstream>
#include <iostream>
#include"SingleNode
.h"
#include"Context
.h"
#include"IfNode
.h"
#include"ThenNode
.h"
#include"WhenNode
.h"
#include"AndNode
.h"
#include"NotNode
.h"
#include"OrNode
.h"
using namespace std;
unique_ptr<ExpressionNode> Parser::parse
(const string& expr) {
string cleaned = trim
(expr
.substr
(expr
.find
('
(') + 1, expr
.rfind
(')') - expr
.find
('
(') - 1)
);
return parseExpression
(cleaned
);
}
unique_ptr<ExpressionNode> Parser::parseSingleNode
(const string& expr) {
if
(expr
.find
("THEN
(") != 0 && expr
.find
("IF
(") != 0 &&
expr
.find
("WHEN
(") != 0 && expr
.find
("AND
(") != 0 &&
expr
.find
("OR
(") != 0 && expr
.find
("NOT
(") != 0) {
return make_unique<SingleNode>
(expr
);
}
return parseExpression
(expr
);
}
unique_ptr<ExpressionNode> Parser::parseIfExpression
(const string& expr) {
size_t comma1 = findMatchingBracket
(expr, 0
);
string condition = trim
(expr
.substr
(0, comma1)
);
size_t comma
2 = findMatchingBracket
(expr, comma1 + 1
);
string thenPart = trim
(expr
.substr
(comma1 + 1, comma
2 - comma1 - 1)
);
string elsePart = trim
(expr
.substr
(comma
2 + 1)
);
auto conditionNode = parseLogicalExpression
(condition
);
return make_unique<IfNode>
(condition, move
(conditionNode),
elsePart
.empty
() ? nullptr : parseExpression
(elsePart)
);
}
unique_ptr<ExpressionNode> Parser::parseThenExpression
(const string& expr) {
vector<unique_ptr<ExpressionNode>> children;
size_t pos = 0;
while
(pos < expr
.size
()) {
size_t end = findMatchingBracket
(expr, pos
);
string item = expr
.substr
(pos, end - pos
);
children
.push_back
(parseExpression
(trim
(item))
);
pos =
(end == string::npos) ? expr
.size
() : end + 1;
}
return make_unique<ThenNode>
(move
(children)
);
}
unique_ptr<ExpressionNode> Parser::parseWhenExpression
(const string& expr) {
vector<unique_ptr<ExpressionNode>> children;
auto parts = splitComponents
(expr
);
for
(const auto& part : parts) {
children
.push_back
(parseExpression
(trim
(part))
);
}
return make_unique<WhenNode>
(move
(children)
);
}
vector<string> Parser::splitComponents
(const string& expr) {
vector<string> parts;
int bracketCount = 0;
size_t start = 0;
for
(size_t i = 0; i < expr
.size
(); ++i) {
char c = expr[i];
if
(c == '
(') {
bracketCount++;
}
else if
(c == ')') {
bracketCount--;
}
else if
(c == ',' && bracketCount == 0) {
string part = expr
.substr
(start, i - start
);
parts
.push_back
(trim
(part)
);
start = i + 1;
}
}
if
(start < expr
.size
()) {
string lastPart = expr
.substr
(start
);
parts
.push_back
(trim
(lastPart)
);
}
return parts;
}
unique_ptr<ExpressionNode> Parser::parseExpression
(const string& expr) {
try {
string trimmed = trim
(expr
);
if
(trimmed
.empty
()) {
throw runtime_error
("Empty expression"
);
}
if
(startsWith
(trimmed, "THEN
(")) {
return parseThenExpression
(trimmed
.substr
(5, trimmed
.size
() - 6)
);
}
if
(startsWith
(trimmed, "IF
(")) {
return parseIfExpression
(trimmed
.substr
(3, trimmed
.size
() - 4)
);
}
if
(startsWith
(trimmed, "WHEN
(") || startsWith
(trimmed, "PAR
(")) {
return parseWhenExpression
(trimmed
.substr
(5, trimmed
.size
() - 6)
);
}
if
(startsWith
(trimmed, "AND
(")) {
return parseAndExpression
(trimmed
.substr
(4, trimmed
.size
() - 5)
);
}
if
(startsWith
(trimmed, "OR
(")) {
return parseOrExpression
(trimmed
.substr
(3, trimmed
.size
() - 4)
);
}
if
(startsWith
(trimmed, "NOT
(")) {
return parseNotExpression
(trimmed
.substr
(4, trimmed
.size
() - 5)
);
}
return parseSingleNode
(trimmed
);
}
catch
(const exception& e) {
cerr << "Parse EL error: " << e
.what
() << endl;
throw;
}
}
// 新增逻辑表达式解析方法
unique_ptr<ExpressionNode> Parser::parseLogicalExpression
(const string& expr) {
string trimmed = trim
(expr
);
if
(startsWith
(trimmed, "AND
(")) {
return parseAndExpression
(trimmed
.substr
(4, trimmed
.size
() - 5)
);
}
if
(startsWith
(trimmed, "OR
(")) {
return parseOrExpression
(trimmed
.substr
(3, trimmed
.size
() - 4)
);
}
if
(startsWith
(trimmed, "NOT
(")) {
return parseNotExpression
(trimmed
.substr
(4, trimmed
.size
() - 5)
);
}
return parseSingleNode
(trimmed
);
}
unique_ptr<ExpressionNode> Parser::parseAndExpression
(const string& expr) {
auto parts = splitComponents
(expr
);
vector<unique_ptr<ExpressionNode>> children;
for
(const auto& part : parts) {
children
.push_back
(parseLogicalExpression
(trim
(part))
);
}
return make_unique<AndNode>
(move
(children)
);
}
unique_ptr<ExpressionNode> Parser::parseOrExpression
(const string& expr) {
auto parts = splitComponents
(expr
);
vector<unique_ptr<ExpressionNode>> children;
for
(const auto& part : parts) {
children
.push_back
(parseLogicalExpression
(trim
(part))
);
}
return make_unique<OrNode>
(move
(children)
);
}
unique_ptr<ExpressionNode> Parser::parseNotExpression
(const string& expr) {
// 确保NOT表达式只有一个参数
auto parts = splitComponents
(expr
);
if
(parts
.size
() != 1) {
throw runtime_error
("NOT expression requires exactly one argument"
);
}
return make_unique<NotNode>
(parseLogicalExpression
(trim
(parts[0]))
);
}
// 辅助函数
bool Parser::startsWith
(const string& str, const string& prefix) {
return str
.compare
(0, prefix
.length
(), prefix) == 0;
}
size_t Parser::findMatchingBracket
(const string& expr, size_t start) {
int balance = 0;
for
(size_t i = start; i < expr
.size
(); ++i) {
if
(expr[i] == '
(') balance++;
else if
(expr[i] == ')') balance--;
else if
(expr[i] == ',' && balance == 0) {
return i;
}
}
return string::npos;
}
string Parser::trim
(const string& s) {
size_t start = s
.find_first_not_of
(" \t\n\r"
);
size_t end = s
.find_last_not_of
(" \t\n\r"
);
return
(start == string::npos) ? "" : s
.substr
(start, end - start + 1
);
}
提供了与或非表达式，就是AND，OR，NOT表达式。通过之前的几小章，应该可以知道，有些编排需要返回一个布尔值，比如条件编排：
<chain name="chain1">
IF
(x, a, b
);
</chain>
其中x组件应该为布尔组件，返回的是一个布尔值。但是如果这个布尔值并不是由一个组件决定的，而是由多个组件决定的呢。这里就可以用与或非表达式了。假设这里的条件是要由x和y共同决定，利用与或非表达式中的AND:
<chain name="chain1">
IF
(AND
(x,y), a, b
);
</chain>
上述AND的意思是，如果x和y都为true，则为真，会执行组件a，如果x和y有一个为false，则执行b。
AND里面可以有多个布尔组件或者与或非表达式。同理，这里也可以用OR来表示：
<chain name="chain1">
IF
(OR
(x,y), a, b
);
</chain>
上述OR的意思是，只要x和y中的一个为true，则为真，否则为假。OR里面可以有多个组件或者与或非表达式。NOT就是非的意思，比如：
<chain name="chain1">
IF
(NOT
(x), a, b
);
</chain>
如果x返回true，则经过非运算后，为假，执行b，如果x返回false，则经过非运算后，为真，执行a。NOT里面只能有一个布尔组件或者与或非表达式。 怎样修改parse并增加新的弄得文件内容
本文通过三个示例详细解释了C++中模板和多态性的应用，包括使用typeid函数获取类型信息、模板参数、类继承和多态性的区别与实现。
扫一扫
2983
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
