src/lib/assembler.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 __ASSEMBLER_H__
#define __ASSEMBLER_H__

class voxel_c;
class assembly_c;
class problem_c;
class xmlWriter_c;

class assembler_cb {

public:

  /* this function gets called once for every assembly
   * found by an assembler. It gets the found assembly
   * as parameter
   */
  virtual bool assembly(assembly_c * a) = 0;

  virtual ~assembler_cb(void) {}
};

class assembler_c {

public:

  typedef enum {
    ERR_NONE,                    
    ERR_TOO_MANY_UNITS,          
    ERR_TOO_FEW_UNITS,           
    ERR_CAN_NOT_PLACE,           
    ERR_CAN_NOT_RESTORE_VERSION, 
    ERR_CAN_NOT_RESTORE_SYNTAX,  
    ERR_PUZZLE_UNHANDABLE        
  } errState;

  assembler_c(void) {}

  virtual ~assembler_c(void) { }

  virtual errState createMatrix(const problem_c * /*puz*/, bool /*keepMirror*/, bool /*keepRotations*/, bool /*complete*/);

  virtual int getErrorsParam(void) { return 0; }

  virtual void reduce(void) { }

  virtual unsigned int getReducePiece(void) const { return 0; }

  virtual void assemble(assembler_cb * /*callback*/) {}

  virtual unsigned long getIterations(void) { return 0; }

  virtual float getFinished(void) const { return 0; }

  virtual void stop(void) {}

  virtual bool stopped(void) const { return false; }

  virtual errState setPosition(const char * string, const char * version);

  virtual void save(xmlWriter_c & xml) const;

  /* some more special information to find out possible piece placements */

  /* it is optional to support this interface. The user alsway has to first check
   * if the Supported function returns true, if not the functionality is not
   * supported
   */
  virtual bool getPiecePlacementSupported(void) const { return false; }

  /* return the number of placements for a given _PIECE_ not the shape */
  virtual unsigned int getPiecePlacementCount(unsigned int /*piece*/) const { return 0; }

  /* returns the placement of a piece (orientation, and position). Node gives a current position
   * inside some internal data structure, the new position is returned as return value, for initialisation
   * give 0 as node. Delta is the number of placements you want to go back of forward. So
   * node = getPiecePlacement(0, 10, ...) returns the 11-th placement of the given piece (1st plus 10 forward)
   */
  virtual unsigned int getPiecePlacement(unsigned int /*node*/, int /*delta*/,
      unsigned int /*piece*/, unsigned char * /*ran*/, int * /*x*/, int * /*y*/, int * /*z*/) const { return 0; }


  /* finally some debugging functions that allow to look how, why, and where pieces are placed */

  /* do exactly the given number of rounds in the assembler, and then stop */
  virtual void debug_step(unsigned long /*num*/) {};

  /* returns the assembly for the current state of the assembler or the solution assembly, if
   * the assembler is currently at a solution
   */
  virtual assembly_c * getAssembly(void) = 0;

private:

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

};

#endif

---