source: PSPA/Interface_Web/trunk/pspaWT/sources/controler/src/nomDeLogiciel.cc @ 485

#include "nomDeLogiciel.h"

nomDeLogiciel::Logiciel nomDeLogiciel::fromString( std::string s)
  {
    if (s == "parmela" ) return parmela;
    else if ( s == "transport" ) return transport;
    else if ( s == "generator" ) return generator;
    else if ( s == "test" ) return test;
    else if ( s == "madx" ) return madx;
    else if ( s == "usersprogram" ) return usersprogram;
    return unknownSoftware;
  }

std::string nomDeLogiciel::toString(nomDeLogiciel::Logiciel lg)
{
  switch (lg) 
    {
    case parmela : { return "parmela"; }
    case transport : { return "transport"; }
    case generator : { return "generator"; }
    case test : { return "test"; }
    case madx : { return "madx"; }
    case usersprogram : { return "usersprogram"; }
    case unknownSoftware : { return "unknownSoftware"; }
    }
  return "unknownSoftware";
}

/** Color of the background of the sofware
    Should be a valid Css name as FFEEDD
*/
std::string nomDeLogiciel::getWtColor( nomDeLogiciel::Logiciel lg) const
{
  switch (lg)
    {
    case parmela : { return "#e09bdf"; }
    case transport : { return "#c0ea8e"; }
    case generator : { return "#a3c0ed"; }
    case test : { return "#ecc38e"; }
    case madx : { return "#ecc38e"; } //{ return "#FFFF00"; }
    case unknownSoftware : { return "#FFFFFF"; }
    }
  return "#FFFFFF";
}

 nomDeLogiciel::nomDeLogiciel()  
 {
   program_ = unknownSoftware;
   progString_ = toString(program_);
   setCompatiblesElements();
 }

nomDeLogiciel::nomDeLogiciel(const string& s)
{
  program_ = fromString(s);
  progString_ = toString(program_);
  setCompatiblesElements(); 
}

nomDeLogiciel::nomDeLogiciel(int val)
{  
  program_ = (Logiciel)val;
  progString_ = toString(program_);
  setCompatiblesElements(); 
}

int nomDeLogiciel::getNumberOfSoftwares() 
{ 
  return unknownSoftware;
}


void nomDeLogiciel::registerElement(nomdElements::typedElement nomdel,trivaluedBool b) 
{
  if (b == TBoolIgnore) {
    ignoredElements_.push_back(nomdel);
  } else if (b == TBoolOk) {
    acceptedElements_.push_back(nomdel);
  }
}



void nomDeLogiciel::setCompatiblesElements() 
{
  cout << " nomDeLogiciel::setCompatiblesElements() " << program_ << endl;
  switch (program_) 
    {
    case parmela : 
      {  
        registerElement(nomdElements::RFgun,TBoolOk);
        registerElement(nomdElements::drift,TBoolOk);
        registerElement(nomdElements::cell,TBoolOk);
        registerElement(nomdElements::bend,TBoolOk);
        registerElement(nomdElements::soleno,TBoolOk);
        registerElement(nomdElements::fit,TBoolIgnore);
        registerElement(nomdElements::snapshot,TBoolIgnore);
        break;
      }
     case transport : 
       {  
         registerElement(nomdElements::beam,TBoolOk);
         registerElement(nomdElements::drift,TBoolOk);
         registerElement(nomdElements::bend,TBoolOk);
         registerElement(nomdElements::soleno,TBoolOk);
         registerElement(nomdElements::fit,TBoolOk);
         registerElement(nomdElements::snapshot,TBoolIgnore);
         break;
       }
     case generator : 
       { 
         registerElement(nomdElements::RFgun,TBoolOk);
         break;
       }
    case test : 
      { 
        break;
      }
    case madx : 
      {  
        registerElement(nomdElements::RFgun,TBoolOk);
        registerElement(nomdElements::drift,TBoolOk);
        registerElement(nomdElements::mpole,TBoolOk);
        break;
      }
    case usersprogram : 
      {  
        registerElement(nomdElements::snapshot,TBoolOk);
      }
    case unknownSoftware :
      { 
        break;
      }
    }
}



trivaluedBool nomDeLogiciel::doAcceptElement(nomdElements::typedElement typdel) 
{
  //xx

  cout << " nomDeLogiciel::doAcceptElement type : " << typdel << endl;
  cout << " nomDeLogiciel::doAcceptElement nb el/ acc. " << acceptedElements_.size() << endl;
  if (acceptedElements_.size() == 0 ) {
    return TBoolError;
  }

  if (std::find(acceptedElements_.begin(),acceptedElements_.end(),typdel) != acceptedElements_.end()) {
    return TBoolOk;
  }

  if (ignoredElements_.size() == 0) {
    return TBoolError;
  }

  if (std::find(ignoredElements_.begin(),ignoredElements_.end(),typdel) != ignoredElements_.end()) {
    return TBoolIgnore;
  }

  return TBoolOk;
}




// operators
nomDeLogiciel& nomDeLogiciel::operator= (const nomDeLogiciel& nl)
{
  program_ = nl.program_;
  progString_ = nl.progString_;
  acceptedElements_ = nl.acceptedElements_;
  ignoredElements_ = nl.ignoredElements_;
  return *this;
}

bool nomDeLogiciel::operator== (const nomDeLogiciel& nl)
{
  return ( program_ == nl.program_);
}

bool nomDeLogiciel::operator!= (const nomDeLogiciel& nl)
{
  return ( program_ != nl.program_);
}