1 /*
   2  * Copyright (c) 2003, 2008, 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 sun.management;
  27 
  28 import java.util.*;
  29 import com.sun.management.VMOption;
  30 import com.sun.management.VMOption.Origin;
  31 
  32 /**
  33  * Flag class is a helper class for constructing a VMOption.
  34  * It has the static methods for getting the Flag objects, each
  35  * corresponds to one VMOption.
  36  *
  37  */
  38 class Flag {
  39     private String name;
  40     private Object value;
  41     private Origin origin;
  42     private boolean writeable;
  43     private boolean external;
  44 
  45     Flag(String name, Object value, boolean writeable,
  46          boolean external, Origin origin) {
  47         this.name = name;
  48         this.value = value == null ? "" : value ;
  49         this.origin = origin;
  50         this.writeable = writeable;
  51         this.external = external;
  52     }
  53 
  54     Object getValue() {
  55         return value;
  56     }
  57 
  58     boolean isWriteable() {
  59         return writeable;
  60     }
  61 
  62     boolean isExternal() {
  63         return external;
  64     }
  65 
  66     VMOption getVMOption() {
  67         return new VMOption(name, value.toString(), writeable, origin);
  68     }
  69 
  70     static Flag getFlag(String name) {
  71         String[] names = new String[1];
  72         names[0] = name;
  73 
  74         List<Flag> flags = getFlags(names, 1);
  75         if (flags.isEmpty()) {
  76             return null;
  77         } else {
  78             // flags should have only one element
  79             return flags.get(0);
  80         }
  81     }
  82 
  83     static List<Flag> getAllFlags() {
  84         int numFlags = getInternalFlagCount();
  85 
  86         // Get all internal flags with names = null
  87         return getFlags(null, numFlags);
  88     }
  89 
  90     private static List<Flag> getFlags(String[] names, int numFlags) {
  91         Flag[] flags = new Flag[numFlags];
  92         int count = getFlags(names, flags, numFlags);
  93 
  94         List<Flag> result = new ArrayList<Flag>();
  95         for (Flag f : flags) {
  96             if (f != null) {
  97                 result.add(f);
  98             }
  99         }
 100         return result;
 101     }
 102 
 103     private static native String[] getAllFlagNames();
 104     // getFlags sets each element in the given flags array
 105     // with a Flag object only if the name is valid and the
 106     // type is supported. The flags array may contain null elements.
 107     private static native int getFlags(String[] names, Flag[] flags, int count);
 108     private static native int getInternalFlagCount();
 109 
 110     // These set* methods are synchronized on the class object
 111     // to avoid multiple threads updating the same flag at the same time.
 112     static synchronized native void setLongValue(String name, long value);
 113     static synchronized native void setBooleanValue(String name, boolean value);
 114     static synchronized native void setStringValue(String name, String value);
 115 
 116     static {
 117         initialize();
 118     }
 119     private static native void initialize();
 120 }