// Formater je interface za različite objekte koji formatiraju
// text. Konkretni formateri prerađuju metodu format().
class Formater{
  public:
    virtual void format(std::string &) const = 0;
    virtual ~Formater(){}
};

class FormaterA : public Formater{
  public:
    void format(std::string & str) const {
       std::string tmp = "//: ";
       str = tmp + str;
    }
};

class FormaterB : public Formater{
  public:
    void format(std::string & str) const {
       std::string tmp = "\?\?- ";
       str = tmp + str;
    }
};

// FormaterCreator je sučelje za sve Creator klase.
// Konkretne Creator klase će instancirati konkretne Formater
// objekte.
class FormaterCreator{
  public:
    virtual Formater* make() const = 0;
    virtual ~FormaterCreator(){}
};

class FormaterACreator : public FormaterCreator{
  public:
    virtual Formater* make() const { return new FormaterA; }
};

class FormaterBCreator : public FormaterCreator{
  public:
    virtual Formater* make() const { return new FormaterB; }
};

// Cilj obrasca je omogućiti pisanje klijenta neovisno o tipu konkretnog
// formatera s kojim radi. Klijent radi samo sa sučeljima Formater i FormaterCreator.
class Klijent{
  public:
    void work(FormaterCreator const * formater){
      std::string text;
      text = "bla bla bla";
      Formater * pcc = formater->make();
      pcc->format(text);
      std::cout << text << std::endl;
      delete pcc;
    }
};

int main(){
  // Odluka o tipu formatiranja se donosi izvan aplikacije.
  Klijent app;

  FormaterCreator * f = new FormaterACreator;
  app.work(f);
  delete f;

  f = new FormaterBCreator;
  app.work(f);
  delete f;
}

template <typename TheFormater>
class TheCreator : public FormaterCreator{
  public:
    virtual Formater* make() const { return new TheFormater; }
};

class Singleton{
    public:
        // Metoda koja vraća jedinstvenu instancu klase
        static Singleton &  instance(){
                static Singleton _instance;
                return _instance;
        }

        Singleton(const Singleton &) = delete;
        Singleton(Singleton &&) = delete;
        Singleton & operator=(const Singleton &) = delete;
        Singleton & operator=(Singleton &&) = delete;
        // Ostale metode klase
        int  get_data() const  { return _data; }
        void set_data(int d){  _data = d; }
    private:
        // Konstruktor -- privatan da ne bi mogao biti pozvan
        Singleton() : _data(0) {}
        // Ostale varijable klase
        int    _data;
};

class Graphics{
    public:
        Graphics(SFMLGrid * pGrid, std::string const & fileName);
        void run();
    private:
        sf::RenderWindow mWindow;
        SFMLGrid * mGrid;

        void processEvents();
        void update();
        void render();
};

class SFMLGrid : public sf::Drawable, public sf::Transformable{
    public:
        SFMLGrid();
        virtual void readFromFile(std::string const & fileName);
    private:
        sf::VertexArray mVA;
        void draw(sf::RenderTarget & target, sf::RenderStates states) const override;
};

class GmshGrid{
  public:
    using Triangle = std::tuple<std::size_t, std::size_t, std::size_t>;
    GmshGrid();
    void read(const std::string & fileName);
    // ...
  private:
      std::vector<double>   mVertexXcoor;
      std::vector<double>   mVertexYcoor;
      std::vector<Triangle> mElement;
};

class Adapter: public SFMLGrid, private GmshGrid{
public:
    Adapter();
    void readFromFile(std::string const & fileName);
private:
   // ...
};

#include "composite.hh"

int main() {
        Component * folder1 = new Folder("top");
        Component * file1 = new TextFile("file1");
        Component * file2 = new TextFile("file2");
        Component * folder2 = new Folder("folder");
        Component * file3 = new TextFile("file3");
        Component * file4 = new TextFile("file4");

        folder1->addComponent(file1);
        folder1->addComponent(file2);
        folder1->addComponent(folder2);
        folder1->addComponent(file4);
        folder2->addComponent(file3);

        folder1->print(std::cout);
}

top
  file1
  file2
  folder
    file3
  file4

void shell_sort(int v[], int n) {
   for (int g = n / 2; g > 0; g /= 2)
     for (int i = g; i < n; i++)
       for (int j = i - g; j >= 0; j -= g)
         if (v[j] > v[j + g])
           std::swap(v[j], v[j + g]);
}

void shell_sort_back(int v[], int n) {
   for (int g = n / 2; g > 0; g /= 2)
     for (int i = g; i < n; i++)
       for (int j = i - g; j >= 0; j -= g)
         if (v[j] < v[j + g])
           std::swap(v[j], v[j + g]);
}

// apstraktna baza class AbstractShellSort{
    public:
        void sort(int v[], int n) const; // nevirtualna metoda
        virtual ~AbstractShellSort(){}
    protected:
        virtual bool doSwap(int, int) const = 0 ;
};

void AbstractShellSort::sort(int v[], int n) const {
   for (int g = n / 2; g > 0; g /= 2)
     for (int i = g; i < n; i++)
       for (int j = i - g; j >= 0; j -= g)
         if (doSwap(v[j], v[j + g]))
           std::swap(v[j], v[j + g]);
}

class  SortUp : public AbstractShellSort{
   protected:
        virtual bool doSwap(int a, int b) const { return a > b; }
};

class  SortDown : public AbstractShellSort{
   protected:
        virtual bool doSwap(int a, int b) const { return a < b; }
};

class AbstractSort{
    public:
        virtual void sort(int v[], int n) const;
        virtual ~AbstractSort(){}
};

Iterator it;
 for(it.first(); !it.isDone(); it.next()){
        auto current = it.current();
         // ....
 }

/** Design pattern: Observer.
 *  Bazna klasa za konkretne Subjekte.
 */
class Subject{
public:
        /** Dodaj pokazivač na zainteresiranog Promatrača. */
        virtual void attach(Observer * o);
        /** Ukloni pokazivač na Promatrača. */
        virtual void dettach(Observer * o);
        /** Obavijesti sve Promatrače o promjeni Subjekta. */
        virtual void notify();
        virtual ~Subject() {}
protected:
        /** Lista pokazivača na Promatrače zainteresirane za Subjekt.
         */
        std::list<Observer*> m_observers;
protected:
        typedef std::list<Observer*>::iterator iterator;
};

/** observer.cpp */
#include "observer.h"
#include <algorithm>
#include <iostream>
#include <ctime>

void Subject::attach(Observer* o){
        // Nemoj logirati više puta isti Promatrač
        iterator it = std::find(m_observers.begin(), m_observers.end(), o);
        if(it != m_observers.end())
                throw "Subject:: Observer already attached.";
        m_observers.push_back(o);
}

void Subject::dettach(Observer* o){
        // Eliminiraj promatrač ako je logiran.
        iterator it = std::find(m_observers.begin(), m_observers.end(), o);
        if(it == m_observers.end())
                        throw "Subject:: Observer is not attached.";
        m_observers.erase(it);
}

void Subject::notify(){
        // Zovi update() na svim promatračima
    iterator it = m_observers.begin();
    for( ; it != m_observers.end(); ++it)
        (*it)->update(this);
}

/** Konkretan Subjekt. Čuva informaciju o trenutnom vremenu.
 */
class Timer : public Subject{
public:
        Timer() : m_sec(0), m_min(0), m_hour(0) {}
        virtual int get_sec() const { return m_sec;}
        virtual int get_min() const { return m_min;}
        virtual int get_hour() const { return m_hour;}
    /** Postavlja stanje Timer-a, tj. trenutno vrijeme. */
        virtual void set_state();
private:
        int m_sec;
        int m_min;
        int m_hour;
};

/** observer.cpp */
void Timer::set_state(){
    // Uzmi trenutno vrijeme (zaglavlje <ctime>). time_t je integralni tip
    time_t now = std::time(0);
    // Konvertiraj dobiveno vrijeme u strukturu tm.
    tm * now_tm = std::localtime(&now);  // konverzija
    // Iz strukture tm pročitaj sekunde, minute i sate.
    m_sec = now_tm->tm_sec;
    m_min = now_tm->tm_min;
    m_hour= now_tm->tm_hour;
    // Obavijesti sve Promatrače -- stanje Subjekta je promijenjeno.
    notify();
}

/** Konkretan Promatrač.
 */
class NormalClock : public Observer{
public:
    NormalClock(Timer * pc) : m_pclock(pc) {m_pclock->attach(this); }
    /** Prerađeni update(). Identificira Subjekt i ignorira sve osim
                                onog kod kojeg je logiran.
     */
    virtual void update(Subject* ps){ if(m_pclock == ps) draw(); }
        /** Iscrtavanje sata. */
    virtual void draw() const;
private:
     /** Pokazivač na konkretni Subjekt. */
    Timer * m_pclock;
};

/** observer.cpp */
void NormalClock::draw() const{
        // "Iscrtavanje" sata.
   std::cout << m_pclock->get_hour()<<":"
                     << m_pclock->get_min()<<":"
                     << m_pclock->get_sec()<< std::endl;
}

std::vector<Visitable*> equipment;
Visitable * pk = new Keyboard(80.99);
Visitable * pm = new Mouse(120.0);
// ...

equipment.push_back(pk);
equipment.push_back(pm);
// ...

SummerDiscountPriceVisitor visitor;

for(Visitable * pv : equipment)
                pv->accept(&visitor);

class Visitor;

struct Visitable{
        virtual void accept(Visitor *) = 0;
        virtual ~Visitable() {}
};

class Keyboard : public Visitable {
        double m_price;
public:
        Keyboard(double price) : m_price(price) {}
        double get_price() const { return m_price; }
        virtual void accept(Visitor *v);
};

class Mouse : public Visitable {
        double m_price;
public:
        Mouse(double price) : m_price(price) {}
        double get_price() const { return m_price; }
        virtual void accept(Visitor *v);
};

// Implementacija accept metoda
void Keyboard::accept(Visitor *v) { v->visiteKeyboard(this); }
void Mouse::accept(Visitor *v) { v->visiteMouse(this); }

struct Visitor{
        virtual void visiteKeyboard(Keyboard *) = 0;
        virtual void visiteMouse(Mouse *) = 0;
};

// Konkretan Visitor
class SummerDiscountPriceVisitor : public Visitor{
public:
        SummerDiscountPriceVisitor() : m_sum(0.0) {}

        virtual void visiteKeyboard(Keyboard *);
        virtual void visiteMouse(Mouse *);

        double get_total_price() const { return m_sum; }
private:
        double m_sum;
        const double m_discount_keyboard = 0.1; // 10 %
        const double m_discount_mouse = 0.05;   // 5 %
};

void SummerDiscountPriceVisitor::visiteKeyboard(Keyboard *p_keyboard){
    double price = p_keyboard->get_price();
    double discount_price = price * (1 - m_discount_keyboard);
    m_sum += discount_price;
}

void SummerDiscountPriceVisitor::visiteMouse(Mouse *p_mouse){
    double price = p_mouse->get_price();
    double discount_price = price * (1 - m_discount_mouse);
    m_sum += discount_price;
}

int main() {
        std::vector<Visitable*> equipment;
        Visitable * pk = new Keyboard(80.99);
        Visitable * pm = new Mouse(120.0);

        equipment.push_back(pk);
        equipment.push_back(pm);

        SummerDiscountPriceVisitor visitor;

        for(Visitable * pv : equipment)
                pv->accept(&visitor);

        std::cout << "Total : " << visitor.get_total_price() << std::endl;

        delete pk;
        delete pm;
}

void checkForCollision(GameObject *o1, GameObject *o2){
  // Detekcija kolizije ovisi o stvarnom obliku objekata te stoga
  // naša funkcija mora biti "virtualna" po dva argumenta.
}

GameObject *po1 = new SpaceShip();
GameObject *po2 = new Asteroid();

po1->checkForCollision(po2); // po1 poziva funkciju iz SpaceShip klase, ali
                             // po2 "ostaje" GameObject*.

void SpaceShip::checkForCollision(GameObject* obj)
{
        const type_info & objectType = typeid(*obj);

        if(objectType == typeid(SpaceShip)){
            //  SpaceShip - SpaceShip kolizija
        }
        else if(objectType == typeid(SpaceStation)){
            //  SpaceShip - SpaceStation kolizija
        }
        else if(objectType == typeid(Asteroid)){
            //  SpaceShip - Asteroid kolizija
        }
        else
           throw std::runtime_error("Collision with unknown object");
}

void SpaceShip::checkForCollision(GameObject* obj){
        obj->checkForCollision(this);
}

GameObject *po1 = new SpaceShip();
GameObject *po2 = new Asteroid();

po1->checkForCollision(po2);