// 迭代器模式
// IteratorPattern.h檔案

#ifndef ITERATOR
#define ITERATOR

#include <iostream>
#include <iomanip>
#include <string>
#include <vector>
#include <list>

using std::string;
using std::cout;
using std::cin;
using std::endl;
using std::vector;
using std::list;

// 迭代器模式中的迭代器抽象類
// 模板用來確定迭代器遍歷的集合元素型別
template < class Item >
class Iterator
{
public:
	Iterator(){}
	virtual ~Iterator(){}

    virtual void first () = 0;
    virtual void next  () = 0;
    virtual bool isDone() = 0;
    virtual Item* currentItem() = 0;
};

// 迭代器要遍歷的選單項中的條目：餐廳的一種菜
class MenuItem
{
public:
    MenuItem(string name, string description, bool vegetarian, double price)
    {
        this->name = name;
        this->description = description;
        this->vegetarian = vegetarian;
        this->price = price;
    }

    string getName();
    string getDescription();
    double getPrice();
    bool isVegetarian();
    string toString();
private:
    string name;
    string description;
    bool   vegetarian;
    double price;
};

// 迭代器模式中的迭代器具體類
// 1. vector迭代器
template < class Item >
class VectorIterator : public Iterator < Item >
{
public:
    VectorIterator(vector < Item > items)
    {
        this->items = items;
        this->position = 0;
    }

    void first();
    void next();
    bool isDone();
    Item* currentItem();
private:
    vector < Item > items;
    int position;
};

// 1. vector迭代器
template < class Item >
void VectorIterator < Item > ::first()
{
    position = 0;
}

template < class Item >
void VectorIterator < Item > ::next()
{
    if (position < items.size())
    {
        position++;
    }
}

template < class Item >
bool VectorIterator < Item > ::isDone()
{
    if (position >= items.size())
    {
        return true;
    }
    else
    {
        return false;
    }
}

template < class Item >
Item* VectorIterator < Item > ::currentItem()
{
    if (position < items.size())
    {
        return &(items[position]);
    }
    else
    {
        return NULL;
    }
}

// 2. list迭代器
template < class Item >
class ListIterator : public Iterator < Item >
{
public:
    ListIterator(list < Item > items)
    {
        this->items = items;
        this->position = 0;
    }

    void first();
    void next();
    bool isDone();
    Item* currentItem();
private:
    list < Item > items;
    int position;
};

// 2. list迭代器
template < class Item >
void ListIterator < Item > ::first()
{
    position = 0;
}

template < class Item >
void ListIterator < Item > ::next()
{
    if (position < items.size())
    {
        items.erase(items.begin());
    }
}

template < class Item >
bool ListIterator < Item > ::isDone()
{
    if (position >= items.size())
    {
        return true;
    }
    else
    {
        return false;
    }
}

template < class Item >
Item* ListIterator < Item > ::currentItem()
{
    if (position < items.size())
    {
        return &(*(items.begin()));
    }
    else
    {
        return NULL;
    }
}

// 迭代器模式中的抽象集合角色（Aggregate）
template < class Item >
class Menu
{
public:
    Menu(){}
    virtual ~Menu(){}

    // 集合角色中用來建立迭代器角色的函式，留給子類實現
    virtual Iterator < Item > * createIterator() = 0;
};

// 迭代器模式中的具體集合角色（Concrete Aggregate）
template < class Item >
class DinerMenu : public Menu < Item >
{
public:
    DinerMenu() 
    {
        addItem("Vegetarian BLT",
            "(Fakin') Bacon with lettuce & tomato on whole wheat", true, 2.99);
        addItem("BLT",
            "Bacon with lettuce & tomato on whole wheat", false, 2.99);
        addItem("Soup of the day",
            "Soup of the day, with a side of potato salad", false, 3.29);
        addItem("Hotdog",
            "A hot dog, with saurkraut, relish, onions, topped with cheese",
            false, 3.05);
        addItem("Steamed Veggies and Brown Rice",
            "Steamed vegetables over brown rice", true, 3.99);
        addItem("Pasta",
            "Spaghetti with Marinara Sauce, and a slice of sourdough bread",
            true, 3.89);
    }

    void addItem(string name, string description, bool vegetarian, double price);
    vector < Item > getMenuItems();
    Iterator < Item > * createIterator();
private:
    vector < Item > menuItems;
};

// vector
template < class Item >
void DinerMenu < Item > ::addItem(string name, string description, bool vegetarian, double price)
{
    MenuItem mu(name, description, vegetarian, price);
    menuItems.push_back(mu);
}

template < class Item >
vector < Item > DinerMenu < Item > ::getMenuItems()
{
    return menuItems;
}

template < class Item >
Iterator < Item > * DinerMenu < Item > ::createIterator()
{
    return new VectorIterator < Item >(menuItems);
}

template < class Item >
class PancakeHouseMenu : public Menu < Item >
{
public:
    PancakeHouseMenu()
    {
        addItem("K&B's Pancake Breakfast",
            "Pancakes with scrambled eggs, and toast",
            true,
            2.99);

        addItem("Regular Pancake Breakfast",
            "Pancakes with fried eggs, sausage",
            false,
            2.99);

        addItem("Blueberry Pancakes",
            "Pancakes made with fresh blueberries",
            true,
            3.49);

        addItem("Waffles",
            "Waffles, with your choice of blueberries or strawberries",
            true,
            3.59);
    }

    void addItem(string name, string description, bool vegetarian, double price);
    list < Item > getMenuItems();
    Iterator < Item > * createIterator();
private:
    list < Item > menuItems;
};

// list
template < class Item >
void PancakeHouseMenu < Item > ::addItem(string name, string description, bool vegetarian, double price)
{
    MenuItem mu(name, description, vegetarian, price);
    menuItems.push_back(mu);
}

template < class Item >
list < Item > PancakeHouseMenu < Item > ::getMenuItems()
{
    return menuItems;
}

template < class Item >
Iterator < Item > * PancakeHouseMenu < Item > ::createIterator()
{
    return new ListIterator < Item >(menuItems);
}

// 服務員來使用這兩個選單
template < class Item >
class Waitress
{
public:
    Waitress(PancakeHouseMenu < Item > pancakeHouseMenu,
        DinerMenu < Item > dinerMenu)
    {
        this->pancakeHouseMenu = pancakeHouseMenu;
        this->dinerMenu = dinerMenu;
    }

    void printMenu();
private:
    PancakeHouseMenu < Item > pancakeHouseMenu;
    DinerMenu < Item > dinerMenu;

    void printMenu(Iterator < Item > * iterator)
    {
        while (!iterator->isDone()) {
            Item menuItem = *(iterator->currentItem());
            cout << menuItem.getName() << ", " << endl;
            cout << menuItem.getPrice() << " -- " << endl;
            cout << menuItem.getDescription() << endl;

            iterator->next();
        }
    }
};

// 服務員來使用這兩個選單
template < class Item >
void Waitress < Item > ::printMenu()
{
    Iterator < Item > *pancakeIterator = pancakeHouseMenu.createIterator();
    Iterator < Item > *dinerIterator = dinerMenu.createIterator();

    cout << "MENU\n----\nBREAKFAST" << endl;
    printMenu(pancakeIterator);
    cout << "\nLUNCH" << endl;
    printMenu(dinerIterator);
}

#endif
 

// IteratorPattern.cpp檔案

#include "IteratorPattern.h"

// 迭代器要遍歷的選單項中的條目：餐廳的一種菜
string MenuItem::getName()
{
    return name;
}

string MenuItem::getDescription()
{
    return description;
}

double MenuItem::getPrice()
{
    return price;
}

bool MenuItem::isVegetarian()
{
    return vegetarian;
}

string MenuItem::toString()
{
    char buf[8];
    sprintf_s(buf, "%d", price);
    return (name + ", $" + buf + "\n   " + description);
}
 

// IteratorPatternTest.cpp檔案

#include "IteratorPattern.h"

void main()
{
    PancakeHouseMenu < MenuItem > pancakeHouseMenu;
    DinerMenu < MenuItem > dinerMenu;

    Waitress<MenuItem> waitress(pancakeHouseMenu, dinerMenu);

    waitress.printMenu();
}