Merge pull request #46204 from wddgit/esProductResolverRenaming

More of the DataProxy to ESProductResolver renaming

Author: cmsbuild

FWCore/Concurrency/scripts/edmStreamStallGrapher.py

@@ -603,7 +603,7 @@ def plotPerStreamAboveFirstAndPrepareStack(points, allStackTimes, ax, stream, he
             allStackTimes[color].extend(theTS*(nthreads-threadOffset))
 
 #----------------------------------------------
-# The same ES module can have multiple Proxies running concurrently
+# The same ES module can have multiple Resolvers running concurrently
 #   so we need to reference count the names of the active modules
 class RefCountSet(set):
   def __init__(self):

FWCore/Framework/interface/CallbackBase.h

@@ -68,7 +68,7 @@ namespace edm {
     class CallbackBase {
     public:
       CallbackBase(T* iProd, std::shared_ptr<TProduceFunc> iProduceFunc, unsigned int iID, const TDecorator& iDec)
-          : proxyData_{},
+          : resolverData_{},
             producer_(iProd),
             callingContext_(&iProd->description(), iID),
             produceFunction_(std::move(iProduceFunc)),
@@ -127,13 +127,13 @@ namespace edm {
                     try {
                       convertException::wrap([this, &serviceToken, &record, &eventSetupImpl, &produceFunctor] {
                         ESModuleCallingContext const& context = callingContext_;
-                        auto proxies = getTokenIndices();
+                        auto resolvers = getTokenIndices();
                         if (postMayGetResolvers_) {
-                          proxies = &((*postMayGetResolvers_).front());
+                          resolvers = &((*postMayGetResolvers_).front());
                         }
                         TRecord rec;
                         ESParentContext pc{&context};
-                        rec.setImpl(record, transitionID(), proxies, eventSetupImpl, &pc);
+                        rec.setImpl(record, transitionID(), resolvers, eventSetupImpl, &pc);
                         ServiceRegistry::Operate operate(serviceToken.lock());
                         record->activityRegistry()->preESModuleSignal_.emit(record->key(), context);
                         struct EndGuard {
@@ -202,12 +202,12 @@ namespace edm {
 
       template <class DataT>
       void holdOntoPointer(DataT* iData) {
-        proxyData_[produce::find_index<TReturn, DataT>::value] = iData;
+        resolverData_[produce::find_index<TReturn, DataT>::value] = iData;
       }
 
       template <class RemainingContainerT, class DataT, class ProductsT>
       void setData(ProductsT& iProducts) {
-        DataT* temp = reinterpret_cast<DataT*>(proxyData_[produce::find_index<TReturn, DataT>::value]);
+        DataT* temp = reinterpret_cast<DataT*>(resolverData_[produce::find_index<TReturn, DataT>::value]);
         if (nullptr != temp) {
           moveFromTo(iProducts, *temp);
         }
@@ -243,14 +243,14 @@ namespace edm {
 
       void prefetchNeededDataAsync(WaitingTaskHolder task,
                                    EventSetupImpl const* iImpl,
-                                   ESResolverIndex const* proxies,
+                                   ESResolverIndex const* resolvers,
                                    ServiceToken const& token) const noexcept {
         auto recs = producer_->getTokenRecordIndices(id_);
         auto n = producer_->numberOfTokenIndices(id_);
         for (size_t i = 0; i != n; ++i) {
           auto rec = iImpl->findImpl(recs[i]);
           if (rec) {
-            rec->prefetchAsync(task, proxies[i], iImpl, token, ESParentContext{&callingContext_});
+            rec->prefetchAsync(task, resolvers[i], iImpl, token, ESParentContext{&callingContext_});
           }
         }
       }
@@ -264,7 +264,7 @@ namespace edm {
         return static_cast<bool>(postMayGetResolvers_);
       }
 
-      std::array<void*, produce::size<TReturn>::value> proxyData_;
+      std::array<void*, produce::size<TReturn>::value> resolverData_;
       std::optional<std::vector<ESResolverIndex>> postMayGetResolvers_;
       propagate_const<T*> producer_;
       ESModuleCallingContext callingContext_;

FWCore/Framework/interface/CallbackExternalWork.h

@@ -172,13 +172,13 @@ namespace edm {
                         try {
                           convertException::wrap([this, &holder, &serviceToken, &record, &eventSetupImpl] {
                             ESModuleCallingContext const& context = Base::callingContext();
-                            auto proxies = Base::getTokenIndices();
+                            auto resolvers = Base::getTokenIndices();
                             if (Base::postMayGetResolvers()) {
-                              proxies = &((*Base::postMayGetResolvers()).front());
+                              resolvers = &((*Base::postMayGetResolvers()).front());
                             }
                             TRecord rec;
                             edm::ESParentContext pc{&context};
-                            rec.setImpl(record, Base::transitionID(), proxies, eventSetupImpl, &pc);
+                            rec.setImpl(record, Base::transitionID(), resolvers, eventSetupImpl, &pc);
                             ServiceRegistry::Operate operate(serviceToken.lock());
                             record->activityRegistry()->preESModuleAcquireSignal_.emit(record->key(), context);
                             struct EndGuard {

FWCore/Framework/interface/ESProducer.h

@@ -16,11 +16,11 @@
   set at run-time instead of compile time can be obtained by inheriting from ESProductResolverFactoryProducer instead.)
 
     If only one algorithm is being encapsulated then the user needs to
-      1) add a method name 'produce' to the class.  The 'produce' takes as its argument a const reference
+      1) add a method named 'produce' to the class.  The 'produce' takes as its argument a const reference
          to the record that is to hold the data item being produced.  If only one data item is being produced,
          the 'produce' method must return either an 'std::unique_ptr' or 'std::shared_ptr' to the object being
          produced.  (The choice depends on if the EventSetup or the ESProducer is managing the lifetime of
-         the object).  If multiple items are being Produced they the 'produce' method must return an
+         the object).  If multiple items are being Produced then the 'produce' method must return an
          ESProducts<> object which holds all of the items.
       2) add 'setWhatProduced(this);' to their classes constructor
 

FWCore/Framework/interface/ESProductResolver.h

@@ -1,13 +1,13 @@
+// -*- C++ -*-
 #ifndef FWCore_Framework_ESProductResolver_h
 #define FWCore_Framework_ESProductResolver_h
-// -*- C++ -*-
 //
 // Package:     Framework
 // Class  :     ESProductResolver
 //
 /**\class edm::eventsetup::ESProductResolver
 
- Description: Base class for data Proxies held by a EventSetupRecord
+ Description: Base class for product resolvers held by a EventSetupRecord
 
  Usage:
     This class defines the interface used to handle retrieving data from an

FWCore/Framework/interface/ESProductResolverFactoryProducer.h

@@ -1,21 +1,21 @@
+// -*- C++ -*-
 #ifndef Framework_ESProductResolverFactoryProducer_h
 #define Framework_ESProductResolverFactoryProducer_h
-// -*- C++ -*-
 //
 // Package:     Framework
 // Class  :     ESProductResolverFactoryProducer
 //
-/**\class ESProductResolverFactoryProducer ESProductResolverFactoryProducer.h FWCore/Framework/interface/ESProductResolverFactoryProducer.h
+/**\class edm::ESProductResolverFactoryProducer
 
- Description: An EventSetup algorithmic Provider that manages Factories of Proxies
+ Description: An EventSetup algorithmic Provider that manages Factories of Resolvers
 
  Usage:
     This class is used when the algorithms in the EventSetup that are to be run on demand are encapsulated
   in edm::eventsetup::ProductResolvers's.  This 'design pattern' is more flexible than having the algorithm embedded
   directly in the Provider (see ESProducer for such an implemenation).
 
     Users inherit from this class and then call the 'registerFactory' method in their class' constructor
-  in order to get their Proxies registered.  For most users, the already available templated Factory classes
+  in order to get their Resolvers registered.  For most users, the already available templated Factory classes
   should suffice and therefore they should not need to create their own Factories.
 
 Example: register one Factory that creates a resolver that takes no arguments

FWCore/Framework/interface/ESProductResolverProvider.h

@@ -1,6 +1,6 @@
+// -*- C++ -*-
 #ifndef FWCore_Framework_ESProductResolverProvider_h
 #define FWCore_Framework_ESProductResolverProvider_h
-// -*- C++ -*-
 //
 // Package:     Framework
 // Class  :     ESProductResolverProvider
@@ -22,7 +22,7 @@
     CondDBESSource is the main such class) then the registerResolvers
     function must be overridden. For the same EventSetupRecordKey, the
     vector returned should contain the same DataKeys in the same order for
-    all the different iovIndexes. DataProxies associated with the same
+    all the different iovIndexes. ESProductResolver's associated with the same
     EventSetupRecordKey should have caches that use different memory, but
     other than that they should also be the same.
 
@@ -33,7 +33,7 @@
     All other functions are intended for use by the Framework or tests
     and should not be called in classes derived from ESProductResolverProvider.
     They are primarily used when initializing the EventSetup system
-    so the DataProxies are available for use when needed.
+    so the ESProductResolver's are available for use when needed.
 */
 //
 // Author:      Chris Jones

FWCore/Framework/interface/ESProductResolverTemplate.h

@@ -1,13 +1,13 @@
+// -*- C++ -*-
 #ifndef FWCore_Framework_ESProductResolverTemplate_h
 #define FWCore_Framework_ESProductResolverTemplate_h
-// -*- C++ -*-
 //
 // Package:     Framework
 // Class  :     ESProductResolverTemplate
 //
-/**\class ESProductResolverTemplate ESProductResolverTemplate.h FWCore/Framework/interface/ESProductResolverTemplate.h
+/**\class edm::eventsetup::ESProductResolverTemplate
 
- Description: A ESProductResolver base class which allows one to write type-safe proxies
+ Description: A ESProductResolver base class which allows one to write type-safe resolvers
 
               Note that ESProductResolver types that inherit from this are not allowed
               to get data from the EventSetup (they cannot consume anything).

FWCore/Framework/interface/ESSourceConcurrentProductResolverTemplate.h

@@ -1,13 +1,13 @@
+// -*- C++ -*-
 #ifndef FWCore_Framework_ESSourceConcurrentESProductResolverTemplate_h
 #define FWCore_Framework_ESSourceConcurrentESProductResolverTemplate_h
-// -*- C++ -*-
 //
 // Package:     FWCore/Framework
 // Class  :     ESSourceConcurrentESProductResolverTemplate
 //
-/**\class ESSourceConcurrentESProductResolverTemplate ESSourceConcurrentESProductResolverTemplate.h "FWCore/Framework/interface/ESSourceConcurrentESProductResolverTemplate.h"
+/**\class edm::eventsetup::ESSourceConcurrentESProductResolverTemplate
 
- Description: An ESSource specific ESProductResolver which is type safe and can run concurrently with other DataProxies from the same ESSource.
+ Description: An ESSource specific ESProductResolver which is type safe and can run concurrently with other ESProductResolvers from the same ESSource.
 
  Usage:
     Inherit from this class and override

FWCore/Framework/interface/ESSourceProductResolverBase.h

@@ -1,16 +1,17 @@
+// -*- C++ -*-
 #ifndef FWCore_Framework_ESSourceProductResolverBase_h
 #define FWCore_Framework_ESSourceProductResolverBase_h
-// -*- C++ -*-
 //
 // Package:     FWCore/Framework
 // Class  :     ESSourceProductResolverBase
 //
-/**\class ESSourceProductResolverBase ESSourceProductResolverBase.h "FWCore/Framework/interface/ESSourceProductResolverBase.h"
+/**\class edm::eventsetup::ESSourceProductResolverBase
 
- Description: Base class for DataProxies for ESSources that can be specialized based on concurrency needs
+ Description: Base class for ESProductResolvers for ESSources that can be specialized based on concurrency needs
 
  Usage:
-    The ESSourceProductResolverBase provides the bases for DataProxies needed for ESSources. It allows customization of synchronization needs via the use of template parameters.
+    The ESSourceProductResolverBase provides the bases for ProductResolvers needed for ESSources.
+    It allows customization of synchronization needs via the use of template parameters.
 
     NOTE: if inheriting classes override `void invalidateCache()` they must be sure to call this classes
     implementation as part of the call.