FWItemAccessorFactory.cc

Go to the documentation of this file.

// -*- C++ -*-
//
// Package:     Core
// Class  :     FWItemAccessorFactory
//
// Implementation:
//     <Notes on implementation>
//
// Original Author:  Chris Jones
//         Created:  Sat Oct 18 14:48:14 EDT 2008
//

// system include files
#include <iostream>
#include "TClass.h"
#include "TVirtualCollectionProxy.h"
#include "FWCore/Utilities/interface/TypeWithDict.h"
#include "FWCore/Utilities/interface/MemberWithDict.h"

// user include files
#include "Fireworks/Core/interface/FWItemAccessorFactory.h"
#include "Fireworks/Core/interface/FWItemAccessorRegistry.h"
#include "Fireworks/Core/src/FWItemTVirtualCollectionProxyAccessor.h"
#include "Fireworks/Core/src/FWItemSingleAccessor.h"
#include "Fireworks/Core/interface/fwLog.h"

//
// constants, enums and typedefs
//

//
// static data member definitions
//

//
// constructors and destructor
//
FWItemAccessorFactory::FWItemAccessorFactory()
{
}

// FWItemAccessorFactory::FWItemAccessorFactory(const FWItemAccessorFactory& rhs)
// {
//    // do actual copying here;
// }

FWItemAccessorFactory::~FWItemAccessorFactory()
{
}

//
// assignment operators
//
// const FWItemAccessorFactory& FWItemAccessorFactory::operator=(const FWItemAccessorFactory& rhs)
// {
//   //An exception safe implementation is
//   FWItemAccessorFactory temp(rhs);
//   swap(rhs);
//
//   return *this;
// }

//
// member functions
//

//
// const member functions
//

std::shared_ptr<FWItemAccessorBase>
FWItemAccessorFactory::accessorFor(const TClass* iClass) const
{
   static const bool debug = false;

   TClass *member = nullptr;
   size_t offset=0;

   if(hasTVirtualCollectionProxy(iClass)) 
   {
      if (debug)
         fwLog(fwlog::kDebug) << "class " << iClass->GetName()
                              << " uses FWItemTVirtualCollectionProxyAccessor." << std::endl;
      return std::make_shared<FWItemTVirtualCollectionProxyAccessor>(iClass,
            std::shared_ptr<TVirtualCollectionProxy>(iClass->GetCollectionProxy()->Generate()));
   } 
   
   // Iterate on the available plugins and use the one which handles 
   // the iClass type. 
   // NOTE: This is done only a few times, not really performance critical.
   // If you want this to be fast, the loop can be moved in the 
   // constructor. Notice that this will require constructing FWEventItemsManager 
   // after the plugin manager (i.e. invoking FWLiteEnabler::enable()) is configured
   // (i.e. invoking FWLiteEnabler::enable()) in CmsShowMain.
   std::string accessorName;
   if (hasAccessor(iClass, accessorName))
   {
      if (debug)
         fwLog(fwlog::kDebug) << "class " << iClass->GetName() << " uses " 
                              << accessorName << "." << std::endl;
      return std::shared_ptr<FWItemAccessorBase>(FWItemAccessorRegistry::get()->create(accessorName, iClass));
   }
   
   if (hasMemberTVirtualCollectionProxy(iClass, member,offset)) 
   {
      if (debug)
         fwLog(fwlog::kDebug) << "class "<< iClass->GetName()
                              << " only contains data member " << member->GetName()
                              << " which uses FWItemTVirtualCollectionProxyAccessor."
                              << std::endl;
       
      return std::make_shared<FWItemTVirtualCollectionProxyAccessor>(iClass,
            std::shared_ptr<TVirtualCollectionProxy>(member->GetCollectionProxy()->Generate()),
                                                   offset);
   }

   return std::make_shared<FWItemSingleAccessor>(iClass);
}

bool
FWItemAccessorFactory::hasTVirtualCollectionProxy(const TClass *iClass)
{
   // Check if this is a collection known by ROOT but also that the item held by
   // the colletion actually has a dictionary  
   return iClass &&
          iClass->GetCollectionProxy() && 
          iClass->GetCollectionProxy()->GetValueClass() &&
          iClass->GetCollectionProxy()->GetValueClass()->IsLoaded();
}

bool
FWItemAccessorFactory::hasMemberTVirtualCollectionProxy(const TClass *iClass,
                                                        TClass *&oMember,
                                                        size_t& oOffset)
{
   assert(iClass->GetTypeInfo());
   edm::TypeWithDict dataType(*(iClass->GetTypeInfo()));
   assert(bool(dataType));

   // If the object has more than one data member, we avoid guessing. 
   edm::TypeDataMembers members(dataType);
   if (members.size() != 1)
      return false;
   
   edm::MemberWithDict member(*members.begin());
   edm::TypeWithDict memType(member.typeOf());
   assert(bool(memType));
   oMember = TClass::GetClass(memType.typeInfo());
   oOffset = member.offset();
   
   // Check if this is a collection known by ROOT but also that the item held by
   // the colletion actually has a dictionary  
            
   if (!hasTVirtualCollectionProxy(oMember))
      return false;

   return true;
}

bool
FWItemAccessorFactory::hasAccessor(const TClass *iClass, std::string &result)
{
   const std::vector<edmplugin::PluginInfo> &available
      = edmplugin::PluginManager::get()->categoryToInfos().find("cmsShow FWItemAccessorBase")->second;
   
   for (size_t i = 0, e = available.size(); i != e; ++i)
   {
      std::string name = available[i].name_;
      std::string type = name.substr(0, name.find_first_of('@'));
      if (iClass->GetTypeInfo()->name() == type)
      {
         result.swap(name);
         return true;
      }
   }
   return false;
}

bool FWItemAccessorFactory::classAccessedAsCollection(const TClass* iClass)
{
   std::string accessorName;
   TClass *member = nullptr;
   size_t offset=0;
   
   // This is pretty much the same thing that happens 
   return (FWItemAccessorFactory::hasTVirtualCollectionProxy(iClass) 
           || FWItemAccessorFactory::hasMemberTVirtualCollectionProxy(iClass, member,offset)
           || FWItemAccessorFactory::hasAccessor(iClass, accessorName));
}

//
// static member functions
//