diagnosticArgument.hpp revision 3465:d2a62e0f25eb 
1/*
2 * Copyright (c) 2012, 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.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25#ifndef SHARE_VM_SERVICES_DIAGNOSTICARGUMENT_HPP
26#define SHARE_VM_SERVICES_DIAGNOSTICARGUMENT_HPP
27
28#include "classfile/vmSymbols.hpp"
29#include "memory/allocation.hpp"
30#include "runtime/os.hpp"
31#include "runtime/thread.hpp"
32#include "utilities/exceptions.hpp"
33
34class StringArrayArgument : public CHeapObj<mtInternal> {
35private:
36  GrowableArray<char*>* _array;
37public:
38  StringArrayArgument() {
39    _array = new(ResourceObj::C_HEAP, mtInternal)GrowableArray<char *>(32, true);
40    assert(_array != NULL, "Sanity check");
41  }
42  void add(const char* str, size_t len) {
43    if (str != NULL) {
44      char* ptr = NEW_C_HEAP_ARRAY(char, len+1, mtInternal);
45      strncpy(ptr, str, len);
46      ptr[len] = 0;
47      _array->append(ptr);
48    }
49  }
50  GrowableArray<char*>* array() {
51    return _array;
52  }
53  ~StringArrayArgument() {
54    for (int i=0; i<_array->length(); i++) {
55      if(_array->at(i) != NULL) { // Safety check
56        FREE_C_HEAP_ARRAY(char, _array->at(i), mtInternal);
57      }
58    }
59    delete _array;
60  }
61};
62
63class NanoTimeArgument {
64public:
65  jlong _nanotime;
66  jlong _time;
67  char _unit[3];
68};
69
70class MemorySizeArgument {
71public:
72  u8 _size;
73  u8 _val;
74  char _multiplier;
75};
76
77class GenDCmdArgument : public ResourceObj {
78protected:
79  GenDCmdArgument* _next;
80  const char*      _name;
81  const char*      _description;
82  const char*      _type;
83  const char*      _default_string;
84  bool             _is_set;
85  bool             _is_mandatory;
86  bool             _allow_multiple;
87  GenDCmdArgument(const char* name, const char* description, const char* type,
88                  const char* default_string, bool mandatory) {
89    _name = name;
90    _description = description;
91    _type = type;
92    _default_string = default_string;
93    _is_mandatory = mandatory;
94    _is_set = false;
95    _allow_multiple = false;
96  };
97public:
98  const char* name() { return _name; }
99  const char* description() { return _description; }
100  const char* type() { return _type; }
101  const char* default_string() { return _default_string; }
102  bool is_set() { return _is_set; }
103  void set_is_set(bool b) { _is_set = b; }
104  bool allow_multiple() { return _allow_multiple; }
105  bool is_mandatory() { return _is_mandatory; }
106  bool has_value() { return _is_set || _default_string != NULL; }
107  bool has_default() { return _default_string != NULL; }
108  void read_value(const char* str, size_t len, TRAPS);
109  virtual void parse_value(const char* str, size_t len, TRAPS) = 0;
110  virtual void init_value(TRAPS) = 0;
111  virtual void reset(TRAPS) = 0;
112  virtual void cleanup() = 0;
113  virtual void value_as_str(char* buf, size_t len) = 0;
114  void set_next(GenDCmdArgument* arg) {
115    _next = arg;
116  }
117  GenDCmdArgument* next() {
118    return _next;
119  }
120
121  void to_string(jlong l, char* buf, size_t len);
122  void to_string(bool b, char* buf, size_t len);
123  void to_string(char* c, char* buf, size_t len);
124  void to_string(NanoTimeArgument n, char* buf, size_t len);
125  void to_string(MemorySizeArgument f, char* buf, size_t len);
126  void to_string(StringArrayArgument* s, char* buf, size_t len);
127};
128
129template <class ArgType> class DCmdArgument: public GenDCmdArgument {
130private:
131  ArgType _value;
132public:
133  DCmdArgument(const char* name, const char* description, const char* type,
134               bool mandatory) :
135               GenDCmdArgument(name, description, type, NULL, mandatory) { }
136  DCmdArgument(const char* name, const char* description, const char* type,
137               bool mandatory, const char* defaultvalue) :
138               GenDCmdArgument(name, description, type, defaultvalue, mandatory)
139               { }
140  ~DCmdArgument() { destroy_value(); }
141  ArgType value() { return _value;}
142  void set_value(ArgType v) { _value = v; }
143  void reset(TRAPS) {
144    destroy_value();
145    init_value(CHECK);
146    _is_set = false;
147  }
148  void cleanup() {
149    destroy_value();
150  }
151  void parse_value(const char* str, size_t len, TRAPS);
152  void init_value(TRAPS);
153  void destroy_value();
154  void value_as_str(char *buf, size_t len) { return to_string(_value, buf, len);}
155};
156
157#endif  /* SHARE_VM_SERVICES_DIAGNOSTICARGUMENT_HPP */
158