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

/* A factory method implemented in C++, reading from a data
file within the factory with each call returning the next object
pointer, and a NULL return once there's no more data.

This example has a fixed size array to hold the objects that are
returned by the factory - see NEXT EXAMPLE (flow4) for a Vector
based example */

// -------------------------------

class Train {
        public:
                Train(char *);
                static Train* factory();
                int getcapacity();
        private:
                static ifstream *datasource;
                int ncars;
                int spv;
        };

// -------------------------------

/* We're using a static method (a factory pattern) to generate our
objects rather than calling the constructor directly. This allows us to
handle the reading of data from a file (in the form of an iterator and
return a NULL when we have run out of data */

ifstream * Train::datasource = NULL;

Train* Train::factory() {
        char trainline[256];
        if (! datasource) { // Only on the first call do you open the file
                datasource = new ifstream("trains.txt");
                }
        // read the (next) line from the file
        datasource->getline(trainline,256);
        if (datasource->eof()) {
                return NULL;
                }
        // Next line for demonstration
        cout << trainline << endl;
        return new Train(trainline);
        }

Train::Train(char * source) {

// Source line example: Train 06:45 3 75

// This constructor takes a character string record containing all the
// initial values for an object, separated them out ans stores the ones
// it needs into variables within the object

        int starts[4];
        int k=0;
        int param=0;

// Split the string by replacing the incoming separators with nulls so that
// you have in effect a series of null terminated strings

        while (source[k] != '\0') {
                if (source[k] == ' ') {
                        source[k] = '\0';
                        starts[param++] = k+1;
                }
                k++;
                if (param > 3) break;
        }

// Get the integers from the appropriate fields

        this->ncars = atoi(&source[starts[2]]);
        this->spv = atoi(&source[starts[1]]);
        }

int Train::getcapacity() {
        // 40% standing allowed in a train without it being overcrowded ...
        return (int)(this->ncars * this->spv * 1.4);
        }

// -------------------------------

int main () {
        Train *service[10];
        int traincount = 0;
        int k;

// Main program is quite short and straightforward - clever stuff is in the classes

        Train *current;

        while (1) {
                current = Train::factory();
                if (! current) break;
                service[traincount++] = current;
                }

        for (k=0; k<traincount; k++) {
                cout << service[k]->getcapacity() << endl;
                }
        return 0;

}

/* Sample running

munchkin:cj12 grahamellis$ g++ -o flow2 flow2.cpp
munchkin:cj12 grahamellis$ ./flow2
Train 06:45 3 75
Train 07:17 2 74
Train 19:11 1 68
Train 19:47 2 77
315
207
95
215
munchkin:cj12 grahamellis$

*/