TDirectoryEntry.hxx

Go to the documentation of this file.

/// \file ROOT/TDirectoryEntry.h
/// \ingroup Base ROOT7
/// \author Axel Naumann <axel@cern.ch>
/// \date 2015-07-31
/// \warning This is part of the ROOT 7 prototype! It will change without notice. It might trigger earthquakes. Feedback is welcome!

/*************************************************************************
 * Copyright (C) 1995-2015, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/

#ifndef ROOT7_TDirectoryEntry
#define ROOT7_TDirectoryEntry

#include "TClass.h"

#include <chrono>
#include <memory>
#include <typeinfo>

namespace ROOT {
namespace Experimental {

namespace Internal {

class TDirectoryEntry {
public:
  using clock_t = std::chrono::system_clock;
  using time_point_t = std::chrono::time_point<clock_t>;

private:
  time_point_t fDate = clock_t::now(); ///< Time of last change
  TClass* fType;
  std::shared_ptr<void> fObj;

public:
  TDirectoryEntry(): TDirectoryEntry(nullptr) {}
  TDirectoryEntry(std::nullptr_t):
    TDirectoryEntry(std::make_shared<std::nullptr_t>(nullptr)) {}
  template<class T>
  explicit TDirectoryEntry(T* ptr):
    TDirectoryEntry(std::make_shared<T>(*ptr)) {}
  template<class T>
  explicit TDirectoryEntry(const std::shared_ptr<T>& ptr):
    fType(TClass::GetClass(typeid(T))),
    fObj(ptr) {}

  /// Get the last change date of the entry.
  const time_point_t& GetDate() const { return fDate; }

  /// Inform the entry that it has been modified, and needs to update its
  /// last-changed time stamp.
  void SetChanged() { fDate = clock_t::now(); }

  /// Type of the object represented by this entry.
  const std::type_info& GetTypeInfo() const { return *fType->GetTypeInfo(); }

  /// Get the object's type.
  TClass* GetType() const { return fType; }

  /// Retrieve the `shared_ptr` of the referenced object.
  std::shared_ptr<void>& GetPointer() { return fObj; }
  const std::shared_ptr<void>& GetPointer() const { return fObj; }

  template<class U>
  std::shared_ptr<U> CastPointer() const;

  explicit operator bool() const { return !!fObj; }

  void swap(TDirectoryEntry& other) noexcept;
};

template<class U>
std::shared_ptr<U> TDirectoryEntry::CastPointer() const {
  if (auto ptr = fType->DynamicCast(TClass::GetClass(typeid(U)), fObj.get()))
    return std::shared_ptr<U>(fObj, static_cast<U*>(ptr));
  return std::shared_ptr<U>();
}

inline void TDirectoryEntry::swap(TDirectoryEntry& other) noexcept {
  using std::swap;

  swap(fDate, other.fDate);
  swap(fType, other.fType);
  swap(fObj, other.fObj);
}

inline void swap(TDirectoryEntry& e1, TDirectoryEntry& e2) noexcept {
  e1.swap(e2);
}

} // namespace Internal

} // namespace Experimental
} // namespace ROOT
#endif