com.sun.corba.se.impl.util.RepositoryId Java Examples

public Object readResolve()
{
    String repositoryId = ior.getRepositoryId() ;
    String cname = RepositoryId.cache.getId( repositoryId ).getClassName() ;

    Class cls = null ;

    try {
        cls = JDKBridge.loadClass( cname, null, null ) ;
    } catch (ClassNotFoundException exc) {
        // XXX log this
    }

    PresentationManager pm =
        com.sun.corba.se.spi.orb.ORB.getPresentationManager() ;
    PresentationManager.ClassData classData = pm.getClassData( cls ) ;
    InvocationHandlerFactoryImpl ihfactory =
        (InvocationHandlerFactoryImpl)classData.getInvocationHandlerFactory() ;
    return ihfactory.getInvocationHandler( this ) ;
}
 

public static String getSignature(ValueMember member)
    throws ClassNotFoundException {

    // REVISIT.  Can the type be something that is
    // non-primitive yet not a value_box, value, or objref?
    // If so, should use ObjectStreamClass or throw
    // exception.

    if (member.type.kind().value() == TCKind._tk_value_box ||
        member.type.kind().value() == TCKind._tk_value ||
        member.type.kind().value() == TCKind._tk_objref) {
        Class c = RepositoryId.cache.getId(member.id).getClassFromType();
        return ObjectStreamClass.getSignature(c);

    } else {

        return primitiveConstants[member.type.kind().value()];
    }

}
 

/**
*  Returns a boolean of whether or not RepositoryId indicates
*  FullValueDescriptor.
*  used for backward compatability
*/

public boolean useFullValueDescription(Class clazz, String repositoryID)
   throws IOException
{
   return RepositoryId.useFullValueDescription(clazz, repositoryID);
}
 

/**
 * Java to IDL ptc-02-01-12 1.5.1
 *
 * "The rep_id string passed to the start_value method must be
 * 'RMI:org.omg.custom.class:hashcode:suid' where class is the
 * fully-qualified name of the class whose writeObject method
 * is being invoked and hashcode and suid are the class's hashcode
 * and SUID."
 */
private String computeRMIIIOPOptionalDataRepId() {

    StringBuffer sbuf = new StringBuffer("RMI:org.omg.custom.");
    sbuf.append(RepositoryId.convertToISOLatin1(this.getName()));
    sbuf.append(':');
    sbuf.append(this.getActualSerialVersionUIDStr());
    sbuf.append(':');
    sbuf.append(this.getSerialVersionUIDStr());

    return sbuf.toString();
}
 

/**
*  Returns a boolean of whether or not RepositoryId indicates
*  FullValueDescriptor.
*  used for backward compatability
*/

public boolean useFullValueDescription(Class clazz, String repositoryID)
   throws IOException
{
   return RepositoryId.useFullValueDescription(clazz, repositoryID);
}
 

/**
*  Returns a boolean of whether or not RepositoryId indicates
*  FullValueDescriptor.
*  used for backward compatability
*/

public boolean useFullValueDescription(Class clazz, String repositoryID)
   throws IOException
{
   return RepositoryId.useFullValueDescription(clazz, repositoryID);
}
 

/**
*  Returns a boolean of whether or not RepositoryId indicates
*  FullValueDescriptor.
*  used for backward compatability
*/

public boolean useFullValueDescription(Class clazz, String repositoryID)
   throws IOException
{
   return RepositoryId.useFullValueDescription(clazz, repositoryID);
}
 

public int getStandardRMIUnchunkedId() {
    return RepositoryId.kPreComputed_StandardRMIUnchunked;
}
 

public boolean isCodeBasePresent(int valueTag) {
    return RepositoryId.isCodeBasePresent(valueTag);
}
 

public int getTypeInfo(int valueTag) {
    return RepositoryId.getTypeInfo(valueTag);
}
 

public String createSequenceRepID(Class clazz) {
    return RepositoryId.createSequenceRepID(clazz);
}
 

public String createForAnyType(Class cl)
{
   return RepositoryId.createForAnyType(cl);
}
 

public String getSerialVersionUID(String id)
{
   RepositoryId repId = RepositoryId.cache.getId(id);
   return repId.getSerialVersionUID();
}
 

public String createForAnyType(Class type) {
    return RepositoryId.createForAnyType(type);
}
 

public boolean isSequence(String id)
{
   RepositoryId repId = RepositoryId.cache.getId(id);
   return repId.isSequence();
}
 

public Class getClassFromType(String id)
   throws ClassNotFoundException
{
   RepositoryId repId = RepositoryId.cache.getId(id);
   return repId.getClassFromType();
}
 

public int getTypeInfo(int valueTag) {
    return RepositoryId.getTypeInfo(valueTag);
}
 

public boolean isSequence(String id)
{
   RepositoryId repId = RepositoryId.cache.getId(id);
   return repId.isSequence();
}
 

public org.omg.CORBA.Object read_Object(Class clz)
{
    // In any case, we must first read the IOR.
    IOR ior = IORFactories.makeIOR(parent) ;
    if (ior.isNil())
        return null ;

    PresentationManager.StubFactoryFactory sff = ORB.getStubFactoryFactory() ;
    String codeBase = ior.getProfile().getCodebase() ;
    PresentationManager.StubFactory stubFactory = null ;

    if (clz == null) {
        RepositoryId rid = RepositoryId.cache.getId( ior.getTypeId() ) ;
        String className = rid.getClassName() ;
        boolean isIDLInterface = rid.isIDLType() ;

        if (className == null || className.equals( "" ))
            stubFactory = null ;
        else
            try {
                stubFactory = sff.createStubFactory( className,
                    isIDLInterface, codeBase, (Class)null,
                    (ClassLoader)null );
            } catch (Exception exc) {
                // Could not create stubFactory, so use null.
                // XXX stubFactory handling is still too complex:
                // Can we resolve the stubFactory question once in
                // a single place?
                stubFactory = null ;
            }
    } else if (StubAdapter.isStubClass( clz )) {
        stubFactory = PresentationDefaults.makeStaticStubFactory(
            clz ) ;
    } else {
        // clz is an interface class
        boolean isIDL = IDLEntity.class.isAssignableFrom( clz ) ;

        stubFactory = sff.createStubFactory( clz.getName(),
            isIDL, codeBase, clz, clz.getClassLoader() ) ;
    }

    return internalIORToObject( ior, stubFactory, orb ) ;
}
 

public String getClassDescValueRepId() {
    return RepositoryId.kClassDescValueRepID;
}
 

public Class getClassFromType(String id)
   throws ClassNotFoundException
{
   RepositoryId repId = RepositoryId.cache.getId(id);
   return repId.getClassFromType();
}
 

public String getClassName(String id)
{
   RepositoryId repID = RepositoryId.cache.getId(id);
   return repID.getClassName();
}
 

public String createSequenceRepID(Class clazz) {
    return RepositoryId.createSequenceRepID(clazz);
}
 

public int getCodeBaseRMIChunkedId() {
    return RepositoryId.kPreComputed_CodeBaseRMIChunked;
}
 

/**
 * Checks to ensure that an object of a remote or abstract interface type
 * can be cast to a desired type.
 * @param narrowFrom the object to check.
 * @param narrowTo the desired type.
 * @return an object which can be cast to the desired type.
 * @throws ClassCastException if narrowFrom cannot be cast to narrowTo.
 */
public java.lang.Object narrow ( java.lang.Object narrowFrom,
    java.lang.Class narrowTo) throws ClassCastException
{
    java.lang.Object result = null;

    if (narrowFrom == null)
        return null;

    if (narrowTo == null)
        throw new NullPointerException("invalid argument");

    try {
        if (narrowTo.isAssignableFrom(narrowFrom.getClass()))
            return narrowFrom;

        // Is narrowTo an interface that might be
        // implemented by a servant running on iiop?
        if (narrowTo.isInterface() &&
            narrowTo != java.io.Serializable.class &&
            narrowTo != java.io.Externalizable.class) {

            org.omg.CORBA.Object narrowObj
                = (org.omg.CORBA.Object) narrowFrom;

            // Create an id from the narrowTo type...
            String id = RepositoryId.createForAnyType(narrowTo);

            if (narrowObj._is_a(id)) {
                return Utility.loadStub(narrowObj,narrowTo);
            } else {
                throw new ClassCastException( "Object is not of remote type " +
                    narrowTo.getName() ) ;
            }
        } else {
            throw new ClassCastException( "Class " + narrowTo.getName() +
                " is not a valid remote interface" ) ;
        }
    } catch(Exception error) {
        ClassCastException cce = new ClassCastException() ;
        cce.initCause( error ) ;
        throw cce ;
    }
}
 

private RepIdDelegator(RepositoryId _delegate) {
    this.delegate = _delegate;
}
 

public String getSerialVersionUID(String id)
{
   RepositoryId repId = RepositoryId.cache.getId(id);
   return repId.getSerialVersionUID();
}
 

public String createForJavaType(Class clz)
    throws TypeMismatchException
{
    return RepositoryId.createForJavaType(clz);
}
 

public int getCodeBaseRMIUnchunkedNoRepStrId() {
    return RepositoryId.kPreComputed_CodeBaseRMIUnchunked_NoRep;
}
 

public String getDefinedInId(String id)
{
   RepositoryId repId = RepositoryId.cache.getId(id);
   return repId.getDefinedInId();
}