com.sun.corba.se.spi.orb.ORBVersion Java Examples

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");
    }
}
 

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");
    }
}
 

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");
    }
}
 

public boolean equals( Object obj )
{
    if (!(obj instanceof ORBVersion))
        return false ;

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

/**
 * 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;
        }
    }
}
 

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();
}
 

public void setORBVersion(ORBVersion verObj)
{
    synchronized (this) {
            checkShutdownState();
    }
    orbVersionThreadLocal.set(verObj);
}
 

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();
}
 

/**
 * 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;
        }
    }
}
 

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);
    }
}
 

/**
 * 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;
        }
    }
}
 

public boolean equals( Object obj )
{
    if (!(obj instanceof ORBVersion))
        return false ;

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

public ORBVersion getORBVersion()
{
    synchronized (this) {
            checkShutdownState();
    }
    return (ORBVersion)(orbVersionThreadLocal.get()) ;
}
 

public ORBVersion getORBVersion()
{
    if (getMagic() == ObjectKeyFactoryImpl.JAVAMAGIC_OLD)
        return ORBVersionFactory.getOLD() ;
    else if (getMagic() == ObjectKeyFactoryImpl.JAVAMAGIC_NEW)
        return ORBVersionFactory.getNEW() ;
    else
        throw new INTERNAL() ;
}
 

/**
 * 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;
        }
    }
}
 

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);
    }
}
 

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);
    }
}
 

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();
}
 

public void setORBVersion(ORBVersion verObj)
{
    synchronized (this) {
            checkShutdownState();
    }
    orbVersionThreadLocal.set(verObj);
}
 

public void setORBVersion(ORBVersion verObj)
{
    synchronized (this) {
            checkShutdownState();
    }
    orbVersionThreadLocal.set(verObj);
}
 

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);
    }
}
 

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();
}
 

public ORBVersion getORBVersion()
{
    synchronized (this) {
            checkShutdownState();
    }
    return (ORBVersion)(orbVersionThreadLocal.get()) ;
}
 

public ORBVersionServiceContext( ORBVersion ver )
{
    this.version = ver ;
}
 

public static ORBVersion getFOREIGN()
{
    return ORBVersionImpl.FOREIGN ;
}
 

/**
 * @return the ORBVersion associated with the object key in the IOR.
 */
public ORBVersion getORBVersion() {
    return oktemp.getORBVersion();
}
 

protected void setORBVersion( InputStream is )
{
    ORBVersion version = ORBVersionFactory.create( is ) ;
    setORBVersion( version ) ;
}
 

public boolean lessThan(ORBVersion version) {
    return orbType < version.getORBType();
}
 

public ORBVersion getORBVersion()
{
    return ORBVersionFactory.getFOREIGN() ;
}
 

public static ORBVersion getPEORB()
{
    return ORBVersionImpl.PEORB ;
}