private void _GetMapElement(MapStringRequiredInfo requiredInfo, MapStringInfo formatDefine, out string errorString)
{
// 解析key
if (_tokenQueue.Count == 0)
{
errorString = "定义不完整";
return;
}
MapStringToken keyToken = _tokenQueue.Dequeue();
if (keyToken.TokenType != MapStringTokenType.String)
{
errorString = string.Concat("map子元素中的key名非法，输入值为", keyToken.DefineString);
return;
}
string key = keyToken.DefineString.Trim();
// 检查该变量名是否定义
if (!formatDefine.ParamInfo.ContainsKey(key))
{
errorString = string.Format("mapString定义中不存在名为{0}的key", key);
return;
}
// 检查是否已存在此变量名
MapStringParamInfo paramInfo = formatDefine.ParamInfo[key];
if (requiredInfo.ParamRequiredInfo.ContainsKey(key))
{
errorString = string.Format("定义中存在相同的key名（{0}）", key);
return;
}
// 判断key名后是否为等号
if (_tokenQueue.Count == 0)
{
errorString = string.Format("定义不完整，map子元素中的key名（{0}）后缺失等号", key);
return;
}
MapStringToken equalSignToken = _tokenQueue.Dequeue();
if (equalSignToken.TokenType != MapStringTokenType.EqualSign)
{
errorString = string.Concat("map子元素中的key名（{0}）后应为等号，而输入值为{1}", key, equalSignToken.DefineString);
return;
}
// 解析value值
if (_tokenQueue.Count == 0)
{
errorString = string.Format("定义不完整，map子元素中的key名（{0}）在等号后未声明参数要求，请用1声明为必须存在或用0声明为不允许存在", key);
return;
}
MapStringToken valueToken = _tokenQueue.Dequeue();
if (valueToken.TokenType == MapStringTokenType.Number)
{
if ("1".Equals(valueToken.DefineString))
{
MapStringParamRequiredInfo paramRequiredInfo = new MapStringParamRequiredInfo();
paramRequiredInfo.ParamName = key;
paramRequiredInfo.ParamRequired = ParamRequired.MustHave;
requiredInfo.ParamRequiredInfo.Add(key, paramRequiredInfo);
}
else if ("0".Equals(valueToken.DefineString))
{
MapStringParamRequiredInfo paramRequiredInfo = new MapStringParamRequiredInfo();
paramRequiredInfo.ParamName = key;
paramRequiredInfo.ParamRequired = ParamRequired.NotAllowed;
requiredInfo.ParamRequiredInfo.Add(key, paramRequiredInfo);
}
else
{
errorString = string.Format("map子元素中的key名（{0}）对应的参数要求非法，输入值为\"{1}\"，请用1或0分别设置该参数为必须含有或不允许含有", keyToken.DefineString);
return;
}
}
else if (valueToken.TokenType == MapStringTokenType.StartMap)
{
if (paramInfo.DataType == DataType.MapString)
{
MapStringRequiredInfo childRequiredInfo = new MapStringRequiredInfo();
_GetMapElement(childRequiredInfo, formatDefine.ParamInfo[key].MapStringInfo, out errorString);
if (errorString != null)
{
errorString = string.Format("名为{0}的map下属的子元素错误：{1}", key, errorString);
return;
}
MapStringParamRequiredInfo paramRequiredInfo = new MapStringParamRequiredInfo();
paramRequiredInfo.ParamName = key;
paramRequiredInfo.ParamRequired = ParamRequired.None;
paramRequiredInfo.MapStringRequiredInfo = childRequiredInfo;
requiredInfo.ParamRequiredInfo.Add(key, paramRequiredInfo);
}
else
{
errorString = string.Format("mapString定义中要求key名（{0}）对应{1}类型的数据，而输入的检查规则却以mapString型进行设置，请不要对非mapString型使用括号声明", key, paramInfo.DataType);
return;
}
}
else
{
errorString = string.Format("map子元素中的key名（{0}）对应的参数要求非法，输入值为\"{1}\"，请用1或0分别设置该参数为必须含有或不允许含有", keyToken.DefineString);
return;
}
// 解析后面的token
if (_tokenQueue.Count == 0)
{
errorString = string.Format("定义不完整，map下的子元素{0}之后未声明用英文逗号分隔下一个子元素，也没有声明map的结束", key);
return;
}
MapStringToken nextToken = _tokenQueue.Dequeue();
if (nextToken.TokenType == MapStringTokenType.EndMap)
{
errorString = null;
return;
}
else if (nextToken.TokenType == MapStringTokenType.Comma)
{
if (_tokenQueue.Count == 0)
{
errorString = string.Format("定义不完整，map下的子元素{0}之后的英文逗号后未声明下一个元素", key);
return;
}
_GetMapElement(requiredInfo, formatDefine, out errorString);
if (errorString != null)
{
errorString = string.Format("名为{0}的子元素后面的元素声明错误：{1}", key, errorString);
return;
}
}
else
{
errorString = string.Format("map下的子元素{0}之后未声明用英文逗号分隔下一个子元素，也没有声明map的结束，输入值为{1}", key, nextToken.DefineString);
return;
}
}
private void _GetMapElement(JsonData jsonData, MapStringInfo formatDefine, out string errorString)
{
// 解析key
if (_tokenQueue.Count == 0)
{
errorString = "mapString数据不完整";
return;
}
MapStringToken keyToken = _tokenQueue.Dequeue();
if (keyToken.TokenType != MapStringTokenType.String && keyToken.TokenType != MapStringTokenType.StringWithQuotationMark)
{
errorString = string.Concat("map子元素中的key名非法，输入值为", keyToken.DefineString);
return;
}
string key = keyToken.DefineString.Trim();
// 检查该变量名是否定义
if (!formatDefine.ParamInfo.ContainsKey(key))
{
errorString = string.Format("mapString定义中不存在名为{0}的key", key);
return;
}
// 检查是否已存在此变量名
MapStringParamInfo paramInfo = formatDefine.ParamInfo[key];
if (jsonData.Keys.Contains(key))
{
errorString = string.Format("mapString数据中存在相同的key名（{0}）", key);
return;
}
// 判断key名后是否为等号
if (_tokenQueue.Count == 0)
{
errorString = string.Format("mapString数据不完整，map子元素中的key名（{0}）后缺失等号", key);
return;
}
MapStringToken equalSignToken = _tokenQueue.Dequeue();
if (equalSignToken.TokenType != MapStringTokenType.EqualSign)
{
errorString = string.Format("map子元素中的key名（{0}）后应为等号，而输入值为{1}", key, equalSignToken.DefineString);
return;
}
// 解析value值
if (_tokenQueue.Count == 0)
{
errorString = string.Format("mapString数据不完整，map子元素中的key名（{0}）在等号后未声明对应的数据值", key);
return;
}
MapStringToken valueToken = _tokenQueue.Dequeue();
if (valueToken.TokenType == MapStringTokenType.StringWithQuotationMark)
{
if (paramInfo.DataType == DataType.String)
{
// 适应LitJson类库的实现，对换行和引号进行处理
jsonData[key] = valueToken.DefineString.Replace("\\n", "\n").Replace("\\\"", "\"");
}
else if (paramInfo.DataType == DataType.Lang)
{
if (AppValues.LangData.ContainsKey(valueToken.DefineString))
{
jsonData[key] = AppValues.LangData[valueToken.DefineString];
}
else
{
errorString = string.Format("mapString数据中key名（{0}）对应的lang型数据的key（{1}）在lang文件中找不到对应的value", key, valueToken.DefineString);
return;
}
}
else if (paramInfo.DataType == DataType.MapString)
{
errorString = string.Format("mapString定义中要求key名（{0}）对应mapString类型的数据，而输入的数据值为\"{1}\"，请按格式要求在英文括号内声明mapString类型的数据", key, valueToken.DefineString);
return;
}
else
{
errorString = string.Format("mapString定义中要求key名（{0}）对应{1}类型的数据，而该类型数据不应该用英文引号包裹，只有string和lang型需要", key, paramInfo.DataType);
return;
}
}
else if (valueToken.TokenType == MapStringTokenType.String)
{
if (paramInfo.DataType == DataType.Bool)
{
if ("true".Equals(valueToken.DefineString, StringComparison.CurrentCultureIgnoreCase))
{
jsonData[key] = true;
}
else if ("false".Equals(valueToken.DefineString, StringComparison.CurrentCultureIgnoreCase))
{
jsonData[key] = false;
}
else
{
errorString = string.Format("mapString定义中要求key名（{0}）对应bool类型的数据，而输入值（{1}）非法，请用数字1、0或true、false进行数据定义", key, valueToken.DefineString);
return;
}
}
else if (paramInfo.DataType == DataType.String || paramInfo.DataType == DataType.Lang)
{
errorString = string.Format("mapString定义中要求key名（{0}）对应{1}类型的数据，而该类型数据必须用英文引号包裹", key, paramInfo.DataType);
return;
}
else if (paramInfo.DataType == DataType.MapString)
{
errorString = string.Format("mapString定义中要求key名（{0}）对应mapString类型的数据，而输入的数据值为\"{1}\"，请按格式要求在英文括号内声明mapString类型的数据", key, valueToken.DefineString);
return;
}
else
{
errorString = string.Format("mapString定义中要求key名（{0}）对应{1}类型的数据，而输入的数据值为\"{2}\"", key, paramInfo.DataType, valueToken.DefineString);
return;
}
}
else if (valueToken.TokenType == MapStringTokenType.Number)
{
if (paramInfo.DataType == DataType.Int)
{
int number = 0;
if (int.TryParse(valueToken.DefineString, out number) == false)
{
errorString = string.Format("mapString定义中要求key名（{0}）对应int类型的数据，而输入值（{1}）非法", key, valueToken.DefineString);
return;
}
jsonData[key] = number;
}
else if (paramInfo.DataType == DataType.Long)
{
long number = 0;
if (long.TryParse(valueToken.DefineString, out number) == false)
{
errorString = string.Format("mapString定义中要求key名（{0}）对应long类型的数据，而输入值（{1}）非法", key, valueToken.DefineString);
return;
}
jsonData[key] = number;
}
else if (paramInfo.DataType == DataType.Float)
{
double number = 0;
if (double.TryParse(valueToken.DefineString, out number) == false)
{
errorString = string.Format("mapString定义中要求key名（{0}）对应float类型的数据，而输入值（{1}）非法", key, valueToken.DefineString);
return;
}
jsonData[key] = number;
}
else if (paramInfo.DataType == DataType.Bool)
{
if ("1".Equals(valueToken.DefineString))
{
jsonData[key] = true;
}
else if ("0".Equals(valueToken.DefineString))
{
jsonData[key] = false;
}
else
{
errorString = string.Format("mapString定义中要求key名（{0}）对应bool类型的数据，而输入值（{1}）非法，请用数字1、0或true、false进行数据定义", key, valueToken.DefineString);
return;
}
}
else if (paramInfo.DataType == DataType.MapString)
{
errorString = string.Format("mapString定义中要求key名（{0}）对应mapString类型的数据，而输入的数据值为\"{1}\"，请按格式要求在英文括号内声明mapString类型的数据", key, valueToken.DefineString);
return;
}
else
{
errorString = string.Format("mapString定义中要求key名（{0}）对应{1}类型的数据，而该类型数据必须用英文引号包裹", key, paramInfo.DataType);
return;
}
}
else if (valueToken.TokenType == MapStringTokenType.StartMap)
{
if (paramInfo.DataType == DataType.MapString)
{
JsonData childJsonData = new JsonData();
_GetMapElement(childJsonData, formatDefine.ParamInfo[key].MapStringInfo, out errorString);
if (errorString != null)
{
errorString = string.Format("名为{0}的map下属的子元素错误：{1}", key, errorString);
return;
}
jsonData[key] = childJsonData;
}
else
{
errorString = string.Format("mapString定义中要求key名（{0}）对应{1}类型的数据，而输入数据为mapString型", key, paramInfo.DataType);
return;
}
}
else
{
errorString = string.Format("与变量名（{0}）对应的数据值声明非法，输入值为{1}", key, valueToken.DefineString);
return;
}
// 解析后面的token
if (_tokenQueue.Count == 0)
{
errorString = string.Format("mapString数据不完整，map下的子元素{0}之后未声明用英文逗号分隔下一个子元素，也没有声明map的结束", key);
return;
}
MapStringToken nextToken = _tokenQueue.Dequeue();
if (nextToken.TokenType == MapStringTokenType.EndMap)
{
errorString = null;
return;
}
else if (nextToken.TokenType == MapStringTokenType.Comma)
{
if (_tokenQueue.Count == 0)
{
errorString = string.Format("mapString数据不完整，map下的子元素{0}之后的英文逗号后未声明下一个元素", key);
return;
}
_GetMapElement(jsonData, formatDefine, out errorString);
if (errorString != null)
{
errorString = string.Format("名为{0}的子元素后面的元素声明错误：{1}", key, errorString);
return;
}
}
else
{
errorString = string.Format("map下的子元素{0}之后未声明用英文逗号分隔下一个子元素，也没有声明map的结束，输入值为{1}", key, nextToken.DefineString);
return;
}
}
private MapStringParamInfo _GetArrayElement(string arrayKey, int arrayDepth, out string errorString)
{
// 解析key
if (_tokenQueue.Count == 0)
{
errorString = "mapString Array define is uncompleted";
return(null);
}
MapStringParamInfo paramInfo = null;
MapStringToken valueToken = _tokenQueue.Dequeue();
DataType valueDataType = DataType.Invalid;
if (valueToken.TokenType == MapStringTokenType.String)
{
string dataTypeString = valueToken.DefineString.Trim();
if ("int".Equals(dataTypeString, StringComparison.CurrentCultureIgnoreCase))
{
valueDataType = DataType.Int;
}
else if ("long".Equals(dataTypeString, StringComparison.CurrentCultureIgnoreCase))
{
valueDataType = DataType.Long;
}
else if ("float".Equals(dataTypeString, StringComparison.CurrentCultureIgnoreCase))
{
valueDataType = DataType.Float;
}
else if ("string".Equals(dataTypeString, StringComparison.CurrentCultureIgnoreCase))
{
valueDataType = DataType.String;
}
else if ("lang".Equals(dataTypeString, StringComparison.CurrentCultureIgnoreCase))
{
valueDataType = DataType.Lang;
}
else if ("bool".Equals(dataTypeString, StringComparison.CurrentCultureIgnoreCase))
{
valueDataType = DataType.Bool;
}
else
{
errorString = string.Format("mapString array层级{0}子元素对应的数据类型（{1}）非法，只支持int、long、float、string、lang、bool这几种最基础类型", arrayDepth, dataTypeString);
return(null);
}
paramInfo = new MapStringParamInfo();
paramInfo.ParamName = arrayKey;
paramInfo.DataType = valueDataType;
paramInfo.ArrayDepth = arrayDepth;
}
else if (valueToken.TokenType == MapStringTokenType.StartMap)
{
paramInfo = new MapStringParamInfo();
paramInfo.ParamName = arrayKey;
paramInfo.DataType = DataType.MapString;
paramInfo.MapStringInfo = new MapStringInfo();
paramInfo.ArrayDepth = arrayDepth;
_GetMapElement(paramInfo.MapStringInfo, out errorString);
if (errorString != null)
{
errorString = string.Format("mapString array层级{0}的map子元素错误：{1}", arrayDepth, errorString);
return(null);
}
}
else if (valueToken.TokenType == MapStringTokenType.StartArray)
{
paramInfo = new MapStringParamInfo();
paramInfo.ParamName = arrayKey;
paramInfo.DataType = DataType.Array;
paramInfo.ArrayParamInfo = _GetArrayElement(arrayKey, arrayDepth + 1, out errorString);
paramInfo.ArrayDepth = arrayDepth;
if (errorString != null)
{
errorString = string.Format("mapString array层级{0}的array子元素错误：{1}", arrayDepth, errorString);
return(null);
}
}
else
{
errorString = string.Format("mapString array层级{0}子元素的数据类型声明非法，输入值为{1}", arrayDepth, valueToken.DefineString);
return(null);
}
// 解析后面的token
if (_tokenQueue.Count == 0)
{
errorString = string.Format("mapString array层级{0}定义不完整，array下的子元素之后未声明array的结束", arrayDepth);
return(null);
}
MapStringToken nextToken = _tokenQueue.Dequeue();
if (nextToken.TokenType == MapStringTokenType.EndArray)
{
errorString = null;
return(paramInfo);
}
errorString = string.Format("mapString array层级{0}定义不完整，array下的子元素之后未声明array的结束，输入值为{1}", arrayDepth, nextToken.DefineString);
return(null);
}
private void _GetMapElement(MapStringInfo mapStringInfo, out string errorString)
{
// 解析key
if (_tokenQueue.Count == 0)
{
errorString = "mapString定义不完整";
return;
}
MapStringToken keyToken = _tokenQueue.Dequeue();
if (keyToken.TokenType != MapStringTokenType.String)
{
errorString = string.Concat("map子元素中的key名非法，输入值为", keyToken.DefineString);
return;
}
string key = keyToken.DefineString.Trim();
// 检查输入的key名是否符合变量名要求
if (TableCheckHelper.CheckFieldName(key, out errorString) == false)
{
errorString = string.Concat("map子元素中的key名不符合变量名要求，", errorString);
return;
}
// 检查是否已存在此变量名
if (mapStringInfo.ParamInfo.ContainsKey(key))
{
errorString = string.Format("map子元素中不允许存在相同key名（{0}）", key);
return;
}
// 判断key名后是否为等号
if (_tokenQueue.Count == 0)
{
errorString = string.Format("mapString定义不完整，map子元素中的key名（{0}）后缺失等号", key);
return;
}
MapStringToken equalSignToken = _tokenQueue.Dequeue();
if (equalSignToken.TokenType != MapStringTokenType.EqualSign)
{
errorString = string.Format("map子元素中的key名（{0}）后应为等号，而输入值为{1}", key, equalSignToken.DefineString);
return;
}
// 解析value值
if (_tokenQueue.Count == 0)
{
errorString = string.Format("mapString定义不完整，map子元素中的key名（{0}）在等号后未声明对应的数据类型", key);
return;
}
MapStringToken valueToken = _tokenQueue.Dequeue();
DataType valueDataType = DataType.Invalid;
if (valueToken.TokenType == MapStringTokenType.String)
{
string dataTypeString = valueToken.DefineString.Trim();
if ("int".Equals(dataTypeString, StringComparison.CurrentCultureIgnoreCase))
{
valueDataType = DataType.Int;
}
else if ("long".Equals(dataTypeString, StringComparison.CurrentCultureIgnoreCase))
{
valueDataType = DataType.Long;
}
else if ("float".Equals(dataTypeString, StringComparison.CurrentCultureIgnoreCase))
{
valueDataType = DataType.Float;
}
else if ("string".Equals(dataTypeString, StringComparison.CurrentCultureIgnoreCase))
{
valueDataType = DataType.String;
}
else if ("lang".Equals(dataTypeString, StringComparison.CurrentCultureIgnoreCase))
{
valueDataType = DataType.Lang;
}
else if ("bool".Equals(dataTypeString, StringComparison.CurrentCultureIgnoreCase))
{
valueDataType = DataType.Bool;
}
else
{
errorString = string.Format("map子元素中的key名（{0}）对应的数据类型（{1}）非法，只支持int、long、float、string、lang、bool这几种最基础类型", key, dataTypeString);
return;
}
MapStringParamInfo paramInfo = new MapStringParamInfo();
paramInfo.ParamName = key;
paramInfo.DataType = valueDataType;
mapStringInfo.ParamInfo.Add(key, paramInfo);
}
else if (valueToken.TokenType == MapStringTokenType.StartMap)
{
MapStringParamInfo paramInfo = new MapStringParamInfo();
paramInfo.ParamName = key;
paramInfo.DataType = DataType.MapString;
paramInfo.MapStringInfo = new MapStringInfo();
_GetMapElement(paramInfo.MapStringInfo, out errorString);
if (errorString != null)
{
errorString = string.Format("名为{0}的map下属的子元素错误：{1}", key, errorString);
return;
}
mapStringInfo.ParamInfo.Add(key, paramInfo);
}
else
{
errorString = string.Format("与变量名（{0}）对应的数据类型声明非法，输入值为{1}", key, valueToken.DefineString);
return;
}
// 解析后面的token
if (_tokenQueue.Count == 0)
{
errorString = string.Format("mapString定义不完整，map下的子元素{0}之后未声明用英文逗号分隔下一个子元素，也没有声明map的结束", key);
return;
}
MapStringToken nextToken = _tokenQueue.Dequeue();
if (nextToken.TokenType == MapStringTokenType.EndMap)
{
return;
}
else if (nextToken.TokenType == MapStringTokenType.Comma)
{
if (_tokenQueue.Count == 0)
{
errorString = string.Format("mapString定义不完整，map下的子元素{0}之后的英文逗号后未声明下一个元素", key);
return;
}
_GetMapElement(mapStringInfo, out errorString);
if (errorString != null)
{
errorString = string.Format("名为{0}的子元素后面的元素声明错误：{1}", key, errorString);
return;
}
}
else
{
errorString = string.Format("map下的子元素{0}之后未声明用英文逗号分隔下一个子元素，也没有声明map的结束，输入值为{1}", key, nextToken.DefineString);
return;
}
}
private void _GetArrayElement(JsonData jsonData, MapStringParamInfo paramInfo, out string errorString)
{
errorString = null;
// 解析value值
if (_tokenQueue.Count == 0)
{
errorString = string.Format("array层级{0}数据不完整", paramInfo.ArrayDepth);
return;
}
MapStringToken valueToken = _tokenQueue.Dequeue();
if (valueToken.TokenType == MapStringTokenType.StringWithQuotationMark)
{
if (paramInfo.DataType == DataType.String)
{
// 适应LitJson类库的实现，对换行和引号进行处理
jsonData.Add(valueToken.DefineString.Replace("\\n", "\n").Replace("\\\"", "\""));
}
else if (paramInfo.DataType == DataType.Lang)
{
if (AppValues.LangData.ContainsKey(valueToken.DefineString))
{
jsonData.Add(AppValues.LangData[valueToken.DefineString]);
}
else
{
errorString = string.Format("array层级{0}下的index{1}子元素要求对应的lang型数据的key（{2}）在lang文件中找不到对应的value", paramInfo.ArrayDepth, jsonData.Count - 1, valueToken.DefineString);
return;
}
}
else if (paramInfo.DataType == DataType.MapString)
{
errorString = string.Format("array层级{0}下的index{1}子元素要求对应mapString类型的数据，而输入的数据值为\"{2}\"，请按格式要求在英文括号内声明mapString类型的数据", paramInfo.ArrayDepth, jsonData.Count - 1, valueToken.DefineString);
return;
}
else if (paramInfo.DataType == DataType.Array)
{
errorString = string.Format("array层级{0}下的index{1}子元素要求对应array类型的数据，而输入的数据值为\"{2}\"，请按格式要求在[]内声明array类型的数据", paramInfo.ArrayDepth, jsonData.Count - 1, valueToken.DefineString);
return;
}
else
{
errorString = string.Format("array层级{0}下的index{1}子元素要求对应{2}类型的数据，而该类型数据不应该用英文引号包裹，只有string和lang型需要", paramInfo.ArrayDepth, jsonData.Count - 1, paramInfo.DataType);
return;
}
}
else if (valueToken.TokenType == MapStringTokenType.String)
{
if (paramInfo.DataType == DataType.Bool)
{
if ("true".Equals(valueToken.DefineString, StringComparison.CurrentCultureIgnoreCase))
{
jsonData.Add(true);
}
else if ("false".Equals(valueToken.DefineString, StringComparison.CurrentCultureIgnoreCase))
{
jsonData.Add(false);
}
else
{
errorString = string.Format("array层级{0}下的index{1}子元素要求对应bool类型的数据，而输入值（{2}）非法，请用数字1、0或true、false进行数据定义", paramInfo.ArrayDepth, jsonData.Count - 1, valueToken.DefineString);
return;
}
}
else if (paramInfo.DataType == DataType.String || paramInfo.DataType == DataType.Lang)
{
errorString = string.Format("array层级{0}下的index{1}子元素要求对应{2}类型的数据，而该类型数据必须用英文引号包裹", paramInfo.ArrayDepth, jsonData.Count - 1, paramInfo.DataType);
return;
}
else if (paramInfo.DataType == DataType.MapString)
{
errorString = string.Format("array层级{0}下的index{1}子元素要求对应mapString类型的数据，而输入的数据值为\"{2}\"，请按格式要求在英文括号内声明mapString类型的数据", paramInfo.ArrayDepth, jsonData.Count - 1, valueToken.DefineString);
return;
}
else if (paramInfo.DataType == DataType.Array)
{
errorString = string.Format("array层级{0}下的index{1}子元素要求对应array类型的数据，而输入的数据值为\"{2}\"，请按格式要求在[]内声明array类型的数据", paramInfo.ArrayDepth, jsonData.Count - 1, valueToken.DefineString);
return;
}
else
{
errorString = string.Format("array层级{0}下的index{1}子元素要求对应{2}类型的数据，而输入的数据值为\"{3}\"", paramInfo.ArrayDepth, jsonData.Count - 1, paramInfo.DataType, valueToken.DefineString);
return;
}
}
else if (valueToken.TokenType == MapStringTokenType.Number)
{
if (paramInfo.DataType == DataType.Int)
{
int number = 0;
if (int.TryParse(valueToken.DefineString, out number) == false)
{
errorString = string.Format("array层级{0}下的index{1}子元素要求对应int类型的数据，而输入值（{2}）非法", paramInfo.ArrayDepth, jsonData.Count - 1, valueToken.DefineString);
return;
}
jsonData.Add(number);
}
else if (paramInfo.DataType == DataType.Long)
{
long number = 0;
if (long.TryParse(valueToken.DefineString, out number) == false)
{
errorString = string.Format("array层级{0}下的index{1}子元素要求对应long类型的数据，而输入值（{2}）非法", paramInfo.ArrayDepth, jsonData.Count - 1, valueToken.DefineString);
return;
}
jsonData.Add(number);
}
else if (paramInfo.DataType == DataType.Float)
{
double number = 0;
if (double.TryParse(valueToken.DefineString, out number) == false)
{
errorString = string.Format("array层级{0}下的index{1}子元素要求对应float类型的数据，而输入值（{2}）非法", paramInfo.ArrayDepth, jsonData.Count - 1, valueToken.DefineString);
return;
}
jsonData.Add(number);
}
else if (paramInfo.DataType == DataType.Bool)
{
if ("1".Equals(valueToken.DefineString))
{
jsonData.Add(true);
}
else if ("0".Equals(valueToken.DefineString))
{
jsonData.Add(false);
}
else
{
errorString = string.Format("array层级{0}下的index{1}子元素要求对应bool类型的数据，而输入值（{2}）非法，请用数字1、0或true、false进行数据定义", paramInfo.ArrayDepth, jsonData.Count - 1, valueToken.DefineString);
return;
}
}
else if (paramInfo.DataType == DataType.MapString)
{
errorString = string.Format("array层级{0}下的index{1}子元素要求对应mapString类型的数据，而输入的数据值为\"{2}\"，请按格式要求在英文括号内声明mapString类型的数据", paramInfo.ArrayDepth, jsonData.Count - 1, valueToken.DefineString);
return;
}
else if (paramInfo.DataType == DataType.Array)
{
errorString = string.Format("array层级{0}下的index{1}子元素要求对应array类型的数据，而输入的数据值为\"{2}\"，请按格式要求在[]内声明array类型的数据", paramInfo.ArrayDepth, jsonData.Count - 1, valueToken.DefineString);
return;
}
else
{
errorString = string.Format("array层级{0}下的index{1}子元素要求对应{2}类型的数据，而该类型数据必须用英文引号包裹", paramInfo.ArrayDepth, jsonData.Count - 1, paramInfo.DataType);
return;
}
}
else if (valueToken.TokenType == MapStringTokenType.StartMap)
{
if (paramInfo.DataType == DataType.MapString)
{
JsonData childJsonData = new JsonData();
_GetMapElement(childJsonData, paramInfo.MapStringInfo, out errorString);
if (errorString != null)
{
errorString = string.Format("array层级{0}下的index{1}子元素错误：{2}", paramInfo.ArrayDepth, jsonData.Count - 1, errorString);
return;
}
jsonData.Add(childJsonData);
}
else
{
errorString = string.Format("array层级{0}下的index{1}子元素要求对应{2}类型的数据，而输入数据为mapString型", paramInfo.ArrayDepth, jsonData.Count - 1, paramInfo.DataType);
return;
}
}
else if (valueToken.TokenType == MapStringTokenType.StartArray)
{
if (paramInfo.DataType == DataType.Array)
{
JsonData childJsonData = new JsonData();
childJsonData.SetJsonType(JsonType.Array);
_GetArrayElement(childJsonData, paramInfo.ArrayParamInfo, out errorString);
if (errorString != null)
{
errorString = string.Format("array层级{0}下的index{1}子元素错误：{2}", paramInfo.ArrayDepth, jsonData.Count - 1, errorString);
return;
}
jsonData.Add(childJsonData);
}
else
{
errorString = string.Format("array层级{0}下的index{1}子元素要求对应{2}类型的数据，而输入数据为array型", paramInfo.ArrayDepth, jsonData.Count - 1, paramInfo.DataType);
return;
}
}
else
{
errorString = string.Format("array层级{0}下的index{1}子元素对应的数据值声明非法，输入值为{2}", paramInfo.ArrayDepth, jsonData.Count - 1, valueToken.DefineString);
return;
}
// 解析后面的token
if (_tokenQueue.Count == 0)
{
errorString = string.Format("mapString数据不完整，array层级{0}下的index{1}子元素之后未声明用英文逗号分隔下一个子元素，也没有声明array的结束", paramInfo.ArrayDepth, jsonData.Count - 1);
return;
}
MapStringToken nextToken = _tokenQueue.Dequeue();
if (nextToken.TokenType == MapStringTokenType.EndArray)
{
errorString = null;
return;
}
else if (nextToken.TokenType == MapStringTokenType.Comma)
{
if (_tokenQueue.Count == 0)
{
errorString = string.Format("mapString数据不完整，array层级{0}下的index{1}子元素之后的英文逗号后未声明下一个元素", paramInfo.ArrayDepth, jsonData.Count - 1);
return;
}
_GetArrayElement(jsonData, paramInfo, out errorString);
if (errorString != null)
{
errorString = string.Format("array层级{0}下的index{1}子元素后面的元素声明错误：{1}", paramInfo.ArrayDepth, jsonData.Count - 1);
return;
}
}
else
{
errorString = string.Format("array层级{0}下的index{1}子元素之后未声明用英文逗号分隔下一个子元素，也没有声明array的结束，输入值为{2}", paramInfo.ArrayDepth, jsonData.Count - 1, nextToken.DefineString);
return;
}
}
