src/share/vm/trace/traceEvent.hpp

rev 7560 : 8066814: Reduce accessibility in TraceEvent
Reviewed-by:

@@ -60,11 +60,10 @@
 
   void set_endtime(const TracingTime& time) {
     _endTime = time;
   }
 
- public:
   TraceEvent(EventStartTime timing=TIMED) :
     _startTime(0),
     _endTime(0),
     _started(false)
 #ifdef ASSERT

@@ -75,83 +74,87 @@
 #endif
   {
     if (T::is_enabled()) {
       _started = true;
       if (timing == TIMED && !T::isInstant) {
-        static_cast<T *>(this)->set_starttime(Tracing::time());
+        static_cast<T*>(this)->set_starttime(Tracing::time());
       }
     }
   }
 
+ public:
   static bool is_enabled() {
     return Tracing::is_event_enabled(T::eventId);
   }
 
-  bool should_commit() {
-    return _started;
+  void set_starttime(const Ticks& time) {
+    _startTime = time.value();
   }
 
-  void ignoreCheck() {
-    DEBUG_ONLY(_ignore_check = true);
+  void set_endtime(const Ticks& time) {
+    _endTime = time.value();
+  }
+
+  bool should_commit() {
+    return _started;
   }
 
   void commit() {
     if (!should_commit()) {
-        cancel();
+      DEBUG_ONLY(cancel());
         return;
     }
+    assert(!_cancelled, "Committing an event that has already been cancelled");
     if (_endTime == 0) {
       static_cast<T*>(this)->set_endtime(Tracing::time());
     }
     if (static_cast<T*>(this)->should_write()) {
       static_cast<T*>(this)->writeEvent();
     }
-    set_commited();
-  }
-
-  void set_starttime(const Ticks& time) {
-    _startTime = time.value();
-  }
-
-  void set_endtime(const Ticks& time) {
-    _endTime = time.value();
+    DEBUG_ONLY(set_commited());
   }
 
-  TraceEventId id() const {
-    return T::eventId;
+  void cancel() {
+    assert(!_committed && !_cancelled, "event was already committed/cancelled");
+    DEBUG_ONLY(_cancelled = true);
   }
 
-  bool is_instant() const {
+  static bool is_instant() {
     return T::isInstant;
   }
 
-  bool is_requestable() const {
+  static bool is_requestable() {
     return T::isRequestable;
   }
 
-  bool has_thread() const {
+  static bool has_thread() {
     return T::hasThread;
   }
 
-  bool has_stacktrace() const {
+  static bool has_stacktrace() {
     return T::hasStackTrace;
   }
 
-  void cancel() {
-    assert(!_committed && !_cancelled, "event was already committed/cancelled");
-    DEBUG_ONLY(_cancelled = true);
+  ~TraceEvent() {
+    if (_started) {
+      assert(_ignore_check || _committed || _cancelled, "event was not committed/cancelled");
+    }
   }
 
+#ifdef ASSERT
+
+ protected:
+  void ignoreCheck() {
+    _ignore_check = true;
+  }
+
+ private:
   void set_commited() {
     assert(!_committed, "event has already been committed");
-    DEBUG_ONLY(_committed = true);
+    _committed = true;
   }
 
-  ~TraceEvent() {
-    if (_started) {
-      assert(_ignore_check || _committed || _cancelled, "event was not committed/cancelled");
-    }
-  }
+#endif // ASSERT
 };
 
 #endif // INCLUDE_TRACE
 #endif // SHARE_VM_TRACE_TRACEEVENT_HPP