index.cpp

Go to the documentation of this file.

// DUNE DAQ modification notice:
// This file has been modified from the original ATLAS oks source for the DUNE DAQ project.
// Fork baseline commit: oks-08-03-04 (2022-04-14).
// Renamed since fork: no.
 
#define _OksBuildDll_
 
#include "oks/index.hpp"
#include "oks/attribute.hpp"
#include "oks/class.hpp"
 
namespace dunedaq {
namespace oks {
 
size_t
OksIndex::get_offset(OksClass *cl, OksAttribute *a)
{
  OksDataInfo::Map::const_iterator x = cl->p_data_info->find(a->p_name);
  return (x == cl->p_data_info->end()) ? 0 : x->second->offset;
}
 
 
OksIndex::OksIndex(OksClass *cl, OksAttribute *attr) :
  std::multiset<OksObject *, OksObjectSortBy> (get_offset(cl, attr)),
  c (cl),
  a (attr)
{
  const char * fname = "OksIndex::OksIndex(OksClass *, OksAttribute *";
 
  if(!c) {
    Oks::error_msg(fname) << "Can't build index for NIL class\n";
    return;
  }
  
  if(c->get_is_abstract()) {
    Oks::error_msg(fname)
      << "Can't build index for ABSTRACT class \"" << c->get_name() << "\"\n";
    return;
  }
 
  if(!a) {
    Oks::error_msg(fname) << "Can't build index for NIL attribute\n";
    return;
  }
 
  if(c->find_attribute(a->get_name()) == 0) {
    Oks::error_msg(fname)
      << "Can't find attribute \"" << a->p_name << "\" in class \""
      << c->get_name() << "\" to build index.\n";
    return;
  }
 
  if(c->p_indices && c->p_indices->find(a) != c->p_indices->end()) {
    Oks::error_msg(fname)
      << "Class \"" << c->get_name() << "\" already has index for attribute \""
      << a->p_name << "\".\n";
    return;
  }
 
  offset = ((*c->p_data_info)[a->p_name])->offset;
 
  if(!c->p_indices)
    c->p_indices = new OksIndex::Map();
 
  (*c->p_indices)[a] = this;
 
  if(c->p_objects && !c->p_objects->empty()) {
    for(OksObject::Map::iterator i = c->p_objects->begin(); i != c->p_objects->end(); ++i)
      insert((*i).second);
  }
  
  std::cout << "Build index for attribute \'" << a->p_name << "\' in class \'" << c->get_name()
        << "\' for " << size() << " instances\n";
 
#ifdef DEBUG_INDICES
  for(int j=0; j<entries(); j++) {
    OksObject *obj = at(j);
 
    std::cout << j << ".\tobject id \'" << obj->GetId() << "\'   "
          << "\tvalue: \'" << obj->data[offset] << "\'\n";
  }
#endif
}
 
OksIndex::~OksIndex()
{
  if(c && a) {
    c->p_indices->erase(a);
 
    if(c->p_indices->empty()) {
      delete c->p_indices;
      c->p_indices = 0;
    }
  }
}
 
 
OksObject*
OksIndex::remove_obj(OksObject *o)
{
  std::pair<Position, Position> positions = equal_range(o);
  Position i = positions.first;
  Position i2 = positions.second;
 
  for(; i != i2; ++i) {
    if(o == *i) {
      erase(i);
      return o;
    }
  }
 
  return 0;
}
 
 
OksObject *
OksIndex::FindFirst(OksData *d) const
{
  OksObject test_o(offset, d);
 
  ConstPosition pos = lower_bound(&test_o);
 
  if(pos != end()) return *pos;
 
  return 0;
}
 
 
void
OksIndex::find_interval(OksData *d, OksQuery::Comparator f, ConstPosition& i1, ConstPosition& i2) const
{
  i1 = i2 = end();
 
  if(empty()) return;
 
  OksObject test_o(offset, d);
 
  if(f == OksQuery::equal_cmp) {
    i1 = lower_bound(&test_o);
 
    if(i1 != end()) {
      if((*i1)->data[offset] == *d) {
        i2 = upper_bound(&test_o);
      }
      else {
        i2 = i1;
      }
    }
  }
  else if(f == OksQuery::less_or_equal_cmp || f == OksQuery::less_cmp) {
    i1 = begin();
 
    if(f == OksQuery::less_cmp) {
      i2 = lower_bound(&test_o);
    }
    else {
      i2 = upper_bound(&test_o);
    }
  }
  else if(f == OksQuery::greater_or_equal_cmp || f == OksQuery::greater_cmp) {
    i2 = end();
    
    if(f == OksQuery::greater_cmp) {
      i1 = upper_bound(&test_o);
    }
    else {
      i1 = lower_bound(&test_o);
    }
  }
}
 
 
OksObject::List *
OksIndex::find_all(OksData *d, OksQuery::Comparator f) const
{
  OksObject::List * olist = 0;
 
  ConstPosition pos1, pos2;
 
  find_interval(d, f, pos1, pos2);
 
  if(pos1 != pos2) {
    olist = new OksObject::List();
    for(;pos1 != pos2; ++pos1) olist->push_back(*pos1);
  }
 
  return olist;
}
 
 
OksObject::List *
OksIndex::find_all(bool andOperation, OksData *d1, OksQuery::Comparator f1, OksData *d2, OksQuery::Comparator f2) const
{
  OksObject::List * olist = 0;
  
  ConstPosition a1, b1;
  
  find_interval(d1, f1, a1, b1);
  
  if((andOperation == true) && (a1 == b1)) return 0;
  
  ConstPosition a2, b2;
 
  find_interval(d2, f2, a2, b2);
 
  if(andOperation == true) { 
    if(a2 == b2) return 0;
 
 
      //
      // find intersection ([pos1,pos2] or NIL) of [a1,b1] and [a2,b2]
      // where begin() <= {a1,b1,a2,b2} <= end())
      //
      // (note that a1 and a2 are not equal to end() but b1 nad b2 have to be tested)
      //
 
    ConstPosition pos1, pos2;
 
    if((*a2)->data[offset] <= (*a1)->data[offset]) {
      if((b2 != end()) && ((*b2)->data[offset] < (*a1)->data[offset])) return 0;
      pos1 = a1;
    }
    else {
      if((b1 != end()) && (*a2)->data[offset] > (*b1)->data[offset]) return 0;
      pos1 = a2;
    }
    
    if(b2 == end() || b1 == end()) {
      pos2 = (b2 != end()) ? b2 : b1;
    }
    else
      pos2 = ((*b2)->data[offset] <= (*b1)->data[offset]) ? b2 : b1;
 
    olist = new OksObject::List();
    for(;pos1 != pos2; ++pos1) olist->push_back(*pos1);
  }
  else {
    if(a1 != b1 && a2 == b2) {
      olist = new OksObject::List();
      for(;a1 != b1; ++a1) olist->push_back(*a1);
    }
    else if(a2 != b2 && a1 == b1) {
      olist = new OksObject::List();
      for(;a2 != b2; ++a2) olist->push_back(*a2);
    }
    else if(a1 != b1 && a2 != b2) {
      olist = new OksObject::List();
 
 
        //
        // find union of [a1,b1] and [a2,b2] (i.e. [pos1,pos2] or [a1,b1],[a2,b2])
    // where begin() <= {a1,b1,a2,b2} <= end())
        //
        // (note that a1 and a2 are not equal to end() but b1 nad b2 have to be tested)
        //
 
      ConstPosition pos1, pos2;
 
      if((*a2)->data[offset] <= (*a1)->data[offset]) {
        if(b2 != end() && (*b2)->data[offset] < (*a1)->data[offset]) {
          for(;a2 != b2; ++a2) olist->push_back(*a2);
          for(;a1 != b1; ++a1) olist->push_back(*a1);
 
          return olist;
        }
 
        pos1 = a2;
      }
      else {
        if(b1 != end() && (*a2)->data[offset] > (*b1)->data[offset]) {
          for(;a1 != b1; ++a1) olist->push_back(*a1);
          for(;a2 != b2; ++a2) olist->push_back(*a2);
 
          return olist;
        }
        
        pos1 = a1;
      }
 
      if(b2 == end() || b1 == end()) {
    pos2 = (b2 == end()) ? b2 : b1;
      }
      else
        pos2 = ((*b2)->data[offset] >= (*b1)->data[offset]) ? b2 : b1;
 
      for(;pos1 != pos2; ++pos1) olist->push_back(*pos1);
    }
  }
 
  return olist;
}
 
} // namespace oks
} // namespace dunedaq