Channel.cpp

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

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

    // the constructor

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


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

    if(print_header) {
      s
        << str << "SCTDAL Channel 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 << "  outputCurrent: " << outputCurrent() << 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 << "  outputDelay: " << outputDelay() << 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 << "  outputMarkSpace: " << outputMarkSpace() << 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 << "  stream0Threshold: " << stream0Threshold() << 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 << "  stream0Delay: " << stream0Delay() << 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 << "  stream0ErrMask: " << stream0ErrMask() << 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 << "  stream1Threshold: " << stream1Threshold() << 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 << "  stream1Delay: " << stream1Delay() << 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 << "  stream1ErrMask: " << stream1ErrMask() << 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 << "  outputFibre: " << outputFibre() << 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 << "  stream0Fibre: " << stream0Fibre() << 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 << "  stream1Fibre: " << stream1Fibre() << std::endl;
    s.setf(std::ios::dec, std::ios::basefield);
  }


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

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

    return s;
  }


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

    return s;
  }


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


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


  void Channel::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("outputCurrent",m_outputCurrent)) {
      std::cerr << "ERROR: could not find attribute 'outputCurrent'\n";
    }
    else {
      p_db.convert(m_outputCurrent, p_obj, "outputCurrent");
    }

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

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

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

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

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

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

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

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

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

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

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

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

  Channel::~Channel()
  {
  }

}

---