src/lib/disassembly.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 __DISASSEMBLY_H__
#define __DISASSEMBLY_H__

/* this module contains the datastructures to store the instruction how to assemble
 * and disassemble a puzzle
 */

#include "bt_assert.h"

#include <deque>
#include <vector>

class xmlWriter_c;
class xmlParser_c;


class disassembly_c
{

  public:

    disassembly_c(void) {}
    virtual ~disassembly_c(void) {}

    virtual unsigned int sumMoves(void) const = 0;
    virtual void movesText(char * txt, int len) const = 0;

    int compare(const disassembly_c * s2) const;

  protected:

    virtual unsigned int getSequenceLength(unsigned int x) const = 0;

    virtual unsigned int getNumSequences(void) const = 0;

  private:

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


class state_c {

  int *dx;
  int *dy;
  int *dz;

#ifndef NDEBUG

  unsigned int piecenumber;
#endif

public:

  state_c(unsigned int pn);

  state_c(const state_c * cpy, unsigned int pn);

  state_c(xmlParser_c & pars, unsigned int pn);

  ~state_c();

  void save(xmlWriter_c & xml, unsigned int piecenumber) const;

  void set(unsigned int piece, int x, int y, int z);

  int getX(unsigned int i) const {
    bt_assert(i < piecenumber);
    return dx[i];
  }
  int getY(unsigned int i) const {
    bt_assert(i < piecenumber);
    return dy[i];
  }
  int getZ(unsigned int i) const {
    bt_assert(i < piecenumber);
    return dz[i];
  }

  bool pieceRemoved(unsigned int i) const;

#ifndef NDEBUG

  unsigned int getPiecenumber(void) const { return piecenumber; }
#endif

private:

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


class separation_c : public disassembly_c
{

  std::vector<unsigned int> pieces;

  std::deque <state_c *> states;

  /* the 2 parts the puzzle gets divided with the
   * last move. If one of this parts consists of only
   * one piece there will be a null pointer
   */
  separation_c * removed, *left;

  bool containsMultiMoves(void);

  unsigned int numSequences;

  int movesText2(char * txt, int len) const;

public:

  separation_c(separation_c * r, separation_c * l, const std::vector<unsigned int> & pcs);

  separation_c(xmlParser_c & pars, unsigned int pieces);

  separation_c(const separation_c * cpy);

  /* save into an xml node, please always call with just xml, the type is for internal use */
  void save(xmlWriter_c & xml, int type = 0) const;

  ~separation_c();

  unsigned int getMoves(void) const { return states.size() - 1; }

  const state_c * getState(unsigned int num) const {
    bt_assert(num < states.size());
    return states[num];
  }

  const separation_c * getLeft(void) const { return left; }

  const separation_c * getRemoved(void) const { return removed; }

  void addstate(state_c *st);

  unsigned int getPieceNumber(void) const { return pieces.size(); }

  unsigned int getPieceName(unsigned int num) const {
    bt_assert(num < pieces.size());
    return pieces[num];
  }

  void exchangeShape(unsigned int s1, unsigned int s2);

  /* implementation of the base class functions */
  virtual unsigned int getSequenceLength(unsigned int x) const;
  virtual unsigned int getNumSequences(void) const;
  virtual unsigned int sumMoves(void) const;
  virtual void movesText(char * txt, int len) const { movesText2(txt, len); }

  void removePieces(unsigned int from, unsigned int cnt);
  void addNonPlacedPieces(unsigned int from, unsigned int cnt);

private:

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

class separationInfo_c : public disassembly_c {

  private:

    std::vector<unsigned int> values;

    bool containsMultiMoves(unsigned int root) const;

    void recursiveConstruction(const separation_c * sep);

    int movesText2(char * txt, int len, unsigned int idx) const;

  public:

    separationInfo_c(xmlParser_c & pars);

    separationInfo_c(const separation_c * sep);

    void save(xmlWriter_c & xml) const;

    /* implement abstract functions */
    virtual unsigned int sumMoves(void) const;
    virtual void movesText(char * txt, int len) const { movesText2(txt, len, 0); }
    virtual unsigned int getSequenceLength(unsigned int x) const;
    virtual unsigned int getNumSequences(void) const;

  private:

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


#endif

---