DRCEFunctionalObjectBase.cpp

Go to the documentation of this file.

#include <Poco/JSON/Object.h>
#include <Poco/JSON/Array.h>
#include <Poco/JSON/JSON.h>
#include <Poco/JSON/Stringifier.h>
#include <Poco/JSON/Parser.h>
#include <Poco/JSON/JSONException.h>
#include <Poco/Dynamic/Var.h>
#include <algorithm>
#include <ctype.h>

#include "DRCEFunctionalObjectBase.hpp"
#include "DRCEMessageConst.hpp"
#include "DRCEError.hpp"
#include "DRCETaskRequestSetExecute.hpp"

namespace HCE
{
namespace drce
{
//-----------------------------------------------------------------------------
DRCEFunctionalObjectBase::DRCEFunctionalObjectBase(void)
:errorMsg(""), errorCode(NO_ERROR), _isError(false), logger(drce_const::moduleName), environments()
{
}
//-----------------------------------------------------------------------------
void DRCEFunctionalObjectBase::resetLogStream(void)
{
  logger.resetLogStream();
}
//-----------------------------------------------------------------------------
void DRCEFunctionalObjectBase::setLogStream(std::ostream& os)
{
  logger.setLogStream(os);
}
//-----------------------------------------------------------------------------
std::string DRCEFunctionalObjectBase::logMsg(bool isReset)
{
  return logger.logMsg(isReset);
}
//-----------------------------------------------------------------------------
std::ostream& DRCEFunctionalObjectBase::log(LoggerStream::Priority logPriority)
{
  return logger.log(logPriority);
}
//-----------------------------------------------------------------------------
void DRCEFunctionalObjectBase::setLoggable(Loggable loggable)
{
  logger.setLoggable(loggable);
}
//-----------------------------------------------------------------------------
void DRCEFunctionalObjectBase::resetLoggable(void)
{
  logger.resetLoggable();
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// cppcheck-suppress unusedFunction
bool DRCEFunctionalObjectBase::insensitiveCompare(const std::string& lhs, const std::string& rhs)
{
  std::string lhsCpy(lhs);
  std::string rhsCpy(rhs);
  std::transform(lhsCpy.begin(), lhsCpy.end(), lhsCpy.begin(), tolower);
  std::transform(rhsCpy.begin(), rhsCpy.end(), rhsCpy.begin(), tolower);
  return (lhsCpy == rhsCpy);
}
//-------------------------------------------------------------------
size_t DRCEFunctionalObjectBase::getElapsedTimeMsec(const Poco::Timestamp& tsStart)
{
  Poco::Timestamp tsStop;
  Poco::Timestamp::TimeDiff diff = tsStop-tsStart;
  return static_cast<size_t>(diff/1000);
}
//-----------------------------------------------------------------------------
void DRCEFunctionalObjectBase::setEnvironments(const std::string& env)
{
  environments.clear();
  if (!env.empty())
  {
    try
    {
      Poco::JSON::Parser parser;
      Poco::Dynamic::Var res = parser.parse(env);
      Poco::JSON::Object::Ptr pObj = res.extract<Poco::JSON::Object::Ptr>();

      if (!pObj.isNull())
      {
        Poco::Dynamic::Var tmp;
        std::vector<std::string> names;
        pObj->getNames(names);
        for (size_t k=0;k<names.size();++k)
        {
          tmp = pObj->get(names[k]);
          if (tmp.isString())
            environments.push_back(std::make_pair(names[k], tmp.convert<std::string>()));
        }
      }
      _isError = false;
    }
    catch(Poco::JSON::JSONException& e)
    {
      _isError = true;
      errorMsg = std::string(message_const::setEnvironmentError)+": "+e.message();
      errorCode = ERROR_SET_MANDATORY_ENVIRONMENT;
    }
    catch(Poco::Exception& e)
    {
      _isError = true;
      errorMsg = std::string(message_const::setEnvironmentError)+": "+e.message();
      errorCode = ERROR_SET_MANDATORY_ENVIRONMENT;
    }
  }
}
//-----------------------------------------------------------------------------
void DRCEFunctionalObjectBase::applyEnvironments(DRCETaskRequest* pTaskRequest)
{
  DRCETaskRequestSetExecute* pTaskRequestSetExecute = dynamic_cast<DRCETaskRequestSetExecute*>(pTaskRequest);
  if (pTaskRequestSetExecute && !environments.empty())
  {
    SessionOptions sessionOptions = pTaskRequestSetExecute->getSessionOptions();
    for (size_t i=0;i<environments.size();++i)
    {
      sessionOptions.environments.push_back(environments[i]);
    }
    pTaskRequestSetExecute->setSessionOptions(std::forward<SessionOptions>(sessionOptions));
  }
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
} // namespace drce
} // namespace HCE