Esempio n. 1
0
        private void CrearObjeto(NodoReferencia nodo, IColeccion col)
        {
            int i = 0;

            foreach (IObjetoDatos od in col)
            {
                CrearObjeto(nodo, od, i++);
            }
        }
Esempio n. 2
0
        private void CrearObjeto(NodoReferencia nodo)
        {
            IObjetoDatos od        = ((NodoObjeto)nodo.Padre).Objeto.ObjetoDatos;
            IPropiedad   propiedad = nodo.Propiedad;

            // crear nodos hijos
            if (propiedad.Cardinalidad >= Cardinalidad.Muchos)
            {
                CrearObjeto(nodo, od.ObtenerColeccion(propiedad));
            }
            else
            {
                CrearObjeto(nodo, od.ObtenerObjetoDatos(propiedad));
            }
        }
Esempio n. 3
0
        private void CrearPropiedad(NodoObjeto nodo, IPropiedad propiedad)
        {
            if (propiedad.Tipo.EsTipoDeDato)
            {
                return;
            }

            IObjetoDatos od = nodo.Objeto.ObjetoDatos;

            if (!od.Establecido(propiedad))
            {
                return;
            }

            // crear nodo
            NodoReferencia nodoprop = new NodoReferencia(nodo, propiedad);

            nodo.Agregar(nodoprop);

            // crear nodos hijos
            CrearObjeto(nodoprop);
        }
 public NodoObjeto(NodoReferencia padre, ObjetoMap omap)
     : base(padre)
 {
     Objeto = omap;
 }
Esempio n. 5
0
 private void CrearObjeto(NodoReferencia nodo, IObjetoDatos od)
 {
     CrearObjeto(nodo, od, 0);
 }
Esempio n. 6
0
        private void CrearObjeto(NodoReferencia nodo, IObjetoDatos od, int indice)
        {
            if (od == null)
            {
                return;
            }

            ObjetoMap omap = _heap.Obtener(od);

            if (omap == null)
            {
                return;
            }

            // crear nodo
            NodoObjeto nodoobj = new NodoObjeto(nodo, omap);

            nodo.Agregar(nodoobj);

            // establecer valores
            string ruta        = ((NodoObjeto)nodo.Padre).Ruta;
            bool   composicion = (nodo.Propiedad.Asociacion == Asociacion.Composicion);

            if (nodo.Propiedad.Cardinalidad >= Cardinalidad.Muchos)
            {
                ruta = string.Format("{0}/{1}[{2}]", ruta, nodo.Propiedad.Nombre, indice);
            }
            else
            {
                ruta = string.Format("{0}/{1}", ruta, nodo.Propiedad.Nombre);
            }

            nodoobj.Ruta   = ruta;
            nodoobj.Indice = indice;

            // determinar si debe resolverse
            bool resol = (composicion || _resol) && string.IsNullOrEmpty(omap.Propietario);

            // establecer referencia agregacion
            if (!resol)
            {
                // le referencia agregacion es proxy, hasta que se resuelva
                nodoobj.EsProxy = true;
                // se mantiene la primera referencia
                if (!_agre.ContainsKey(od))
                {
                    _agre.Add(od, nodoobj);
                }
                return;
            }

            // establecer propietario
            omap.Propietario = ruta;

            // eliminar referencia resuelta
            if (_agre.ContainsKey(od))
            {
                _agre.Remove(od);
            }

            // crear nodos hijos
            CrearPropiedad(nodoobj);
        }