/// <summary>
/// 检查列表中数据是否在引用表中存在
/// </summary>
private bool Check(FList data, RefRule rule)
{
bool isOk = true;
var list = data.Values;
for (int i = 0; i < list.Count; i++)
{
isOk &= Check(list[i], rule);
}
return(isOk);
}
private bool Check(FDict data, RefRule rule, RuleInfo info)
{
bool isOk = true;
var dict = data.Values;
foreach (var item in dict)
{
if (info._isKey)
{
isOk &= Check(item.Key, rule);
}
if (info._isValue)
{
isOk &= Check(item.Value, rule);
}
}
return(isOk);
}
public static IRule Parse(JToken token)
{
switch (token.Type)
{
case JTokenType.String:
return(new RefRule(token.Path, token.Value <string>()));
case JTokenType.Object:
RuleType type = (RuleType)Enum.Parse(
typeof(RuleType),
token["type"].Value <string>(),
ignoreCase: true);
return(type switch
{
RuleType.AllOf => AllOfRule.Parse(token),
RuleType.OneOf => OneOfRule.Parse(token),
RuleType.If => IfRule.Parse(token),
RuleType.Sound => SoundRule.Parse(token),
RuleType.Ref => RefRule.Parse(token),
_ => throw new Exception($"Unknown rule type {type}"),
});
public override bool VerifyRule()
{
bool isOk = base.VerifyRule();
_refs = new RefRule[_ruleTable.Length];
for (int i = 0; i < _ruleTable.Length; i++)
{
RuleInfo info = _ruleTable[i];
string rule = info._rule;
if (rule.IsEmpty())
{
Warning($"Ref检查规则:表达式为空");
isOk = false;
}
else
{
string[] nodes = rule.Split(Setting.DotSplit, System.StringSplitOptions.RemoveEmptyEntries);
if (nodes.Length == 3)
{
RefRule refr = new RefRule();
string targetName = $"{nodes[0]}.{nodes[1]}";
if (!ConfigWrap.IsConfig(targetName))
{
Warning($"Ref检查规则:目标{targetName}配置表无法获取!");
isOk = false;
}
refr._target = ConfigWrap.Get(targetName);
refr._targetField = nodes[2];
if (refr._target == null)
{
Warning("Ref检查规则:仅支持引用表结构最外层基础类型字段数据");
isOk = false;
}
else
{
var targetCls = ClassWrap.Get(targetName);
var define = targetCls.Fields.Find(field => field.Name == refr._targetField);
if (define.IsContainer)
{
if (define.OriginalType == Setting.LIST &&
define.GetItemDefine().IsClass)
{
Warning($"Ref检查规则:由于多态的复杂性,不支持list中数据类型为Class!仅支持基础类型.");
isOk = false;
}
else if (define.OriginalType == Setting.DICT &&
define.GetValueDefine().IsClass)
{
Warning($"Ref检查规则:由于多态的复杂性,不支持dict.value数据类型为Class!仅支持基础类型.");
isOk = false;
}
}
else if (define.IsEnum || define.IsRaw)
{
}
else
{
Warning($"Ref检查规则:由于多态的复杂性,不支持数据类型为Class!仅支持基础类型.");
isOk = false;
}
}
_refs[i] = refr;
}
else
{
Warning($"Ref检查规则:格式错误,正确格式[Namespace.Class.Field]");
isOk = false;
}
}
}
return(isOk);
}
private bool Check(Data data, RefRule rule)
{
return(rule._hash.Contains(data));
}
