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
// $Id: FWItemAccessorFactory.cc,v 1.12 2012/06/26 22:13:04 wmtan Exp $
//

// system include files
#include <iostream>
#include "TClass.h"
#include "TVirtualCollectionProxy.h"
#include "Reflex/Type.h"
#include "Reflex/Member.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
//

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

   TClass *member = 0;
   size_t offset=0;

   if(hasTVirtualCollectionProxy(iClass)) 
   {
      if (debug)
         fwLog(fwlog::kDebug) << "class " << iClass->GetName()
                              << " uses FWItemTVirtualCollectionProxyAccessor." << std::endl;
      return boost::shared_ptr<FWItemAccessorBase>(
         new FWItemTVirtualCollectionProxyAccessor(iClass,
            boost::shared_ptr<TVirtualCollectionProxy>(iClass->GetCollectionProxy()->Generate())));
   } 
   else 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 boost::shared_ptr<FWItemAccessorBase>(
         new FWItemTVirtualCollectionProxyAccessor(iClass,
            boost::shared_ptr<TVirtualCollectionProxy>(member->GetCollectionProxy()->Generate()),
                                                   offset));
   }
   
   // 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 AutoLibraryLoader::enable()) is configured
   // (i.e. invoking AutoLibraryLoader::enable()) in CmsShowMain.
   std::string accessorName;
   if (hasAccessor(iClass, accessorName))
   {
      if (debug)
         fwLog(fwlog::kDebug) << "class " << iClass->GetName() << " uses " 
                              << accessorName << "." << std::endl;
      return boost::shared_ptr<FWItemAccessorBase>(FWItemAccessorRegistry::get()->create(accessorName, iClass));
   }
   
   return boost::shared_ptr<FWItemAccessorBase>(new 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());
   Reflex::Type dataType(Reflex::Type::ByTypeInfo(*(iClass->GetTypeInfo())));
   assert(dataType != Reflex::Type());

   // If the object has more than one data member, we avoid guessing. 
   if (dataType.DataMemberSize() != 1)
      return false;
   
   Reflex::Type memType(dataType.DataMemberAt(0).TypeOf());
   assert(memType != Reflex::Type());
   //make sure this is the real type and not a typedef
   memType = memType.FinalType();
   oMember = TClass::GetClass(memType.TypeInfo());
   oOffset = dataType.DataMemberAt(0).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 
      = FWItemAccessorRegistry::get()->available();
   
   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 = 0;
   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
//