[df] Remove DataSource template argument of RInterface

It was added by commit e0b0d16 / pull request #1939 in 2018:
> This will allow, in the future, to optimize loading of entries
> from TDataSources: GetColumnReaders does not have to pass through
> virtual calls to TDataSource anymore, which means that concrete
> TDS's can provide custom, possibly lazy column readers which
> TInterface will use directly.

This was never implemented and the template argument is currently
unused, so remove it.

Author: hahnjo

tree/dataframe/inc/ROOT/RDF/GraphUtils.hxx

@@ -80,8 +80,8 @@ public:
 
    ////////////////////////////////////////////////////////////////////////////
    /// \brief Starting from a Filter or Range, prints the branch it belongs to
-   template <typename Proxied, typename DataSource>
-   std::string RepresentGraph(ROOT::RDF::RInterface<Proxied, DataSource> &rInterface)
+   template <typename Proxied>
+   std::string RepresentGraph(ROOT::RDF::RInterface<Proxied> &rInterface)
    {
       auto loopManager = rInterface.GetLoopManager();
       loopManager->Jit();

tree/dataframe/inc/ROOT/RDF/InterfaceUtils.hxx

@@ -49,9 +49,9 @@ class RNodeBase;
 }
 }
 namespace RDF {
-template<typename T, typename V>
+template <typename Proxied>
 class RInterface;
-using RNode = RInterface<::ROOT::Detail::RDF::RNodeBase, void>;
+using RNode = RInterface<::ROOT::Detail::RDF::RNodeBase>;
 } // namespace RDF
 
 } // namespace ROOT

tree/dataframe/inc/ROOT/RDF/RInterface.hxx

@@ -51,8 +51,8 @@ namespace Experimental {
 
  The RMetaData object is passed to an RSample object which represents a single dataset sample.
 
- A dataframe built with the RMetaData object can be accessed with the \ref ROOT::RDF::RInterface< Proxied,
-DS_t>::DefinePerSample "DefinePerSample()" method.
+ A dataframe built with the RMetaData object can be accessed with the
+ \ref ROOT::RDF::RInterface<Proxied>::DefinePerSample "DefinePerSample()" method.
 **/
 class RMetaData {
    friend void ROOT::Internal::RDF::ImportJSON(ROOT::RDF::Experimental::RMetaData &, const std::string &jsonString);

tree/dataframe/inc/ROOT/RDF/RMetaData.hxx

@@ -25,7 +25,7 @@ namespace ROOT {
 namespace RDF {
 
 /// This type represents a sample identifier, to be used in conjunction with RDataFrame features such as
-/// \ref ROOT::RDF::RInterface< Proxied, DS_t >::DefinePerSample "DefinePerSample()" and per-sample callbacks.
+/// \ref ROOT::RDF::RInterface<Proxied>::DefinePerSample "DefinePerSample()" and per-sample callbacks.
 ///
 /// When the input data comes from a TTree, the string representation of RSampleInfo (which is returned by AsString()
 /// and that can be queried e.g. with Contains()) is of the form "<filename>/<treename>".
@@ -129,8 +129,8 @@ public:
 };
 
 /// The type of a data-block callback, registered with an RDataFrame computation graph via e.g.  \ref
-/// ROOT::RDF::RInterface< Proxied, DS_t >::DefinePerSample "DefinePerSample()" or by certain actions (e.g. \ref
-/// ROOT::RDF::RInterface<Proxied,DataSource>::Snapshot "Snapshot()").
+/// ROOT::RDF::RInterface<Proxied>::DefinePerSample "DefinePerSample()" or by certain actions (e.g. \ref
+/// ROOT::RDF::RInterface<Proxied>::Snapshot "Snapshot()").
 using SampleCallback_t = std::function<void(unsigned int, const ROOT::RDF::RSampleInfo &)>;
 
 } // namespace RDF

tree/dataframe/inc/ROOT/RDF/RSampleInfo.hxx

@@ -222,7 +222,7 @@ namespace Experimental {
 template <typename T>
 RResultMap<T> VariationsFor(RResultPtr<T> resPtr)
 {
-   using SnapshotResult_t = ROOT::RDF::RInterface<ROOT::Detail::RDF::RLoopManager, void>;
+   using SnapshotResult_t = ROOT::RDF::RInterface<ROOT::Detail::RDF::RLoopManager>;
    static_assert(!std::is_same_v<T, SnapshotResult_t>,
                  "Snapshot with variations can only be enabled via RSnapshotOptions.");
 

tree/dataframe/inc/ROOT/RDFHelpers.hxx

@@ -34,7 +34,7 @@ template <typename T>
 RResultMap<T> VariationsFor(RResultPtr<T> resPtr);
 } // namespace Experimental
 
-template <typename Proxied, typename DataSource>
+template <typename Proxied>
 class RInterface;
 } // namespace RDF
 
@@ -59,7 +59,7 @@ ROOT::RDF::RResultPtr<T> CloneResultAndAction(const ROOT::RDF::RResultPtr<T> &in
                                    inptr.fActionPtr->CloneAction(reinterpret_cast<void *>(&copiedResult)));
 }
 
-using SnapshotPtr_t = ROOT::RDF::RResultPtr<ROOT::RDF::RInterface<ROOT::Detail::RDF::RLoopManager, void>>;
+using SnapshotPtr_t = ROOT::RDF::RResultPtr<ROOT::RDF::RInterface<ROOT::Detail::RDF::RLoopManager>>;
 /**
  * \brief Creates a new RResultPtr with a cloned Snapshot action.
  *

tree/dataframe/inc/ROOT/RResultPtr.hxx

@@ -948,13 +948,13 @@ TEST(RDFSnapshotMore, LazyNotTriggered)
                        "storing its result in a variable and for example calling the GetValue() method on it.");
 }
 
-RResultPtr<RInterface<RLoopManager, void>> ReturnLazySnapshot(const char *fname)
+RResultPtr<RInterface<RLoopManager>> ReturnLazySnapshot(const char *fname)
 {
    auto d = ROOT::RDataFrame(1);
    ROOT::RDF::RSnapshotOptions opts;
    opts.fLazy = true;
    auto res = d.Snapshot("t", fname, {"rdfentry_"}, opts);
-   RResultPtr<RInterface<RLoopManager, void>> res2 = res;
+   RResultPtr<RInterface<RLoopManager>> res2 = res;
    return res;
 }