Expansion of the TStreamerInfo actions.

core/meta/inc/TClass.h

@@ -406,6 +406,7 @@ friend class TStreamerInfo;
    void               ForceReload (TClass* oldcl);
    Bool_t             HasDataMemberInfo() const { return fIsSyntheticPair || fHasRootPcmInfo || HasInterpreterInfo(); }
    Bool_t             HasDefaultConstructor(Bool_t testio = kFALSE) const;
+   Bool_t             HasDirectStreamerInfoUse() const { return fStreamerImpl == &TClass::StreamerStreamerInfo; }
    Bool_t             HasInterpreterInfoInMemory() const { return nullptr != fClassInfo; }
    Bool_t             HasInterpreterInfo() const { return fCanLoadClassInfo || fClassInfo; }
    UInt_t             GetCheckSum(ECheckSum code = kCurrentCheckSum) const;

core/meta/inc/TStreamerElement.h

@@ -52,6 +52,8 @@ class TStreamerElement : public TNamed {
    Double_t         fXmax;            //!Maximum of data member if a range is specified  [xmin,xmax,nbits]
    Double_t         fFactor;          //!Conversion factor if a range is specified fFactor = (1<<nbits/(xmax-xmin)
 
+   friend class TStreamerSTL;
+
 public:
 
    enum ESTLtype {
@@ -409,6 +411,7 @@ class TStreamerSTL : public TStreamerElement {
    Bool_t         CannotSplit() const override;
    Bool_t         IsaPointer() const override;
    Bool_t         IsBase() const override;
+   TClass        *GetClassPointer() const override;
    Int_t          GetSTLtype() const {return fSTLtype;}
    Int_t          GetCtype()   const {return fCtype;}
    const char    *GetInclude() const override;

core/meta/src/TStreamerElement.cxx

@@ -26,6 +26,7 @@
 #include "TBaseClass.h"
 #include "TDataMember.h"
 #include "TDataType.h"
+#include "TEnum.h"
 #include "TRealData.h"
 #include "ThreadLocalStorage.h"
 #include "TList.h"
@@ -480,8 +481,10 @@ void TStreamerElement::ls(Option_t *) const
 void TStreamerElement::SetArrayDim(Int_t dim)
 {
    fArrayDim = dim;
-   if (dim) fType += TVirtualStreamerInfo::kOffsetL;
-   fNewType = fType;
+   if (dim) {
+      fType += TVirtualStreamerInfo::kOffsetL;
+      fNewType += TVirtualStreamerInfo::kOffsetL;
+   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -1683,7 +1686,7 @@ ClassImp(TStreamerSTL);
 ////////////////////////////////////////////////////////////////////////////////
 /// Default ctor.
 
-TStreamerSTL::TStreamerSTL() : fSTLtype(0),fCtype(0)
+TStreamerSTL::TStreamerSTL() : fSTLtype(0), fCtype(0)
 {
 }
 
@@ -1694,7 +1697,10 @@ TStreamerSTL::TStreamerSTL(const char *name, const char *title, Int_t offset,
                            const char *typeName, const TVirtualCollectionProxy &proxy, Bool_t dmPointer)
         : TStreamerElement(name,title,offset,ROOT::kSTLany,typeName)
 {
-   fTypeName = TClassEdit::ShortType(fTypeName,TClassEdit::kDropStlDefault).c_str();
+   std::string answer;
+   TClassEdit::TSplitType arglist(fTypeName, TClassEdit::kDropStlDefault);
+   arglist.ShortType(answer, TClassEdit::kDropStlDefault);
+   fTypeName = answer;
 
   if (name==typeName /* intentional pointer comparison */
       || strcmp(name,typeName)==0) {
@@ -1714,8 +1720,15 @@ TStreamerSTL::TStreamerSTL(const char *name, const char *title, Int_t offset,
    } else {
       fCtype = proxy.GetType();
       if (proxy.HasPointers()) fCtype += TVirtualStreamerInfo::kOffsetP;
+      auto enumdesc = TEnum::GetEnum(arglist.fElements[1].c_str());
+      if (enumdesc || gCling->ClassInfo_IsEnum(arglist.fElements[1].c_str())) {
+         fCtype = enumdesc ? enumdesc->GetUnderlyingType() : 3;
+      }
+   }
+   if (TStreamerSTL::IsaPointer()) {
+      fType = TVirtualStreamerInfo::kSTLp;
+      fNewType = fType;
    }
-   if (TStreamerSTL::IsaPointer()) fType = TVirtualStreamerInfo::kSTLp;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -1776,8 +1789,11 @@ TStreamerSTL::TStreamerSTL(const char *name, const char *title, Int_t offset,
          if (isPointer) fCtype = TVirtualStreamerInfo::kObjectp;
          else           fCtype = TVirtualStreamerInfo::kObject;
       } else {
-         if (gCling->ClassInfo_IsEnum(intype.c_str())) {
-            if (isPointer) fCtype += TVirtualStreamerInfo::kOffsetP;
+         auto enumdesc = TEnum::GetEnum(intype.c_str());
+         if (enumdesc || gCling->ClassInfo_IsEnum(intype.c_str())) {
+            fCtype = enumdesc ? enumdesc->GetUnderlyingType() : 3;
+            if (isPointer)
+               fCtype += TVirtualStreamerInfo::kOffsetP;
          } else {
             if (intype != "string") {
                // This case can happens when 'this' is a TStreamerElement for
@@ -1794,7 +1810,10 @@ TStreamerSTL::TStreamerSTL(const char *name, const char *title, Int_t offset,
       }
    }
 
-   if (TStreamerSTL::IsaPointer()) fType = TVirtualStreamerInfo::kSTLp;
+   if (TStreamerSTL::IsaPointer()) {
+      fType = TVirtualStreamerInfo::kSTLp;
+      fNewType = fType;
+   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -1844,6 +1863,41 @@ Bool_t TStreamerSTL::IsBase() const
    if (strcmp(ts.Data(),GetTypeNameBasic())==0) return kTRUE;
    return kFALSE;
 }
+
+////////////////////////////////////////////////////////////////////////////////
+/// Returns a pointer to the TClass of this element.
+
+TClass *TStreamerSTL::GetClassPointer() const
+{
+   if (fClassObject!=(TClass*)(-1))
+      return fClassObject;
+
+   bool quiet = (fType == TVirtualStreamerInfo::kArtificial);
+
+   TString className(ExtractClassName(fTypeName));
+   TClass *cl = TClass::GetClass(className, kTRUE, quiet);
+
+   auto proxy = cl->GetCollectionProxy();
+   if (fNewClass && proxy->GetValueClass() == nullptr) {
+      // Collection of numerical type, let check if it is an enum.
+      TClassEdit::TSplitType arglist(fTypeName, TClassEdit::kDropStlDefault);
+      if ( arglist.fElements[1].size() >= 2 ) {
+         auto enumdesc = TEnum::GetEnum(arglist.fElements[1].c_str());
+         if (enumdesc || gCling->ClassInfo_IsEnum(arglist.fElements[1].c_str())) {
+            if (fNewClass == nullptr) {
+               ((TStreamerElement*)this)->fNewClass = cl;
+               if (proxy->HasPointers())
+                  cl = TClass::GetClass("vector<Int_t*>");
+               else
+                  cl = TClass::GetClass("vector<Int_t>");
+            }
+         }
+      }
+   }
+   ((TStreamerElement*)this)->fClassObject = cl;
+   return fClassObject;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 /// Returns size of STL container in bytes.
 

io/io/inc/TStreamerInfoActions.h

@@ -175,7 +175,7 @@ namespace TStreamerInfoActions {
 
    typedef std::vector<TConfiguredAction> ActionContainer_t;
    class TActionSequence : public TObject {
-      TActionSequence() {};
+      TActionSequence() = delete;
    public:
       enum class EStatusBits {
          kVectorPtrLooper = BIT(14)
@@ -216,7 +216,9 @@ namespace TStreamerInfoActions {
 
       TActionSequence *CreateCopy();
       static TActionSequence *CreateReadMemberWiseActions(TVirtualStreamerInfo *info, TVirtualCollectionProxy &proxy);
+      static TActionSequence *CreateReadMemberWiseActions(TVirtualStreamerInfo &info, TLoopConfiguration *loopConfig);  // 2nd arg should be unique_ptr
       static TActionSequence *CreateWriteMemberWiseActions(TVirtualStreamerInfo *info, TVirtualCollectionProxy &proxy);
+      static TActionSequence *CreateWriteMemberWiseActions(TVirtualStreamerInfo &info, TLoopConfiguration *loopConfig);  // 2nd arg should be unique_ptr
       TActionSequence *CreateSubSequence(const std::vector<Int_t> &element_ids, size_t offset);
 
       TActionSequence *CreateSubSequence(const TIDs &element_ids, size_t offset, SequenceGetter_t create);

io/io/src/TStreamerInfo.cxx

@@ -535,8 +535,10 @@ void TStreamerInfo::Build(Bool_t isTransient)
             element = new TStreamerSTLstring(dmName, dmTitle, offset, dmFull, dmIsPtr);
          } else if (dm->IsSTLContainer()) {
             TVirtualCollectionProxy *proxy = TClass::GetClass(dmType /* the underlying type */)->GetCollectionProxy();
-            if (proxy) element = new TStreamerSTL(dmName, dmTitle, offset, dmFull, *proxy, dmIsPtr);
-            else element = new TStreamerSTL(dmName, dmTitle, offset, dmFull, dmFull, dmIsPtr);
+            if (proxy)
+               element = new TStreamerSTL(dmName, dmTitle, offset, dmFull, *proxy, dmIsPtr);
+            else
+               element = new TStreamerSTL(dmName, dmTitle, offset, dmFull, dmFull, dmIsPtr);
             bool hasCustomAlloc = proxy ? proxy->GetProperties() & TVirtualCollectionProxy::kCustomAlloc : kFALSE;
             if (((TStreamerSTL*)element)->GetSTLtype() != ROOT::kSTLvector || hasCustomAlloc) {
                auto printErrorMsg = [&](const char* category)