// Purpose. Chain of Responsibility. #include <iostream.h>
//
// Discussion. Instead of the client class H {
// having to know about the number of public:
// "handlers", and manually map re- H( H* next = 0 ) {
// quests to available handlers; de- id_ = count_++;
// sign the handlers into an "intel- busy_ = 0;
// ligent" chain. Clients "launch next_ = next;
// and leave" requests with the head }
// of the chain. ~H() {
cout << id_<<" dtor" << endl;
#include <iostream.h> // don't get into a loop
if (next_->next_) {
class H { H* t = next_;
public: next_ = 0;
H() { delete t;
id_ = count_++; } }
busy_ = 0; void setNext( H* next ) {
} next_ = next;
~H() { }
cout << id_ << " dtor" << endl; void handle() {
} if (busy_ = ! busy_)
int handle() { cout << id_ << " handles"
if (busy_ = ! busy_) { << endl;
cout << id_ << " handles" else {
<< endl; cout << id_ << " is busy"
return 1; << endl;
} else { next_->handle();
cout << id_ << " is busy" } }
<< endl; private:
return 0; int id_, busy_;
} } H* next_;
private: static int count_;
int id_, busy_; };
static int count_; int H::count_ = 1;
};
int H::count_ = 1; H* setUpList() {
H* first = new H;
void main( void ) { H* last = new H(first);
const int TOTAL = 2; first->setNext( last );
H* list[TOTAL] = { new H, new H }; return first;
}
for (int i=0; i < 6; i++)
for (int j=0; 1 ; void main( void ) {
j = (j + 1) % TOTAL) H* head = setUpList();
if (list[j]->handle())
break; for (int i=0; i < 6; i++)
head->handle();
for (int k=0; k < TOTAL; k++)
delete list[k]; delete head;
} }

// 1 handles // 1 handles
// 1 is busy // 1 is busy
// 2 handles // 2 handles
// 1 handles // 1 handles
// 1 is busy // 1 is busy
// 2 is busy // 2 is busy
// 1 handles // 1 handles
// 1 is busy // 1 is busy
// 2 handles // 2 handles
// 1 handles // 1 handles
// 1 dtor // 1 dtor
// 2 dtor // 2 dtor




// Purpose. Chain of Responsibility design pattern

// 1. Put a "next" pointer in the base class
// 2. The "chain" method in the base class always delegates to the next object
// 3. If the derived classes cannot handle, they delegate to the base class

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

class Base {
Base* next; // 1. "next" pointer in the base class
public:
Base() { next = 0; }
void setNext( Base* n ) { next = n; }
void add( Base* n ) { if (next) next->add( n ); else next = n; }
// 2. The "chain" method in the base class always delegates to the next obj
virtual void handle( int i ) { next->handle( i ); }
};

class Handler1 : public Base { public:
/*virtual*/ void handle( int i ) {
if (rand() % 3) { // 3. Don't handle requests 3 times out of 4
cout << "H1 passsed " << i << " ";
Base::handle( i ); // 3. Delegate to the base class
} else
cout << "H1 handled " << i << " ";
} };

class Handler2 : public Base { public:
/*virtual*/ void handle( int i ) {
if (rand() % 3) { cout << "H2 passsed " << i << " "; Base::handle( i ); }
else cout << "H2 handled " << i << " ";
} };

class Handler3 : public Base { public:
/*virtual*/ void handle( int i ) {
if (rand() % 3) { cout << "H3 passsed " << i << " "; Base::handle( i ); }
else cout << "H3 handled " << i << " ";
} };

void main( void ) {
srand( time( 0 ) );
Handler1 root; Handler2 two; Handler3 thr;
root.add( &two ); root.add( &thr );
thr.setNext( &root );
for (int i=1; i < 10; i++) {
root.handle( i ); cout << '\n';
} }

// H1 passsed 1 H2 passsed 1 H3 passsed 1 H1 passsed 1 H2 handled 1
// H1 handled 2
// H1 handled 3
// H1 passsed 4 H2 passsed 4 H3 handled 4
// H1 passsed 5 H2 handled 5
// H1 passsed 6 H2 passsed 6 H3 passsed 6 H1 handled 6
// H1 passsed 7 H2 passsed 7 H3 passsed 7 H1 passsed 7 H2 handled 7
// H1 handled 8
// H1 passsed 9 H2 passsed 9 H3 handled 9




// Purpose. Chain of Responsibility and Composite

// 1. Put a "next" pointer in the base class
// 2. The "chain" method in the base class always delegates to the next object
// 3. If the derived classes cannot handle, they delegate to the base class

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

class Component {
int value;
Component* next; // 1. "next" pointer in the base class
public:
Component( int v, Component* n ) { value = v; next = n; }
void setNext( Component* n ) { next = n; }
virtual void traverse() { cout << value << ' '; }
// 2. The "chain" method in the base class always delegates to the next obj
virtual void volunteer() { next->volunteer(); }
};

class Primitive : public Component { public:
Primitive( int val, Component* n = 0 ) : Component( val, n ) { }
/*virtual*/ void volunteer() {
Component::traverse();
// 3. Primitive objects don't handle volunteer requests 5 times out of 6
if (rand() * 100 % 6 != 0)
// 3. Delegate to the base class
Component::volunteer();
} };

class Composite : public Component {
vector<Component*> children;
public:
Composite( int val, Component* n = 0 ) : Component( val, n ) { }
void add( Component* c ) { children.push_back( c ); }
/*virtual*/ void traverse() {
Component::traverse();
for (int i=0; i < children.size(); i++)
children[i]->traverse();
}
// 3. Composite objects never handle volunteer requests
/*virtual*/ void volunteer() { Component::volunteer(); }
};

void main( void ) {
srand( time( 0 ) ); // 1
Primitive seven( 7 ); // |
Primitive six( 6, &seven ); // +-- 2
Composite three( 3, &six ); // | |
three.add( &six ); three.add( &seven ); // | +-- 4 5
Primitive five( 5, &three ); // |
Primitive four( 4, &five ); // +-- 3
Composite two( 2, &four ); // | |
two.add( &four ); two.add( &five ); // | +-- 6 7
Composite one( 1, &two ); // |
Primitive nine( 9, &one ); // +-- 8 9
Primitive eight( 8, &nine );
one.add( &two ); one.add( &three ); one.add( &eight ); one.add( &nine );
seven.setNext( &eight );
cout << "traverse: "; one.traverse(); cout << '\n';
for (int i=0; i < 8; i++) {
one.volunteer(); cout << '\n';
} }

// traverse: 1 2 4 5 3 6 7 8 9
// 4
// 4 5 6 7
// 4 5 6 7 8 9 4 5 6 7 8 9 4
// 4
// 4 5 6
// 4 5
// 4 5
// 4 5 6 7 8 9 4 5 6 7 8 9 4 5 6




// Purpose. Chain of Responsibility - links bid on job, chain assigns job
//
// 1. Base class maintains a "next" pointer
// 2. Each "link" does its part to handle (and/or pass on) the request
// 3. Client "launches and leaves" each request with the chain
// 4. The current bid and bidder are maintained in chain static members
// 5. The last link in the chain assigns the job to the low bidder

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

class Link {
int id;
Link* next; // 1. "next" pointer
static int theBid; // 4. Current bid and bidder
static Link* bidder;
public:
Link( int num ) { id = num; next = 0; }
void addLast( Link* l ) {
if (next) next->addLast( l ); // 2. Handle and/or pass on
else next = l;
}
void bid() {
int num = rand() % 9;
cout << id << '-' << num << " ";
if (num < theBid) {
theBid = num; // 4. Current bid and bidder
bidder = this;
}
if (next) next->bid(); // 2. Handle and/or pass on
else bidder->execute(); // 5. The last 1 assigns the job
}
void execute() {
cout << id << " is executing\n";
theBid = 999;
} };
int Link::theBid = 999; // 4. Current bid and bidder
Link* Link::bidder = 0;

void main( void ) {
Link chain( 1 );
for (int i=2; i < 7; i++)
chain.addLast( new Link( i ) );
srand( time( 0 ) );
for (i=0; i < 10; i++)
chain.bid(); // 3. Client "launches & leaves"
}

// 1-1 2-6 3-0 4-3 5-1 6-0 3 is executing
// 1-1 2-1 3-1 4-0 5-7 6-1 4 is executing
// 1-0 2-1 3-0 4-6 5-1 6-2 1 is executing
// 1-6 2-3 3-8 4-0 5-1 6-4 4 is executing
// 1-8 2-0 3-5 4-8 5-4 6-2 2 is executing
// 1-1 2-0 3-8 4-8 5-7 6-0 2 is executing
// 1-1 2-1 3-3 4-1 5-6 6-2 1 is executing
// 1-2 2-1 3-0 4-3 5-6 6-8 3 is executing
// 1-7 2-5 3-4 4-2 5-1 6-2 5 is executing
// 1-3 2-6 3-7 4-7 5-6 6-0 6 is executing