# org.omg.DynamicAny

***

**1. Creating and Initializing a DynamicAny**

```java
DynamicAny any = DynamicAnyFactory.factory.create_any();
any.insert_string("Hello, World!");
```

**2. Getting the Any's Value**

```java
String value = any.get_string();
```

**3. Setting the Any's Value to Null**

```java
any.insert_null();
```

**4. Checking if the Any is Null**

```java
if (any.is_null()) {
    // Do something
}
```

**5. Getting the Type of the Any's Value**

```java
TypeCode typeCode = any.type();
```

**6. Getting the Type Name of the Any's Value**

```java
String typeName = any.type().name();
```

**7. Copying a DynamicAny**

```java
DynamicAny copy = any.copy();
```

**8. Destroying a DynamicAny**

```java
any.destroy();
```

**9. Creating a DynamicAny from a Java Object**

```java
Any b = DynamicAnyFactory.factory.create_any();
b.insert_object(new Date());
```

**10. Creating a DynamicAny from a TypeCode**

```java
TypeCode tc = null; // Get a TypeCode somehow
DynamicAny a = DynamicAnyFactory.factory.create_dynamic_any(tc);
```

**11. Creating an Anonymous TypeCode**

```java
TypeCode tc = DynamicAnyFactory.factory.create_anonymous_tc();
```

**12. Creating a DynEnum**

```java
DynEnum de = (DynEnum) DynamicAnyFactory.factory.create_any();
de.insert_string("RED");
```

**13. Getting the Enumerator Values**

```java
for (Iterator i = de.get_enum().values(); i.hasNext();) {
    String value = (String) i.next();
}
```

**14. Getting the Base Type of a DynEnum**

```java
TypeCode baseType = de.get_enum().base_type();
```

**15. Creating a DynSequence**

```java
DynSequence ds = (DynSequence) DynamicAnyFactory.factory.create_any();
ds.insert_sequence(new String[] { "a", "b", "c" });
```

**16. Getting the Element Type of a DynSequence**

```java
TypeCode elementType = ds.get_sequence().element_type();
```

**17. Creating a DynArray**

```java
DynArray da = (DynArray) DynamicAnyFactory.factory.create_any();
da.insert_array(new int[] { 1, 2, 3 });
```

**18. Getting the Element Type of a DynArray**

```java
TypeCode elementType = da.get_array().element_type();
```

**19. Creating a DynStruct**

```java
DynStruct ds = (DynStruct) DynamicAnyFactory.factory.create_any();
ds.insert_struct(new String[] { "name", "address" }, new String[] { "John Doe", "123 Main Street" });
```

**20. Getting the Member Names of a DynStruct**

```java
String[] memberNames = ds.get_struct().member_names();
```

**21. Creating a DynUnion**

```java
DynUnion du = (DynUnion) DynamicAnyFactory.factory.create_any();
du.insert_union(new String[] { "name", "address" }, new String[] { "John Doe", "123 Main Street" });
```

**22. Getting the Selector Value of a DynUnion**

```java
String selector = du.get_union().selector_value().id();
```

**23. Getting the Case of a DynUnion**

```java
TypeCode casetc = du.get_union().discriminator_type();
```

**24. Creating a DynAny**

```java
DynAny da = (DynAny) DynamicAnyFactory.factory.create_any();
```

**25. Converting an Ordinary TypeCode to an Anonymous TypeCode**

```java
TypeCode tc = null; // Get a TypeCode somehow
TypeCode anonymous = DynamicAnyFactory.factory.create_anonymous_tc(tc);
```

**26. Converting an Any to a DynAny**

```java
DynamicAny dynobj = DynamicAnyFactory.factory.any_to_dyn_any(any);
```

**27. Converting a DynAny to an Any**

```java
Any anyobj = DynamicAnyFactory.factory.dyn_any_to_any(dynany);
```

**28. Creating a DynArray from a TypeCode**

```java
TypeCode tc = DynamicAnyFactory.factory.create_array_tc(3, DynamicAnyFactory.factory.create_typecode(IDLType.INT));
```

**29. Getting the Length of a DynArray**

```java
int length = ((DynArray) any).get_length();
```

**30. Getting an Element from a DynArray**

```java
Object o = ((DynArray) any).get_element(index);
```

**31. Setting an Element in a DynArray**

```java
((DynArray) any).set_element(index, o);
```

**32. Getting the Member Count of a DynStruct**

```java
int count = ((DynStruct) any).get_member_count();
```

**33. Getting a Member from a DynStruct**

```java
Object o = ((DynStruct) any).get_member(index);
```

**34. Setting a Member in a DynStruct**

```java
((DynStruct) any).set_member(index, o);
```

**35. Getting the Selector Value of a DynUnion**

```java
Object o = ((DynUnion) any).get_discriminator();
```

**36. Setting the Selector Value of a DynUnion**

```java
((DynUnion) any).set_discriminator(o);
```

**37. Getting the Case TypeCode of a DynUnion**

```java
TypeCode tc = ((DynUnion) any).get_discriminator_type();
```

**38. Getting the Case Any of a DynUnion**

```java
Any any = ((DynUnion) any).get_member();
```

**39. Setting the Case Any of a DynUnion**

```java
((DynUnion) any).set_member(any);
```

**40. Creating a DynValueBox**

```java
DynValueBox dvb = (DynValueBox) DynamicAnyFactory.factory.create_any();
dvb.set_value_from_any(any);
```

**41. Getting the Any from a DynValueBox**

```java
Any any = dvb.get_value();
```

**42. Creating a Value from a TypeCode**

```java
Value v = DynamicAnyFactory.factory.get_boxed_value(typeCode, "123");
```

**43. Getting the TypeCode of a Value**

```java
TypeCode tc = v.type();
```

**44. Getting the Value of a Value**

```java
String s = v.get_value().extract_string();
```

**45. Setting the Value of a Value**

```java
v.set_value((Any) value);
```

**46. Boxing and Unboxing Values**

```java
Any a = DynamicAnyFactory.factory.create_any();
a.insert_value(new Date());
Value v = a.extract_value();
Date d = (Date) v.get_value();
```

**47. Converting a DynUnion to an Ordinary Union**

```java
Union uf = (Union) ((DynUnion) any).copy();
```

**48. Converting an Ordinary Union to a DynUnion**

```java
DynUnion dyu = (DynUnion) DynamicAnyFactory.factory.create_any();
dyu.insert_union(uf);
```

**49. Converting a DynStruct to an Ordinary Struct**

```java
Struct sf = (Struct) ((DynStruct) any).copy();
```

**50. Converting an Ordinary Struct to a DynStruct**

```java
DynStruct dyu = (DynStruct) DynamicAnyFactory.factory.create_any();
dyu.insert_struct(sf);
```