[ntuple] deprecate small helpers in RFieldDescriptor

The query methods `IsCustomClass`, `IsCustomEnum`, and `IsStdAtomic` are
rather arbitrary and should not have been added to the public interface.
They only make sense in the internal context in which they are used.

Removed for v6.42.

Author: jblomer

tree/ntuple/inc/ROOT/RNTupleDescriptor.hxx

@@ -189,15 +189,10 @@ public:
    std::uint32_t GetColumnCardinality() const { return fColumnCardinality; }
    std::optional<std::uint32_t> GetTypeChecksum() const { return fTypeChecksum; }
    bool IsProjectedField() const { return fProjectionSourceId != ROOT::kInvalidDescriptorId; }
-   /// Tells if the field describes a user-defined class rather than a fundamental type, a collection, or one of the
-   /// natively supported stdlib classes.
-   /// The dictionary does not need to be available for this method.
-   bool IsCustomClass() const;
-   /// Tells if the field describes a user-defined enum type.
-   /// The dictionary does not need to be available for this method.
-   /// Needs the full descriptor to look up sub fields.
-   bool IsCustomEnum(const RNTupleDescriptor &desc) const;
-   bool IsStdAtomic() const;
+
+   bool IsCustomClass() const R__DEPRECATED(6, 42, "removed from public interface");
+   bool IsCustomEnum(const RNTupleDescriptor &desc) const R__DEPRECATED(6, 42, "removed from public interface");
+   bool IsStdAtomic() const R__DEPRECATED(6, 42, "removed from public interface");
 };
 
 // clang-format off
@@ -1772,6 +1767,19 @@ inline RNTupleDescriptor CloneDescriptorSchema(const RNTupleDescriptor &desc)
    return desc.CloneSchema();
 }
 
+/// Tells if the field describes a user-defined class rather than a fundamental type, a collection, or one of the
+/// natively supported stdlib classes.
+/// The dictionary does not need to be available for this method.
+bool IsCustomClassFieldDesc(const RFieldDescriptor &fieldDesc);
+
+/// Tells if the field describes a user-defined enum type.
+/// The dictionary does not need to be available for this method.
+/// Needs the full descriptor to look up sub fields.
+bool IsCustomEnumFieldDesc(const RNTupleDescriptor &desc, const RFieldDescriptor &fieldDesc);
+
+/// Tells if the field describes a std::atomic<T> type
+bool IsStdAtomicFieldDesc(const RFieldDescriptor &fieldDesc);
+
 } // namespace Internal
 
 } // namespace ROOT

tree/ntuple/src/RField.cxx

@@ -117,7 +117,7 @@ void ROOT::RSimpleField<T>::ReconcileIntegralField(const RNTupleDescriptor &desc
    EnsureMatchingOnDiskField(desc, kDiffTypeName);
 
    const RFieldDescriptor &fieldDesc = desc.GetFieldDescriptor(GetOnDiskId());
-   if (fieldDesc.IsCustomEnum(desc)) {
+   if (Internal::IsCustomEnumFieldDesc(desc, fieldDesc)) {
       SetOnDiskId(desc.FindFieldId("_0", GetOnDiskId()));
       return;
    }

tree/ntuple/src/RFieldBase.cxx

@@ -959,7 +959,8 @@ void ROOT::RFieldBase::ConnectPageSource(ROOT::Internal::RPageSource &pageSource
       // Note that we have to do this before calling BeforeConnectPageSource(), which already may compare the field
       // to its on-disk description.
       const auto &desc = pageSource.GetSharedDescriptorGuard().GetRef();
-      if (!dynamic_cast<RAtomicField *>(this) && desc.GetFieldDescriptor(GetOnDiskId()).IsStdAtomic()) {
+      if (!dynamic_cast<RAtomicField *>(this) &&
+          Internal::IsStdAtomicFieldDesc(desc.GetFieldDescriptor(GetOnDiskId()))) {
          SetOnDiskId(desc.GetFieldDescriptor(GetOnDiskId()).GetLinkIds()[0]);
       }
    }

tree/ntuple/src/RNTupleDescriptor.cxx

@@ -152,46 +152,17 @@ ROOT::RFieldDescriptor::CreateField(const RNTupleDescriptor &ntplDesc, const ROO
 
 bool ROOT::RFieldDescriptor::IsCustomClass() const
 {
-   if (fStructure != ROOT::ENTupleStructure::kRecord && fStructure != ROOT::ENTupleStructure::kStreamer)
-      return false;
-
-   // Skip untyped structs
-   if (fTypeName.empty())
-      return false;
-
-   if (fStructure == ROOT::ENTupleStructure::kRecord) {
-      if (fTypeName.compare(0, 10, "std::pair<") == 0)
-         return false;
-      if (fTypeName.compare(0, 11, "std::tuple<") == 0)
-         return false;
-   }
-
-   return true;
+   return Internal::IsCustomClassFieldDesc(*this);
 }
 
 bool ROOT::RFieldDescriptor::IsCustomEnum(const RNTupleDescriptor &desc) const
 {
-   if (fStructure != ROOT::ENTupleStructure::kPlain)
-      return false;
-   if (fTypeName.rfind("std::", 0) == 0)
-      return false;
-
-   auto subFieldId = desc.FindFieldId("_0", fFieldId);
-   if (subFieldId == kInvalidDescriptorId)
-      return false;
-
-   static const std::string gIntTypeNames[] = {"bool",         "char",          "std::int8_t",  "std::uint8_t",
-                                               "std::int16_t", "std::uint16_t", "std::int32_t", "std::uint32_t",
-                                               "std::int64_t", "std::uint64_t"};
-   return std::find(std::begin(gIntTypeNames), std::end(gIntTypeNames),
-                    desc.GetFieldDescriptor(subFieldId).GetTypeName()) != std::end(gIntTypeNames);
+   return Internal::IsCustomEnumFieldDesc(desc, *this);
 }
 
 bool ROOT::RFieldDescriptor::IsStdAtomic() const
 {
-   if (fStructure != ROOT::ENTupleStructure::kPlain)
-      return false;
-   return (fTypeName.rfind("std::atomic<", 0) == 0);
+   return Internal::IsStdAtomicFieldDesc(*this);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -1419,7 +1390,7 @@ RNTupleSerializer::StreamerInfoMap_t ROOT::Internal::RNTupleDescriptorBuilder::B
 
    std::function<void(const RFieldDescriptor &)> fnWalkFieldTree;
    fnWalkFieldTree = [&desc, &streamerInfoMap, &fnWalkFieldTree](const RFieldDescriptor &fieldDesc) {
-      if (fieldDesc.IsCustomClass()) {
+      if (Internal::IsCustomClassFieldDesc(fieldDesc)) {
          // Add streamer info for this class to streamerInfoMap
          auto cl = TClass::GetClass(fieldDesc.GetTypeName().c_str());
          if (!cl) {
@@ -1550,3 +1521,49 @@ ROOT::Experimental::RNTupleAttrSetDescriptor ROOT::Experimental::RNTupleAttrSetD
    desc.fName = fName;
    return desc;
 }
+
+bool ROOT::Internal::IsCustomClassFieldDesc(const RFieldDescriptor &fieldDesc)
+{
+   if (fieldDesc.GetStructure() != ROOT::ENTupleStructure::kRecord &&
+       fieldDesc.GetStructure() != ROOT::ENTupleStructure::kStreamer) {
+      return false;
+   }
+
+   // Skip untyped structs
+   if (fieldDesc.GetTypeName().empty())
+      return false;
+
+   if (fieldDesc.GetStructure() == ROOT::ENTupleStructure::kRecord) {
+      if (fieldDesc.GetTypeName().compare(0, 10, "std::pair<") == 0)
+         return false;
+      if (fieldDesc.GetTypeName().compare(0, 11, "std::tuple<") == 0)
+         return false;
+   }
+
+   return true;
+}
+
+bool ROOT::Internal::IsCustomEnumFieldDesc(const RNTupleDescriptor &desc, const RFieldDescriptor &fieldDesc)
+{
+   if (fieldDesc.GetStructure() != ROOT::ENTupleStructure::kPlain)
+      return false;
+   if (fieldDesc.GetTypeName().rfind("std::", 0) == 0)
+      return false;
+
+   auto subFieldId = desc.FindFieldId("_0", fieldDesc.GetId());
+   if (subFieldId == kInvalidDescriptorId)
+      return false;
+
+   static const std::string gIntTypeNames[] = {"bool",         "char",          "std::int8_t",  "std::uint8_t",
+                                               "std::int16_t", "std::uint16_t", "std::int32_t", "std::uint32_t",
+                                               "std::int64_t", "std::uint64_t"};
+   return std::find(std::begin(gIntTypeNames), std::end(gIntTypeNames),
+                    desc.GetFieldDescriptor(subFieldId).GetTypeName()) != std::end(gIntTypeNames);
+}
+
+bool ROOT::Internal::IsStdAtomicFieldDesc(const RFieldDescriptor &fieldDesc)
+{
+   if (fieldDesc.GetStructure() != ROOT::ENTupleStructure::kPlain)
+      return false;
+   return (fieldDesc.GetTypeName().rfind("std::atomic<", 0) == 0);
+}