SCT_Chip.cpp

#include <config/ConfigObject.h>
#include <config/Change.h>
#include "SCT_Chip.h"

namespace SCTDAL {
  const std::string SCT_Chip::s_class_name("SCT_Chip");

    // the constructor

  SCT_Chip::SCT_Chip(::Configuration& db, ::ConfigObject& o) :
    DalObject(db, o)  {
  }


  void SCT_Chip::print(unsigned int indent, bool print_header, std::ostream& s) const
  {
    std::string str(indent, ' ');

    if(print_header) {
      s
        << str << "SCTDAL SCT_Chip object:\n"
        << str << "  id: \'" << UID() << "\', class name: \'" << class_name() << "\'\n";
    }


      // print direct attributes

    s << str << "  id: " << id() << std::endl;
    s.setf(std::ios::hex, std::ios::basefield); s.setf(std::ios::showbase);
    s << str << "  address: " << address() << std::endl;
    s.setf(std::ios::dec, std::ios::basefield);
    s << str << "  active: " << active() << std::endl;
    s.setf(std::ios::hex, std::ios::basefield); s.setf(std::ios::showbase);
    s << str << "  vthr: " << vthr() << std::endl;
    s.setf(std::ios::dec, std::ios::basefield);
    s.setf(std::ios::hex, std::ios::basefield); s.setf(std::ios::showbase);
    s << str << "  vcal: " << vcal() << std::endl;
    s.setf(std::ios::dec, std::ios::basefield);
    s.setf(std::ios::hex, std::ios::basefield); s.setf(std::ios::showbase);
    s << str << "  delay: " << delay() << std::endl;
    s.setf(std::ios::dec, std::ios::basefield);
    s.setf(std::ios::hex, std::ios::basefield); s.setf(std::ios::showbase);
    s << str << "  preamp: " << preamp() << std::endl;
    s.setf(std::ios::dec, std::ios::basefield);
    s.setf(std::ios::hex, std::ios::basefield); s.setf(std::ios::showbase);
    s << str << "  shaper: " << shaper() << std::endl;
    s.setf(std::ios::dec, std::ios::basefield);
    s << str << "  rc_function: " << rc_function() << std::endl;
    s << str << "  rc_function_type: " << rc_function_type() << std::endl;
    if( !m_config.empty() ) {
      s << str << "  " << m_config.size() << " value(s) in config: ";
      for(std::vector<unsigned short>::const_iterator i = m_config.begin(); i != m_config.end(); ++i) {
        if(i != m_config.begin()) s << ", ";
        s << *i;
      }
      s << std::endl;
    }
    else {
      s << str << "  config value is empty\n";
    }
    s << str << "  c_factor: " << c_factor() << std::endl;
    s << str << "  target: " << target() << std::endl;
    if( !m_trims.empty() ) {
      s << str << "  " << m_trims.size() << " value(s) in trims: ";
      s.setf(std::ios::hex, std::ios::basefield); s.setf(std::ios::showbase);
      for(std::vector<unsigned long>::const_iterator i = m_trims.begin(); i != m_trims.end(); ++i) {
        if(i != m_trims.begin()) s << ", ";
        s << *i;
      }
      s.setf(std::ios::dec, std::ios::basefield);
      s << std::endl;
    }
    else {
      s << str << "  trims value is empty\n";
    }
    if( !m_mask.empty() ) {
      s << str << "  " << m_mask.size() << " value(s) in mask: ";
      s.setf(std::ios::hex, std::ios::basefield); s.setf(std::ios::showbase);
      for(std::vector<unsigned long>::const_iterator i = m_mask.begin(); i != m_mask.end(); ++i) {
        if(i != m_mask.begin()) s << ", ";
        s << *i;
      }
      s.setf(std::ios::dec, std::ios::basefield);
      s << std::endl;
    }
    else {
      s << str << "  mask value is empty\n";
    }
  }


  std::ostream&
  operator<<(std::ostream& s, const SCT_Chip * obj)
  {
    s << '\'';

    if(obj == 0) {
      s << "(null)";
    }
    else {
      obj->config_object().print_ptr(s);
    }
    s << '\'';

    return s;
  }


  std::ostream&
  operator<<(std::ostream& s, const SCT_Chip & obj)
  {
    if(&obj == 0) {
      s << "(null)";
    }
    else {
      obj.print(0, true, s);
    }

    return s;
  }


  void SCT_Chip::update(::Configuration& conf, const ::ConfigurationChange * change)
  {
    conf.update<SCT_Chip>(change->get_modified_objs(), change->get_removed_objs());
  }


  void SCT_Chip::reset(::Configuration& conf, bool re_initialise_obj)
  {
    conf.reset_objects<SCT_Chip>(re_initialise_obj);
  }


  void SCT_Chip::init(bool /* init_children */)
  {
    p_was_read = true;
    increment_read();
    static const char * env = ::getenv("TDAQ_REPORT_DAL_OBJECT_READ");
    if(env) { std::cout << "DEBUG: read object " << this << std::endl; }

    if(!p_obj.get("id",m_id)) {
      std::cerr << "ERROR: could not find attribute 'id'\n";
    }
    else {
      p_db.convert(m_id, p_obj, "id");
    }

    if(!p_obj.get("address",m_address)) {
      std::cerr << "ERROR: could not find attribute 'address'\n";
    }
    else {
      p_db.convert(m_address, p_obj, "address");
    }

    if(!p_obj.get("active",m_active)) {
      std::cerr << "ERROR: could not find attribute 'active'\n";
    }
    else {
      p_db.convert(m_active, p_obj, "active");
    }

    if(!p_obj.get("vthr",m_vthr)) {
      std::cerr << "ERROR: could not find attribute 'vthr'\n";
    }
    else {
      p_db.convert(m_vthr, p_obj, "vthr");
    }

    if(!p_obj.get("vcal",m_vcal)) {
      std::cerr << "ERROR: could not find attribute 'vcal'\n";
    }
    else {
      p_db.convert(m_vcal, p_obj, "vcal");
    }

    if(!p_obj.get("delay",m_delay)) {
      std::cerr << "ERROR: could not find attribute 'delay'\n";
    }
    else {
      p_db.convert(m_delay, p_obj, "delay");
    }

    if(!p_obj.get("preamp",m_preamp)) {
      std::cerr << "ERROR: could not find attribute 'preamp'\n";
    }
    else {
      p_db.convert(m_preamp, p_obj, "preamp");
    }

    if(!p_obj.get("shaper",m_shaper)) {
      std::cerr << "ERROR: could not find attribute 'shaper'\n";
    }
    else {
      p_db.convert(m_shaper, p_obj, "shaper");
    }

    if(!p_obj.get("rc_function",m_rc_function)) {
      std::cerr << "ERROR: could not find attribute 'rc_function'\n";
    }
    else {
      p_db.convert(m_rc_function, p_obj, "rc_function");
    }

    if(!p_obj.get("rc_function_type",m_rc_function_type)) {
      std::cerr << "ERROR: could not find attribute 'rc_function_type'\n";
    }
    else {
      p_db.convert(m_rc_function_type, p_obj, "rc_function_type");
    }

    if(!p_obj.get("config",m_config)) {
      std::cerr << "ERROR: could not find attribute 'config'\n";
    }
    else {
      p_db.convert2(m_config, p_obj, "config");
    }

    if(!p_obj.get("c_factor",m_c_factor)) {
      std::cerr << "ERROR: could not find attribute 'c_factor'\n";
    }
    else {
      p_db.convert(m_c_factor, p_obj, "c_factor");
    }

    if(!p_obj.get("target",m_target)) {
      std::cerr << "ERROR: could not find attribute 'target'\n";
    }
    else {
      p_db.convert(m_target, p_obj, "target");
    }

    if(!p_obj.get("trims",m_trims)) {
      std::cerr << "ERROR: could not find attribute 'trims'\n";
    }
    else {
      p_db.convert2(m_trims, p_obj, "trims");
    }

    if(!p_obj.get("mask",m_mask)) {
      std::cerr << "ERROR: could not find attribute 'mask'\n";
    }
    else {
      p_db.convert2(m_mask, p_obj, "mask");
    }

    p_obj.clear(); // clear resources used by implementation
  }

  SCT_Chip::~SCT_Chip()
  {
  }

}

---