[ntuple] rename RInvalidField::RCategory to ECategory

Author: silverweed

tree/ntuple/inc/ROOT/RField.hxx

@@ -71,7 +71,7 @@ public:
 /// future RNTuple versions (e.g. an unknown Structure)
 class RInvalidField final : public RFieldBase {
 public:
-   enum class RCategory {
+   enum class ECategory {
       /// Generic unrecoverable error
       kGeneric,
       /// The type given to RFieldBase::Create was invalid
@@ -82,9 +82,11 @@ public:
       kUnknownStructure,
    };
 
+   using RCategory = ECategory R__DEPRECATED(6, 40, "enum renamed to ECategory");
+
 private:
    std::string fError;
-   RCategory fCategory;
+   ECategory fCategory;
 
 protected:
    std::unique_ptr<RFieldBase> CloneImpl(std::string_view newName) const final
@@ -94,14 +96,14 @@ protected:
    void ConstructValue(void *) const final {}
 
 public:
-   RInvalidField(std::string_view name, std::string_view type, std::string_view error, RCategory category)
+   RInvalidField(std::string_view name, std::string_view type, std::string_view error, ECategory category)
       : RFieldBase(name, type, ROOT::ENTupleStructure::kLeaf, false /* isSimple */), fError(error), fCategory(category)
    {
       fTraits |= kTraitInvalidField;
    }
 
    const std::string &GetError() const { return fError; }
-   RCategory GetCategory() const { return fCategory; }
+   ECategory GetCategory() const { return fCategory; }
 
    size_t GetValueSize() const final { return 0; }
    size_t GetAlignment() const final { return 0; }
@@ -214,7 +216,7 @@ private:
 
    TClass *fClass = nullptr;
    ROOT::Internal::RNTupleSerializer::StreamerInfoMap_t fStreamerInfos; ///< streamer info records seen during writing
-   ROOT::Internal::RColumnIndex fIndex;                           ///< number of bytes written in the current cluster
+   ROOT::Internal::RColumnIndex fIndex; ///< number of bytes written in the current cluster
 
 private:
    RStreamerField(std::string_view fieldName, TClass *classp);

tree/ntuple/src/RFieldBase.cxx

@@ -305,8 +305,8 @@ ROOT::RFieldBase::Create(const std::string &fieldName, const std::string &typeNa
 
    auto fnFail = [&fieldName,
                   &resolvedType](const std::string &errMsg,
-                                 RInvalidField::RCategory cat =
-                                    RInvalidField::RCategory::kTypeError) -> RResult<std::unique_ptr<RFieldBase>> {
+                                 RInvalidField::ECategory cat =
+                                    RInvalidField::ECategory::kTypeError) -> RResult<std::unique_ptr<RFieldBase>> {
       if (createContext.GetContinueOnError()) {
          return std::unique_ptr<RFieldBase>(std::make_unique<RInvalidField>(fieldName, resolvedType, errMsg, cat));
       } else {
@@ -603,15 +603,15 @@ ROOT::RFieldBase::Create(const std::string &fieldName, const std::string &typeNa
       auto error = e.GetError();
       if (createContext.GetContinueOnError()) {
          return std::unique_ptr<RFieldBase>(std::make_unique<RInvalidField>(fieldName, typeName, error.GetReport(),
-                                                                            RInvalidField::RCategory::kGeneric));
+                                                                            RInvalidField::ECategory::kGeneric));
       } else {
          return error;
       }
    } catch (const std::logic_error &e) {
       // Integer parsing error
       if (createContext.GetContinueOnError()) {
          return std::unique_ptr<RFieldBase>(
-            std::make_unique<RInvalidField>(fieldName, typeName, e.what(), RInvalidField::RCategory::kGeneric));
+            std::make_unique<RInvalidField>(fieldName, typeName, e.what(), RInvalidField::ECategory::kGeneric));
       } else {
          return R__FAIL(e.what());
       }
@@ -624,7 +624,7 @@ ROOT::RFieldBase::Create(const std::string &fieldName, const std::string &typeNa
       }
       return result;
    }
-   return R__FORWARD_RESULT(fnFail("unknown type: " + typeName, RInvalidField::RCategory::kUnknownType));
+   return R__FORWARD_RESULT(fnFail("unknown type: " + typeName, RInvalidField::ECategory::kUnknownType));
 }
 
 const ROOT::RFieldBase::RColumnRepresentations &ROOT::RFieldBase::GetColumnRepresentations() const

tree/ntuple/src/RNTupleDescriptor.cxx

@@ -81,7 +81,7 @@ ROOT::RFieldDescriptor::CreateField(const RNTupleDescriptor &ntplDesc, const ROO
    if (GetStructure() == ROOT::ENTupleStructure::kUnknown) {
       if (options.GetReturnInvalidOnError()) {
          auto invalidField = std::make_unique<ROOT::RInvalidField>(GetFieldName(), GetTypeName(), "",
-                                                                   ROOT::RInvalidField::RCategory::kUnknownStructure);
+                                                                   ROOT::RInvalidField::ECategory::kUnknownStructure);
          invalidField->SetOnDiskId(fFieldId);
          return invalidField;
       } else {
@@ -144,7 +144,7 @@ ROOT::RFieldDescriptor::CreateField(const RNTupleDescriptor &ntplDesc, const ROO
    } catch (const RException &ex) {
       if (options.GetReturnInvalidOnError())
          return std::make_unique<ROOT::RInvalidField>(GetFieldName(), GetTypeName(), ex.GetError().GetReport(),
-                                                      ROOT::RInvalidField::RCategory::kGeneric);
+                                                      ROOT::RInvalidField::ECategory::kGeneric);
       else
          throw ex;
    }
@@ -702,7 +702,7 @@ std::unique_ptr<ROOT::RNTupleModel> ROOT::RNTupleDescriptor::CreateModel(const R
       if (field->GetTraits() & ROOT::RFieldBase::kTraitInvalidField) {
          const auto &invalid = static_cast<const RInvalidField &>(*field);
          const auto cat = invalid.GetCategory();
-         bool mustThrow = cat != RInvalidField::RCategory::kUnknownStructure;
+         bool mustThrow = cat != RInvalidField::ECategory::kUnknownStructure;
          if (mustThrow)
             throw invalid.GetError();