field.h

#pragma once

#include <list>

#include "Coordinates.h"

enum State{is_undefined= -1, is_usable, is_unusable, is_road, is_in_out, max_state};

class Field
{

protected:

    unsigned nb_cols;
    unsigned nb_rows;
    std::list<Coordinates> ins_outs;

    State** parcels;

public:
    Field(unsigned width, unsigned height/*, std::list< Coordinates >& inputs_and_ouputs = *(new std::list<Coordinates>()) */);
    Field(const Field& other);

    virtual ~Field();

    /*=== Getters ===*/
    inline unsigned get_width() const   { return nb_cols; }
    inline unsigned get_height() const  { return nb_rows; }

    inline std::list<Coordinates> & get_insOuts() { return ins_outs; }

    inline unsigned getNbParcels() const    { return nb_cols * nb_rows; }

    /*=== Setters ===*/
    inline void set_width(unsigned width)
    { nb_cols =  width; }
    inline void set_height(unsigned height)
    { nb_rows =  height; }

    //private:
    void deleteOldMatrix();
    void resizeWithDimensions();
public:
    void add_road(const Coordinates& coords)
    { parcels[coords.row][coords.col]= is_road; }
    void add_road(unsigned col, unsigned row)
    { parcels[row][col]= is_road; }

    void addRoads(std::list<Coordinates>* roads, unsigned serveDistance);
    void removeRoads(std::list<Coordinates>* roads, unsigned serveDistance);

    bool tryAdd_in_out(const Coordinates& coords);
    bool tryAdd_in_out(unsigned col, unsigned row)
    { return tryAdd_in_out(Coordinates(col, row)); }

    void add_undefined(const Coordinates& coords);

    void add_undefined(unsigned col, unsigned row)
    { add_undefined(Coordinates(col, row)); }

public:
    inline State at(const Coordinates& pos) const { return parcels[pos.row][pos.col]; }
    inline State operator[](const Coordinates& pos) const { return parcels[pos.row][pos.col]; }
    inline Field& operator=(const Field& other)
    {
        assert(nb_cols == other.nb_cols && nb_rows == other.nb_cols);
        ins_outs= other.ins_outs;
        parcels= other.parcels;

        return *this;
    }

//     inline std::vector<std::vector<State>>::const_iterator begin() const { return parcels.cbegin(); }
//     inline std::vector<std::vector<State>>::const_iterator end() const { return parcels.cend(); }
//     inline std::vector<std::vector<State>>::iterator begin() { return parcels.begin(); }
//     inline std::vector<std::vector<State>>::iterator end() { return parcels.end(); }

    static inline Coordinates& first()
    { return *(new Coordinates(0,0)); }

public:
    /*=== Affichage ===*/
    void show_ins_and_outs() const;

    std::ostream& print(std::ostream& out) const;
    friend std::ostream& operator<<(std::ostream& out, const Field& field)
    { return field.print(out); }

    bool contains(int x, int y) const ;
    bool contains(const Coordinates& coord) const ;
    bool nextCoordinates ( Coordinates* coord ) const;

    void generateInsAndOuts(unsigned nb);

private:
    inline bool isRoad(const Coordinates& neighbour) const;
    inline bool isParcel(const Coordinates &neighbour) const;
    inline bool isUnusableParcel(const Coordinates &neighbour) const;
    bool isRoadAndNeighbourOf(const Coordinates& neighbour, const Coordinates& coord, unsigned servingDistance) const;

public:
//    /**
//     * Recherche des parcelles qui sont concomitantes à la cellule
//        * @param coord Coordonnées de la parcelle
//     * @return une liste de parcelle adjacentes à la cellule
//     */
//    std::list<Coordinates> *getNeighbourParcels( const Coordinates& coord ) const;
    std::list<Coordinates> *getNeighbourRoads( const Coordinates& coord ) const;


// bool
private:
    std::list<Coordinates> *getClose(const Coordinates &coord, unsigned maxDist, bool (Field::*neighbourVerif)(const Coordinates &) const) const;

public:
    std::list<Coordinates> *getCloseUnusableParcels( const Coordinates& coord, unsigned servingDistance ) const;
    std::list<Coordinates> *getCloseParcels( const Coordinates& coord, unsigned maxDist ) const;
    std::list<Coordinates> *getCloseRoads( const Coordinates& coord, unsigned maxDist ) const;
    std::list<Coordinates> *getServingRoads( const Coordinates& coord, unsigned servingDistance ) const;

//private:
    bool hasServingRoad ( const Coordinates& coord, unsigned servingDistance ) const;

public:
    void setUsables(unsigned servingDistance);
    void resetUsables(unsigned servingDistance);
    void updateUsables(unsigned servingDistance);

    /*=== Autres méthodes utiles ===*/
    void createExample();
};