symboltable.java

JAVA3D矩陈的相关类

        
        return symbol;
    }
    
    public int getUnsavedNodeComponentsSize() {
        return ((LinkedList)unsavedNodeComponentsStack.peek()).size();
    }
    
    public ListIterator getUnsavedNodeComponents() {
        return ((LinkedList)unsavedNodeComponentsStack.peek()).listIterator(0);
    }
    
    public void startUnsavedNodeComponentFrame() {
        unsavedNodeComponentsStack.push( new LinkedList() );
    }
    
    public void endUnsavedNodeComponentFrame() {
        unsavedNodeComponentsStack.pop();
        confirmInterGraphDependency();
    }
    
    /**
     * Check for and remove any inter graph dependency
     * labels that have been resolved to the current graph
     */
    private void confirmInterGraphDependency() {
        HashSet set = (HashSet)branchGraphDependencies.get(currentBranchGraphID);
        if (set==null)
            return;
        
        Iterator it = set.iterator();
        while(it.hasNext()) {
            SymbolTableData symbol = (SymbolTableData)it.next();
            if (symbol.branchGraphID==currentBranchGraphID)
                it.remove();
        }
        
    }
    
    /** 
     * Add a dependency to the current branchgraph on <code>symbol</code>
     *
     * Only nodes (not nodeComponents) affect intergraph dependencies
     */
    private void addInterGraphDependency( SymbolTableData symbol ) {
        HashSet set = (HashSet)branchGraphDependencies.get( currentBranchGraphID );
        if (set==null) {
            set = new HashSet();
            branchGraphDependencies.set( currentBranchGraphID, set );
        }
        
        set.add(symbol);
    }
    
    /**
     * Update the reference count for the node component.
     *
     * Called during NodeComponentState.addSubReference()
     */
    public void incNodeComponentRefCount( int nodeID ) {
        if (nodeID==0) return;
        
        SymbolTableData symbol = getSymbol( nodeID );
        
        ((NodeComponentState)symbol.nodeState).addSubReference();
        
        if (symbol.referenceCount==1)
            sharedNodes.add( symbol );
        symbol.referenceCount++;
    }
    
    /**
     * Add a refernce to the specified node
     * Also returns the nodes id
     */
    public int addReference( SceneGraphObject node ) {
        if (node==null) return 0;
        
        SymbolTableData symbol = getSymbol( node );
        
        if (symbol==null) {
            if (node instanceof javax.media.j3d.Node) {
                symbol = createDanglingSymbol( node );
                if (symbol.branchGraphID != currentBranchGraphID  ) {
                    //System.out.println("------------- Adding Reference "+symbol.nodeID+" "+node );  // TODO - remove
                    addInterGraphDependency( symbol );
                    sharedNodes.add( symbol );
                }
            } else {
                symbol = createNodeComponentSymbol( node );
            }
            return symbol.nodeID;
        } else {
            return addReference( symbol );
        }
    }
    
    /**
     * Add a refernce to the specified node
     * Also returns the nodes id
     */
    public int addReference( SymbolTableData symbol ) {
                
        if (symbol!=null) {
            if (symbol.referenceCount==1)
                sharedNodes.add( symbol );
            symbol.referenceCount++;
            
            if (symbol.j3dNode instanceof javax.media.j3d.NodeComponent && symbol.referenceCount>1) {
                ((NodeComponentState)symbol.nodeState).addSubReference();
            }
            
            if (symbol.branchGraphID != currentBranchGraphID && 
                symbol.j3dNode instanceof javax.media.j3d.Node ) {
                    // System.out.println("------------- Adding Reference "+symbol.nodeID+" "+symbol.j3dNode );    // TODO - remove
                    addInterGraphDependency( symbol );
                }
        } else {
            throw new SGIORuntimeException("Null Symbol");
        }
        
        return symbol.nodeID;
    }
    
    /**
     * Add a refernce to the BranchGraph root
     * Also returns the nodes id
     *
     * Used to associate graphs with a locale without storing the graph at the
     * current time.
     */
    public int addBranchGraphReference( SceneGraphObject node, int branchGraphID ) {
        if (node==null) return 0;
        
        SymbolTableData symbol = getSymbol( node );
        
        if (symbol!=null) {
            if (symbol.referenceCount==1)
                sharedNodes.add( symbol );
            symbol.referenceCount++;
        } else {
            symbol = new SymbolTableData( nodeID++, node, null, -3 );
            j3dNodeIndex.put( node, symbol );
            nodeIDIndex.add( symbol );
            danglingReferences.put( node, symbol );
        }
        
        symbol.branchGraphID = branchGraphID;
        for(int i=branchGraphs.size(); i<branchGraphID+1; i++) {
            branchGraphs.add( null);
            branchGraphDependencies.add( null );
        }

        branchGraphs.set( symbol.branchGraphID, symbol );
        
        return symbol.nodeID;
    }    
    
    /**
     * Return true if this node has already been loaded
     */
    public boolean isLoaded( int nodeID ) {
        SymbolTableData symbol = getSymbol( nodeID );
        
        if (symbol==null)
            return false;
        
        if (symbol.j3dNode==null)
            return false;
        
        return true;
    }
    
    /**
     * Return the Java3D node associated with the nodeID.
     *
     * The method will call buildGraph() on the node if necessary
     */
    public SceneGraphObject getJ3dNode( int nodeID ) {
        if (nodeID==0) return null;
        
        SymbolTableData symbol = getSymbol( nodeID );

        // Although referenced this node was not attached to the
        // scenegraph, so return null
        if (symbol.branchGraphID==-3)
	    return null;
        
        if (symbol!=null && symbol.j3dNode==null) {
            if (symbol.isNodeComponent && (control instanceof RandomAccessFileControl) ) {
                try {
                    ((RandomAccessFileControl)control).loadNodeComponent( symbol );
                } catch(IOException e ) {
                    System.out.println("FAILED to seek and load NodeComponent");
                    return null;
                }
            } else {
                System.out.println("WARNING - Object has not been loaded "+nodeID);
                System.out.println("Need to load branchgraph "+symbol.branchGraphID );
                return null;
            }
        } else if (symbol==null) {
            throw new SGIORuntimeException("Missing Symbol "+nodeID );
        }
        
        if ( !symbol.graphBuilt ) {
            symbol.graphBuilt = true;
            symbol.nodeState.buildGraph();
        }
        
        return symbol.j3dNode;
    }
    
    /**
     * Get the table entry for node
     */
    public SymbolTableData getSymbol( SceneGraphObject node ) {     
        //System.out.println("getSymbol "+node+"  "+j3dNodeIndex.get( node ));
        return (SymbolTableData)j3dNodeIndex.get( node );
    }
      
    /**
     * Return the node with the give ID
     */
    public SymbolTableData getSymbol( int nodeID ) {
        // nodeID's start at 1
        
        if (nodeID==0 || nodeID>nodeIDIndex.size() )
            return null;
        else 
            return (SymbolTableData)nodeIDIndex.get( nodeID );
    }
    
    /** Get the symbol for the shared group
     *  If the sharedgroup has not been loaded then load it before
     *  returning (if we are using RandomAccessFileControl
     */
    public SymbolTableData getSharedGroup( int nodeID ) {
        SymbolTableData symbol = getSymbol( nodeID );
        
        if (symbol.nodeState==null && control instanceof RandomAccessFileControl) {
            try {
                ((RandomAccessFileControl)control).loadSharedGroup( symbol );
            } catch( java.io.IOException e ) {
                e.printStackTrace();
                throw new SGIORuntimeException("Internal error in getSharedGroup");
            }
        }
        
        return symbol;
    }
    
    /** 
     * Set the position of the object referenced by state
     */
    public void setFilePosition( long ptr, SceneGraphObjectState state ) {
        if (state instanceof NullSceneGraphObjectState) return;
        
        SymbolTableData symbol = getSymbol( state.getNodeID() );
        
        symbol.filePosition = ptr;
    }
    /**
     * Associate the name with the scene graph object 
     */
    public void addNamedObject( String name, SceneGraphObject object ) {
        namedObjects.put( name, object );
    }
    
    /**
     * Add all the named objects in <code>map</code>
     */
    public void addNamedObjects( HashMap map ) {
        if (map!=null)
            namedObjects.putAll( map );
    }
    
    /**
     * Return the SceneGraphObject associated with the name
     */
    public SceneGraphObject getNamedObject( String name ) throws NamedObjectException, ObjectNotLoadedException {
        Object obj = namedObjects.get( name );
        if (obj==null)
            throw new NamedObjectException( "Unknown name :"+name );
        
        if (obj instanceof SceneGraphObject)
            return (SceneGraphObject)obj;
        else {
            SymbolTableData symbol = getSymbol( ((Integer)obj).intValue() );
            if (symbol==null || symbol.j3dNode==null)
                throw new ObjectNotLoadedException( ((Integer)obj).toString() );
            return symbol.j3dNode;
        }
    }
    
    /**
     * Get all the names of the named objects
     */
    public String[] getNames() {
        return (String[])namedObjects.keySet().toArray( new String[] {} );
    }
    
    /**
     * Add the namedObject mappings to <code>map</code>
     */
    public void getNamedObjectMap( HashMap map ) {
        map.putAll( namedObjects );
    }
    
    public String toString() {
        StringBuffer buf = new StringBuffer();
        
        for(int i=0; i<nodeIDIndex.size(); i++) {
            SymbolTableData data = (SymbolTableData)nodeIDIndex.get(i);
            if (data!=null)
                buf.append( data.nodeID+" "+data.referenceCount+" "+data.filePosition+"  "+data.branchGraphID+"  "+data.nodeState+"\n" );
        }
        
        buf.append("\nShared Objects\n");
        
        ListIterator l = sharedNodes.listIterator();
        while(l.hasNext()) {
            SymbolTableData data = (SymbolTableData)l.next();
            buf.append( data.nodeID+" "+data.referenceCount+" "+data.filePosition+"  "+data.branchGraphID+"  "+data.j3dNode+"\n" );            
        }
        
        buf.append("\nNamed Objects\n");
        
        String[] names = getNames();
        for(int i=0; i<names.length; i++)
            buf.append( names[i]+"  "+namedObjects.get(names[i]) );
        
        buf.append("\nBranch Graphs\n");
        for(int i=0; i<branchGraphs.size(); i++) {
            SymbolTableData data = (SymbolTableData)branchGraphs.get(i);
            if (data==null) System.out.println("Data is null "+i+"  "+branchGraphs.size());
            buf.append( data.nodeID+" "+data.referenceCount+" "+data.filePosition+"  "+data.branchGraphID+"  "+data.j3dNode+" "+data.nodeState+"\n" );            
        }
        
        buf.append("\nBranch Graph Dependencies\n");
        for(int i=0; i<branchGraphDependencies.size(); i++) {
            buf.append("Graph "+i+" - ");
            HashSet set = (HashSet)branchGraphDependencies.get(i);
            if (set!=null) {
                Iterator it = set.iterator();
                while(it.hasNext())
                    buf.append( ((SymbolTableData)it.next()).nodeID+" ");
            }
            buf.append("\n");
        }
        
        buf.append("------------------");
        
        return buf.toString();
    }

    /**
     * Clear all elements from the symbol table
     */
    public void clear() {
        j3dNodeIndex.clear();
        nodeIDIndex.clear();
        while (!unsavedNodeComponentsStack.empty())
            unsavedNodeComponentsStack.pop();
        danglingReferences.clear();
        sharedNodes.clear();
        namedObjects.clear();
        nodeID = 1;
    }
    
    /**
     * Clear all the Symbols that are not shared with other Graphs in the file
     *
     * Remove all Symbols from all structures with referenceCounts=1
     */
    public void clearUnshared() {
        // Convert as many named objects as possible to reference to j3dNode
        String[] names = getNames();
        for(int i=0; i<names.length; i++) {
            try {
                Object obj = namedObjects.get(names[i]);
                if (obj instanceof Integer) {
                    SymbolTableData symbol = getSymbol( ((Integer)obj).intValue() );
                    if (symbol!=null && symbol.j3dNode!=null)
                        namedObjects.put( names[i], symbol.j3dNode );
                }
            } catch( Exception e ) { e.printStackTrace();}
        }
        
        j3dNodeIndex.clear();
        nodeIDIndex.clear();
        while (!unsavedNodeComponentsStack.empty())
            unsavedNodeComponentsStack.pop();
        
        nodeIDIndexEnsureCapacity( nodeID );
        
        // Add the shared and dangling Symbols back into the other structures
        ListIterator list = sharedNodes.listIterator();
        while(list.hasNext()) {
            SymbolTableData symbol = (SymbolTableData)list.next();
            nodeIDIndex.set( symbol.nodeID, symbol );
            j3dNodeIndex.put( symbol.j3dNode, symbol );
        }
        
        Iterator it = danglingReferences.values().iterator();
        while(it.hasNext()) {
            SymbolTableData symbol = (SymbolTableData)it.next();
            nodeIDIndex.set( symbol.nodeID, symbol );
            j3dNodeIndex.put( symbol.j3dNode, symbol );
        }
        

    }
    
    /**
 * Given a nodeID return the corresponding scene graph object.
 *
 * Use only during the load cycle
 */
    public javax.media.j3d.SceneGraphObject resolveReference(int nodeID) {
        return getJ3dNode( nodeID );
    }
    
}