EIC code displayed by LXR master/​include/​root/​ROOT/​RDF/​RDisplay.hxx	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-12-16 10:29:49

 // Author: Enrico Guiraud, Danilo Piparo CERN, Massimo Tumolo Politecnico di Torino  08/2018
 
 /*************************************************************************
  * Copyright (C) 1995-2018, Rene Brun and Fons Rademakers.               *
  * All rights reserved.                                                  *
  *                                                                       *
  * For the licensing terms see $ROOTSYS/LICENSE.                         *
  * For the list of contributors see $ROOTSYS/README/CREDITS.             *
  *************************************************************************/
 
 #ifndef ROOT_RDFDISPLAYER
 #define ROOT_RDFDISPLAYER
 
 #include "ROOT/RDF/Utils.hxx"  // IsDataContainer, InterpreterCalc
 #include "ROOT/RVec.hxx"
 #include "ROOT/TypeTraits.hxx"
 #include "TClassEdit.h"
 
 #include <vector>
 #include <string>
 #include <sstream>
 #include <type_traits>
 
 namespace ROOT {
 namespace Internal {
 namespace RDF {
 
 template<typename T>
 class DisplayHelper;
 std::string PrettyPrintAddr(const void *const addr);
 
 class RDisplayElement {
 private:
    enum class PrintingAction { ToBePrinted, ToBeIgnored, ToBeDotted };
    std::string fRepresentation;
    PrintingAction fPrintingAction;
 
 public:
    RDisplayElement(const std::string &representation);
    RDisplayElement();
    void SetPrint();
    void SetIgnore();
    void SetDots();
    bool IsPrint() const;
    bool IsIgnore() const;
    bool IsDot() const;
    const std::string &GetRepresentation() const;
    bool IsEmpty() const;
 };
 } // namespace RDF
 } // namespace Internal
 
 namespace RDF {
 
 /**
  * \class ROOT::RDF::RDisplay
  * \ingroup dataframe
  * This class is the textual representation of the content of a columnar dataset.
  *
  * This class is provided to the user, and it can be used to print on screen
  * the entries of the dataset requested through the Display action in a compact
  * representation or to return the full representation of the events as a string.
  * In order to apply proper formatting the content is buffered in memory as strings.
  */
 class RDisplay {
    template<typename T>
    friend class ROOT::Internal::RDF::DisplayHelper;
 
 public:
    enum class EPrintFormat {
       kMarkdown,
       kHtml
    };
 
    struct RPrintOptions {
       EPrintFormat fFormat;
    };
 
 private:
    using VecStr_t = std::vector<std::string>;
    using DElement_t = ROOT::Internal::RDF::RDisplayElement;
    static constexpr char fgSeparator = ' '; ///< Spacing used to align the table entries
    static constexpr unsigned fgMaxWidth = 100; ///< Maximum width of the table that Print() displays
 
    VecStr_t fTypes; ///< This attribute stores the type of each column. It is needed by the interpreter to print it.
    std::vector<std::vector<DElement_t>> fTable; ///< String representation of the data to be printed.
    std::vector<unsigned short> fWidths; ///< Tracks the maximum width of each column, based on the largest element.
 
    VecStr_t fRepresentations; ///< Used by the JITted code to store the string representation of the data.
    std::vector<VecStr_t> fCollectionsRepresentations; ///< Used by the JITted code to store the string representation of
                                                       ///< the data in case of collection. Each row corresponds to a
                                                       ///< column, each column to a value of the collection.
 
    size_t fNColumns; ///< Number of columns to be printed
 
    size_t fCurrentRow = 0;    ///< Row that is being filled
    size_t fNextRow = 1;       ///< Next row to be filled.
    size_t fCurrentColumn = 0; ///< Column that is being filled.
 
    size_t fNMaxCollectionElements = 10; // threshold on number of elements in collections to be Print()
 
    ////////////////////////////////////////////////////////////////////////////
    /// Appends a cling::printValue call to the stringstream
    /// This overload works for non-collection data types which are also not
    /// trivially representable as strings.
    /// \tparam T the type of the event to convert
    /// \param[in] stream Where the conversion function call will be chained.
    /// \param[in] element The event to convert to its string representation
    /// \param[in] index To which column the event belongs to
    /// \return false, the event is not a collection
    template <typename T,
              std::enable_if_t<!std::is_arithmetic_v<T> && !ROOT::Internal::RDF::IsDataContainer<T>::value, int> = 0>
    bool AddInterpreterString(std::stringstream &stream, T &element, const int &index)
    {
       stream << "*((std::string*)" << ROOT::Internal::RDF::PrettyPrintAddr(&(fRepresentations[index]))
              << ") = cling::printValue((" << fTypes[index] << "*)" << ROOT::Internal::RDF::PrettyPrintAddr(&element)
              << ");";
       return false;
    }
 
    ////////////////////////////////////////////////////////////////////////////
    /// Appends a string if the T type is an arithmetic type.
    /// This overload works for arithmetic data types that are trivially
    /// convertible to string.
    /// \tparam T the type of the event to convert
    /// \param[in] element The event to convert to its string representation
    /// \param[in] index To which column the event belongs to
    /// \return false, the event is not a collection
    template <typename T, std::enable_if_t<std::is_arithmetic_v<T>, int> = 0>
    bool AddInterpreterString(std::stringstream &, T &element, const int &index)
    {
       // Short-circuit the logic and just insert the string representation of
       // the symple type at the right index.
       fRepresentations[index] = std::to_string(element);
       return false;
    }
 
    ////////////////////////////////////////////////////////////////////////////
    /// Appends a string if the T type is boolean.
    /// \param[in] element The event to convert to its string representation
    /// \param[in] index To which column the event belongs to
    /// \return false, the event is not a collection
    bool AddInterpreterString(std::stringstream &, bool &element, const int &index)
    {
       // Short-circuit the logic and just insert the string representation of
       // the boolean value at the right index.
       fRepresentations[index] = (element ? "true" : "false");
       return false;
    }
 
    ////////////////////////////////////////////////////////////////////////////
    /// Appends collection.size() cling::printValue calls to the stringstream.
    /// \tparam T the type of the event to convert
    /// \param[in] stream Where the conversion function call will be chained.
    /// \param[in] collection The event to convert to its string representation
    /// \param[in] index To which column the event belongs to
    /// \return true, the event is a collection
    /// This function chains a sequence of call to cling::printValue, one for each element of the collection.
    template <typename T, std::enable_if_t<ROOT::Internal::RDF::IsDataContainer<T>::value &&
                                              !std::is_arithmetic_v<typename T::value_type>,
                                           int> = 0>
    bool AddInterpreterString(std::stringstream &stream, T &collection, const int &index)
    {
       size_t collectionSize = std::distance(std::begin(collection), std::end(collection));
       // Prepare the row to contain as many elements as the number of elements in the collection
       fCollectionsRepresentations[index] = VecStr_t(collectionSize);
 
       // Use GetSplit to get the encapsulated type of the collection. For example, GetSplit on
       // std::vector<std::vector<int>> will return std::vector<int>
       VecStr_t output;
       int nestedLoc = 0;
       TClassEdit::GetSplit(fTypes[index].c_str(), output, nestedLoc);
 
       // For each element, append a call and feed the proper type returned by GetSplit
       for (size_t i = 0; i < collectionSize; ++i) {
          stream << "*((std::string*)" << ROOT::Internal::RDF::PrettyPrintAddr(&(fCollectionsRepresentations[index][i]))
                 << ") = cling::printValue((" << output[1] << "*)"
                 << ROOT::Internal::RDF::PrettyPrintAddr(&(collection[i])) << ");";
       }
       return true;
    }
 
    ////////////////////////////////////////////////////////////////////////////
    /// Represent a collection of values as a collection of strings.
    /// \tparam T the type of the event to convert. This must be a collection of
    ///           values of arithmetic type, but not boolean.
    /// \param[in] collection The event to convert to its string representation
    /// \param[in] index To which column the event belongs to
    /// \return true, the event is a collection
    template <typename T, std::enable_if_t<ROOT::Internal::RDF::IsDataContainer<T>::value &&
                                              std::is_arithmetic_v<typename T::value_type> &&
                                              !std::is_same_v<typename T::value_type, bool>,
                                           int> = 0>
    bool AddInterpreterString(std::stringstream &, T &collection, const int &index)
    {
       auto collectionSize = std::distance(std::begin(collection), std::end(collection));
       VecStr_t collectionRepr(collectionSize);
       std::generate(collectionRepr.begin(), collectionRepr.end(), [i = 0, &collection]() mutable {
          auto valRepr = std::to_string(collection[i]);
          i++;
          return valRepr;
       });
       fCollectionsRepresentations[index] = std::move(collectionRepr);
       return true;
    }
 
    ////////////////////////////////////////////////////////////////////////////
    /// Represent a collection of booleans as a collection of strings.
    /// \tparam T the type of the event to convert. This must be a collection of
    ///           boolean values.
    /// \param[in] collection The event to convert to its string representation
    /// \param[in] index To which column the event belongs to
    /// \return true, the event is a collection
    template <typename T, std::enable_if_t<ROOT::Internal::RDF::IsDataContainer<T>::value &&
                                              std::is_same_v<typename T::value_type, bool>,
                                           int> = 0>
    bool AddInterpreterString(std::stringstream &, T &collection, const int &index)
    {
       auto collectionSize = std::distance(std::begin(collection), std::end(collection));
       VecStr_t collectionRepr(collectionSize);
       std::generate(collectionRepr.begin(), collectionRepr.end(), [i = 0, &collection]() mutable {
          auto valRepr = (collection[i] ? "true" : "false");
          i++;
          return valRepr;
       });
       fCollectionsRepresentations[index] = std::move(collectionRepr);
       return true;
    }
 
    ////////////////////////////////////////////////////////////////////////////
    /// AddInterpreterString overload for arrays of chars.
    ///
    /// \param[in] charArr The character array to convert to string representation
    /// \param[in] index To which column the event belongs
    /// \return false, the event is not a collection
    ///
    /// This specialization for arrays of characters skips the cling::printValue
    /// (i.e. appends nothing to the stream) and directly writes to fRepresentations the
    /// string representation of the array of chars.
    bool AddInterpreterString(std::stringstream &, ROOT::RVec<char> &charArr, const int &index)
    {
       // if null-terminated char array, do not copy the null terminator into std::string, it makes columns misaligned.
       const auto length = charArr[charArr.size()-1] == '\0' ? charArr.size() - 1 : charArr.size();
       const std::string arrAsStr(charArr.data(), length); // also works for non-null-terminated strings
       fRepresentations[index] = arrAsStr;
       return false; // do not treat this as a collection
    }
 
    ////////////////////////////////////////////////////////////////////////////
    /// Adds a single element to the next slot in the table
    void AddToRow(const std::string &stringEle);
 
    ////////////////////////////////////////////////////////////////////////////
    /// Adds a collection to the table
    ///
    /// Starting from the slot, the elements are added one under the other, each
    /// one using a single cell of an entire row
    void AddCollectionToRow(const VecStr_t &collection);
 
    ////////////////////////////////////////////////////////////////////////////
    /// Moves to the next cell
    ///
    /// Moves to the next cell, and if the row is full moves to the next row.
    void MovePosition();
 
    ////////////////////////////////////////////////////////////////////////////
    /// Get the number of columns that do NOT fit in the characters limit
    size_t GetNColumnsToShorten() const;
 
    ////////////////////////////////////////////////////////////////////////////
    /// Generate dashes between entries in Print() and AsString() Methods
    std::string DashesBetweenLines(size_t lastColToPrint, bool allColumnsFit) const;
 
    ////////////////////////////////////////////////////////////////////////////
    /// Adds a row of events to the table
    template <typename... Columns>
    void AddRow(Columns &... columns)
    {
       std::stringstream calc; // JITted code
       int columnIndex = 0;
       // Unwrapping the parameters to create the JITted code.
       bool isCollection [] {AddInterpreterString(calc, columns, columnIndex++)...};
 
       // Let cling::printValue handle the conversion. This can be done only through cling-compiled code.
       const std::string toJit = calc.str();
       if (!toJit.empty())
          ROOT::Internal::RDF::InterpreterCalc(calc.str(), "Display");
 
       // Populate the fTable using the results of the JITted code.
       for (size_t i = 0; i < fNColumns; ++i) {
          if (isCollection[i]) {
             AddCollectionToRow(fCollectionsRepresentations[i]);
          } else {
             AddToRow(fRepresentations[i]);
          }
       }
    }
 
    void EnsureCurrentColumnWidth(size_t w);
 
    std::string AsStringInternal(bool considerDots, const RPrintOptions &options = {EPrintFormat::kMarkdown}) const;
    std::string AsStringMarkdown(bool considerDots) const;
    std::string AsStringHtml() const;
 
 public:
    ////////////////////////////////////////////////////////////////////////////
    /// Creates an RDisplay to print the event values
    /// \param[in] columnNames Columns to print
    /// \param[in] types The type of each column
    /// \param[in] nMaxCollectionElements Number of maximum elements in collection.
    RDisplay(const VecStr_t &columnNames, const VecStr_t &types, size_t nMaxCollectionElements);
 
    ////////////////////////////////////////////////////////////////////////////
    /// Prints the representation to the standard output
    ///
    /// Collections are shortened to the first and last element. The overall width
    /// is shortened to a fixed number of columns that should fit the screen width.
    void Print(const RPrintOptions &options = {EPrintFormat::kMarkdown}) const;
 
    ////////////////////////////////////////////////////////////////////////////
    /// Returns the representation as a string
    std::string AsString(const RPrintOptions &options = {EPrintFormat::kMarkdown}) const;
 };
 
 } // namespace RDF
 } // namespace ROOT
 
 #endif

This page was automatically generated by the 2.3.7 LXR engine. The LXR team