11#ifndef ROOT_RRESULTPTR
12#define ROOT_RRESULTPTR
29namespace Experimental {
37template <
typename Proxied,
typename DataSource>
57 std::shared_ptr<T> copiedResult{
new T{*inptr.
fObjPtr}};
59 inptr.
fActionPtr->CloneAction(
reinterpret_cast<void *
>(&copiedResult)));
83RResultPtr<T>
MakeResultPtr(
const std::shared_ptr<T> &
r, RLoopManager &df,
84 std::shared_ptr<ROOT::Internal::RDF::RActionBase> actionPtr);
124 template <
typename T1>
127 template <
typename T1>
129 std::shared_ptr<RDFInternal::RActionBase>);
131 template <
typename T1>
134 template <
class T1,
class T2>
136 template <
class T1,
class T2>
146 friend std::unique_ptr<RDFDetail::RMergeableValue<T>> RDFDetail::GetMergeableValue<T>(
RResultPtr<T> &rptr);
155 const std::string &outputFileName);
157 template <typename V, bool hasBeginEnd = TTraits::HasBeginAndEnd<V>::value>
158 struct RIterationHelper {
159 using Iterator_t = void;
160 void GetBegin(
const V &) {
static_assert(
sizeof(V) == 0,
"It does not make sense to ask begin for this class."); }
161 void GetEnd(
const V &) {
static_assert(
sizeof(V) == 0,
"It does not make sense to ask end for this class."); }
164 template <
typename V>
165 struct RIterationHelper<V, true> {
166 using Iterator_t =
decltype(std::begin(std::declval<V>()));
167 static Iterator_t GetBegin(
const V &
v) {
return std::begin(
v); };
168 static Iterator_t GetEnd(
const V &
v) {
return std::end(
v); };
196 throw std::runtime_error(
"Trying to access the contents of a null RResultPtr.");
200 std::shared_ptr<RDFInternal::RActionBase> actionPtr)
220 template <
typename T2,
221 std::enable_if_t<std::is_constructible<std::shared_ptr<T>, std::shared_ptr<T2>>
::value,
int> = 0>
257 typename RIterationHelper<T>::Iterator_t
begin()
262 return RIterationHelper<T>::GetBegin(*
fObjPtr);
267 typename RIterationHelper<T>::Iterator_t
end()
272 return RIterationHelper<T>::GetEnd(*
fObjPtr);
323 auto c = [nSlots, actionPtr, callback](
unsigned int slot) {
324 if (slot != nSlots - 1)
326 auto partialResult =
static_cast<Value_t *
>(actionPtr->PartialUpdate(slot));
327 callback(*partialResult);
368 auto c = [actionPtr, callback](
unsigned int slot) {
369 auto partialResult =
static_cast<Value_t *
>(actionPtr->PartialUpdate(slot));
370 callback(slot, *partialResult);
400template <
class T1,
class T2>
406template <
class T1,
class T2>
475 return std::unique_ptr<RMergeableValue<T>>{
unsigned long long ULong64_t
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t r
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void value
The head node of a RDF computation graph.
void Run(bool jit=true)
Start the event loop with a different mechanism depending on IMT/no IMT, data source/no data source.
unsigned int GetNSlots() const
void RegisterCallback(ULong64_t everyNEvents, std::function< void(unsigned int)> &&f)
A result of an RDataFrame execution, that knows how to merge with other results of the same type.
Helper class that provides the operation graph nodes.
A type-erased version of RResultPtr and RResultMap.
Smart pointer for the return type of actions.
bool IsReady() const
Check whether the result has already been computed.
void TriggerRun()
Triggers the event loop in the RLoopManager.
RResultPtr(RResultPtr &&)=default
T * GetPtr()
Get the pointer to the encapsulated object.
RResultPtr< T > & OnPartialResult(ULong64_t everyNEvents, std::function< void(T &)> callback)
Register a callback that RDataFrame will execute "everyNEvents" on a partial result.
RDFDetail::RLoopManager * fLoopManager
Non-owning pointer to the RLoopManager at the root of this computation graph.
friend bool operator!=(const RResultPtr< T1 > &lhs, const RResultPtr< T2 > &rhs)
RIterationHelper< T >::Iterator_t begin()
Return an iterator to the beginning of the contained object if this makes sense, throw a compilation ...
T Value_t
Convenience alias to simplify access to proxied type.
T * Get()
Get the pointer to the encapsulated result.
const T & GetValue()
Get a const reference to the encapsulated object.
RResultPtr(const RResultPtr &)=default
T & operator*()
Get a pointer to the encapsulated object.
RResultPtr & operator=(const RResultPtr &)=default
RResultPtr< T > & OnPartialResultSlot(ULong64_t everyNEvents, std::function< void(unsigned int, T &)> callback)
Register a callback that RDataFrame will execute in each worker thread concurrently on that thread's ...
RResultPtr & operator=(RResultPtr &&)=default
friend bool operator==(const RResultPtr< T1 > &lhs, const RResultPtr< T2 > &rhs)
RResultPtr(const RResultPtr< T2 > &r)
Convert a RResultPtr<T2> to a RResultPtr<T>.
std::shared_ptr< RDFInternal::RActionBase > fActionPtr
Owning pointer to the action that will produce this result.
std::shared_ptr< T > SPT_t
T * operator->()
Get a pointer to the encapsulated object.
SPT_t fObjPtr
Shared pointer encapsulating the wrapped result.
static constexpr ULong64_t kOnce
Convenience definition to express a callback must be executed once.
RResultPtr(std::shared_ptr< T > objPtr, RDFDetail::RLoopManager *lm, std::shared_ptr< RDFInternal::RActionBase > actionPtr)
RIterationHelper< T >::Iterator_t end()
Return an iterator to the end of the contained object if this makes sense, throw a compilation error ...
std::unique_ptr< RMergeableVariations< T > > GetMergeableValue(ROOT::RDF::Experimental::RResultMap< T > &rmap)
Retrieve mergeable values after calling ROOT::RDF::VariationsFor .
RResultPtr< T > MakeResultPtr(const std::shared_ptr< T > &r, RLoopManager &df, std::shared_ptr< ROOT::Internal::RDF::RActionBase > actionPtr)
Create a RResultPtr and set its pointer to the corresponding RAction This overload is invoked by non-...
ROOT::RDF::Experimental::RResultMap< T > CloneResultAndAction(const ROOT::RDF::Experimental::RResultMap< T > &inmap)
Clones an RResultMap and its corresponding RVariedAction.
RResultMap< T > VariationsFor(RResultPtr< T > resPtr)
Produce all required systematic variations for the given result.
bool operator!=(const RResultPtr< T1 > &lhs, const RResultPtr< T2 > &rhs)
bool operator==(const RResultPtr< T1 > &lhs, const RResultPtr< T2 > &rhs)
ROOT type_traits extensions.
This file contains a specialised ROOT message handler to test for diagnostic in unit tests.