protected void GetFieldDataDefault(IVO pOutput)
{
pOutput.Codigo = GetInt32(Ordinal.BaseField.Codigo, Ordinal.Codigo);
pOutput.Ativo = GetBoolean(Ordinal.BaseField.Ativo, Ordinal.Ativo);
pOutput.CodigoUsuarioCadastro = GetInt32(Ordinal.BaseField.CodigoUsuarioCadastro, Ordinal.CodigoUsuarioCadastro);
pOutput.Cadastro = GetDateTime(Ordinal.BaseField.Cadastro, Ordinal.Cadastro);
pOutput.CodigoUsuarioAtualizacao = GetInt32(Ordinal.BaseField.CodigoUsuarioAtualizacao, Ordinal.CodigoUsuarioAtualizacao);
pOutput.Atualizacao = GetDateTime(Ordinal.BaseField.Atualizacao, Ordinal.Atualizacao);
}
public virtual bool Setup(MonoBehaviour rootContainer, IVO vo)
{
if (this._view == null && this._setupVO == null && rootContainer != null && vo is SetupVO)
{
this._view = rootContainer;
this._setupVO = vo as SetupVO;
return(true);
}
return(false);
}
private static void MoveIvo(IVO ivo, int[,] matrix)
{
while (ivo.Row >= 0)
{
if (ivo.Row < matrix.GetLength(0) && ivo.Col >= 0 && ivo.Col < matrix.GetLength(1))
{
ivo.CollectPoints(matrix[ivo.Row, ivo.Col]);
}
ivo.UpdateCoordinates(ivo.Row - 1, ivo.Col + 1);
}
}
public static TEntity CreateEntity <TEntity>(this IVO <TEntity> vo)
where TEntity : new()
{
if (vo != null)
{
var _result = new TEntity();
vo.CopyTo(ref _result);
return(_result);
}
else
{
return(default(TEntity));
}
}
private static void UpdateCoordinates(string command, IVO ivo, EVIL evil)
{
var ivoCoordinates = command
.Split(' ')
.Select(int.Parse)
.ToArray();
ivo.UpdateCoordinates(ivoCoordinates[0], ivoCoordinates[1]);
command = Console.ReadLine();
var evilCoordinates = command
.Split(' ')
.Select(int.Parse)
.ToArray();
evil.UpdateCoordinates(evilCoordinates[0], evilCoordinates[1]);
}
public virtual IVO GetData()
{
try
{
IVO lRetorno = GetFieldData();
GetFieldDataDefault(lRetorno);
GetSiblingsData(lRetorno);
return(lRetorno);
}
catch (Exception ex)
{
throw new DALException(ex.Message,
System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name,
System.Reflection.MethodBase.GetCurrentMethod().Name,
"Não foi possível ler os dados.", ex);
}
}
static void Main(string[] args)
{
short[] sizes = Console.ReadLine()
.Split(' ')
.Select(short.Parse)
.ToArray();
var matrix = InitializeMatrix(sizes);
var ivo = new IVO();
var evil = new EVIL();
string command;
while ((command = Console.ReadLine()) != "Let the Force be with you")
{
UpdateCoordinates(command, ivo, evil);
MoveEvil(evil, matrix);
MoveIvo(ivo, matrix);
}
Console.WriteLine(ivo.Score);
}
public virtual void GetSiblingsData(IVO pRetorno)
{
}
public virtual void SetOutputParameters(IVO pObjeto)
{
}
public abstract void GetPersistenceParameters(IVO pObjeto);
public bool SetData(IVO vo)
{
this._vo = vo;
return(true);
}
protected void assumeFail(TestContext tc, string blob, IVO.CMS.SemanticError[] expectedErrors, SemanticWarning[] expectedWarnings)
{
var bl = new MemoryStreamedBlob(blob);
assumeFail(tc, bl, new TreeID(), expectedErrors, expectedWarnings);
}
protected void assumeFail(string blob, IVO.CMS.SemanticError[] expectedErrors, SemanticWarning[] expectedWarnings)
{
var tc = getTestContext();
assumeFail(tc, blob, expectedErrors, expectedWarnings);
}
protected void assumeFail(TestContext tc, TreePathStreamedBlob item, IVO.CMS.SemanticError[] expectedErrors, SemanticWarning[] expectedWarnings)
{
output(item);
var fragTask = tc.ce.RenderBlob(item);
fragTask.Wait();
var efrag = fragTask.Result;
Assert.IsFalse(efrag.HasErrors);
var frag = efrag.Value;
output(frag);
var errors = tc.ce.GetErrors();
if (errors.Count > 0)
{
Console.Error.WriteLine("Error(s):");
foreach (var err in errors)
{
Console.Error.WriteLine(" {0} ({1}:{2}): {3}", err.Item.TreeBlobPath.Path, err.LineNumber, err.LinePosition, err.Message);
}
}
var warns = tc.ce.GetWarnings();
if (warns.Count > 0)
{
Console.Error.WriteLine("Warning(s):");
foreach (var warn in warns)
{
Console.Error.WriteLine(" {0} ({1}:{2}): {3}", warn.Item.TreeBlobPath.Path, warn.LineNumber, warn.LinePosition, warn.Message);
}
}
Assert.AreEqual(expectedErrors.Length, errors.Count);
CollectionAssert.AreEqual(expectedErrors, errors, new SemanticErrorMessageComparer());
Assert.AreEqual(expectedWarnings.Length, warns.Count);
CollectionAssert.AreEqual(expectedWarnings, warns, new SemanticWarningMessageComparer());
}
protected void assumeFail(TestContext tc, IStreamedBlob bl, TreeID rootid, IVO.CMS.SemanticError[] expectedErrors, SemanticWarning[] expectedWarnings)
{
var item = new TreePathStreamedBlob(rootid, (CanonicalBlobPath)"/test", bl);
assumeFail(tc, item, expectedErrors, expectedWarnings);
}
