src/share/vm/trace/traceEvent.hpp

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

*** 60,70 ****
  
    void set_endtime(const TracingTime& time) {
      _endTime = time;
    }
  
-  public:
    TraceEvent(EventStartTime timing=TIMED) :
      _startTime(0),
      _endTime(0),
      _started(false)
  #ifdef ASSERT
--- 60,69 ----
*** 75,157 ****
  #endif
    {
      if (T::is_enabled()) {
        _started = true;
        if (timing == TIMED && !T::isInstant) {
!         static_cast<T *>(this)->set_starttime(Tracing::time());
        }
      }
    }
  
    static bool is_enabled() {
      return Tracing::is_event_enabled(T::eventId);
    }
  
!   bool should_commit() {
!     return _started;
    }
  
!   void ignoreCheck() {
!     DEBUG_ONLY(_ignore_check = true);
    }
  
    void commit() {
      if (!should_commit()) {
!         cancel();
          return;
      }
      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();
    }
  
!   TraceEventId id() const {
!     return T::eventId;
    }
  
!   bool is_instant() const {
      return T::isInstant;
    }
  
!   bool is_requestable() const {
      return T::isRequestable;
    }
  
!   bool has_thread() const {
      return T::hasThread;
    }
  
!   bool has_stacktrace() const {
      return T::hasStackTrace;
    }
  
!   void cancel() {
!     assert(!_committed && !_cancelled, "event was already committed/cancelled");
!     DEBUG_ONLY(_cancelled = true);
    }
  
    void set_commited() {
      assert(!_committed, "event has already been committed");
!     DEBUG_ONLY(_committed = true);
    }
  
!   ~TraceEvent() {
!     if (_started) {
!       assert(_ignore_check || _committed || _cancelled, "event was not committed/cancelled");
!     }
!   }
  };
  
  #endif // INCLUDE_TRACE
  #endif // SHARE_VM_TRACE_TRACEEVENT_HPP
--- 74,160 ----
  #endif
    {
      if (T::is_enabled()) {
        _started = true;
        if (timing == TIMED && !T::isInstant) {
!         static_cast<T*>(this)->set_starttime(Tracing::time());
        }
      }
    }
  
+  public:
    static bool is_enabled() {
      return Tracing::is_event_enabled(T::eventId);
    }
  
!   void set_starttime(const Ticks& time) {
!     _startTime = time.value();
    }
  
!   void set_endtime(const Ticks& time) {
!     _endTime = time.value();
!   }
! 
!   bool should_commit() {
!     return _started;
    }
  
    void commit() {
      if (!should_commit()) {
!       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();
      }
!     DEBUG_ONLY(set_commited());
    }
  
!   void cancel() {
!     assert(!_committed && !_cancelled, "event was already committed/cancelled");
!     DEBUG_ONLY(_cancelled = true);
    }
  
!   static bool is_instant() {
      return T::isInstant;
    }
  
!   static bool is_requestable() {
      return T::isRequestable;
    }
  
!   static bool has_thread() {
      return T::hasThread;
    }
  
!   static bool has_stacktrace() {
      return T::hasStackTrace;
    }
  
!   ~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");
!     _committed = true;
    }
  
! #endif // ASSERT
  };
  
  #endif // INCLUDE_TRACE
  #endif // SHARE_VM_TRACE_TRACEEVENT_HPP