/// <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)
{
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="config">部署服务客户端配置</param>
/// <param name="onClient">部署服务客户端就绪</param>
public Client(ClientConfig config = null, Action <OnClientParameter> onClient = null)
{
this.Config = config ?? ConfigLoader.GetUnion(typeof(ClientConfig)).ClientConfig;
this.onClient = onClient;
if ((deploys = config.Deploys).Length == 0)
{
throw new ArgumentNullException();
}
IgnoreFileNames = config.IgnoreFileNames.getHash(value => value) ?? HashSetCreator.CreateOnly <string>();
Dictionary <HashString, AutoCSer.Net.TcpInternalServer.ServerAttribute> attributes;
if (config.ServerAttributes.length() == 0)
{
attributes = null;
}
else
{
attributes = DictionaryCreator.CreateHashString <AutoCSer.Net.TcpInternalServer.ServerAttribute>();
foreach (KeyValue <string, AutoCSer.Net.TcpInternalServer.ServerAttribute> attribute in config.ServerAttributes.notNull())
{
attributes.Add(attribute.Key ?? string.Empty, attribute.Value);
}
}
TcpClient tcpClient;
int deployIndex = 0;
foreach (ClientDeploy deploy in deploys)
{
if (deploy.Tasks.length() == 0)
{
throw new ArgumentNullException("deploys[" + deployIndex.toString() + "].Tasks");
}
HashString serverName = deploy.ServerName ?? string.Empty;
if (!clients.TryGetValue(serverName, out tcpClient))
{
if (serverName.String.Length == 0)
{
clients.Add(serverName, tcpClient = new TcpClient(this, string.Empty, null));
}
else
{
AutoCSer.Net.TcpInternalServer.ServerAttribute attribute;
if (attributes.TryGetValue(serverName, out attribute))
{
clients.Add(serverName, tcpClient = new TcpClient(this, serverName.String, attribute));
}
else
{
throw new ArgumentNullException("缺少服务命名 " + serverName);
}
}
}
deploys[deployIndex++].TcpClient = tcpClient;
}
}
/// <summary>
/// 反射模式对象扫描
/// </summary>
/// <param name="scanner">类型扫描</param>
/// <param name="fieldInfo">当前扫描静态字段</param>
internal ReflectionScanner(ReflectionTypeScanner scanner, FieldInfo fieldInfo)
{
Scanner = scanner;
FieldInfo = fieldInfo;
objectReferences = HashSetCreator <ObjectReference> .Create();
Arrays = new LeftArray <ReflectionArrayScanner>(0);
Objects = new LeftArray <ReflectionObjectScanner>(0);
IsLimitExceeded = false;
}
/// <summary>
/// TCP 注册服务客户端
/// </summary>
/// <param name="serviceName">TCP 注册服务服务名称</param>
private Client(ref HashString serviceName)
{
#if NoAutoCSer
throw new Exception();
#else
this.serviceName = serviceName;
servers = HashSetCreator.CreateAny <IServer>();
registerClient = new Server.TcpInternalClient(TcpInternalServer.ServerAttribute.GetConfig(serviceName, typeof(AutoCSer.Net.TcpRegister.Server)));
logHandle = onLog;
checkSocketVersion = registerClient._TcpClient_.CreateCheckSocketVersion(onNewSocket);
#endif
}
/// <summary>
/// 转换HASH
/// </summary>
/// <typeparam name="valueType">数据类型</typeparam>
/// <typeparam name="hashType">目标数据类型</typeparam>
/// <param name="array">数组数据</param>
/// <param name="getValue">数据获取器</param>
/// <returns>HASH</returns>
public static HashSet <hashType> getHash <valueType, hashType>(this valueType[] array, Func <valueType, hashType> getValue)
{
if (array != null)
{
HashSet <hashType> hash = HashSetCreator <hashType> .Create();
foreach (valueType value in array)
{
hash.Add(getValue(value));
}
return(hash);
}
return(null);
}
/// <summary>
/// 分组列表 延时排序缓存
/// </summary>
/// <param name="cache">整表缓存</param>
/// <param name="getKey">分组字典关键字获取器</param>
/// <param name="getValue">获取目标对象委托</param>
/// <param name="member">缓存字段表达式</param>
/// <param name="getTargets"></param>
/// <param name="sorter">排序器</param>
/// <param name="isReset">是否初始化</param>
public MemberOrderList(Event.Cache <valueType, modelType> cache, Func <modelType, keyType> getKey
, Func <keyType, targetType> getValue, Expression <Func <targetType, ListArray <valueType> > > member
, Func <IEnumerable <targetType> > getTargets, Func <LeftArray <valueType>, LeftArray <valueType> > sorter, bool isReset)
: base(cache, getKey, getValue, member, getTargets)
{
if (sorter == null)
{
throw new ArgumentNullException();
}
this.sorter = sorter;
if (isReset)
{
HashSet <keyType> keys = HashSetCreator <keyType> .Create();
foreach (valueType value in cache.Values)
{
keyType key = getKey(value);
targetType target = getValue(key);
if (target == null)
{
cache.SqlTable.Log.Debug(typeof(valueType).FullName + " 没有找到缓存目标对象 " + key.ToString(), LogLevel.Debug | LogLevel.Info | LogLevel.AutoCSer);
}
else
{
ListArray <valueType> list = getMember(target);
if (list == null)
{
(list = new ListArray <valueType>()).Add(value);
setMember(target, list);
}
else
{
list.Add(value);
keys.Add(key);
}
}
}
foreach (keyType key in keys)
{
ListArray <valueType> list = getMember(getValue(key));
list.Array = sorter(list.Array);
//list.Array.Array = list.Array.Array.notNull();
}
cache.OnInserted += onInserted;
cache.OnUpdated += onUpdated;
cache.OnDeleted += onDeleted;
}
}
/// <summary>
/// 转换HASH
/// </summary>
/// <typeparam name="T">数据类型</typeparam>
/// <typeparam name="VT">目标数据类型</typeparam>
/// <param name="array">数组数据</param>
/// <param name="getValue">数据获取器</param>
/// <returns>HASH</returns>
public static HashSet <VT> getHash <T, VT>(this T[] array, Func <T, VT> getValue)
where VT : IEquatable <VT>
{
if (array != null)
{
HashSet <VT> hash = HashSetCreator <VT> .Create();
foreach (T value in array)
{
hash.Add(getValue(value));
}
return(hash);
}
return(null);
}
/// <summary>
/// 解析索引位置
/// </summary>
/// <param name="start">起始字符位置</param>
/// <param name="end">结束字符位置</param>
private void getIndex(char *start, char *end)
{
if (start != end)
{
string value = new string(start, 0, (int)(end - start));
if (AutoCSer.Extension.StringExtension.FindNotNull(start, end, ',') == null)
{
if (!int.TryParse(value, out index))
{
index = -1;
}
}
else
{
HashSet <int> hashSet = HashSetCreator.CreateInt();
int[] indexs = value.splitIntNoCheckNotEmpty(',');
foreach (int index in indexs)
{
hashSet.Add(index);
}
if (hashSet.Count != indexs.Length)
{
if (hashSet.Count == 1)
{
foreach (int index in hashSet)
{
this.index = index;
}
}
else
{
this.indexs = hashSet.getArray();
}
}
else
{
if (indexs.Length != 1)
{
Array.Sort(this.indexs = indexs);
}
else
{
index = indexs[0];
}
}
}
}
}
/// <summary>
/// 根据筛选路径值匹配HTML节点集合
/// </summary>
/// <param name="node">筛选节点</param>
/// <param name="nodes"></param>
/// <returns>匹配的 HTML 节点集合</returns>
private IEnumerable <Node> get(Node node, HashSet <Node>[] nodes)
{
if (node != null)
{
switch (type)
{
case FilterType.Node:
if (isDistinctNode)
{
HashSet <Node> hashSet = nodes[depth];
if (hashSet == null || !hashSet.Contains(node))
{
if (hashSet == null)
{
nodes[depth] = hashSet = HashSetCreator.CreateOnly <Node>();
}
hashSet.Add(node);
if (nextFilter == null)
{
foreach (Node nextNode in getNode(node, hashSet))
{
yield return(nextNode);
}
}
else
{
foreach (Node nextNode in getNode(node, hashSet))
{
foreach (Node returnNode in nextFilter.get(nextNode, nodes))
{
yield return(returnNode);
}
}
}
}
}
else
{
if (nextFilter == null)
{
foreach (Node nextNode in getNode(node))
{
yield return(nextNode);
}
}
else
{
foreach (Node nextNode in getNode(node))
{
foreach (Node returnNode in nextFilter.get(nextNode, nodes))
{
yield return(returnNode);
}
}
}
}
break;
case FilterType.Class:
if (isClass(node))
{
if (nextFilter == null)
{
yield return(node);
}
else
{
foreach (Node returnNode in nextFilter.get(node, nodes))
{
yield return(returnNode);
}
}
}
break;
case FilterType.Child:
if (nextFilter == null)
{
foreach (Node nextNode in getChild(node))
{
yield return(nextNode);
}
}
else
{
foreach (Node nextNode in getChild(node))
{
foreach (Node returnNode in nextFilter.get(nextNode, nodes))
{
yield return(returnNode);
}
}
}
break;
case FilterType.Value:
if (isValue(node))
{
if (nextFilter == null)
{
yield return(node);
}
else
{
foreach (Node returnNode in nextFilter.get(node, nodes))
{
yield return(returnNode);
}
}
}
break;
}
}
}
