public override bool EqualForTaskExecutionSpecial(ITaskParam OtherParam)
{
return
BotTaskParam.MemberEqualForTaskExecutionSpecial(RootUIElement, (OtherParam as MenuPathParam)?.RootUIElement) &&
RootMouseButton == (OtherParam as MenuPathParam)?.RootMouseButton &&
(PathSegmentRegexPattern?.SequenceEqual((OtherParam as MenuPathParam)?.PathSegmentRegexPattern) ?? false);
}
public ContainerRateLimit(
ITaskParam Task,
ITaskRateLimit RateLimit)
:
this(Task, RateLimit.Yield())
{
}
public ContainerRateLimit(
ITaskParam Task,
IEnumerable<ITaskRateLimit> SetRateLimit = null)
:
base(Task.Yield())
{
this.SetRateLimit = SetRateLimit?.ToArray();
}
public TaskRateLimitEqualForTaskExecution(
ITaskParam TaskParam,
int? DistanceMinStepCount,
int? DistanceMinTime = null)
{
this.TaskParam = TaskParam;
this.DistanceMinStepCount = DistanceMinStepCount;
this.DistanceMinTime = DistanceMinTime;
}
public ITask TaskForExecutingTaskParam(
ITaskParam Param,
int IdAtClient = 0)
{
if (null == Param)
{
return null;
}
var ListTask = StepCurrentState.ListTask;
if (null == ListTask)
{
StepCurrentState.ListTask = ListTask = new List<ITask>();
}
var Task = ListTask.LastOrDefault(candidateTask => Param.IsBeeingExecutedByTask(candidateTask) && !candidateTask.MotionComplete());
if (null != Task)
{
return Task;
}
var IdAtBot = ++TaskLastId;
Task = new Task.Task(IdAtClient, IdAtBot, Param, StepIndex ?? -1);
ListTask.Add(Task);
return Task;
}
IEnumerable<ITaskParam> Component(ITaskParam TaskParam)
{
var Method = NodeResolveMethodResolve.GetMethodForTaskParam(TaskParam);
if (null == Method)
{
return null;
}
var Component = Method.Invoke(null, new object[] { TaskParam, this });
return
(Component as IEnumerable<ITaskParam>) ??
(Component as ITaskParam).Yield();
}
IEnumerable<KeyValuePair<ITaskRateLimit, IEnumerable<ITask>>> EnumRateLimitEffective(ITaskParam TaskParam)
{
var TaskParamRateLimit = TaskParam?.RateLimit;
foreach (var RateLimit in TaskParamRateLimit.EmptyIfNull())
{
yield return new KeyValuePair<ITaskRateLimit, IEnumerable<ITask>>(RateLimit, EnumRateLimitEffective(RateLimit)?.ToArray());
}
}
static public System.Reflection.MethodInfo GetMethodForTaskParam(ITaskParam TaskParam) => GetMethodForTaskParamType(TaskParam?.GetType());
public Task(
int IdAtClient,
int IdAtBot,
ITaskParam Param,
int BeginStepIndexInBot)
{
this.IdAtClient = IdAtClient;
this.IdAtBot = IdAtBot;
this.Param = Param;
this.BeginStepIndexInBot = BeginStepIndexInBot;
Status = TaskStatusEnum.InProgress;
}
virtual public bool EqualForTaskExecutionSpecial(ITaskParam OtherParam)
{
if (null == OtherParam)
{
return false;
}
var Type = GetType();
var TypePolicy = TaskComparisonTypePolicyCache.ZuTypeBehandlung(Type);
foreach (var Member in TypePolicy.MengeMemberBehandlung)
{
var MemberValueSelf = Member.HerkunftTypeMemberGetter(this);
var MemberValueOther = Member.HerkunftTypeMemberGetter(OtherParam);
if (!MemberEqualForTaskExecutionSpecial(MemberValueSelf, MemberValueOther))
{
return false;
}
}
return true;
}
virtual public bool EqualForTaskExecution(ITaskParam OtherParam)
{
if (Equals(this, OtherParam))
{
return true;
}
if (OtherParam?.GetType() != GetType())
{
return false;
}
return EqualForTaskExecutionSpecial(OtherParam);
}
