jdk-sandbox: comparison jdk/src/java.management/share/classes/javax/management/relation/RelationSupport.java

equal deleted inserted replaced

-:cb2a6851b837
+:da1786d695b6
 /*
-* Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2000, 2017, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 package javax.management.relation;
+import java.lang.System.Logger.Level;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.Map;
 import java.util.List;
 throws InvalidRoleValueException,
 IllegalArgumentException {
 super();
-RELATION_LOGGER.entering(RelationSupport.class.getName(),
+RELATION_LOGGER.log(Level.TRACE, "ENTRY");
-"RelationSupport");
 // Can throw InvalidRoleValueException and IllegalArgumentException
 initMembers(relationId,
 relationServiceName,
 null,
 relationTypeName,
 list);
-RELATION_LOGGER.exiting(RelationSupport.class.getName(),
+RELATION_LOGGER.log(Level.TRACE, "RETURN");
-"RelationSupport");
 }
 /**
 * Creates a {@code RelationSupport} object.
 * <P>This constructor has to be used when the user relation MBean
 if (relationServiceMBeanServer == null) {
 String excMsg = "Invalid parameter.";
 throw new IllegalArgumentException(excMsg);
 }
-RELATION_LOGGER.entering(RelationSupport.class.getName(),
+RELATION_LOGGER.log(Level.TRACE, "ENTRY");
-"RelationSupport");
 // Can throw InvalidRoleValueException and
 // IllegalArgumentException
 initMembers(relationId,
 relationServiceName,
 relationServiceMBeanServer,
 relationTypeName,
 list);
-RELATION_LOGGER.exiting(RelationSupport.class.getName(),
+RELATION_LOGGER.log(Level.TRACE, "RETURN");
-"RelationSupport");
 }
 //
 // Relation Interface
 //
 if (roleName == null) {
 String excMsg = "Invalid parameter.";
 throw new IllegalArgumentException(excMsg);
 }
-RELATION_LOGGER.entering(RelationSupport.class.getName(),
+RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", roleName);
-"getRole", roleName);
 // Can throw RoleNotFoundException and
 // RelationServiceNotRegisteredException
 List<ObjectName> result = cast(
 getRoleInt(roleName, false, null, false));
-RELATION_LOGGER.exiting(RelationSupport.class.getName(), "getRole");
+RELATION_LOGGER.log(Level.TRACE, "RETURN");
 return result;
 }
 /**
 * Retrieves values of roles with given names.
 if (roleNameArray == null) {
 String excMsg = "Invalid parameter.";
 throw new IllegalArgumentException(excMsg);
 }
-RELATION_LOGGER.entering(RelationSupport.class.getName(), "getRoles");
+RELATION_LOGGER.log(Level.TRACE, "ENTRY");
 // Can throw RelationServiceNotRegisteredException
 RoleResult result = getRolesInt(roleNameArray, false, null);
-RELATION_LOGGER.exiting(RelationSupport.class.getName(), "getRoles");
+RELATION_LOGGER.log(Level.TRACE, "RETURN");
 return result;
 }
 /**
 * Returns all roles present in the relation.
 * Service is not registered in the MBean Server
 */
 public RoleResult getAllRoles()
 throws RelationServiceNotRegisteredException {
-RELATION_LOGGER.entering(RelationSupport.class.getName(),
+RELATION_LOGGER.log(Level.TRACE, "ENTRY");
-"getAllRoles");
 RoleResult result = null;
 try {
 result = getAllRolesInt(false, null);
 } catch (IllegalArgumentException exc) {
 // OK : Invalid parameters, ignore...
 }
-RELATION_LOGGER.exiting(RelationSupport.class.getName(), "getAllRoles");
+RELATION_LOGGER.log(Level.TRACE, "RETURN");
 return result;
 }
 /**
 * Returns all roles in the relation without checking read mode.
 *
 * @return a RoleList
 */
 public RoleList retrieveAllRoles() {
-RELATION_LOGGER.entering(RelationSupport.class.getName(),
+RELATION_LOGGER.log(Level.TRACE, "ENTRY");
-"retrieveAllRoles");
 RoleList result;
 synchronized(myRoleName2ValueMap) {
 result =
 new RoleList(new ArrayList<Role>(myRoleName2ValueMap.values()));
 }
-RELATION_LOGGER.exiting(RelationSupport.class.getName(),
+RELATION_LOGGER.log(Level.TRACE, "RETURN");
-"retrieveAllRoles");
 return result;
 }
 /**
 * Returns the number of MBeans currently referenced in the given role.
 if (roleName == null) {
 String excMsg = "Invalid parameter.";
 throw new IllegalArgumentException(excMsg);
 }
-RELATION_LOGGER.entering(RelationSupport.class.getName(),
+RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", roleName);
-"getRoleCardinality", roleName);
 // Try to retrieve the role
 Role role;
 synchronized(myRoleName2ValueMap) {
 // No null Role is allowed, so direct use of get()
 }
 }
 List<ObjectName> roleValue = role.getRoleValue();
-RELATION_LOGGER.exiting(RelationSupport.class.getName(),
+RELATION_LOGGER.log(Level.TRACE, "RETURN");
-"getRoleCardinality");
 return roleValue.size();
 }
 /**
 * Sets the given role.
 if (role == null) {
 String excMsg = "Invalid parameter.";
 throw new IllegalArgumentException(excMsg);
 }
-RELATION_LOGGER.entering(RelationSupport.class.getName(),
+RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", role);
-"setRole", role);
 // Will return null :)
 Object result = setRoleInt(role, false, null, false);
-RELATION_LOGGER.exiting(RelationSupport.class.getName(), "setRole");
+RELATION_LOGGER.log(Level.TRACE, "RETURN");
 return;
 }
 /**
 * Sets the given roles.
 if (list == null) {
 String excMsg = "Invalid parameter.";
 throw new IllegalArgumentException(excMsg);
 }
-RELATION_LOGGER.entering(RelationSupport.class.getName(),
+RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", list);
-"setRoles", list);
 RoleResult result = setRolesInt(list, false, null);
-RELATION_LOGGER.exiting(RelationSupport.class.getName(), "setRoles");
+RELATION_LOGGER.log(Level.TRACE, "RETURN");
 return result;
 }
 /**
 * Callback used by the Relation Service when a MBean referenced in a role
 if (objectName == null || roleName == null) {
 String excMsg = "Invalid parameter.";
 throw new IllegalArgumentException(excMsg);
 }
-RELATION_LOGGER.entering(RelationSupport.class.getName(),
+RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1}", objectName, roleName);
-"handleMBeanUnregistration",
-new Object[]{objectName, roleName});
 // Can throw RoleNotFoundException, InvalidRoleValueException,
 // or RelationTypeNotFoundException
 handleMBeanUnregistrationInt(objectName,
 roleName,
 false,
 null);
-RELATION_LOGGER.exiting(RelationSupport.class.getName(),
+RELATION_LOGGER.log(Level.TRACE, "RETURN");
-"handleMBeanUnregistration");
 return;
 }
 /**
 * Retrieves MBeans referenced in the various roles of the relation.
 * @return a HashMap mapping:
 * <P> ObjectName {@literal ->} ArrayList of String (role names)
 */
 public Map<ObjectName,List<String>> getReferencedMBeans() {
-RELATION_LOGGER.entering(RelationSupport.class.getName(),
+RELATION_LOGGER.log(Level.TRACE, "ENTRY");
-"getReferencedMBeans");
 Map<ObjectName,List<String>> refMBeanMap =
 new HashMap<ObjectName,List<String>>();
 synchronized(myRoleName2ValueMap) {
 }
 }
 }
 }
-RELATION_LOGGER.exiting(RelationSupport.class.getName(),
+RELATION_LOGGER.log(Level.TRACE, "RETURN");
-"getReferencedMBeans");
 return refMBeanMap;
 }
 /**
 * Returns name of associated relation type.
 (relationServCallFlg && relationServ == null)) {
 String excMsg = "Invalid parameter.";
 throw new IllegalArgumentException(excMsg);
 }
-RELATION_LOGGER.entering(RelationSupport.class.getName(),
+RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", roleName);
-"getRoleInt", roleName);
 int pbType = 0;
 Role role;
 synchronized(myRoleName2ValueMap) {
 // returns a RoleUnresolved object
 result = new RoleUnresolved(roleName, null, pbType);
 }
 }
-RELATION_LOGGER.exiting(RelationSupport.class.getName(), "getRoleInt");
+RELATION_LOGGER.log(Level.TRACE, "RETURN");
 return result;
 }
 // Gets the given roles
 // For each role, verifies if the role exists and is readable according to
 (relationServCallFlg && relationServ == null)) {
 String excMsg = "Invalid parameter.";
 throw new IllegalArgumentException(excMsg);
 }
-RELATION_LOGGER.entering(RelationSupport.class.getName(),
+RELATION_LOGGER.log(Level.TRACE, "ENTRY");
-"getRolesInt");
 RoleList roleList = new RoleList();
 RoleUnresolvedList roleUnresList = new RoleUnresolvedList();
 for (int i = 0; i < roleNameArray.length; i++) {
 }
 }
 }
 RoleResult result = new RoleResult(roleList, roleUnresList);
-RELATION_LOGGER.exiting(RelationSupport.class.getName(),
+RELATION_LOGGER.log(Level.TRACE, "RETURN");
-"getRolesInt");
 return result;
 }
 // Returns all roles present in the relation
 //
 if (relationServCallFlg && relationServ == null) {
 String excMsg = "Invalid parameter.";
 throw new IllegalArgumentException(excMsg);
 }
-RELATION_LOGGER.entering(RelationSupport.class.getName(),
+RELATION_LOGGER.log(Level.TRACE, "ENTRY");
-"getAllRolesInt");
 List<String> roleNameList;
 synchronized(myRoleName2ValueMap) {
 roleNameList =
 new ArrayList<String>(myRoleName2ValueMap.keySet());
 RoleResult result = getRolesInt(roleNames,
 relationServCallFlg,
 relationServ);
-RELATION_LOGGER.exiting(RelationSupport.class.getName(),
+RELATION_LOGGER.log(Level.TRACE, "RETURN");
-"getAllRolesInt");
 return result;
 }
 // Sets the role with given value
 //
 (relationServCallFlg && relationServ == null)) {
 String excMsg = "Invalid parameter.";
 throw new IllegalArgumentException(excMsg);
 }
-RELATION_LOGGER.entering(RelationSupport.class.getName(),
+RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1} {2} {3}",
-"setRoleInt", new Object[] {aRole, relationServCallFlg,
+aRole, relationServCallFlg, relationServ,
-relationServ, multiRoleFlg});
+multiRoleFlg);
 String roleName = aRole.getRoleName();
 int pbType = 0;
 // Checks if role exists in the relation
 aRole.getRoleValue(),
 pbType);
 }
 }
-RELATION_LOGGER.exiting(RelationSupport.class.getName(), "setRoleInt");
+RELATION_LOGGER.log(Level.TRACE, "RETURN");
 return result;
 }
 // Requires the Relation Service to send a notification
 // RelationNotification, with type being either:
 (relationServCallFlg && relationServ == null)) {
 String excMsg = "Invalid parameter.";
 throw new IllegalArgumentException(excMsg);
 }
-RELATION_LOGGER.entering(RelationSupport.class.getName(),
+RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1} {2} {3}",
-"sendRoleUpdateNotification", new Object[] {newRole,
+newRole, oldRoleValue, relationServCallFlg,
-oldRoleValue, relationServCallFlg, relationServ});
+relationServ);
 if (relationServCallFlg) {
 // Direct call to the Relation Service
 // Shall not throw a RelationNotFoundException for an internal
 // relation
 throw new RuntimeException(wrappedExc.getMessage());
 }
 }
 }
-RELATION_LOGGER.exiting(RelationSupport.class.getName(),
+RELATION_LOGGER.log(Level.TRACE, "RETURN");
-"sendRoleUpdateNotification");
 return;
 }
 // Requires the Relation Service to update its internal map handling
 // MBeans referenced in relations.
 (relationServCallFlg && relationServ == null)) {
 String excMsg = "Invalid parameter.";
 throw new IllegalArgumentException(excMsg);
 }
-RELATION_LOGGER.entering(RelationSupport.class.getName(),
+RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1} {2} {3}",
-"updateRelationServiceMap", new Object[] {newRole,
+newRole, oldRoleValue, relationServCallFlg,
-oldRoleValue, relationServCallFlg, relationServ});
+relationServ);
 if (relationServCallFlg) {
 // Direct call to the Relation Service
 // Shall not throw a RelationNotFoundException
 try {
 throw new RuntimeException(wrappedExc.getMessage());
 }
 }
 }
-RELATION_LOGGER.exiting(RelationSupport.class.getName(),
+RELATION_LOGGER.log(Level.TRACE, "RETURN");
-"updateRelationServiceMap");
 return;
 }
 // Sets the given roles
 // For each role:
 (relationServCallFlg && relationServ == null)) {
 String excMsg = "Invalid parameter.";
 throw new IllegalArgumentException(excMsg);
 }
-RELATION_LOGGER.entering(RelationSupport.class.getName(),
+RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1} {2}",
-"setRolesInt",
+list, relationServCallFlg, relationServ);
-new Object[] {list, relationServCallFlg, relationServ});
 RoleList roleList = new RoleList();
 RoleUnresolvedList roleUnresList = new RoleUnresolvedList();
 for (Role currRole : list.asList()) {
 }
 }
 RoleResult result = new RoleResult(roleList, roleUnresList);
-RELATION_LOGGER.exiting(RelationSupport.class.getName(), "setRolesInt");
+RELATION_LOGGER.log(Level.TRACE, "RETURN");
 return result;
 }
 // Initializes all members
 //
 relationTypeName == null) {
 String excMsg = "Invalid parameter.";
 throw new IllegalArgumentException(excMsg);
 }
-RELATION_LOGGER.entering(RelationSupport.class.getName(),
+RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1} {2} {3} {4}",
-"initMembers", new Object[] {relationId, relationServiceName,
+relationId, relationServiceName,
-relationServiceMBeanServer, relationTypeName, list});
+relationServiceMBeanServer, relationTypeName, list);
 myRelId = relationId;
 myRelServiceName = relationServiceName;
 myRelServiceMBeanServer = relationServiceMBeanServer;
 myRelTypeName = relationTypeName;
 // Can throw InvalidRoleValueException
 initRoleMap(list);
-RELATION_LOGGER.exiting(RelationSupport.class.getName(), "initMembers");
+RELATION_LOGGER.log(Level.TRACE, "RETURN");
 return;
 }
 // Initialize the internal role map from given RoleList parameter
 //
 if (list == null) {
 return;
 }
-RELATION_LOGGER.entering(RelationSupport.class.getName(),
+RELATION_LOGGER.log(Level.TRACE, "ENTRY {0}", list);
-"initRoleMap", list);
 synchronized(myRoleName2ValueMap) {
 for (Role currRole : list.asList()) {
 myRoleName2ValueMap.put(currRoleName,
 (Role)(currRole.clone()));
 }
 }
-RELATION_LOGGER.exiting(RelationSupport.class.getName(), "initRoleMap");
+RELATION_LOGGER.log(Level.TRACE, "RETURN");
 return;
 }
 // Callback used by the Relation Service when a MBean referenced in a role
 // is unregistered.
 (relationServCallFlg && relationServ == null)) {
 String excMsg = "Invalid parameter.";
 throw new IllegalArgumentException(excMsg);
 }
-RELATION_LOGGER.entering(RelationSupport.class.getName(),
+RELATION_LOGGER.log(Level.TRACE, "ENTRY {0} {1} {2} {3}",
-"handleMBeanUnregistrationInt", new Object[] {objectName,
+objectName, roleName, relationServCallFlg,
-roleName, relationServCallFlg, relationServ});
+relationServ);
 // Retrieves current role value
 Role role;
 synchronized(myRoleName2ValueMap) {
 role = (myRoleName2ValueMap.get(roleName));
 // RelationTypeNotFoundException
 // (RoleNotFoundException already detected)
 Object result =
 setRoleInt(newRole, relationServCallFlg, relationServ, false);
-RELATION_LOGGER.exiting(RelationSupport.class.getName(),
+RELATION_LOGGER.log(Level.TRACE, "RETURN");
-"handleMBeanUnregistrationInt");
 return;
 }
 }

changeset 43235	da1786d695b6
parent 25859	3317bb8137f4