// Purpose. Decorator design pattern lab
//
// Problem. Inheritance is being used to produce lots of incremental
// customizations. This is fine - until all the potential permutations of
// options gets out of hand. Another limitation is the static nature of
// inheritance. For any particular combination of options to be useable,
// the class hierarchy must explicitly implement that combination. It would
// be much better if all the individual "options" could each be represented
// by their own class, and, the client could dynamically compose her
// peculiar list of options at run-time.
//
// Assignment.
// o Add an abstract base class Expression with the single pure virtual
// function evaluate().
// o Function should inherit from Expression (but otherwise remain unchanged).
// o Add a base class Decorator that inherits from Expression.
// o Add an Expression* data member to Decorator (this will be used to remember
// the "core" object that this Decorator instance is "wrapping").
// o Decorator needs a constructor to initialize this Expression* data member.
// o Decorator's evaluate() should do nothing more than delegate to the
// Expression* data member.
// o LowCut and HighCut should now inherit from Decorator instead of Function.
// o Eliminate MiddlePass.
// o Add an Expression* parameter to LowCut's and HighCut's constructors (this
// is the "core" object that this "onion skin" is going to be wrapping).
// o Use a member initialization list to communicate the Expression* parameter
// to the Decorator base class.
// o LowCut's and HighCut's evaluate() should now call base class Decorator's
// evaluate() instead of Function's (Function is no longer serving as a base
// class).
// o Now that LowCut and HighCut no longer have an "isa" relationship to
// Function (they are now "embellishments" for a core object of type
// Function), the "lc" and "hc" local variables in main() must have a
// Function* at the "core" of their constructor arguments. This could be
// done with an inline dynamic allocation (new Function).
// o The MiddlePass class no longer exists. Therefore, the "mp" local variable
// in main() will be configured by using a layering of "decorator" objects on
// a "core" object.

#include <iostream.h>
#include <stdlib.h>
#include <time.h>

class Function {
public:
Function() {
time_t t;
srand((unsigned) time(&t)); }
virtual int evaluate() {
return rand() % 30; }
};

class LowCut : virtual public Function {
public:
LowCut( int min ) {
minimum_ = min; }
int evaluate() {
int temp = Function::evaluate();
if (temp < minimum_) return minimum_;
return temp; }
protected:
int minimum_;
};


class HighCut : virtual public Function {
public:
HighCut( int max ) {
maximum_ = max; }
int evaluate() {
int temp = Function::evaluate();
if (temp > maximum_) return maximum_;
return temp; }
protected:
int maximum_;
};

class MiddlePass : public LowCut, public HighCut {
public:
MiddlePass( int min, int max ) : LowCut(min), HighCut(max) { }
int evaluate() {
int temp = LowCut::evaluate();
if (temp > maximum_) return maximum_;
return temp; }
};

void main( void )
{
LowCut lc( 7 );
HighCut hc( 23 );
MiddlePass mp( 10, 20 );
int i;

for (i=0; i < 25; i++) cout << lc.evaluate() << " "; cout << endl;
for (i=0; i < 25; i++) cout << hc.evaluate() << " "; cout << endl;
for (i=0; i < 25; i++) cout << mp.evaluate() << " "; cout << endl;
}

// 27 18 7 13 19 13 22 16 22 16 17 11 13 13 10 20 22 7 8 23 14 7 29 7 15
// 2 22 23 15 8 16 7 18 7 10 6 21 6 19 3 23 0 20 5 13 23 3 2 6 1
// 18 19 20 20 12 10 14 14 13 14 20 20 20 10 12 18 10 11 10 18 20 20 10 10 10
//
// 11 19 26 27 7 7 25 15 10 9 23 8 10 13 20 18 14 7 7 17 7 7 7 22 25
// 11 4 6 23 22 10 15 23 22 2 12 19 19 12 13 18 6 15 6 1 13 1 10 14 23
// 18 20 20 20 10 20 17 10 20 15 20 17 10 16 10 10 10 17 20 20 11 14 20 10 10
//
// 7 7 11 29 27 7 11 16 27 15 10 26 27 7 11 28 17 7 7 13 11 20 26 21 29
// 22 23 23 23 3 13 17 13 12 0 23 23 3 11 14 23 13 4 0 23 9 22 23 14 14
// 10 10 10 10 10 10 10 10 19 14 14 10 13 10 11 14 20 16 20 20 20 10 18 18 10