public ClassTemplateImpl(IGenerateSerie gen, IUseMethod pMethod)
: base(gen)
{
Method = pMethod;
Level = (uint)pMethod.Level;
pMethod.Implementation = (IGetBase)this;
idSerie = Method.IdMethod;
}
public static IStrategyTodo GetInstance(ETypeDoIndependentWork tipo, IGenerateSerie generaSerie, int iteracionesOSegundos)
{
if (tipo == ETypeDoIndependentWork.LOOPING)
{
return(new Looping(generaSerie, iteracionesOSegundos));
}
else if (tipo == ETypeDoIndependentWork.SLEEPING)
{
return(new Sleeping(generaSerie, iteracionesOSegundos));
}
throw new Exception("Not Expected TODO Strategy");
}
private static IGetString GetInstanceNoAsync(IUseMethod method, IGenerateSerie reporter, IGetBase lastClass)
{
if (method == null)
{
return(null);
}
var processing = StrategyTodoFactory.GetInstance(method.TypeDoIndependentWork, reporter, method.NumSteps);
IStrategyTodo todo = StrategyTodoFactory.GetInstance(method.TypeDoIndependentWork, reporter, method.NumSteps);
MyWorkSync myW = new MyWorkSync(todo, reporter);
if (method.Next == null)
{
return(new MethodSyncFinal(myW, reporter, processing, method));
}
else
{
IGetString result = null;
if (lastClass is IGetString)
{
result = new CallNextSyncIfNextMethodIsSync(myW, (IGetString)lastClass, reporter, method);
}
else if (lastClass is IGetStringAsync)
{
switch (method.CallNext)
{
case ECallNext.WAIT_FIRST:
result = new CallNextSyncWaitFirstIfNextMethodIsAsync(myW, (IGetStringAsync)lastClass, reporter, method);
break;
case ECallNext.WAIT_AFTER:
case ECallNext.AWAITER_AFTER:
case ECallNext.NOT_WAIT:
result = new CallNextSyncWaitAfterIfNextMethodIsAsync(myW, (IGetStringAsync)lastClass, reporter, method);
break;
}
}
return(result);
}
}
public static IGetBase GetInstance(IUseMethod method, IGenerateSerie reporter)
{
if (method == null)
{
return(null);
}
IGetBase result = null;
var lastClass = GetInstance(method.Next, reporter);
if (method.TypeImpl == ETypeImpl.ASYNC)
{
result = GetInstanceAsync(method, reporter, lastClass);
}
else if (method.TypeImpl == ETypeImpl.SYNC)
{
result = GetInstanceNoAsync(method, reporter, lastClass);
}
return(result);
}
public MethodSyncFinal(IMyWorkSync pMyWork, IGenerateSerie gen, IStrategyTodo pProcesamiento, IUseMethod pMethod)
: base(pMyWork, gen, pMethod)
{
}
public MyWorkAsyncAwaiter(IStrategyTodo pProcesamiento, IGenerateSerie pgenerator)
: base(pProcesamiento, pgenerator)
{
}
public MyWorkSync(IStrategyTodo pProcesamiento, IGenerateSerie pgenerator)
: base(pProcesamiento, pgenerator)
{
}
public MyWork(IStrategyTodo pProcesamiento, IGenerateSerie pgenerator)
{
StrategyTodo = pProcesamiento;
generator = pgenerator;
}
public ClassBaseImpl(IGenerateSerie gen)
{
generator = gen;
}
public CallNextSyncIfNextMethodIsSync(IMyWorkSync pMyWork, IGetString pNext, IGenerateSerie gen, IUseMethod pMethod)
: base(pMyWork, pNext, gen, pMethod)
{
}
public Looping(IGenerateSerie gen, int count)
{
generateSerie = gen;
_count = count;
}
public Sleeping(IGenerateSerie gen, int count)
{
_generaSerie = gen;
_count = count;
}
public Launcher(IGenerateSerie generaSerie, IGetBase implementacion)
{
_generaSerie = generaSerie;
_implementacion = implementacion;
}
public CallNextAsyncWaitFirst(IMyWorkASync pMyWork, IGetStringAsync pNext, IGenerateSerie gen, IUseMethod pMethod)
: base(pMyWork, pNext, gen, pMethod)
{
}
private static IGetStringAsync GetInstanceAsync(IUseMethod method, IGenerateSerie reporter, IGetBase lastClass)
{
if (method == null)
{
return(null);
}
var processing = StrategyTodoFactory.GetInstance(method.TypeDoIndependentWork, reporter, method.NumSteps);
IStrategyTodo todo = StrategyTodoFactory.GetInstance(method.TypeDoIndependentWork, reporter, method.NumSteps);
MyWorkAsync myW = null;
switch (method.StrategyDoIndependentWork)
{
case EStrategyDoIndependentWork.WRAPPER_ASYNC:
myW = new MyWorkAsyncWait(todo, reporter);
break;
case EStrategyDoIndependentWork.WRAPPER_ASYNC_AWAITER:
myW = new MyWorkAsyncAwaiter(todo, reporter);
break;
case EStrategyDoIndependentWork.NORMAL:
myW = new MyWorkAsyncNotWait(todo, reporter);
break;
}
if (method.Next == null)
{
return(new MainAsyncFinal(myW, reporter, processing, method));
}
else
{
IGetStringAsync result = null;
if (lastClass is IGetStringAsync)
{
switch (method.CallNext)
{
case ECallNext.WAIT_FIRST:
result = new CallNextAsyncWaitFirst(myW, (IGetStringAsync)lastClass, reporter, method);
break;
case ECallNext.WAIT_AFTER:
result = new CallNextAsyncWaitAfter(myW, (IGetStringAsync)lastClass, reporter, method);
break;
case ECallNext.AWAITER_AFTER:
result = new CallNextAsyncAwaiter(myW, (IGetStringAsync)lastClass, reporter, method);
break;
case ECallNext.NOT_WAIT:
result = new CallNextAsyncNotWait(myW, (IGetStringAsync)lastClass, reporter, method);
break;
}
}
else
{
result = new CallNextAsyncToSync(myW, (IGetString)lastClass, reporter, method);
}
return(result);
}
}
public MethodSyncWithNext(IMyWorkSync pMyWork, IGetBase pNext, IGenerateSerie gen, IUseMethod pMethod)
: base(pMyWork, gen, pMethod)
{
Next = pNext;
}
public MethodSync(IMyWorkSync pMyWork, IGenerateSerie gen, IUseMethod pMethod)
: base(gen, pMethod)
{
DoIndependetWork = pMyWork;
}
public CallNextSyncWaitAfterIfNextMethodIsAsync(IMyWorkSync pMyWork, IGetStringAsync pNext, IGenerateSerie gen, IUseMethod pMethod)
: base(pMyWork, pNext, gen, pMethod)
{
}
