Package org.itsnat.impl.core.clientdoc

Examples of org.itsnat.impl.core.clientdoc.NodeCacheRegistryImpl


        this.nodeLocationDeleg = getNodeLocationNotParent(node, id, path, clientDoc);

        this.cachedParent = cachedParent;
        this.cachedParentId = cachedParentId;

        NodeCacheRegistryImpl nodeCache = clientDoc.getNodeCacheRegistry();
        if ((nodeCache != null) && cacheIfPossible) // Aunque est� cacheado el nodo principal aprovechamos para cachear los padres.
        {
            // Cacheamos unos cuantos padres inmediatos para que los nodos "adyacentes" (de la zona en general)
            // puedan encontrarse m�s r�pidamente, sobre todo si el cachedParent no se encontr� o est� muy arriba.

            int maxParents = 3; // Un valor razonable para evitar cachear en exceso nodos padre (y enviar demasiado JavaScript)
                                // que a lo mejor no se usan nunca ni para el c�lculo de paths
            Node currParent = node.getParentNode();
            for(int i = 0; (currParent != null) && (currParent != cachedParent) && (i < maxParents); i++)
            {
                String parentId = nodeCache.getId(currParent);
                if (parentId == null) // No cacheado
                {
                    parentId = nodeCache.addNode(currParent);
                    if (parentId != null)
                    {
                        // Hemos cacheado un nuevo nodo, DEBEMOS LLAMAR toJSArray y enviar al cliente
                        // de otra manera el cliente NO se enterar� de este cacheado.
                        if (newCachedParentIds == null)
View Full Code Here


    public static NodeLocationWithParentImpl getNodeLocationWithParent(Node node,boolean cacheIfPossible,ClientDocumentStfulImpl clientDoc)
    {
        // Si cacheIfPossible es true y se cachea el nodo, el location DEBE enviarse al cliente y resolverse para cachear en el cliente

        NodeCacheRegistryImpl nodeCache = clientDoc.getNodeCacheRegistry();
        if (nodeCache != null)
        {
            String id = nodeCache.getId(node);
            if (id != null)
            {
                return new NodeLocationWithParentImpl(node,id,null,cacheIfPossible,clientDoc); // S�lo se necesita el id del nodo, cuando est� en la cach� no necesitamos el string path que es una tarea que consume mucho tiempo tanto en el servidor como en el cliente
            }
            else // No cacheado
            {
                if (cacheIfPossible)
                {
                    id = nodeCache.addNode(node); // Si el nodo no es cacheable o la cach� est� bloqueada (s�lo lectural) devuelve null, no pasa nada por no poder cachear
                    return getNodeLocationWithParentUsingCache(node,id,true,nodeCache);
                }
                else
                {
                    String path = clientDoc.getStringPathFromNode(node);
View Full Code Here

        String idRefChild = null;
        String refChildPathRel = null;
        boolean needRefNodePath = false;

        NodeCacheRegistryImpl nodeCache = clientDoc.getNodeCacheRegistry();
        if (nodeCache != null)
        {
            idRefChild = nodeCache.getId(nextSibling);
            if (idRefChild != null) // Est� en la cach�
            {
                needRefNodePath = false; // est� cacheado, no necesitamos calcular el path
            }
            else
            {
                // No cacheado,intentamos cachear ahora, necesitamos calcular el path para que se cachee en el cliente tambi�n
                needRefNodePath = true;
                idRefChild = nodeCache.addNode(nextSibling); // el caso null es que no es cacheable por ejemplo, o la cach� est� "bloqueada"
            }
        }
        else needRefNodePath = true;

        if (needRefNodePath)
View Full Code Here

        // Este m�todo es �til cuando se dispone ya del parent en el cliente obtenido de alguna forma
        String idNode = null;
        String nodePathRel = null;
        boolean needNodePath = false;

        NodeCacheRegistryImpl nodeCache = clientDoc.getNodeCacheRegistry();
        if (nodeCache != null)
        {
            idNode = nodeCache.getId(node);
            if (idNode != null) // Est� en la cach�
            {
                needNodePath = false; // est� cacheado, no necesitamos calcular el path
            }
            else
            {
                // Intentamos cachear ahora, necesitamos calcular el path para que se cachee en el cliente tambi�n
                needNodePath = true;
                idNode = nodeCache.addNode(node); // el caso null es que no es cacheable por ejemplo, o la cach� est� "bloqueada"
            }
        }
        else needNodePath = true;

        if (needNodePath)
View Full Code Here

    {
        // Copiamos la cach� del cliente propietarios pues contiene los nodos m�s frecuentemente
        // usados, as� aceleramos el c�lculo de paths para el observador.
        ItsNatStfulDocumentImpl itsNatDoc = clientAttached.getItsNatStfulDocument();
        ClientDocumentStfulOwnerImpl clientDocOwner = itsNatDoc.getClientDocumentStfulOwner();
        NodeCacheRegistryImpl nodeCacheOwner = clientDocOwner.getNodeCacheRegistry();
        if ((nodeCacheOwner == null) || nodeCacheOwner.isEmpty())
            return;

        StringBuilder code = new StringBuilder();
        NodeCacheRegistryImpl nodeCacheObserver = clientAttached.getNodeCacheRegistry(); // DEBE existir
        if (!nodeCacheObserver.isEmpty()) throw new ItsNatException("INTERNAL ERROR"); // Debe estar "virgen" no sea que hayamos ya antes cacheado nodos en el observador y estar�amos cacheando dos veces aunque sea con el mismo id lo cual no est� permitido, provocamos error antes.
        ArrayList<LinkedList<Map.Entry<Node,String>>> cacheCopy = nodeCacheOwner.getOrderedByHeight();
        boolean cacheParentIfPossible = false// De esta manera evitamos un cacheado indirecto, el objetivo de este c�digo es copiar una cach� a otra, exactamente los mismos nodos
        for(int h = 0; h < cacheCopy.size(); h++)
        {
            LinkedList<Map.Entry<Node,String>> sameH = cacheCopy.get(h);
            if (sameH == null) continue;
            for(Map.Entry<Node,String> entry : sameH)
            {
                Node node = entry.getKey();
                String id = entry.getValue();
                // Los ids de los nodos son generados por el ItsNatDocumentImpl
                // por lo que pueden compartirse entre cach�s de clientes.

                if (isIgnoredNodeForCaching(node)) continue;

                nodeCacheObserver.addNode(node,id); // node no puede ser nulo

                NodeLocationWithParentImpl nodeLoc = NodeLocationWithParentImpl.getNodeLocationWithParentUsingCache(node,id,cacheParentIfPossible,nodeCacheObserver);
                if (!nodeLoc.isJustCached())
                    throw new ItsNatException("INTERNAL ERROR");
                code.append( JSRenderNodeImpl.addNodeToCache(nodeLoc) );
View Full Code Here

    protected abstract void checkAllClientsCanReceiveJSCode();

    protected boolean isNodeCachedWithId(Node node,String id,ClientDocumentStfulImpl clientDoc)
    {
        NodeCacheRegistryImpl nodeCache = clientDoc.getNodeCacheRegistry(); // No puede ser nula
        Node nodeCached = nodeCache.getNodeById(id);
        return node == nodeCached;
    }
View Full Code Here

        return node == nodeCached;
    }

    protected void preventiveNodeCaching(Node node,String id,ClientDocumentStfulImpl clientDoc)
    {
        NodeCacheRegistryImpl nodeCache = clientDoc.getNodeCacheRegistry(); // No puede ser nula
        nodeCache.addNode(node,id); // node no puede ser nulo (dar� error)

        // Con cacheIfPossible = true tambi�n cacheamos padres, minimizando problemas.
        NodeLocationWithParentImpl nodeLoc = NodeLocationWithParentImpl.getNodeLocationWithParentUsingCache(node,id,true,nodeCache);
        if (!nodeLoc.isJustCached())
            throw new ItsNatException("INTERNAL ERROR");
View Full Code Here

    protected abstract boolean preventiveNodeCaching2(final Node node);

    protected boolean preventiveNodeCachingOneClient(Node node,ClientDocumentStfulImpl clientDoc)
    {
        NodeCacheRegistryImpl nodeCache = clientDoc.getNodeCacheRegistry(); // No puede ser nula la cach�
        String oldId = nodeCache.getId(node);
        if (oldId != null) return false; // Ya est� cacheado y s�lo hay un cliente

        ItsNatStfulDocumentImpl itsNatDoc = getItsNatStfulDocument();
        String id = NodeCacheRegistryImpl.generateUniqueId(itsNatDoc);
        preventiveNodeCaching(node,id,clientDoc);
View Full Code Here

        // Evitamos cachear con un nuevo id si todos los clientes ya usan
        // dicho id, es el caso de un nodo que ya fue "cacheado preventivamente"
        // por las vistas y se quiere una nueva referencia como string.
        ItsNatStfulDocumentImpl itsNatDoc = getItsNatStfulDocument();
        ClientDocumentStfulImpl clientDocOwner = itsNatDoc.getClientDocumentStfulOwner();
        NodeCacheRegistryImpl nodeCache = clientDocOwner.getNodeCacheRegistry(); // No puede ser nula
        final String oldId = nodeCache.getId(node);

        ClientDocStfulTask clientTask = new ClientDocStfulTask()
        {
            public boolean doTask(ClientDocumentStfulImpl clientDoc,Object arg)
            {
View Full Code Here

        // ser�a muy tedioso.

        if (!clientDoc.getItsNatStfulDocument().isNewNodeDirectChildOfContentRoot(newNode))
            return null;
       
        NodeCacheRegistryImpl nodeCache = clientDoc.getNodeCacheRegistry();
        if (nodeCache == null) return null;
        String id = nodeCache.addNode(newNode); // Si devuelve null es que no se puede cachear el nodo o cach� "bloqueada"
       
        // Este idJS es para m�todos especiales en donde opcionalmente podemos pasar el id del nodo cacheado (si se pudo cachear sino pues null), es simplemente el "id", en este caso no es necesario y no sigue el convencionalismo de arrays de NodeLocation
        return id != null ? "\"" + id + "\"" : "null";       
    }
View Full Code Here

TOP

Related Classes of org.itsnat.impl.core.clientdoc.NodeCacheRegistryImpl

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.