From fe721162acdf79afe32a912960642628a3ba5288 Mon Sep 17 00:00:00 2001
From: codeboss <2422523675@qq.com>
Date: Sat, 16 Nov 2024 21:37:42 +0800
Subject: [PATCH] Rename
---
PenetrateBasic/PenetrateBasic.vcxproj | 2 +
PenetrateBasic/PenetrateBasic.vcxproj.filters | 6 +
PenetrateBasic/data_types.h | 37 +++++--
PenetrateBasic/validate_impl.h | 95 ++++++++++++++++
PenetrateBasic/validation.h | 104 ++++++++----------
5 files changed, 180 insertions(+), 64 deletions(-)
create mode 100644 PenetrateBasic/validate_impl.h
diff --git a/PenetrateBasic/PenetrateBasic.vcxproj b/PenetrateBasic/PenetrateBasic.vcxproj
index 37024de..381ea67 100644
--- a/PenetrateBasic/PenetrateBasic.vcxproj
+++ b/PenetrateBasic/PenetrateBasic.vcxproj
@@ -102,6 +102,8 @@
+
+
diff --git a/PenetrateBasic/PenetrateBasic.vcxproj.filters b/PenetrateBasic/PenetrateBasic.vcxproj.filters
index a7a99b8..01c677c 100644
--- a/PenetrateBasic/PenetrateBasic.vcxproj.filters
+++ b/PenetrateBasic/PenetrateBasic.vcxproj.filters
@@ -49,5 +49,11 @@
Header Files
+
+ Header Files
+
+
+ Header Files
+
\ No newline at end of file
diff --git a/PenetrateBasic/data_types.h b/PenetrateBasic/data_types.h
index 309b411..a879b8e 100644
--- a/PenetrateBasic/data_types.h
+++ b/PenetrateBasic/data_types.h
@@ -1,31 +1,52 @@
#pragma once
#include
+#include
namespace datas {
-
class IDataArray;
class IDataObject {
public:
virtual ~IDataObject() = default;
- virtual bool isValid() const = 0;
+ /**
+ * @brief 是否空对象.
+ *
+ * \return 结果
+ */
+ virtual bool isEmpty() const = 0;
+ /**
+ * @brief 当前对象是否是Array.
+ *
+ * \return 结果
+ */
virtual bool isArray() const = 0;
- virtual IDataArray toArray() = 0;
+ /**
+ * @brief 转换成Array.
+ *
+ * \return
+ */
+ virtual std::shared_ptr toArray() = 0;
virtual bool getBool(const QString& key) const = 0;
virtual double getDouble(const QString& key) const = 0;
virtual int32_t getInt32(const QString& key) const = 0;
virtual int64_t getInt64(const QString& key) const = 0;
virtual QString getString(const QString& key) const = 0;
- virtual IDataObject getObject(const QString& key) const = 0;
+ /**
+ * @brief 获取指定对象，若无指定对象则返回一个不关联的空对象.
+ *
+ * \param key
+ * \return
+ */
+ virtual std::shared_ptr getObject(const QString& key) const = 0;
virtual void setBool(const QString& key, bool value) = 0;
virtual void setDouble(const QString& key, double value) = 0;
virtual void setInt32(const QString& key, int32_t value) = 0;
virtual void setInt64(const QString& key, int64_t value) = 0;
virtual void setString(const QString& key, const QString& value) = 0;
- virtual void setObject(const QString& key, IDataObject value) = 0;
+ virtual void setObject(const QString& key, std::shared_ptr value) = 0;
virtual QString toText() const = 0;
virtual void loadFrom(const QString &text) = 0;
@@ -37,9 +58,9 @@ namespace datas {
virtual bool isValid() const = 0;
virtual int32_t size() const = 0;
- virtual IDataObject get(int index) const = 0;
- virtual void insert(int index, IDataObject value) = 0;
- virtual void append(IDataObject value) = 0;
+ virtual std::shared_ptr get(int index) const = 0;
+ virtual void insert(int index, std::shared_ptr value) = 0;
+ virtual void append(std::shared_ptr value) = 0;
};
diff --git a/PenetrateBasic/validate_impl.h b/PenetrateBasic/validate_impl.h
new file mode 100644
index 0000000..c07840d
--- /dev/null
+++ b/PenetrateBasic/validate_impl.h
@@ -0,0 +1,95 @@
+#pragma once
+
+#include "validation.h"
+
+namespace impls {
+ template
+ class DoubleLimit : public validate::Validator {
+ private:
+ QString _name_store;
+ double _limit_max, _limit_min;
+ int64_t _limit_max_times = 0, _limit_min_times = 0;
+
+ public:
+ DoubleLimit(const QString& name, double min, double max)
+ : _name_store(name), _limit_max(max), _limit_min(min) {
+ _limit_min_times = static_cast(min * precision) - min_equal;
+ _limit_max_times = static_cast(max * precision) + max_equal;
+ }
+
+
+ virtual bool check(double value) const {
+ auto value_times = static_cast(value * precision);
+ return _limit_min_times < value_times && value_times < _limit_max_times;
+ }
+
+ virtual void getDepict(datas::IDataObject& self_description) {
+ self_description.setString(u8"ValidatorName", _name_store);
+ self_description.setString(u8"ValueType", u8"Double");
+ self_description.setInt64(u8"Precision", precision);
+ self_description.setDouble(u8"MinValue", _limit_min);
+ self_description.setDouble(u8"MaxValue", _limit_max);
+
+ auto description = QString(u8"%1 %3 value %4 %2").arg(_limit_min).arg(_limit_max);
+ description = description.arg(min_equal ? u8"<=" : u8"<", max_equal ? u8"<=" : u8"<");
+ self_description.setString(u8"Description", description);
+ }
+ };
+
+ template
+ class IntegerLimit : public validate::Validator {
+ private:
+ QString _name_store;
+ int64_t _limit_max, _limit_min;
+ int64_t _limit_max_times = 0, _limit_min_times = 0;
+
+ public:
+ IntegerLimit(const QString& name, int64_t min, int64_t max)
+ : _name_store(name), _limit_min(min), _limit_max(max) {
+ _limit_max_times = _limit_max + max_equal;
+ _limit_min_times = _limit_min - min_equal;
+ }
+
+
+ virtual bool check(int64_t value) const {
+ return _limit_min_times < value && value < _limit_max_times;
+ }
+
+ virtual void getDepict(datas::IDataObject& self_description) {
+ self_description.setString(u8"ValidatorName", _name_store);
+ self_description.setString(u8"ValueType", u8"Integer");
+ self_description.setInt64(u8"MinValue", _limit_min);
+ self_description.setInt64(u8"MaxValue", _limit_max);
+
+ auto description = QString(u8"%1 %3 value %4 %2").arg(_limit_min).arg(_limit_max);
+ description = description.arg(min_equal ? u8"<=" : u8"<", max_equal ? u8"<=" : u8"<");
+ self_description.setString(u8"Description", description);
+ }
+ };
+
+ class EnumsValidator : public validate::Validator {
+ private:
+ QString _name_store;
+ QList _enum_options;
+
+ public:
+ EnumsValidator(const QString& name, const QList& list)
+ :_name_store(name), _enum_options(list) { }
+
+ virtual bool check(int32_t value) const {
+ return _enum_options.contains(value);
+ }
+
+ virtual void getDepict(datas::IDataObject& self_description) {
+ self_description.setString(u8"ValidatorName", _name_store);
+ self_description.setString(u8"ValueType", u8"Enum");
+
+ QStringList options;
+ std::transform(_enum_options.begin(), _enum_options.end(), std::back_inserter(options), [](int32_t v) {return QString::number(v); });
+ self_description.setString(u8"Values", options.join(u8","));
+ self_description.setString(u8"Description", QString("value ∈ { %1 }").arg(options.join(u8",")));
+ }
+ };
+
+
+}
diff --git a/PenetrateBasic/validation.h b/PenetrateBasic/validation.h
index bc2f359..e3bfdc0 100644
--- a/PenetrateBasic/validation.h
+++ b/PenetrateBasic/validation.h
@@ -4,37 +4,34 @@
#include
#include
#include
+#include "data_types.h"
namespace validate {
- template class validator {
+ template class Validator {
public:
virtual bool check(T value) const {
return false;
}
+ virtual void getDepict(datas::IDataObject& self_description) { }
};
- template class validator_receiver {
+ template class ValidatorReceiver {
public:
- virtual void append(validator inst) { }
+ virtual void append(Validator inst) { }
};
- template struct check_delegation;
- template<> struct check_delegation<> {
-
- void prest() {
- std::cout << "ends" << std::endl;
- }
- };
+ template struct ValidateTemplet;
+ template<> struct ValidateTemplet<> { };
template
- struct check_delegation : public check_delegation {
+ struct ValidateTemplet : public ValidateTemplet {
private:
- QList> validator_list;
+ QList> validator_list;
public:
- void add(validator vinst) {
+ void add(Validator vinst) {
validator_list << vinst;
}
bool check(head_type value) {
@@ -43,48 +40,43 @@ namespace validate {
return false;
return true;
}
-
- void prest() {
- std::cout << "[-]" << validator_list.size() << std::endl;
- check_delegation::prest();
- }
};
- template struct elm_pos;
+ template struct ElmPos;
template
- struct elm_pos<0, check_delegation> {
+ struct ElmPos<0, ValidateTemplet> {
using value_type = head_type;
- using templet_type = check_delegation;
+ using templet_type = ValidateTemplet;
};
template
- struct elm_pos> {
- using value_type = typename elm_pos>::value_type;
- using templet_type = typename elm_pos>::templet_type;
+ struct ElmPos> {
+ using value_type = typename ElmPos>::value_type;
+ using templet_type = typename ElmPos>::templet_type;
};
template
- void __validator_insert_helper(check_delegation& target,
- validator>::value_type> inst) {
- using templet_type = typename elm_pos>::templet_type;
+ void __validator_insert_helper(ValidateTemplet& target,
+ Validator>::value_type> inst) {
+ using templet_type = typename ElmPos>::templet_type;
target.templet_type::add(inst);
}
- template class slice_position;
+ template class SlicePosition;
- template class slice_validator : public validator {
+ template class SliceValidator : public Validator {
private:
std::function _proc_conv;
- validator _sub_validator;
+ Validator _sub_validator;
public:
- slice_validator(std::function proc, validator vinst)
+ SliceValidator(std::function proc, Validator vinst)
: _proc_conv(proc), _sub_validator(vinst) { }
virtual bool check(S value) const {
@@ -92,68 +84,68 @@ namespace validate {
return _sub_validator.check(t_value);
}
};
- template class args_position
- : public validator_receiver>::value_type> {
+ template class ArgsPosition
+ : public ValidatorReceiver>::value_type> {
public:
- using param_type = typename elm_pos>::value_type;
+ using param_type = typename ElmPos>::value_type;
- args_position(check_delegation& target) :_templet_bind(target) { }
+ ArgsPosition(ValidateTemplet& target) :_templet_bind(target) { }
- args_position& operator&(validator vinst) {
+ ArgsPosition& operator&(Validator vinst) {
append(vinst);
return *this;
}
template
- slice_position>
- slice(std::function slice_fun) {
- return slice_position>(*this, slice_fun);
+ SlicePosition>
+ slice(std::function slice_fun) {
+ return SlicePosition>(*this, slice_fun);
}
- // validator_receiver
- virtual void append(validator inst) {
+ // ValidatorReceiver
+ virtual void append(Validator inst) {
__validator_insert_helper(_templet_bind, inst);
}
private:
- check_delegation& _templet_bind;
+ ValidateTemplet& _templet_bind;
};
template
- class slice_position> : public validator_receiver {
+ class SlicePosition> : public ValidatorReceiver {
public:
- slice_position(validator_receiver& host, std::function func)
+ SlicePosition(ValidatorReceiver& host, std::function func)
:_conv_func(func), _prev_bind(host) { }
- slice_position>& operator&(validator vinst) {
+ SlicePosition>& operator&(Validator vinst) {
append(vinst);
return *this;
}
template
- slice_position>
- slice(std::function slice_fun) {
- return slice_position>(*this, slice_fun);
+ SlicePosition>
+ slice(std::function slice_fun) {
+ return SlicePosition>(*this, slice_fun);
}
- // validator_receiver
- virtual void append(validator inst) {
- slice_validator mid_validator(_conv_func, inst);
+ // ValidatorReceiver
+ virtual void append(Validator inst) {
+ SliceValidator mid_validator(_conv_func, inst);
_prev_bind.append(mid_validator);
}
private:
std::function _conv_func;
- validator_receiver& _prev_bind;
+ ValidatorReceiver& _prev_bind;
};
- template struct validate_helper;
+ template struct ValidateHelper;
template
- struct validate_helper : public check_delegation {
- template args_position pos() {
- return args_position(*this);
+ struct ValidateHelper : public ValidateTemplet {
+ template ArgsPosition pos() {
+ return ArgsPosition(*this);
}
};