# org.omg.CORBA.portable

***

**1. Creating and Initializing an ORB**

```java
ORB orb = ORB.init(args, null);
```

**2. Obtaining an Interface Reference**

```java
org.omg.CORBA.Object objRef = orb.string_to_object(strRef);
```

**3. Sending a Request to a Remote Object**

```java
String message = objRef.toString();
```

**4. Receiving a Response from a Remote Object**

```java
objRef.deactivate();
```

**5. Using a TypeCode**

```java
TypeCode tc = ORB.init().create_string_tc(0);
```

**6. Marshaling and Demarshaling Data**

```java
InputStream is = new ByteArrayInputStream(data);
OutputStream os = new ByteArrayOutputStream();
```

**7. Using a Servant**

```java
public class MyServant extends IDLActivationPOA {
  // Servant implementation
}
```

**8. Creating an Interceptor**

```java
public class MyInterceptor extends Interceptor {
  // Interceptor implementation
}
```

**9. Registering an Interceptor**

```java
ORB orb = ORB.init();
orb.register_interceptor(new MyInterceptor());
```

**10. Using a ValueHandler**

```java
ValueHandler vh = ValueHandlerFactory.getDefaultValueHandler();
```

**11. Creating a ValueBase**

```java
public final class Address extends ValueBase {
  // ValueBase implementation
}
```

**12. Using a ValueFactory**

```java
org.omg.CORBA_2_3.portable.ValueFactory factory = ValueFactoryImpl.init();
```

**13. Using a Dynamic Invocation Interface**

```java
DynamicInvocation dii = new DynamicInvocation(orb, objRef);
```

**14. Getting an Interface Repository**

```java
InterfaceRepository repository = ORB.init().get_interface_repository();
```

**15. Getting an Repository ID**

```java
String id = repository.get_id("IDL:MyModule/MyInterface:1.0");
```

**16. Getting an Interface Description**

```java
org.omg.CORBA.InterfaceDef interfaceDef = repository.lookup_id(id);
```

**17. Getting an Operation Description**

```java
org.omg.CORBA.OperationDef operationDef = interfaceDef.lookup_operation("myOperation");
```

**18. Using a ValueFactory Class**

```java
public final class Address extends ValueFactoryClass {
  // ValueFactoryClass implementation
}
```

**19. Using a ServantActivator**

```java
public class MyServantActivator implements ServantActivator {
  // ServantActivator implementation
}
```

**20. Using a ServantLocator**

```java
public class MyServantLocator implements ServantLocator {
  // ServantLocator implementation
}
```

**21. Using a ServantManager**

```java
public class MyServantManager implements ServantManager {
  // ServantManager implementation
}
```

**22. Using a ServantRequestHandler**

```java
public class MyServantRequestHandler implements ServantRequestHandler {
  // ServantRequestHandler implementation
}
```

**23. Using a ServantRetentionPolicy**

```java
public class MyServantRetentionPolicy implements ServantRetentionPolicy {
  // ServantRetentionPolicy implementation
}
```

**24. Using a ThreadPolicy**

```java
public final class MyThreadPolicy implements ThreadPolicy {
  // ThreadPolicy implementation
}
```

**25. Using a SynchronizationPolicy**

```java
public final class MySynchronizationPolicy implements SynchronizationPolicy {
  // SynchronizationPolicy implementation
}
```

**26. Using a RequestProcessingPolicy**

```java
public interface MyRequestProcessingPolicy extends RequestProcessingPolicy {
  // RequestProcessingPolicy implementation
}
```

**27. Using a RequestInfo**

```java
RequestInfo reqInfo = orb.create_request_info();
```

**28. Setting Request Options**

```java
reqInfo.set_reply_needed(true);
```

**29. Getting Request Options**

```java
boolean replyNeeded = reqInfo.get_reply_needed();
```

**30. Using a Connection**

```java
org.omg.CORBA.portable.Connection conn = orb.connect(objRef);
```

**31. Using a Messaging**

```java
org.omg.CORBA.portable.Messaging messaging = new Messaging(orb);
```

**32. Using a PolicyManager**

```java
PolicyManager pm = ORB.init().get_policy_manager();
```

**33. Getting a Policy**

```java
Policy policy = pm.get_policy(policyType);
```

**34. Setting a Policy**

```java
pm.set_policy(policy);
```

**35. Using a TransportManager**

```java
TransportManager tm = ORB.init().get_transport_manager();
```

**36. Getting a Transport**

```java
Transport transport = tm.get_transport(target);
```

**37. Using a TransportFactory**

```java
TransportFactory tf = ORB.init().get_transport_factory();
```

**38. Creating a Transport**

```java
Transport transport = tf.create_transport(target);
```

**39. Using a RequestTarget**

```java
RequestTarget target = new RequestTarget(objRef, operation);
```

**40. Using a ResponseHandler**

```java
ResponseHandler handler = new ResponseHandler(callback);
```

**41. Sending a Request with a Callback**

```java
transport.send_request(target, handler);
```

**42. Receiving a Response**

```java
Object result = handler.get_response();
```

**43. Using a ConnectionFactory**

```java
ConnectionFactory cf = ORB.init().get_connection_factory();
```

**44. Creating a Connection**

```java
Connection conn = cf.create_connection(target);
```

**45. Using a PersistentConnection**

```java
PersistentConnection conn = cf.create_persistent_connection(target);
```

**46. Using a RequestProcessor**

```java
RequestProcessor processor = new RequestProcessor(orb, connectionFactory);
```

**47. Starting a Request Processor**

```java
processor.start();
```

**48. Shutting Down a Request Processor**

```java
processor.stop();
```

**49. Using an ObjectAdapterFactory**

```java
ObjectAdapterFactory oaf = ORB.init().get_object_adapter_factory();
```

**50. Creating an Object Adapter**

```java
ObjectAdapter adapter = oaf.create_object_adapter("Name", manager);
```