RProvider.cxx

Go to the documentation of this file.

/*************************************************************************
 * Copyright (C) 1995-2020, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
 
#include <ROOT/Browsable/RProvider.hxx>
 
#include <ROOT/RLogger.hxx>
 
#include "TBaseClass.h"
#include "TList.h"
#include "TClass.h"
#include "TSystem.h"
 
using namespace ROOT::Browsable;
using namespace std::string_literals;
 
RProvider::BrowseNTupleFunc_t RProvider::gNTupleFunc = nullptr;
 
//////////////////////////////////////////////////////////////////////////////////
// Provide map of browsing for different classes
 
RProvider::BrowseMap_t &RProvider::GetBrowseMap()
{
   static RProvider::BrowseMap_t sMap;
   return sMap;
}
 
//////////////////////////////////////////////////////////////////////////////////
// Provide map of files opening
 
RProvider::FileMap_t &RProvider::GetFileMap()
{
   static RProvider::FileMap_t sMap;
   return sMap;
}
 
//////////////////////////////////////////////////////////////////////////////////
// Returns map of registered drawing functions for v6 canvas
 
RProvider::Draw6Map_t &RProvider::GetDraw6Map()
{
   static RProvider::Draw6Map_t sMap;
   return sMap;
}
 
//////////////////////////////////////////////////////////////////////////////////
// Returns map of registered drawing functions for v7 canvas
 
RProvider::Draw7Map_t &RProvider::GetDraw7Map()
{
   static RProvider::Draw7Map_t sMap;
   return sMap;
}
 
//////////////////////////////////////////////////////////////////////////////////
// Returns map of registered icons base on class pointer
 
RProvider::ClassMap_t &RProvider::GetClassMap()
{
   static RProvider::ClassMap_t sMap;
   return sMap;
}
 
//////////////////////////////////////////////////////////////////////////////////
// Returns vector of registered progress functions
 
RProvider::ProgressVect_t &RProvider::GetProgressVect()
{
   static RProvider::ProgressVect_t sVect;
   return sVect;
}
 
 
//////////////////////////////////////////////////////////////////////////////////
// Destructor
/// Automatically unregister provider from all maps
 
RProvider::~RProvider()
{
   // here to remove all correspondent entries
   CleanThis(GetClassMap());
   CleanThis(GetFileMap());
   CleanThis(GetBrowseMap());
   CleanThis(GetDraw6Map());
   CleanThis(GetDraw7Map());
}
 
//////////////////////////////////////////////////////////////////////////////////
// Register file open function for specified extension
 
void RProvider::RegisterFile(const std::string &extension, FileFunc_t func)
{
    auto &fmap = GetFileMap();
 
    if ((extension != "*") && (fmap.find(extension) != fmap.end()))
       R__LOG_ERROR(BrowsableLog()) << "Provider for file extension  " << extension << " already exists";
 
    fmap.emplace(extension, StructFile{this,func});
}
 
//////////////////////////////////////////////////////////////////////////////////
// Register browse function for specified class
 
void RProvider::RegisterBrowse(const TClass *cl, BrowseFunc_t func)
{
    auto &bmap = GetBrowseMap();
 
    if (cl && (bmap.find(cl) != bmap.end()))
       R__LOG_ERROR(BrowsableLog()) << "Browse provider for class " << cl->GetName() << " already exists";
 
    bmap.emplace(cl, StructBrowse{this,func});
}
 
//////////////////////////////////////////////////////////////////////////////////
// Register drawing function for v6 canvas
 
void RProvider::RegisterDraw6(const TClass *cl, Draw6Func_t func)
{
    auto &bmap = GetDraw6Map();
 
    if (cl && (bmap.find(cl) != bmap.end()))
       R__LOG_ERROR(BrowsableLog()) << "Draw v6 handler for class " << cl->GetName() << " already exists";
 
    bmap.emplace(cl, StructDraw6{this, func});
}
 
//////////////////////////////////////////////////////////////////////////////////
// Register drawing function for v7 canvas
 
void RProvider::RegisterDraw7(const TClass *cl, Draw7Func_t func)
{
    auto &bmap = GetDraw7Map();
 
    if (cl && (bmap.find(cl) != bmap.end()))
       R__LOG_ERROR(BrowsableLog()) << "Draw v7 handler for class " << cl->GetName() << " already exists";
 
    bmap.emplace(cl, StructDraw7{this, func});
}
 
//////////////////////////////////////////////////////////////////////////////////
// Register function for browsing RNTuple
 
void RProvider::RegisterNTupleFunc(BrowseNTupleFunc_t func)
{
   gNTupleFunc = func;
}
 
//////////////////////////////////////////////////////////////////////////////////
// Register class with supported libs (if any)
 
void RProvider::RegisterClass(const std::string &clname, const std::string &iconname,
                              const std::string &browselib, const std::string &draw6lib,
                              const std::string &draw7lib, const std::string &drawopt)
{
   auto &bmap = GetClassMap();
 
   if (!clname.empty() && (bmap.find(clname) != bmap.end()))
      R__LOG_ERROR(BrowsableLog()) << "Entry for class " << clname << " already exists";
 
   std::string blib = browselib;
   bool can_have_childs = !browselib.empty();
   if ((blib == "dflt") || (blib == "TObject")) blib = ""; // just use as indicator that browsing is possible
 
   bmap.emplace(clname, StructClass{this, can_have_childs, iconname, blib, draw6lib, draw7lib, drawopt});
}
 
//////////////////////////////////////////////////////////////////////////////////
// Returns entry for the requested class
RProvider::StructClass &RProvider::GetClassEntry(const ClassArg &cl)
{
   if (!cl.empty()) {
      auto &bmap = GetClassMap();
      auto iter = bmap.find(cl.cl ? cl.cl->GetName() : cl.name.c_str());
      if (iter != bmap.end())
         return iter->second;
 
      if (!cl.name.empty()) {
         for (auto &elem : bmap)
            if (cl.name.compare(0, elem.first.length(), elem.first) == 0)
               return elem.second;
      } else if (cl.cl) {
         auto bases = const_cast<TClass *>(cl.cl)->GetListOfBases();
         const TClass *basecl = bases && (bases->GetSize() > 0) ? dynamic_cast<TBaseClass *>(bases->First())->GetClassPointer() : nullptr;
         if (basecl) return RProvider::GetClassEntry(basecl);
      }
   }
 
   static StructClass dummy;
   return dummy;
}
 
//////////////////////////////////////////////////////////////////////////////////
// Returns true if file extension is supported
 
bool RProvider::IsFileFormatSupported(const std::string &extension)
{
   if (extension.empty())
      return false;
 
   auto &fmap = GetFileMap();
 
   return fmap.find(extension) != fmap.end();
}
 
//////////////////////////////////////////////////////////////////////////////////
// Try to open file using provided extension.
 
std::shared_ptr<RElement> RProvider::OpenFile(const std::string &extension, const std::string &fullname)
{
   auto &fmap = GetFileMap();
 
   auto iter = fmap.find(extension);
 
   if (iter != fmap.end())
      return iter->second.func(fullname);
 
   return nullptr;
}
 
//////////////////////////////////////////////////////////////////////////////////
// Template function to scan class entries, including parent object classes
 
template<class Map_t, class Func_t>
bool ScanProviderMap(Map_t &fmap, const RProvider::ClassArg &cl, bool test_all = false, std::function<bool(Func_t &)> check_func = nullptr)
{
   if (cl.empty())
      return false;
 
   if (cl.GetClass()) {
      TClass *testcl = const_cast<TClass *>(cl.GetClass());
      while (testcl) {
         auto iter = fmap.find(testcl);
         if (iter != fmap.end())
            if (!check_func || check_func(iter->second.func))
               return true;
 
         auto bases = testcl->GetListOfBases();
 
         testcl = bases && (bases->GetSize() > 0) ? dynamic_cast<TBaseClass *>(bases->First())->GetClassPointer() : nullptr;
      }
   } else {
      for (auto &entry : fmap) {
         if (!entry.first) continue;
         std::string name = entry.first->GetName();
         if (!check_func) {
            // when check_func not specified, just try to guess if class can match
            if ((cl.GetName() == name) || (cl.GetName().compare(0, name.length(), name) == 0))
               return true;
         } else if (cl.GetName() == name) {
            if (check_func(entry.second.func))
               return true;
         }
      }
   }
 
   if (test_all && check_func) {
      for (auto &entry : fmap)
         if (!entry.first && check_func(entry.second.func))
            return true;
   }
 
   return false;
}
 
/////////////////////////////////////////////////////////////////////////
/// Create browsable element for the object
/// Created element may take ownership over the object
 
std::shared_ptr<RElement> RProvider::Browse(std::unique_ptr<RHolder> &object)
{
   std::shared_ptr<RElement> res;
 
   if (!object) return res;
 
   auto browse_func = [&res, &object] (BrowseFunc_t &func) -> bool {
      res = func(object);
      return (res || !object) ? true : false;
   };
 
   // check only class entries
   if (ScanProviderMap<BrowseMap_t,BrowseFunc_t>(GetBrowseMap(), object->GetClass(), false, browse_func))
      return res;
 
   auto &entry = GetClassEntry(object->GetClass());
   if (!entry.dummy() && !entry.browselib.empty())
      gSystem->Load(entry.browselib.c_str());
 
   // let call also generic browse functions (multicast)
   ScanProviderMap<BrowseMap_t,BrowseFunc_t>(GetBrowseMap(), object->GetClass(), true, browse_func);
 
   return res;
}
 
/////////////////////////////////////////////////////////////////////////////////
/// Start browsing of RNTuple
 
std::shared_ptr<RElement> RProvider::BrowseNTuple(const std::string &tuplename, const std::string &filename)
{
   if (!gNTupleFunc) {
      auto &entry = GetClassEntry("ROOT::RNTuple");
 
      if (entry.browselib.empty())
         return nullptr;
 
      gSystem->Load(entry.browselib.c_str());
   }
 
   if (!gNTupleFunc)
      return nullptr;
 
   return gNTupleFunc(tuplename, filename);
}
 
/////////////////////////////////////////////////////////////////////////////////
/// Invoke drawing of object on TCanvas sub-pad
/// All existing providers are checked, first checked are class matches (including direct parents)
 
bool RProvider::Draw6(TVirtualPad *subpad, std::unique_ptr<RHolder> &object, const std::string &opt)
{
   if (!object || !object->GetClass())
      return false;
 
   auto draw_func = [subpad, &object, &opt](Draw6Func_t &func) -> bool {
      return func(subpad, object, opt);
   };
 
   if (ScanProviderMap<Draw6Map_t,Draw6Func_t>(GetDraw6Map(), object->GetClass(), false, draw_func))
      return true;
 
   auto &entry = GetClassEntry(object->GetClass());
   if (!entry.dummy() && !entry.draw6lib.empty())
      gSystem->Load(entry.draw6lib.c_str());
 
   return ScanProviderMap<Draw6Map_t,Draw6Func_t>(GetDraw6Map(), object->GetClass(), true, draw_func);
}
 
/////////////////////////////////////////////////////////////////////////////////
/// Invoke drawing of object on RCanvas sub-pad
/// All existing providers are checked, first checked are class matches (including direct parents)
 
bool RProvider::Draw7(std::shared_ptr<ROOT::Experimental::RPadBase> &subpad, std::unique_ptr<RHolder> &object, const std::string &opt)
{
   if (!object || !object->GetClass())
      return false;
 
   auto draw_func = [&subpad, &object, &opt](Draw7Func_t &func) -> bool {
      return func(subpad, object, opt);
   };
 
   if (ScanProviderMap<Draw7Map_t,Draw7Func_t>(GetDraw7Map(), object->GetClass(), false, draw_func))
      return true;
 
   auto &entry = GetClassEntry(object->GetClass());
   if (!entry.dummy() && !entry.draw7lib.empty())
      gSystem->Load(entry.draw7lib.c_str());
 
   return ScanProviderMap<Draw7Map_t,Draw7Func_t>(GetDraw7Map(), object->GetClass(), true, draw_func);
}
 
/////////////////////////////////////////////////////////////////////
/// Return icon name for the given class - either class name or TClass *
 
std::string RProvider::GetClassIcon(const ClassArg &arg, bool is_folder)
{
   auto &entry = GetClassEntry(arg);
   if (!entry.iconname.empty())
      return entry.iconname;
 
   return is_folder ? "sap-icon://folder-blank"s : "sap-icon://electronic-medical-record"s;
}
 
/////////////////////////////////////////////////////////////////////
/// Return configured draw option for the class
 
std::string RProvider::GetClassDrawOption(const ClassArg &arg)
{
   return GetClassEntry(arg).drawopt;
}
 
/////////////////////////////////////////////////////////////////////
/// Set draw option for the class
/// Return true if entry for the class exists
 
bool RProvider::SetClassDrawOption(const ClassArg &arg, const std::string &opt)
{
   auto &entry = GetClassEntry(arg);
   if (entry.dummy())
      return false;
 
   entry.drawopt = opt;
   return true;
}
 
/////////////////////////////////////////////////////////////////////
/// Return true if provided class can have childs
 
bool RProvider::CanHaveChilds(const ClassArg &arg)
{
   return GetClassEntry(arg).can_have_childs;
}
 
/////////////////////////////////////////////////////////////////////
/// Check if showing of sub-elements was disabled
 
bool RProvider::NotShowChilds(const ClassArg &arg)
{
   auto &entry = GetClassEntry(arg);
   return !entry.dummy() && !entry.can_have_childs;
}
 
/////////////////////////////////////////////////////////////////////
/// Return true if provided class can be drawn on the TCanvas
 
bool RProvider::CanDraw6(const ClassArg &arg)
{
   if (ScanProviderMap<Draw6Map_t,Draw6Func_t>(GetDraw6Map(), arg))
      return true;
 
   if (!GetClassEntry(arg).draw6lib.empty())
      return true;
 
   return false;
}
 
/////////////////////////////////////////////////////////////////////
/// Return true if provided class can be drawn on the RCanvas
 
bool RProvider::CanDraw7(const ClassArg &arg)
{
   if (ScanProviderMap<Draw7Map_t,Draw7Func_t>(GetDraw7Map(), arg))
      return true;
 
   if (!GetClassEntry(arg).draw7lib.empty())
      return true;
 
   return false;
}
 
/////////////////////////////////////////////////////////////////////
/// Create progress handle
 
RProvider::ProgressHandle::ProgressHandle(void *handle, RProvider::ProgressFunc_t func)
{
   fHandle = handle;
   RProvider::GetProgressVect().emplace_back(StructProgress{handle, nullptr, func});
}
 
/////////////////////////////////////////////////////////////////////
/// Destroy progress handle
 
RProvider::ProgressHandle::~ProgressHandle()
{
   auto &vect = RProvider::GetProgressVect();
   auto iter = vect.begin();
   while (iter != vect.end()) {
      if (iter->handle == fHandle) {
         vect.erase(iter);
      } else {
         iter++;
      }
   }
}
 
/////////////////////////////////////////////////////////////////////
/// Extend progress handle
 
void RProvider::ProgressHandle::Extend(void *handle2)
{
   RProvider::ExtendProgressHandle(fHandle, handle2);
}
 
/////////////////////////////////////////////////////////////////////
/// Extend progress handle - to be able react on sub item
 
void RProvider::ExtendProgressHandle(void *handle, void *handle2)
{
   for (auto &elem : GetProgressVect())
      if (elem.handle == handle)
         elem.handle2 = handle2;
}
 
/////////////////////////////////////////////////////////////////////
/// Report running progress
/// Returns true if handling function was invoked
/// Method can be used to detect if there any progress handler assigned
 
 
bool RProvider::ReportProgress(void *handle, float progress)
{
   bool is_any = false;
   for (auto &elem : GetProgressVect())
      if ((elem.handle == handle) || (elem.handle2 == handle)) {
         elem.func(progress, elem.handle);
         is_any = true;
      }
 
   return is_any;
}
 
// ==============================================================================================
 
class RDefaultProvider : public RProvider {
 
public:
   RDefaultProvider()
   {
      // TODO: let read from rootrc or any other files
      RegisterClass("ROOT::Experimental::RH1D", "sap-icon://bar-chart", "", "", "libROOTHistDrawProvider");
      RegisterClass("ROOT::Experimental::RH2D", "sap-icon://pixelate", "", "", "libROOTHistDrawProvider");
      RegisterClass("ROOT::Experimental::RH3D", "sap-icon://product", "", "", "libROOTHistDrawProvider");
      RegisterClass("ROOT::Experimental::RCanvas", "sap-icon://business-objects-experience", "", "", "libROOTHistDrawProvider");
      RegisterClass("ROOT::RNTuple", "sap-icon://table-chart", "libROOTNTupleBrowseProvider",
                    "libROOTNTupleDraw6Provider", "libROOTNTupleDraw7Provider");
   }
 
} newRDefaultProvider;