classicobjectcontainer.java

用Java写的面相对象的数据库管理系统

        OzoneCompatible old = target;
        target = obj;
        if (target != null) {
            target.setContainer( this );
            if (targetShadow != null) {
                env.logWriter.newEntry( this, "setObject(): targetShadow != null !", LogWriter.WARN );
            } 
        } 
        return old;
    } 
    
    
    /** */
    protected void setOwner( User newOwner ) {
        permissions.setOwner( newOwner );
    } 
    
    
    /** */
    protected int touchCount() {
        return touchCount;
    } 
    
    
    /** */
    protected boolean touched() {
        return touched;
    } 
    
    
    /** */
    protected long touchTime() {
        return touchTime;
    } 
    
    
    /** */
    protected ClusterID clusterID() {
        return clusterID;
    } 
    
    
    /** */
    protected void setClusterID( ClusterID _clusterID ) {
        clusterID = _clusterID;
    } 
    
    
    /**
     */
    protected Class objectClass() throws Exception {
        return activatedObject().getClass();
    } 
    
    
    /**
     * Liefert referenz auf das eigentliche objekt; das objekt wird
     * nachgeladen, wenn es gerade nicht aktiv ist; waehrend einer
     * update-ta wird nur der clone bearbeitet und somit auch
     * nicht nachgeladen
     */
    protected OzoneCompatible activatedObject() throws Exception {
        //meistens sollte _object initialisiert sein, deshalb wird
        //das zuerst geprueft
        if (target != null) {
            return target;
        } else if (targetShadow != null) {
            return targetShadow;
        } else {
            clusterSpace.activateObject( this );
            return target;
        } 
    } 
    
    
    /** */
    protected synchronized void commitTarget( Transaction ta ) {
        if (targetShadow != null) {
            target = targetShadow;
            targetShadow = null;
            targetBackup = null;
        } 
        created = false;
        lock.release( ta );
    } 
    
    
    /** */
    protected synchronized void abortTarget( Transaction ta ) {
        if (targetShadow != null) {
            try {
                ObjectInputStream in = new ObjectInputStream( new ByteArrayInputStream( targetBackup ) );
                target = (OzoneCompatible)in.readObject();
                in.close();
            } catch (Exception e) {
                //kann/darf eigentlich nicht passieren
                env.logWriter.newEntry( this, "abortObject(): ", e, LogWriter.WARN );
                target = null;
            } 
            targetShadow = null;
            targetBackup = null;
        } 
        created = false;
        deleted = false;
        lock.release( ta );
    } 
    
    
    /** */
    protected synchronized void upgradeLockLevel( Transaction ta, int lockLevel ) throws Exception {
        activatedObject();
        lock.acquire( ta, Lock.LEVEL_READ );
        if (lockLevel > Lock.LEVEL_READ) {
            lock.acquire( ta, lockLevel );
            // TODO: Should new created object be shadowed or not ??
            if (!isCreated()) {
                createShadow();
            } 
        } 
    } 
    
    
    /** */
    protected synchronized void createShadow() throws Exception {
        try {
            ByteArrayOutputStream bout = new ByteArrayOutputStream();
            ObjectOutputStream out = new ObjectOutputStream( bout );
            out.writeObject( activatedObject() );
            out.close();
            targetBackup = bout.toByteArray();
            targetShadow = target;
            target = null;
        } catch (Exception e) {
            // darf/kann nicht passieren
            env.logWriter.newEntry( this, "lockWrite(): ", e, LogWriter.WARN );
        } 
    } 
    
    
    /**
     * In stream schreiben - fuer DxDiskHashtable
     */
    public void writeExternal( ObjectOutput out ) throws IOException {
        //       if (_object != null)
        //          System.out.print ("#");
        //       else  if (_targetShadow != null)
        //          System.out.print ("*");
        //       else
        //          System.out.print ("+");
        
        out.writeByte( subSerialVersionUID );
        
        out.writeObject( permissions );
        out.writeObject( objID );
        out.writeObject( target );
        out.writeObject( targetShadow );
        out.writeObject( targetBackup );
        out.writeObject( name );
        out.writeObject( clusterID );
        out.writeLong( touchTime );
        out.writeShort( touchCount );
        out.writeBoolean( touched );
        out.writeBoolean( created );
        out.writeBoolean( deleted );
        out.writeObject( lock );
    } 
    
    
    /**
     * Aus stream lesen - fuer DxDiskHashtable. objID ist
     * normalerweise referenz auf objID in object
     */
    public synchronized void readExternal( ObjectInput in ) throws IOException, ClassNotFoundException {
        env = Env.currentEnv();
        clusterSpace = ((ClassicStore)env.store).objectSpace.clusterSpace;
        
        byte streamVersionUID = in.readByte();
        
        permissions = (Permissions)in.readObject();
        objID = (ObjectID)in.readObject();
        target = (OzoneCompatible)in.readObject();
        targetShadow = (OzoneCompatible)in.readObject();
        targetBackup = (byte[])in.readObject();
        if (target != null) {
            target.setContainer( this );
        } 
        if (targetShadow != null) {
            targetShadow.setContainer( this );
        } 
        
        name = (String)in.readObject();
        clusterID = (ClusterID)in.readObject();
        touchTime = in.readLong();
        touchCount = in.readShort();
        touched = in.readBoolean();
        created = in.readBoolean();
        deleted = in.readBoolean();
        lock = (Lock)in.readObject();
    
    //       if (_object != null)
    //          System.out.print (".");
    //       else  if (_targetShadow != null)
    //          System.out.print (";");
    //       else
    //          System.out.print ("-");
    } 
    
    
    /**
     * In stream schreiben. wird vom ClusterSpace verwendet.
     */
    protected void storeExternal( ObjectOutput out ) throws IOException {
        out.writeLong( serialVersionUID );
        out.writeObject( permissions );
        out.writeObject( objID );
        out.writeObject( name );
        out.writeObject( clusterID );
    } 
    
    
    /**
     * Aus stream lesen - fuer ClusterSpace. objID ist
     * normalerweise referenz auf objID in object
     */
    protected void loadExternal( ObjectInput in ) throws IOException, ClassNotFoundException {
        env = Env.currentEnv();
        clusterSpace = ((ClassicStore)env.store).objectSpace.clusterSpace;
        
        long streamSerialVersionUID = in.readLong();
        permissions = (Permissions)in.readObject();
        objID = (ObjectID)in.readObject();
        name = (String)in.readObject();
        clusterID = (ClusterID)in.readObject();
        
        created = false;
        deleted = false;
        touchTime = System.currentTimeMillis();
        touchCount = 1;
        touched = false;
        lock = new DefaultLock();
    } 
    
    
    /**
     * Search the method with the specified name and signature. Ones
     * a method has been invoked it is stored in a global cache that holds
     * the method objects of all database classes.
     */
    private Method methodFor( String methodName, String sig, Object[] args ) throws Exception {
        String key = objectClass().getName() + methodName + sig;
        
        Method method = (Method)methodTable.elementForKey( key );
        // Method method = null;
        if (method == null) {
            int argNum = args.length;
            Class[] classes = new Class[argNum];
            if (sig == null) {
                //signatur aus den argumenten generieren; kann natuerlich
                //falsch sein
                for (int i = 0; i < argNum; i++) {
                    classes[i] = args[i].getClass();
                } 
            } else {
                //signatur aus dem sig-string vom proxy generieren
                StringTokenizer st = new StringTokenizer( sig, OPP.SIGNATURE_DELIMITER );
                int i = 0;
                while (st.hasMoreTokens()) {
                    classes[i++] = env.classManager.classForName( st.nextToken() );
                } 
            // classes[i++] = Class.forName (st.nextToken());
            } 
            method = objectClass().getMethod( methodName, classes );
            methodTable.addForKey( method, key );
        } 
        
        return method;
    } 
}