public Request _create_request(Context ctx,
    String operation,
    NVList arg_list,
    NamedValue result) 
{
        return _get_delegate().create_request(this,
                                              ctx,
                                              operation,
                                              arg_list,
                                              result);
}

Creates a Request object that contains the given context, method, argument list, and container for the result.

 public Request _create_request(Context ctx,
    String operation,
    NVList arg_list,
    NamedValue result,
    ExceptionList exceptions,
    ContextList contexts) 
{
        return _get_delegate().create_request(this,
                                              ctx,
                                              operation,
                                              arg_list,
                                              result,
                                              exceptions,
                                              contexts);
}

Creates a Request object that contains the given context, method, argument list, container for the result, exceptions, and list of property names to be used in resolving the context strings. This Request object is for use in the Dynamic Invocation Interface.

 public Object _duplicate() 
{
        return _get_delegate().duplicate(this);
}

Returns a duplicate of this ObjectImpl object.

 public Delegate _get_delegate() 
{
        if (__delegate == null)
            throw new BAD_OPERATION("The delegate has not been set!");
        return __delegate;
}

Retrieves the reference to the vendor-specific Delegate object to which this ObjectImpl object delegates all methods invoked on it.

 public DomainManager[] _get_domain_managers() 
{
        return _get_delegate().get_domain_managers(this);
}

Retrieves a list of the domain managers for this ObjectImpl object.

 public Object _get_interface_def() 
{
        // First try to call the delegate implementation class's
        // "Object get_interface_def(..)" method (will work for JDK1.2 ORBs).
        // Else call the delegate implementation class's
        // "InterfaceDef get_interface(..)" method using reflection
        // (will work for pre-JDK1.2 ORBs).
        org.omg.CORBA.portable.Delegate delegate = _get_delegate();
        try {
            // If the ORB's delegate class does not implement
            // "Object get_interface_def(..)", this will call
            // get_interface_def(..) on portable.Delegate.
            return delegate.get_interface_def(this);
        }
        catch( org.omg.CORBA.NO_IMPLEMENT ex ) {
            // Call "InterfaceDef get_interface(..)" method using reflection.
            try {
                Class[] argc = { org.omg.CORBA.Object.class };
                java.lang.reflect.Method meth =
                    delegate.getClass().getMethod("get_interface", argc);
                Object[] argx = { this };
                return (org.omg.CORBA.Object)meth.invoke(delegate, argx);
            }
            catch( java.lang.reflect.InvocationTargetException exs ) {
                Throwable t = exs.getTargetException();
                if (t instanceof Error) {
                    throw (Error) t;
                }
                else if (t instanceof RuntimeException) {
                    throw (RuntimeException) t;
                }
                else {
                    throw new org.omg.CORBA.NO_IMPLEMENT();
                }
            } catch( RuntimeException rex ) {
                throw rex;
            } catch( Exception exr ) {
                throw new org.omg.CORBA.NO_IMPLEMENT();
            }
        }
}

Retrieves the interface definition for this ObjectImpl object.

 public Policy _get_policy(int policy_type) 
{
        return _get_delegate().get_policy(this, policy_type);
}

Retrieves the Policy object for this ObjectImpl object that has the given policy type.

 public int _hash(int maximum) 
{
        return _get_delegate().hash(this, maximum);
}

Retrieves the hash code that serves as an ORB-internal identifier for this ObjectImpl object.

 abstract public String[] _ids()
Retrieves a string array containing the repository identifiers
supported by this ObjectImpl object. For example,
for a stub, this method returns information about all the
interfaces supported by the stub.

 public InputStream _invoke(OutputStream output) throws RemarshalException, ApplicationException 
{
        return _get_delegate().invoke(this, output);
}

Invokes an operation and returns an InputStream object for reading the response. The stub provides the OutputStream object that was previously returned by a call to the _request method. The method specified as an argument to _request when it was called previously is the method that this method invokes.

If an exception occurs, the _invoke method may throw an ApplicationException object that contains an InputStream from which the user exception state may be unmarshalled.

 public boolean _is_a(String repository_id) 
{
        return _get_delegate().is_a(this, repository_id);
}

Checks whether the object identified by the given repository identifier is an ObjectImpl object.

 public boolean _is_equivalent(Object that) 
{
        return _get_delegate().is_equivalent(this, that);
}

Checks whether the the given ObjectImpl object is equivalent to this ObjectImpl object.

 public boolean _is_local() 
{
        return _get_delegate().is_local(this);
}

Checks whether this ObjectImpl object is implemented by a local servant. If so, local invocation API's may be used.

 public boolean _non_existent() 
{
        return _get_delegate().non_existent(this);
}

Checks whether the server object for this ObjectImpl object has been destroyed.

 public ORB _orb() 
{
        return _get_delegate().orb(this);
}

Returns a reference to the ORB associated with this object and its delegate. This is the ORB object that created the delegate.

 public  void _release() 
{
        _get_delegate().release(this);
}

Releases the resources associated with this ObjectImpl object.

 public  void _releaseReply(InputStream input) 
{
        _get_delegate().releaseReply(this, input);
}

Releases the given reply stream back to the ORB when unmarshalling has completed after a call to the method _invoke. Calling this method is optional for the stub.

 public Request _request(String operation) 
{
        return _get_delegate().request(this, operation);
}

Creates a Request object containing the given method that can be used with the Dynamic Invocation Interface.

 public OutputStream _request(String operation,
    boolean responseExpected) 
{
        return _get_delegate().request(this, operation, responseExpected);
}

Returns an OutputStream object to use for marshalling the arguments of the given method. This method is called by a stub, which must indicate if a response is expected, that is, whether or not the call is oneway.

 public  void _servant_postinvoke(ServantObject servant) 
{
        _get_delegate().servant_postinvoke(this, servant);
}

Is called by the local stub after it has invoked an operation on the local servant that was previously retrieved from a call to the method _servant_preinvoke. The _servant_postinvoke method must be called if the _servant_preinvoke method returned a non-null value, even if an exception was thrown by the method invoked by the servant. For this reason, the call to the method _servant_postinvoke should be placed in a Java finally clause.

 public ServantObject _servant_preinvoke(String operation,
    Class expectedType) 
{
        return _get_delegate().servant_preinvoke(this, operation,
                                                 expectedType);
}

Returns a Java reference to the local servant that should be used for sending a request for the method specified. If this ObjectImpl object is a local stub, it will invoke the _servant_preinvoke method before sending a request in order to obtain the ServantObject instance to use.

If a ServantObject object is returned, its servant field has been set to an object of the expected type (Note: the object may or may not be the actual servant instance). The local stub may cast the servant field to the expected type, and then invoke the operation directly. The ServantRequest object is valid for only one invocation and cannot be used for more than one invocation.

 public  void _set_delegate(Delegate delegate) 
{
        __delegate = delegate;
}

Sets the Delegate for this ObjectImpl instance to the given Delegate object. All method invocations on this ObjectImpl object will be forwarded to this delegate.

 public Object _set_policy_override(Policy[] policies,
    SetOverrideType set_add) 
{
        return _get_delegate().set_policy_override(this, policies,
                                                   set_add);
}

Sets this ObjectImpl object's override type for the given policies to the given instance of SetOverrideType.

 public boolean equals(Object obj) 
{
        if ( __delegate != null )
           return __delegate.equals(this, obj);
        else
           return (this==obj);
}

Compares this ObjectImpl object with the given one for equality.

 public int hashCode() 
{
        if ( __delegate != null )
           return __delegate.hashCode(this);
        else
            return super.hashCode();
}

Returns the hash code for this ObjectImpl object.

 public String toString() 
{
        if ( __delegate != null )
           return __delegate.toString(this);
        else
           return getClass().getName() + ": no delegate set";
}

Returns a String object that represents this ObjectImpl object.