sgiteration_maxminmax.hpp

// This file is part of the SGSolve library for stochastic games
// Copyright (C) 2019 Benjamin A. Brooks
// 
// SGSolve 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 3 of the License, or
// (at your option) any later version.
// 
// SGSolve 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/>.
// 
// Benjamin A. Brooks
// ben@benjaminbrooks.net
// Chicago, IL
 
#ifndef _SGITERATION_MAXMINMAX_HPP
#define _SGITERATION_MAXMINMAX_HPP
 
#include "sggame.hpp"
#include "sgstep.hpp"
#include <boost/archive/text_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/serialization/utility.hpp>
 
 
class SGIteration_MaxMinMax
{
private:
  vector< vector<SGBaseAction> > actions; 
  SGTuple threatTuple; 
  list<SGStep> steps; 
public:
  SGIteration_MaxMinMax() {}
 
 
  SGIteration_MaxMinMax (const vector<list<SGAction_MaxMinMax> > & _actions,
          const SGTuple & _threatTuple):
    threatTuple{_threatTuple}
  {
    // Copy the actions and recast them as SGBaseActions
    actions.resize(_actions.size());
    for (int state = 0; state < _actions.size(); state++)
      {
    actions[state].reserve(_actions[state].size());
    for (auto ait = _actions[state].begin();
         ait != _actions[state].end();
         ait++)
      actions[state].push_back(static_cast<SGBaseAction>(*ait));
      }
  }
 
  void push_back(const SGStep & step)
  {
    steps.push_back(step);
  }
  const list<SGStep> & getSteps() const { return steps; }
  const vector< vector<SGBaseAction> > & getActions() const { return actions; }
  const SGTuple & getThreatTuple() const { return threatTuple; }
  
  friend class boost::serialization::access;
  template<class Archive>
 
  void serialize(Archive &ar, const unsigned int version)
  {
    ar & steps;
    ar & actions;
    ar & threatTuple;
  }
}; // SGIteration_MaxMinMax
 
#endif