Java ORBVersion类代码示例

import com.sun.corba.se.spi.orb.ORBVersion; //导入依赖的package包/类
public void readData(InputStreamHook stream) throws IOException {
    org.omg.CORBA.ORB orb = stream.getOrbStream().orb();
    if ((orb == null) ||
            !(orb instanceof com.sun.corba.se.spi.orb.ORB)) {
        throw new StreamCorruptedException(
                             "Default data must be read first");
    }
    ORBVersion clientOrbVersion =
        ((com.sun.corba.se.spi.orb.ORB)orb).getORBVersion();

    // Fix Date interop bug. For older versions of the ORB don't do
    // anything for readData(). Before this used to throw
    // StreamCorruptedException for older versions of the ORB where
    // calledDefaultWriteObject always returns true.
    if ((ORBVersionFactory.getPEORB().compareTo(clientOrbVersion) <= 0) ||
            (clientOrbVersion.equals(ORBVersionFactory.getFOREIGN()))) {
        // XXX I18N and logging needed.
        throw new StreamCorruptedException("Default data must be read first");
    }
}
 

import com.sun.corba.se.spi.orb.ORBVersion; //导入依赖的package包/类
/**
 * Checks the version of the ORB and returns the appropriate
 * RepositoryIdStrings instance.
 */
public static RepositoryIdStrings getRepIdStringsFactory(ORB orb)
{
    if (orb != null) {
        switch (orb.getORBVersion().getORBType()) {
            case ORBVersion.NEWER:
            case ORBVersion.FOREIGN:
            case ORBVersion.JDK1_3_1_01:
                return currentDelegator;
            case ORBVersion.OLD:
                return legacyDelegator;
            case ORBVersion.NEW:
                return ladybirdDelegator;
            default:
                return currentDelegator;
        }
    } else
        return currentDelegator;
}
 

import com.sun.corba.se.spi.orb.ORBVersion; //导入依赖的package包/类
/**
 * Checks the version of the ORB and returns the appropriate
 * RepositoryIdUtility instance.
 */
public static RepositoryIdUtility getRepIdUtility(ORB orb)
{
    if (orb != null) {
        switch (orb.getORBVersion().getORBType()) {
            case ORBVersion.NEWER:
            case ORBVersion.FOREIGN:
            case ORBVersion.JDK1_3_1_01:
                return currentDelegator;
            case ORBVersion.OLD:
                return legacyDelegator;
            case ORBVersion.NEW:
                return ladybirdDelegator;
            default:
                return currentDelegator;
        }
    } else
        return currentDelegator;
}
 

import com.sun.corba.se.spi.orb.ORBVersion; //导入依赖的package包/类
/**
 * Creates the correct ValueHandler for the given ORB,
 * querying ORBVersion information.  If the ORB or
 * ORBVersion is null, gets the ValueHandler from
 * Util.createValueHandler.
 */
public static ValueHandler createValueHandler(ORB orb) {

    if (orb == null)
        return Util.createValueHandler();

    ORBVersion version = orb.getORBVersion();

    if (version == null)
        return Util.createValueHandler();

    if (version.equals(ORBVersionFactory.getOLD()))
        return new ValueHandlerImpl_1_3();
    if (version.equals(ORBVersionFactory.getNEW()))
        return new ValueHandlerImpl_1_3_1();

    return Util.createValueHandler();
}
 

import com.sun.corba.se.spi.orb.ORBVersion; //导入依赖的package包/类
private static ORBVersion byteToVersion( byte value )
{
    /* Throwing an exception here would cause this version to be
    * incompatible with future versions of the ORB, to the point
    * that this version could
    * not even unmarshal objrefs from a newer version that uses
    * extended versioning.  Therefore, we will simply treat all
    * unknown versions as the latest version.
    if (value < 0)
        throw new INTERNAL() ;
    */

    /**
     * Update: If we treat all unknown versions as the latest version
     * then when we send an IOR with a PEORB version to an ORB that
     * doesn't know the PEORB version it will treat it as whatever
     * its idea of the latest version is.  Then, if that IOR is
     * sent back to the server and compared with the original
     * the equality check will fail because the versions will be
     * different.
     *
     * Instead, just capture the version bytes.
     */

    switch (value) {
        case ORBVersion.FOREIGN : return ORBVersionImpl.FOREIGN ;
        case ORBVersion.OLD : return ORBVersionImpl.OLD ;
        case ORBVersion.NEW : return ORBVersionImpl.NEW ;
        case ORBVersion.JDK1_3_1_01: return ORBVersionImpl.JDK1_3_1_01 ;
        case ORBVersion.NEWER : return ORBVersionImpl.NEWER ;
        case ORBVersion.PEORB : return ORBVersionImpl.PEORB ;
        default : return new ORBVersionImpl(value);
    }
}
 

import com.sun.corba.se.spi.orb.ORBVersion; //导入依赖的package包/类
/**
 * This chooses the appropriate GIOP version.
 *
 * @return the GIOP version 13.00 if Java serialization is enabled, or
 *         smallest(profGIOPVersion, orbGIOPVersion)
 */
public static GIOPVersion chooseRequestVersion(ORB orb, IOR ior ) {

    GIOPVersion orbVersion = orb.getORBData().getGIOPVersion();
    IIOPProfile prof = ior.getProfile() ;
    GIOPVersion profVersion = prof.getGIOPVersion();

    // Check if the profile is from a legacy Sun ORB.

    ORBVersion targetOrbVersion = prof.getORBVersion();
    if (!(targetOrbVersion.equals(ORBVersionFactory.getFOREIGN())) &&
            targetOrbVersion.lessThan(ORBVersionFactory.getNEWER())) {
        // we are dealing with a SUN legacy orb which emits 1.1 IORs,
        // in spite of being able to handle only GIOP 1.0 messages.
        return V1_0;
    }

    // Now the target has to be (FOREIGN | NEWER*)

    byte prof_major = profVersion.getMajor();
    byte prof_minor = profVersion.getMinor();

    byte orb_major = orbVersion.getMajor();
    byte orb_minor = orbVersion.getMinor();

    if (orb_major < prof_major) {
        return orbVersion;
    } else if (orb_major > prof_major) {
        return profVersion;
    } else { // both major version are the same
        if (orb_minor <= prof_minor) {
            return orbVersion;
        } else {
            return profVersion;
        }
    }
}
 

import com.sun.corba.se.spi.orb.ORBVersion; //导入依赖的package包/类
public boolean equals( Object obj )
{
    if (!(obj instanceof ORBVersion))
        return false ;

    ORBVersion version = (ORBVersion)obj ;
    return version.getORBType() == orbType ;
}
 

import com.sun.corba.se.spi.orb.ORBVersion; //导入依赖的package包/类
public int compareTo(Object obj) {
    // The Comparable interface says that this
    // method throws a ClassCastException if the
    // given object's type prevents it from being
    // compared.
    return getORBType() - ((ORBVersion)obj).getORBType();
}
 

import com.sun.corba.se.spi.orb.ORBVersion; //导入依赖的package包/类
public ORBVersion getORBVersion()
{
    synchronized (this) {
            checkShutdownState();
    }
    return (ORBVersion)(orbVersionThreadLocal.get()) ;
}
 

import com.sun.corba.se.spi.orb.ORBVersion; //导入依赖的package包/类
public void setORBVersion(ORBVersion verObj)
{
    synchronized (this) {
            checkShutdownState();
    }
    orbVersionThreadLocal.set(verObj);
}
 

import com.sun.corba.se.spi.orb.ORBVersion; //导入依赖的package包/类
public ORBVersion getORBVersion()
{
    if (getMagic() == ObjectKeyFactoryImpl.JAVAMAGIC_OLD)
        return ORBVersionFactory.getOLD() ;
    else if (getMagic() == ObjectKeyFactoryImpl.JAVAMAGIC_NEW)
        return ORBVersionFactory.getNEW() ;
    else
        throw new INTERNAL() ;
}