AnalysisScanDataContainerUnit.cpp

Go to the documentation of this file.

// AnalysisScanDataContainerUnit.cpp: implementation of the AnalysisScanDataContainerUnit class.
//
 
#include "AnalysisScanDataContainerUnit.h"
#include <boost/serialization/export.hpp>
#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>
BOOST_CLASS_EXPORT_IMPLEMENT(AnalysisScanDataContainerUnit)
using namespace std;
 
// Construction/Destruction
 
AnalysisScanDataContainerUnit::AnalysisScanDataContainerUnit() {
  time = -999.0;
  operator_id = -999;
}
 
AnalysisScanDataContainerUnit::~AnalysisScanDataContainerUnit() {
  this->alarm_name.clear();
  this->alarm_priority.clear();
  this->component_name.clear();
  this->component_priority.clear();
  this->support_system_name.clear();
  this->support_system_priority.clear();
  this->parameter_name.clear();
  this->parameter_priority.clear();
}
 
void AnalysisScanDataContainerUnit::copyAnalysisScanDataContainerUnit(AnalysisScanDataContainerUnit &_asdcu) {
  int n;
  this->setAnalysisScanDataTime(_asdcu.getAnalysisScanDataTime());
  this->setAnalysisScanDataOperator(_asdcu.getAnalysisScanDataOperator());
  //
  //copy alarms
  for (n = 0; n < _asdcu.alarm_name.size(); n++) {
    this->alarm_name.push_back(_asdcu.alarm_name.at(n));
    this->alarm_priority.push_back(_asdcu.alarm_priority.at(n));
  }
  //
  //copy components
  for (n = 0; n < _asdcu.component_name.size(); n++) {
    this->component_name.push_back(_asdcu.component_name.at(n));
    this->component_priority.push_back(_asdcu.component_priority.at(n));
  }
  //
  //copy support systems
  for (n = 0; n < _asdcu.support_system_name.size(); n++) {
    this->support_system_name.push_back(_asdcu.support_system_name.at(n));
    this->support_system_priority.push_back(_asdcu.support_system_priority.at(n));
  }
  //
  //copy parameters
  for (n = 0; n < _asdcu.parameter_name.size(); n++) {
    this->parameter_name.push_back(_asdcu.parameter_name.at(n));
    this->parameter_priority.push_back(_asdcu.parameter_priority.at(n));
  }
}
 
void AnalysisScanDataContainerUnit::saveAnalysisScanDataContainerUnittoFile(std::ofstream &fout) {
  int n;
  fout << "ScanDataInformation" << '\n';
  fout << time << ' '
       << operator_id << '\n';
  fout << this->alarm_name.size() << '\n';
  for (n = 0; n < this->alarm_name.size(); n++) {
    fout << this->alarm_name.at(n) << ' '
         << this->alarm_priority.at(n) << '\n';
  }
  //
  fout << this->component_name.size() << '\n';
  for (n = 0; n < this->component_name.size(); n++) {
    fout << this->component_name.at(n) << ' '
         << this->component_priority.at(n) << '\n';
  }
  //
  fout << this->support_system_name.size() << '\n';
  for (n = 0; n < this->support_system_name.size(); n++) {
    fout << this->support_system_name.at(n) << ' '
         << this->support_system_priority.at(n) << '\n';
  }
  //
  fout << this->parameter_name.size() << '\n';
  for (n = 0; n < this->parameter_name.size(); n++) {
    fout << this->parameter_name.at(n) << ' '
         << this->parameter_priority.at(n) << '\n';
  }
 
}
 
void AnalysisScanDataContainerUnit::retrieveAnalysisScanDataContainerUnitfromFile(std::ifstream &fin) {
  int i, n, priority;
  std::string item_name, str;
  fin >> str;
  fin >> this->time
      >> this->operator_id
      >> n;
  for (i = 0; i < n; i++) {
    fin >> item_name
        >> priority;
    this->alarm_name.push_back(item_name);
    this->alarm_priority.push_back(priority);
  }
  //
  fin >> n;
  for (i = 0; i < n; i++) {
    fin >> item_name
        >> priority;
    this->component_name.push_back(item_name);
    this->component_priority.push_back(priority);
  }
  //
  fin >> n;
  for (i = 0; i < n; i++) {
    fin >> item_name
        >> priority;
    this->support_system_name.push_back(item_name);
    this->support_system_priority.push_back(priority);
  }
  //
  fin >> n;
  for (i = 0; i < n; i++) {
    fin >> item_name
        >> priority;
    this->parameter_name.push_back(item_name);
    this->parameter_priority.push_back(priority);
  }
}
 
void AnalysisScanDataContainerUnit::saveScanDataInfotoFile(std::ofstream &fout) {
  std::string operator_type;
  int n, queue_size;
 
  if (this->getAnalysisScanDataOperator() == sim::Operator::ODM) {
    operator_type = "ODM";
  } else if (this->getAnalysisScanDataOperator() == sim::Operator::OAT) {
    operator_type = "OAT";
  } else {
    operator_type = "unknown";
  }
  //
  queue_size = this->alarm_name.size() + this->component_name.size() + this->support_system_name.size()
      + this->parameter_name.size();
  fout << this->time << '\t'
       << operator_type << '\t'
       << queue_size << '\n';
  //
  if (this->alarm_name.size() > 0) {
    fout << '\t' << "Scanned Alarms" << '\t' << "Priority" << '\n';
    for (n = 0; n < this->alarm_name.size(); n++) {
      fout << '\t'
           << this->alarm_name.at(n) << '\t'
           << this->alarm_priority.at(n) << '\n';
    }
  }
  //
  if (this->component_name.size() > 0) {
    fout << '\t' << "Scanned Components" << '\t' << "Priority" << '\n';
    for (n = 0; n < this->component_name.size(); n++) {
      fout << '\t'
           << this->component_name.at(n) << '\t'
           << this->component_priority.at(n) << '\n';
    }
  }
  //
  if (this->support_system_name.size() > 0) {
    fout << '\t' << "Scanned Support Systems" << '\t' << "Priority" << '\n';
    for (n = 0; n < this->support_system_name.size(); n++) {
      fout << '\t'
           << this->support_system_name.at(n) << '\t'
           << this->support_system_priority.at(n) << '\n';
    }
  }
  //
  if (this->parameter_name.size() > 0) {
    fout << '\t' << "Scanned Parameters" << '\t' << "Priority" << '\n';
    for (n = 0; n < this->parameter_name.size(); n++) {
      fout << '\t'
           << this->parameter_name.at(n) << '\t'
           << this->parameter_priority.at(n) << '\n';
    }
  }
  //
}
 
void AnalysisScanDataContainerUnit::setAnalysisScanDataTime(double _x) { time = _x; }
void AnalysisScanDataContainerUnit::setAnalysisScanDataOperator(int _n) { operator_id = _n; }
double AnalysisScanDataContainerUnit::getAnalysisScanDataTime() { return time; }
int AnalysisScanDataContainerUnit::getAnalysisScanDataOperator() { return operator_id; }