IsPutCommand.cpp

#include "IsPutCommand.h"
#include "Archiver.h"
#include "Sct/IS/IOManagerIS.h"
#include "Sct/LogicErrors.h"
#include "Sct/IoExceptions.h"
#include "Sct/ISProxy/IOManagerISProxy.h"
#include "Sct/ISUtilities.h"
#include "CalibrationController/Serialization/IsInfoWrapper.h"
// Summary stuff:
#include "SummaryWriter/TestSummaryIS.h"
#include "SummaryWriter/SummaryManager.h"
#include "SctData/TestResult.h"
#include <is/info.h>
#include <is/infodictionary.h>
#include <is/infoiterator.h>
#include <is/inforeceiver.h>
#include <is/infoT.h>
#include <boost/timer.hpp>
#include <sstream>

namespace SctArchiving{
  IsPutCommand::IsPutCommand(boost::shared_ptr<Sct::Serializable> ob)
    : PutCommand(ob)  {
  }

  IsPutCommand::IsPutCommand() {}

  IsPutCommand::~IsPutCommand() {}

  void IsPutCommand::setServer(const string& name){
    m_server=name;
  }

  boost::shared_ptr<ArchivingCommand> IsPutCommand::create()const{
    boost::shared_ptr<ArchivingCommand> cmd(new IsPutCommand() );
    return cmd;
  }
  
  void IsPutCommand::execute(){
    using namespace SctCalibrationController;
    boost::timer t;

    if (!m_ob.get()) throw Sct::IllegalStateError("Null pointer", __FILE__, __LINE__);

    if (m_server=="") m_server = Archiver::instance().getRetrieveIsServer();

    if (m_ob->getClassName()=="TestData" || m_ob->getClassName()=="SequenceData") {
      shared_ptr<IsInfoWrapper> wrapper = boost::dynamic_pointer_cast<IsInfoWrapper>(m_ob);
      if (!wrapper.get()) throw Sct::IllegalStateError(m_ob->getClassName() + 
                               " couldnt be cast as a ISSerializableWrapperI", __FILE__, __LINE__);
      wrapper->publishWrappedObject(m_server);
    }else{
      Sct::IS::IOParamsIS params( m_server );
      Sct::ISProxy::IOManagerISProxy::instance().write(*m_ob, &params);      
    }

     // if TestResult publish summary too.
    if (m_ob->getClassName().find("TestResult")!=std::string::npos){
      try{
    shared_ptr<SctData::TestResult> r = boost::dynamic_pointer_cast<SctData::TestResult>(m_ob);
    if (!r.get()) throw Sct::IllegalStateError(string("Bad cast of TestResult ") + (string)m_ob->getUniqueID(), __FILE__, __LINE__);
    TestSummaryIS t;
    t.dataString = SctData::TestSummary::SummaryManager::instance().write(*r);
    std::string name = m_server;
    name += ".";
    name += "Summary.";
    name += (string) m_ob->getUniqueID();
    
    Sct::ISUtilities::addOrUpdateOrThrow(name, t, __FILE__, __LINE__, MRS_ERROR);
      }catch(Sct::IsException& e){
    if (e.getStatus()==ISInfo::AlreadyExist){
      std::cerr << e.what() << std::endl;
    }else{
      throw;
    }
      }catch(Sct::Throwable& e){
    e.sendToMrs(MRS_DIAGNOSTIC);
      }
      
      Archiver::instance().addISTime(t.elapsed());
    }
  }
}

---