History

My first initial commit with all of mine experimental changes.

Dmitry Kabak (userdima committed 13 years ago

Commit d37b88d1 parent 3f5b46618352 files · +2598093 −-8690Browse files

Showing the changes to java/pkg/javax/management/relation/RelationTypeSupport.java (1 of 18352 files). Show all

Unified · Split

java/pkg/javax/management/relation/RelationTypeSupport.java+486−0
@@ -0,0 +1,486 @@
1+/*
2+ * Copyright (c) 2000, 2006, Oracle and/or its affiliates. All rights reserved.
3+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4+ *
5+ * This code is free software; you can redistribute it and/or modify it
6+ * under the terms of the GNU General Public License version 2 only, as
7+ * published by the Free Software Foundation. Oracle designates this
8+ * particular file as subject to the "Classpath" exception as provided
9+ * by Oracle in the LICENSE file that accompanied this code.
10+ *
11+ * This code is distributed in the hope that it will be useful, but WITHOUT
12+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14+ * version 2 for more details (a copy is included in the LICENSE file that
15+ * accompanied this code).
16+ *
17+ * You should have received a copy of the GNU General Public License version
18+ * 2 along with this work; if not, write to the Free Software Foundation,
19+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20+ *
21+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22+ * or visit www.oracle.com if you need additional information or have any
23+ * questions.
24+ */
25+
26+package javax.management.relation;
27+
28+import static com.sun.jmx.defaults.JmxProperties.RELATION_LOGGER;
29+import static com.sun.jmx.mbeanserver.Util.cast;
30+import com.sun.jmx.mbeanserver.GetPropertyAction;
31+
32+import java.io.IOException;
33+import java.io.ObjectInputStream;
34+import java.io.ObjectOutputStream;
35+import java.io.ObjectStreamField;
36+
37+import java.security.AccessController;
38+
39+import java.util.ArrayList;
40+import java.util.HashMap;
41+import java.util.HashSet;
42+import java.util.List;
43+import java.util.Map;
44+import java.util.Set;
45+import java.util.logging.Level;
46+
47+/**
48+ * A RelationTypeSupport object implements the RelationType interface.
49+ * <P>It represents a relation type, providing role information for each role
50+ * expected to be supported in every relation of that type.
51+ *
52+ * <P>A relation type includes a relation type name and a list of
53+ * role infos (represented by RoleInfo objects).
54+ *
55+ * <P>A relation type has to be declared in the Relation Service:
56+ * <P>- either using the createRelationType() method, where a RelationTypeSupport
57+ * object will be created and kept in the Relation Service
58+ * <P>- either using the addRelationType() method where the user has to create
59+ * an object implementing the RelationType interface, and this object will be
60+ * used as representing a relation type in the Relation Service.
61+ *
62+ * <p>The <b>serialVersionUID</b> of this class is <code>4611072955724144607L</code>.
63+ *
64+ * @since 1.5
65+ */
66+@SuppressWarnings("serial") // serialVersionUID not constant
67+public class RelationTypeSupport implements RelationType {
68+
69+ // Serialization compatibility stuff:
70+ // Two serial forms are supported in this class. The selected form depends
71+ // on system property "jmx.serial.form":
72+ // - "1.0" for JMX 1.0
73+ // - any other value for JMX 1.1 and higher
74+ //
75+ // Serial version for old serial form
76+ private static final long oldSerialVersionUID = -8179019472410837190L;
77+ //
78+ // Serial version for new serial form
79+ private static final long newSerialVersionUID = 4611072955724144607L;
80+ //
81+ // Serializable fields in old serial form
82+ private static final ObjectStreamField[] oldSerialPersistentFields =
83+ {
84+ new ObjectStreamField("myTypeName", String.class),
85+ new ObjectStreamField("myRoleName2InfoMap", HashMap.class),
86+ new ObjectStreamField("myIsInRelServFlg", boolean.class)
87+ };
88+ //
89+ // Serializable fields in new serial form
90+ private static final ObjectStreamField[] newSerialPersistentFields =
91+ {
92+ new ObjectStreamField("typeName", String.class),
93+ new ObjectStreamField("roleName2InfoMap", Map.class),
94+ new ObjectStreamField("isInRelationService", boolean.class)
95+ };
96+ //
97+ // Actual serial version and serial form
98+ private static final long serialVersionUID;
99+ /**
100+ * @serialField typeName String Relation type name
101+ * @serialField roleName2InfoMap Map {@link Map} holding the mapping:
102+ * &lt;role name ({@link String})&gt; -&gt; &lt;role info ({@link RoleInfo} object)&gt;
103+ * @serialField isInRelationService boolean Flag specifying whether the relation type has been declared in the
104+ * Relation Service (so can no longer be updated)
105+ */
106+ private static final ObjectStreamField[] serialPersistentFields;
107+ private static boolean compat = false;
108+ static {
109+ try {
110+ GetPropertyAction act = new GetPropertyAction("jmx.serial.form");
111+ String form = AccessController.doPrivileged(act);
112+ compat = (form != null && form.equals("1.0"));
113+ } catch (Exception e) {
114+ // OK : Too bad, no compat with 1.0
115+ }
116+ if (compat) {
117+ serialPersistentFields = oldSerialPersistentFields;
118+ serialVersionUID = oldSerialVersionUID;
119+ } else {
120+ serialPersistentFields = newSerialPersistentFields;
121+ serialVersionUID = newSerialVersionUID;
122+ }
123+ }
124+ //
125+ // END Serialization compatibility stuff
126+
127+ //
128+ // Private members
129+ //
130+
131+ /**
132+ * @serial Relation type name
133+ */
134+ private String typeName = null;
135+
136+ /**
137+ * @serial {@link Map} holding the mapping:
138+ * &lt;role name ({@link String})&gt; -&gt; &lt;role info ({@link RoleInfo} object)&gt;
139+ */
140+ private Map<String,RoleInfo> roleName2InfoMap =
141+ new HashMap<String,RoleInfo>();
142+
143+ /**
144+ * @serial Flag specifying whether the relation type has been declared in the
145+ * Relation Service (so can no longer be updated)
146+ */
147+ private boolean isInRelationService = false;
148+
149+ //
150+ // Constructors
151+ //
152+
153+ /**
154+ * Constructor where all role definitions are dynamically created and
155+ * passed as parameter.
156+ *
157+ * @param relationTypeName Name of relation type
158+ * @param roleInfoArray List of role definitions (RoleInfo objects)
159+ *
160+ * @exception IllegalArgumentException if null parameter
161+ * @exception InvalidRelationTypeException if:
162+ * <P>- the same name has been used for two different roles
163+ * <P>- no role info provided
164+ * <P>- one null role info provided
165+ */
166+ public RelationTypeSupport(String relationTypeName,
167+ RoleInfo[] roleInfoArray)
168+ throws IllegalArgumentException,
169+ InvalidRelationTypeException {
170+
171+ if (relationTypeName == null || roleInfoArray == null) {
172+ String excMsg = "Invalid parameter.";
173+ throw new IllegalArgumentException(excMsg);
174+ }
175+
176+ RELATION_LOGGER.entering(RelationTypeSupport.class.getName(),
177+ "RelationTypeSupport", relationTypeName);
178+
179+ // Can throw InvalidRelationTypeException, ClassNotFoundException
180+ // and NotCompliantMBeanException
181+ initMembers(relationTypeName, roleInfoArray);
182+
183+ RELATION_LOGGER.exiting(RelationTypeSupport.class.getName(),
184+ "RelationTypeSupport");
185+ return;
186+ }
187+
188+ /**
189+ * Constructor to be used for subclasses.
190+ *
191+ * @param relationTypeName Name of relation type.
192+ *
193+ * @exception IllegalArgumentException if null parameter.
194+ */
195+ protected RelationTypeSupport(String relationTypeName)
196+ {
197+ if (relationTypeName == null) {
198+ String excMsg = "Invalid parameter.";
199+ throw new IllegalArgumentException(excMsg);
200+ }
201+
202+ RELATION_LOGGER.entering(RelationTypeSupport.class.getName(),
203+ "RelationTypeSupport", relationTypeName);
204+
205+ typeName = relationTypeName;
206+
207+ RELATION_LOGGER.exiting(RelationTypeSupport.class.getName(),
208+ "RelationTypeSupport");
209+ return;
210+ }
211+
212+ //
213+ // Accessors
214+ //
215+
216+ /**
217+ * Returns the relation type name.
218+ *
219+ * @return the relation type name.
220+ */
221+ public String getRelationTypeName() {
222+ return typeName;
223+ }
224+
225+ /**
226+ * Returns the list of role definitions (ArrayList of RoleInfo objects).
227+ */
228+ public List<RoleInfo> getRoleInfos() {
229+ return new ArrayList<RoleInfo>(roleName2InfoMap.values());
230+ }
231+
232+ /**
233+ * Returns the role info (RoleInfo object) for the given role info name
234+ * (null if not found).
235+ *
236+ * @param roleInfoName role info name
237+ *
238+ * @return RoleInfo object providing role definition
239+ * does not exist
240+ *
241+ * @exception IllegalArgumentException if null parameter
242+ * @exception RoleInfoNotFoundException if no role info with that name in
243+ * relation type.
244+ */
245+ public RoleInfo getRoleInfo(String roleInfoName)
246+ throws IllegalArgumentException,
247+ RoleInfoNotFoundException {
248+
249+ if (roleInfoName == null) {
250+ String excMsg = "Invalid parameter.";
251+ throw new IllegalArgumentException(excMsg);
252+ }
253+
254+ RELATION_LOGGER.entering(RelationTypeSupport.class.getName(),
255+ "getRoleInfo", roleInfoName);
256+
257+ // No null RoleInfo allowed, so use get()
258+ RoleInfo result = roleName2InfoMap.get(roleInfoName);
259+
260+ if (result == null) {
261+ StringBuilder excMsgStrB = new StringBuilder();
262+ String excMsg = "No role info for role ";
263+ excMsgStrB.append(excMsg);
264+ excMsgStrB.append(roleInfoName);
265+ throw new RoleInfoNotFoundException(excMsgStrB.toString());
266+ }
267+
268+ RELATION_LOGGER.exiting(RelationTypeSupport.class.getName(),
269+ "getRoleInfo");
270+ return result;
271+ }
272+
273+ //
274+ // Misc
275+ //
276+
277+ /**
278+ * Add a role info.
279+ * This method of course should not be used after the creation of the
280+ * relation type, because updating it would invalidate that the relations
281+ * created associated to that type still conform to it.
282+ * Can throw a RuntimeException if trying to update a relation type
283+ * declared in the Relation Service.
284+ *
285+ * @param roleInfo role info to be added.
286+ *
287+ * @exception IllegalArgumentException if null parameter.
288+ * @exception InvalidRelationTypeException if there is already a role
289+ * info in current relation type with the same name.
290+ */
291+ protected void addRoleInfo(RoleInfo roleInfo)
292+ throws IllegalArgumentException,
293+ InvalidRelationTypeException {
294+
295+ if (roleInfo == null) {
296+ String excMsg = "Invalid parameter.";
297+ throw new IllegalArgumentException(excMsg);
298+ }
299+
300+ RELATION_LOGGER.entering(RelationTypeSupport.class.getName(),
301+ "addRoleInfo", roleInfo);
302+
303+ if (isInRelationService) {
304+ // Trying to update a declared relation type
305+ String excMsg = "Relation type cannot be updated as it is declared in the Relation Service.";
306+ throw new RuntimeException(excMsg);
307+ }
308+
309+ String roleName = roleInfo.getName();
310+
311+ // Checks if the role info has already been described
312+ if (roleName2InfoMap.containsKey(roleName)) {
313+ StringBuilder excMsgStrB = new StringBuilder();
314+ String excMsg = "Two role infos provided for role ";
315+ excMsgStrB.append(excMsg);
316+ excMsgStrB.append(roleName);
317+ throw new InvalidRelationTypeException(excMsgStrB.toString());
318+ }
319+
320+ roleName2InfoMap.put(roleName, new RoleInfo(roleInfo));
321+
322+ RELATION_LOGGER.exiting(RelationTypeSupport.class.getName(),
323+ "addRoleInfo");
324+ return;
325+ }
326+
327+ // Sets the internal flag to specify that the relation type has been
328+ // declared in the Relation Service
329+ void setRelationServiceFlag(boolean flag) {
330+ isInRelationService = flag;
331+ return;
332+ }
333+
334+ // Initializes the members, i.e. type name and role info list.
335+ //
336+ // -param relationTypeName Name of relation type
337+ // -param roleInfoArray List of role definitions (RoleInfo objects)
338+ //
339+ // -exception IllegalArgumentException if null parameter
340+ // -exception InvalidRelationTypeException If:
341+ // - the same name has been used for two different roles
342+ // - no role info provided
343+ // - one null role info provided
344+ private void initMembers(String relationTypeName,
345+ RoleInfo[] roleInfoArray)
346+ throws IllegalArgumentException,
347+ InvalidRelationTypeException {
348+
349+ if (relationTypeName == null || roleInfoArray == null) {
350+ String excMsg = "Invalid parameter.";
351+ throw new IllegalArgumentException(excMsg);
352+ }
353+
354+ RELATION_LOGGER.entering(RelationTypeSupport.class.getName(),
355+ "initMembers", relationTypeName);
356+
357+ typeName = relationTypeName;
358+
359+ // Verifies role infos before setting them
360+ // Can throw InvalidRelationTypeException
361+ checkRoleInfos(roleInfoArray);
362+
363+ for (int i = 0; i < roleInfoArray.length; i++) {
364+ RoleInfo currRoleInfo = roleInfoArray[i];
365+ roleName2InfoMap.put(currRoleInfo.getName(),
366+ new RoleInfo(currRoleInfo));
367+ }
368+
369+ RELATION_LOGGER.exiting(RelationTypeSupport.class.getName(),
370+ "initMembers");
371+ return;
372+ }
373+
374+ // Checks the given RoleInfo array to verify that:
375+ // - the array is not empty
376+ // - it does not contain a null element
377+ // - a given role name is used only for one RoleInfo
378+ //
379+ // -param roleInfoArray array to be checked
380+ //
381+ // -exception IllegalArgumentException
382+ // -exception InvalidRelationTypeException If:
383+ // - the same name has been used for two different roles
384+ // - no role info provided
385+ // - one null role info provided
386+ static void checkRoleInfos(RoleInfo[] roleInfoArray)
387+ throws IllegalArgumentException,
388+ InvalidRelationTypeException {
389+
390+ if (roleInfoArray == null) {
391+ String excMsg = "Invalid parameter.";
392+ throw new IllegalArgumentException(excMsg);
393+ }
394+
395+ if (roleInfoArray.length == 0) {
396+ // No role info provided
397+ String excMsg = "No role info provided.";
398+ throw new InvalidRelationTypeException(excMsg);
399+ }
400+
401+
402+ Set<String> roleNames = new HashSet<String>();
403+
404+ for (int i = 0; i < roleInfoArray.length; i++) {
405+ RoleInfo currRoleInfo = roleInfoArray[i];
406+
407+ if (currRoleInfo == null) {
408+ String excMsg = "Null role info provided.";
409+ throw new InvalidRelationTypeException(excMsg);
410+ }
411+
412+ String roleName = currRoleInfo.getName();
413+
414+ // Checks if the role info has already been described
415+ if (roleNames.contains(roleName)) {
416+ StringBuilder excMsgStrB = new StringBuilder();
417+ String excMsg = "Two role infos provided for role ";
418+ excMsgStrB.append(excMsg);
419+ excMsgStrB.append(roleName);
420+ throw new InvalidRelationTypeException(excMsgStrB.toString());
421+ }
422+ roleNames.add(roleName);
423+ }
424+
425+ return;
426+ }
427+
428+
429+ /**
430+ * Deserializes a {@link RelationTypeSupport} from an {@link ObjectInputStream}.
431+ */
432+ private void readObject(ObjectInputStream in)
433+ throws IOException, ClassNotFoundException {
434+ if (compat)
435+ {
436+ // Read an object serialized in the old serial form
437+ //
438+ ObjectInputStream.GetField fields = in.readFields();
439+ typeName = (String) fields.get("myTypeName", null);
440+ if (fields.defaulted("myTypeName"))
441+ {
442+ throw new NullPointerException("myTypeName");
443+ }
444+ roleName2InfoMap = cast(fields.get("myRoleName2InfoMap", null));
445+ if (fields.defaulted("myRoleName2InfoMap"))
446+ {
447+ throw new NullPointerException("myRoleName2InfoMap");
448+ }
449+ isInRelationService = fields.get("myIsInRelServFlg", false);
450+ if (fields.defaulted("myIsInRelServFlg"))
451+ {
452+ throw new NullPointerException("myIsInRelServFlg");
453+ }
454+ }
455+ else
456+ {
457+ // Read an object serialized in the new serial form
458+ //
459+ in.defaultReadObject();
460+ }
461+ }
462+
463+
464+ /**
465+ * Serializes a {@link RelationTypeSupport} to an {@link ObjectOutputStream}.
466+ */
467+ private void writeObject(ObjectOutputStream out)
468+ throws IOException {
469+ if (compat)
470+ {
471+ // Serializes this instance in the old serial form
472+ //
473+ ObjectOutputStream.PutField fields = out.putFields();
474+ fields.put("myTypeName", typeName);
475+ fields.put("myRoleName2InfoMap", roleName2InfoMap);
476+ fields.put("myIsInRelServFlg", isInRelationService);
477+ out.writeFields();
478+ }
479+ else
480+ {
481+ // Serializes this instance in the new serial form
482+ //
483+ out.defaultWriteObject();
484+ }
485+ }
486+}