Conditions.cpp

Go to the documentation of this file.

//==========================================================================
//  AIDA Detector description implementation for LCD
//--------------------------------------------------------------------------
// Copyright (C) Organisation europeenne pour la Recherche nucleaire (CERN)
// All rights reserved.
//
// For the licensing terms see $DD4hepINSTALL/LICENSE.
// For the list of contributors see $DD4hepINSTALL/doc/CREDITS.
//
// Author     : M.Frank
//
//==========================================================================

// Framework includes
#include "DD4hep/Handle.inl"
#include "DD4hep/Printout.h"
#include "DD4hep/objects/ConditionsInterna.h"

// C/C++ include files
#include <climits>
#include <iomanip>

using namespace std;
using namespace DD4hep::Conditions;

Condition::Processor::Processor() {
}

ConditionKey DD4hep::Conditions::make_key(Condition c) {
  Condition::Object* p = c.ptr();
  if ( p ) return ConditionKey(p->name,p->hash);
  invalidHandleError<Condition>();
  return ConditionKey();
}

ConditionKey::ConditionKey(const string& value) 
  : name(value), hash(hashCode(value))
{
}

ConditionKey& ConditionKey::operator=(const string& value)  {
  ConditionKey key(value);
  hash = hashCode(value);
  name = value;
  return *this;
}

bool ConditionKey::operator<(const string& compare)  const  {  
  return hash < hashCode(compare);
}

Condition::Condition(const string& nam,const string& typ) : Handle<Object>()  {
  Object* o = new Object();
  assign(o,nam,typ);
  o->hash = ConditionKey::hashCode(nam);
}

string Condition::str(int flags)  const   {
  stringstream output;
  Object* o = access();
  const IOV* ptr_iov = o->iovData();
  if ( 0 == (flags&NO_NAME) )
    output << setw(16) << left << o->name;
  if ( flags&WITH_IOV )
    output << " " << (ptr_iov ? ptr_iov->str().c_str() : "IOV:[UNKNOWN]");
  if ( flags&WITH_TYPE )
    output << " (" << o->type << ")";
  if ( flags&WITH_ADDRESS )
    output << " " << o->address;
  if ( flags&WITH_DATATYPE )
    output << " -> " << o->data.dataType();
  if ( flags&WITH_DATA )
    output << " Data:" << o->data.str();
  if ( flags&WITH_COMMENT )
    output << " \"" << o->comment << "\"";
  return output.str();
}

int Condition::dataType() const   {
  return access()->data.type;
}

DD4hep::OpaqueData& Condition::data() const   {
  return access()->data;
}

const DD4hep::IOVType& Condition::iovType() const   {
  return *(access()->iovType());
}

const DD4hep::IOV& Condition::iov() const   {
  return *(access()->iovData());
}

const string& Condition::type()  const   {
  return access()->type;
}

const string& Condition::value()  const   {
  return access()->value;
}

const string& Condition::comment()  const   {
  return access()->comment;
}

const string& Condition::address()  const   {
  return access()->address;
}

const type_info& Condition::typeInfo() const   {
  return descriptor().type();
}

Condition::key_type Condition::key()  const    {
  return access()->hash;
}

const DD4hep::BasicGrammar& Condition::descriptor() const   {
  const BasicGrammar* g = access()->data.grammar;
  if ( !g ) {
    invalidHandleError<Condition>();
    // This code is never reached, since function above throws exception!
    // Needed to satisfay CppCheck
    throw runtime_error("Null pointer in Grammar object");
  }
  return *g;
}

Condition& Condition::rebind()    {
  Object* o = access();
#if 0
  const IOV* i = o->iov;
  const IOVType* t = i->iovType;
  i->fromString(o->validity);
  if ( t != i->iovType )  {
    except("Condition","Rebinding condition with different IOV types [%d <> %d] is not allowed!",
           t ? t->type : -1, i->iovType ? i->iovType->type : -1);
  }
#endif
  o->data.fromString(o->value);
  printout(INFO,"Condition","+++ condition:%s rebinding value:%s",
           name(), o->value.c_str());
  return *this;
}

Container::Processor::Processor() {
}

size_t Container::numKeys() const   {
  Object* o = ptr();
  if ( !o )   {
    invalidHandleError<Container>();
  }
  return o->keys.size();
}

const Container::Keys& Container::keys()  const   {
  Object* o = ptr();
  if ( !o )   {
    invalidHandleError<Container>();
  }
  return o->keys;
}

Condition Container::get(const string& condition_key, const iov_type& iov)  {
  Object* o = ptr();
  if ( o )  {
    Condition c = o->get(condition_key, iov);
    if ( c.isValid() )  {
      return c;
    }
    invalidHandleError<Condition>();
  }
  invalidHandleError<Container>();
  return Condition();
}

Condition Container::get(key_type condition_key, const iov_type& iov)  {
  Object* o = ptr();
  if ( o )  {
    Condition c = o->get(condition_key, iov);
    if ( c.isValid() )  {
      return c;
    }
    invalidHandleError<Condition>();
  }
  invalidHandleError<Container>();
  return Condition();
}

Condition Container::get(const string& condition_key, const UserPool& pool)  {
  Object* o = ptr();
  if ( o )  {
    Condition c = o->get(condition_key, pool);
    if ( c.isValid() )  {
      return c;
    }
    invalidHandleError<Condition>();
  }
  invalidHandleError<Container>();
  return Condition();
}

Condition Container::get(key_type condition_key, const UserPool& pool)  {
  Object* o = ptr();
  if ( o )  {
    Condition c = o->get(condition_key, pool);
    if ( c.isValid() )  {
      return c;
    }
    invalidHandleError<Condition>();
  }
  invalidHandleError<Container>();
  return Condition();
}