[ntuple] Replace all const string & with string_view in fn parameters

Author: silverweed

tree/ntuple/inc/ROOT/RField.hxx

@@ -185,7 +185,7 @@ private:
    ROOT::DescriptorId_t
    LookupMember(const ROOT::RNTupleDescriptor &desc, std::string_view memberName, ROOT::DescriptorId_t classFieldId);
    /// Sets fStagingClass according to the given name and version
-   void SetStagingClass(const std::string &className, unsigned int classVersion);
+   void SetStagingClass(std::string_view className, unsigned int classVersion);
    /// If there are rules with inputs (source members), create the staging area according to the TClass instance
    /// that corresponds to the on-disk field.
    void PrepareStagingArea(const std::vector<const TSchemaRule *> &rules, const ROOT::RNTupleDescriptor &desc,
@@ -555,7 +555,7 @@ namespace Internal {
 /// type renormalization of the demangled type name T. The failure case, however, needs to additionally check for
 /// ROOT-specific special cases.
 template <class T>
-bool IsMatchingFieldType(const std::string &actualTypeName)
+bool IsMatchingFieldType(std::string_view actualTypeName)
 {
    return IsMatchingFieldType(actualTypeName, ROOT::RField<T>::TypeName(), typeid(T));
 }

tree/ntuple/inc/ROOT/RFieldBase.hxx

@@ -62,7 +62,7 @@ void CallCommitClusterOnField(RFieldBase &);
 void CallConnectPageSinkOnField(RFieldBase &, ROOT::Internal::RPageSink &, ROOT::NTupleSize_t firstEntry = 0);
 void CallConnectPageSourceOnField(RFieldBase &, ROOT::Internal::RPageSource &);
 ROOT::RResult<std::unique_ptr<ROOT::RFieldBase>>
-CallFieldBaseCreate(const std::string &fieldName, const std::string &typeName, const ROOT::RCreateFieldOptions &options,
+CallFieldBaseCreate(std::string_view fieldName, std::string_view typeName, const ROOT::RCreateFieldOptions &options,
                     const ROOT::RNTupleDescriptor *desc, ROOT::DescriptorId_t fieldId);
 
 } // namespace Internal
@@ -97,7 +97,7 @@ class RFieldBase {
    friend void Internal::CallConnectPageSinkOnField(RFieldBase &, ROOT::Internal::RPageSink &, ROOT::NTupleSize_t);
    friend void Internal::CallConnectPageSourceOnField(RFieldBase &, ROOT::Internal::RPageSource &);
    friend ROOT::RResult<std::unique_ptr<ROOT::RFieldBase>>
-   Internal::CallFieldBaseCreate(const std::string &fieldName, const std::string &typeName,
+   Internal::CallFieldBaseCreate(std::string_view fieldName, std::string_view typeName,
                                  const ROOT::RCreateFieldOptions &options, const ROOT::RNTupleDescriptor *desc,
                                  ROOT::DescriptorId_t fieldId);
 
@@ -566,7 +566,7 @@ protected:
    /// normalized type name and type alias.
    /// `desc` and `fieldId` must be passed if `options.fEmulateUnknownTypes` is true, otherwise they can be left blank.
    static RResult<std::unique_ptr<RFieldBase>>
-   Create(const std::string &fieldName, const std::string &typeName, const ROOT::RCreateFieldOptions &options,
+   Create(std::string_view fieldName, std::string_view typeName, const ROOT::RCreateFieldOptions &options,
           const ROOT::RNTupleDescriptor *desc, ROOT::DescriptorId_t fieldId);
 
 public:
@@ -605,12 +605,11 @@ public:
    /// Factory method to create a field from a certain type given as string.
    /// Note that the provided type name must be a valid C++ type name. Template arguments of templated types
    /// must be type names or integers (e.g., no expressions).
-   static RResult<std::unique_ptr<RFieldBase>>
-   Create(const std::string &fieldName, const std::string &typeName);
+   static RResult<std::unique_ptr<RFieldBase>> Create(std::string_view fieldName, std::string_view typeName);
 
    /// Checks if the given type is supported by RNTuple. In case of success, the result vector is empty.
    /// Otherwise there is an error record for each failing subfield (subtype).
-   static std::vector<RCheckResult> Check(const std::string &fieldName, const std::string &typeName);
+   static std::vector<RCheckResult> Check(std::string_view fieldName, std::string_view typeName);
 
    /// Generates an object of the field type and allocates new initialized memory according to the type.
    /// Implemented at the end of this header because the implementation is using RField<T>::TypeName()

tree/ntuple/inc/ROOT/RFieldUtils.hxx

@@ -27,10 +27,10 @@ namespace Internal {
 /// template arguments (hence "Prefix").
 /// Furthermore, if the type is a C-style array, rules are applied to the base type and the C style array
 /// is then mapped to an std::array.
-std::string GetCanonicalTypePrefix(const std::string &typeName);
+std::string GetCanonicalTypePrefix(std::string_view typeName);
 
 /// Given a type name normalized by ROOT meta, renormalize it for RNTuple. E.g., insert std::prefix.
-std::string GetRenormalizedTypeName(const std::string &metaNormalizedName);
+std::string GetRenormalizedTypeName(std::string_view metaNormalizedName);
 
 /// Given a type info ask ROOT meta to demangle it, then renormalize the resulting type name for RNTuple. Useful to
 /// ensure that e.g. fundamental types are normalized to the type used by RNTuple (e.g. int -> std::int32_t).
@@ -42,18 +42,18 @@ std::string GetRenormalizedTypeName(const std::type_info &ti);
 /// to ensure correct reconstruction of objects from disk.
 /// If the function returns true, renormalizedAlias contains the RNTuple normalized name that should be used as
 /// type alias.
-bool NeedsMetaNameAsAlias(const std::string &metaNormalizedName, std::string &renormalizedAlias,
+bool NeedsMetaNameAsAlias(std::string_view metaNormalizedName, std::string &renormalizedAlias,
                           bool isArgInTemplatedUserClass = false /* used in recursion */);
 
 /// Applies all RNTuple type normalization rules except typedef resolution.
-std::string GetNormalizedUnresolvedTypeName(const std::string &origName);
+std::string GetNormalizedUnresolvedTypeName(std::string_view origName);
 
 /// Appends 'll' or 'ull' to the where necessary and strips the suffix if not needed.
-std::string GetNormalizedInteger(const std::string &intTemplateArg);
+std::string GetNormalizedInteger(std::string_view intTemplateArg);
 std::string GetNormalizedInteger(long long val);
 std::string GetNormalizedInteger(unsigned long long val);
-long long ParseIntTypeToken(const std::string &intToken);
-unsigned long long ParseUIntTypeToken(const std::string &uintToken);
+long long ParseIntTypeToken(std::string_view intToken);
+unsigned long long ParseUIntTypeToken(std::string_view uintToken);
 
 /// Possible settings for the "rntuple.streamerMode" class attribute in the dictionary.
 enum class ERNTupleSerializationMode {

tree/ntuple/inc/ROOT/RFieldVisitor.hxx

@@ -253,7 +253,7 @@ The functions in this class format strings which are displayed by RNTupleReader:
 class RNTupleFormatter {
 public:
    // Can abbreviate long strings, e.g. ("ExampleString" , space= 8) => "Examp..."
-   static std::string FitString(const std::string &str, int availableSpace);
+   static std::string FitString(std::string_view str, int availableSpace);
 };
 
 } // namespace Internal

tree/ntuple/inc/ROOT/RMiniFile.hxx

@@ -197,8 +197,8 @@ private:
       /// Writes a TKey including the data record, given by buffer, into fFile; returns the file offset to the payload.
       /// The payload is already compressed
       std::uint64_t WriteKey(const void *buffer, std::size_t nbytes, std::size_t len, std::int64_t offset = -1,
-                             std::uint64_t directoryOffset = 100, const std::string &className = "",
-                             const std::string &objectName = "", const std::string &title = "");
+                             std::uint64_t directoryOffset = 100, std::string_view className = "",
+                             std::string_view objectName = "", std::string_view title = "");
       /// Reserves an RBlob opaque key as data record and returns the offset of the record. If keyBuffer is specified,
       /// it must be written *before* the returned offset. (Note that the array type is purely documentation, the
       /// argument is actually just a pointer.)

tree/ntuple/inc/ROOT/RNTupleDescriptor.hxx

@@ -1537,22 +1537,22 @@ public:
       fField.fProjectionSourceId = id;
       return *this;
    }
-   RFieldDescriptorBuilder &FieldName(const std::string &fieldName)
+   RFieldDescriptorBuilder &FieldName(std::string_view fieldName)
    {
       fField.fFieldName = fieldName;
       return *this;
    }
-   RFieldDescriptorBuilder &FieldDescription(const std::string &fieldDescription)
+   RFieldDescriptorBuilder &FieldDescription(std::string_view fieldDescription)
    {
       fField.fFieldDescription = fieldDescription;
       return *this;
    }
-   RFieldDescriptorBuilder &TypeName(const std::string &typeName)
+   RFieldDescriptorBuilder &TypeName(std::string_view typeName)
    {
       fField.fTypeName = typeName;
       return *this;
    }
-   RFieldDescriptorBuilder &TypeAlias(const std::string &typeAlias)
+   RFieldDescriptorBuilder &TypeAlias(std::string_view typeAlias)
    {
       fField.fTypeAlias = typeAlias;
       return *this;
@@ -1723,12 +1723,12 @@ public:
       fExtraTypeInfo.fTypeVersion = typeVersion;
       return *this;
    }
-   RExtraTypeInfoDescriptorBuilder &TypeName(const std::string &typeName)
+   RExtraTypeInfoDescriptorBuilder &TypeName(std::string_view typeName)
    {
       fExtraTypeInfo.fTypeName = typeName;
       return *this;
    }
-   RExtraTypeInfoDescriptorBuilder &Content(const std::string &content)
+   RExtraTypeInfoDescriptorBuilder &Content(std::string_view content)
    {
       fExtraTypeInfo.fContent = content;
       return *this;

tree/ntuple/inc/ROOT/RNTupleMetrics.hxx

@@ -59,8 +59,10 @@ private:
    bool fIsEnabled = false;
 
 public:
-   RNTuplePerfCounter(const std::string &name, const std::string &unit, const std::string &desc)
-      : fName(name), fUnit(unit), fDescription(desc) {}
+   RNTuplePerfCounter(std::string_view name, std::string_view unit, std::string_view desc)
+      : fName(name), fUnit(unit), fDescription(desc)
+   {
+   }
    virtual ~RNTuplePerfCounter();
    void Enable() { fIsEnabled = true; }
    bool IsEnabled() const { return fIsEnabled; }
@@ -86,7 +88,7 @@ private:
    std::int64_t fCounter = 0;
 
 public:
-   RNTuplePlainCounter(const std::string &name, const std::string &unit, const std::string &desc)
+   RNTuplePlainCounter(std::string_view name, std::string_view unit, std::string_view desc)
       : RNTuplePerfCounter(name, unit, desc)
    {
    }
@@ -113,8 +115,10 @@ private:
    std::atomic<std::int64_t> fCounter{0};
 
 public:
-   RNTupleAtomicCounter(const std::string &name, const std::string &unit, const std::string &desc)
-      : RNTuplePerfCounter(name, unit, desc) { }
+   RNTupleAtomicCounter(std::string_view name, std::string_view unit, std::string_view desc)
+      : RNTuplePerfCounter(name, unit, desc)
+   {
+   }
 
    R__ALWAYS_INLINE
    void Inc() {
@@ -175,8 +179,8 @@ private:
    const MetricFunc_t fFunc;
 
 public:
-   RNTupleCalcPerf(const std::string &name, const std::string &unit, const std::string &desc,
-                   RNTupleMetrics &metrics, MetricFunc_t &&func)
+   RNTupleCalcPerf(std::string_view name, std::string_view unit, std::string_view desc, RNTupleMetrics &metrics,
+                   MetricFunc_t &&func)
       : RNTuplePerfCounter(name, unit, desc), fMetrics(metrics), fFunc(std::move(func))
    {
    }
@@ -211,7 +215,7 @@ When printing, the value is converted from ticks to nanoseconds.
 template <typename BaseCounterT>
 class RNTupleTickCounter : public BaseCounterT {
 public:
-   RNTupleTickCounter(const std::string &name, const std::string &unit, const std::string &desc)
+   RNTupleTickCounter(std::string_view name, std::string_view unit, std::string_view desc)
       : BaseCounterT(name, unit, desc)
    {
       R__ASSERT(unit == "ns");
@@ -294,10 +298,10 @@ private:
    std::string fName;
    bool fIsEnabled = false;
 
-   bool Contains(const std::string &name) const;
+   bool Contains(std::string_view name) const;
 
 public:
-   explicit RNTupleMetrics(const std::string &name) : fName(name) {}
+   explicit RNTupleMetrics(std::string_view name) : fName(name) {}
    RNTupleMetrics(const RNTupleMetrics &other) = delete;
    RNTupleMetrics & operator=(const RNTupleMetrics &other) = delete;
    RNTupleMetrics(RNTupleMetrics &&other) = default;
@@ -306,7 +310,7 @@ public:
 
    // TODO(jblomer): return a reference
    template <typename CounterPtrT, class... Args>
-   CounterPtrT MakeCounter(const std::string &name, Args&&... args)
+   CounterPtrT MakeCounter(std::string_view name, Args &&...args)
    {
       R__ASSERT(!Contains(name));
       auto counter = std::make_unique<std::remove_pointer_t<CounterPtrT>>(name, std::forward<Args>(args)...);
@@ -323,7 +327,7 @@ public:
 
    void ObserveMetrics(RNTupleMetrics &observee);
 
-   void Print(std::ostream &output, const std::string &prefix = "") const;
+   void Print(std::ostream &output, std::string_view prefix = "") const;
    void Enable();
    bool IsEnabled() const { return fIsEnabled; }
 };

tree/ntuple/inc/ROOT/RNTupleProcessor.hxx

@@ -59,7 +59,7 @@ private:
 
 public:
    RNTupleOpenSpec(std::string_view n, TDirectory *s) : fNTupleName(n), fStorage(s) {}
-   RNTupleOpenSpec(std::string_view n, const std::string &s) : fNTupleName(n), fStorage(s) {}
+   RNTupleOpenSpec(std::string_view n, std::string_view s) : fNTupleName(n), fStorage(std::string(s)) {}
 
    std::unique_ptr<ROOT::Internal::RPageSource> CreatePageSource() const;
 };
@@ -314,7 +314,7 @@ protected:
    ///
    /// In case the field was already present in the entry, the index of the existing field is returned.
    virtual Internal::RNTupleProcessorEntry::FieldIndex_t
-   AddFieldToEntry(const std::string &fieldName, const std::string &typeName, void *valuePtr,
+   AddFieldToEntry(std::string_view fieldName, std::string_view typeName, void *valuePtr,
                    const Internal::RNTupleProcessorProvenance &provenance) = 0;
 
    /////////////////////////////////////////////////////////////////////////////
@@ -385,7 +385,7 @@ public:
    /// invalid data. After passing a pointer to `RequestField`, we *strongly* recommend only accessing its data through
    /// the interface of the returned `RNTupleProcessorOptionalPtr`, to ensure that only valid data can be read.
    template <typename T>
-   RNTupleProcessorOptionalPtr<T> RequestField(const std::string &fieldName, void *valuePtr = nullptr)
+   RNTupleProcessorOptionalPtr<T> RequestField(std::string_view fieldName, void *valuePtr = nullptr)
    {
       Initialize(fEntry);
       std::string typeName{};
@@ -412,7 +412,7 @@ public:
    /// invalid data. After passing a pointer to `RequestField`, we *strongly* recommend only accessing its data through
    /// the interface of the returned `RNTupleProcessorOptionalPtr`, to ensure that only valid data can be read.
    RNTupleProcessorOptionalPtr<void>
-   RequestField(const std::string &fieldName, const std::string &typeName, void *valuePtr = nullptr)
+   RequestField(std::string_view fieldName, std::string_view typeName, void *valuePtr = nullptr)
    {
       Initialize(fEntry);
       auto fieldIdx = AddFieldToEntry(fieldName, typeName, valuePtr, Internal::RNTupleProcessorProvenance());
@@ -590,7 +590,7 @@ private:
    /// \return The newly created field.
    /// \throws ROOT::RException In case the requested field cannot be found on disk.
    std::unique_ptr<ROOT::RFieldBase>
-   CreateAndConnectField(const std::string &qualifiedFieldName, const std::string &typeName);
+   CreateAndConnectField(std::string_view qualifiedFieldName, std::string_view typeName);
 
    /////////////////////////////////////////////////////////////////////////////
    /// \brief Initialize the processor by creating an (initially empty) `fEntry`, or setting an existing one.
@@ -631,7 +631,7 @@ private:
    ///
    /// \sa RNTupleProcessor::AddFieldToEntry()
    Internal::RNTupleProcessorEntry::FieldIndex_t AddFieldToEntry(
-      const std::string &fieldName, const std::string &typeName, void *valuePtr = nullptr,
+      std::string_view fieldName, std::string_view typeName, void *valuePtr = nullptr,
       const Internal::RNTupleProcessorProvenance &provenance = Internal::RNTupleProcessorProvenance()) final;
 
    /////////////////////////////////////////////////////////////////////////////
@@ -726,7 +726,7 @@ private:
    ///
    /// \sa RNTupleProcessor::AddFieldToEntry()
    Internal::RNTupleProcessorEntry::FieldIndex_t AddFieldToEntry(
-      const std::string &fieldName, const std::string &typeName, void *valuePtr = nullptr,
+      std::string_view fieldName, std::string_view typeName, void *valuePtr = nullptr,
       const Internal::RNTupleProcessorProvenance &provenance = Internal::RNTupleProcessorProvenance()) final;
 
    /////////////////////////////////////////////////////////////////////////////
@@ -826,7 +826,7 @@ private:
    ///
    /// \sa RNTupleProcessor::AddFieldToEntry()
    Internal::RNTupleProcessorEntry::FieldIndex_t AddFieldToEntry(
-      const std::string &fieldName, const std::string &typeName, void *valuePtr = nullptr,
+      std::string_view fieldName, std::string_view typeName, void *valuePtr = nullptr,
       const Internal::RNTupleProcessorProvenance &provenance = Internal::RNTupleProcessorProvenance()) final;
 
    /////////////////////////////////////////////////////////////////////////////

tree/ntuple/inc/ROOT/RNTupleProcessorEntry.hxx

@@ -41,7 +41,7 @@ private:
 
 public:
    RNTupleProcessorProvenance() = default;
-   RNTupleProcessorProvenance(const std::string &provenance) : fProvenance(provenance) {}
+   RNTupleProcessorProvenance(std::string_view provenance) : fProvenance(provenance) {}
 
    /////////////////////////////////////////////////////////////////////////////
    /// \brief Get the full processor provenance, in the form of "x.y.z".
@@ -53,12 +53,12 @@ public:
    /// \param[in] processorName Name of the processor to add.
    ///
    /// \return The updated provenance.
-   RNTupleProcessorProvenance Evolve(const std::string &processorName) const
+   RNTupleProcessorProvenance Evolve(std::string_view processorName) const
    {
       if (fProvenance.empty())
          return RNTupleProcessorProvenance(processorName);
 
-      return RNTupleProcessorProvenance(fProvenance + "." + processorName);
+      return RNTupleProcessorProvenance(fProvenance + "." + std::string(processorName));
    }
 
    /////////////////////////////////////////////////////////////////////////////
@@ -173,7 +173,7 @@ public:
    /// \param[in] provenance Processor provenance of the field.
    ///
    /// \return The field index of the newly added field.
-   FieldIndex_t AddField(const std::string &qualifiedFieldName, std::unique_ptr<ROOT::RFieldBase> field, void *valuePtr,
+   FieldIndex_t AddField(std::string_view qualifiedFieldName, std::unique_ptr<ROOT::RFieldBase> field, void *valuePtr,
                          const RNTupleProcessorProvenance &provenance);
 
    /////////////////////////////////////////////////////////////////////////////

tree/ntuple/inc/ROOT/RNTupleSerialize.hxx

@@ -222,7 +222,7 @@ public:
    static std::uint32_t SerializeUInt64(std::uint64_t val, void *buffer);
    static std::uint32_t DeserializeUInt64(const void *buffer, std::uint64_t &val);
 
-   static std::uint32_t SerializeString(const std::string &val, void *buffer);
+   static std::uint32_t SerializeString(std::string_view val, void *buffer);
    static RResult<std::uint32_t> DeserializeString(const void *buffer, std::uint64_t bufSize, std::string &val);
 
    /// While we could just interpret the enums as ints, we make the translation explicit
@@ -313,7 +313,7 @@ public:
 
    // Helper functions to (de-)serialize the streamer info type extra information
    static std::string SerializeStreamerInfos(const StreamerInfoMap_t &infos);
-   static RResult<StreamerInfoMap_t> DeserializeStreamerInfos(const std::string &extraTypeInfoContent);
+   static RResult<StreamerInfoMap_t> DeserializeStreamerInfos(std::string_view extraTypeInfoContent);
 }; // class RNTupleSerializer
 
 } // namespace Internal