CondContBase::Compare Struct Reference

Comparison object needed by ConcurrentRangeMap. More...

#include <CondCont.h>

Collaboration diagram for CondContBase::Compare:

Public Member Functions
bool	operator() (const RangeKey &r1, const RangeKey &r2) const
bool	operator() (key_type t, const RangeKey &r2) const
bool	inRange (key_type t, const RangeKey &r) const
int	overlap (const EventContext &ctx, const RangeKey &oldRange, RangeKey &newRange) const
	Test if two ranges overlap, and adjust if needed.
int	extendRange (RangeKey &range, const RangeKey &newRange) const
	Possibly extend an existing range at the end.

Detailed Description

Comparison object needed by ConcurrentRangeMap.

Definition at line 449 of file CondCont.h.

Member Function Documentation

extendRange()

int CondContBase::Compare::extendRange	(	RangeKey &	range,
		const RangeKey &	newRange ) const

Possibly extend an existing range at the end.

Parameters

range	THe existing range.
newRange	Range being added.

Returns one of: 0 – no change was made to RANGE. 1 – RANGE was extended. -1 – newRange is a duplicate.

Definition at line 158 of file CondCont.cxx.

{
  //      |--- range ---|
  //  |--- newRange ....
  if (newRange.m_start < range.m_start) {
    return 0;
  }
 
  //      |--- range ---|
  //                         |--- newRange ....
  if (newRange.m_start > range.m_stop) {
    return 0;
  }
 
  //      |--- range ----------------|
  //         |--- newRange ---|
  if (newRange.m_stop <= range.m_stop) {
    return -1;
  }
 
  //      |--- range ----|
  //         |--- newRange ---|
  range.m_stop = newRange.m_stop;
  range.m_range = EventIDRange (range.m_range.start(),
                                newRange.m_range.stop());
  return 1;
}

inRange()

bool CondContBase::Compare::inRange ( key_type t, const RangeKey & r ) const

inline

Definition at line 455 of file CondCont.h.

    {
      return t >= r.m_start && t< r.m_stop;
    }

operator()() [1/2]

bool CondContBase::Compare::operator() ( const RangeKey & r1, const RangeKey & r2 ) const

inline

Definition at line 451 of file CondCont.h.

    { return r1.m_start < r2.m_start; }

operator()() [2/2]

bool CondContBase::Compare::operator() ( key_type t, const RangeKey & r2 ) const

inline

Definition at line 453 of file CondCont.h.

    { return t < r2.m_start; }

overlap()

int CondContBase::Compare::overlap	(	const EventContext &	ctx,
		const RangeKey &	oldRange,
		RangeKey &	newRange ) const

Test if two ranges overlap, and adjust if needed.

Parameters

ctx	Event context passed to emplace().
oldRange	An existing range in the container.
newRange	New range being added.

Returns one of: 0 – no overlap between the ranges; NEWRANGE is unmodified. 1 – ranges overlap. NEWRANGE has been adjusted to avoid the overlap. If the start of NEWRANGE is changed, it must only be moved forward (increased), never backwards. -1 – duplicate: NEWRANGE is entirely inside OLDRANGE. Delete the new range.

Definition at line 39 of file CondCont.cxx.

{
  //                              |--- oldRange ---|
  //  |--- newRange ---|
  if (newRange.m_stop <= oldRange.m_start) {
    return 0;
  }
        
  //  |--- oldRange ---|
  //                        |--- newRange ---|
  if (oldRange.m_stop <= newRange.m_start) {
    return 0;
  }
 
  //   |---     oldRange    ---|
  //      |--- newRange ---|
  if (newRange.m_start >= oldRange.m_start &&
      newRange.m_stop <= oldRange.m_stop)
  {
    return -1;
  }
 
  // Current IOV key.
  key_type cur;
  if (newRange.m_range.start().isTimeStamp()) {
    cur = keyFromTimestamp (ctx.eventID());
  }
  else {
    EventIDBase eid = ctx.eventID();
    if (ctx.hasExtension()) {
      EventIDBase::number_type conditionsRun =
        Atlas::getExtendedEventContext (ctx).conditionsRun();
      if (conditionsRun != EventIDBase::UNDEFNUM) {
        eid.set_run_number (conditionsRun);
      }
    }
    cur = keyFromRunLBN (eid);
  }
 
  // Either this:
  //      |---     oldRange    ---|
  //                 |--- newRange ---|
  //
  // Or this
  //      |---     oldRange    ---|
  //  |---               newRange ---|
  //  with the current IOV key after the end of oldRange.
  //
  // In either case, we start the start of newRange to the end of oldRange.
  if (newRange.m_stop > oldRange.m_stop &&
      (newRange.m_start >= oldRange.m_start ||
       cur > oldRange.m_stop))
  {
    newRange.m_start = oldRange.m_stop;
    if (oldRange.m_range.stop().isTimeStamp()) {
      // If this is a mixed key, we need to copy only the timestamp part.
      EventIDBase oldId = oldRange.m_range.stop();
      EventIDBase newId = newRange.m_range.start();
      newRange.m_range = EventIDRange (EventIDBase (newId.run_number(),
                                                    newId.event_number(),
                                                    oldId.time_stamp(),
                                                    oldId.time_stamp_ns_offset(),
                                                    newId.lumi_block(),
                                                    newId.bunch_crossing_id()),
                                       newRange.m_range.stop());
    }
    else {
      newRange.m_range = EventIDRange (oldRange.m_range.stop(),
                                       newRange.m_range.stop());
    }
  }
 
 
  //              |---     oldRange    ---|
  //      |--- newRange  ---|
  else if (newRange.m_start < oldRange.m_start &&
           newRange.m_stop > oldRange.m_start)
  {
    // Change the end of newRange to the start of oldRange.
    newRange.m_stop = oldRange.m_start;
    if (oldRange.m_range.start().isTimeStamp()) {
      // If this is a mixed key, we need to copy only the timestamp part.
      EventIDBase oldId = oldRange.m_range.start();
      EventIDBase newId = newRange.m_range.stop();
      newRange.m_range = EventIDRange (newRange.m_range.start(),
                                       EventIDBase (newId.run_number(),
                                                    newId.event_number(),
                                                    oldId.time_stamp(),
                                                    oldId.time_stamp_ns_offset(),
                                                    newId.lumi_block(),
                                                    newId.bunch_crossing_id()));
    }
    else {
      newRange.m_range = EventIDRange (newRange.m_range.start(),
                                       oldRange.m_range.start());
    }
  }
 
  // Should have handled all cases by now!
  else {
    std::abort();
  }
 
  return 1;
}

---

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

• CondCont.h
• CondCont.cxx