using namespace std;
#include <iostream>
#include <vector>

/* Vector, Multiple Inheritance, virtual, Polymorphism demo

This demonstration uses two base classes and inherits into two
subclasses. We don't know how many members we'll be creating of
the Holiday class, so we use a vector which is a rather like an
array but not fixed in size when created (it's accessed via methods
rather than via [] notation too.

There's also an example of a factory method in here, where we call
a static method (a function) which internally calls the appropriate
constructor. The beauty of a factory method is that it can work out
which type of object it needs to create, rather than the calling code
having to perform that operation - which is naturally something you'll
want to be encapsulated in the class in most cases. */

/* Define a base class */

class Day {
        public:
                Day();
        };

class Holiday {
        public:
                Holiday();
                Holiday(int moy);
                int month;
                int getmoy();
                virtual int getdom() {} ;
        // Will be in each subclass. Empty block is needed to
        // avoid spectacular error messages!

        // Factory method
                 static Holiday * builder(int type, int dom_or_dow, int moy);
                 };

class Daybased : public Holiday , public Day{
        public:
                Daybased(int dom, int moy);
                int getdom();
        private:
                int dom;
        };

class Weekbased : public Holiday{
        public:
                Weekbased(int dow, int moy);
                int getdom();
        private:
                int dow;
        };

/* ----------------------- */

Day::Day() {
        cout << "itzaday" << endl;
        };

Holiday::Holiday() {
        };

Holiday::Holiday(int month) {
        this->month = month;
        };

int Holiday::getmoy() {
        return month;
        };

Daybased::Daybased(int dom, int moy) : Holiday(moy), Day() {
        this->dom = dom;
        };

int Daybased::getdom() {
        return dom;
        };

Weekbased::Weekbased(int dow, int moy) : Holiday(moy) {
        this->dow = dow;
        };

Holiday * Holiday::builder(int flag, int day, int moy) {
        if (flag == 1) {
                return new Weekbased(day,moy);
        }
                return new Daybased(day,moy);
        };

// This is where we need to look up the start day
// for a particular month (!)

int Weekbased::getdom() {
        int spooffactor = 100;
        return dow + spooffactor;
        };

/* ------------------ */

int main() {

        // Holiday *Bank [8];

        vector<Holiday *> Bank(0) ;

        int k;
        Bank.push_back ( new Daybased(25,12));
        Bank.push_back ( new Daybased(26,12));
        Bank.push_back ( new Daybased(1,1));
        Bank.push_back ( new Weekbased(5,4));
        Bank.push_back ( Holiday::builder(1,1,4));
        // More typical call - Holiday::builder("Last Thursday in December");
        Bank.push_back ( new Weekbased(1,5));
        Bank.push_back ( new Weekbased(1,5));
        Bank.push_back ( new Weekbased(1,8));
        Bank.push_back( new Daybased(29,4));
        Bank.push_back( new Daybased(29,4));

        for (k=0; k<Bank.size(); k++) {
                Holiday *Current = Bank.at(k);

        // Polymorphic - many-way switch saved as it works out the
        // object type for itself.
                cout << Current->getdom() << "/";

        // From base class - always the same code and it only has to
        // be defined once and is then inherited.
                cout << Current->getmoy() << endl;
        }

}

/* Output when run:

itzaday
itzaday
itzaday
itzaday
itzaday
25/12
26/12
1/1
105/4
101/4
101/5
101/5
101/8
29/4
29/4
wizard:antrim graham$

*/