.. _program_listing_file_src_VALfiles_misc_HowAnalyser.h:

Program Listing for File HowAnalyser.h
======================================

|exhale_lsh| :ref:`Return to documentation for file <file_src_VALfiles_misc_HowAnalyser.h>` (``src/VALfiles/misc/HowAnalyser.h``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   /************************************************************************
    * Copyright 2008, Strathclyde Planning Group,
    * Department of Computer and Information Sciences,
    * University of Strathclyde, Glasgow, UK
    * http://planning.cis.strath.ac.uk/
    *
    * Maria Fox, Richard Howey and Derek Long - VAL
    * Stephen Cresswell - PDDL Parser
    *
    * This file is part of VAL, the PDDL validator.
    *
    * VAL 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.
    *
    * VAL 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 VAL.  If not, see <http://www.gnu.org/licenses/>.
    *
    ************************************************************************/
   
   #ifndef __HOWANALYSER
   #define __HOWANALYSER
   
   #include "ptree.h"
   #include "VisitController.h"
   #include <iostream>
   #include "TypedAnalyser.h"
   #include "TimSupport.h"
   #include <set>
   
   using std::set;
   using std::cout;
   using namespace TIM;
   
   namespace VAL {
   
   class AbstractGraph;
   
   class HWWAction {
   private:
       typedef map<vector<int>,vector<extended_pred_symbol *> > ArgSets;
       ArgSets argSets;
   public:
       HWWAction(operator_ * op) 
       {};
   
       void add(const vector<int> & v,extended_pred_symbol * pd)
       {
           argSets[v].push_back(pd);
       };
   
       void write(ostream & o) const
       {
           for(ArgSets::const_iterator i = argSets.begin();i != argSets.end();++i)
           {
               o << "{";
               for(unsigned int j = 0;j < i->first.size();++j)
               {
                   o << (i->first)[j] << " ";
               };
               o << "}";
           };
       };
   
       void analyse(action * a)
       {
           for(ArgSets::const_iterator i = argSets.begin();i != argSets.end();++i)
           {
               cout << "Argument set: {";
               for(unsigned int j = 0;j < i->first.size();++j)
               {
                   cout << (i->first)[j] << " ";
               };
               cout << "}\n";
               conj_goal * cg = dynamic_cast<conj_goal *>(a->precondition);
               if(!cg)
               {
                   cout << "Complex precondition\n";
                   continue;
               };
               for(goal_list::const_iterator g = cg->getGoals()->begin();g != cg->getGoals()->end();++g)
               {
                   const simple_goal * sg = dynamic_cast<const simple_goal *>(*g);
                   if(!sg)
                   {
                       cout << **g << " is not a simple goal\n";
                       continue;
                   };
                   cout << "Going to analyse: ";
                   EPS(sg->getProp()->head)->writeName(cout);
                   cout << "\n";
                   
               };
           };
       };
   };
   
   inline ostream & operator << (ostream & o,const HWWAction & a)
   {
       a.write(o);
       return o;
   };
   
   class HowAnalyser : public VisitController {
   private:
       map<operator_*,HWWAction *> acts;
   
       set<extended_pred_symbol *> epss;
       AbstractGraph * ag;
       
   public:
       HowAnalyser();
   
       void completeGraph();
       
       virtual void visit_action(action * a);
   
       virtual void visit_effect_lists(effect_lists * el)
       {
           for(pc_list<simple_effect *>::iterator i = el->add_effects.begin();
                   i != el->add_effects.end();++i)
           {
               (*i)->visit(this);
           };
   
           for(pc_list<assignment *>::iterator i = el->assign_effects.begin();
                   i != el->assign_effects.end();++i)
           {
               (*i)->visit(this);
           };
   
           for(pc_list<timed_effect *>::iterator i = el->timed_effects.begin();
                   i != el->timed_effects.end();++i)
           {
               (*i)->visit(this);
           };
       };
   
       virtual void visit_simple_effect(simple_effect * se);
       virtual void visit_timed_effect(timed_effect * te)
       {
           cout << "Timed initial literal: not yet handled\n";
       };
   
       virtual void visit_assignment(assignment * a)
       {
           cout << "Initial assignment value: not yet considered\n";
       };
       
       virtual void visit_pred_decl(pred_decl * p)
       {
           if(dynamic_cast<TIMpred_decl*>(p) != 0) return;
   
           cout << "\nVisiting " << p->getPred()->getName() << "\n";
           
           holding_pred_symbol * hps = HPS(p->getPred());
           if(hps)
           {
               for(holding_pred_symbol::PIt i = hps->pBegin();i != hps->pEnd();++i)
               {
                   (*i)->writeName(cout); 
                   cout << ": ";
                   if((*i)->isStatic()) 
                   {
                       cout << "Static (or wrong type level)";
                   }
                   else if((*i)->decays()) 
                   {
                       cout << "Decays";
                   }
                   else 
                   {
                       cout << (*i)->addsEnd()-(*i)->addsBegin() << " choices:";
                       for(extended_pred_symbol::OpProps::const_iterator j = (*i)->addsBegin();
                               j != (*i)->addsEnd();++j)
                       {
                           if(acts.find(j->op) == acts.end())
                           {
                               acts.insert(make_pair(j->op,new HWWAction(j->op)));
                           };
                           int pc = 0;
                           vector<int> ags;
                           cout << "\n\t" << *(j->op->name) << "(";
                           for(var_symbol_list::const_iterator k = j->op->parameters->begin();
                                   k != j->op->parameters->end();++k,++pc)
                           {
                               unsigned int ac = 0;
                               bool d = false;
                               parameter_symbol_list::const_iterator x = j->second->args->begin();
                               for(ac=0;ac < j->second->args->size();++x,++ac)
                               {
                                   if(*x == *k)
                                   {
                                       cout << "P[" << ac << "] ";
                                       ags.push_back(pc);
                                       d = true;
                                   };
                               };
                               if(!d) 
                               {
                                   cout << "{" << theTC->range(*k).size() << " choices of ";
                                   
                                   if((*k)->type) 
                                   {
                                       cout << (*k)->type->getName();
                                       
                                       vector<const pddl_type *> ls = theTC->leaves((*k)->type);
                                       if(!ls.empty())
                                       {
                                           cout << " [";
                                           for(vector<const pddl_type *>::const_iterator x = ls.begin();
                                                   x != ls.end();++x)
                                           {
                                               cout << (*x)->getName() << " ";
                                           };
                                           cout << "]";
                                       };
                                   }
                                   else
                                   {
                                       cout << "?";
                                   };
                                   cout << "} ";
                                   
                               };
                           };
                           cout << ")";
                           acts[j->op]->add(ags,*i);
                       };
                   };
                   cout << "\n";
                   TIMpredSymbol * tps = TPS(*i);
                   
                   if(tps && !(*i)->isStatic())
                   {
                       bool something = false;
                       cout << "TIM says:\n";
                       for(int a = 0;a < tps->arity();++a)
                       {
                           if(tps->property(a)->isSingleValued())
                           {
                               cout << *(tps->property(a)) << " is ";
                               cout << "single valued\n";
                               something = true;
                           }
                           
                       };
                       if(!something) 
                       {
                           cout << "nothing interesting here\n";
                       };
                   };
               };
           };  
       };
   };
   
   };
   
   #endif