static BuilderObjetoDatos()
{
_rnd = new Random();
_delegados = new Dictionary <Type, Action <IObjetoDatos, IPropiedad> >(16);
_delegados[typeof(bool)] = (od, propiedad) => od.EstablecerBoolean(propiedad, true);
_delegados[typeof(byte)] = (od, propiedad) => od.EstablecerByte(propiedad, byte.MaxValue);
_delegados[typeof(char)] = (od, propiedad) => od.EstablecerChar(propiedad, char.MaxValue);
_delegados[typeof(DateTime)] = (od, propiedad) => od.EstablecerDateTime(propiedad, DateTime.Now); //DateTime.MaxValue);
_delegados[typeof(decimal)] = (od, propiedad) => od.EstablecerDecimal(propiedad, (decimal)_rnd.NextDouble() * _rnd.Next()); //decimal.MaxValue);
_delegados[typeof(double)] = (od, propiedad) => od.EstablecerDouble(propiedad, _rnd.NextDouble() * _rnd.Next()); //double.MaxValue);
_delegados[typeof(float)] = (od, propiedad) => od.EstablecerFloat(propiedad, float.MaxValue);
_delegados[typeof(int)] = (od, propiedad) => od.EstablecerInteger(propiedad, int.MaxValue);
_delegados[typeof(long)] = (od, propiedad) => od.EstablecerLong(propiedad, long.MaxValue);
_delegados[typeof(sbyte)] = (od, propiedad) => od.EstablecerSByte(propiedad, sbyte.MaxValue);
_delegados[typeof(short)] = (od, propiedad) => od.EstablecerShort(propiedad, short.MaxValue);
_delegados[typeof(string)] = (od, propiedad) => od.EstablecerString(propiedad, "texto");
_delegados[typeof(uint)] = (od, propiedad) => od.EstablecerUInteger(propiedad, uint.MaxValue);
_delegados[typeof(ulong)] = (od, propiedad) => od.EstablecerULong(propiedad, ulong.MaxValue);
_delegados[typeof(ushort)] = (od, propiedad) => od.EstablecerUShort(propiedad, ushort.MaxValue);
_tipo = HelperTipo.ObtenerTipo(); // BuilderTipo.Construir();
_od = Construir(_tipo, 1, 6);
_od.EstablecerInteger("atributoId", 0);
_od.EstablecerString("atributoString", "Objeto agregado");
}
public static IObjetoDatos Construir(ITipo tipo, int niveles, int items)
{
IObjetoDatos od = Fabrica.Instancia.Crear(tipo);
Construir(od, niveles, items);
return(od);
}
public MetodoEscrituraTipo(IModeloEscritura modelo, IEscritor escritor, IMetodoEscritura metodoEscritura, IObjetoDatos od, int refid)
: base(modelo, escritor)
{
_od = od;
_tipo = od.Tipo;
_refid = refid;
_metodo = Metodo.Tipo;
_metodoescritura = metodoEscritura;
}
private void AgregarTipo(ITipo tipo)
{
string clave = $"{tipo.Uri}.{tipo.Nombre}";
if (!_tipos.ContainsKey(clave))
{
_tipos.Add(clave, tipo);
}
}
public IPropiedad Leer(ITipo contexto)
{
IPropiedad propiedad = null;
if (_reader.MoveToNextAttribute())
{
propiedad = contexto[_reader.Name];
}
return(propiedad);
}
private void ConstruirTipos(ITipo contexto)
{
var propiedades = from propiedad in contexto.Propiedades
where !propiedad.Tipo.EsTipoDeDato && propiedad.Asociacion == Estructura.Asociacion.Agregacion
select propiedad;
foreach (IPropiedad propiedad in propiedades)
{
ConstruirTipos(propiedad);
}
}
public EvaluarObjetoDatos()
{
_tipo = new Tipo();
BuilderTipo.Construir((Tipo)_tipo);
_tipox = new Tipo();
BuilderTipo.Construir2((Tipo)_tipox);
// eliminar propiedad "id"
if (_tipo.ContienePropiedad("atributoId"))
{
((Tipo)_tipo).RemoverPropiedad(_tipo["atributoId"]);
}
if (_tipox.ContienePropiedad("atributoId"))
{
((Tipo)_tipox).RemoverPropiedad(_tipox["atributoId"]);
}
}
static HelperDiagrama()
{
Tipo tipo = new Tipo();
tipo.AgregarPropiedad(new Propiedad {
Nombre = "ruta", Tipo = Primarios.String
});
BuilderTipo.Construir2(tipo);
_tipo = tipo;
tipo = new Tipo();
tipo.AgregarPropiedad(new Propiedad {
Nombre = "ruta", Tipo = Primarios.String
});
BuilderTipo.Construir3(tipo);
_tipox = tipo;
((Propiedad)_tipo.ObtenerPropiedad("ReferenciaObjetoDatos2")).Tipo = _tipo;
//((Propiedad)_tipo.ObtenerPropiedad("ReferenciaObjetoDatosItem2")).Tipo = _tipo;
}
private IObjetoDatos Instanciar(int refid, string uri, string nombre)
{
// obtener el tipo
ITipo tipo = _tipos[$"{uri}.{nombre}"];
IObjetoDatos od;
// instanciar el od
if (refid == 0) //(tipo == _od.Tipo)
{
od = _od;
}
else
{
od = Fabrica.Instancia.Crear(tipo);
}
// agregar el od
_stack.Agregar(od, refid);
return(od);
}
public IImplementacion Crear(ITipo tipo)
{
return(new Implementacion(tipo));
}
public void CrearDiagramaAgregacion()
{
IObjetoDatos od = HelperDiagrama.CrearObjetoDatosX();
Helper.Construir(od, 2, 5);
HelperDiagrama.EstablecerAtributoRuta(od);
ITipo tipoagr = od.Tipo.ObtenerPropiedad("ReferenciaObjetoDatos2").Tipo;
IObjetoDatos odagr = Helper.Crear(tipoagr);
IObjetoDatos odagr2 = Helper.Crear(tipoagr);
odagr.CrearObjetoDatos("ReferenciaObjetoDatos");
odagr.EstablecerObjetoDatos("ReferenciaObjetoDatos2", odagr2);
odagr2.EstablecerObjetoDatos("ReferenciaObjetoDatos2", odagr); // establecer referencia agregacion apuntando al contenedor (odgr)
od.EstablecerObjetoDatos("ReferenciaObjetoDatos2", odagr);
BuilderDiagrama helper = new BuilderDiagrama();
Diagrama diag = helper.Crear(od);
NodoReferencia nodoprop1 = (NodoReferencia)diag.Root.Nodos[0];
NodoReferencia nodoprop3 = (NodoReferencia)diag.Root.Nodos[2];
NodoObjeto nodoobj1 = (NodoObjeto)nodoprop1.Nodos[0];
NodoObjeto nodoobj3 = (NodoObjeto)nodoprop3.Nodos[0];
IPropiedad prop1 = od.Tipo.ObtenerPropiedad("ReferenciaObjetoDatos");
IPropiedad prop3 = od.Tipo.ObtenerPropiedad("ReferenciaObjetoDatos2");
IObjetoDatos obj1 = od.ObtenerObjetoDatos(prop1);
IObjetoDatos obj3 = od.ObtenerObjetoDatos(prop3);
Assert.IsNotNull(nodoprop1);
Assert.IsNotNull(nodoprop3);
Assert.IsNotNull(prop1);
Assert.IsNotNull(prop3);
Assert.IsNotNull(obj1);
Assert.IsNotNull(obj3);
Assert.AreEqual(prop1, nodoprop1.Propiedad);
Assert.AreEqual(prop3, nodoprop3.Propiedad);
Assert.AreEqual(obj1, nodoobj1.Objeto.ObjetoDatos);
Assert.AreEqual(obj3, nodoobj3.Objeto.ObjetoDatos);
Assert.AreEqual("/ReferenciaObjetoDatos", nodoobj1.Objeto.Propietario);
Assert.AreEqual("/ReferenciaObjetoDatos2", nodoobj3.Objeto.Propietario);
nodoprop1 = (NodoReferencia)nodoobj3.Nodos[0];
nodoprop3 = (NodoReferencia)nodoobj3.Nodos[1];
nodoobj1 = (NodoObjeto)nodoprop1.Nodos[0];
nodoobj3 = (NodoObjeto)nodoprop3.Nodos[0];
prop1 = odagr.Tipo.ObtenerPropiedad("ReferenciaObjetoDatos");
prop3 = odagr.Tipo.ObtenerPropiedad("ReferenciaObjetoDatos2");
obj1 = odagr.ObtenerObjetoDatos(prop1);
obj3 = odagr.ObtenerObjetoDatos(prop3);
Assert.IsNotNull(nodoprop1);
Assert.IsNotNull(nodoprop3);
Assert.IsNotNull(prop1);
Assert.IsNotNull(prop3);
Assert.IsNotNull(obj1);
Assert.IsNotNull(obj3);
Assert.AreEqual(prop1, nodoprop1.Propiedad);
Assert.AreEqual(prop3, nodoprop3.Propiedad);
Assert.AreEqual(obj1, nodoobj1.Objeto.ObjetoDatos);
Assert.AreEqual(odagr2, nodoobj3.Objeto.ObjetoDatos);
Assert.AreEqual("/ReferenciaObjetoDatos2/ReferenciaObjetoDatos", nodoobj1.Objeto.Propietario);
Assert.AreEqual("/ReferenciaObjetoDatos2/ReferenciaObjetoDatos2", nodoobj3.Objeto.Propietario);
// verificar la referencia odgr2.ReferenciaObjetoDatos2 => odagr
nodoprop1 = (NodoReferencia)nodoobj3.Nodos[0];
nodoobj1 = (NodoObjeto)nodoprop1.Nodos[0];
obj1 = odagr2.ObtenerObjetoDatos("ReferenciaObjetoDatos2");
Assert.AreEqual(odagr, obj1);
Assert.AreEqual("/ReferenciaObjetoDatos2", nodoobj1.Objeto.Propietario);
}
protected virtual IObjetoDatos CrearObjetoDatos(ITipo tipo)
{
return(Fabrica.Instancia.Crear(tipo));
}
public IObjetoDatos Crear(ITipo tipo, IObjetoDatos propietario)
{
return(Crear(FabricaImplementacion.Instancia.Crear(tipo, propietario)));
}
public abstract IImplementacion Crear(ITipo tipo, IObjetoDatos propietario);
public Contenido(ITipo tipo)
{
Tipo = tipo;
_caracteristicas = new Dictionary <IPropiedad, Caracteristica>(tipo.Propiedades.Count);
Construir();
}
public IObjetoDatosImpl Crear(ITipo tipo, ObjetoDatos propietario)
{
return(new DecoradorHistorial(_impl.Crear(tipo, propietario), _historial));
}
internal Implementacion(ITipo tipo, IObjetoDatos propietario)
: this(tipo)
{
_propietario = propietario;
}
public IPropiedad Leer(ITipo contexto)
{
int indice = _reader.ReadInt32();
return(contexto?[indice]);
}
//public override IImplementacion Crear(ITipo tipo)
//{
// return new HistorialImpl(_impl.Crear(tipo), _historial);
//}
public override IImplementacion Crear(ITipo tipo, IObjetoDatos propietario)
{
return(new HistorialImpl(_impl.Crear(tipo, propietario), _historial));
}
static HelperTipo()
{
BuilderTipo.Construir((Tipo)(_tipo = new Tipo()));
BuilderTipo.Construir2((Tipo)(_tipo2 = new Tipo()));
BuilderTipo.Construir3((Tipo)(_tipo3 = new Tipo()));
}
public override IImplementacion Crear(ITipo tipo, IObjetoDatos propietario)
{
return(new ImplementacionNotificacion(_impl.Crear(tipo, propietario)));
}
public static IObjetoDatos Crear(ITipo tipo, IFabrica fabrica)
{
return(fabrica.Crear(tipo));
}
public static IObjetoDatos Crear(ITipo tipo)
{
return(Fabrica.Instancia.Crear(tipo));
}
public static Type ObtenerType(ITipo tipo)
{
return(Type.GetType(string.Format("{0}.{1}", tipo.Uri, tipo.Nombre)));
}
public IImplementacion Crear(ITipo tipo, IObjetoDatos propietario)
{
return(new Implementacion(tipo, propietario));
}
IObjetoDatos IFabrica.Crear(ITipo tipo, IObjetoDatos propietario)
{
IImplementacion impl = Crear(tipo, propietario);
return(CrearObjetoDatos(impl));
}
internal Implementacion(ITipo tipo)
{
_impl = new Contenido(tipo);
}
