Matrix.h

Go to the documentation of this file.

#ifndef __MATRIX__H__
#define __MATRIX__H__

#include <list>
#include <algorithm>
#include <limits>

#include "common.h"
#include "objects/Object.h"
#include "objects/ObjectFixed.h"
#include "objects/ObjectTransferable.h"
#include "objects/ObjectAgent.h"
#include "objects/ObjectTrail.h"
#include "configs/ConfigMatrix.h"

class Matrix {
public:
        typedef size_t SizeType;

public:
        friend class iterator;

        class iterator {
        public:
                typedef Matrix::SizeType SizeType;

                iterator(const Matrix * matrix, SizeType xIndex = 0, SizeType yIndex = 0):
                        m(matrix), x(xIndex), y(yIndex) {}

                iterator(const iterator &iter) {
                        *this = iter;
                }

                ~iterator() {}

                Object & operator *();

                Object * operator ->();

                iterator & operator ++();

                iterator operator ++(int);

                iterator & operator =(const iterator & iter);

                friend bool operator ==(const iterator & iter1, const iterator & iter2);

                friend bool operator !=(const iterator & iter1, const iterator & iter2);

        private:
                const Matrix * m;
                SizeType x;
                SizeType y;
        };

public:
        explicit Matrix(const ConfigMatrix & config);

        ~Matrix();

        iterator begin();

        iterator end() {
                return iterator(this, 0, height);
        }

        bool PutObject(Object * object, SizeType xIndex, SizeType yIndex);

        bool MoveObject(SizeType xFrom, SizeType yFrom, SizeType xTo, SizeType yTo);

        bool DestroyObject(SizeType xIndex, SizeType yIndex);

        bool IsThereObject(SizeType xIndex, SizeType yIndex) const;

        bool IsEditableByUser(SizeType xIndex, SizeType yIndex) const;

        void MakeStep();

        ConfigMatrix * GetConfigMatrix() const;

private:
        void SendCollisions(Object * firstObject, Object * secondObject);

        void PerformActions();

        void PerformSpecificOperations();

private:
        class SecondIndex {
        public:
                friend class Matrix;

                SecondIndex(Matrix * matrix): m(matrix) {}

                Object & operator [](SizeType secondIndex);

        private:
                Matrix * m;
                SizeType x;

                // Disable copy constructor
                SecondIndex(const SecondIndex &);
                // Disable assignment operator
                SecondIndex & operator =(const SecondIndex &);
                // User won't be able to destroy this object, so only Matrix can do it
                ~SecondIndex() {}
        };

public:
        SecondIndex & operator [](SizeType firstIndex);

private:
        class CallSpecificMethods: public std::unary_function<Object *, void> {
        public:
                void operator ()(Object * object) const {
                        object->ChooseNextAction();
                }
        };

        class RemoveSpecificObjects: public std::unary_function<Object *, bool> {
        public:
                bool operator ()(const Object * object) const {
                        return object->GetAction().GetAction() == Object::Action::EXPIRED_REMOVE;
                }
        };

        class SaveObjectIntoConfig: public std::unary_function<Object *, void> {
        public:
                explicit SaveObjectIntoConfig(ConfigMatrix * config,
                        SizeType xIndex, SizeType yIndex):
                        x(xIndex), y(yIndex), matrixConfig(config)
                {}

                void operator ()(const Object * object) const {
                        matrixConfig->AddConfigCell(new ConfigMatrix::ConfigCell(
                                x, y, object->CreateObjectConfig()));
                }

        private:
                const SizeType x;
                const SizeType y;
                ConfigMatrix * const matrixConfig;
        };

        class Item {
        public:
                typedef std::list<Object *> Container;

                typedef Container::size_type SizeType;

                Item() {}

                ~Item() {
                        RemoveAllObjects(true);
                }

                Object * GetTopObject() const {
                        return (!container.empty() ? *container.begin() : 0);
                }

                void AddObject(Object *object);

                bool RemoveObject(Object::Priority priority, bool freeMemory = true);

                bool RemoveTopObject(bool freeMemory = true);

                void RemoveAllObjects(bool freeMemory = true);

                bool IsThereObject() const {
                        return !container.empty();
                }

                template <class Function>
                void ApplyFunctionToEachObject(Function func, bool reversedPass = false) {
                        if (reversedPass) {
                                std::for_each(container.rbegin(), container.rend(), func);
                        }
                        else {
                                std::for_each(container.begin(), container.end(), func);
                        }
                }

                template <class Predicate>
                void RemoveObjectsAccToPredicate(Predicate pred) {
                        Container::iterator i = container.begin();
                        while (i != container.end()) {
                                if (pred(*i)) {
                                        delete *i;
                                        Container::iterator old = i;
                                        ++i;
                                        container.erase(old);
                                }
                                else {
                                        ++i;
                                }
                        }
                }

        private:
                Container container;
        };

public:
        SizeType GetWidth() const { return width; }

        SizeType GetHeight() const { return height; }

        static SizeType GetMinWidth() { return MIN_WIDTH; }

        static SizeType GetMinHeight() { return MIN_HEIGHT; }

        static SizeType GetDefaultWidth() { return DEFAULT_WIDTH; }

        static SizeType GetDefaultHeight() { return DEFAULT_HEIGHT; }

        static SizeType GetMaxWidth() { return MAX_WIDTH; }

        static SizeType GetMaxHeight() { return MAX_HEIGHT; }

private:
        SizeType width;
        SizeType height;
        static const SizeType MIN_WIDTH;
        static const SizeType MIN_HEIGHT;
        static const SizeType DEFAULT_WIDTH;
        static const SizeType DEFAULT_HEIGHT;
        static const SizeType MAX_WIDTH;
        static const SizeType MAX_HEIGHT;
        static const SizeType WIDTH_INCREMENT;
        static const SizeType HEIGHT_INCREMENT;

private:
        Item ** matrix;
        SecondIndex secIndex;
        Object::TicketSize ticketNumber;
        static const Object::TicketSize STARTING_TICKET_NUMBER = 0;

private:
        void IncreaseMatrixSizeForBorders();

        void CreateEmptyMatrix();

        void CreateWallsAroundMatrix();

        void LoadObjectsFromConfig(const ConfigMatrix & config);

        void GenerateNextTicketNumber() {
                ticketNumber++;
        }

        bool IsOutOfRange(SizeType xIndex, SizeType yIndex) const {
                return (xIndex >= GetWidth() || yIndex >= GetHeight());
        }

        string CreateOutOfRangeMessage(SizeType xIndex, SizeType yIndex) const;

        bool IndexExists(SizeType xIndex, SizeType yIndex) const {
                return (xIndex < GetWidth() && yIndex < GetHeight());
        }

        void GetIndexOfNextPlace(SizeType xFrom, SizeType yFrom, const Direction & direction,
                SizeType & xTo, SizeType & yTo);

        bool GetIndexOfNextFreePlace(SizeType xFrom, SizeType yFrom,
                SizeType & xTo, SizeType & yTo, Direction & direction);

        bool IsFreePlace(SizeType xIndex, SizeType yIndex) const {
                return (!IsThereObject(xIndex, yIndex) ||
                        matrix[yIndex * GetWidth() + xIndex]->GetTopObject()->IsImaginary());
        }

        bool OnBorder(SizeType xIndex, SizeType yIndex) const {
                return (xIndex == 0 || yIndex == 0 ||
                        xIndex == (GetWidth() - 1) || yIndex == (GetHeight() - 1));
        }

        bool CanBeAdded(const Object * object, SizeType xIndex, SizeType yIndex) const {
                return (!IsOutOfRange(xIndex, yIndex) && !OnBorder(xIndex, yIndex) &&
                        (!IsThereObject(xIndex, yIndex) ||
                                object->IsImaginary() ||
                                matrix[yIndex * GetWidth() + xIndex]->GetTopObject()->IsImaginary()));
        }

        void InternalMoveObject(SizeType xFrom, SizeType yFrom, const Direction & direction);

        void InternalMoveObject(SizeType xFrom, SizeType yFrom, SizeType xTo, SizeType yTo);

private:
        bool PerformActionTakeObject(Object * object, SizeType xIndex, SizeType yIndex);

        bool PerformActionDropObject(Object * object, SizeType xIndex, SizeType yIndex);

        bool PerformActionPutTrail(Object * object, SizeType xIndex, SizeType yIndex);
};

#endif /* #ifndef __MATRIX__H__ */

/* End of file Matrix.h */

---