sgsolution_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 _SGSOLUTION_MAXMINMAX_HPP
#define _SGSOLUTION_MAXMINMAX_HPP
 
#include "sggame.hpp"
#include "sgiteration_maxminmax.hpp"
#include <boost/archive/text_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>
#include <boost/archive/binary_oarchive.hpp>
#include <boost/serialization/utility.hpp>
 
 
class SGSolution_MaxMinMax
{
private:
  SGGame game; 
  list<SGIteration_MaxMinMax> iterations; 
public:
  SGSolution_MaxMinMax() {}
  SGSolution_MaxMinMax(const SGGame& _game):
    game(_game)
  {}
 
  const SGGame & getGame() const { return game; }
  const list<SGIteration_MaxMinMax> & getIterations() const { return iterations; }
  
  void clear() {iterations.clear(); }
  void push_back(const SGIteration_MaxMinMax & iteration)
  { iterations.push_back(iteration); }
 
  template<class Archive>
  void serialize(Archive &ar, const unsigned int version)
  {
    ar & game & iterations;
  }
 
  static void save(const SGSolution_MaxMinMax & soln, const char* filename)
  {
    std::ofstream ofs(filename,std::fstream::out);
 
    if (ofs.good())
      {
    boost::archive::binary_oarchive oa(ofs);
    oa << soln;
      }
    else
      throw(SGException(SG::FAILED_OPEN));
 
    ofs.close();
  }
 
  static void load(SGSolution_MaxMinMax & soln, const char* filename)
  {
    std::ifstream ifs(filename,std::fstream::in);
    if (ifs.good() && ifs.is_open())
      {
    boost::archive::binary_iarchive ia(ifs);
    ia >> soln;
      }
    else
      throw(SGException(SG::FAILED_OPEN));
 
    ifs.close();
  }
 
  friend class boost::serialization::access;
}; // SGSolution_MaxMinMax
 
#endif