src/lib/problem.h

Go to the documentation of this file.

/* BurrTools
 *
 * BurrTools is the legal property of its developers, whose
 * names are listed in the COPYRIGHT file, which is included
 * within the source distribution.
 *
 * This program 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.

 * This program 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, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */
#ifndef __PROBLEM_H__
#define __PROBLEM_H__

#include "assembler.h"
#include "bt_assert.h"

#include <stdint.h>
#include <vector>
#include <set>
#include <string>

#include <stdint.h>

class voxel_c;
class separation_c;
class separationInfo_c;
class disassembly_c;
class assembly_c;
class gridType_c;
class puzzle_c;
class part_c;
class solution_c;
class xmlWriter_c;
class xmlParser_c;

typedef enum {
  SS_UNSOLVED,    
  SS_SOLVING,     
  SS_SOLVED,      
  SS_UNKNOWN
} solveState_e;


class problem_c {

private:

  puzzle_c & puzzle;

  std::vector<part_c *> parts;

  unsigned int result;

  std::vector<solution_c*> solutions;

  std::set<uint32_t> colorConstraints;

  assembler_c * assm;

  std::string name;

  solveState_e solveState;

  unsigned long numAssemblies;

  unsigned long numSolutions;

  std::string assemblerState;

  std::string assemblerVersion;

  unsigned long usedTime;

  unsigned int maxHoles;

  void editProblem(void);

public:

  problem_c(puzzle_c & puz);
  problem_c(puzzle_c & puz, xmlParser_c & pars);
  problem_c(const problem_c * prob, puzzle_c & puz);

  ~problem_c(void);

  void save(xmlWriter_c & xml) const;

  const gridType_c * getGridType(void) const;
  gridType_c * getGridType(void);

  const std::string & getName(void) const { return name; }
  void setName(std::string nm) { name = nm; }

  void setResultId(unsigned int shape);
  bool resultValid(void) const;
  unsigned int getResultId(void) const;
  const voxel_c * getResultShape(void) const;
  voxel_c * getResultShape(void);

  void removeShape(unsigned short shapeId);
  void setShapeMinimum(unsigned int shapeId, unsigned int count);
  void setShapeMaximum(unsigned int shapeId, unsigned int count);
  unsigned int getShapeMinimum(unsigned int shapeId) const;
  unsigned int getShapeMaximum(unsigned int shapeId) const;
  bool usesShape(unsigned int shapeId) const;
  unsigned int partNumber(void) const { return parts.size(); }
  unsigned int getShapeMin(unsigned int piece) const;
  unsigned int getShapeMax(unsigned int piece) const;
  unsigned int getShape(unsigned int piece) const;
  unsigned int getShapeId(unsigned int shape) const;
  const voxel_c * getShapeShape(unsigned int piece) const;
  voxel_c * getShapeShape(unsigned int piece);
  void exchangeShape(unsigned int p1, unsigned int p2);
  void exchangeShapeId(unsigned int s1, unsigned int s2);

  unsigned int pieceNumber(void) const;
  unsigned int pieceToShape(unsigned int pieceNr) const;
  unsigned int pieceToSubShape(unsigned int pieceNr) const;

  void allowPlacement(unsigned int pc, unsigned int res);
  void disallowPlacement(unsigned int pc, unsigned int res);
  bool placementAllowed(unsigned int pc, unsigned int res) const;

  void setShapeGroup(unsigned int piece, unsigned short group, unsigned short count);
  unsigned short getShapeGroupNumber(unsigned int piece) const;
  unsigned short getShapeGroup(unsigned int piece, unsigned int groupID) const;
  unsigned short getShapeGroupCount(unsigned int piece, unsigned int groupID) const;

  bool maxHolesDefined(void) const { return maxHoles != 0xFFFFFFFF; }
  unsigned int getMaxHoles(void) const { bt_assert(maxHoles != 0xFFFFFFFF); return maxHoles; }
  void setMaxHoles(unsigned int value) { bt_assert(value < 0xFFFFFFFF); maxHoles = value; }
  void setMaxHolesInvalid(void) { maxHoles = 0xFFFFFFFF; }

  void removeAllSolutions(void);

  assembler_c::errState setAssembler(assembler_c * assm);
  assembler_c * getAssembler(void) { return assm; }
  const assembler_c * getAssembler(void) const { return assm; }
  void incNumAssemblies(void) { bt_assert(solveState == SS_SOLVING); numAssemblies++; }
  void incNumSolutions(void) { bt_assert(solveState == SS_SOLVING); numSolutions++; }
  void addTime(unsigned long time) { bt_assert(solveState == SS_SOLVING); usedTime += time; }
  void addSolution(assembly_c * assm);
  void addSolution(assembly_c * assm, separationInfo_c * disasm, unsigned int pos = 0xFFFFFFFF);
  void addSolution(assembly_c * assm, separation_c * disasm, unsigned int pos = 0xFFFFFFFF);
  void finishedSolving(void) { solveState = SS_SOLVED; }

  void makeUnknown(void);

  solveState_e getSolveState(void) const { return solveState; }
  bool numAssembliesKnown(void) const { return solveState != SS_UNSOLVED; }
  unsigned long getNumAssemblies(void) const { bt_assert(solveState != SS_UNSOLVED); return numAssemblies; }
  bool numSolutionsKnown(void) const { return solveState != SS_UNSOLVED; }
  unsigned long getNumSolutions(void) const { bt_assert(solveState != SS_UNSOLVED); return numSolutions; }
  bool usedTimeKnown(void) const { return solveState != SS_UNSOLVED; }
  unsigned long getUsedTime(void) const { bt_assert(solveState != SS_UNSOLVED); return usedTime; }
  unsigned int solutionNumber(void) const { return solutions.size(); }

  const solution_c * getSolution(unsigned int sol) const { bt_assert(sol < solutions.size()); return solutions[sol]; }
  solution_c * getSolution(unsigned int sol) { bt_assert(sol < solutions.size()); return solutions[sol]; }


  void removeSolution(unsigned int sol);

  void sortSolutions(int by);

private:

  // no copying and assigning
  problem_c(const problem_c&);
  void operator=(const problem_c&);

};

#endif

---