int main( void ) {
Subject subj;
DivObserver divObs1( &subj, 4 );
DivObserver divObs2( &subj, 3 );
ModObserver modObs3( &subj, 3 );
subj.set_val( 14 );
}
static int tolua_CCGUI_Subject_detach00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"Subject",0,&tolua_err) ||
(tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"LUA_FUNCTION",0,&tolua_err)) ||
!tolua_isnoobj(tolua_S,3,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
Subject* self = (Subject*) tolua_tousertype(tolua_S,1,0);
LUA_FUNCTION handler = *((LUA_FUNCTION*) tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'detach'", NULL);
#endif
{
self->detach(handler);
}
}
return 0;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'detach'.",&tolua_err);
return 0;
#endif
}
void Calculations(Subject p)
{
string choice;
while (choice != "e")
{
cout << "What would you like to calculate about your class? \n";
cout << " 1. Your overall grade\n 2. Points need in a category to get a specific grade\n 3. Exit to previous menu.\n";
cout << "Enter you choice: ";
cin >> choice; cout << "\n";
if (choice == "1")
{
p.calcGrade();
}
if (choice == "2")
{
p.Determine_Needed_Category_Points();
}
if (choice == "3")
{
cout << "Are you sure? (y/n) ";
cin >> choice; cout << "\n";
if (choice == "y")
{
choice = "e";
}
}
}
int main(int argc, char **argv) {
printf("\n\nBEGIN OF PROGRAM\n\n");
Physics physics;
Unit unit("foo");
AudioObserver audioObserver;
GraphicsObserver graphicsObserver;
Observer baseObserver;
Subject base = Subject::base();
base.addObserver(&audioObserver);
base.addObserver(&audioObserver);
physics.subject()->addObserver(&audioObserver);
physics.subject()->addObserver(&graphicsObserver);
physics.subject()->addObserver(&baseObserver);
for (unsigned int i = 0; i < 6; i++) {
physics.updateUnit(unit);
if (i == 3) {
physics.subject()->removeObserver(&baseObserver);
printf("#INFO: Base Observer removed\n");
}
}
printf("\n\nEND OF PROGRAM\n");
}
static int tolua_CCGUI_Subject_notify00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"Subject",0,&tolua_err) ||
!tolua_isnoobj(tolua_S,2,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
Subject* self = (Subject*) tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'notify'", NULL);
#endif
{
self->notify();
}
}
return 0;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'notify'.",&tolua_err);
return 0;
#endif
}
int main(){
Subject sub;
DivObserver divObs1(&sub, 4);
DivObserver divObs2(&sub, 3);
ModObserver modvObs3(&sub, 3);
sub.setVal(14);
return 0;
}
int main(int argc, const char *argv[])
{
Subject sub;
ConcreteObserver co;
sub.Add(&co);
sub.Notify();
return 0;
}
//Observer pattern
void pseudoMain2(){
Subject subject;
SpecificObserver observer1("Andrey");
SpecificObserver observer2("Clara");
subject.registerObserver(&observer1);
subject.registerObserver(&observer2);
subject.notifyObservers();
}
static void connect_method(Subject& subject, Foo& foo)
{
subject.Connect(&foo, &Foo::handler);
// Automatically disconnect when the foo instance is destroyed
// Benchmarks require connection management
foo.reg = make_slot_scope([&](void*) { subject.Disconnect(&foo, &Foo::handler); });
}
int main()
{
Subject subj;
subj.set_value(14);
cin.get();
}
void BehaviourPatterns::cObserver() {
Subject subj;
DivObserver div1( &subj, 60 );
MultObserver mult1( &subj, 3 );
DivObserver div2( &subj, 42 );
MultObserver mult2( &subj, 5 );
subj.SetValue( 3 );
subj.SetValue( 5 );
}
int main()
{
Subject *sub = new RealSubject;
Subject *proxy = new Proxy(sub);
proxy->operation();
return 0;
}
int main()
{
Subject* proxy = new Proxy();
proxy->giveChocolate();
proxy->giveDolls();
proxy->giveFlowers();
return 0;
}
int main()
{
Subject subj;
DivObserver divObs1(&subj, 4); // 7. Client configures the number and
DivObserver divObs2(&subj, 3); // type of Observers
ModObserver modObs3(&subj, 3);
subj.setVal(14);
return 0;
}
void main( void ) {
Subject subj;
int value;
cout << "Input integer: ";
while (cin >> value) {
subj.setState( value );
cout << "\nInput integer: ";
}
}
int main()
{
Subject* pProxy = new Proxy();
pProxy->Request();
delete pProxy;
system("pause");
return 0;
}
int main(int argc, char *argv[])
{
Subject subj;
DivObserver divObs1(&subj, 4);
DivObserver divObs2(&subj, 3);
ModObserver modObs3(&subj, 3);
subj.setVal(14);
return 0;
}
int main() {
// your code goes here
Subject sub;
Observer *ob1 = new RavObserver(&sub);
Observer *ob2 = new MatObserver(&sub);
sub.set_data(12);
ob1->get_data();
ob2->get_data();
return 0;
}
void clientObserver() {
cout << "Observer\n";
Subject* subject = new Subject;
Observer* dp[] = { new Observer1, new Observer2, new Observer3};
for(size_t i=0; i<COUNT(dp); i++) {
subject->attach(dp[i]);
dp[i]->link(subject);
}
subject->notify();
cout << endl;
}
static void testSubjects()
{
Subject subj;
DummySubject dummy;
auto message = handle<DummyMessage>(0);
auto rcvr = handle<DummyReceiver>();
send(message, dummy);
const int times = 16;
start = hrc::now();
for(register int i = 0; i < times; ++i)
subj.send(message, dummy);
elapsed = hrc::now() - start;
cout << "Message delivery time (" << times << " times): " << elapsed.count() << " ns" << endl;
start = hrc::now();
connect(dummy, receiver);
elapsed = hrc::now() - start;
cout << "Message plain callback connection: " << elapsed.count() << " ns" << endl;
start = hrc::now();
connect(dummy, lambda([](Handle<DummyMessage> & msg, DummySubject & dst, const Subject * subj)
{
}));
elapsed = hrc::now() - start;
cout << "Message lambda callback connection: " << elapsed.count() << " ns" << endl;
start = hrc::now();
connect(dummy, rcvr, &DummyReceiver::receive);
elapsed = hrc::now() - start;
cout << "Message object callback connection: " << elapsed.count() << " ns" << endl;
start = hrc::now();
for(register int i = 0; i < times; ++i)
subj.send(message, dummy);
elapsed = hrc::now() - start;
cout << "Message delivery time with 3 connections (" << times << " times): " << elapsed.count() << " ns" << endl;
/*
start = hrc::now();
for(register int i = 0; i < times; ++i)
dummy.read(message, &subj);
elapsed = hrc::now() - start;
cout << "Immediate message delivery time (" << times << " times): " << elapsed.count() << " ns" << endl;
*/
}
int main()
{
Subject sujeto;
sujeto.set_noticia("Bla bla bla");
Personas<string> personas;
personas.insert("EPN", new Noticiero<string>);
string noticia = "Hola";
Command<string>* n = personas.getPersona("EPN");
cout << n->publica(noticia);
}
void subject_selector_write(int argc, char* argv[]) {
if (string(argv[2]) == "math") {
Math.write(argc, argv, "hw/mathhw.txt", "Math homework is: ");
}
else if (string(argv[2]) == "science") {
Science.write(argc, argv, "hw/sciencehw.txt", "Science homework is: ");
}
else if (string(argv[2]) == "socialstudies") {
SocialStudies.write(argc, argv, "hw/socialstudieshw.txt", "Social Studies homework is: ");
}
else {
cout << "You didn't give a command.";
}
}
void Door::onCollision() {
if(Inventory::getKey(key)) {
this->position.y += 0.01f;
if(playSound) {
playSound = false;
Subject sub;
DoorObserver dob(&sub, sound);
sub.setVal();
}
}
}
int main(int argc, char** argv) {
Subject subject;
subject.addObserver(ObserverObject(new Observer(1)));
subject.addObserver(ObserverObject(new Observer(2)));
subject.addObserver(ObserverObject(new Observer(3)));
subject.addObserver(ObserverObject(new Observer(4)));
subject.addObserver(ObserverObject(new Observer(5)));
subject.changeSubject();
std::this_thread::sleep_for(std::chrono::seconds(1));
return 0;
}
int main(int argc, char *argv[])
{
MyObserver my1, my3;
MyObserver2 my2;
Subject sub;
sub.Attach(&my1);
sub.Attach(&my2);
sub.Attach(&my3);
sub.Detach(&my3);
sub.Detach(&my2);
sub.Notify();
return 0;
}
void observe(uint iters, int N) {
for (uint iter = 0; iter < iters; iter++) {
BenchmarkSuspender bs;
Subject<int> subject;
std::vector<std::unique_ptr<Observer<int>>> observers;
for (int i = 0; i < N; i++) {
observers.push_back(makeObserver());
}
bs.dismiss();
for (int i = 0; i < N; i++) {
subject.observe(std::move(observers[i]));
}
bs.rehire();
}
}
Observer(Subject *mod, int div)
{
model = mod;
denom = div;
// 4. Observers register themselves with the Subject
model->attach(this);
}
void EditSubject::setSubject(const Subject &subject_)
{
m_subject.reset();
if (subject_.dates())
{
ui->autoDates->setChecked(false);
}
else
{
ui->autoDates->setChecked(true);
}
ui->hourCount->setValue(subject_.hourCount());
ui->firstClassDate->setDate(subject_.firstClass());
m_subject.reset(new Subject(subject_));
updateDates();
}
void notifyInlineObservers(uint iters, int N) {
for (uint iter = 0; iter < iters; iter++) {
BenchmarkSuspender bs;
Subject<int> subject;
std::vector<Observer<int>*> observers;
for (int i = 0; i < N; i++) {
observers.push_back(makeObserver().release());
}
for (int i = 0; i < N; i++) {
subject.observe(observers[i]);
}
bs.dismiss();
subject.onNext(42);
bs.rehire();
}
}
//Register this callback function for incomming messages
void TwitterOnReceive() {
char *message = AsyncMessage;
//Get the 'to' field of this message
JsonGetString(message, "to", tempBuffer);
//Hashtag multicast
if (tempBuffer[0] == '#') {
//Is there any callbacks registered to this message?
if (hashtagA.callback && !strcmp(hashtagA.hashtag, tempBuffer)) {
hashtagA.callback();
} else if (hashtagB.callback && !strcmp(hashtagB.hashtag, tempBuffer)) {
hashtagB.callback();
} else if (hashtagC.callback && !strcmp(hashtagC.hashtag, tempBuffer)) {
hashtagC.callback();
}
//Send message back if needed
isARelay = 1;
TwitterSendToAll(message);
isARelay = 0;
//Is this message directed towards me?
} else if (!strcmp(tempBuffer, name)) {
JsonGetString(message, "sub", tempBuffer);
//Is this part of a session?
if (tempBuffer[0] == 'c' && tempBuffer[1] == 'c') {
int key = JsonGetValue(message, "key");
//Find the callback
if (sessionA.key == key && sessionA.key != -1) {
Async(sessionA.callback, message);
sessionA.key = -1;
} else if (sessionB.key == key && sessionB.key != -1) {
Async(sessionB.callback, message);
sessionB.key = -1;
}
}
//Is there any callbacks registered to this message
else if (subjectA.callback && !strcmp(subjectA.subject, tempBuffer)) {
subjectA.callback();
} else if (subjectB.callback && !strcmp(subjectB.subject, tempBuffer)) {
subjectB.callback();
}
}
}
