1:
37:
38:
39: package ;
40:
41: import ;
42: import ;
43: import ;
44:
45: import ;
46: import ;
47: import ;
48: import ;
49: import ;
50: import ;
51: import ;
52: import ;
53: import ;
54: import ;
55: import ;
56: import ;
57: import ;
58: import ;
59: import ;
60: import ;
61: import ;
62: import ;
63: import ;
64: import ;
65: import ;
66: import ;
67: import ;
68: import ;
69: import ;
70: import ;
71: import ;
72: import ;
73: import ;
74: import ;
75: import ;
76: import ;
77: import ;
78: import ;
79: import ;
80: import ;
81: import ;
82: import ;
83: import ;
84: import ;
85: import ;
86: import ;
87: import ;
88: import ;
89: import ;
90: import ;
91: import ;
92: import ;
93: import ;
94: import ;
95:
96: import ;
97: import ;
98: import ;
99:
100:
105: public class gnuPOA
106: extends LocalObject
107: implements POA, ObjectReferenceFactory
108: {
109:
114: class RefTemplate implements ObjectReferenceTemplate
115: {
116:
119: private static final long serialVersionUID = 1;
120:
121: RefTemplate()
122: {
123:
124: ArrayList names = new ArrayList();
125: names.add(the_name());
126:
127: POA poa = the_parent();
128: while (poa != null)
129: {
130: names.add(poa.the_name());
131: poa = poa.the_parent();
132: }
133:
134:
135:
136: m_adapter_name = new String[names.size()];
137:
138: for (int i = 0; i < m_adapter_name.length; i++)
139: m_adapter_name[i] = (String) names.get(m_adapter_name.length - i - 1);
140: }
141:
142:
145: final String[] m_adapter_name;
146:
147:
150: public String[] adapter_name()
151: {
152: return (String[]) m_adapter_name.clone();
153: }
154:
155:
158: public String orb_id()
159: {
160: return m_orb.orb_id;
161: }
162:
163:
166: public String server_id()
167: {
168: return OrbFunctional.server_id;
169: }
170:
171:
174: public Object make_object(String repositoryId, byte[] objectId)
175: {
176: return create_reference_with_id(objectId, repositoryId);
177: }
178:
179:
182: public String[] _truncatable_ids()
183: {
184: return ref_template_ids;
185: }
186: }
187:
188:
191: private static final long serialVersionUID = 1;
192:
193:
196: ObjectReferenceTemplate refTemplate;
197:
198:
202: final static String[] ref_template_ids =
203: new String[] { ObjectReferenceTemplateHelper.id() };
204:
205:
208: public final AOM aom = new AOM();
209:
210:
213: final ArrayList children = new ArrayList();
214:
215:
218: final String name;
219:
220:
223: final POA parent;
224:
225:
229: static final int SIGNATURE = 0x66726565;
230:
231:
234: AdapterActivator m_activator;
235:
236:
239: POAManager m_manager;
240:
241:
244: ServantActivator servant_activator;
245:
246:
249: ServantLocator servant_locator;
250:
251:
254: Servant default_servant;
255:
256:
259: private byte[] m_poa_id;
260:
261:
265: private final HashSet m_policies;
266:
267:
270: Policy[] s_policies;
271:
272:
275: final ORB_1_4 m_orb;
276:
277:
280: boolean m_inDestruction;
281:
282:
287: public final boolean retain_servant;
288:
289:
293: ObjectReferenceFactory m_object_factory = this;
294:
295:
305: public gnuPOA(gnuPOA a_parent, String a_name, POAManager a_manager,
306: Policy[] a_policies, ORB_1_4 an_orb
307: )
308: throws InvalidPolicy
309: {
310:
311: Policy[] all_policies = StandardPolicies.withDefault(a_policies);
312:
313: name = a_name;
314: parent = a_parent;
315: m_orb = an_orb;
316:
317: if (a_manager != null)
318: m_manager = a_manager;
319: else
320: m_manager = new gnuPOAManager();
321:
322: if (m_manager instanceof gnuPOAManager)
323: {
324: gnuPOAManager g = (gnuPOAManager) m_manager;
325: g.addPoa(this);
326: }
327:
328: m_policies = new HashSet(all_policies.length);
329:
330: s_policies = new Policy[ all_policies.length ];
331: for (int i = 0; i < s_policies.length; i++)
332: {
333: s_policies [ i ] = all_policies [ i ].copy();
334: m_policies.add(((AccessiblePolicy) s_policies [ i ]).getValue());
335: }
336:
337: retain_servant = applies(ServantRetentionPolicyValue.RETAIN);
338:
339: validatePolicies(a_policies);
340:
341: refTemplate = new RefTemplate();
342: }
343:
344:
348: public void waitWhileRunning()
349: {
350:
351: long time = 1;
352:
353:
354: long max = 500;
355:
356: boolean runs;
357:
358: do
359: {
360: runs = m_orb.currents.has(this);
361:
362: if (runs)
363: {
364:
365:
366: try
367: {
368: Thread.sleep(time);
369: time = time * 2;
370: if (time > max)
371: time = max;
372: }
373: catch (InterruptedException ex)
374: {
375: }
376: }
377: }
378: while (runs);
379: }
380:
381:
386: protected void etherealizeAll()
387: {
388: if (servant_activator == null)
389: return;
390:
391: ArrayList keys = new ArrayList();
392: keys.addAll(aom.keySet());
393:
394: byte[] key;
395: AOM.Obj obj;
396: boolean last;
397: for (int i = 0; i < keys.size(); i++)
398: {
399: key = (byte[]) keys.get(i);
400: obj = aom.get(key);
401:
402: if (obj.poa == this)
403: {
404: aom.remove(key);
405:
406: if (!obj.isDeactiveted())
407: {
408:
409: last = aom.findServant(obj.servant) == null;
410: servant_activator.etherealize(obj.key, this, obj.servant, true,
411: last
412: );
413: }
414: }
415: }
416: }
417:
418:
432: protected POA createPoaInstance(String child_name, POAManager a_manager,
433: Policy[] policies, ORB_1_4 an_orb
434: )
435: throws InvalidPolicy
436: {
437: POAManager some_manager =
438: a_manager == null ? new gnuPOAManager() : a_manager;
439:
440: if (some_manager instanceof gnuPOAManager)
441: {
442: ((gnuPOAManager) some_manager).addPoa(this);
443: }
444:
445: return new gnuPOA(this, child_name, some_manager, policies, an_orb);
446: }
447:
448:
457: public final boolean applies(java.lang.Object policy_value)
458: {
459: return m_policies.contains(policy_value);
460: }
461:
462:
469: public final void required(java.lang.Object policy_value)
470: throws WrongPolicy
471: {
472: if (!applies(policy_value))
473: throw new WrongPolicy(policy_value + " policy required.");
474: }
475:
476:
483: public final void excluding(java.lang.Object policy_value)
484: throws WrongPolicy
485: {
486: if (applies(policy_value))
487: throw new WrongPolicy(policy_value + " policy applies.");
488: }
489:
490:
505: public POA find_POA(String poa_name, boolean activate_it)
506: throws AdapterNonExistent
507: {
508: POA child;
509: for (int i = 0; i < children.size(); i++)
510: {
511: child = (POA) children.get(i);
512: if (child.the_name().equals(poa_name))
513: return child;
514: }
515:
516: if (activate_it && m_activator != null)
517: {
518: boolean activated = m_activator.unknown_adapter(this, poa_name);
519: if (!activated)
520: throw new AdapterNonExistent(poa_name + " activation failed.");
521:
522:
523: for (int i = 0; i < children.size(); i++)
524: {
525: child = (POA) children.get(i);
526: if (child.the_name().equals(poa_name))
527: return child;
528: }
529: throw new AdapterNonExistent(poa_name + " not created. ");
530: }
531: else
532: throw new AdapterNonExistent(poa_name);
533: }
534:
535:
552: public byte[] activate_object(Servant a_servant)
553: throws ServantAlreadyActive, WrongPolicy
554: {
555: checkDiscarding();
556: required(ServantRetentionPolicyValue.RETAIN);
557: required(IdAssignmentPolicyValue.SYSTEM_ID);
558:
559: AOM.Obj exists = aom.findServant(a_servant);
560:
561: if (exists != null)
562: {
563: if (exists.isDeactiveted())
564: {
565:
566:
567: exists.setDeactivated(false);
568: incarnate(exists, exists.key, a_servant, false);
569: return exists.key;
570: }
571: else if (applies(IdUniquenessPolicyValue.UNIQUE_ID))
572: throw new ServantAlreadyActive();
573:
574:
575:
576: }
577:
578: byte[] object_key = AOM.getFreeId();
579: ServantDelegateImpl delegate = new ServantDelegateImpl(a_servant, this,
580: object_key);
581: create_and_connect(object_key,
582: a_servant._all_interfaces(this, object_key)[0], delegate);
583: return object_key;
584: }
585:
586:
604: public void activate_object_with_id(byte[] an_Object_Id, Servant a_servant)
605: throws ServantAlreadyActive, ObjectAlreadyActive,
606: WrongPolicy
607: {
608: activate_object_with_id(an_Object_Id, a_servant, false);
609: }
610:
611:
617: public void activate_object_with_id(byte[] an_Object_Id, Servant a_servant,
618: boolean use_forwarding)
619: throws ServantAlreadyActive, ObjectAlreadyActive, WrongPolicy
620: {
621: checkDiscarding();
622: required(ServantRetentionPolicyValue.RETAIN);
623:
624:
625:
626: if (applies(IdUniquenessPolicyValue.UNIQUE_ID))
627: {
628: AOM.Obj sx = aom.findServant(a_servant, false);
629: if (sx != null)
630: throw new ServantAlreadyActive();
631: }
632:
633: AOM.Obj exists = aom.get(an_Object_Id);
634: if (exists != null)
635: {
636: if (exists.servant == null)
637: {
638: locateServant(an_Object_Id, a_servant, exists, use_forwarding);
639: exists.setDeactivated(false);
640: }
641: else if (exists.isDeactiveted())
642: {
643: exists.setDeactivated(false);
644: incarnate(exists, an_Object_Id, a_servant, use_forwarding);
645: }
646: else
647: throw new ObjectAlreadyActive();
648: }
649: else
650: {
651: ServantDelegateImpl delegate = new ServantDelegateImpl(a_servant, this,
652: an_Object_Id);
653: create_and_connect(an_Object_Id, a_servant._all_interfaces(this,
654: an_Object_Id)[0], delegate);
655: }
656: }
657:
658:
670: private void locateServant(byte[] an_Object_Id, Servant a_servant,
671: AOM.Obj exists, boolean use_forwarding
672: )
673: throws InternalError
674: {
675:
676: gnuServantObject object = (gnuServantObject) exists.object;
677: if (servant_activator != null)
678: {
679: exists.setServant(incarnate(exists, an_Object_Id, a_servant,
680: use_forwarding
681: )
682: );
683: }
684: else if (default_servant != null)
685: {
686: exists.setServant(default_servant);
687: }
688: if (exists.servant == null)
689: {
690: exists.setServant(a_servant);
691: }
692: if (exists.servant == null)
693: {
694: throw new OBJ_ADAPTER("no servant", 4, CompletionStatus.COMPLETED_NO);
695: }
696:
697: ServantDelegateImpl delegate =
698: new ServantDelegateImpl(exists.servant, this, an_Object_Id);
699: exists.servant._set_delegate(delegate);
700: object.setServant(exists.servant);
701: connect_to_orb(an_Object_Id, delegate.object);
702: }
703:
704:
715: public void deactivate_object(byte[] the_Object_Id)
716: throws ObjectNotActive, WrongPolicy
717: {
718: required(ServantRetentionPolicyValue.RETAIN);
719:
720: AOM.Obj exists = aom.get(the_Object_Id);
721:
722: if (exists == null || exists.isDeactiveted())
723: throw new ObjectNotActive();
724:
725: exists.setDeactivated(true);
726:
727:
728: aom.remove(the_Object_Id);
729:
730: AOM.Obj other = aom.findServant(exists.servant, false);
731:
732: boolean remaining = other != null;
733:
734: aom.put(exists);
735:
736: if (servant_activator != null)
737: servant_activator.etherealize(the_Object_Id, this, exists.servant, false,
738: remaining
739: );
740: }
741:
742:
754: public org.omg.CORBA.Object create_reference(String a_repository_id)
755: throws WrongPolicy
756: {
757: required(IdAssignmentPolicyValue.SYSTEM_ID);
758: return create_reference_with_id(AOM.getFreeId(), a_repository_id);
759: }
760:
761:
776: public org.omg.CORBA.Object create_reference_with_id(byte[] an_object_id,
777: String a_repository_id
778: )
779: {
780: String[] ids;
781: if (a_repository_id == null)
782: ids = null;
783: else
784: ids = new String[] { a_repository_id };
785:
786:
787: AOM.Obj e = aom.get(an_object_id);
788:
789: Servant servant;
790: if (e == null)
791: {
792: servant = null;
793: }
794: else
795: {
796: servant = e.servant;
797: e.setDeactivated(false);
798: }
799:
800: gnuServantObject object =
801: new gnuServantObject(ids, an_object_id, this, m_orb);
802: object._set_delegate(new LocalDelegate(object, this, an_object_id));
803: aom.add(object.Id, object, servant, this);
804: connect_to_orb(an_object_id, object);
805:
806: return object;
807: }
808:
809:
829: public POA create_POA(String child_name, POAManager manager, Policy[] policies)
830: throws AdapterAlreadyExists, InvalidPolicy
831: {
832: POA child;
833: for (int i = 0; i < children.size(); i++)
834: {
835: child = (POA) children.get(i);
836: if (child.the_name().equals(child_name))
837: throw new AdapterAlreadyExists(name + "/" + child_name);
838: }
839:
840: POA poa = createPoaInstance(child_name, manager, policies, m_orb);
841: children.add(poa);
842: return poa;
843: }
844:
845:
854: public Servant get_servant()
855: throws NoServant, WrongPolicy
856: {
857: required(RequestProcessingPolicyValue.USE_DEFAULT_SERVANT);
858: if (default_servant == null)
859: throw new NoServant();
860: return default_servant;
861: }
862:
863:
871: public void set_servant(Servant a_servant)
872: throws WrongPolicy
873: {
874: required(RequestProcessingPolicyValue.USE_DEFAULT_SERVANT);
875: default_servant = a_servant;
876: }
877:
878:
897: public void set_servant_manager(ServantManager a_manager)
898: throws WrongPolicy
899: {
900: required(RequestProcessingPolicyValue.USE_SERVANT_MANAGER);
901: if (servant_activator != null || servant_locator != null)
902: throw new BAD_INV_ORDER("Setting manager twice for " + name, 6,
903: CompletionStatus.COMPLETED_NO
904: );
905:
906: if (applies(ServantRetentionPolicyValue.RETAIN))
907: {
908: if (a_manager instanceof ServantActivator)
909: servant_activator = (ServantActivator) a_manager;
910: else
911: throw new OBJ_ADAPTER("RETAIN requires ServantActivator", 4,
912: CompletionStatus.COMPLETED_NO
913: );
914: }
915: else if (applies(ServantRetentionPolicyValue.NON_RETAIN))
916: {
917: if (a_manager instanceof ServantLocator)
918: servant_locator = (ServantLocator) a_manager;
919: else
920: throw new OBJ_ADAPTER("NON_RETAIN requires ServantLocator", 4,
921: CompletionStatus.COMPLETED_NO
922: );
923: }
924: else
925: throw new WrongPolicy("No servant retention policy is specified.");
926: }
927:
928:
937: public ServantManager get_servant_manager()
938: throws WrongPolicy
939: {
940: required(RequestProcessingPolicyValue.USE_SERVANT_MANAGER);
941:
942: if (servant_activator != null)
943: return servant_activator;
944: else
945: return servant_locator;
946: }
947:
948:
956: public byte[] id()
957: {
958: if (m_poa_id != null)
959: return m_poa_id;
960: else
961: {
962: BufferedCdrOutput buffer = new BufferedCdrOutput();
963: POA p = this;
964: while (p != null)
965: {
966: buffer.write_string(p.the_name());
967: p = p.the_parent();
968: }
969: m_poa_id = buffer.buffer.toByteArray();
970: return m_poa_id;
971: }
972: }
973:
974:
984: public org.omg.CORBA.Object id_to_reference(byte[] the_Object_Id)
985: throws ObjectNotActive, WrongPolicy
986: {
987: required(ServantRetentionPolicyValue.RETAIN);
988:
989: AOM.Obj ref = aom.get(the_Object_Id);
990: if (ref == null)
991: throw new ObjectNotActive();
992: else
993: return ref.object;
994: }
995:
996:
1007: public Servant id_to_servant(byte[] the_Object_Id)
1008: throws ObjectNotActive, WrongPolicy
1009: {
1010: if (applies(ServantRetentionPolicyValue.RETAIN))
1011: {
1012: AOM.Obj ref = aom.get(the_Object_Id);
1013: if (ref == null || ref.isDeactiveted())
1014: {
1015: if (default_servant != null)
1016: return default_servant;
1017: else
1018: throw new ObjectNotActive();
1019: }
1020: else if (ref.servant != null)
1021: return ref.servant;
1022: else if (default_servant != null)
1023: return default_servant;
1024: else
1025: throw new ObjectNotActive();
1026: }
1027: else if (default_servant != null)
1028: {
1029: return default_servant;
1030: }
1031: else
1032: throw new WrongPolicy("Either RETAIN or USE_DEFAULT_SERVANT required.");
1033: }
1034:
1035:
1044: public byte[] reference_to_id(org.omg.CORBA.Object the_Object)
1045: throws WrongAdapter, WrongPolicy
1046: {
1047: AOM.Obj ref = aom.findObject(the_Object);
1048: if (ref == null)
1049: throw new WrongAdapter();
1050: return ref.key;
1051: }
1052:
1053:
1067: public Servant reference_to_servant(org.omg.CORBA.Object the_Object)
1068: throws ObjectNotActive, WrongPolicy,
1069: WrongAdapter
1070: {
1071: if (applies(ServantRetentionPolicyValue.RETAIN))
1072: {
1073: AOM.Obj ref = aom.findObject(the_Object);
1074: if (ref == null)
1075: throw new WrongAdapter();
1076: else if (ref.isDeactiveted() || ref.servant == null)
1077: {
1078: if (default_servant != null)
1079: return default_servant;
1080: else
1081: throw new ObjectNotActive();
1082: }
1083: else
1084: return ref.servant;
1085: }
1086: else if (default_servant != null)
1087: {
1088: return default_servant;
1089: }
1090: else
1091: throw new WrongPolicy("Either RETAIN or USE_DEFAULT_SERVANT required.");
1092: }
1093:
1094:
1121: public byte[] servant_to_id(Servant the_Servant)
1122: throws ServantNotActive, WrongPolicy
1123: {
1124: if (applies(RequestProcessingPolicyValue.USE_DEFAULT_SERVANT) ||
1125: applies(ServantRetentionPolicyValue.RETAIN) &&
1126: (
1127: applies(IdUniquenessPolicyValue.UNIQUE_ID) ||
1128: applies(ImplicitActivationPolicyValue.IMPLICIT_ACTIVATION)
1129: )
1130: )
1131: {
1132: AOM.Obj ref = null;
1133: if (!applies(IdUniquenessPolicyValue.MULTIPLE_ID))
1134: ref = aom.findServant(the_Servant);
1135: if (ref == null &&
1136: applies(ImplicitActivationPolicyValue.IMPLICIT_ACTIVATION)
1137: )
1138: {
1139:
1140: try
1141: {
1142: return activate_object(the_Servant);
1143: }
1144: catch (ServantAlreadyActive ex)
1145: {
1146:
1147: throw new InternalError();
1148: }
1149: }
1150: if (ref == null)
1151: throw new ServantNotActive();
1152: else
1153: return ref.key;
1154: }
1155: else
1156: throw new WrongPolicy("(RETAIN and UNIQUE ID) " +
1157: "or USE_DEFAULT_SERVANT required."
1158: );
1159: }
1160:
1161:
1181: public org.omg.CORBA.Object servant_to_reference(Servant the_Servant)
1182: throws ServantNotActive, WrongPolicy
1183: {
1184: required(ServantRetentionPolicyValue.RETAIN);
1185:
1186: AOM.Obj exists = null;
1187:
1188: if (!applies(IdUniquenessPolicyValue.MULTIPLE_ID))
1189: exists = aom.findServant(the_Servant);
1190:
1191: if (exists != null)
1192: {
1193: if (exists.isDeactiveted())
1194: {
1195: if (applies(ImplicitActivationPolicyValue.IMPLICIT_ACTIVATION))
1196: {
1197: checkDiscarding();
1198: exists.setDeactivated(false);
1199: incarnate(exists, exists.key, the_Servant, false);
1200: }
1201: else
1202: throw new ServantNotActive();
1203: }
1204: else
1205: return exists.object;
1206: }
1207: if (exists == null
1208: && applies(ImplicitActivationPolicyValue.IMPLICIT_ACTIVATION))
1209: {
1210: checkDiscarding();
1211:
1212: byte[] object_key = AOM.getFreeId();
1213:
1214: ServantDelegateImpl delegate = new ServantDelegateImpl(the_Servant,
1215: this, object_key);
1216: create_and_connect(object_key, the_Servant._all_interfaces(this,
1217: object_key)[0], delegate);
1218:
1219: return delegate.object;
1220: }
1221: else
1222: throw new ServantNotActive();
1223: }
1224:
1225:
1241: private Servant incarnate(AOM.Obj x, byte[] object_key,
1242: Servant a_servant, boolean use_forwarding
1243: )
1244: {
1245: if (servant_activator != null)
1246: {
1247: Servant servant;
1248: try
1249: {
1250: servant = servant_activator.incarnate(object_key, this);
1251: }
1252: catch (ForwardRequest ex)
1253: {
1254: if (use_forwarding)
1255: throw new gnuForwardRequest(ex.forward_reference);
1256: else
1257: servant =
1258: ForwardedServant.create((ObjectImpl) ex.forward_reference);
1259: }
1260: if (servant != null && x != null)
1261: x.setServant(servant);
1262: if (servant == null && x != null)
1263: servant = x.servant;
1264: return servant;
1265: }
1266: else if (a_servant != null)
1267: {
1268: x.setServant(a_servant);
1269: return a_servant;
1270: }
1271: else if (x.servant != null)
1272: {
1273: return x.servant;
1274: }
1275: else if (default_servant != null)
1276: {
1277: x.setServant(default_servant);
1278: return x.servant;
1279: }
1280: else
1281: throw new BAD_INV_ORDER("No servant given and the servant activator not set");
1282: }
1283:
1284:
1289: public POAManager the_POAManager()
1290: {
1291: return m_manager;
1292: }
1293:
1294:
1302: public AdapterActivator the_activator()
1303: {
1304: return m_activator;
1305: }
1306:
1307:
1312: public void the_activator(AdapterActivator an_activator)
1313: {
1314: m_activator = an_activator;
1315: }
1316:
1317:
1322: public POA[] the_children()
1323: {
1324: POA[] poas = new POA[ children.size() ];
1325: for (int i = 0; i < poas.length; i++)
1326: {
1327: poas [ i ] = (POA) children.get(i);
1328: }
1329: return poas;
1330: }
1331:
1332:
1337: public String the_name()
1338: {
1339: return name;
1340: }
1341: ;
1342:
1343:
1348: public POA the_parent()
1349: {
1350: return parent;
1351: }
1352:
1353:
1354: public IdAssignmentPolicy create_id_assignment_policy(IdAssignmentPolicyValue a_value)
1355: {
1356: return new gnuIdAssignmentPolicy(a_value);
1357: }
1358:
1359:
1360: public IdUniquenessPolicy create_id_uniqueness_policy(IdUniquenessPolicyValue a_value)
1361: {
1362: return new gnuIdUniquenessPolicy(a_value);
1363: }
1364:
1365:
1366: public ImplicitActivationPolicy create_implicit_activation_policy(ImplicitActivationPolicyValue a_value)
1367: {
1368: return new gnuImplicitActivationPolicy(a_value);
1369: }
1370:
1371:
1372: public LifespanPolicy create_lifespan_policy(LifespanPolicyValue a_value)
1373: {
1374: return new gnuLifespanPolicy(a_value);
1375: }
1376:
1377:
1378: public RequestProcessingPolicy create_request_processing_policy(RequestProcessingPolicyValue a_value)
1379: {
1380: return new gnuRequestProcessingPolicy(a_value);
1381: }
1382:
1383:
1384: public ServantRetentionPolicy create_servant_retention_policy(ServantRetentionPolicyValue a_value)
1385: {
1386: return new gnuServantRetentionPolicy(a_value);
1387: }
1388:
1389:
1390: public ThreadPolicy create_thread_policy(ThreadPolicyValue a_value)
1391: {
1392: return new gnuThreadPolicy(a_value);
1393: }
1394:
1395:
1419: public void destroy(boolean etherealize_objects, boolean wait_for_completion)
1420: {
1421:
1422: if (m_orb.iIor != null)
1423: m_orb.iIor.adapter_state_changed(
1424: new ObjectReferenceTemplate[] { getReferenceTemplate() },
1425: NON_EXISTENT.value);
1426:
1427: if (wait_for_completion)
1428: waitWhileRunning();
1429:
1430:
1431: if (m_manager instanceof gnuPOAManager)
1432: {
1433: ((gnuPOAManager) m_manager).poaDestroyed(this);
1434: }
1435:
1436:
1437:
1438: gnuPOAManager g = new gnuPOAManager();
1439: g.state = State.INACTIVE;
1440: m_manager = g;
1441:
1442:
1443: if (parent instanceof gnuPOA)
1444: {
1445: ((gnuPOA) parent).children.remove(this);
1446: }
1447:
1448: unregisterFromManager();
1449:
1450:
1451: ArrayList keys = new ArrayList();
1452: keys.addAll(aom.keySet());
1453:
1454: byte[] key;
1455: AOM.Obj obj;
1456: for (int i = 0; i < keys.size(); i++)
1457: {
1458: key = (byte[]) keys.get(i);
1459: obj = aom.get(key);
1460: if (obj.poa == this)
1461: m_orb.disconnect(obj.object);
1462: }
1463:
1464: m_orb.identityDestroyed(this);
1465:
1466: if (etherealize_objects && servant_activator != null && !m_inDestruction)
1467: {
1468: etherealizeAll();
1469: }
1470: m_inDestruction = true;
1471:
1472: POA[] ch = the_children();
1473: for (int i = 0; i < ch.length; i++)
1474: {
1475: ch[i].destroy(etherealize_objects, wait_for_completion);
1476: }
1477: }
1478:
1479:
1482: protected void finalize()
1483: throws java.lang.Throwable
1484: {
1485: if (!m_inDestruction)
1486: destroy(false, false);
1487: }
1488:
1489:
1492: private void unregisterFromManager()
1493: {
1494: if (m_manager instanceof gnuPOAManager)
1495: {
1496: gnuPOAManager p = (gnuPOAManager) m_manager;
1497: p.removePOA(this);
1498: }
1499: }
1500:
1501:
1510: public Policy _get_policy(int a_policy_type)
1511: throws org.omg.CORBA.BAD_PARAM
1512: {
1513: for (int i = 0; i < s_policies.length; i++)
1514: {
1515: if (s_policies [ i ].policy_type() == a_policy_type)
1516: return s_policies [ i ].copy();
1517: }
1518: throw new BAD_PARAM("No policy type " + a_policy_type);
1519: }
1520:
1521:
1524: public Policy[] getPolicyArray()
1525: {
1526: Policy[] r = new Policy[ s_policies.length ];
1527: for (int i = 0; i < s_policies.length; i++)
1528: {
1529: r [ i ] = s_policies [ i ].copy();
1530: }
1531: return r;
1532: }
1533:
1534:
1541: public org.omg.CORBA.Object _set_policy_override(Policy[] policies,
1542: SetOverrideType how
1543: )
1544: {
1545: throw new NO_IMPLEMENT("Use createPOA instead.");
1546: }
1547:
1548:
1551: public ORB orb()
1552: {
1553: return m_orb;
1554: }
1555:
1556:
1559: private void create_and_connect(byte[] object_key, String repository_id,
1560: ServantDelegateImpl delegate)
1561: {
1562: aom.add(delegate);
1563: connect_to_orb(object_key, getReferenceFactory().make_object(repository_id,
1564: object_key));
1565: if (servant_activator != null)
1566: incarnate(null, object_key, delegate.servant, false);
1567: }
1568:
1569:
1575: private void checkDiscarding()
1576: throws TRANSIENT
1577: {
1578: if (m_manager.get_state() == State.DISCARDING)
1579: throw new TRANSIENT("Discarding mode", 1, CompletionStatus.COMPLETED_MAYBE);
1580: }
1581:
1582:
1585: protected void connect_to_orb(byte[] an_Object_Id, org.omg.CORBA.Object object)
1586: {
1587: if (applies(ThreadPolicyValue.SINGLE_THREAD_MODEL))
1588: m_orb.connect_1_thread(object, toIORKey(an_Object_Id), this);
1589: else
1590: m_orb.connect(object, toIORKey(an_Object_Id));
1591: }
1592:
1593:
1596: public String toString()
1597: {
1598: StringBuffer b = new StringBuffer(name);
1599:
1600: if (children.size() != 0)
1601: {
1602: b.append(" (");
1603:
1604: for (int i = 0; i < children.size(); i++)
1605: {
1606: b.append(children.get(i));
1607: if (i < children.size() - 2)
1608: b.append(", ");
1609: }
1610: b.append(")");
1611: }
1612: return b.toString();
1613: }
1614:
1615:
1618: protected boolean validatePolicies(Policy[] a)
1619: throws InvalidPolicy
1620: {
1621: if (applies(ServantRetentionPolicyValue.NON_RETAIN))
1622: {
1623: if (!applies(RequestProcessingPolicyValue.USE_DEFAULT_SERVANT) &&
1624: !applies(RequestProcessingPolicyValue.USE_SERVANT_MANAGER)
1625: )
1626: {
1627: short p = 0;
1628: for (short i = 0; i < a.length; i++)
1629: {
1630: if (a [ i ].policy_type() == SERVANT_RETENTION_POLICY_ID.value)
1631: p = i;
1632: }
1633: throw new InvalidPolicy("NON_RETAIN requires either " +
1634: "USE_DEFAULT_SERVANT or USE_SERVANT_MANAGER",
1635: p
1636: );
1637: }
1638: }
1639: return true;
1640: }
1641:
1642:
1645: public AOM.Obj findObject(org.omg.CORBA.Object object)
1646: {
1647: AOM.Obj h = aom.findObject(object);
1648: if (h != null)
1649: return h;
1650: else
1651: {
1652: for (int i = 0; i < children.size(); i++)
1653: {
1654: h = ((gnuPOA) children.get(i)).findObject(object);
1655: if (h != null)
1656: return h;
1657: }
1658: }
1659: return h;
1660: }
1661:
1662:
1668: public AOM.Obj findKey(byte[] object_id, byte[] poa_id)
1669: {
1670: AOM.Obj h = null;
1671: if (Arrays.equals(poa_id, id()))
1672: h = aom.get(object_id);
1673: if (h != null)
1674: return h;
1675: else
1676: {
1677: for (int i = 0; i < children.size(); i++)
1678: {
1679: h = ((gnuPOA) children.get(i)).findKey(object_id, poa_id);
1680: if (h != null)
1681: return h;
1682: }
1683: }
1684: return h;
1685: }
1686:
1687:
1691: public AOM.Obj findIorKey(byte[] ior_key)
1692: {
1693: BufferredCdrInput in = new BufferredCdrInput(ior_key);
1694: int signature = in.read_long();
1695: if (signature != SIGNATURE)
1696: return null;
1697:
1698: byte[] id = in.read_sequence();
1699: byte[] poa = in.read_sequence();
1700: return findKey(id, poa);
1701: }
1702:
1703:
1708: public byte[] toIORKey(byte[] object_id)
1709: {
1710: BufferedCdrOutput buffer = new BufferedCdrOutput();
1711: buffer.write_long(SIGNATURE);
1712: buffer.write_sequence(object_id);
1713: buffer.write_sequence(id());
1714: return buffer.buffer.toByteArray();
1715: }
1716:
1717:
1726: public byte[] idFormIor(byte[] ior_key)
1727: {
1728: BufferredCdrInput in = new BufferredCdrInput(ior_key);
1729: int signature = in.read_long();
1730: if (signature != SIGNATURE)
1731: return null;
1732:
1733: byte[] object_id = in.read_sequence();
1734: byte[] poa_id = in.read_sequence();
1735: if (Arrays.equals(poa_id, id()))
1736: return object_id;
1737: else
1738: return null;
1739: }
1740:
1741:
1744: public AOM.Obj findServant(Servant servant)
1745: {
1746: AOM.Obj h = aom.findServant(servant);
1747: if (h != null)
1748: return h;
1749: else
1750: {
1751: for (int i = 0; i < children.size(); i++)
1752: {
1753: h = ((gnuPOA) children.get(i)).findServant(servant);
1754: if (h != null)
1755: return h;
1756: }
1757: }
1758: return h;
1759: }
1760:
1761:
1765: public ObjectReferenceTemplate getReferenceTemplate()
1766: {
1767: if (refTemplate == null)
1768: refTemplate = new RefTemplate();
1769:
1770: return refTemplate;
1771: }
1772:
1773: public ObjectReferenceFactory getReferenceFactory()
1774: {
1775: return m_object_factory;
1776: }
1777:
1778: public void setReferenceFactory(ObjectReferenceFactory factory)
1779: {
1780: m_object_factory = factory;
1781: }
1782:
1783:
1786: public Object make_object(String a_repository_id, byte[] an_object_id)
1787: {
1788: AOM.Obj existing = aom.get(an_object_id);
1789:
1790: if (existing != null && existing.object != null)
1791: return existing.object;
1792: else
1793: {
1794: return new gnuServantObject(new String[] { a_repository_id },
1795: an_object_id, this, m_orb);
1796: }
1797: }
1798:
1799:
1802: public String[] _truncatable_ids()
1803: {
1804: return ref_template_ids;
1805: }