PluginDOTExporter.cpp

Go to the documentation of this file.

/*********************************************************************
 * Software License Agreement (BSD License)
 *
 *  Copyright (c) 2013, Institute for Artificial Intelligence,
 *  Universität Bremen.
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions
 *  are met:
 *
 *   * Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *   * Redistributions in binary form must reproduce the above
 *     copyright notice, this list of conditions and the following
 *     disclaimer in the documentation and/or other materials provided
 *     with the distribution.
 *   * Neither the name of the Institute for Artificial Intelligence,
 *     Universität Bremen, nor the names of its contributors may be
 *     used to endorse or promote products derived from this software
 *     without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 *  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
 *  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 *  POSSIBILITY OF SUCH DAMAGE.
 *********************************************************************/

#include <plugins/dotexporter/PluginDOTExporter.h>


namespace beliefstate {
  namespace plugins {
    PLUGIN_CLASS::PLUGIN_CLASS() {
      this->setPluginVersion("0.2");
    }
    
    PLUGIN_CLASS::~PLUGIN_CLASS() {
    }
    
    Result PLUGIN_CLASS::init(int argc, char** argv) {
      Result resInit = defaultResult();
      
      this->setSubscribedToEvent("export-planlog", true);
      
      return resInit;
    }
    
    Result PLUGIN_CLASS::deinit() {
      return defaultResult();
    }
    
    Result PLUGIN_CLASS::cycle() {
      Result resCycle = defaultResult();
      this->deployCycleData(resCycle);
      
      return resCycle;
    }
    
    void PLUGIN_CLASS::consumeEvent(Event evEvent) {
      if(evEvent.cdDesignator) {
        std::string strFormat = evEvent.cdDesignator->stringValue("format");
        transform(strFormat.begin(), strFormat.end(), strFormat.begin(), ::tolower);
        
        if(strFormat == "dot") {
          ServiceEvent seGetPlanTree = defaultServiceEvent("symbolic-plan-tree");
          seGetPlanTree.cdDesignator = new CDesignator(evEvent.cdDesignator);
          this->deployServiceEvent(seGetPlanTree);
        }
      }
    }
    
    Event PLUGIN_CLASS::consumeServiceEvent(ServiceEvent seServiceEvent) {
      Event evResult = defaultEvent();
      
      if(seServiceEvent.siServiceIdentifier == SI_RESPONSE) {
        if(seServiceEvent.strServiceName == "symbolic-plan-tree") {
          if(seServiceEvent.cdDesignator) {
            if(seServiceEvent.lstResultEvents.size() > 0) {
              Event evCar = seServiceEvent.lstResultEvents.front();
              
              std::string strFormat = seServiceEvent.cdDesignator->stringValue("format");
              transform(strFormat.begin(), strFormat.end(), strFormat.begin(), ::tolower);
              
              if(strFormat == "dot") {
                this->info("DOTExporter Plugin received plan log data. Exporting symbolic log.");
                
                CExporterDot* expDot = new CExporterDot();
                expDot->configuration()->setValue(string("display-successes"), (int)seServiceEvent.cdDesignator->floatValue("show-successes"));
                expDot->configuration()->setValue(string("display-failures"), (int)seServiceEvent.cdDesignator->floatValue("show-fails"));
                expDot->configuration()->setValue(string("max-detail-level"), (int)seServiceEvent.cdDesignator->floatValue("max-detail-level"));
                
                this->info("Using max detail level of " + this->str((int)expDot->configuration()->floatValue("max-detail-level")) + ".");
                
                for(Node* ndNode : evCar.lstNodes) {
                  expDot->addNode(ndNode);
                }
                
                expDot->setDesignatorIDs(evCar.lstDesignatorIDs);
                expDot->setDesignatorEquations(evCar.lstEquations);
                expDot->setDesignatorEquationTimes(evCar.lstEquationTimes);
                
                ConfigSettings cfgsetCurrent = configSettings();
                expDot->setOutputFilename(cfgsetCurrent.strExperimentDirectory + seServiceEvent.cdDesignator->stringValue("filename"));
                
                if(expDot->runExporter(NULL)) {
                  this->info("Successfully exported DOT file '" + expDot->outputFilename() + "'", true);
                } else {
                  this->warn("Failed to export to DOT file '" + expDot->outputFilename() + "'", true);
                }
                
                delete expDot;
              }
            }
          }
        }
      }
      
      return evResult;
    }
  }
  
  extern "C" plugins::PLUGIN_CLASS* createInstance() {
    return new plugins::PLUGIN_CLASS();
  }
  
  extern "C" void destroyInstance(plugins::PLUGIN_CLASS* icDestroy) {
    delete icDestroy;
  }
}