sgsolution_pencilsharpening.hpp

// This file is part of the SGSolve library for stochastic games
// Copyright (C) 2016 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_HPP
#define _SGSOLUTION_HPP
 
#include "sggame.hpp"
#include "sgiteration_pencilsharpening.hpp"
#include <boost/archive/text_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/serialization/utility.hpp>
 
 
class SGSolution_PencilSharpening
{
private:
  SGGame game; 
  list<SGIteration_PencilSharpening> iterations; 
  list<SGTuple> extremeTuples; 
public:
  SGSolution_PencilSharpening() {}
  SGSolution_PencilSharpening(const SGGame& _game):
    game(_game)
  {}
 
  const SGGame & getGame() const { return game; }
  const list<SGIteration_PencilSharpening> & getIterations() const { return iterations; }
  const list<SGTuple> & getExtremeTuples() const { return extremeTuples; }
  
  void clear() {iterations.clear(); extremeTuples.clear();}
  void push_back(const SGIteration_PencilSharpening & iteration)
  { iterations.push_back(iteration); }
  void push_back(const SGTuple & tuple)
  { extremeTuples.push_back(tuple); }
  void pop_back()
  { extremeTuples.pop_back(); }
 
  template<class Archive>
  void serialize(Archive &ar, const unsigned int version)
  {
    ar & game & iterations & extremeTuples;
  }
 
  static void save(const SGSolution_PencilSharpening & soln, const char* filename)
  {
    std::ofstream ofs(filename,std::fstream::out);
 
    if (ofs.good())
      {
    boost::archive::text_oarchive oa(ofs);
    oa << soln;
      }
    else
      throw(SGException(SG::FAILED_OPEN));
  }
 
  static void load(SGSolution_PencilSharpening & soln, const char* filename)
  {
    std::ifstream ifs(filename,std::fstream::in);
    if (ifs.good() && ifs.is_open())
      {
    boost::archive::text_iarchive ia(ifs);
    ia >> soln;
      }
    else
      throw(SGException(SG::FAILED_OPEN));
  }
 
  friend class boost::serialization::access;
}; // SGSolution
 
#endif