From b9b11d401e8b7ab1891f518e408ad4bf54871a82 Mon Sep 17 00:00:00 2001 From: Love Billenius Date: Wed, 11 Sep 2024 17:32:59 +0200 Subject: [PATCH] Init --- .gitignore | 12 + Boggle.pro | 60 ++ lib/StanfordCPPLib/error.cpp | 42 ++ lib/StanfordCPPLib/error.h | 56 ++ lib/StanfordCPPLib/foreach.h | 217 ++++++ lib/StanfordCPPLib/grid.h | 549 ++++++++++++++ lib/StanfordCPPLib/lexicon.cpp | 316 ++++++++ lib/StanfordCPPLib/lexicon.h | 366 +++++++++ lib/StanfordCPPLib/map.h | 919 +++++++++++++++++++++++ lib/StanfordCPPLib/private/_main.h_ | 218 ++++++ lib/StanfordCPPLib/private/main.h | 62 ++ lib/StanfordCPPLib/private/randompatch.h | 63 ++ lib/StanfordCPPLib/private/tokenpatch.h | 11 + lib/StanfordCPPLib/private/tplatform.h | 25 + lib/StanfordCPPLib/random.cpp | 99 +++ lib/StanfordCPPLib/random.h | 58 ++ lib/StanfordCPPLib/set.h | 628 ++++++++++++++++ lib/StanfordCPPLib/simpio.cpp | 67 ++ lib/StanfordCPPLib/simpio.h | 53 ++ lib/StanfordCPPLib/stack.h | 285 +++++++ lib/StanfordCPPLib/strlib.cpp | 240 ++++++ lib/StanfordCPPLib/strlib.h | 222 ++++++ lib/StanfordCPPLib/vector.h | 727 ++++++++++++++++++ res/EnglishWords.dat | Bin 0 -> 345126 bytes res/expected-output-1.txt | 144 ++++ res/expected-output-2.txt | 232 ++++++ src/Boggle.cpp | 22 + src/Boggle.h | 29 + src/bogglemain.cpp | 79 ++ src/bogglemain.h | 21 + src/boggleplay.cpp | 32 + src/readme.txt | 3 + src/shuffle.h | 78 ++ 33 files changed, 5935 insertions(+) create mode 100755 .gitignore create mode 100755 Boggle.pro create mode 100755 lib/StanfordCPPLib/error.cpp create mode 100755 lib/StanfordCPPLib/error.h create mode 100755 lib/StanfordCPPLib/foreach.h create mode 100755 lib/StanfordCPPLib/grid.h create mode 100755 lib/StanfordCPPLib/lexicon.cpp create mode 100755 lib/StanfordCPPLib/lexicon.h create mode 100755 lib/StanfordCPPLib/map.h create mode 100755 lib/StanfordCPPLib/private/_main.h_ create mode 100755 lib/StanfordCPPLib/private/main.h create mode 100755 lib/StanfordCPPLib/private/randompatch.h create mode 100755 lib/StanfordCPPLib/private/tokenpatch.h create mode 100755 lib/StanfordCPPLib/private/tplatform.h create mode 100755 lib/StanfordCPPLib/random.cpp create mode 100755 lib/StanfordCPPLib/random.h create mode 100755 lib/StanfordCPPLib/set.h create mode 100755 lib/StanfordCPPLib/simpio.cpp create mode 100755 lib/StanfordCPPLib/simpio.h create mode 100755 lib/StanfordCPPLib/stack.h create mode 100755 lib/StanfordCPPLib/strlib.cpp create mode 100755 lib/StanfordCPPLib/strlib.h create mode 100755 lib/StanfordCPPLib/vector.h create mode 100755 res/EnglishWords.dat create mode 100755 res/expected-output-1.txt create mode 100755 res/expected-output-2.txt create mode 100755 src/Boggle.cpp create mode 100755 src/Boggle.h create mode 100755 src/bogglemain.cpp create mode 100755 src/bogglemain.h create mode 100755 src/boggleplay.cpp create mode 100755 src/readme.txt create mode 100755 src/shuffle.h diff --git a/.gitignore b/.gitignore new file mode 100755 index 0000000..cfa84e5 --- /dev/null +++ b/.gitignore @@ -0,0 +1,12 @@ +*~ + +.DS_Store + +*.pro.user.* +*.pro.user + +build-*/ +*.app +*.exe + +build diff --git a/Boggle.pro b/Boggle.pro new file mode 100755 index 0000000..56b1b65 --- /dev/null +++ b/Boggle.pro @@ -0,0 +1,60 @@ +TEMPLATE = app + +CONFIG += console +# Make sure we do not accidentally #include files placed in 'resources' +CONFIG += no_include_pwd + +# Do not create an app bundle when running on OS X +#CONFIG -= app_bundle + +SOURCES = $$PWD/src/*.cpp +SOURCES += $$PWD/lib/StanfordCPPLib/*.cpp + +HEADERS = $$PWD/src/*.h +HEADERS += $$PWD/lib/StanfordCPPLib/*.h + +# GCC defaults to not warning about failing to return from a non-void function +# We enable this warning manually, since Clang warns by default +QMAKE_CXXFLAGS += -std=c++11 -Wreturn-type + +INCLUDEPATH += $$PWD/lib/StanfordCPPLib/ + +# Copies the given files to the destination directory +# The rest of this file defines how to copy the resources folder +defineTest(copyToDestdir) { + files = $$1 + + for(FILE, files) { + DDIR = $$OUT_PWD + + # Replace slashes in paths with backslashes for Windows + win32:FILE ~= s,/,\\,g + win32:DDIR ~= s,/,\\,g + + !win32 { + copyResources.commands += cp -r '"'$$FILE'"' '"'$$DDIR'"' $$escape_expand(\\n\\t) + } + win32 { + copyResources.commands += xcopy '"'$$FILE'"' '"'$$DDIR'"' /e /y $$escape_expand(\\n\\t) + } + } + export(copyResources.commands) +} + +!win32 { + copyToDestdir($$files($$PWD/res/*)) + copyToDestdir($$files($$PWD/lib/*.jar)) +} +win32 { + copyToDestdir($$PWD/res) + copyToDestdir($$PWD/lib/*.jar) +} + +copyResources.input = $$files($$PWD/res/*) +OTHER_FILES = $$files(res/*) +QMAKE_EXTRA_TARGETS += copyResources +POST_TARGETDEPS += copyResources + +macx { + cache() +} diff --git a/lib/StanfordCPPLib/error.cpp b/lib/StanfordCPPLib/error.cpp new file mode 100755 index 0000000..928b4f5 --- /dev/null +++ b/lib/StanfordCPPLib/error.cpp @@ -0,0 +1,42 @@ +/* + * File: error.cpp + * --------------- + * Implementation of the error function. + */ + +#include +#include +#include +#include "error.h" +using namespace std; + +/* Definitions for the ErrorException class */ + +ErrorException::ErrorException(string msg) { + this->msg = msg; +} + +ErrorException::~ErrorException() throw () { + /* Empty */ +} + +string ErrorException::getMessage() const { + return msg; +} + +const char *ErrorException::what() const throw () { + return msg.c_str(); +} + +/* + * Implementation notes: error + * --------------------------- + * Earlier implementations of error made it possible, at least on the + * Macintosh, to help the debugger generate a backtrace at the point + * of the error. Unfortunately, doing so is no longer possible if + * the errors are catchable. + */ + +void error(string msg) { + throw ErrorException(msg); +} diff --git a/lib/StanfordCPPLib/error.h b/lib/StanfordCPPLib/error.h new file mode 100755 index 0000000..359ea99 --- /dev/null +++ b/lib/StanfordCPPLib/error.h @@ -0,0 +1,56 @@ +/* + * File: error.h + * ------------- + * This file defines the ErrorException class and the + * error function. + */ + +#ifndef _error_h +#define _error_h + +#include +#include + +/* + * Class: ErrorException + * --------------------- + * This exception is thrown by calls to the error + * function. Typical code for catching errors looks like this: + * + *
+ *    try {
+ *       ... code in which an error might occur ...
+ *    } catch (ErrorException & ex) {
+ *       ... code to handle the error condition ...
+ *    }
+ *
+ * + * If an ErrorException is thrown at any point in the + * range of the try (including in functions called from + * that code), control will jump immediately to the error handler. + */ + +class ErrorException : public std::exception { +public: + ErrorException(std::string msg); + virtual ~ErrorException() throw (); + virtual std::string getMessage() const; + virtual const char *what() const throw (); + +private: + std::string msg; +}; + +/* + * Function: error + * Usage: error(msg); + * ------------------ + * Signals an error condition in a program by throwing an + * ErrorException with the specified message. + */ + +void error(std::string msg); + +#include "private/main.h" + +#endif diff --git a/lib/StanfordCPPLib/foreach.h b/lib/StanfordCPPLib/foreach.h new file mode 100755 index 0000000..15a758b --- /dev/null +++ b/lib/StanfordCPPLib/foreach.h @@ -0,0 +1,217 @@ +/* + * File: foreach.h + * --------------- + * This file defines the foreach keyword, which implements + * a substitute for the range-based for loop from C++11. + * All iterable classes in the Stanford libraries import this file, so + * clients don't ordinarily need to do so explicitly. This version of + * foreach also supports C++ strings and arrays. + */ + +#ifndef _foreach_h +#define _foreach_h + +/* + * Statement: foreach + * Usage: foreach (type var in collection) { ... } + * ----------------------------------------------- + * The foreach statement steps through the elements in + * a collection. It works correctly with the collection classes in + * both the Standard Template Library and the Stanford C++ libraries, + * but can also be used with C++ strings and statically initialized + * arrays. + * + *

The following code, for example, prints every element in the + * string vector lines: + * + *

+ *    foreach (string str in lines) {
+ *       cout << str << endl;
+ *    }
+ *
+ * + * Similarly, the following function calculates the sum of the character + * codes in a string: + * + *
+ *    int sumCharacterCodes(string str) {
+ *       int sum = 0;
+ *       foreach (char ch in str) sum += ch;
+ *       return sum;
+ *    }
+ *
+ * + * As a simplification when iterating over maps, the foreach + * macro iterates through the keys rather than the key/value pairs. + */ + +/* Private section */ + +/**********************************************************************/ +/* Note: Everything below this point in the file is logically part */ +/* of the implementation and should not be of interest to clients. */ +/**********************************************************************/ + +#include +#include +#include +#include + +/* These #includes are for files that contain "in" as a token */ + +#include +#include +#include +using namespace std; + +/* Redefine the ios constants (one of which is "in") */ + +static const ios::openmode IOS_APP = ios::app; +static const ios::openmode IOS_ATE = ios::ate; +static const ios::openmode IOS_BINARY = ios::binary; +static const ios::openmode IOS_IN = ios::in; +static const ios::openmode IOS_OUT = ios::out; +static const ios::openmode IOS_TRUNC = ios::trunc; + +/* Private implementation namespace */ + +namespace _fe { + struct Range { + virtual ~Range() { }; + }; + + template + struct ArrayRange : Range { + ArrayRange(const T *begin, const T *end) : iter(begin), end(end) { } + const T *iter; + const T *end; + }; + + template + struct CRange : Range { + CRange(const CType& c) : + cont(c), iter(cont.begin()), end(cont.end()) { } + CType cont; + typename CType::iterator iter, end; + }; + + template + struct MapRange : Range { + MapRange(const map & c) : + cont(c), iter(cont.begin()), end(cont.end()) { } + map cont; + typename map::iterator iter, end; + }; + +/* + * The State struct glues together all of these pieces and + * stores all of the information throughout the loops. + */ + + struct State { + State() : state(0), itr(NULL) { } + ~State() { delete itr; } + int state; + Range *itr; + }; + +/* General hook function */ + + template + ValueType HookImpl(State& fe) { + DowncastType *ip = (DowncastType *) fe.itr; + if (ip->iter == ip->end) { + fe.state = 2; + return ValueType(); + } + fe.state = 1; + ValueType vp = *ip->iter; /* Subtle implementation note: */ + ++ip->iter; /* Using *ip->iter++ here would */ + return vp; /* require copying the iterator. */ + } + +/* Foreach implementation for containers */ + + template + CRange *Init(State & fe, const CType & collection) { + fe.itr = new CRange(collection); + return (CRange*) fe.itr; + } + + template + typename iterator_traits::value_type + Hook(State & fe, CRange *) { + return HookImpl, + typename iterator_traits::value_type>(fe); + } + +/* For maps */ + + template + MapRange *Init(State & fe, const map & collection) { + fe.itr = new MapRange(collection); + return (MapRange*) fe.itr; + } + + template + ValueType MapHookImpl(State & fe) { + DowncastType *ip = (DowncastType *) fe.itr; + if (ip->iter == ip->end) { + fe.state = 2; + return ValueType(); + } + fe.state = 1; + ValueType key = ip->iter->first; + ++ip->iter; + return key; + } + + template + K Hook(State & fe, MapRange *) { + return MapHookImpl,K>(fe); + } + +/* For C strings */ + + template + ArrayRange *Init(State & fe, char (&str)[n]) { + fe.itr = new ArrayRange(str, str + strlen(str)); + return (ArrayRange*) fe.itr; + } + + template + ArrayRange *Init(State & fe, const char (&str)[n]) { + fe.itr = new ArrayRange(str, str + strlen(str)); + return (ArrayRange*) fe.itr; + } + +/* For arrays */ + + template + ArrayRange *Init(State & fe, T (&arr)[n]) { + fe.itr = new ArrayRange(arr, arr + n); + return (ArrayRange*) fe.itr; + } + + template + ArrayRange *Init(State & fe, const T (&arr)[n]) { + fe.itr = new ArrayRange(arr, arr + n); + return (ArrayRange*) fe.itr; + } + + template + T Hook(State& fe, ArrayRange*) { + return HookImpl, T>(fe); + } + +} + +/* The actual foreach and in macros */ + +#define foreach(arg) \ + for (_fe::State _fe; _fe.state < 2; ) \ + for (arg)); _fe.state++ == 1; _fe.state = 0) + +#define in = _fe::Hook(_fe, _fe.state != 0 ? NULL : _fe::Init(_fe, + +#endif diff --git a/lib/StanfordCPPLib/grid.h b/lib/StanfordCPPLib/grid.h new file mode 100755 index 0000000..406edc9 --- /dev/null +++ b/lib/StanfordCPPLib/grid.h @@ -0,0 +1,549 @@ +/* + * File: grid.h + * ------------ + * This file exports the Grid class, which offers a + * convenient abstraction for representing a two-dimensional array. + */ + +#ifndef _grid_h +#define _grid_h + +#include +#include +#include +#include +//#include "strlib.h" +/* + * Class: Grid + * ---------------------- + * This class stores an indexed, two-dimensional array. The following code, + * for example, creates an identity matrix of size n, in which + * the elements are 1.0 along the main diagonal and 0.0 everywhere else: + * + *
+ *    Grid<double> createIdentityMatrix(int n) {
+ *       Grid<double> matrix(n, n);
+ *       for (int i = 0; i < n; i++) {
+ *          matrix[i][i] = 1.0;
+ *       }
+ *       return matrix;
+ *    }
+ *
+ */ + +template +class Grid { + +public: + + /* Forward reference */ + class GridRow; + class ConstGridRow; + + /* + * Constructor: Grid + * Usage: Grid grid; + * Grid grid(nRows, nCols); + * ------------------------------------------ + * Initializes a new grid. The second form of the constructor is + * more common and creates a grid with the specified number of rows + * and columns. Each element of the grid is initialized to the + * default value for the type. The default constructor creates an + * empty grid for which the client must call resize to + * set the dimensions. + */ + + Grid(); + Grid(int nRows, int nCols); + + /* + * Destructor: ~Grid + * ----------------- + * Frees any heap storage associated with this grid. + */ + + virtual ~Grid(); + + /* + * Method: numRows + * Usage: int nRows = grid.numRows(); + * ---------------------------------- + * Returns the number of rows in the grid. + */ + + int numRows() const; + + /* + * Method: numCols + * Usage: int nCols = grid.numCols(); + * ---------------------------------- + * Returns the number of columns in the grid. + */ + + int numCols() const; + + /* + * Method: resize + * Usage: grid.resize(nRows, nCols); + * --------------------------------- + * Reinitializes the grid to have the specified number of rows + * and columns. Any previous grid contents are discarded. + */ + + void resize(int nRows, int nCols); + + /* + * Method: inBounds + * Usage: if (grid.inBounds(row, col)) ... + * --------------------------------------- + * Returns true if the specified row and column position + * is inside the bounds of the grid. + */ + + bool inBounds(int row, int col) const; + + /* + * Method: get + * Usage: ValueType value = grid.get(row, col); + * -------------------------------------------- + * Returns the element at the specified row/col + * position in this grid. This method signals an error if the + * row and col arguments are outside + * the grid boundaries. + */ + + ValueType get(int row, int col); + const ValueType & get(int row, int col) const; + + /* + * Method: set + * Usage: grid.set(row, col, value); + * --------------------------------- + * Replaces the element at the specified row/col + * location in this grid with a new value. This method signals an error + * if the row and col arguments are outside + * the grid boundaries. + */ + + void set(int row, int col, ValueType value); + + /* + * Operator: [] + * Usage: grid[row][col] + * ---------------------- + * Overloads [] to select elements from this grid. + * This extension enables the use of traditional array notation to + * get or set individual elements. This method signals an error if + * the row and col arguments are outside + * the grid boundaries. + */ + + GridRow operator[](int row); + const ConstGridRow operator[](int row) const; + + /* + * Method: toString + * Usage: string str = grid.toString(); + * ------------------------------------ + * Converts the grid to a printable string representation. + */ + + std::string toString(); + + /* + * Method: mapAll + * Usage: grid.mapAll(fn); + * ----------------------- + * Calls the specified function on each element of the grid. The + * elements are processed in row-major order, in which + * all the elements of row 0 are processed, followed by the elements + * in row 1, and so on. + */ + + void mapAll(void (*fn)(ValueType value)) const; + void mapAll(void (*fn)(const ValueType & value)) const; + + template + void mapAll(FunctorType fn) const; + + /* + * Additional Grid operations + * -------------------------- + * In addition to the methods listed in this interface, the Grid + * class supports the following operations: + * + * - Stream I/O using the << and >> operators + * - Deep copying for the copy constructor and assignment operator + * - Iteration using the range-based for statement and STL iterators + * + * The iteration forms process the grid in row-major order. + */ + + /* Private section */ + + /**********************************************************************/ + /* Note: Everything below this point in the file is logically part */ + /* of the implementation and should not be of interest to clients. */ + /**********************************************************************/ + + /* + * Implementation notes: Grid data structure + * ----------------------------------------- + * The Grid is internally managed as a dynamic array of elements. + * The array itself is one-dimensional, the logical separation into + * rows and columns is done by arithmetic computation. The layout + * is in row-major order, which is to say that the entire first row + * is laid out contiguously, followed by the entire second row, + * and so on. + */ + + /* Instance variables */ + + ValueType *elements; /* A dynamic array of the elements */ + int nRows; /* The number of rows in the grid */ + int nCols; /* The number of columns in the grid */ + + /* Private method prototypes */ + + void checkRange(int row, int col); + + /* + * Hidden features + * --------------- + * The remainder of this file consists of the code required to + * support deep copying and iteration. Including these methods + * in the public interface would make that interface more + * difficult to understand for the average client. + */ + + /* + * Deep copying support + * -------------------- + * This copy constructor and operator= are defined to make a + * deep copy, making it possible to pass/return grids by value + * and assign from one grid to another. The entire contents of + * the grid, including all elements, are copied. Each grid + * element is copied from the original grid to the copy using + * assignment (operator=). Making copies is generally avoided + * because of the expense and thus, grids are typically passed + * by reference, however, when a copy is needed, these operations + * are supported. + */ + + void deepCopy(const Grid & grid) { + int n = grid.nRows * grid.nCols; + elements = new ValueType[n]; + for (int i = 0; i < n; i++) { + elements[i] = grid.elements[i]; + } + nRows = grid.nRows; + nCols = grid.nCols; + } + +public: + + Grid & operator=(const Grid & src) { + if (this != &src) { + delete[] elements; + deepCopy(src); + } + return *this; + } + + Grid(const Grid & src) { + deepCopy(src); + } + + /* + * Iterator support + * ---------------- + * The classes in the StanfordCPPLib collection implement input + * iterators so that they work symmetrically with respect to the + * corresponding STL classes. + */ + + class iterator : public std::iterator { + + public: + + iterator(const Grid *gp, int index) { + this->gp = gp; + this->index = index; + } + + iterator(const iterator & it) { + this->gp = it.gp; + this->index = it.index; + } + + iterator & operator++() { + index++; + return *this; + } + + iterator operator++(int) { + iterator copy(*this); + operator++(); + return copy; + } + + bool operator==(const iterator & rhs) { + return gp == rhs.gp && index == rhs.index; + } + + bool operator!=(const iterator & rhs) { + return !(*this == rhs); + } + + ValueType & operator*() { + return gp->elements[index]; + } + + ValueType *operator->() { + return &gp->elements[index]; + } + + private: + const Grid *gp; + int index; + }; + + iterator begin() const { + return iterator(this, 0); + } + + iterator end() const { + return iterator(this, nRows * nCols); + } + + /* + * Private class: Grid::GridRow + * ------------------------------------- + * This section of the code defines a nested class within the Grid template + * that makes it possible to use traditional subscripting on Grid values. + */ + + class GridRow { + public: + GridRow() { + /* Empty */ + } + + ValueType & operator[](int col) { + if (!gp->inBounds(row, col)) { + throw std::out_of_range("Grid index values out of range"); + } + return gp->elements[(row * gp->nCols) + col]; + } + + ValueType operator[](int col) const { + if (!gp->inBounds(row, col)) { + throw std::out_of_range("Grid index values out of range"); + } + return gp->elements[(row * gp->nCols) + col]; + } + + private: + GridRow(Grid *gridRef, int index) { + gp = gridRef; + row = index; + } + + Grid *gp; + int row; + friend class Grid; + }; + friend class ConstGridRow; + + /* + * Private class: Grid::ConstGridRow + * ------------------------------------- + * This section of the code defines a nested class within the Grid template + * that makes it possible to use traditional subscripting on Grid values for + * const versions of the Grid. + */ + + class ConstGridRow { + public: + ConstGridRow() { + /* Empty */ + } + + ValueType operator[](int col) const { + if (!gp->inBounds(row, col)) { + throw std::out_of_range("Grid index values out of range"); + } + return gp->elements[(row * gp->nCols) + col]; + } + + private: + ConstGridRow(const Grid *gridRef, int index) { + gp = gridRef; + row = index; + } + + const Grid *gp; + int row; + friend class Grid; + }; + friend class GridRow; + +}; + +template +Grid::Grid() { + elements = NULL; + nRows = 0; + nCols = 0; +} + +template +Grid::Grid(int nRows, int nCols) { + elements = NULL; + resize(nRows, nCols); +} + +template +Grid::~Grid() { + if (elements != NULL) delete[] elements; +} + +template +int Grid::numRows() const { + return nRows; +} + +template +int Grid::numCols() const { + return nCols; +} + +template +void Grid::resize(int nRows, int nCols) { + if (nRows < 0 || nCols < 0) { + throw std::invalid_argument("Attempt to resize grid to invalid size (" + + std::to_string(nRows) + ", " + + std::to_string(nCols) + ")"); + } + if (elements != NULL) delete[] elements; + this->nRows = nRows; + this->nCols = nCols; + elements = new ValueType[nRows * nCols]; + ValueType value = ValueType(); + for (int i = 0; i < nRows * nCols; i++) { + elements[i] = value; + } +} + +template +bool Grid::inBounds(int row, int col) const { + return row >= 0 && col >= 0 && row < nRows && col < nCols; +} + +template +ValueType Grid::get(int row, int col) { + if (!inBounds(row, col)) throw std::out_of_range("get: Grid indices out of bounds"); + return elements[(row * nCols) + col]; +} + +template +const ValueType & Grid::get(int row, int col) const { + if (!inBounds(row, col)) throw std::out_of_range("get: Grid indices out of bounds"); + return elements[(row * nCols) + col]; +} + +template +void Grid::set(int row, int col, ValueType value) { + if (!inBounds(row, col)) throw std::out_of_range("set: Grid indices out of bounds"); + elements[(row * nCols) + col] = value; +} + +template +typename Grid::GridRow Grid::operator[](int row) { + return GridRow(this, row); +} + +template +const typename Grid::ConstGridRow +Grid::operator[](int row) const { + return ConstGridRow(this, row); +} + +template +void Grid::mapAll(void (*fn)(ValueType value)) const { + for (int i = 0; i < nRows; i++) { + for (int j = 0; j < nCols; j++) { + fn(get(i, j)); + } + } +} + +template +void Grid::mapAll(void (*fn)(const ValueType & value)) const { + for (int i = 0; i < nRows; i++) { + for (int j = 0; j < nCols; j++) { + fn(get(i, j)); + } + } +} + +template +template +void Grid::mapAll(FunctorType fn) const { + for (int i = 0; i < nRows; i++) { + for (int j = 0; j < nCols; j++) { + fn(get(i, j)); + } + } +} + +template +std::string Grid::toString() { + std::ostringstream os; + os << *this; + return os.str(); +} + +/* + * Implementation notes: << and >> + * ------------------------------- + * The insertion and extraction operators use the template facilities in + * strlib.h to read and write generic values in a way that treats strings + * specially. + */ + +template +std::ostream & operator<<(std::ostream & os, const Grid & grid) { + os << "{"; + int nRows = grid.numRows(); + int nCols = grid.numCols(); + for (int i = 0; i < nRows; i++) { + if (i > 0) os << ", "; + os << "{"; + for (int j = 0; j < nCols; j++) { + if (j > 0) os << ", "; + os << grid.get(i, j); + } + os << "}"; + } + return os << "}"; +} + +template +std::istream & operator>>(std::istream & is, Grid & grid) { + std::vector> vec2d; + is >> vec2d; + int nRows = vec2d.size(); + int nCols = (nRows == 0) ? 0 : vec2d[0].size(); + grid.resize(nRows, nCols); + for (int i = 0; i < nRows; i++) { + for (int j = 0; j < nCols; j++) { + grid[i][j] = vec2d[i][j]; + } + } + return is; +} + + + +#endif diff --git a/lib/StanfordCPPLib/lexicon.cpp b/lib/StanfordCPPLib/lexicon.cpp new file mode 100755 index 0000000..140bef2 --- /dev/null +++ b/lib/StanfordCPPLib/lexicon.cpp @@ -0,0 +1,316 @@ +/* + * File: lexicon.cpp + * ----------------- + * A lexicon is a word list. This lexicon is backed by two separate data + * structures for storing the words in the list: + * + * 1) a DAWG (directed acyclic word graph) + * 2) a Set of other words. + * + * Typically the DAWG is used for a large list read from a file in binary + * format. The STL set is for words added piecemeal at runtime. + * + * The DAWG idea comes from an article by Appel & Jacobson, CACM May 1988. + * This lexicon implementation only has the code to load/search the DAWG. + * The DAWG builder code is quite a bit more intricate, see me (Julie) + * if you need it. + */ + +#include +#include +#include +#include +#include +#include +#include +#include "error.h" +#include "lexicon.h" +#include "strlib.h" +using namespace std; + +static void toLowerCaseInPlace(string & str); + +/* + * The DAWG is stored as an array of edges. Each edge is represented by + * one 32-bit struct. The 5 "letter" bits indicate the character on this + * transition (expressed as integer from 1 to 26), the "accept" bit indicates + * if you accept after appending that char (current path forms word), and the + * "lastEdge" bit marks this as the last edge in a sequence of childeren. + * The bulk of the bits (24) are used for the index within the edge array for + * the children of this node. The children are laid out contiguously in + * alphabetical order. Since we read edges as binary bits from a file in + * a big-endian format, we have to swap the struct order for little-endian + * machines. + */ + +Lexicon::Lexicon() { + edges = start = NULL; + numEdges = numDawgWords = 0; +} + +Lexicon::Lexicon(string filename) { + edges = start = NULL; + numEdges = numDawgWords = 0; + addWordsFromFile(filename); +} + +Lexicon::~Lexicon() { + if (edges) delete[] edges; +} + +/* + * Swaps a 4-byte long from big to little endian byte order + */ + +static uint32_t my_ntohl(uint32_t arg) { + uint32_t result = ((arg & 0xff000000) >> 24) | + ((arg & 0x00ff0000) >> 8) | + ((arg & 0x0000ff00) << 8) | + ((arg & 0x000000ff) << 24); + return result; +} + +/* + * Implementation notes: readBinaryFile + * ------------------------------------ + * The binary lexicon file format must follow this pattern: + * DAWG::: + */ + +void Lexicon::readBinaryFile(string filename) { + long startIndex, numBytes; + char firstFour[4], expected[] = "DAWG"; + ifstream istr(filename.c_str(), IOS_IN | IOS_BINARY); + if (false) my_ntohl(0); + if (istr.fail()) { + error("Couldn't open lexicon file " + filename); + } + istr.read(firstFour, 4); + istr.get(); + istr >> startIndex; + istr.get(); + istr >> numBytes; + istr.get(); + if (istr.fail() || strncmp(firstFour, expected, 4) != 0 + || startIndex < 0 || numBytes < 0) { + error("Improperly formed lexicon file " + filename); + } + numEdges = numBytes/sizeof(Edge); + edges = new Edge[numEdges]; + start = &edges[startIndex]; + istr.read((char *)edges, numBytes); + if (istr.fail() && !istr.eof()) { + error("Improperly formed lexicon file " + filename); + } + +#if defined(BYTE_ORDER) && BYTE_ORDER == LITTLE_ENDIAN + uint32_t *cur = (uint32_t *) edges; + for (int i = 0; i < numEdges; i++, cur++) { + *cur = my_ntohl(*cur); + } +#endif + + istr.close(); + numDawgWords = countDawgWords(start); +} + +int Lexicon::countDawgWords(Edge *ep) const { + int count = 0; + while (true) { + if (ep->accept) count++; + if (ep->children != 0) { + count += countDawgWords(&edges[ep->children]); + } + if (ep->lastEdge) break; + ep++; + } + return count; +} + +/* + * Check for DAWG in first 4 to identify as special binary format, + * otherwise assume ASCII, one word per line + */ + +void Lexicon::addWordsFromFile(string filename) { + char firstFour[4], expected[] = "DAWG"; + ifstream istr(filename.c_str()); + if (istr.fail()) { + error("Couldn't open lexicon file " + filename); + } + istr.read(firstFour, 4); + if (strncmp(firstFour, expected, 4) == 0) { + if (otherWords.size() != 0) { + error("Binary files require an empty lexicon"); + } + readBinaryFile(filename); + return; + } + istr.seekg(0); + string line; + while (getline(istr, line)) { + add(line); + } + istr.close(); +} + +int Lexicon::size() const { + return numDawgWords + otherWords.size(); +} + +bool Lexicon::isEmpty() const { + return size() == 0; +} + +void Lexicon::clear() { + if (edges) delete[] edges; + edges = start = NULL; + numEdges = numDawgWords = 0; + otherWords.clear(); +} + +/* + * Implementation notes: findEdgeForChar + * ------------------------------------- + * Iterate over sequence of children to find one that + * matches the given char. Returns NULL if we get to + * last child without finding a match (thus no such + * child edge exists). + */ + +Lexicon::Edge *Lexicon::findEdgeForChar(Edge *children, char ch) const { + Edge *curEdge = children; + while (true) { + if (curEdge->letter == charToOrd(ch)) return curEdge; + if (curEdge->lastEdge) return NULL; + curEdge++; + } +} + +/* + * Implementation notes: traceToLastEdge + * ------------------------------------- + * Given a string, trace out path through the DAWG edge-by-edge. + * If a path exists, return last edge; otherwise return NULL. + */ + +Lexicon::Edge *Lexicon::traceToLastEdge(const string & s) const { + if (!start) return NULL; + Edge *curEdge = findEdgeForChar(start, s[0]); + int len = (int) s.length(); + for (int i = 1; i < len; i++) { + if (!curEdge || !curEdge->children) return NULL; + curEdge = findEdgeForChar(&edges[curEdge->children], s[i]); + } + return curEdge; +} + +bool Lexicon::containsPrefix(string prefix) const { + if (prefix.empty()) return true; + toLowerCaseInPlace(prefix); + if (traceToLastEdge(prefix)) return true; + foreach (string word in otherWords) { + if (startsWith(word, prefix)) return true; + if (prefix < word) return false; + } + return false; +} + +bool Lexicon::contains(string word) const { + toLowerCaseInPlace(word); + Edge *lastEdge = traceToLastEdge(word); + if (lastEdge && lastEdge->accept) return true; + return otherWords.contains(word); +} + +void Lexicon::add(string word) { + toLowerCaseInPlace(word); + if (!contains(word)) { + otherWords.add(word); + } +} + +Lexicon::Lexicon(const Lexicon & src) { + deepCopy(src); +} + +Lexicon & Lexicon::operator=(const Lexicon & src) { + if (this != &src) { + if (edges != NULL) delete[] edges; + deepCopy(src); + } + return *this; +} + +void Lexicon::deepCopy(const Lexicon & src) { + if (src.edges == NULL) { + edges = NULL; + start = NULL; + } else { + numEdges = src.numEdges; + edges = new Edge[src.numEdges]; + memcpy(edges, src.edges, sizeof(Edge)*src.numEdges); + start = edges + (src.start - src.edges); + } + numDawgWords = src.numDawgWords; + otherWords = src.otherWords; +} + +void Lexicon::mapAll(void (*fn)(string)) const { + foreach (string word in *this) { + fn(word); + } +} + +void Lexicon::mapAll(void (*fn)(const string &)) const { + foreach (string word in *this) { + fn(word); + } +} + +void Lexicon::iterator::advanceToNextWordInSet() { + if (setIterator == setEnd) { + currentSetWord = ""; + } else { + currentSetWord = *setIterator; + ++setIterator; + } +} + +void Lexicon::iterator::advanceToNextWordInDawg() { + if (edgePtr == NULL) { + edgePtr = lp->start; + } else { + advanceToNextEdge(); + } + while (edgePtr != NULL && !edgePtr->accept) { + advanceToNextEdge(); + } +} + +void Lexicon::iterator::advanceToNextEdge() { + Edge *ep = edgePtr; + if (ep->children == 0) { + while (ep != NULL && ep->lastEdge) { + if (stack.isEmpty()) { + edgePtr = NULL; + return; + } else { + ep = stack.pop(); + currentDawgPrefix.resize(currentDawgPrefix.length() - 1); + } + } + edgePtr = ep + 1; + } else { + stack.push(ep); + currentDawgPrefix.push_back(lp->ordToChar(ep->letter)); + edgePtr = &lp->edges[ep->children]; + } +}; + +static void toLowerCaseInPlace(string & str) { + int nChars = str.length(); + for (int i = 0; i < nChars; i++) { + str[i] = tolower(str[i]); + } +} diff --git a/lib/StanfordCPPLib/lexicon.h b/lib/StanfordCPPLib/lexicon.h new file mode 100755 index 0000000..fea4726 --- /dev/null +++ b/lib/StanfordCPPLib/lexicon.h @@ -0,0 +1,366 @@ +/* + * File: lexicon.h + * --------------- + * This file exports the Lexicon class, which is a + * compact structure for storing a list of words. + */ + +#ifndef _lexicon_h +#define _lexicon_h + +#include +#include "foreach.h" +#include "set.h" +#include "stack.h" + +/* + * Class: Lexicon + * -------------- + * This class is used to represent a lexicon, or word list. + * The main difference between a lexicon and a dictionary is that + * a lexicon does not provide any mechanism for storing definitions; + * the lexicon contains only words, with no associated information. + * It is therefore similar to a set of strings, but with a more + * space-efficient internal representation. The Lexicon + * class supports efficient lookup operations for words and prefixes. + * + *

As an example of the use of the Lexicon class, the + * following program lists all the two-letter words in the lexicon + * stored in EnglishWords.dat: + * + *

+ *    int main() {
+ *       Lexicon english("EnglishWords.dat");
+ *       foreach (string word in english) {
+ *          if (word.length() == 2) {
+ *             cout << word << endl;
+ *          }
+ *       }
+ *       return 0;
+ *    }
+ *
+ */ + +#include + +class Lexicon { + +public: + +/* + * Constructor: Lexicon + * Usage: Lexicon lex; + * Lexicon lex(filename); + * ----------------------------- + * Initializes a new lexicon. The default constructor creates an empty + * lexicon. The second form reads in the contents of the lexicon from + * the specified data file. The data file must be in one of two formats: + * (1) a space-efficient precompiled binary format or (2) a text file + * containing one word per line. The Stanford library distribution + * includes a binary lexicon file named English.dat + * containing a list of words in English. The standard code pattern + * to initialize that lexicon looks like this: + * + *
+ *    Lexicon english("English.dat");
+ *
+ */ + + Lexicon(); + Lexicon(std::string filename); + +/* + * Destructor: ~Lexicon + * -------------------- + * The destructor deallocates any storage associated with the lexicon. + */ + + virtual ~Lexicon(); + +/* + * Method: size + * Usage: int n = lex.size(); + * -------------------------- + * Returns the number of words contained in the lexicon. + */ + + int size() const; + +/* + * Method: isEmpty + * Usage: if (lex.isEmpty()) ... + * ----------------------------- + * Returns true if the lexicon contains no words. + */ + + bool isEmpty() const; + +/* + * Method: clear + * Usage: lex.clear(); + * ------------------- + * Removes all words from the lexicon. + */ + + void clear(); + +/* + * Method: add + * Usage: lex.add(word); + * --------------------- + * Adds the specified word to the lexicon. + */ + + void add(std::string word); + +/* + * Method: addWordsFromFile + * Usage: lex.addWordsFromFile(filename); + * -------------------------------------- + * Reads the file and adds all of its words to the lexicon. + */ + + void addWordsFromFile(std::string filename); + +/* + * Method: contains + * Usage: if (lex.contains(word)) ... + * ---------------------------------- + * Returns true if word is contained in the + * lexicon. In the Lexicon class, the case of letters is + * ignored, so "Zoo" is the same as "ZOO" or "zoo". + */ + + bool contains(std::string word) const; + +/* + * Method: containsPrefix + * Usage: if (lex.containsPrefix(prefix)) ... + * ------------------------------------------ + * Returns true if any words in the lexicon begin with prefix. + * Like containsWord, this method ignores the case of letters + * so that "MO" is a prefix of "monkey" or "Monday". + */ + + bool containsPrefix(std::string prefix) const; + +/* + * Method: mapAll + * Usage: lexicon.mapAll(fn); + * -------------------------- + * Calls the specified function on each word in the lexicon. + */ + + void mapAll(void (*fn)(std::string)) const; + void mapAll(void (*fn)(const std::string &)) const; + + template + void mapAll(FunctorType fn) const; + +/* + * Additional Lexicon operations + * ----------------------------- + * In addition to the methods listed in this interface, the Lexicon + * class supports the following operations: + * + * - Deep copying for the copy constructor and assignment operator + * - Iteration using the range-based for statement and STL iterators + * + * All iteration is guaranteed to proceed in alphabetical order. All + * words in the lexicon are stored in lowercase. + */ + +/* Private section */ + +/**********************************************************************/ +/* Note: Everything below this point in the file is logically part */ +/* of the implementation and should not be of interest to clients. */ +/**********************************************************************/ + +private: + +#ifdef _WIN32 +#define LITTLE_ENDIAN 1 +#define BYTE_ORDER LITTLE_ENDIAN +#endif + +#pragma pack(1) + struct Edge { +#if defined(BYTE_ORDER) && BYTE_ORDER == LITTLE_ENDIAN + unsigned long letter:5; + unsigned long lastEdge:1; + unsigned long accept:1; + unsigned long unused:1; + unsigned long children:24; +#else + unsigned long children:24; + unsigned long unused:1; + unsigned long accept:1; + unsigned long lastEdge:1; + unsigned long letter:5; +#endif + }; +#pragma pack() + + Edge *edges, *start; + int numEdges, numDawgWords; + Set otherWords; + +public: + +/* + * Deep copying support + * -------------------- + * This copy constructor and operator= are defined to make a + * deep copy, making it possible to pass/return lexicons by value + * and assign from one lexicon to another. The entire contents of + * the lexicon, including all words, are copied. Making copies is + * generally avoided because of the expense and thus, lexicons are + * typically passed by reference. When a copy is needed, these + * operations are supported. + */ + + Lexicon(const Lexicon & src); + Lexicon & operator=(const Lexicon & src); + +/* + * Iterator support + * ---------------- + * The classes in the StanfordCPPLib collection implement input + * iterators so that they work symmetrically with respect to the + * corresponding STL classes. + */ + + class iterator : public std::iterator { + private: + const Lexicon *lp; + int index; + std::string currentDawgPrefix; + std::string currentSetWord; + std::string tmpWord; + Edge *edgePtr; + Stack stack; + Set::iterator setIterator; + Set::iterator setEnd; + + void advanceToNextWordInDawg(); + void advanceToNextWordInSet(); + void advanceToNextEdge(); + + public: + iterator() { + this->lp = NULL; + } + + iterator(const Lexicon *lp, bool endFlag) { + this->lp = lp; + if (endFlag) { + index = lp->size(); + } else { + index = 0; + edgePtr = NULL; + setIterator = lp->otherWords.begin(); + setEnd = lp->otherWords.end(); + currentDawgPrefix = ""; + currentSetWord = ""; + advanceToNextWordInDawg(); + advanceToNextWordInSet(); + } + } + + iterator(const iterator & it) { + lp = it.lp; + index = it.index; + currentDawgPrefix = it.currentDawgPrefix; + currentSetWord = it.currentSetWord; + edgePtr = it.edgePtr; + stack = it.stack; + setIterator = it.setIterator; + } + + iterator & operator++() { + if (edgePtr == NULL) { + advanceToNextWordInSet(); + } else { + if (currentSetWord == "" || currentDawgPrefix < currentSetWord) { + advanceToNextWordInDawg(); + } else { + advanceToNextWordInSet(); + } + } + index++; + return *this; + } + + iterator operator++(int) { + iterator copy(*this); + operator++(); + return copy; + } + + bool operator==(const iterator & rhs) { + return lp == rhs.lp && index == rhs.index; + } + + bool operator!=(const iterator & rhs) { + return !(*this == rhs); + } + + std::string operator*() { + if (edgePtr == NULL) return currentSetWord; + if (currentSetWord == "" || currentDawgPrefix < currentSetWord) { + return currentDawgPrefix + lp->ordToChar(edgePtr->letter); + } else { + return currentSetWord; + } + } + + std::string *operator->() { + if (edgePtr == NULL) return ¤tSetWord; + if (currentSetWord == "" || currentDawgPrefix < currentSetWord) { + tmpWord = currentDawgPrefix + lp->ordToChar(edgePtr->letter); + return &tmpWord; + } else { + return ¤tSetWord; + } + } + + }; + + iterator begin() const { + return iterator(this, false); + } + + iterator end() const { + return iterator(this, true); + } + +private: + + Edge *findEdgeForChar(Edge *children, char ch) const; + Edge *traceToLastEdge(const std::string & s) const; + void readBinaryFile(std::string filename); + void deepCopy(const Lexicon & src); + int countDawgWords(Edge *start) const; + + unsigned int charToOrd(char ch) const { + return ((unsigned int)(tolower(ch) - 'a' + 1)); + } + + char ordToChar(unsigned int ord) const { + return ((char)(ord - 1 + 'a')); + } + +}; + +template +void Lexicon::mapAll(FunctorType fn) const { + foreach (std::string word in *this) { + fn(word); + } +} + +// hashing functions for lexicons; defined in hashmap.cpp +int hashCode(const Lexicon& l); + +#endif diff --git a/lib/StanfordCPPLib/map.h b/lib/StanfordCPPLib/map.h new file mode 100755 index 0000000..ff75cba --- /dev/null +++ b/lib/StanfordCPPLib/map.h @@ -0,0 +1,919 @@ +/* + * File: map.h + * ----------- + * This file exports the template class Map, which + * maintains a collection of key-value pairs. + */ + +#ifndef _map_h +#define _map_h + +#include +#include "foreach.h" +#include "stack.h" +#include "vector.h" + +/* + * Class: Map + * ----------------------------- + * This class maintains an association between keys and + * values. The types used for keys and values are + * specified using templates, which makes it possible to use + * this structure with any data type. + */ + +template +class Map { + +public: + +/* + * Constructor: Map + * Usage: Map map; + * ---------------------------------- + * Initializes a new empty map that associates keys and values of the + * specified types. + */ + + Map(); + +/* + * Destructor: ~Map + * ---------------- + * Frees any heap storage associated with this map. + */ + + virtual ~Map(); + +/* + * Method: size + * Usage: int nEntries = map.size(); + * --------------------------------- + * Returns the number of entries in this map. + */ + + int size() const; + +/* + * Method: isEmpty + * Usage: if (map.isEmpty()) ... + * ----------------------------- + * Returns true if this map contains no entries. + */ + + bool isEmpty() const; + +/* + * Method: put + * Usage: map.put(key, value); + * --------------------------- + * Associates key with value in this map. + * Any previous value associated with key is replaced + * by the new value. + */ + + void put(const KeyType & key, const ValueType & value); + +/* + * Method: get + * Usage: ValueType value = map.get(key); + * -------------------------------------- + * Returns the value associated with key in this map. + * If key is not found, get returns the + * default value for ValueType. + */ + + ValueType get(const KeyType & key) const; + +/* + * Method: containsKey + * Usage: if (map.containsKey(key)) ... + * ------------------------------------ + * Returns true if there is an entry for key + * in this map. + */ + + bool containsKey(const KeyType & key) const; + +/* + * Method: remove + * Usage: map.remove(key); + * ----------------------- + * Removes any entry for key from this map. + */ + + void remove(const KeyType & key); + +/* + * Method: clear + * Usage: map.clear(); + * ------------------- + * Removes all entries from this map. + */ + + void clear(); + +/* + * Method: keys + * Usage: Vector keys = map.keys(); + * ------------------------------------------- + * Returns a collection containing all keys in this map. + */ + + Vector keys() const; + +/* + * Method: values + * Usage: Vector values = map.values(); + * ------------------------------------------- + * Returns a collection containing all values in this map. + */ + + Vector values() const; + +/* + * Operator: [] + * Usage: map[key] + * --------------- + * Selects the value associated with key. This syntax + * makes it easy to think of a map as an "associative array" + * indexed by the key type. If key is already present + * in the map, this function returns a reference to its associated + * value. If key is not present in the map, a new entry is created + * whose value is set to the default for the value type. + */ + + ValueType & operator[](const KeyType & key); + ValueType operator[](const KeyType & key) const; + +/* + * Method: toString + * Usage: string str = map.toString(); + * ----------------------------------- + * Converts the map to a printable string representation. + */ + + std::string toString(); + +/* + * Method: mapAll + * Usage: map.mapAll(fn); + * ---------------------- + * Iterates through the map entries and calls fn(key, value) + * for each one. The keys are processed in ascending order, as defined + * by the comparison function. + */ + + void mapAll(void (*fn)(KeyType, ValueType)) const; + void mapAll(void (*fn)(const KeyType &, const ValueType &)) const; + template + void mapAll(FunctorType fn) const; + +/* + * Additional Map operations + * ------------------------- + * In addition to the methods listed in this interface, the Map + * class supports the following operations: + * + * - Stream I/O using the << and >> operators + * - Deep copying for the copy constructor and assignment operator + * - Iteration using the range-based for statement and STL iterators + * + * All iteration is guaranteed to proceed in the order established by + * the comparison function passed to the constructor, which ordinarily + * matches the order of the key type. + */ + +/* Private section */ + +/**********************************************************************/ +/* Note: Everything below this point in the file is logically part */ +/* of the implementation and should not be of interest to clients. */ +/**********************************************************************/ + +/* + * Implementation notes: + * --------------------- + * The map class is represented using a binary search tree. The + * specific implementation used here is the classic AVL algorithm + * developed by Georgii Adel'son-Vel'skii and Evgenii Landis in 1962. + */ + +private: + +/* Constant definitions */ + + static const int BST_LEFT_HEAVY = -1; + static const int BST_IN_BALANCE = 0; + static const int BST_RIGHT_HEAVY = +1; + +/* Type definition for nodes in the binary search tree */ + + struct BSTNode { + KeyType key; /* The key stored in this node */ + ValueType value; /* The corresponding value */ + BSTNode *left; /* Subtree containing all smaller keys */ + BSTNode *right; /* Subtree containing all larger keys */ + int bf; /* AVL balance factor */ + }; + +/* + * Implementation notes: Comparator + * -------------------------------- + * The Comparator class encapsulates a functor that compares two values + * of KeyType. In contrast to the classes in the STL, all of which embed + * the comparator in the type, the Map class and its derivatives pass an + * optional Comparator value. While this strategy results in a more + * complex implementation, it has the advantage of allowing maps and sets + * to carry their own comparators without forcing the client to include + * the comparator in the template declaration. This simplification is + * particularly important for the Graph class. + * + * The allocation is required in the TemplateComparator class because + * the type std::binary_function has subclasses but does not define a + * virtual destructor. + */ + + class Comparator { + public: + virtual ~Comparator() { } + virtual bool lessThan(const KeyType & k1, const KeyType & k2) = 0; + virtual Comparator *clone() = 0; + }; + + template + class TemplateComparator : public Comparator { + public: + TemplateComparator(CompareType cmp) { + this->cmp = new CompareType(cmp); + } + + virtual bool lessThan(const KeyType & k1, const KeyType & k2) { + return (*cmp)(k1, k2); + } + + virtual Comparator *clone() { + return new TemplateComparator(*cmp); + } + + private: + CompareType *cmp; + }; + + Comparator & getComparator() const { + return *cmpp; + } + +/* Instance variables */ + + BSTNode *root; /* Pointer to the root of the tree */ + int nodeCount; /* Number of entries in the map */ + Comparator *cmpp; /* Pointer to the comparator */ + + int (*cmpFn)(const KeyType &, const KeyType &); + +/* Private methods */ + +/* + * Implementation notes: findNode(t, key) + * -------------------------------------- + * Searches the tree rooted at t to find the specified key, searching + * in the left or right subtree, as approriate. If a matching node + * is found, findNode returns a pointer to the value cell in that node. + * If no matching node exists in the tree, findNode returns NULL. + */ + + ValueType *findNode(BSTNode *t, const KeyType & key) const { + if (t == NULL) return NULL; + int sign = compareKeys(key, t->key); + if (sign == 0) return &t->value; + if (sign < 0) { + return findNode(t->left, key); + } else { + return findNode(t->right, key); + } + } + +/* + * Implementation notes: addNode(t, key, heightFlag) + * ------------------------------------------------- + * Searches the tree rooted at t to find the specified key, searching + * in the left or right subtree, as approriate. If a matching node + * is found, addNode returns a pointer to the value cell in that node, + * just like findNode. If no matching node exists in the tree, addNode + * creates a new node with a default value. The heightFlag reference + * parameter returns a bool indicating whether the height of the tree + * was changed by this operation. + */ + + ValueType *addNode(BSTNode * & t, const KeyType & key, bool & heightFlag) { + heightFlag = false; + if (t == NULL) { + t = new BSTNode(); + t->key = key; + t->value = ValueType(); + t->bf = BST_IN_BALANCE; + t->left = t->right = NULL; + heightFlag = true; + nodeCount++; + return &t->value; + } + int sign = compareKeys(key, t->key); + if (sign == 0) return &t->value; + ValueType *vp = NULL; + int bfDelta = BST_IN_BALANCE; + if (sign < 0) { + vp = addNode(t->left, key, heightFlag); + if (heightFlag) bfDelta = BST_LEFT_HEAVY; + } else { + vp = addNode(t->right, key, heightFlag); + if (heightFlag) bfDelta = BST_RIGHT_HEAVY; + } + updateBF(t, bfDelta); + heightFlag = (bfDelta != 0 && t->bf != BST_IN_BALANCE); + return vp; + } + +/* + * Implementation notes: removeNode(t, key) + * ---------------------------------------- + * Removes the node containing the specified key from the tree rooted + * at t. The return value is true if the height of this subtree + * changes. The removeTargetNode method does the actual deletion. + */ + + bool removeNode(BSTNode * & t, const KeyType & key) { + if (t == NULL) return false; + int sign = compareKeys(key, t->key); + if (sign == 0) return removeTargetNode(t); + int bfDelta = BST_IN_BALANCE; + if (sign < 0) { + if (removeNode(t->left, key)) bfDelta = BST_RIGHT_HEAVY; + } else { + if (removeNode(t->right, key)) bfDelta = BST_LEFT_HEAVY; + } + updateBF(t, bfDelta); + return bfDelta != 0 && t->bf == BST_IN_BALANCE; + } + +/* + * Implementation notes: removeTargetNode(t) + * ----------------------------------------- + * Removes the node which is passed by reference as t. The easy case + * occurs when either (or both) of the children is NULL; all you need + * to do is replace the node with its non-NULL child, if any. If both + * children are non-NULL, this code finds the rightmost descendent of + * the left child; this node may not be a leaf, but will have no right + * child. Its left child replaces it in the tree, after which the + * replacement data is moved to the position occupied by the target node. + */ + + bool removeTargetNode(BSTNode * & t) { + BSTNode *toDelete = t; + if (t->left == NULL) { + t = t->right; + delete toDelete; + nodeCount--; + return true; + } else if (t->right == NULL) { + t = t->left; + delete toDelete; + nodeCount--; + return true; + } else { + BSTNode *successor = t->left; + while (successor->right != NULL) { + successor = successor->right; + } + t->key = successor->key; + t->value = successor->value; + if (removeNode(t->left, successor->key)) { + updateBF(t, BST_RIGHT_HEAVY); + return (t->bf == BST_IN_BALANCE); + } + return false; + } + } + +/* + * Implementation notes: updateBF(t, bfDelta) + * ------------------------------------------ + * Updates the balance factor in the node and rebalances the tree + * if necessary. + */ + + void updateBF(BSTNode * & t, int bfDelta) { + t->bf += bfDelta; + if (t->bf < BST_LEFT_HEAVY) { + fixLeftImbalance(t); + } else if (t->bf > BST_RIGHT_HEAVY) { + fixRightImbalance(t); + } + } + +/* + * Implementation notes: fixLeftImbalance(t) + * ----------------------------------------- + * This function is called when a node has been found that is out + * of balance with the longer subtree on the left. Depending on + * the balance factor of the left child, the code performs a + * single or double rotation. + */ + + void fixLeftImbalance(BSTNode * & t) { + BSTNode *child = t->left; + if (child->bf == BST_RIGHT_HEAVY) { + int oldBF = child->right->bf; + rotateLeft(t->left); + rotateRight(t); + t->bf = BST_IN_BALANCE; + switch (oldBF) { + case BST_LEFT_HEAVY: + t->left->bf = BST_IN_BALANCE; + t->right->bf = BST_RIGHT_HEAVY; + break; + case BST_IN_BALANCE: + t->left->bf = t->right->bf = BST_IN_BALANCE; + break; + case BST_RIGHT_HEAVY: + t->left->bf = BST_LEFT_HEAVY; + t->right->bf = BST_IN_BALANCE; + break; + } + } else if (child->bf == BST_IN_BALANCE) { + rotateRight(t); + t->bf = BST_RIGHT_HEAVY; + t->right->bf = BST_LEFT_HEAVY; + } else { + rotateRight(t); + t->right->bf = t->bf = BST_IN_BALANCE; + } + } + +/* + * Implementation notes: rotateLeft(t) + * ----------------------------------- + * This function performs a single left rotation of the tree + * that is passed by reference. The balance factors + * are unchanged by this function and must be corrected at a + * higher level of the algorithm. + */ + + void rotateLeft(BSTNode * & t) { + BSTNode *child = t->right; + t->right = child->left; + child->left = t; + t = child; + } + +/* + * Implementation notes: fixRightImbalance(t) + * ------------------------------------------ + * This function is called when a node has been found that + * is out of balance with the longer subtree on the right. + * Depending on the balance factor of the right child, the + * code performs a single or double rotation. + */ + + void fixRightImbalance(BSTNode * & t) { + BSTNode *child = t->right; + if (child->bf == BST_LEFT_HEAVY) { + int oldBF = child->left->bf; + rotateRight(t->right); + rotateLeft(t); + t->bf = BST_IN_BALANCE; + switch (oldBF) { + case BST_LEFT_HEAVY: + t->left->bf = BST_IN_BALANCE; + t->right->bf = BST_RIGHT_HEAVY; + break; + case BST_IN_BALANCE: + t->left->bf = t->right->bf = BST_IN_BALANCE; + break; + case BST_RIGHT_HEAVY: + t->left->bf = BST_LEFT_HEAVY; + t->right->bf = BST_IN_BALANCE; + break; + } + } else if (child->bf == BST_IN_BALANCE) { + rotateLeft(t); + t->bf = BST_LEFT_HEAVY; + t->left->bf = BST_RIGHT_HEAVY; + } else { + rotateLeft(t); + t->left->bf = t->bf = BST_IN_BALANCE; + } + } + +/* + * Implementation notes: rotateRight(t) + * ------------------------------------ + * This function performs a single right rotation of the tree + * that is passed by reference. The balance factors + * are unchanged by this function and must be corrected at a + * higher level of the algorithm. + */ + + void rotateRight(BSTNode * & t) { + + BSTNode *child = t->left; + t->left = child->right; + child->right = t; + t = child; + } + +/* + * Implementation notes: deleteTree(t) + * ----------------------------------- + * Deletes all the nodes in the tree. + */ + + void deleteTree(BSTNode *t) { + if (t != NULL) { + deleteTree(t->left); + deleteTree(t->right); + delete t; + } + } + +/* + * Implementation notes: mapAll + * ---------------------------- + * Calls fn(key, value) for every key-value pair in the tree. + */ + + void mapAll(BSTNode *t, void (*fn)(KeyType, ValueType)) const { + if (t != NULL) { + mapAll(t->left, fn); + fn(t->key, t->value); + mapAll(t->right, fn); + } + } + + void mapAll(BSTNode *t, + void (*fn)(const KeyType &, const ValueType &)) const { + if (t != NULL) { + mapAll(t->left, fn); + fn(t->key, t->value); + mapAll(t->right, fn); + } + } + + template + void mapAll(BSTNode *t, FunctorType fn) const { + if (t != NULL) { + mapAll(t->left, fn); + fn(t->key, t->value); + mapAll(t->right, fn); + } + } + + void deepCopy(const Map & other) { + root = copyTree(other.root); + nodeCount = other.nodeCount; + cmpp = (other.cmpp == NULL) ? NULL : other.cmpp->clone(); + } + + BSTNode *copyTree(BSTNode * const t) { + if (t == NULL) return NULL; + BSTNode *np = new BSTNode(); + np->key = t->key; + np->value = t->value; + np->bf = t->bf; + np->left = copyTree(t->left); + np->right = copyTree(t->right); + return np; + } + +public: + +/* + * Hidden features + * --------------- + * The remainder of this file consists of the code required to + * support deep copying and iteration. Including these methods in + * the public portion of the interface would make that interface more + * difficult to understand for the average client. + */ + +/* Extended constructors */ + + template + explicit Map(CompareType cmp) { + root = NULL; + nodeCount = 0; + cmpp = new TemplateComparator(cmp); + } + +/* + * Implementation notes: compareKeys(k1, k2) + * ----------------------------------------- + * Compares the keys k1 and k2 and returns an integer (-1, 0, or +1) + * depending on whether k1 < k2, k1 == k2, or k1 > k2, respectively. + */ + + int compareKeys(const KeyType & k1, const KeyType & k2) const { + if (cmpp->lessThan(k1, k2)) return -1; + if (cmpp->lessThan(k2, k1)) return +1; + return 0; + } + +/* + * Deep copying support + * -------------------- + * This copy constructor and operator= are defined to make a + * deep copy, making it possible to pass/return maps by value + * and assign from one map to another. + */ + + Map & operator=(const Map & src) { + if (this != &src) { + clear(); + deepCopy(src); + } + return *this; + } + + Map(const Map & src) { + deepCopy(src); + } + +/* + * Iterator support + * ---------------- + * The classes in the StanfordCPPLib collection implement input + * iterators so that they work symmetrically with respect to the + * corresponding STL classes. + */ + + class iterator : public std::iterator { + + private: + + struct NodeMarker { + BSTNode *np; + bool processed; + }; + + const Map *mp; /* Pointer to the map */ + int index; /* Index of current element */ + Stack stack; /* Stack of unprocessed nodes */ + + void findLeftmostChild() { + BSTNode *np = stack.peek().np; + if (np == NULL) return; + while (np->left != NULL) { + NodeMarker marker = { np->left, false }; + stack.push(marker); + np = np->left; + } + } + + public: + + iterator() { + /* Empty */ + } + + iterator(const Map *mp, bool end) { + this->mp = mp; + if (end || mp->nodeCount == 0) { + index = mp->nodeCount; + } else { + index = 0; + NodeMarker marker = { mp->root, false }; + stack.push(marker); + findLeftmostChild(); + } + } + + iterator(const iterator & it) { + mp = it.mp; + index = it.index; + stack = it.stack; + } + + iterator& operator=(const iterator & it) { + if(*this != it){ + mp = it.mp; + index = it.index; + stack = it.stack; + } + return *this; + } + + iterator & operator++() { + NodeMarker marker = stack.pop(); + BSTNode *np = marker.np; + if (np->right == NULL) { + while (!stack.isEmpty() && stack.peek().processed) { + stack.pop(); + } + } else { + marker.processed = true; + stack.push(marker); + marker.np = np->right; + marker.processed = false; + stack.push(marker); + findLeftmostChild(); + } + index++; + return *this; + } + + iterator operator++(int) { + iterator copy(*this); + operator++(); + return copy; + } + + bool operator==(const iterator & rhs) { + return mp == rhs.mp && index == rhs.index; + } + + bool operator!=(const iterator & rhs) { + return !(*this == rhs); + } + + KeyType operator*() { + return stack.peek().np->key; + } + + KeyType *operator->() { + return &stack.peek().np->key; + } + + friend class Map; + + }; + + iterator begin() const { + return iterator(this, false); + } + + iterator end() const { + return iterator(this, true); + } + +}; + +template +Map::Map() { + root = NULL; + nodeCount = 0; + cmpp = new TemplateComparator< less >(less()); +} + +template +Map::~Map() { + if (cmpp != NULL) delete cmpp; + deleteTree(root); +} + +template +int Map::size() const { + return nodeCount; +} + +template +bool Map::isEmpty() const { + return nodeCount == 0; +} + +template +void Map::put(const KeyType & key, + const ValueType & value) { + bool dummy; + *addNode(root, key, dummy) = value; +} + +template +ValueType Map::get(const KeyType & key) const { + ValueType *vp = findNode(root, key); + if (vp == NULL) return ValueType(); + return *vp; +} + +template +void Map::remove(const KeyType & key) { + removeNode(root, key); +} + +template +void Map::clear() { + deleteTree(root); + root = NULL; + nodeCount = 0; +} + +template +bool Map::containsKey(const KeyType & key) const { + return findNode(root, key) != NULL; +} + +template +ValueType & Map::operator[](const KeyType & key) { + bool dummy; + return *addNode(root, key, dummy); +} + +template +ValueType Map::operator[](const KeyType & key) const { + return get(key); +} + +template +void Map::mapAll(void (*fn)(KeyType, ValueType)) const { + mapAll(root, fn); +} + +template +void Map::mapAll(void (*fn)(const KeyType &, + const ValueType &)) const { + mapAll(root, fn); +} + +template +template +void Map::mapAll(FunctorType fn) const { + mapAll(root, fn); +} + +template +std::string Map::toString() { + ostringstream os; + os << *this; + return os.str(); +} + +template +Vector Map::keys() const { + Vector keyset; + foreach (KeyType key in *this) { + keyset.add(key); + } + return keyset; +} + +template +Vector Map::values() const { + Vector values; + foreach (KeyType key in *this) { + values.add(this->get(key)); + } + return values; +} + +/* + * Implementation notes: << and >> + * ------------------------------- + * The insertion and extraction operators use the template facilities in + * strlib.h to read and write generic values in a way that treats strings + * specially. + */ + +template +std::ostream & operator<<(std::ostream & os, + const Map & map) { + os << "{"; + typename Map::iterator begin = map.begin(); + typename Map::iterator end = map.end(); + typename Map::iterator it = begin; + while (it != end) { + if (it != begin) os << ", "; + writeGenericValue(os, *it, false); + os << ":"; + writeGenericValue(os, map[*it], false); + ++it; + } + return os << "}"; +} + +template +std::istream & operator>>(std::istream & is, Map & map) { + char ch; + is >> ch; + if (ch != '{') error("operator >>: Missing {"); + map.clear(); + is >> ch; + if (ch != '}') { + is.unget(); + while (true) { + KeyType key; + readGenericValue(is, key); + is >> ch; + if (ch != ':') error("operator >>: Missing colon after key"); + ValueType value; + readGenericValue(is, value); + map[key] = value; + is >> ch; + if (ch == '}') break; + if (ch != ',') { + error(std::string("operator >>: Unexpected character ") + ch); + } + } + } + return is; +} + +#endif diff --git a/lib/StanfordCPPLib/private/_main.h_ b/lib/StanfordCPPLib/private/_main.h_ new file mode 100755 index 0000000..5392d18 --- /dev/null +++ b/lib/StanfordCPPLib/private/_main.h_ @@ -0,0 +1,218 @@ +/* + * File: main.h + * ------------ + * This file renames the main method in the client's + * program to Main, thereby allowing a custom + * main method in the libraries to take control + * before passing control back to the client program. The main macro + * also defines a function getMainFlags that returns an int whose bits + * indicate which of the various interfaces have been loaded by this + * definition of main. + * + * Note: This file can be loaded more than once and must therefore + * check to see what has already been defined. + */ + +#ifdef main +# undef main +# undef CONSOLE_FLAG +# undef GRAPHICS_FLAG +#else +# define MAIN_USES_CONSOLE (1<<0) +# define MAIN_USES_GRAPHICS (1<<1) +#endif + +#ifdef _console_h +# define CONSOLE_FLAG MAIN_USES_CONSOLE +#else +# define CONSOLE_FLAG 0 +#endif + +#ifdef _gwindow_h +# define GRAPHICS_FLAG MAIN_USES_GRAPHICS +#else +# define GRAPHICS_FLAG 0 +#endif + +#if CONSOLE_FLAG | GRAPHICS_FLAG + +#define main main(int argc, char **argv) { \ + extern int _mainFlags; \ + _mainFlags = GRAPHICS_FLAG + CONSOLE_FLAG; \ + try { \ + return startupMain(argc, argv); \ + } catch (const std::exception& ex) { \ + string msg = "\n ***\n"; \ + msg += " *** STANFORD C++ LIBRARY \n"; \ + msg += " *** An exception occurred during program execution: \n"; \ + msg += " *** "; \ + msg += ex.what(); \ + msg += "\n ***\n\n"; \ + std::cerr << msg; \ + throw ex; \ + } catch (std::string str) { \ + string msg = "\n ***\n"; \ + msg += " *** STANFORD C++ LIBRARY \n"; \ + msg += " *** A string exception occurred during program execution: \n"; \ + msg += " *** \""; \ + msg += str; \ + msg += "\"\n ***\n"; \ + std::cerr << msg; \ + throw str; \ + } catch (char const* str) { \ + string msg = "\n ***\n"; \ + msg += " *** STANFORD C++ LIBRARY \n"; \ + msg += " *** A string exception occurred during program execution: \n"; \ + msg += " *** \""; \ + msg += str; \ + msg += "\"\n ***\n"; \ + std::cerr << msg; \ + throw str; \ + } catch (int n) { \ + char buf[128]; \ + snprintf(buf, 128, "%d", n); \ + string msg = "\n ***\n"; \ + msg += " *** STANFORD C++ LIBRARY \n"; \ + msg += " *** An int exception occurred during program execution: \n"; \ + msg += " *** "; \ + msg += buf; \ + msg += "\n ***\n\n"; \ + std::cerr << msg; \ + throw n; \ + } catch (long l) { \ + char buf[128]; \ + snprintf(buf, 128, "%ld", l); \ + string msg = "\n ***\n"; \ + msg += " *** STANFORD C++ LIBRARY \n"; \ + msg += " *** A long exception occurred during program execution: \n"; \ + msg += " *** "; \ + msg += buf; \ + msg += "\n ***\n\n"; \ + std::cerr << msg; \ + throw l; \ + } catch (char c) { \ + string msg = "\n ***\n"; \ + msg += " *** STANFORD C++ LIBRARY \n"; \ + msg += " *** A char exception occurred during program execution: \n"; \ + msg += " *** '"; \ + msg += c; \ + msg += "'\n ***\n"; \ + std::cerr << msg; \ + throw c; \ + } catch (bool b) { \ + string msg = "\n ***\n"; \ + msg += " *** STANFORD C++ LIBRARY \n"; \ + msg += " *** A bool exception occurred during program execution: \n"; \ + msg += " *** "; \ + msg += (b ? "true" : "false"); \ + msg += "\n ***\n\n"; \ + std::cerr << msg; \ + throw b; \ + } catch (double d) { \ + char buf[128]; \ + snprintf(buf, 128, "%lf", d); \ + string msg = "\n ***\n"; \ + msg += " *** STANFORD C++ LIBRARY \n"; \ + msg += " *** A double exception occurred during program execution: \n"; \ + msg += " *** "; \ + msg += buf; \ + msg += "\n ***\n\n"; \ + std::cerr << msg; \ + throw d; \ + } \ + } \ + int Main + +extern int startupMain(int argc, char **argv); + +#else + +#define main main(int argc, char **argv) { \ + extern int _mainFlags; \ + _mainFlags = GRAPHICS_FLAG + CONSOLE_FLAG; \ + try { \ + return mainWrapper(argc, argv); } \ + } catch (const std::exception& ex) { \ + string msg = "\n ***\n"; \ + msg += " *** STANFORD C++ LIBRARY \n"; \ + msg += " *** An exception occurred during program execution: \n"; \ + msg += " *** "; \ + msg += ex.what(); \ + msg += "\n ***\n\n"; \ + std::cerr << msg; \ + throw ex; \ + } catch (std::string str) { \ + string msg = "\n ***\n"; \ + msg += " *** STANFORD C++ LIBRARY \n"; \ + msg += " *** A string exception occurred during program execution: \n"; \ + msg += " *** \""; \ + msg += str; \ + msg += "\"\n ***\n"; \ + std::cerr << msg; \ + throw str; \ + } catch (char const* str) { \ + string msg = "\n ***\n"; \ + msg += " *** STANFORD C++ LIBRARY \n"; \ + msg += " *** A string exception occurred during program execution: \n"; \ + msg += " *** \""; \ + msg += str; \ + msg += "\"\n ***\n"; \ + std::cerr << msg; \ + throw str; \ + } catch (int n) { \ + char buf[128]; \ + snprintf(buf, 128, "%d", n); \ + string msg = "\n ***\n"; \ + msg += " *** STANFORD C++ LIBRARY \n"; \ + msg += " *** An int exception occurred during program execution: \n"; \ + msg += " *** "; \ + msg += buf; \ + msg += "\n ***\n\n"; \ + std::cerr << msg; \ + throw n; \ + } catch (long l) { \ + char buf[128]; \ + snprintf(buf, 128, "%ld", l); \ + string msg = "\n ***\n"; \ + msg += " *** STANFORD C++ LIBRARY \n"; \ + msg += " *** A long exception occurred during program execution: \n"; \ + msg += " *** "; \ + msg += buf; \ + msg += "\n ***\n\n"; \ + std::cerr << msg; \ + throw l; \ + } catch (char c) { \ + string msg = "\n ***\n"; \ + msg += " *** STANFORD C++ LIBRARY \n"; \ + msg += " *** A char exception occurred during program execution: \n"; \ + msg += " *** '"; \ + msg += c; \ + msg += "'\n ***\n"; \ + std::cerr << msg; \ + throw c; \ + } catch (bool b) { \ + string msg = "\n ***\n"; \ + msg += " *** STANFORD C++ LIBRARY \n"; \ + msg += " *** A bool exception occurred during program execution: \n"; \ + msg += " *** "; \ + msg += (b ? "true" : "false"); \ + msg += "\n ***\n\n"; \ + std::cerr << msg; \ + throw b; \ + } catch (double d) { \ + char buf[128]; \ + snprintf(buf, 128, "%lf", d); \ + string msg = "\n ***\n"; \ + msg += " *** STANFORD C++ LIBRARY \n"; \ + msg += " *** A double exception occurred during program execution: \n"; \ + msg += " *** "; \ + msg += buf; \ + msg += "\n ***\n\n"; \ + std::cerr << msg; \ + throw d; \ + } \ + int Main + +extern int mainWrapper(int argc, char **argv); + +#endif diff --git a/lib/StanfordCPPLib/private/main.h b/lib/StanfordCPPLib/private/main.h new file mode 100755 index 0000000..4339915 --- /dev/null +++ b/lib/StanfordCPPLib/private/main.h @@ -0,0 +1,62 @@ +/* + * File: main.h + * ------------ + * This file renames the main method in the client's + * program to Main, thereby allowing a custom + * main method in the libraries to take control + * before passing control back to the client program. The main macro + * also defines a function getMainFlags that returns an int whose bits + * indicate which of the various interfaces have been loaded by this + * definition of main. + * + * Note: This file can be loaded more than once and must therefore + * check to see what has already been defined. + */ + +#ifdef main +# undef main +# undef CONSOLE_FLAG +# undef GRAPHICS_FLAG +#else +# define MAIN_USES_CONSOLE (1<<0) +# define MAIN_USES_GRAPHICS (1<<1) +#endif + +#ifdef _console_h +# define CONSOLE_FLAG MAIN_USES_CONSOLE +#else +# define CONSOLE_FLAG 0 +#endif + +#ifdef _gwindow_h +# define GRAPHICS_FLAG MAIN_USES_GRAPHICS +#else +# define GRAPHICS_FLAG 0 +#endif + +void __StanfordCPPLib_terminate_handler(); +void __StanfordCPPLib_set_terminate(); + +#if CONSOLE_FLAG | GRAPHICS_FLAG + +#define main main(int argc, char **argv) { \ + extern int _mainFlags; \ + _mainFlags = GRAPHICS_FLAG + CONSOLE_FLAG; \ + return startupMain(argc, argv); \ + } \ + int Main + +extern int startupMain(int argc, char **argv); + +#else + +#define main main(int argc, char **argv) { \ + extern int _mainFlags; \ + _mainFlags = GRAPHICS_FLAG + CONSOLE_FLAG; \ + return mainWrapper(argc, argv); } \ + } \ + int Main + +extern int mainWrapper(int argc, char **argv); + +#endif diff --git a/lib/StanfordCPPLib/private/randompatch.h b/lib/StanfordCPPLib/private/randompatch.h new file mode 100755 index 0000000..c7a4b86 --- /dev/null +++ b/lib/StanfordCPPLib/private/randompatch.h @@ -0,0 +1,63 @@ +/* + * File: private/randompatch.h + * --------------------------- + * This file patches the implementation of the random number library + * to avoid some serious bugs in standard implementations of rand, + * particularly on Mac OS X. It also includes a hack to set the + * seed from the RANDOM_SEED environment variable, which makes it + * possible to produce repeatable figures. + */ + +/* + * Implementation notes: rand, srand + * --------------------------------- + * To ensure that this package works the same way on all platforms, + * this file completely reimplements the rand and srand methods. The + * algorithm is a conventional linear congruential generator with the + * parameters used in GNU's gclib. RAND_MAX for this implementation + * is 2147483647 (2^31 - 1). + */ + +#define MULTIPLIER 1103515245 +#define OFFSET 12345 + +static int _seed = 1; + +#undef rand +#define rand() ((_seed = MULTIPLIER * _seed + OFFSET) & 0x7FFFFFFF) + +#undef srand +#define srand(seed) (_seed = int(seed), _seed = (_seed <= 0) ? 1 : _seed) + +#undef RAND_MAX +#define RAND_MAX 2147483647 + +/* + * Implementation notes: Windows patch + * ----------------------------------- + * On some versions of Windows, the time function is too coarse to use + * as a random seed. On those versions, this definition substitutes the + * GetTickCount function. + */ + +#if defined (_MSC_VER) && (_MSC_VER >= 1200) +# include +# define time(dummy) (GetTickCount()) +#endif + +#ifdef __APPLE__ + +# include + + static time_t patchedTime(time_t *) { + char *str = getenv("RANDOM_SEED"); + if (str == NULL) { + return time(NULL); + } else { + return atoi(str); + } + } + +# define time(dummy) patchedTime(dummy) + +#endif diff --git a/lib/StanfordCPPLib/private/tokenpatch.h b/lib/StanfordCPPLib/private/tokenpatch.h new file mode 100755 index 0000000..d4930e5 --- /dev/null +++ b/lib/StanfordCPPLib/private/tokenpatch.h @@ -0,0 +1,11 @@ +/* + * File: tokenpatch.h + * ------------------ + * This file renames TokenType and WORD to avoid conflict with the + * header. + */ + +#ifdef _MSC_VER +# define TokenType TokenTypeT +# define WORD WORD_TC +#endif diff --git a/lib/StanfordCPPLib/private/tplatform.h b/lib/StanfordCPPLib/private/tplatform.h new file mode 100755 index 0000000..6cf4bae --- /dev/null +++ b/lib/StanfordCPPLib/private/tplatform.h @@ -0,0 +1,25 @@ +/* + * File: tplatform.h + * ----------------- + * This interface defines the platform-specific methods on threads + * and locks. + */ + +/* Methods for threads */ + +int forkForPlatform(void (*fn)(void *), void *arg); +void incThreadRefCountForPlatform(int id); +void decThreadRefCountForPlatform(int id); +void joinForPlatform(int id); +int getCurrentThreadForPlatform(); +void yieldForPlatform(); + +/* Methods for locks */ + +int initLockForPlatform(); +void incLockRefCountForPlatform(int id); +void decLockRefCountForPlatform(int id); +void lockForPlatform(int id); +void unlockForPlatform(int id); +void waitForPlatform(int id); +void signalForPlatform(int id); diff --git a/lib/StanfordCPPLib/random.cpp b/lib/StanfordCPPLib/random.cpp new file mode 100755 index 0000000..b7ea860 --- /dev/null +++ b/lib/StanfordCPPLib/random.cpp @@ -0,0 +1,99 @@ +/* + * File: random.cpp + * ---------------- + * This file implements the random.h interface. + */ + +#include +#include +#include +#include "random.h" +#include "private/randompatch.h" +using namespace std; + +/* Private function prototype */ + +static void initRandomSeed(); + +/* + * Implementation notes: randomInteger + * ----------------------------------- + * The code for randomInteger produces the number in four steps: + * + * 1. Generate a random real number d in the range [0 .. 1). + * 2. Scale the number to the range [0 .. N) where N is the number of values. + * 3. Translate the number so that the range starts at the appropriate value. + * 4. Convert the result to the next lower integer. + * + * The implementation is complicated by the fact that both the expression + * + * RAND_MAX + 1 + * + * and the expression for the number of values + * + * high - low + 1 + * + * can overflow the integer range. These calculations must therefore be + * performed using doubles instead of ints. + */ + +int randomInteger(int low, int high) { + initRandomSeed(); + double d = rand() / (double(RAND_MAX) + 1); + double s = d * (double(high) - low + 1); + return int(floor(low + s)); +} + +/* + * Implementation notes: randomReal + * -------------------------------- + * The code for randomReal is similar to that for randomInteger, + * without the final conversion step. + */ + +double randomReal(double low, double high) { + initRandomSeed(); + double d = rand() / (double(RAND_MAX) + 1); + double s = d * (high - low); + return low + s; +} + +/* + * Implementation notes: randomChance + * ---------------------------------- + * The code for randomChance calls randomReal(0, 1) and then checks + * whether the result is less than the requested probability. + */ + +bool randomChance(double p) { + initRandomSeed(); + return randomReal(0, 1) < p; +} + +/* + * Implementation notes: setRandomSeed + * ----------------------------------- + * The setRandomSeed function simply forwards its argument to srand. + * The call to initRandomSeed is required to set the initialized flag. + */ + +void setRandomSeed(int seed) { + initRandomSeed(); + srand(seed); +} + +/* + * Implementation notes: initRandomSeed + * ------------------------------------ + * The initRandomSeed function declares a static variable that keeps track + * of whether the seed has been initialized. The first time initRandomSeed + * is called, initialized is false, so the seed is set to the current time. + */ + +static void initRandomSeed() { + static bool initialized = false; + if (!initialized) { + srand(int(time(NULL))); + initialized = true; + } +} diff --git a/lib/StanfordCPPLib/random.h b/lib/StanfordCPPLib/random.h new file mode 100755 index 0000000..3286f8f --- /dev/null +++ b/lib/StanfordCPPLib/random.h @@ -0,0 +1,58 @@ +/* + * File: random.h + * -------------- + * This file exports functions for generating pseudorandom numbers. + */ + +#ifndef _random_h +#define _random_h + +/* + * Function: randomInteger + * Usage: int n = randomInteger(low, high); + * ---------------------------------------- + * Returns a random integer in the range low to + * high, inclusive. + */ + +int randomInteger(int low, int high); + +/* + * Function: randomReal + * Usage: double d = randomReal(low, high); + * ---------------------------------------- + * Returns a random real number in the half-open interval + * [low .. high). A half-open + * interval includes the first endpoint but not the second, which + * means that the result is always greater than or equal to + * low but strictly less than high. + */ + +double randomReal(double low, double high); + +/* + * Function: randomChance + * Usage: if (randomChance(p)) ... + * ------------------------------- + * Returns true with the probability indicated by p. + * The argument p must be a floating-point number between + * 0 (never) and 1 (always). For example, calling + * randomChance(.30) returns true 30 percent + * of the time. + */ + +bool randomChance(double p); + +/* + * Function: setRandomSeed + * Usage: setRandomSeed(seed); + * --------------------------- + * Sets the internal random number seed to the specified value. You + * can use this function to set a specific starting point for the + * pseudorandom sequence or to ensure that program behavior is + * repeatable during the debugging phase. + */ + +void setRandomSeed(int seed); + +#endif diff --git a/lib/StanfordCPPLib/set.h b/lib/StanfordCPPLib/set.h new file mode 100755 index 0000000..155dc9b --- /dev/null +++ b/lib/StanfordCPPLib/set.h @@ -0,0 +1,628 @@ +/* + * File: set.h + * ----------- + * This file exports the Set class, which implements a + * collection for storing a set of distinct elements. + */ + +#ifndef _set_h +#define _set_h + +#include +#include "foreach.h" +#include "map.h" +#include "vector.h" + +/* + * Class: Set + * --------------------- + * This class stores a collection of distinct elements. + */ + +template +class Set { + +public: + +/* + * Constructor: Set + * Usage: Set set; + * -------------------------- + * Creates an empty set of the specified element type. + */ + + Set(); + +/* + * Destructor: ~Set + * ---------------- + * Frees any heap storage associated with this set. + */ + + virtual ~Set(); + +/* + * Method: size + * Usage: count = set.size(); + * -------------------------- + * Returns the number of elements in this set. + */ + + int size() const; + +/* + * Method: isEmpty + * Usage: if (set.isEmpty()) ... + * ----------------------------- + * Returns true if this set contains no elements. + */ + + bool isEmpty() const; + +/* + * Method: add + * Usage: set.add(value); + * ---------------------- + * Adds an element to this set, if it was not already there. For + * compatibility with the STL set class, this method + * is also exported as insert. + */ + + void add(const ValueType & value); + void insert(const ValueType & value); + +/* + * Method: remove + * Usage: set.remove(value); + * ------------------------- + * Removes an element from this set. If the value was not + * contained in the set, no error is generated and the set + * remains unchanged. + */ + + void remove(const ValueType & value); + +/* + * Method: contains + * Usage: if (set.contains(value)) ... + * ----------------------------------- + * Returns true if the specified value is in this set. + */ + + bool contains(const ValueType & value) const; + +/* + * Method: isSubsetOf + * Usage: if (set.isSubsetOf(set2)) ... + * ------------------------------------ + * Implements the subset relation on sets. It returns + * true if every element of this set is + * contained in set2. + */ + + bool isSubsetOf(const Set & set2) const; + +/* + * Method: clear + * Usage: set.clear(); + * ------------------- + * Removes all elements from this set. + */ + + void clear(); + +/* + * Operator: == + * Usage: set1 == set2 + * ------------------- + * Returns true if set1 and set2 + * contain the same elements. + */ + + bool operator==(const Set & set2) const; + +/* + * Operator: != + * Usage: set1 != set2 + * ------------------- + * Returns true if set1 and set2 + * are different. + */ + + bool operator!=(const Set & set2) const; + +/* + * Operator: + + * Usage: set1 + set2 + * set1 + element + * --------------------- + * Returns the union of sets set1 and set2, which + * is the set of elements that appear in at least one of the two sets. The + * right hand set can be replaced by an element of the value type, in which + * case the operator returns a new set formed by adding that element. + */ + + Set operator+(const Set & set2) const; + Set operator+(const ValueType & element) const; + +/* + * Operator: * + * Usage: set1 * set2 + * ------------------ + * Returns the intersection of sets set1 and set2, + * which is the set of all elements that appear in both. + */ + + Set operator*(const Set & set2) const; + +/* + * Operator: - + * Usage: set1 - set2 + * set1 - element + * --------------------- + * Returns the difference of sets set1 and set2, + * which is all of the elements that appear in set1 but + * not set2. The right hand set can be replaced by an + * element of the value type, in which case the operator returns a new + * set formed by removing that element. + */ + + Set operator-(const Set & set2) const; + Set operator-(const ValueType & element) const; + +/* + * Operator: += + * Usage: set1 += set2; + * set1 += value; + * --------------------- + * Adds all of the elements from set2 (or the single + * specified value) to set1. As a convenience, the + * Set package also overloads the comma operator so + * that it is possible to initialize a set like this: + * + *
+ *    Set digits;
+ *    digits += 0, 1, 2, 3, 4, 5, 6, 7, 8, 9;
+ *
+ */ + + Set & operator+=(const Set & set2); + Set & operator+=(const ValueType & value); + +/* + * Operator: *= + * Usage: set1 *= set2; + * -------------------- + * Removes any elements from set1 that are not present in + * set2. + */ + + Set & operator*=(const Set & set2); + +/* + * Operator: -= + * Usage: set1 -= set2; + * set1 -= value; + * --------------------- + * Removes the elements from set2 (or the single + * specified value) from set1. As a convenience, the + * Set package also overloads the comma operator so + * that it is possible to remove multiple elements from a set + * like this: + * + *
+ *    digits -= 0, 2, 4, 6, 8;
+ *
+ * + * which removes the values 0, 2, 4, 6, and 8 from the set + * digits. + */ + + Set & operator-=(const Set & set2); + Set & operator-=(const ValueType & value); + +/* + * Method: first + * Usage: ValueType value = set.first(); + * ------------------------------------- + * Returns the first value in the set in the order established by the + * foreach macro. If the set is empty, first + * generates an error. + */ + + ValueType first() const; + +/* + * Method: toString + * Usage: string str = set.toString(); + * ----------------------------------- + * Converts the set to a printable string representation. + */ + + std::string toString(); + +/* + * Method: mapAll + * Usage: set.mapAll(fn); + * ---------------------- + * Iterates through the elements of the set and calls fn(value) + * for each one. The values are processed in ascending order, as defined + * by the comparison function. + */ + + void mapAll(void (*fn)(ValueType)) const; + void mapAll(void (*fn)(const ValueType &)) const; + + template + void mapAll(FunctorType fn) const; + +/* + * Additional Set operations + * ------------------------- + * In addition to the methods listed in this interface, the Set class + * supports the following operations: + * + * - Stream I/O using the << and >> operators + * - Deep copying for the copy constructor and assignment operator + * - Iteration using the range-based for statement and STL iterators + * + * The iteration forms process the Set in ascending order. + */ + +/* Private section */ + +/**********************************************************************/ +/* Note: Everything below this point in the file is logically part */ +/* of the implementation and should not be of interest to clients. */ +/**********************************************************************/ + +private: + + Map map; /* Map used to store the element */ + bool removeFlag; /* Flag to differentiate += and -= */ + +public: + +/* + * Hidden features + * --------------- + * The remainder of this file consists of the code required to + * support the comma operator, deep copying, and iteration. + * Including these methods in the public interface would make + * that interface more difficult to understand for the average client. + */ + +/* Extended constructors */ + + template + explicit Set(CompareType cmp) : map(Map(cmp)) { + /* Empty */ + } + + Set & operator,(const ValueType & value) { + if (this->removeFlag) { + this->remove(value); + } else { + this->add(value); + } + return *this; + } + +/* + * Iterator support + * ---------------- + * The classes in the StanfordCPPLib collection implement input + * iterators so that they work symmetrically with respect to the + * corresponding STL classes. + */ + + class iterator : public std::iterator { + + private: + + typename Map::iterator mapit; /* Iterator for the map */ + + public: + + iterator() { + /* Empty */ + } + + iterator(typename Map::iterator it) : mapit(it) { + /* Empty */ + } + + iterator(const iterator & it) { + mapit = it.mapit; + } + + iterator & operator=(const iterator & it) { + if(*this != it){ + mapit = it.mapit; + } + return *this; + } + + iterator & operator++() { + ++mapit; + return *this; + } + + iterator operator++(int) { + iterator copy(*this); + operator++(); + return copy; + } + + bool operator==(const iterator & rhs) { + return mapit == rhs.mapit; + } + + bool operator!=(const iterator & rhs) { + return !(*this == rhs); + } + + ValueType operator*() { + return *mapit; + } + + ValueType *operator->() { + return mapit; + } + }; + + iterator begin() const { + return iterator(map.begin()); + } + + iterator end() const { + return iterator(map.end()); + } + +}; + +extern void error(std::string msg); + +template +Set::Set() { + /* Empty */ +} + +template +Set::~Set() { + /* Empty */ +} + +template +int Set::size() const { + return map.size(); +} + +template +bool Set::isEmpty() const { + return map.isEmpty(); +} + +template +void Set::add(const ValueType & value) { + map.put(value, true); +} + +template +void Set::insert(const ValueType & value) { + map.put(value, true); +} + +template +void Set::remove(const ValueType & value) { + map.remove(value); +} + +template +bool Set::contains(const ValueType & value) const { + return map.containsKey(value); +} + +template +void Set::clear() { + map.clear(); +} + +template +bool Set::isSubsetOf(const Set & set2) const { + iterator it = begin(); + iterator end = this->end(); + while (it != end) { + if (!set2.map.containsKey(*it)) return false; + ++it; + } + return true; +} + +/* + * Implementation notes: set operators + * ----------------------------------- + * The implementations for the set operators use iteration to walk + * over the elements in one or both sets. + */ + +template +bool Set::operator==(const Set & set2) const { + if (size() != set2.map.size()) return false; + iterator it1 = begin(); + iterator it2 = set2.map.begin(); + iterator end = this->end(); + while (it1 != end) { + if (map.compareKeys(*it1, *it2) != 0) return false; + ++it1; + ++it2; + } + return true; +} + +template +bool Set::operator!=(const Set & set2) const { + return !(*this == set2); +} + +template +Set Set::operator+(const Set & set2) const { + Set set = *this; + foreach (ValueType value in set2) { + set.add(value); + } + return set; +} + +template +Set Set::operator+(const ValueType & element) const { + Set set = *this; + set.add(element); + return set; +} + +template +Set Set::operator*(const Set & set2) const { + Set set = *this; + set.clear(); + foreach (ValueType value in *this) { + if (set2.contains(value)) set.add(value); + } + return set; +} + +template +Set Set::operator-(const Set & set2) const { + Set set = *this; + foreach (ValueType value in set2) { + set.remove(value); + } + return set; +} + +template +Set Set::operator-(const ValueType & element) const { + Set set = *this; + set.remove(element); + return set; +} + +template +Set & Set::operator+=(const Set & set2) { + foreach (ValueType value in set2) { + this->add(value); + } + return *this; +} + +template +Set & Set::operator+=(const ValueType & value) { + this->add(value); + this->removeFlag = false; + return *this; +} + +template +Set & Set::operator*=(const Set & set2) { + Vector toRemove; + foreach (ValueType value in *this) { + if (!set2.map.containsKey(value)) toRemove.add(value); + } + foreach (ValueType value in toRemove) { + this->remove(value); + } + return *this; +} + +template +Set & Set::operator-=(const Set & set2) { + Vector toRemove; + foreach (ValueType value in *this) { + if (set2.map.containsKey(value)) toRemove.add(value); + } + foreach (ValueType value in toRemove) { + this->remove(value); + } + return *this; +} + +template +Set & Set::operator-=(const ValueType & value) { + this->remove(value); + this->removeFlag = true; + return *this; +} + +template +ValueType Set::first() const { + if (isEmpty()) error("first: set is empty"); + return *begin(); +} + +template +std::string Set::toString() { + ostringstream os; + os << *this; + return os.str(); +} + +template +void Set::mapAll(void (*fn)(ValueType)) const { + map.mapAll(fn); +} + +template +void Set::mapAll(void (*fn)(const ValueType &)) const { + map.mapAll(fn); +} + +template +template +void Set::mapAll(FunctorType fn) const { + map.mapAll(fn); +} + +template +std::ostream & operator<<(std::ostream & os, const Set & set) { + os << "{"; + bool started = false; + foreach (ValueType value in set) { + if (started) os << ", "; + writeGenericValue(os, value, true); + started = true; + } + os << "}"; + return os; +} + +template +std::istream & operator>>(std::istream & is, Set & set) { + char ch; + is >> ch; + if (ch != '{') error("operator >>: Missing {"); + set.clear(); + is >> ch; + if (ch != '}') { + is.unget(); + while (true) { + ValueType value; + readGenericValue(is, value); + set += value; + is >> ch; + if (ch == '}') break; + if (ch != ',') { + error(std::string("operator >>: Unexpected character ") + ch); + } + } + } + return is; +} + +// hashing functions for sets; defined in hashmap.cpp +int hashCode(const Set& s); +int hashCode(const Set& s); +int hashCode(const Set& s); +int hashCode(const Set& s); +int hashCode(const Set& s); + +#endif diff --git a/lib/StanfordCPPLib/simpio.cpp b/lib/StanfordCPPLib/simpio.cpp new file mode 100755 index 0000000..4f91551 --- /dev/null +++ b/lib/StanfordCPPLib/simpio.cpp @@ -0,0 +1,67 @@ +/* + * File: simpio.cpp + * ---------------- + * This file implements the simpio.h interface. + */ + +#include +#include +#include +#include +#include "simpio.h" +using namespace std; + +/* + * Implementation notes: getInteger, getReal + * ----------------------------------------- + * Each of these functions reads a complete input line and then uses the + * library to parse that line into a value of the desired type. + * If that fails, the implementation asks the user for a new value. + */ + +int getInteger(string prompt) { + int value; + string line; + while (true) { + cout << prompt; + getline(cin, line); + istringstream stream(line); + stream >> value >> ws; + if (!stream.fail() && stream.eof()) break; + cout << "Illegal integer format. Try again." << endl; + if (prompt == "") prompt = "Enter an integer: "; + } + return value; +} + +double getReal(string prompt) { + double value; + string line; + while (true) { + cout << prompt; + getline(cin, line); + istringstream stream(line); + stream >> value >> ws; + if (!stream.fail() && stream.eof()) break; + cout << "Illegal numeric format. Try again." << endl; + if (prompt == "") prompt = "Enter a number: "; + } + return value; +} + +/* + * Implementation notes: getLine + * ----------------------------- + * The getLine function simply combines the process of displaying a + * prompt and reading an input line into a single call. The primary + * reason for including this function in the library is to ensure + * that the process of reading integers, floating-point numbers, and + * strings remains as consistent as possible. + */ + +string getLine(string prompt) { + string line; + cout << prompt; + getline(cin, line); + return line; +} diff --git a/lib/StanfordCPPLib/simpio.h b/lib/StanfordCPPLib/simpio.h new file mode 100755 index 0000000..25c32c1 --- /dev/null +++ b/lib/StanfordCPPLib/simpio.h @@ -0,0 +1,53 @@ +/* + * File: simpio.h + * -------------- + * This file exports a set of functions that simplify input/output + * operations in C++ and provide some error-checking on console input. + */ + +#ifndef _simpio_h +#define _simpio_h + +#include + +/* + * Function: getInteger + * Usage: int n = getInteger(prompt); + * ---------------------------------- + * Reads a complete line from cin and scans it as an + * integer. If the scan succeeds, the integer value is returned. If + * the argument is not a legal integer or if extraneous characters + * (other than whitespace) appear in the string, the user is given + * a chance to reenter the value. If supplied, the optional + * prompt string is printed before reading the value. + */ + +int getInteger(std::string prompt = ""); + +/* + * Function: getReal + * Usage: double x = getReal(prompt); + * ---------------------------------- + * Reads a complete line from cin and scans it as a + * floating-point number. If the scan succeeds, the floating-point + * value is returned. If the input is not a legal number or if + * extraneous characters (other than whitespace) appear in the string, + * the user is given a chance to reenter the value. If supplied, the + * optional prompt string is printed before reading the value. + */ + +double getReal(std::string prompt = ""); + +/* + * Function: getLine + * Usage: string line = getLine(prompt); + * ------------------------------------- + * Reads a line of text from cin and returns that line + * as a string. The newline character that terminates the input is + * not stored as part of the return value. If supplied, the optional + * prompt string is printed before reading the value. + */ + +std::string getLine(std::string prompt = ""); + +#endif diff --git a/lib/StanfordCPPLib/stack.h b/lib/StanfordCPPLib/stack.h new file mode 100755 index 0000000..21d5058 --- /dev/null +++ b/lib/StanfordCPPLib/stack.h @@ -0,0 +1,285 @@ +/* + * File: stack.h + * ------------- + * This file exports the Stack class, which implements + * a collection that processes values in a last-in/first-out (LIFO) order. + */ + +#ifndef _stack_h +#define _stack_h + +#include "vector.h" + +/* + * Class: Stack + * ----------------------- + * This class models a linear structure called a stack + * in which values are added and removed only from one end. + * This discipline gives rise to a last-in/first-out behavior (LIFO) + * that is the defining feature of stacks. The fundamental stack + * operations are push (add to top) and pop + * (remove from top). + */ + +template +class Stack { + +public: + +/* + * Constructor: Stack + * Usage: Stack stack; + * ------------------------------ + * Initializes a new empty stack. + */ + + Stack(); + +/* + * Destructor: ~Stack + * ------------------ + * Frees any heap storage associated with this stack. + */ + + virtual ~Stack(); + +/* + * Method: size + * Usage: int n = stack.size(); + * ---------------------------- + * Returns the number of values in this stack. + */ + + int size() const; + +/* + * Method: isEmpty + * Usage: if (stack.isEmpty()) ... + * ------------------------------- + * Returns true if this stack contains no elements. + */ + + bool isEmpty() const; + +/* + * Method: clear + * Usage: stack.clear(); + * --------------------- + * Removes all elements from this stack. + */ + + void clear(); + +/* + * Method: push + * Usage: stack.push(value); + * ------------------------- + * Pushes the specified value onto this stack. + */ + + void push(ValueType value); + +/* + * Method: pop + * Usage: ValueType top = stack.pop(); + * ----------------------------------- + * Removes the top element from this stack and returns it. This + * method signals an error if called on an empty stack. + */ + + ValueType pop(); + +/* + * Method: peek + * Usage: ValueType top = stack.peek(); + * ------------------------------------ + * Returns the value of top element from this stack, without removing + * it. This method signals an error if called on an empty stack. For + * compatibility with the STL classes, this method is also exported + * under the name top, in which case it returns the value + * by reference. + */ + + ValueType peek() const; + ValueType & top(); + +/* + * Method: toString + * Usage: string str = stack.toString(); + * ------------------------------------- + * Converts the stack to a printable string representation. + */ + + std::string toString(); + +/* + * Operator: == + * Usage: stack1 == stack2 + * ------------------- + * Returns true if stack1 and stack2 + * contain the same elements. + */ + + bool operator==(const Stack & stack2) const; + +/* + * Operator: != + * Usage: stack1 != stack2 + * ------------------- + * Returns true if stack1 and stack2 + * do not contain the same elements. + */ + + bool operator!=(const Stack & stack2) const; + +/* Private section */ + +/**********************************************************************/ +/* Note: Everything below this point in the file is logically part */ +/* of the implementation and should not be of interest to clients. */ +/**********************************************************************/ + +/* + * Implementation notes: Stack data structure + * ------------------------------------------ + * The easiest way to implement a stack is to store the elements in a + * Vector. Doing so means that the problems of dynamic memory allocation + * and copy assignment are already solved by the implementation of the + * underlying Vector class. + */ + +private: + Vector elements; + +}; + +extern void error(std::string msg); + +/* + * Stack class implementation + * -------------------------- + * The Stack is internally managed using a Vector. This layered design + * makes the implementation extremely simple, to the point that most + * methods can be implemented in as single line. + */ + +template +Stack::Stack() { + /* Empty */ +} + +template +Stack::~Stack() { + /* Empty */ +} + +template +int Stack::size() const { + return elements.size(); +} + +template +bool Stack::isEmpty() const { + return size() == 0; +} + +template +void Stack::push(ValueType value) { + elements.add(value); +} + +template +ValueType Stack::pop() { + if (isEmpty()) error("pop: Attempting to pop an empty stack"); + ValueType top = elements[elements.size() - 1]; + elements.remove(elements.size() - 1); + return top; +} + +template +ValueType Stack::peek() const { + if (isEmpty()) error("peek: Attempting to peek at an empty stack"); + return elements.get(elements.size() - 1); +} + +template +ValueType & Stack::top() { + if (isEmpty()) error("top: Attempting to read top of an empty stack"); + return elements[elements.size() - 1]; +} + +template +void Stack::clear() { + elements.clear(); +} + +template +std::string Stack::toString() { + ostringstream os; + os << *this; + return os.str(); +} + +template +bool Stack::operator==(const Stack & stack2) const { + if (size() != stack2.size()) return false; + for (int i = 0; i < size(); i++) { + if (this->elements[i] != stack2.elements[i]) { + return false; + } + } + return true; +} + +template +bool Stack::operator!=(const Stack & stack2) const { + return !(*this == stack2); +} + +template +std::ostream & operator<<(std::ostream & os, const Stack & stack) { + os << "{"; + Stack copy = stack; + Stack reversed; + while (!copy.isEmpty()) { + reversed.push(copy.pop()); + } + int len = stack.size(); + for (int i = 0; i < len; i++) { + if (i > 0) os << ", "; + writeGenericValue(os, reversed.pop(), true); + } + return os << "}"; +} + +template +std::istream & operator>>(std::istream & is, Stack & stack) { + char ch; + is >> ch; + if (ch != '{') error("operator >>: Missing {"); + stack.clear(); + is >> ch; + if (ch != '}') { + is.unget(); + while (true) { + ValueType value; + readGenericValue(is, value); + stack.push(value); + is >> ch; + if (ch == '}') break; + if (ch != ',') { + error(std::string("operator >>: Unexpected character ") + ch); + } + } + } + return is; +} + +// hashing functions for stacks; defined in hashmap.cpp +int hashCode(const Stack& s); +int hashCode(const Stack& s); +int hashCode(const Stack& s); +int hashCode(const Stack& s); +int hashCode(const Stack& s); + +#endif diff --git a/lib/StanfordCPPLib/strlib.cpp b/lib/StanfordCPPLib/strlib.cpp new file mode 100755 index 0000000..6a143ec --- /dev/null +++ b/lib/StanfordCPPLib/strlib.cpp @@ -0,0 +1,240 @@ +/* + * File: strlib.cpp + * ---------------- + * This file implements the strlib.h interface. + */ + +#include +#include +#include +#include +#include "error.h" +#include "strlib.h" +using namespace std; + +/* Function prototypes */ + +/* + * Implementation notes: numeric conversion + * ---------------------------------------- + * These functions use the library to perform the conversion. + */ + +string integerToString(int n) { + ostringstream stream; + stream << n; + return stream.str(); +} + +int stringToInteger(string str) { + return stoi(str); +} + +string realToString(double d) { + ostringstream stream; + stream << uppercase << d; + return stream.str(); +} + +double stringToReal(string str) { + return stod(str); +} + +/* + * Implementation notes: case conversion + * ------------------------------------- + * The functions toUpperCase and toLowerCase return a new string whose + * characters appear in the desired case. These implementations rely on + * the fact that the characters in the string are copied when the + * argument is passed to the function, which makes it possible to change + * the case of the copy without affecting the original. + */ + +string toUpperCase(string str) { + int nChars = str.length(); + for (int i = 0; i < nChars; i++) { + str[i] = toupper(str[i]); + } + return str; +} + +string toLowerCase(string str) { + int nChars = str.length(); + for (int i = 0; i < nChars; i++) { + str[i] = tolower(str[i]); + } + return str; +} + +/* + * Implementation notes: equalsIgnoreCase + * -------------------------------------- + * This implementation uses a for loop to cycle through the characters in + * each string. Converting each string to uppercase and then comparing + * the results makes for a shorter but less efficient implementation. + */ + +bool equalsIgnoreCase(string s1, string s2) { + if (s1.length() != s2.length()) return false; + int nChars = s1.length(); + for (int i = 0; i < nChars; i++) { + if (tolower(s1[i]) != tolower(s2[i])) return false; + } + return true; +} + +/* + * Implementation notes: startsWith, endsWith + * ------------------------------------------ + * These implementations are overloaded to allow the second argument to + * be either a string or a character. + */ + +bool startsWith(string str, string prefix) { + if (str.length() < prefix.length()) return false; + int nChars = prefix.length(); + for (int i = 0; i < nChars; i++) { + if (str[i] != prefix[i]) return false; + } + return true; +} + +bool startsWith(string str, char prefix) { + return str.length() > 0 && str[0] == prefix; +} + +bool endsWith(string str, string suffix) { + int nChars = suffix.length(); + int start = str.length() - nChars; + if (start < 0) return false; + for (int i = 0; i < nChars; i++) { + if (str[start + i] != suffix[i]) return false; + } + return true; +} + +bool endsWith(string str, char suffix) { + return str.length() > 0 && str[str.length() - 1] == suffix; +} + +string trim(string str) { + int finish = str.length() - 1; + while (finish >= 0 && isspace(str[finish])) { + finish--; + } + int start = 0; + while (start <= finish && isspace(str[start])) { + start++; + } + return str.substr(start, finish - start + 1); +} + +/* + * Implementation notes: readQuotedString and writeQuotedString + * ------------------------------------------------------------ + * Most of the work in these functions has to do with escape sequences. + */ + +static const string STRING_DELIMITERS = ",:)}]\n"; + +bool stringNeedsQuoting(const string & str) { + int n = str.length(); + for (int i = 0; i < n; i++) { + char ch = str[i]; + if (isspace(ch)) return false; + if (STRING_DELIMITERS.find(ch) != string::npos) return true; + } + return false; +} + +void readQuotedString(istream & is, string & str) { + str = ""; + char ch; + while (is.get(ch) && isspace(ch)) { + /* Empty */ + } + if (is.fail()) return; + if (ch == '\'' || ch == '"') { + char delim = ch; + while (is.get(ch) && ch != delim) { + if (is.fail()) error("Unterminated string"); + if (ch == '\\') { + if (!is.get(ch)) error("Unterminated string"); + if (isdigit(ch) || ch == 'x') { + int maxDigits = 3; + int base = 8; + if (ch == 'x') { + base = 16; + maxDigits = 2; + } + int result = 0; + int digit = 0; + for (int i = 0; i < maxDigits && ch != delim; i++) { + if (isdigit(ch)) { + digit = ch - '0'; + } else if (base == 16 && isxdigit(ch)) { + digit = toupper(ch) - 'A' + 10; + } else { + break; + } + result = base * result + digit; + if (!is.get(ch)) error("Unterminated string"); + } + ch = char(result); + is.unget(); + } else { + switch (ch) { + case 'a': ch = '\a'; break; + case 'b': ch = '\b'; break; + case 'f': ch = '\f'; break; + case 'n': ch = '\n'; break; + case 'r': ch = '\r'; break; + case 't': ch = '\t'; break; + case 'v': ch = '\v'; break; + case '"': ch = '"'; break; + case '\'': ch = '\''; break; + case '\\': ch = '\\'; break; + } + } + } + str += ch; + } + } else { + str += ch; + int endTrim = 0; + while (is.get(ch) && STRING_DELIMITERS.find(ch) == string::npos) { + str += ch; + if (!isspace(ch)) endTrim = str.length(); + } + if (is) is.unget(); + str = str.substr(0, endTrim); + } +} + +void writeQuotedString(ostream & os, const string & str, bool forceQuotes) { + if (!forceQuotes && stringNeedsQuoting(str)) forceQuotes = true; + if (forceQuotes) os << '"'; + int len = str.length(); + for (int i = 0; i < len; i++) { + char ch = str.at(i); + switch (ch) { + case '\a': os << "\\a"; break; + case '\b': os << "\\b"; break; + case '\f': os << "\\f"; break; + case '\n': os << "\\n"; break; + case '\r': os << "\\r"; break; + case '\t': os << "\\t"; break; + case '\v': os << "\\v"; break; + case '\\': os << "\\\\"; break; + default: + if (isprint(ch) && ch != '"') { + os << ch; + } else { + ostringstream oss; + oss << oct << setw(3) << setfill('0') << (int(ch) & 0xFF); + os << "\\" << oss.str(); + } + } + } + if (forceQuotes) os << '"'; +} diff --git a/lib/StanfordCPPLib/strlib.h b/lib/StanfordCPPLib/strlib.h new file mode 100755 index 0000000..bb27629 --- /dev/null +++ b/lib/StanfordCPPLib/strlib.h @@ -0,0 +1,222 @@ +/* + * File: strlib.h + * -------------- + * This file exports several useful string functions that are not + * included in the C++ string library. + */ + +#ifndef _strlib_h +#define _strlib_h + +#include +#include +#include + +/* + * Function: integerToString + * Usage: string s = integerToString(n); + * ------------------------------------- + * Converts an integer into the corresponding string of digits. + * For example, calling integerToString(123) returns + * the string "123". + */ + +std::string integerToString(int n); + +/* + * Function: stringToInteger + * Usage: int n = stringToInteger(str); + * ------------------------------------ + * Converts a string of digits into an integer. If the string is not a + * legal integer or contains extraneous characters other than whitespace, + * stringToInteger calls error with an + * appropriate message. + */ + +int stringToInteger(std::string str); + +/* + * Function: realToString + * Usage: string s = realToString(d); + * ---------------------------------- + * Converts a floating-point number into the corresponding string form. + * For example, calling realToString(23.45) returns + * the string "23.45". + */ + +std::string realToString(double d); + +/* + * Function: stringToReal + * Usage: double d = stringToReal(str); + * ------------------------------------ + * Converts a string representing a real number into its corresponding + * value. If the string is not a legal floating-point number or contains + * extraneous characters other than whitespace, stringToReal + * calls error with an appropriate message. + */ + +double stringToReal(std::string str); + +/* + * Function: toUpperCase + * Usage: string s = toUpperCase(str); + * ----------------------------------- + * Returns a new string in which all lowercase characters have been converted + * into their uppercase equivalents. + */ + +std::string toUpperCase(std::string str); + +/* + * Function: toLowerCase + * Usage: string s = toLowerCase(str); + * ----------------------------------- + * Returns a new string in which all uppercase characters have been converted + * into their lowercase equivalents. + */ + +std::string toLowerCase(std::string str); + +/* + * Function: equalsIgnoreCase + * Usage: if (equalsIgnoreCase(s1, s2)) ... + * ---------------------------------------- + * Returns true if s1 and s2 are + * equal discounting differences in case. + */ + +bool equalsIgnoreCase(std::string s1, std::string s2); + +/* + * Function: startsWith + * Usage: if (startsWith(str, prefix)) ... + * --------------------------------------- + * Returns true if the string str starts with + * the specified prefix, which may be either a string or a character. + */ + +bool startsWith(std::string str, std::string prefix); +bool startsWith(std::string str, char prefix); + +/* + * Function: endsWith + * Usage: if (endsWith(str, suffix)) ... + * ------------------------------------- + * Returns true if the string str ends with + * the specified suffix, which may be either a string or a character. + */ + +bool endsWith(std::string str, std::string suffix); +bool endsWith(std::string str, char suffix); + +/* + * Function: trim + * Usage: string trimmed = trim(str); + * ---------------------------------- + * Returns a new string after removing any whitespace characters + * from the beginning and end of the argument. + */ + +std::string trim(std::string str); + +/* Private section */ + +/**********************************************************************/ +/* Note: Everything below this point in the file is logically part */ +/* of the implementation and should not be of interest to clients. */ +/**********************************************************************/ + +/* + * Friend function: writeQuotedString + * Usage: writeQuotedString(outfile, str, forceQuotes); + * ---------------------------------------------------- + * Writes the string str to outfile surrounded by double quotes, converting + * special characters to escape sequences, as necessary. If the optional + * parameter forceQuotes is explicitly set to false, quotes are included + * in the output only if necessary. + */ + +void writeQuotedString(std::ostream & os, const std::string & str, + bool forceQuotes = true); + +/* + * Friend function: readQuotedString + * Usage: readQuotedString(infile, str); + * ------------------------------------- + * Reads the next string from infile into the reference parameter str. + * If the first character (other than whitespace) is either a single + * or a double quote, this function reads characters up to the + * matching quote, processing standard escape sequences as it goes. + * If not, readString reads characters up to any of the characters + * in the string STRING_DELIMITERS in the implementation file. + */ + +void readQuotedString(std::istream & is, std::string & str); + +/* + * Friend function: stringNeedsQuoting + * Usage: if (stringNeedsQuoting(str)) ... + * --------------------------------------- + * Checks whether the string needs quoting in order to be read correctly. + */ + +bool stringNeedsQuoting(const std::string & str); + +/* + * Friend function: writeGenericValue + * Usage: writeGenericValue(os, value, forceQuotes); + * ------------------------------------------------- + * Writes a generic value to the output stream. If that value is a string, + * this function uses writeQuotedString to write the value. + */ + +template +void writeGenericValue(std::ostream & os, const ValueType & value, + bool) { + os << value; +} + +template <> +inline void writeGenericValue(std::ostream & os, const std::string & value, + bool forceQuotes) { + writeQuotedString(os, value, forceQuotes); +} + +template +inline std::string genericValueToString(const ValueType & value, + bool forceQuotes = false) { + std::ostringstream os; + writeGenericValue(os, value, forceQuotes); + return os.str(); +} + +template <> +inline std::string genericValueToString(const std::string & value, + bool forceQuotes) { + std::ostringstream os; + writeQuotedString(os, value, forceQuotes); + return os.str(); +} + + +/* + * Friend function: readGenericValue + * Usage: readGenericValue(is, value); + * ----------------------------------- + * Reads a generic value from the input stream. If that value is a string, + * this function uses readQuotedString to read the value. + */ + +template +void readGenericValue(std::istream & is, ValueType & value) { + is >> value; +} + +template <> +inline void readGenericValue(std::istream & is, std::string & value) { + readQuotedString(is, value); +} + + +#endif diff --git a/lib/StanfordCPPLib/vector.h b/lib/StanfordCPPLib/vector.h new file mode 100755 index 0000000..9781daa --- /dev/null +++ b/lib/StanfordCPPLib/vector.h @@ -0,0 +1,727 @@ +/* + * File: vector.h + * -------------- + * This file exports the Vector class, which provides an + * efficient, safe, convenient replacement for the array type in C++. + */ + +#ifndef _vector_h +#define _vector_h + +#include +#include +#include +#include +#include "foreach.h" +#include "strlib.h" + +/* + * Class: Vector + * ------------------------ + * This class stores an ordered list of values similar to an array. + * It supports traditional array selection using square brackets, but + * also supports inserting and deleting elements. It is similar in + * function to the STL vector type, but is simpler both + * to use and to implement. + */ + +template +class Vector { + +public: + +/* + * Constructor: Vector + * Usage: Vector vec; + * Vector vec(n, value); + * --------------------------------------- + * Initializes a new vector. The default constructor creates an + * empty vector. The second form creates an array with n + * elements, each of which is initialized to value; + * if value is missing, the elements are initialized + * to the default value for the type. + */ + + Vector(); + explicit Vector(int n, ValueType value = ValueType()); + +/* + * Destructor: ~Vector + * ------------------- + * Frees any heap storage allocated by this vector. + */ + + virtual ~Vector(); + +/* + * Method: size + * Usage: int nElems = vec.size(); + * ------------------------------- + * Returns the number of elements in this vector. + */ + + int size() const; + +/* + * Method: isEmpty + * Usage: if (vec.isEmpty()) ... + * ----------------------------- + * Returns true if this vector contains no elements. + */ + + bool isEmpty() const; + +/* + * Method: clear + * Usage: vec.clear(); + * ------------------- + * Removes all elements from this vector. + */ + + void clear(); + +/* + * Method: get + * Usage: ValueType val = vec.get(index); + * -------------------------------------- + * Returns the element at the specified index in this vector. This + * method signals an error if the index is not in the array range. + */ + + const ValueType & get(int index) const; + +/* + * Method: set + * Usage: vec.set(index, value); + * ----------------------------- + * Replaces the element at the specified index in this vector with + * a new value. The previous value at that index is overwritten. + * This method signals an error if the index is not in the array range. + */ + + void set(int index, const ValueType & value); + +/* + * Method: insert + * Usage: vec.insert(0, value); + * ---------------------------- + * Inserts the element into this vector before the specified index. + * All subsequent elements are shifted one position to the right. This + * method signals an error if the index is outside the range from 0 + * up to and including the length of the vector. + */ + + void insert(int index, ValueType value); + +/* + * Method: remove + * Usage: vec.remove(index); + * ------------------------- + * Removes the element at the specified index from this vector. + * All subsequent elements are shifted one position to the left. This + * method signals an error if the index is outside the array range. + */ + + void remove(int index); + +/* + * Method: add + * Usage: vec.add(value); + * ---------------------- + * Adds a new value to the end of this vector. To ensure compatibility + * with the vector class in the Standard Template Library, + * this method is also called push_back. + */ + + void add(ValueType value); + void push_back(ValueType value); + +/* + * Operator: [] + * Usage: vec[index] + * ----------------- + * Overloads [] to select elements from this vector. + * This extension enables the use of traditional array notation to + * get or set individual elements. This method signals an error if + * the index is outside the array range. The file supports two + * versions of this operator, one for const vectors and + * one for mutable vectors. + */ + + ValueType & operator[](int index); + const ValueType & operator[](int index) const; + +/* + * Operator: + + * Usage: v1 + v2 + * -------------- + * Concatenates two vectors. + */ + + Vector operator+(const Vector & v2) const; + +/* + * Operator: += + * Usage: v1 += v2; + * v1 += value; + * ------------------- + * Adds all of the elements from v2 (or the single + * specified value) to v1. As a convenience, the + * Vector package also overloads the comma operator so + * that it is possible to initialize a vector like this: + * + *
+ *    Vector<int> digits;
+ *    digits += 0, 1, 2, 3, 4, 5, 6, 7, 8, 9;
+ *
+ */ + + Vector & operator+=(const Vector & v2); + Vector & operator+=(const ValueType & value); + + bool operator==(const Vector & v2); + bool operator!=(const Vector & v2); + +/* + * Method: toString + * Usage: string str = vec.toString(); + * ----------------------------------- + * Converts the vector to a printable string representation. + */ + + std::string toString(); + +/* + * Method: mapAll + * Usage: vec.mapAll(fn); + * ---------------------- + * Calls the specified function on each element of the vector in + * ascending index order. + */ + + void mapAll(void (*fn)(ValueType)) const; + void mapAll(void (*fn)(const ValueType &)) const; + + template + void mapAll(FunctorType fn) const; + +/* + * Additional Vector operations + * ---------------------------- + * In addition to the methods listed in this interface, the Vector + * class supports the following operations: + * + * - Stream I/O using the << and >> operators + * - Deep copying for the copy constructor and assignment operator + * - Iteration using the range-based for statement or STL iterators + * + * The iteration forms process the Vector in index order. + */ + +/* Private section */ + +/**********************************************************************/ +/* Note: Everything below this point in the file is logically part */ +/* of the implementation and should not be of interest to clients. */ +/**********************************************************************/ + +private: + +/* + * Implementation notes: Vector data structure + * ------------------------------------------- + * The elements of the Vector are stored in a dynamic array of + * the specified element type. If the space in the array is ever + * exhausted, the implementation doubles the array capacity. + */ + +/* Instance variables */ + + ValueType *elements; /* A dynamic array of the elements */ + int capacity; /* The allocated size of the array */ + int count; /* The number of elements in use */ + +/* Private methods */ + + void expandCapacity(); + void deepCopy(const Vector & src); + +/* + * Hidden features + * --------------- + * The remainder of this file consists of the code required to + * support deep copying and iteration. Including these methods + * in the public interface would make that interface more + * difficult to understand for the average client. + */ + +public: + +/* + * Deep copying support + * -------------------- + * This copy constructor and operator= are defined to make a deep copy, + * making it possible to pass or return vectors by value and assign + * from one vector to another. + */ + + Vector(const Vector & src); + Vector & operator=(const Vector & src); + +/* + * Operator: , + * ----------- + * Adds an element to the vector passed as the left-hand operatand. + * This form makes it easier to initialize vectors in old versions of C++. + */ + + Vector & operator,(const ValueType & value); + +/* + * Iterator support + * ---------------- + * The classes in the StanfordCPPLib collection implement input + * iterators so that they work symmetrically with respect to the + * corresponding STL classes. + */ + + class iterator : + public std::iterator { + + private: + const Vector *vp; + int index; + + public: + + iterator() { + this->vp = NULL; + } + + iterator(const iterator & it) { + this->vp = it.vp; + this->index = it.index; + } + + iterator(const Vector *vp, int index) { + this->vp = vp; + this->index = index; + } + + iterator & operator++() { + index++; + return *this; + } + + iterator operator++(int) { + iterator copy(*this); + operator++(); + return copy; + } + + iterator & operator--() { + index--; + return *this; + } + + iterator operator--(int) { + iterator copy(*this); + operator--(); + return copy; + } + + bool operator==(const iterator & rhs) { + return vp == rhs.vp && index == rhs.index; + } + + bool operator!=(const iterator & rhs) { + return !(*this == rhs); + } + + bool operator<(const iterator & rhs) { + extern void error(std::string msg); + if (vp != rhs.vp) error("Iterators are in different vectors"); + return index < rhs.index; + } + + bool operator<=(const iterator & rhs) { + extern void error(std::string msg); + if (vp != rhs.vp) error("Iterators are in different vectors"); + return index <= rhs.index; + } + + bool operator>(const iterator & rhs) { + extern void error(std::string msg); + if (vp != rhs.vp) error("Iterators are in different vectors"); + return index > rhs.index; + } + + bool operator>=(const iterator & rhs) { + extern void error(std::string msg); + if (vp != rhs.vp) error("Iterators are in different vectors"); + return index >= rhs.index; + } + + iterator operator+(const int & rhs) { + return iterator(vp, index + rhs); + } + + iterator operator+=(const int & rhs) { + index += rhs; + return *this; + } + + iterator operator-(const int & rhs) { + return iterator(vp, index - rhs); + } + + iterator operator-=(const int & rhs) { + index -= rhs; + return *this; + } + + int operator-(const iterator & rhs) { + extern void error(std::string msg); + if (vp != rhs.vp) error("Iterators are in different vectors"); + return index - rhs.index; + } + + ValueType & operator*() { + return vp->elements[index]; + } + + ValueType *operator->() { + return &vp->elements[index]; + } + + ValueType & operator[](int k) { + return vp->elements[index + k]; + } + + }; + + iterator begin() const { + return iterator(this, 0); + } + + iterator end() const { + return iterator(this, count); + } + +}; + +/* Implementation section */ + +extern void error(std::string msg); + +/* + * Implementation notes: Vector constructor and destructor + * ------------------------------------------------------- + * The constructor allocates storage for the dynamic array + * and initializes the other fields of the object. The + * destructor frees the memory used for the array. + */ + +template +Vector::Vector() { + count = capacity = 0; + elements = NULL; +} + +template +Vector::Vector(int n, ValueType value) { + count = capacity = n; + elements = (n == 0) ? NULL : new ValueType[n]; + for (int i = 0; i < n; i++) { + elements[i] = value; + } +} + +template +Vector::~Vector() { + if (elements != NULL) delete[] elements; +} + +/* + * Implementation notes: Vector methods + * ------------------------------------ + * The basic Vector methods are straightforward and should require + * no detailed documentation. + */ + +template +int Vector::size() const { + return count; +} + +template +bool Vector::isEmpty() const { + return count == 0; +} + +template +void Vector::clear() { + if (elements != NULL) delete[] elements; + count = capacity = 0; + elements = NULL; +} + +template +const ValueType & Vector::get(int index) const { + if (index < 0 || index >= count) error("get: index out of range"); + return elements[index]; +} + +template +void Vector::set(int index, const ValueType & value) { + if (index < 0 || index >= count) error("set: index out of range"); + elements[index] = value; +} + +/* + * Implementation notes: insert, remove, add + * ----------------------------------------- + * These methods must shift the existing elements in the array to + * make room for a new element or to close up the space left by a + * deleted one. + */ + +template +void Vector::insert(int index, ValueType value) { + if (count == capacity) expandCapacity(); + if (index < 0 || index > count) { + error("insert: index out of range"); + } + for (int i = count; i > index; i--) { + elements[i] = elements[i - 1]; + } + elements[index] = value; + count++; +} + +template +void Vector::remove(int index) { + if (index < 0 || index >= count) error("remove: index out of range"); + for (int i = index; i < count - 1; i++) { + elements[i] = elements[i + 1]; + } + count--; +} + +template +void Vector::add(ValueType value) { + insert(count, value); +} + +template +void Vector::push_back(ValueType value) { + insert(count, value); +} + +/* + * Implementation notes: Vector selection + * -------------------------------------- + * The following code implements traditional array selection using + * square brackets for the index. + */ + +template +ValueType & Vector::operator[](int index) { + if (index < 0 || index >= count) error("Selection index out of range"); + return elements[index]; +} +template +const ValueType & Vector::operator[](int index) const { + if (index < 0 || index >= count) error("Selection index out of range"); + return elements[index]; +} + +template +Vector Vector::operator+(const Vector & v2) const { + Vector vec = *this; + foreach (ValueType value in v2) { + vec.add(value); + } + return vec; +} + +template +Vector & Vector::operator+=(const Vector & v2) { + foreach (ValueType value in v2) { + *this += value; + } + return *this; +} + +template +Vector & Vector::operator+=(const ValueType & value) { + this->add(value); + return *this; +} + +template +bool Vector::operator==(const Vector & v2) { + if (this->size() != v2.size()) { + return false; + } + for (int i = 0, size = this->size(); i < size; i++) { + if (this->get(i) != v2.get(i)) { + return false; + } + } + return true; +} + +template +bool Vector::operator!=(const Vector & v2) { + return !(*this == v2); +} + +template +std::string Vector::toString() { + ostringstream os; + os << *this; + return os.str(); +} + +/* + * Implementation notes: copy constructor and assignment operator + * -------------------------------------------------------------- + * The constructor and assignment operators follow a standard paradigm, + * as described in the associated textbook. + */ + +template +Vector::Vector(const Vector & src) { + deepCopy(src); +} + +template +Vector & Vector::operator=(const Vector & src) { + if (this != &src) { + if (elements != NULL) delete[] elements; + deepCopy(src); + } + return *this; +} + +template +void Vector::deepCopy(const Vector & src) { + count = capacity = src.count; + elements = (capacity == 0) ? NULL : new ValueType[capacity]; + for (int i = 0; i < count; i++) { + elements[i] = src.elements[i]; + } +} + +/* + * Implementation notes: The , operator + * ------------------------------------ + * The comma operator works adding the right operand to the vector and + * then returning the vector by reference so that it is set for the next + * value in the chain. + */ + +template +Vector & Vector::operator,(const ValueType & value) { + this->add(value); + return *this; +} + +/* + * Implementation notes: mapAll + * ---------------------------- + * The various versions of the mapAll function apply the function or + * function object to each element in ascending index order. + */ + +template +void Vector::mapAll(void (*fn)(ValueType)) const { + for (int i = 0; i < count; i++) { + fn(elements[i]); + } +} + +template +void Vector::mapAll(void (*fn)(const ValueType &)) const { + for (int i = 0; i < count; i++) { + fn(elements[i]); + } +} + +template +template +void Vector::mapAll(FunctorType fn) const { + for (int i = 0; i < count; i++) { + fn(elements[i]); + } +} + +/* + * Implementation notes: expandCapacity + * ------------------------------------ + * This function doubles the array capacity, copies the old elements + * into the new array, and then frees the old one. + */ + +template +void Vector::expandCapacity() { + capacity = max(1, capacity * 2); + ValueType *array = new ValueType[capacity]; + for (int i = 0; i < count; i++) { + array[i] = elements[i]; + } + if (elements != NULL) delete[] elements; + elements = array; +} + +/* + * Implementation notes: << and >> + * ------------------------------- + * The insertion and extraction operators use the template facilities in + * strlib.h to read and write generic values in a way that treats strings + * specially. + */ + +template +std::ostream & operator<<(std::ostream & os, const Vector & vec) { + os << "{"; + int len = vec.size(); + for (int i = 0; i < len; i++) { + if (i > 0) os << ", "; + writeGenericValue(os, vec[i], true); + } + return os << "}"; +} + +template +std::istream & operator>>(std::istream & is, Vector & vec) { + char ch; + is >> ch; + if (ch != '{') error("operator >>: Missing {"); + vec.clear(); + is >> ch; + if (ch != '}') { + is.unget(); + while (true) { + ValueType value; + readGenericValue(is, value); + vec += value; + is >> ch; + if (ch == '}') break; + if (ch != ',') { + error(std::string("operator >>: Unexpected character ") + ch); + } + } + } + return is; +} + +// hashing functions for vectors; defined in hashmap.cpp +int hashCode(const Vector& v); +int hashCode(const Vector& v); +int hashCode(const Vector& v); +int hashCode(const Vector& v); +int hashCode(const Vector& v); + +#endif diff --git a/res/EnglishWords.dat b/res/EnglishWords.dat new file mode 100755 index 0000000000000000000000000000000000000000..22031a44b60cfb831bc8e400e02ac5a089ecddea GIT binary patch literal 345126 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 ye*E0n7|-*FeRD80 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≧)Ku5<7Ycm|01>DlQ4VxVa~I`Eb9cU%Ur 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 m<3lB +#include "Boggle.h" +#include "random.h" +#include "shuffle.h" +#include "strlib.h" + +static const int NUM_CUBES = 16; // the number of cubes in the game +static const int CUBE_SIDES = 6; // the number of sides on each cube +static string CUBES[NUM_CUBES] = { // the letters on all 6 sides of every cube + "AAEEGN", "ABBJOO", "ACHOPS", "AFFKPS", + "AOOTTW", "CIMOTU", "DEILRX", "DELRVY", + "DISTTY", "EEGHNW", "EEINSU", "EHRTVW", + "EIOSST", "ELRTTY", "HIMNQU", "HLNNRZ" +}; + +// TODO: implement the members you declared in Boggle.h diff --git a/src/Boggle.h b/src/Boggle.h new file mode 100755 index 0000000..3abe9b5 --- /dev/null +++ b/src/Boggle.h @@ -0,0 +1,29 @@ +// This is the .h file you will edit and turn in. +// We have provided a minimal skeleton for you, +// but you must finish it as described in the spec. +// Also remove these comments here and add your own, as well as on the members. +// TODO: remove this comment header and replace it with your own + +#ifndef _boggle_h +#define _boggle_h + +#include +#include +// TODO: include any other header files you need + +using namespace std; + +class Boggle { +public: + const string DICTIONARY_FILE = "EnglishWords.dat"; + const int MIN_WORD_LENGTH = 4; + const int BOARD_SIZE = 4; + + // TODO: decide the public member functions and declare them + +private: + // TODO: decide the private member variables/functions and declare them + +}; + +#endif diff --git a/src/bogglemain.cpp b/src/bogglemain.cpp new file mode 100755 index 0000000..067c8a0 --- /dev/null +++ b/src/bogglemain.cpp @@ -0,0 +1,79 @@ +/* + * TDDD86 Boggle + * This file contains the main program and user interface for running your + * Boggle game. We provide you a skeleton of this file that contains a shell + * of the overall logic, but you must complete the playOneGame function. + * + * The playOneGame function talks to the Boggle class that you will write. + * This file should contain all user interaction (cout / cin), while the Boggle + * class should contain ALL game state such as the 16 letter cubes, the set of + * words that have been formed, the algorithms for searching for words, etc. + * + * Please do not modify this provided file. Your turned-in files should work + * with an unmodified version of all provided code files. + */ + +#include +#include +#include +#include "random.h" +#include "strlib.h" +#include "Boggle.h" +#include "bogglemain.h" + +using namespace std; + +int main() { + intro(); + + // play games repeatedly until user decides to quit + Boggle boggle; + while (true) { + playOneGame(boggle); + cout << endl; + if (!yesOrNo("Play again (Y/N)? ")) { + break; + } + } + + cout << "Have a nice day." << endl; + return 0; +} + +/* + * Explains the program to the user. + */ +void intro() { + cout << "Welcome to TDDD86 Boggle!" << endl; + cout << "This game is a search for words on a 2-D board of letter cubes." << endl; + cout << "The good news is that you might improve your vocabulary a bit." << endl; + cout << "The bad news is that you're probably going to lose miserably to" << endl; + cout << "this little dictionary-toting hunk of silicon." << endl; + cout << "If only YOU had a gig of RAM!" << endl; + cout << endl; + cout << "Press Enter to begin the game ... "; + string line; + getline(cin, line); +} + +/* + * Prompts the user to answer a yes/no question and returns true if the user + * typed 'yes' (or anything that starts with a 'y', case-insensitively), + * false if the user types anything that starts with 'n', or re-prompts if + * the user doesn't type a 'y' or 'n' word. + */ +bool yesOrNo(string prompt) { + cout << prompt; + while (true) { + string answer; + getline(cin, answer); + answer = trim(toLowerCase(answer)); + if (startsWith(answer, 'y')) { + return true; + } else if (startsWith(answer, 'n')) { + return false; + } else { + cout << "Please type a word that begins with 'y' or 'n'." << endl; + } + } +} diff --git a/src/bogglemain.h b/src/bogglemain.h new file mode 100755 index 0000000..78b7f25 --- /dev/null +++ b/src/bogglemain.h @@ -0,0 +1,21 @@ +/* + * TDDD86 Boggle + * This file declares required function prototypes that are defined in + * our provided bogglemain.cpp and your boggleplay.cpp that you will write. + * See the respective .cpp files for implementation comments for each function. + * Please do not modify this provided file. + */ + +#ifndef _bogglemain_h +#define _bogglemain_h + +#include "Boggle.h" +#include +using namespace std; + +void intro(); +void playOneGame(Boggle& boggle); +bool yesOrNo(string prompt); +void clearConsole(); + +#endif diff --git a/src/boggleplay.cpp b/src/boggleplay.cpp new file mode 100755 index 0000000..76bdcde --- /dev/null +++ b/src/boggleplay.cpp @@ -0,0 +1,32 @@ +// You will edit and turn in this CPP file. +// Also remove these comments here and add your own. +// TODO: remove this comment header and replace with your own + +#include +#include +#include +#include +#include "Boggle.h" +#include "bogglemain.h" +#include "strlib.h" +// TODO: include any other header files you need + +/* + * Plays one game of Boggle using the given boggle game state object. + */ +void playOneGame(Boggle& boggle) { + // TODO: implement this function (and add any other functions you like to help you) + +} + +/* + * Erases all currently visible text from the output console. + */ +void clearConsole() { +#if defined(_WIN32) || defined(_WIN64) + std::system("CLS"); +#else + // assume POSIX + std::system("clear"); +#endif +} diff --git a/src/readme.txt b/src/readme.txt new file mode 100755 index 0000000..48a3be7 --- /dev/null +++ b/src/readme.txt @@ -0,0 +1,3 @@ +This directory contains the source code files (*.cpp, *.h) +that you will write as you complete the assignment. +We will also put any instructor-provided code here. diff --git a/src/shuffle.h b/src/shuffle.h new file mode 100755 index 0000000..ebf48c2 --- /dev/null +++ b/src/shuffle.h @@ -0,0 +1,78 @@ +/* + * TDDD86 Boggle + * This file contains implementation of a shuffling function that operates on + * a 1-D and 2-D array, vector, or Grid of any type. + * You can use it in your program. + * Please do not modify this provided file. + */ + +#ifndef _shuffle_h +#define _shuffle_h + +#include "grid.h" +#include "random.h" +#include + +template +void shuffle(T* array, int length) { + for (int i = 0; i < length; i++) { + int j = randomInteger(i, length - 1); + if (i != j) { + T temp = array[i]; + array[i] = array[j]; + array[j] = temp; + } + } +} + +template +void shuffle(T** array2d, int rows, int cols) { + int length = rows * cols; + for (int i = 0; i < length; i++) { + int j = randomInteger(i, length - 1); + if (i != j) { + int r1 = i / cols; + int c1 = i % cols; + int r2 = j / cols; + int c2 = j % cols; + + T temp = array2d[r1][c1]; + array2d[r1][c1] = array2d[r2][c2]; + array2d[r2][c2] = temp; + } + } +} + +template +void shuffle(vector& v) { + for (int i = 0, length = v.size(); i < length; i++) { + int j = randomInteger(i, length - 1); + if (i != j) { + T temp = v[i]; + v[i] = v[j]; + v[j] = temp; + } + } +} + +template +void shuffle(Grid& grid) { + int rows = grid.numRows(); + int cols = grid.numCols(); + int length = rows * cols; + for (int i = 0; i < length; i++) { + int j = randomInteger(i, length - 1); + if (i != j) { + int r1 = i / cols; + int c1 = i % cols; + int r2 = j / cols; + int c2 = j % cols; + + T temp = grid[r1][c1]; + grid[r1][c1] = grid[r2][c2]; + grid[r2][c2] = temp; + } + } +} + +#endif