internal void NotificarRemover(IPropiedad propiedad, IObjetoDatos item, int indice)
 {
     Notificar(new NotificacionColeccion(ObjetoDatos, propiedad)
     {
         Accion = Accion.Remover, Item = item, Indice = indice
     });
 }
        public virtual void Leer(IObjetoDatos od)
        {
            if (od == null)
            {
                return;
            }

            int id = LeerId();

            if (!_oid.Existe(id))
            {
                _oid.Agregar(od, id);
            }

            Tipo = od.Tipo;
            IPropiedad propiedad = Leer();

            while (propiedad != null)
            {
                //System.Diagnostics.Debug.WriteLine(string.Format("[id={0}] - {1}", id, propiedad.Nombre));

                Leer(od, propiedad);
                propiedad = Leer();
            }
        }
Exemplo n.º 3
0
        public void EvaluarObjetoDatosComplejoRemoverUnItem()
        {
            IObjetoDatos od = Helper.Crear(_tipox);

            Helper.Construir(od, 1, 3);
            od.RemoverObjetoDatos("ReferenciaObjetoDatosItem", od.ObtenerColeccion("ReferenciaObjetoDatosItem")[0]);
            Assert.AreEqual(od.ObtenerColeccion("ReferenciaObjetoDatosItem").Longitud, 2);
        }
Exemplo n.º 4
0
 public void Agregar(IObjetoDatos od, int id)
 {
     if (_ids.ContainsKey(id))
     {
         return;
     }
     _ids.Add(id, od);
 }
        public static string ObtenerString(IObjetoDatos od, string ruta)
        {
            IObjetoDatos referencia;
            IPropiedad   propiedad;

            Resolver(od, ruta, out referencia, out propiedad);

            return(referencia != null && propiedad != null ? referencia.ObtenerString(propiedad) : default(string));
        }
Exemplo n.º 6
0
 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;
 }
Exemplo n.º 7
0
        public EscritorObjetoDatos(IEscritor escritor, IObjetoDatos od)
        {
            _escritor = escritor;
            _od       = od;

            _propiedades = from propiedad in _od.Tipo.Propiedades
                           where propiedad.Tipo.EsTipoDeDato && _od.Establecido(propiedad)
                           select propiedad;
        }
        internal ModeloLectura(ILector lector, IObjetoDatos od)
        {
            _lector       = lector;
            _od           = od;
            _stack        = new Identidad();
            _asociaciones = new List <IMetodoAsociacion>();

            ConstruirTipos();
        }
Exemplo n.º 9
0
        private void ConstruirNodos(Root root)
        {
            IObjetoDatos od = root.Objeto.ObjetoDatos;

            foreach (IPropiedad propiedad in od.Tipo.Propiedades)
            {
                CrearPropiedad(root, propiedad);
            }
        }
 public ModeloEscritura(IEscritor escritor, IObjetoDatos od)
 {
     _escritor = escritor;
     _stack    = new Identidad();
     _od       = new List <IObjetoDatos>()
     {
         od
     };
 }
Exemplo n.º 11
0
        /// <summary>
        /// Obtiene el identificador a partir del objeto de datos.
        /// </summary>
        public int Obtener(IObjetoDatos od)
        {
            if (!_identidades.Contains(od))
            {
                _identidades.Add(od);
            }

            return(_identidades.IndexOf(od));
        }
        public void DeshacerCambiosEnObjetoDatos()
        {
            // arrange
            Log controlador = new Log();
            //FabricaHistorial fabrica = new FabricaHistorial();
            IFabrica     fabrica = new FabricaHistorial(controlador);
            IObjetoDatos od      = fabrica.Crear(HelperTipo.ObtenerTipo());

            // act
            bool     valorBoolean  = od.ObtenerBoolean(0);
            byte     valorByte     = od.ObtenerByte(1);
            char     valorChar     = od.ObtenerChar(2);
            DateTime valorDateTime = od.ObtenerDateTime(3);
            var      valorDecimal  = od.ObtenerDecimal(4);
            var      valorDouble   = od.ObtenerDouble(5);
            var      valorFloat    = od.ObtenerFloat(6);
            var      valorInteger  = od.ObtenerInteger(7);
            var      valorLong     = od.ObtenerLong(8);
            var      valorSByte    = od.ObtenerSByte(9);
            var      valorShort    = od.ObtenerShort(10);
            var      valorString   = od.ObtenerString(11);
            var      valorUInteger = od.ObtenerUInteger(12);
            var      valorULong    = od.ObtenerULong(13);
            var      valorUShort   = od.ObtenerUShort(14);

            // establecer valores
            //EstablecerValoresPorIndice(od);
            Helper.Construir(od);

            // deshacer cambios
            controlador.Deshacer();

            //// establecer valores
            ////EstablecerValoresPorTipoPorIndice(od);
            //Helper.Construir(od);

            //// deshacer cambios
            //controlador.Deshacer();

            // assert
            Assert.AreEqual(od.ObtenerBoolean(0), valorBoolean, $"Se esperaba {valorBoolean}");
            Assert.AreEqual(od.ObtenerByte(1), valorByte, $"Se esperaba {valorByte}");
            Assert.AreEqual(od.ObtenerChar(2), valorChar, $"Se esperaba {valorChar}");
            Assert.AreEqual(od.ObtenerDateTime(3), valorDateTime, $"Se esperaba {valorDateTime}");
            Assert.AreEqual(od.ObtenerDecimal(4), valorDecimal, $"Se esperaba {valorDecimal}");
            Assert.AreEqual(od.ObtenerDouble(5), valorDouble, $"Se esperaba {valorDouble}");
            Assert.AreEqual(od.ObtenerFloat(6), valorFloat, $"Se esperaba {valorFloat}");
            Assert.AreEqual(od.ObtenerInteger(7), valorInteger, $"Se esperaba {valorInteger}");
            Assert.AreEqual(od.ObtenerLong(8), valorInteger, $"Se esperaba {valorInteger}");
            Assert.AreEqual(od.ObtenerSByte(9), valorSByte, $"Se esperaba {valorSByte}");
            Assert.AreEqual(od.ObtenerShort(10), valorShort, $"Se esperaba {valorShort}");
            Assert.AreEqual(od.ObtenerString(11), valorString, $"Se esperaba {valorString ?? ""}");
            Assert.AreEqual(od.ObtenerUInteger(12), valorUInteger, $"Se esperaba {valorUInteger}");
            Assert.AreEqual(od.ObtenerULong(13), valorULong, $"Se esperaba {valorULong}");
            Assert.AreEqual(od.ObtenerUShort(14), valorUShort, $"Se esperaba {valorUShort}");
        }
Exemplo n.º 13
0
        public void EvaluarObjetoDatosPathObtenerPorTipo()
        {
            IObjetoDatos od = Helper.Crear(_tipox);

            Helper.Construir(od, 2, 0);

            string ruta = "ReferenciaObjetoDatos";

            bool     valorBoolean  = true;
            byte     valorByte     = 125;
            char     valorChar     = 'D';
            DateTime valorDateTime = DateTime.Now;
            decimal  valorDecimal  = new decimal(15896658.100245);
            double   valorDouble   = 448995.55698;
            float    valorFloat    = (float)56625.55;
            int      valorInteger  = -102458;
            long     valorLong     = -89665522321;
            sbyte    valorSByte    = 89;
            short    valorShort    = 5444;
            string   valorString   = "cadena de texto";
            uint     valorUInteger = 89955212;
            ulong    valorULong    = 788554421056;
            ushort   valorUShort   = 9035;

            od.EstablecerBoolean($"{ruta}/atributoBoolean", valorBoolean);
            od.EstablecerByte($"{ruta}/atributoByte", valorByte);
            od.EstablecerChar($"{ruta}/atributoChar", valorChar);
            od.EstablecerDateTime($"{ruta}/atributoDateTime", valorDateTime);
            od.EstablecerDecimal($"{ruta}/atributoDecimal", valorDecimal);
            od.EstablecerDouble($"{ruta}/atributoDouble", valorDouble);
            od.EstablecerFloat($"{ruta}/atributoFloat", valorFloat);
            od.EstablecerInteger($"{ruta}/atributoInteger", valorInteger);
            od.EstablecerLong($"{ruta}/atributoLong", valorLong);
            od.EstablecerSByte($"{ruta}/atributoSByte", valorSByte);
            od.EstablecerShort($"{ruta}/atributoShort", valorShort);
            od.EstablecerString($"{ruta}/atributoString", valorString);
            od.EstablecerUInteger($"{ruta}/atributoUInteger", valorUInteger);
            od.EstablecerULong($"{ruta}/atributoULong", valorULong);
            od.EstablecerUShort($"{ruta}/atributoUShort", valorUShort);

            Assert.AreEqual(valorBoolean, od.ObtenerBoolean($"{ruta}/atributoBoolean"));
            Assert.AreEqual(valorByte, od.ObtenerByte($"{ruta}/atributoByte"));
            Assert.AreEqual(valorChar, od.ObtenerChar($"{ruta}/atributoChar"));
            Assert.AreEqual(valorDateTime, od.ObtenerDateTime($"{ruta}/atributoDateTime"));
            Assert.AreEqual(valorDecimal, od.ObtenerDecimal($"{ruta}/atributoDecimal"));
            Assert.AreEqual(valorDouble, od.ObtenerDouble($"{ruta}/atributoDouble"));
            Assert.AreEqual(valorFloat, od.ObtenerFloat($"{ruta}/atributoFloat"));
            Assert.AreEqual(valorInteger, od.ObtenerInteger($"{ruta}/atributoInteger"));
            Assert.AreEqual(valorLong, od.ObtenerLong($"{ruta}/atributoLong"));
            Assert.AreEqual(valorSByte, od.ObtenerSByte($"{ruta}/atributoSByte"));
            Assert.AreEqual(valorShort, od.ObtenerShort($"{ruta}/atributoShort"));
            Assert.AreEqual(valorString, od.ObtenerString($"{ruta}/atributoString"));
            Assert.AreEqual(valorUInteger, od.ObtenerUInteger($"{ruta}/atributoUInteger"));
            Assert.AreEqual(valorULong, od.ObtenerULong($"{ruta}/atributoULong"));
            Assert.AreEqual(valorUShort, od.ObtenerUShort($"{ruta}/atributoUShort"));
        }
 void Leer(IObjetoDatos od, IPropiedad propiedad)
 {
     if (propiedad.Tipo.EsTipoDeDato)
     {
         LeerAtributo(od, propiedad);
     }
     else
     {
         LeerReferencia(od, propiedad);
     }
 }
 protected void EstablecerObjetoDatos(string ruta, IObjetoDatos valor)
 {
     if (helper.ComprobarRuta(ref ruta))
     {
         helper.EstablecerObjetoDatos(this, ruta, valor);
     }
     else
     {
         _impl.EstablecerObjetoDatos(Tipo.ObtenerPropiedad(ruta), valor);
     }
 }
 public static void ConstruirObjetoDatos(IObjetoDatos od)
 {
     if (od.Tipo == _tipo)
     {
         Test.Helper.Construir(od);
     }
     else if (od.Tipo == _tipox)
     {
         Test.Helper.Construir(od, 2, 5);
     }
 }
        private IMetodoEscritura Crear(IObjetoDatos od)
        {
            IMetodoEscritura metodo;
            IMetodoEscritura metodood;
            int refid = _stack.Obtener(od);

            metodood = new MetodoEscrituraObjetoDatos(this, _escritor, od, refid);
            metodo   = new MetodoEscrituraTipo(this, _escritor, metodood, od, refid);

            return(metodo);
        }
Exemplo n.º 18
0
        private int ResolverIndice(IPropiedad propiedad, IObjetoDatos item)
        {
            int indice = 0;

            if (propiedad.Cardinalidad >= Cardinalidad.Muchos)
            {
                indice = _impl.ObtenerColeccion(propiedad).Indice(item);
            }

            return(indice);
        }
        public MetodoEscrituraObjetoDatos(IModeloEscritura modelo, IEscritor escritor, IObjetoDatos od, int refid)
            : base(modelo, escritor)
        {
            EscritorObjetoDatos escritorod = new EscritorObjetoDatos(escritor, od);

            _longitud   = escritorod.Longitud;
            _escritorod = escritorod;
            _refid      = refid;
            _od         = od;
            _metodo     = Metodo.ObjetoDatos;
        }
Exemplo n.º 20
0
 private void ActualizarColeccion(IObjetoDatos od, IPropiedad propiedad, Accion accion, IObjetoDatos item, int indice)
 {
     if (accion == Accion.Agregar)
     {
         CrearObservador(item, ObjetoDatos.CrearObjetoDatos(propiedad));
     }
     else if (accion == Accion.Remover)
     {
         ObjetoDatos.RemoverObjetoDatos(propiedad, ObjetoDatos.ObtenerColeccion(propiedad)[indice]);
     }
 }
Exemplo n.º 21
0
 private void ActualizarPropiedad(IObjetoDatos od, IPropiedad propiedad)
 {
     if (propiedad.Tipo.EsTipoDeDato || propiedad.Asociacion == Asociacion.Agregacion || od.ObtenerObjetoDatos(propiedad) == null)
     {
         ObjetoDatos.Establecer(propiedad, od.Obtener(propiedad));
     }
     else if (propiedad.Asociacion == Asociacion.Composicion)
     {
         CrearObservador(od.ObtenerObjetoDatos(propiedad), ObjetoDatos.CrearObjetoDatos(propiedad));
     }
 }
 protected void RemoverObjetoDatos(string ruta, IObjetoDatos item)
 {
     if (helper.ComprobarRuta(ref ruta))
     {
         helper.RemoverObjetoDatos(this, ruta, item);
     }
     else
     {
         _impl.RemoverObjetoDatos(Tipo[ruta], item);
     }
 }
Exemplo n.º 23
0
 public ObjetoMap Obtener(IObjetoDatos od)
 {
     if (!_maps.ContainsKey(od))
     {
         return(Crear(od));
     }
     else
     {
         return(_maps[od]);
     }
 }
Exemplo n.º 24
0
        private static void ConstruirColeccion(IObjetoDatos od, IPropiedad propiedad, int niveles, int items)
        {
            if (niveles == 0)
            {
                return;
            }

            for (int i = 1; i <= items; i++)
            {
                Construir(od.CrearObjetoDatos(propiedad), (niveles - 1), items);
            }
        }
Exemplo n.º 25
0
        public Diagrama Crear(IObjetoDatos od)
        {
            _heap = new Heap();
            _diag = new Diagrama();
            _agre = new Dictionary <IObjetoDatos, NodoObjeto>();

            CrearRoot(od);
            ConstruirNodos(_diag.Root);
            ResolverNodos();

            return(_diag);
        }
Exemplo n.º 26
0
        void CrearObservador(IObjetoDatos od1, IObjetoDatos od2)
        {
            if (od1 == null || od2 == null)
            {
                return;
            }

            Observable observable = ((ObjetoBase)od1).Observable();
            Observador observador = new Observador(od2);

            observable.Agregar(observador);
        }
Exemplo n.º 27
0
        public void EvaluarEstablecerPorIndice()
        {
            IObjetoDatos od  = Fabrica.Instancia.Crear(_tipo);
            Random       rnd = new Random();

            bool     valorBoolean  = true;
            byte     valorByte     = byte.MaxValue;
            char     valorChar     = char.MaxValue;
            DateTime valorDateTime = DateTime.MaxValue;
            decimal  valorDecimal  = decimal.MaxValue;
            double   valorDouble   = double.MaxValue;
            float    valorFloat    = float.MaxValue;
            int      valorInteger  = int.MaxValue;
            long     valorLong     = long.MaxValue;
            sbyte    valorSByte    = sbyte.MaxValue;
            short    valorShort    = short.MaxValue;
            string   valorString   = "abcdefghijklmnoprstuvwxyz";
            uint     valorUInteger = uint.MaxValue;
            ulong    valorULong    = ulong.MaxValue;
            ushort   valorUShort   = ushort.MaxValue;

            od.Establecer(0, valorBoolean);
            od.Establecer(1, valorByte);
            od.Establecer(2, valorChar);
            od.Establecer(3, valorDateTime);
            od.Establecer(4, valorDecimal);
            od.Establecer(5, valorDouble);
            od.Establecer(6, valorFloat);
            od.Establecer(7, valorInteger);
            od.Establecer(8, valorLong);
            od.Establecer(9, valorSByte);
            od.Establecer(10, valorShort);
            od.Establecer(11, valorString);
            od.Establecer(12, valorUInteger);
            od.Establecer(13, valorULong);
            od.Establecer(14, valorUShort);

            Assert.AreEqual(od.Obtener(0), valorBoolean);
            Assert.AreEqual(od.Obtener(1), valorByte);
            Assert.AreEqual(od.Obtener(2), valorChar);
            Assert.AreEqual(od.Obtener(3), valorDateTime);
            Assert.AreEqual(od.Obtener(4), valorDecimal);
            Assert.AreEqual(od.Obtener(5), valorDouble);
            Assert.AreEqual(od.Obtener(6), valorFloat);
            Assert.AreEqual(od.Obtener(7), valorInteger);
            Assert.AreEqual(od.Obtener(8), valorLong);
            Assert.AreEqual(od.Obtener(9), valorSByte);
            Assert.AreEqual(od.Obtener(10), valorShort);
            Assert.AreEqual(od.Obtener(11), valorString);
            Assert.AreEqual(od.Obtener(12), valorUInteger);
            Assert.AreEqual(od.Obtener(13), valorULong);
            Assert.AreEqual(od.Obtener(14), valorUShort);
        }
        public static void EstablecerUShort(IObjetoDatos od, string ruta, ushort valor)
        {
            IObjetoDatos referencia;
            IPropiedad   propiedad;

            Resolver(od, ruta, out referencia, out propiedad);

            if (referencia != null && propiedad != null)
            {
                referencia.EstablecerUShort(propiedad, valor);
            }
        }
        internal static void RemoverObjetoDatos(IObjetoDatos od, string ruta, IObjetoDatos item)
        {
            IObjetoDatos referencia;
            IPropiedad   propiedad;

            Resolver(od, ruta, out referencia, out propiedad);

            if (referencia != null && propiedad != null)
            {
                referencia.RemoverObjetoDatos(propiedad, item);
            }
        }
Exemplo n.º 30
0
        public void EvaluarEstablecerPorNombre()
        {
            IObjetoDatos od  = Fabrica.Instancia.Crear(_tipo);
            Random       rnd = new Random();

            bool     valorBoolean  = true;
            byte     valorByte     = byte.MaxValue;
            char     valorChar     = char.MaxValue;
            DateTime valorDateTime = DateTime.MaxValue;
            decimal  valorDecimal  = decimal.MaxValue;
            double   valorDouble   = double.MaxValue;
            float    valorFloat    = float.MaxValue;
            int      valorInteger  = int.MaxValue;
            long     valorLong     = long.MaxValue;
            sbyte    valorSByte    = sbyte.MaxValue;
            short    valorShort    = short.MaxValue;
            string   valorString   = "abcdefghijklmnoprstuvwxyz";
            uint     valorUInteger = uint.MaxValue;
            ulong    valorULong    = ulong.MaxValue;
            ushort   valorUShort   = ushort.MaxValue;

            od.Establecer("atributoBoolean", valorBoolean);
            od.Establecer("atributoByte", valorByte);
            od.Establecer("atributoChar", valorChar);
            od.Establecer("atributoDateTime", valorDateTime);
            od.Establecer("atributoDecimal", valorDecimal);
            od.Establecer("atributoDouble", valorDouble);
            od.Establecer("atributoFloat", valorFloat);
            od.Establecer("atributoInteger", valorInteger);
            od.Establecer("atributoLong", valorLong);
            od.Establecer("atributoSByte", valorSByte);
            od.Establecer("atributoShort", valorShort);
            od.Establecer("atributoString", valorString);
            od.Establecer("atributoUInteger", valorUInteger);
            od.Establecer("atributoULong", valorULong);
            od.Establecer("atributoUShort", valorUShort);

            Assert.AreEqual(od.Obtener("atributoBoolean"), valorBoolean);
            Assert.AreEqual(od.Obtener("atributoByte"), valorByte);
            Assert.AreEqual(od.Obtener("atributoChar"), valorChar);
            Assert.AreEqual(od.Obtener("atributoDateTime"), valorDateTime);
            Assert.AreEqual(od.Obtener("atributoDecimal"), valorDecimal);
            Assert.AreEqual(od.Obtener("atributoDouble"), valorDouble);
            Assert.AreEqual(od.Obtener("atributoFloat"), valorFloat);
            Assert.AreEqual(od.Obtener("atributoInteger"), valorInteger);
            Assert.AreEqual(od.Obtener("atributoLong"), valorLong);
            Assert.AreEqual(od.Obtener("atributoSByte"), valorSByte);
            Assert.AreEqual(od.Obtener("atributoShort"), valorShort);
            Assert.AreEqual(od.Obtener("atributoString"), valorString);
            Assert.AreEqual(od.Obtener("atributoUInteger"), valorUInteger);
            Assert.AreEqual(od.Obtener("atributoULong"), valorULong);
            Assert.AreEqual(od.Obtener("atributoUShort"), valorUShort);
        }