#include <RangeSet.h>

Public Types
using	const_iterator = std::vector< EventRange >::const_iterator

Public Member Functions
	~RangeSet ()

	RangeSet ()

	RangeSet (RunNumber_t)

	RangeSet (RunNumber_t, std::vector< EventRange > const &eventRanges)

	RangeSet (RangeSet const &)

	RangeSet (RangeSet &&)

RangeSet &	operator= (RangeSet const &)

RangeSet &	operator= (RangeSet &&)

RunNumber_t	run () const

std::vector< EventRange > const &	ranges () const

bool	contains (RunNumber_t, SubRunNumber_t, EventNumber_t) const

bool	is_valid () const

bool	is_full_run () const

bool	is_full_subRun () const

bool	is_sorted () const

bool	is_collapsed () const

std::string	to_compact_string () const

bool	has_disjoint_ranges () const

bool	empty () const

const_iterator	begin () const

const_iterator	end () const

std::size_t	begin_idx () const

std::size_t	end_idx () const

unsigned	checksum () const

std::size_t	next_subrun_or_end (std::size_t const b) const

EventRange &	front ()

EventRange &	back ()

EventRange &	at (std::size_t)

std::vector< EventRange >	extract_ranges (std::size_t const b, std::size_t const e)

void	assign_ranges (RangeSet const &rs, std::size_t const b, std::size_t const e)

void	update (EventID const &)

template<typename... ARGS>
void	emplace_range (ARGS &&...)

RangeSet &	collapse ()

RangeSet &	merge (RangeSet const &other)

std::pair< std::size_t, bool >	split_range (SubRunNumber_t, EventNumber_t)

void	set_run (RunNumber_t const r)

void	sort ()

void	clear ()

template<typename... ARGS>
void	emplace_range (ARGS &&...args)

Static Public Member Functions
static constexpr unsigned	invalidChecksum ()

static RangeSet	invalid ()

static RangeSet	forRun (RunID)

static RangeSet	forSubRun (SubRunID)

Private Member Functions
void	require_not_full_run ()

Private Attributes
RunNumber_t	run_ {IDNumber<Level::Run>::invalid()}

std::vector< EventRange >	ranges_ {}

bool	isCollapsed_ {false}

unsigned	checksum_ {invalidChecksum()}

Detailed Description

Definition at line 25 of file RangeSet.h.

Member Typedef Documentation

using art::RangeSet::const_iterator = std::vector<EventRange>::const_iterator

Definition at line 28 of file RangeSet.h.

Constructor & Destructor Documentation

art::RangeSet::~RangeSet ( )

default

art::RangeSet::RangeSet ( )

explicitdefault

art::RangeSet::RangeSet ( RunNumber_t r )

explicit

Definition at line 71 of file RangeSet.cc.

71 : RangeSet{r, {}} {}

art::RangeSet::RangeSet

RangeSet()

plot_model.r

r

Definition: plot_model.py:57

art::RangeSet::RangeSet	(	RunNumber_t	r,
		std::vector< EventRange > const &	eventRanges
	)

explicit

Definition at line 73 of file RangeSet.cc.

     : run_{r}, ranges_{eventRanges}
   {
     sort();
     collapse();
   }

art::RangeSet::RangeSet ( RangeSet const & )

default

art::RangeSet::RangeSet ( RangeSet && )

default

Member Function Documentation

void art::RangeSet::assign_ranges	(	RangeSet const &	rs,
		std::size_t const	b,
		std::size_t const	e
	)

Definition at line 317 of file RangeSet.cc.

   {
     require_not_full_run();
     if (!rs.ranges_.empty() && (e >= 1) && (e <= rs.ranges_.size())) {
       ranges_.assign(rs.ranges_.cbegin() + b, rs.ranges_.cbegin() + e);
     }
   }

EventRange & art::RangeSet::at ( std::size_t )

Definition at line 246 of file RangeSet.cc.

   {
     return ranges_.at(idx);
   }

EventRange & art::RangeSet::back ( )

Definition at line 240 of file RangeSet.cc.

   {
     return ranges_.back();
   }

RangeSet::const_iterator art::RangeSet::begin ( ) const

Definition at line 201 of file RangeSet.cc.

   {
     return ranges_.cbegin();
   }

size_t art::RangeSet::begin_idx ( ) const

Definition at line 189 of file RangeSet.cc.

   {
     return 0;
   }

unsigned art::RangeSet::checksum ( ) const

Definition at line 213 of file RangeSet.cc.

   {
     // Could cache checksums to improve performance when necessary.
     return checksum_ = cet::crc32{to_compact_string()}.digest();
   }

void art::RangeSet::clear ( )

Definition at line 384 of file RangeSet.cc.

   {
     ranges_.clear();
   }

RangeSet & art::RangeSet::collapse ( )

Definition at line 262 of file RangeSet.cc.

   {
     if (isCollapsed_) {
       return *this;
     }
     if (ranges_.size() < 2) {
       isCollapsed_ = true;
       return *this;
     }
     if (!is_sorted())
       throw art::Exception(art::errors::LogicError, "RangeSet::collapse()")
         << "A range set must be sorted before it is collapsed.\n";
 
     auto processing = ranges_;
     decltype(ranges_) result;
     result.reserve(ranges_.size());
     result.push_back(ranges_.front());
     for (auto ir = ranges_.cbegin() + 1, e = ranges_.cend(); ir != e; ++ir) {
       auto const& r = *ir;
       auto& back = result.back();
       if (back.is_adjacent(r)) {
         back.merge(r);
       } else {
         throw_if_not_disjoint(run_, back, r);
         result.push_back(r);
       }
     }
     std::swap(ranges_, result);
     isCollapsed_ = true;
     return *this;
   }

bool art::RangeSet::contains	(	RunNumber_t	r,
		SubRunNumber_t	s,
		EventNumber_t	e
	)		const

Definition at line 101 of file RangeSet.cc.

   {
     if (run_ != r) {
       return false;
     }
     for (auto const& range : ranges_) {
       if (range.contains(s, e)) {
         return true;
       }
     }
     return false;
   }

template<typename... ARGS>

void art::RangeSet::emplace_range ( ARGS && ... )

template<typename... ARGS>

void art::RangeSet::emplace_range ( ARGS &&... args )

Definition at line 120 of file RangeSet.h.

   {
     require_not_full_run();
     ranges_.emplace_back(std::forward<ARGS>(args)...);
     isCollapsed_ = false;
   }

bool art::RangeSet::empty ( ) const

Definition at line 179 of file RangeSet.cc.

   {
     for (auto const& range : ranges_) {
       if (!range.empty())
         return false;
     }
     return true;
   }

RangeSet::const_iterator art::RangeSet::end ( ) const

Definition at line 207 of file RangeSet.cc.

   {
     return ranges_.cend();
   }

size_t art::RangeSet::end_idx ( ) const

Definition at line 195 of file RangeSet.cc.

   {
     return static_cast<size_t>(ranges_.cend() - ranges_.cbegin());
   }

vector< EventRange > art::RangeSet::extract_ranges	(	std::size_t const	b,
		std::size_t const	e
	)

Definition at line 252 of file RangeSet.cc.

   {
     vector<EventRange> result;
     if (!ranges_.empty() && (e >= 1) && (e <= ranges_.size())) {
       copy(ranges_.cbegin() + b, ranges_.cbegin() + e, back_inserter(result));
     }
     return result;
   }

RangeSet art::RangeSet::forRun ( RunID rid )

static

Definition at line 51 of file RangeSet.cc.

   {
     return RangeSet{rid.run(), {detail::full_run_event_range()}};
   }

RangeSet art::RangeSet::forSubRun ( SubRunID srid )

static

Definition at line 57 of file RangeSet.cc.

   {
     return RangeSet{srid.run(), {EventRange::forSubRun(srid.subRun())}};
   }

EventRange & art::RangeSet::front ( )

Definition at line 234 of file RangeSet.cc.

   {
     return ranges_.front();
   }

bool art::RangeSet::has_disjoint_ranges ( ) const

Definition at line 167 of file RangeSet.cc.

   {
     if (isCollapsed_ || is_sorted()) {
       return (ranges_.size() < 2ull) ? true : disjoint(ranges_);
     }
     RangeSet tmp{*this};
     tmp.sort();
     tmp.collapse();
     return tmp.has_disjoint_ranges();
   }

RangeSet art::RangeSet::invalid ( )

static

Definition at line 45 of file RangeSet.cc.

   {
     return RangeSet{};
   }

static constexpr unsigned art::RangeSet::invalidChecksum ( )

inlinestatic

Definition at line 32 of file RangeSet.h.

     {
       return std::numeric_limits<unsigned>::max();
     }

bool art::RangeSet::is_collapsed ( ) const

Definition at line 142 of file RangeSet.cc.

   {
     return isCollapsed_;
   }

bool art::RangeSet::is_full_run ( ) const

Definition at line 123 of file RangeSet.cc.

   {
     return ranges_.size() == 1ull &&
            ranges_.front() == detail::full_run_event_range();
   }

bool art::RangeSet::is_full_subRun ( ) const

Definition at line 130 of file RangeSet.cc.

   {
     return (ranges_.size() == 1ull) && ranges_.front().is_full_subRun();
   }

bool art::RangeSet::is_sorted ( ) const

Definition at line 136 of file RangeSet.cc.

   {
     return std::is_sorted(ranges_.cbegin(), ranges_.cend());
   }

bool art::RangeSet::is_valid ( ) const

Definition at line 117 of file RangeSet.cc.

   {
     return run_ != IDNumber<Level::Run>::invalid();
   }

RangeSet & art::RangeSet::merge ( RangeSet const & other )

Definition at line 295 of file RangeSet.cc.

   {
     if (!other.is_valid()) {
       return *this;
     }
     if (!is_valid()) {
       run_ = other.run();
     }
     vector<EventRange> merged;
     std::merge(ranges_.cbegin(),
                ranges_.cend(),
                other.ranges_.cbegin(),
                other.ranges_.cend(),
                back_inserter(merged));
     unique(merged.begin(), merged.end());
     std::swap(ranges_, merged);
     isCollapsed_ = false;
     collapse();
     return *this;
   }

size_t art::RangeSet::next_subrun_or_end ( std::size_t const b ) const

Definition at line 220 of file RangeSet.cc.

   {
     if (b == end_idx()) {
       return end_idx();
     }
     auto const sr = ranges_.at(b).subRun();
     auto pos =
       find_if(ranges_.cbegin() + b, ranges_.cend(), [sr](auto const& range) {
         return range.subRun() != sr;
       });
     return static_cast<size_t>(pos - ranges_.cbegin());
   }

RangeSet & art::RangeSet::operator= ( RangeSet const & )

default

RangeSet & art::RangeSet::operator= ( RangeSet && )

default

vector< EventRange > const & art::RangeSet::ranges ( ) const

Definition at line 95 of file RangeSet.cc.

   {
     return ranges_;
   }

void art::RangeSet::require_not_full_run ( )

private

Definition at line 390 of file RangeSet.cc.

   {
     if (is_full_run()) {
       throw Exception(errors::LogicError, "RangeSet::require_not_full_run")
         << "\nA RangeSet created using RangeSet::forRun cannot be modified.\n";
     }
   }

RunNumber_t art::RangeSet::run ( ) const

Definition at line 89 of file RangeSet.cc.

   {
     return run_;
   }

void art::RangeSet::set_run ( RunNumber_t const r )

Definition at line 372 of file RangeSet.cc.

   {
     run_ = r;
   }

void art::RangeSet::sort ( )

Definition at line 378 of file RangeSet.cc.

   {
     cet::sort_all(ranges_);
   }

pair< std::size_t, bool > art::RangeSet::split_range	(	SubRunNumber_t	s,
		EventNumber_t	e
	)

Definition at line 345 of file RangeSet.cc.

   {
     require_not_full_run();
     bool did_split = false;
     auto result = ranges_.end();
     auto foundRange =
       find_if(ranges_.cbegin(), ranges_.cend(), [s, e](auto const& r) {
         return r.contains(s, e);
       });
     // Split only if:
     // - the range is found (i.e. the event is contained by the found range)
     // - the range is valid
     // - the size of the range is greater than 1
     if ((foundRange != ranges_.cend()) && foundRange->is_valid() &&
         (foundRange->size() > 1ull)) {
       auto const begin = foundRange->begin();
       auto const end = foundRange->end();
       auto leftIt = ranges_.emplace(foundRange, s, begin, e);
       result = next(leftIt);
       EventRange right{s, e, end};
       std::swap(*result, right);
       did_split = true;
     }
     return make_pair(static_cast<size_t>(result - ranges_.cbegin()), did_split);
   }

string art::RangeSet::to_compact_string ( ) const

Definition at line 148 of file RangeSet.cc.

   {
     using namespace std;
     string s{to_string(run_)};
     if (!ranges_.empty()) {
       s += ":";
     }
     for (auto const& r : ranges_) {
       s += to_string(r.subRun());
       s += "[";
       s += to_string(r.begin());
       s += ",";
       s += to_string(r.end());
       s += ")";
     }
     return s;
   }

void art::RangeSet::update ( EventID const & id )

Definition at line 326 of file RangeSet.cc.

   {
     require_not_full_run();
     if (ranges_.empty()) {
       run_ = id.run();
       ranges_.emplace_back(id.subRun(), id.event(), id.next().event());
       return;
     }
     auto& back = ranges_.back();
     if (back.subRun() == id.subRun() && back.end() == id.event()) {
       back.set_end(id.next().event());
     } else {
       ranges_.emplace_back(id.subRun(), id.event(), id.next().event());
     }
   }

Member Data Documentation

unsigned art::RangeSet::checksum_ {invalidChecksum()}

mutableprivate

Definition at line 115 of file RangeSet.h.

bool art::RangeSet::isCollapsed_ {false}

private

Definition at line 114 of file RangeSet.h.

std::vector<EventRange> art::RangeSet::ranges_ {}

private

Definition at line 111 of file RangeSet.h.

RunNumber_t art::RangeSet::run_ {IDNumber<Level::Run>::invalid()}

private

Definition at line 110 of file RangeSet.h.

The documentation for this class was generated from the following files:

canvas/canvas/Persistency/Provenance/RangeSet.h
canvas/canvas/Persistency/Provenance/RangeSet.cc

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation