arcssensorlogger.cpp

/*
  name: lib/arcssensorlogger.cpp

  This file is part of ARCS - Augmented Reality Component System
  (version 2-current), written by Jean-Yves Didier 
  for IBISC Laboratory (http://www.ibisc.univ-evry.fr)

  Copyright (C) 2013  Université d'Evry-Val d'Essonne

  This program is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 2 of the License, or
  (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
  
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.


  Please send bugreports  with examples or suggestions to
  jean-yves.didier__at__ibisc.univ-evry.fr
*/


#include <arcs/arcssensorlogger.h>
#include <arcs/arcsfactory.h>
#include <iostream>
#include <QTime>
#include <QDir>

void ARCSSensorLoggerBase::setFilename(QString s)
{
     if (logFile.is_open())
          logFile.close();

     logFile.open(qPrintable(s));
}


bool ARCSSensorLoggerBase::canLog()
{
     if (!logFile.is_open())
          logFile.open("arcs_runtime.log");

     return logFile.is_open();
}


/**********************************************************************************
 *  ARCSSensorLogger
 **********************************************************************************/

ARCSSensorLogger::ARCSSensorLogger(QObject* parent) : ARCSSensorLoggerBase(parent)
{
     idx = 0;
}


QStringList ARCSSensorLogger::getSlotList()
{
     QStringList sl ;
     sl << "log()" ;
     return sl;
}

QStringList ARCSSensorLogger::getSignalList()
{
     return QStringList();
}


int ARCSSensorLogger::cleanSlotConnect(QString sigName, QString /*sltName*/, QString objectName, QString actualSignal)
{
     QString signature = objectName + "." + actualSignal + "." + sigName ;

     int id = -1;
     if (map.contains(signature))
          id = map[signature];
     else
          return -1;

     map.take(signature);
     invertMap.take(id);

     return id;
}


int ARCSSensorLogger::cleanSignalConnect(QString /*sigName*/, QString /*sltName*/, QString /*objectName*/, QString /*actualSlot*/)
{ return -1; }

int ARCSSensorLogger::prepareSlotConnect(QString sigName, QString sltName, QString objectName, QString actualSignal, bool simulate)
{
     if (simulate)
          return 0;

     // if slot is part of something we know locally, then we won't connect it.
     if (objectName.isEmpty())
         return ARCSSensorLoggerBase::metaObject()->indexOfSlot(qPrintable(sltName));

     // first parse sigName
     QString signature = objectName + "." + actualSignal + "." + sigName ;
     LogDetails ld(signature, objectName, actualSignal.section("(",0,0));

     QStringList paramTypes = sigName.section("(",1,1).section(")", 0,0).split(",");
     if (!paramTypes.at(0).isEmpty())
         for (int i=0; i < paramTypes.count(); i++)
              ld.addType(paramTypes.at(i), QMetaType::type(qPrintable(paramTypes.at(i))));

     map.insert(signature,idx);
     invertMap.insert(idx,ld);
     idx++;

     return idx-1 + metaObject()->methodCount();
}

int ARCSSensorLogger::prepareSignalConnect(QString /*sigName*/, QString /*sltName*/, QString /*objectName*/, QString /*actualSlot*/, bool /*simulate*/)
{
     // nothing to implement here.
     return -1 ;
}

int ARCSSensorLogger::qt_metacall(QMetaObject::Call call, int id, void ** arguments)
{
     QMutexLocker lock(&mutex);
     id = ARCSSensorLoggerBase::qt_metacall(call,id, arguments);
     if (id == -1 || call != QMetaObject::InvokeMetaMethod)
          return id;


     if (!canLog())
     {
          std::cerr << "Log file not opened" << std::endl;
          return  -1;
     }

     // the piece of code below should be used in something else if required.

     if (!invertMap.contains(id))
     {
          std::cerr << "Map does not contain id " << id << std::endl;
          return -1;
     }

      LogDetails ld = invertMap[id];

     QTime time = QTime::currentTime() ;

     logFile  << qPrintable(time.toString()) <<"."
               << qPrintable(QString::number(time.msec()).rightJustified(3,'0')) << " "
               << qPrintable(ld.getObject()) << "." << qPrintable(ld.getSignal()) << "(" << std::endl;

     if (ld.count() <= 0)
     {
          logFile << ")" << std::endl ;
          return -1;
     }


     for (int i =0; i < ld.count(); i++)
     {
          QString nt;
          int it;
          ld.getArgument(i, nt, it);

          logFile << "\t\t" << qPrintable(nt) << ": " ;
          if (it != QMetaType::Void)
          {
               QVariant v(it, arguments[i+1]);
               QString s = ARCSFactory::getInstance()->dataSerialize(v);
               logFile << "\"" << qPrintable(s) << "\"" << std::endl;
          }
          else
               logFile << qPrintable(QString::number((long)arguments[i+1],16)) << std::endl;
     }
     logFile << "\t)" << std::endl;


     return -1;
}



/**********************************************************************************
 *  inner class LogDetails of ARCSSensorLogger
 **********************************************************************************/


ARCSSensorLogger::LogDetails::LogDetails(const LogDetails& ld)
{
     object = ld.object;
     signature = ld.signature;
     signal = ld.signal;
     typeNames = ld.typeNames;
     typeIds = ld.typeIds;
}

ARCSSensorLogger::LogDetails::LogDetails(QString sn, QString obj,  QString s)
{
     signature = sn ;
     object = obj ;
     signal = s;
}