/// <summary>
/// 获取查询信息
/// </summary>
/// <typeparam name="valueType">对象类型</typeparam>
/// <typeparam name="modelType">模型类型</typeparam>
/// <param name="sqlTool">SQL操作工具</param>
/// <param name="connection"></param>
/// <param name="query">查询信息</param>
/// <param name="readValue"></param>
/// <returns>对象集合</returns>
internal virtual LeftArray <valueType> Select <valueType, modelType>(Sql.Table <valueType, modelType> sqlTool, ref DbConnection connection, ref SelectQuery <modelType> query, Func <DbDataReader, valueType> readValue)
where valueType : class, modelType
where modelType : class
{
try
{
if (query.Sql != null)
{
if (connection == null)
{
connection = GetConnection();
}
if (connection != null)
{
if (query.IndexFieldName != null)
{
sqlTool.CreateIndex(connection, query.IndexFieldName, false);
query.IndexFieldName = null;
}
bool isFinally = false;
try
{
using (DbCommand command = getCommand(connection, query.Sql))
using (DbDataReader reader = command.ExecuteReader(CommandBehavior.SingleResult))
{
int skipCount = query.SkipCount;
while (skipCount != 0 && reader.Read())
{
--skipCount;
}
if (skipCount == 0)
{
LeftArray <valueType> array = new LeftArray <valueType>();
while (reader.Read())
{
valueType value = readValue(reader);
if (value != null)
{
array.Add(value);
}
}
isFinally = true;
return(array.NotNull());
}
}
isFinally = true;
}
finally
{
if (!isFinally)
{
sqlTool.Log.Add(AutoCSer.Log.LogType.Error, query.Sql);
}
}
}
}
}
finally { query.Free(); }
return(default(LeftArray <valueType>));
}
/// <summary>
/// 自定义模板标记枚举
/// </summary>
/// <param name="headerArray"></param>
/// <param name="codeArray"></param>
/// <param name="linkArray"></param>
internal CombinationTemplateHeaderEnumerable(ref LeftArray <string[][]> headerArray, string[] codeArray, CombinationTemplateLink[] linkArray)
{
this.headerArray = headerArray;
this.codeArray = codeArray;
this.linkArray = linkArray;
indexArray = new int[headerArray.Length];
}
/// <summary>
/// 根据类型获取自定义属性函数信息集合
/// </summary>
/// <param name="type">对象类型</param>
/// <returns>自定义属性函数信息集合</returns>
public static AttributeMethod[] Get(Type type)
{
AttributeMethod[] values;
if (methods.TryGetValue(type, out values))
{
return(values);
}
Monitor.Enter(createLock);
try
{
if (methods.TryGetValue(type, out values))
{
return(values);
}
LeftArray <AttributeMethod> array = new LeftArray <AttributeMethod>(0);
foreach (MethodInfo method in type.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy))
{
object[] attributes = method.GetCustomAttributes(true);
if (attributes.Length != 0)
{
array.Add(new AttributeMethod {
Method = method, attributes = attributes
});
}
}
methods.Set(type, values = array.ToArray());
}
finally { Monitor.Exit(createLock); }
return(values);
}
private void GameStateCheck(eCurentSide currentDirection)
{
if (RightArray.Count == 3)
{
Console.Clear();
Console.WriteLine("YOU WIN");
Console.ReadLine();
Environment.Exit(0);
}
var isGameOver = false;
if (LeftArray.Count == 2 && currentDirection == eCurentSide.Right)
{
isGameOver = LeftArray.Any(f => LeftArray.Any(b => b.IsFood(f)));
}
else if (RightArray.Count == 2 && currentDirection == eCurentSide.Left)
{
isGameOver = RightArray.Any(f => RightArray.Any(b => b.IsFood(f)));
}
if (isGameOver)
{
Console.Clear();
Console.WriteLine("YOU LOSE");
Console.ReadLine();
Environment.Exit(0);
}
}
/// <summary>
/// 获取属性成员集合
/// </summary>
/// <param name="properties">属性成员集合</param>
/// <param name="typeAttribute">类型配置</param>
/// <returns>属性成员集合</returns>
public static LeftArray <PropertyMethod> GetProperties(PropertyIndex[] properties, SerializeAttribute typeAttribute)
{
LeftArray <PropertyMethod> values = new LeftArray <PropertyMethod>(properties.Length);
foreach (PropertyIndex property in properties)
{
if (property.Member.CanRead)
{
Type type = property.Member.PropertyType;
if (!type.IsPointer && (!type.IsArray || type.GetArrayRank() == 1) && !property.IsIgnore && !typeof(Delegate).IsAssignableFrom(type) && !property.Member.IsDefined(typeof(IgnoreMemberAttribute), typeAttribute.IsBaseTypeAttribute))
{
MemberAttribute attribute = property.GetAttribute <MemberAttribute>(typeAttribute.IsBaseTypeAttribute);
if (typeAttribute.IsAttribute ? (attribute != null && attribute.IsSetup) : (attribute == null || attribute.IsSetup))
{
MethodInfo method = property.Member.GetGetMethod(true);
if (method != null && method.GetParameters().Length == 0)
{
values.Add(new PropertyMethod {
Property = property, Method = method, Attribute = attribute
});
}
}
}
}
}
return(values);
}
static Verifyer()
{
if (attribute != null && custom == null && Fields != null)
{
LeftArray <Field> verifyFields = Fields.getFind(value => value.IsVerify);
if (verifyFields.Length != 0)
{
columnNames = new AutoCSer.Threading.LockEquatableLastDictionary <HashString, string[]>();
int index = 0;
Verifyer.verifyFields = verifyFields.ToArray();
#if NOJIT
fields = new sqlColumn.verifyDynamicMethod.field[verifyFields.length];
foreach (AutoCSer.code.cSharp.sqlModel.fieldInfo member in verify.verifyFields)
{
fields[index++].Set(member);
}
#else
ColumnGroup.Verifyer dynamicMethod = new ColumnGroup.Verifyer(typeof(valueType), attribute);
foreach (Field member in Verifyer.verifyFields)
{
dynamicMethod.Push(member, index++);
}
verifyer = (Func <valueType, Table, string[], bool>)dynamicMethod.Create <Func <valueType, Table, string[], bool> >();
#endif
AutoCSer.Pub.ClearCaches += clearCache;
}
}
}
/// <summary>
/// 合并数据块集合
/// </summary>
/// <param name="datas">数据块集合</param>
/// <returns>合并后的数据块</returns>
internal unsafe static byte[] BlocksToByte(ref LeftArray <SubArray <byte> > datas)
{
if (datas.Length != 0)
{
int length = 0, count = datas.Length;
SubArray <byte>[] array = datas.Array;
for (int index = 0; index != count; ++index)
{
length += array[index].Length;
}
byte[] data = new byte[length];
fixed(byte *dataFixed = data)
{
byte *currentData = dataFixed;
for (int index = 0; index != count; ++index)
{
SubArray <byte> subArray = array[index];
fixed(byte *subArrayFixed = subArray.Array)
{
AutoCSer.Memory.CopyNotNull(subArrayFixed + subArray.Start, currentData, subArray.Length);
}
currentData += subArray.Length;
}
}
return(data);
}
return(null);
}
public void LeftRightMatchs(string text, ref LeftArray <KeyValue <int, int> > matchs)
{
if (text.Length != 0)
{
fixed(char *valueFixed = text) leftRightMatchs(valueFixed, valueFixed + text.Length, ref matchs);
}
}
/// <summary>
/// 获取列名集合
/// </summary>
/// <param name="name">列名前缀</param>
/// <returns></returns>
public unsafe static string[] GetColumnNames(string name)
{
string[] names;
HashString nameKey = name;
if (columnNames.TryGetValue(nameKey, out names))
{
return(names);
}
LeftArray <string> nameList = new LeftArray <string>(Fields.Length);
foreach (Field field in Fields)
{
if (field.IsSqlColumn)
{
((ColumnGroup.Verifyer.GetName)AutoCSer.Sql.Metadata.GenericType.Get(field.FieldInfo.FieldType).UpdaterGetColumnNamesMethod)(ref nameList, name + "_" + field.FieldInfo.Name);
}
else
{
nameList.Add(name + "_" + field.FieldInfo.Name);
}
}
columnNames.Set(nameKey, names = nameList.ToArray());
return(names);
}
/// <summary>
/// 搜索结果项
/// </summary>
/// <param name="dataKey">搜索数据关键字</param>
/// <param name="results">搜索结果</param>
internal SearchItem(DataKey dataKey, LeftArray <KeyValue <HashString, AutoCSer.Search.StaticSearcher <DataKey> .QueryResult> > results)
{
DataKey = dataKey;
switch (dataKey.Type)
{
case DataType.HtmlTitle:
Html = Html.Cache[dataKey.Id];
MatchText = default(SubString);
Indexs = Searcher.Default.GetResultIndexs(ref dataKey, Html.Title.Length, ref results);
break;
case DataType.HtmlBodyText:
MatchText = (Html = Html.Cache[dataKey.Id]).Text;
Indexs = Searcher.Default.FormatTextIndexs(ref dataKey, ref MatchText, ref results, maxTextLength);
break;
case DataType.HtmlImage:
HtmlImage image = HtmlImage.Cache[dataKey.Id];
Html = Html.Cache[image.HtmlId];
MatchText = image.Title;
Indexs = Searcher.Default.GetResultIndexs(ref dataKey, MatchText.Count, ref results);
break;
default:
Html = null;
MatchText = default(SubString);
Indexs = null;
break;
}
}
/// <summary>
/// 服务端推送
/// </summary>
/// <param name="customData"></param>
/// <param name="onPushIdentity"></param>
internal void CallCustomPush(byte[] customData, int onPushIdentity)
{
if (onPushIdentity == 0)
{
LeftArray <int> removeIdentitys = default(LeftArray <int>);
foreach (KeyValuePair <int, Func <AutoCSer.Net.TcpServer.ReturnValue <byte[]>, bool> > onPush in onPushs)
{
if (!onPush.Value(customData))
{
removeIdentitys.Add(onPush.Key);
}
}
foreach (int removeIdentity in removeIdentitys)
{
onPushs.Remove(removeIdentity);
}
}
else
{
Func <AutoCSer.Net.TcpServer.ReturnValue <byte[]>, bool> onPush;
if (onPushs.TryGetValue(onPushIdentity, out onPush))
{
if (!onPush(customData))
{
onPushs.Remove(onPushIdentity);
}
}
}
}
/// <summary>
/// 嵌套类型处理
/// </summary>
/// <param name="type">类型</param>
/// <param name="reflectedType">上层类型</param>
internal void ReflectedType(Type type, Type reflectedType)
{
LeftArray <Type> reflectedTypeList = new LeftArray <Type>(sizeof(int));
do
{
reflectedTypeList.Add(reflectedType);
reflectedType = reflectedType.ReflectedType;
}while (reflectedType != null);
Type[] reflectedTypeArray = reflectedTypeList.Array;
int reflectedTypeIndex = reflectedTypeList.Length - 1;
reflectedType = reflectedTypeArray[reflectedTypeIndex];
NameStream.Write(reflectedType.Namespace);
do
{
NameStream.Write('.');
NameStream.SimpleWrite(reflectedType.Name);
if (reflectedTypeIndex == 0)
{
NameStream.Write('.');
NameStream.SimpleWrite(type.Name);
return;
}
else
{
reflectedType = reflectedTypeArray[--reflectedTypeIndex];
}
}while (true);
}
/// <summary>
/// 获取成员名称与类型集合
/// </summary>
/// <param name="name">列名前缀</param>
/// <returns></returns>
internal static KeyValue <string, Type>[] GetDataColumns(string name)
{
if (custom != null)
{
return(custom.GetDataColumns(name));
}
if (Fields != null)
{
KeyValue <string, Type>[] values;
HashString nameKey = name;
if (dataColumns.TryGetValue(nameKey, out values))
{
return(values);
}
LeftArray <KeyValue <string, Type> > columns = new LeftArray <KeyValue <string, Type> >(Fields.Length);
foreach (Field field in Fields)
{
if (field.IsSqlColumn)
{
((Func <string, KeyValue <string, Type>[]>)AutoCSer.Sql.Metadata.GenericType.Get(field.DataType).GetDataColumnsMethod)(name + "_" + field.FieldInfo.Name);
}
else
{
columns.Add(new KeyValue <string, Type>(name + "_" + field.FieldInfo.Name, field.DataType));
}
}
values = columns.ToArray();
dataColumns.Set(nameKey, values);
return(values);
}
return(null);
}
/// <summary>
/// 安装下一个类型
/// </summary>
protected override void nextCreate()
{
if (!Type.Type.IsInterface)
{
LeftArray <MemberExpression> members = default(LeftArray <MemberExpression>);
nodeTypeNames.Clear();
bool isMember = true;
foreach (MemberIndex member in MemberIndex.GetMembers <AutoCSer.Net.RemoteExpression.MemberAttribute>(Type, AutoCSer.Metadata.MemberFilters.Instance, true, false))
{
if (!member.IsIgnore && member.CanGet)
{
AutoCSer.Net.RemoteExpression.MemberAttribute attribute = member.GetAttribute <AutoCSer.Net.RemoteExpression.MemberAttribute>(false);
isMember &= addMember(ref members, new MemberExpression {
Attribute = attribute, Member = member, IntputParameters = member.IsField ? NullValue <ExpressionParameter> .Array : ExpressionParameter.Get(MethodParameter.Get(((PropertyInfo)member.Member).GetGetMethod(true), NullValue <Type> .Array))
});
}
}
Members = members.ToArray();
LeftArray <MethodExpression> methods = default(LeftArray <MethodExpression>);
foreach (MethodIndex member in MethodIndex.GetMethods <AutoCSer.Net.RemoteExpression.MemberAttribute>(Type, AutoCSer.Metadata.MemberFilters.Instance, false, true, false))
{
if (!member.IsIgnore)
{
AutoCSer.Net.RemoteExpression.MemberAttribute attribute = member.GetAttribute <AutoCSer.Net.RemoteExpression.MemberAttribute>(false);
isMember &= addMember(ref methods, new MethodExpression {
Attribute = attribute, Method = member, IntputParameters = ExpressionParameter.Get(member.Parameters)
});
}
}
Methods = methods.ToArray();
LeftArray <StaticMemberExpression> staticMembers = default(LeftArray <StaticMemberExpression>);
foreach (MemberIndex member in MemberIndex.GetStaticMembers <AutoCSer.Net.RemoteExpression.MemberAttribute>(Type, AutoCSer.Metadata.MemberFilters.Static, true, false))
{
if (!member.IsIgnore && member.CanGet)
{
AutoCSer.Net.RemoteExpression.MemberAttribute attribute = member.GetAttribute <AutoCSer.Net.RemoteExpression.MemberAttribute>(false);
isMember &= addMember(ref staticMembers, new StaticMemberExpression {
Attribute = attribute, Member = member, IntputParameters = NullValue <ExpressionParameter> .Array
});
}
}
StaticMembers = staticMembers.ToArray();
LeftArray <StaticMethodExpression> staticMethods = default(LeftArray <StaticMethodExpression>);
foreach (MethodIndex member in MethodIndex.GetMethods <AutoCSer.Net.RemoteExpression.MemberAttribute>(Type, AutoCSer.Metadata.MemberFilters.Static, false, true, false))
{
if (!member.IsIgnore)
{
AutoCSer.Net.RemoteExpression.MemberAttribute attribute = member.GetAttribute <AutoCSer.Net.RemoteExpression.MemberAttribute>(false);
isMember &= addMember(ref staticMethods, new StaticMethodExpression {
Attribute = attribute, Method = member, IntputParameters = ExpressionParameter.Get(member.Parameters)
});
}
}
StaticMethods = staticMethods.ToArray();
if (isMember && (Members.Length | Methods.Length | StaticMemberCount) != 0)
{
create(true);
}
}
}
/// <summary>
/// 获取字段成员集合
/// </summary>
/// <param name="fields"></param>
/// <param name="isColumn"></param>
/// <returns>字段成员集合</returns>
internal static LeftArray <Field> Get(FieldIndex[] fields, bool isColumn)
{
LeftArray <Field> values = new LeftArray <Field>(fields.Length);
foreach (FieldIndex field in fields)
{
Type type = field.Member.FieldType;
if (!type.IsPointer && (!type.IsArray || type.GetArrayRank() == 1) && !field.IsIgnore)
{
MemberAttribute attribute = field.GetAttribute <MemberAttribute>(false);
if (attribute == null || attribute.IsSetup)
{
LogAttribute logAttribute = isColumn ? null : field.GetAttribute <LogAttribute>(false);
if (logAttribute == null || logAttribute.IsMember)
{
if (attribute != null && attribute.IsNowTime && type != typeof(DateTime))
{
attribute.IsNowTime = false;
}
values.Add(new Field(field, attribute));
}
}
}
}
return(values);
}
/// <summary>
/// 创建 Trie 树
/// </summary>
/// <param name="words">分词集合</param>
private void buildTree(ref LeftArray <string> words)
{
if (words.Length != 0)
{
TreeBuilder treeBuilder = new TreeBuilder();
foreach (string word in words)
{
if (!string.IsNullOrEmpty(word))
{
if (CharTypeData.Data == DefaultCharTypeData.Data)
{
AutoCSer.Memory.Common.CopyNotNull(DefaultCharTypeData.Byte, (CharTypeData = Unmanaged.GetPointer(1 << 16, false)).Byte, 1 << 16);
}
fixed(char *wordFixed = word)
{
treeBuilder.Build(Boot, word, wordFixed);
CharTypeData.Byte[*wordFixed] |= TrieGraphHeadFlag;
char *start = wordFixed, end = wordFixed + word.Length;
do
{
if (*start != ' ')
{
CharTypeData.Byte[*start] |= (byte)WordType.TrieGraph;
}
}while (++start != end);
CharTypeData.Byte[*(end - 1)] |= TrieGraphEndFlag;
}
}
}
}
}
public LeftArray <KeyValue <int, int> > LeftRightMatchs(ref SubString text)
{
LeftArray <KeyValue <int, int> > matchs = default(LeftArray <KeyValue <int, int> >);
LeftRightMatchs(ref text, ref matchs);
return(matchs);
}
public LeftArray <KeyValue <int, int> > LeftRightMatchs(SubString text)
{
LeftArray <KeyValue <int, int> > matchs = new LeftArray <KeyValue <int, int> >(0);
LeftRightMatchs(ref text, ref matchs);
return(matchs);
}
/// <summary>
/// 拓扑排序
/// </summary>
/// <typeparam name="valueType">数据类型</typeparam>
/// <param name="edges">边集合</param>
/// <param name="points">无边点集合</param>
/// <param name="isDesc">是否反向排序</param>
/// <returns>排序结果</returns>
public static valueType[] Sort <valueType>(ICollection <KeyValue <valueType, valueType> > edges, HashSet <valueType> points, bool isDesc = false)
where valueType : IEquatable <valueType>
{
if (edges.count() == 0)
{
return(points.getArray());
}
Dictionary <valueType, ListArray <valueType> > graph = DictionaryCreator.CreateAny <valueType, ListArray <valueType> >();
if (points == null)
{
points = HashSetCreator.CreateAny <valueType>();
}
ListArray <valueType> values;
foreach (KeyValue <valueType, valueType> edge in edges)
{
if (!graph.TryGetValue(edge.Key, out values))
{
graph.Add(edge.Key, values = new ListArray <valueType>());
}
values.Add(edge.Value);
points.Add(edge.Value);
}
LeftArray <valueType> pointList = new LeftArray <valueType>(points.Count);
foreach (valueType point in points)
{
if (!graph.ContainsKey(point))
{
pointList.UnsafeAdd(point);
}
}
return(new Sorter <valueType>(graph, ref pointList, isDesc).Sort());
}
/// <summary>
/// 获取列名集合
/// </summary>
/// <param name="name">列名前缀</param>
/// <returns></returns>
internal static string[] GetColumnNames(string name)
{
string[] names;
HashString nameKey = name;
if (columnNames.TryGetValue(ref nameKey, out names))
{
return(names);
}
LeftArray <string> nameList = new LeftArray <string>(verifyFields.Length);
foreach (Field field in verifyFields)
{
if (field.IsSqlColumn)
{
ColumnGroup.Verifyer.GetColumnNames(field.FieldInfo.FieldType)(ref nameList, name + "_" + field.FieldInfo.Name);
}
else
{
nameList.Add(name + "_" + field.FieldInfo.Name);
}
}
columnNames.Set(ref nameKey, names = nameList.ToArray());
return(names);
}
/// <summary>
/// 重新加载数据
/// </summary>
/// <param name="connection"></param>
/// <param name="query">查询信息</param>
internal override void Reset(ref DbConnection connection, ref SelectQuery <modelType> query)
{
LeftArray <valueType> array = SqlTable.Select(ref connection, ref query);
array.RemoveNot(isValue);
reset(array);
}
/// <summary>
/// 获取 HTML 信息
/// </summary>
/// <param name="htmlFile">HTML 文件</param>
/// <returns>HTML 信息</returns>
private static Html getHtml(FileInfo htmlFile)
{
AutoCSer.HtmlNode.Node htmlNode = new AutoCSer.HtmlNode.Node(File.ReadAllText(htmlFile.FullName, Encoding.UTF8));
foreach (AutoCSer.HtmlNode.Node bodyNode in bodyFilter.Get(htmlNode))
{
foreach (AutoCSer.HtmlNode.Node titleNode in titleFilter.Get(htmlNode))
{
string title, bodyText;
if (!string.IsNullOrEmpty(title = titleNode.Text) && !string.IsNullOrEmpty(bodyText = bodyNode.Text))
{
LeftArray <HtmlImage> images = default(LeftArray <HtmlImage>);
foreach (AutoCSer.HtmlNode.Node imgNode in bodyNode.GetNodesByTagName("img"))
{
string alt = imgNode["alt"], src = imgNode["src"] ?? imgNode["@src"];
if (!string.IsNullOrEmpty(alt) && !string.IsNullOrEmpty(src))
{
images.Add(new HtmlImage {
Url = src, Title = alt
});
}
}
return(new Html {
Title = title, Text = bodyText, Images = images.ToArray()
});
}
break;
}
break;
}
return(null);
}
/// <summary>
/// 安装入口
/// </summary>
/// <param name="exportPathType">导出引导类型</param>
/// <returns>是否安装成功</returns>
public bool Run(Type exportPathType, string outputFileName)
{
AutoCSer.WebView.PathAttribute exportWebPath = exportPathType.customAttribute <AutoCSer.WebView.PathAttribute>();
if (exportWebPath == null)
{
Messages.Message("没有找到 path 导出信息 " + exportPathType.fullName());
}
else if (exportWebPath.Flag == 0)
{
Messages.Message("缺少导出二进制位标识 " + exportPathType.fullName());
}
else
{
LeftArray <KeyValue <Type, AutoCSer.WebView.PathAttribute> > types = new LeftArray <KeyValue <Type, AutoCSer.WebView.PathAttribute> >();
foreach (Type type in exportPathType.Assembly.GetTypes())
{
AutoCSer.WebView.PathAttribute webPath = type.customAttribute <AutoCSer.WebView.PathAttribute>();
if (webPath != null && (webPath.Flag & exportWebPath.Flag) == exportWebPath.Flag)
{
types.Add(new KeyValue <Type, AutoCSer.WebView.PathAttribute>(type, webPath));
}
}
foreach (KeyValue <Type, AutoCSer.WebView.PathAttribute> type in types.Sort((left, right) => string.CompareOrdinal(left.Key.FullName, right.Key.FullName)))
{
this.Type = type.Key;
Attribute = type.Value;
nextCreate();
}
this.outputFileName = outputFileName + outputFileExtensionName;
onCreated();
return(true);
}
return(false);
}
static Verifyer()
{
if (attribute != null)
{
LeftArray <Field> verifyFields = Fields.getFind(value => value.IsVerify);
if (verifyFields.Length != 0)
{
#if NOJIT
fields = new sqlModel.verifyField[verifyFields.length];
int index = 0;
foreach (Field member in verifyFields)
{
fields[index++].Set(member);
}
#else
DataModel.Verifyer dynamicMethod = new DataModel.Verifyer(typeof(modelType), attribute);
foreach (Field member in verifyFields)
{
dynamicMethod.Push(member);
}
verifyer = (Func <modelType, MemberMap, Table, bool>)dynamicMethod.Create <Func <modelType, MemberMap, Table, bool> >();
#endif
}
}
}
/// <summary>
/// 安装下一个类型
/// </summary>
protected override void nextCreate()
{
LeftArray <RemoteMethod> remoteMethods = new LeftArray <RemoteMethod>();
foreach (MethodIndex method in MethodIndex.GetMethods <AutoCSer.Net.TcpStaticServer.MethodAttribute>(Type, AutoCSer.Metadata.MemberFilters.Static, false, true, false))
{
if (!method.Method.IsGenericMethodDefinition)
{
AutoCSer.Sql.RemoteMemberAttribute remoteAttribute = method.GetSetupAttribute <AutoCSer.Sql.RemoteMemberAttribute>(false);
if (remoteAttribute != null)
{
MethodParameter[] parameters = method.Parameters;
if (parameters.Length >= 1 && parameters[0].ParameterType == Type.Type)
{
remoteMethods.Add(new RemoteMethod {
Type = Type, ProjectParameter = AutoParameter, Method = method, MethodParameters = parameters, Attribute = remoteAttribute
});
}
}
}
}
RemoteMethods = remoteMethods.ToArray();
setRemoteMemberCache();
if ((RemoteMethods.Length | RemoteMembers.Length | RemoteCaches.Length) != 0)
{
create(true);
}
}
/// <summary>
/// 从左到右最大匹配
/// </summary>
/// <param name="start">匹配起始位置</param>
/// <param name="end">匹配结束位置</param>
/// <param name="matchs">匹配结果集合</param>
private void leftRightMatchs(char *start, char *end, ref LeftArray <KeyValue <int, int> > matchs)
{
Dictionary <char, Node> bootNode = Boot.Nodes;
string value;
Node node = Boot, linkNode = null;
int index = -1;
do
{
char letter = *start;
if (node.GetLinkWhereNull(letter, ref node, ref linkNode) == 0)
{
if (linkNode != null)
{
goto LINK;
}
BOOT:
++index;
node = Boot;
continue;
LINK:
do
{
int isGetValue = linkNode.GetNodeOrLink(letter, ref node, ref linkNode, out value);
if (value != null)
{
matchs.PrepLength(1);
matchs.Array[matchs.Length++].Set(index - value.Length + 1, value.Length);
}
if (isGetValue == 0)
{
if (linkNode == null)
{
goto BOOT;
}
}
else
{
break;
}
}while (true);
}
++index;
if ((value = node.Value) != null)
{
matchs.PrepLength(1);
matchs.Array[matchs.Length++].Set(index - value.Length + 1, value.Length);
}
}while (++start != end);
node = node.Link;
while (node != null)
{
if ((value = node.GetLink(ref node)) != null)
{
matchs.PrepLength(1);
matchs.Array[matchs.Length++].Set(index - value.Length + 1, value.Length);
}
}
}
/// <summary>
/// 创建二进制数据反序列化
/// </summary>
/// <param name="attribute"></param>
/// <returns></returns>
internal TypeDeSerializer <valueType> CreateOnly(BinarySerializeAttribute attribute)
{
DeSerializeVersionField[] fieldArray = this.fields;
LeftArray <FieldSize> fixedFields = new LeftArray <FieldSize>(fieldArray.Length - noSerializeMemberCount), fields = new LeftArray <FieldSize>(fieldArray.Length - noSerializeMemberCount);
LeftArray <AutoCSer.Metadata.FieldIndex> jsonFields = new LeftArray <AutoCSer.Metadata.FieldIndex>(0);
int fixedSize = 0;
AutoCSer.Algorithm.QuickSort.Sort(fieldArray, DeSerializeVersionField.MemberNameSort, 0, fieldArray.Length);
if (attribute.GetIsMemberMap)
{
int memberIndex = 0;
LeftArray <DeSerializeVersionField> newFields = new LeftArray <DeSerializeVersionField>(fieldArray.Length);
foreach (DeSerializeVersionField field in fieldArray)
{
if (field.Attribute != null)
{
if (field.Field.MemberIndex == memberIndex)
{
newFields.Add(field);
}
else
{
newFields.Add(field.Copy(memberIndex));
}
}
++memberIndex;
}
fieldArray = newFields.ToArray();
}
else if (noSerializeMemberCount != 0)
{
fieldArray = fieldArray.getFindArray(value => value.Attribute != null);
}
foreach (DeSerializeVersionField field in fieldArray)
{
BinarySerializeMemberAttribute memberAttribute = field.Attribute;
if (memberAttribute.GetIsJson)
{
jsonFields.Add(field.Field);
}
else
{
FieldSize value = new FieldSize(field.Field);
if (value.FixedSize == 0)
{
fields.Add(value);
}
else
{
fixedFields.Add(value);
fixedSize += value.FixedSize;
}
}
}
int memberCountVerify;
Fields <FieldSize> fieldSizes = new Fields <FieldSize>(ref fixedFields, ref fields, ref jsonFields, fixedSize, attribute.GetIsJson, out memberCountVerify);
return(DeSerializer = new TypeDeSerializer <valueType>(GlobalVersion, ref fieldSizes, memberCountVerify));
}
/// <summary>
/// 复制数据
/// </summary>
/// <param name="array"></param>
public void CopyTo(ref LeftArray <KeyValuePair <keyType, ResultIndexArray> > array)
{
array.PrepLength(Dictionary.Count);
foreach (KeyValuePair <keyType, ResultIndexArray> value in Dictionary)
{
array.UnsafeAdd(value);
}
}
/// <summary>
/// 获取分页数据集合
/// </summary>
/// <param name="sorter"></param>
/// <param name="pageSize">分页大小</param>
/// <param name="currentPage">分页页号</param>
/// <param name="count">数据总数</param>
/// <returns>分页数据集合</returns>
internal valueType[] GetPageDesc(Func <LeftArray <valueType>, LeftArray <valueType> > sorter, int pageSize, int currentPage, out int count)
{
if (!isSorted)
{
Array = sorter(Array);
}
return(Array.GetPageDesc(pageSize, currentPage, out count));
}
public LeftArray <KeyValue <HashString, QueryResult> > Search(out LeftArray <SubString> lessWords)
{
queryResult.Length = 0;
this.lessWords.Length = 0;
wordQuery.Get(ref Simplified, MatchType.Less, ref queryResult, ref this.lessWords);
lessWords = this.lessWords;
return(queryResult);
}
