// signal.cpp : 定义控制台应用程序的入口点。
//
/*
#include "stdafx.h"
#include "boost/utility/result_of.hpp"
#include "boost/typeof/typeof.hpp"
#include "boost/assign.hpp"
#include "boost/ref.hpp"
#include "boost/bind.hpp"
#include "boost/function.hpp"
#include "boost/signals2.hpp"
#include "iostream"
using namespace std;
void slots1()
{
cout << "slots1 call" << endl;
}
void slots2()
{
cout << "slots2 call" << endl;
}
struct Hello
{
void operator()() const
{
std::cout << "Hello";
}
};
int _tmain(int argc, _TCHAR* argv[])
{
boost::signals2::signal<void()> sig;
sig.connect(&slots1);
sig.connect(&slots2);
sig.connect(Hello());
sig();
boost::signals2::signal<void ()> sig1;
sig1.connect(Hello());
sig1();
int act;
cin >> act;
return 0;
}
*/
/*
#include "stdafx.h"
#include "boost/utility/result_of.hpp"
#include "boost/typeof/typeof.hpp"
#include "boost/assign.hpp"
#include "boost/ref.hpp"
#include "boost/bind.hpp"
#include "boost/function.hpp"
#include "boost/signals2.hpp"
#include "iostream"
using namespace std;
template<int N>
struct Slot
{
void operator()()
{
cout << "Slot current N value is : " << N << endl;
}
};
int _tmain(int argc, _TCHAR* argv[])
{
boost::signals2::signal<void()> sig;
sig.connect(Slot<1>(), boost::signals2::at_back); // 最后一个被调用
sig.connect(Slot<99>(), boost::signals2::at_front); // 第一个被调用
sig.connect(5, Slot<55>(), boost::signals2::at_back); // 组号5的最后一个
sig.connect(5, Slot<57>(), boost::signals2::at_front);// 组号5的第一个
sig.connect(10, Slot<100>());// 组号10该组只有一个
sig();
int act;
cin >> act;
return 0;
}
*/
/*
#include "stdafx.h"
#include "boost/utility/result_of.hpp"
#include "boost/typeof/typeof.hpp"
#include "boost/assign.hpp"
#include "boost/ref.hpp"
#include "boost/bind.hpp"
#include "boost/function.hpp"
#include "boost/signals2.hpp"
#include "iostream"
using namespace std;
template<int N>
struct Slot
{
int operator()(int x)
{
cout << "Slot current N * x value is : " << N << endl;
return (N * x);
}
};
int _tmain(int argc, _TCHAR* argv[])
{
boost::signals2::signal<int(int)> sig;
sig.connect(Slot<10>());
sig.connect(Slot<100>());
cout << *sig(2) << endl;
int a;
cin >> a;
return 0;
}
*/
/*
#include "stdafx.h"
#include "boost/utility/result_of.hpp"
#include "boost/typeof/typeof.hpp"
#include "boost/assign.hpp"
#include "boost/ref.hpp"
#include "boost/bind.hpp"
#include "boost/function.hpp"
#include "boost/signals2.hpp"
#include "numeric"
#include "iostream"
using namespace std;
template<int N>
struct Slot
{
int operator()(int x)
{
cout << "Slot current N * x value is : " << N << endl;
return (N * x);
}
};
template<typename T>
class combiner
{
public:
typedef pair<T, T> result_type;
combiner(T t = T()) : v(t)
{
}
template<typename InputIterator>
result_type operator()(InputIterator begin, InputIterator end) const
{
if (begin == end)
{
return result_type();
}
vector<T> vec(begin, end);
T sum = accumulate(vec.begin(), vec.end(), v);
T max = *max_element(vec.begin(), vec.end());
return result_type(sum, max);
}
private:
T v;
};
int _tmain(int argc, _TCHAR* argv[])
{
boost::signals2::signal<int(int), combiner<int> > sig;
sig.connect(Slot<10>());
sig.connect(Slot<20>());
sig.connect(Slot<3>());
BOOST_AUTO(x, sig(2));
cout << x.first << ", " << x.second << endl;
return 0;
}
*/
/*
#include "stdafx.h"
#include "boost/utility/result_of.hpp"
#include "boost/typeof/typeof.hpp"
#include "boost/assign.hpp"
#include "boost/ref.hpp"
#include "boost/bind.hpp"
#include "boost/function.hpp"
#include "boost/signals2.hpp"
#include "numeric"
#include "iostream"
using namespace std;
template<int N>
struct Slot
{
int operator()(int x)
{
cout << "Slot current N * x value is : " << N << endl;
return (N * x);
}
};
template<int N>
bool operator== (const Slot<N>& a, const Slot<N>& b)
{
return true;
}
template<typename T>
class combiner
{
public:
typedef pair<T, T> result_type;
combiner(T t = T()) : v(t)
{
}
template<typename InputIterator>
result_type operator()(InputIterator begin, InputIterator end) const
{
if (begin == end)
{
return result_type();
}
vector<T> vec(begin, end);
T sum = accumulate(vec.begin(), vec.end(), v);
T max = *max_element(vec.begin(), vec.end());
return result_type(sum, max);
}
private:
T v;
};
int _tmain(int argc, _TCHAR* argv[])
{
boost::signals2::signal<int(int)> sig;
// assert(sig.empty());
sig.connect(0, Slot<10>());
sig.connect(Slot<20>());
sig(10);
sig.connect(1, Slot<30>());
sig(20);
assert(sig.num_slots() == 3);
sig.disconnect(0);
// assert(sig.num_slots() == 1);
sig.disconnect(Slot<30>());
// assert(sig.empty());
sig(2);
return 0;
}
*/
/*
#include "stdafx.h"
#include "boost/utility/result_of.hpp"
#include "boost/typeof/typeof.hpp"
#include "boost/assign.hpp"
#include "boost/ref.hpp"
#include "boost/bind.hpp"
#include "boost/function.hpp"
#include "boost/signals2.hpp"
#include "numeric"
#include "iostream"
using namespace std;
template<int N>
struct Slot
{
int operator()(int x)
{
cout << "Slot current N * x value is : " << N << endl;
return (N * x);
}
};
template<int N>
bool operator== (const Slot<N>& a, const Slot<N>& b)
{
return true;
}
template<typename T>
class combiner
{
public:
typedef pair<T, T> result_type;
combiner(T t = T()) : v(t)
{}
template<typename InputIterator>
result_type operator()(InputIterator begin, InputIterator end) const
{
if (begin == end)
{
return result_type();
}
vector<T> vec(begin, end);
T sum = accumulate(vec.begin(), vec.end(), v);
T max = *max_element(vec.begin(), vec.end());
return result_type(sum, max);
}
private:
T v;
};
int _tmain(int argc, _TCHAR* argv[])
{
boost::signals2::signal<int(int)> sig;
boost::signals2::connection c1 = sig.connect(0, Slot<10>());
int aa = sig.num_slots();
boost::signals2::connection c2 = sig.connect(0, Slot<10>());
aa = sig.num_slots();
boost::signals2::connection c3 = sig.connect(0, Slot<10>());
aa = sig.num_slots();
c1.disconnect();
aa = sig.num_slots();
assert(sig.num_slots() == 2);
assert(!c1.connected());
assert(c2.connected());
return 0;
}
*/
/*
#include "stdafx.h"
#include "boost/utility/result_of.hpp"
#include "boost/typeof/typeof.hpp"
#include "boost/assign.hpp"
#include "boost/ref.hpp"
#include "boost/bind.hpp"
#include "boost/function.hpp"
#include "boost/signals2.hpp"
#include "numeric"
#include "iostream"
using namespace std;
template<int N>
struct Slot
{
int operator()(int x)
{
cout << "Slot current N * x value is : " << endl;
return (N * x);
}
};
template<int N>
bool operator== (const Slot<N>& a, const Slot<N>& b)
{
return true;
}
template<typename T>
class combiner
{
public:
typedef pair<T, T> result_type;
combiner(T t = T()) : v(t)
{
}
template<typename InputIterator>
result_type operator()(InputIterator begin, InputIterator end) const
{
if (begin == end)
{
return result_type();
}
vector<T> vec(begin, end);
T sum = accumulate(vec.begin(), vec.end(), v);
T max = *max_element(vec.begin(), vec.end());
return result_type(sum, max);
}
private:
T v;
};
int _tmain(int argc, _TCHAR* argv[])
{
boost::signals2::signal<int(int)> sig;
sig.connect(0, Slot<10>());
assert(sig.num_slots() == 1);
{
boost::signals2::scoped_connection sc = sig.connect(0, Slot<20>());
assert(sig.num_slots() == 2);
sig(2);
}
assert(sig.num_slots() == 1);
sig(10);
return 0;
}
*/
/*
#include "stdafx.h"
#include "boost/utility/result_of.hpp"
#include "boost/typeof/typeof.hpp"
#include "boost/assign.hpp"
#include "boost/ref.hpp"
#include "boost/bind.hpp"
#include "boost/function.hpp"
#include "boost/signals2.hpp"
#include "numeric"
#include "iostream"
using namespace std;
template<int N>
struct Slot
{
void operator()(int x)
{
cout << "Slot current N is : " << N << endl;
}
};
template<int N>
bool operator== (const Slot<N>& a, const Slot<N>& b)
{
return true;
}
template<typename T>
class combiner
{
public:
typedef pair<T, T> result_type;
combiner(T t = T()) : v(t)
{
}
template<typename InputIterator>
result_type operator()(InputIterator begin, InputIterator end) const
{
if (begin == end)
{
return result_type();
}
vector<T> vec(begin, end);
T sum = accumulate(vec.begin(), vec.end(), v);
T max = *max_element(vec.begin(), vec.end());
return result_type(sum, max);
}
private:
T v;
};
int _tmain(int argc, _TCHAR* argv[])
{
boost::signals2::signal<void(int)> sig;
boost::signals2::connection c1 = sig.connect(0, Slot<10>());
boost::signals2::connection c2 = sig.connect(0, Slot<20>());
assert(sig.num_slots() == 2);
sig(2);
cout << "begin blocking..." << endl;
{
boost::signals2::shared_connection_block block(c1);
assert(sig.num_slots() == 2);
assert(c1.blocked());
sig(2);
}
cout << "end blocking.." << endl;
assert(!c1.blocked());
sig(2);
return 0;
}
*/
/*
#include "stdafx.h"
#include <stdlib.h>
#include <iostream>
#include <complex>
// include Boost header
#include <boost/signals2/signal.hpp>
// the class with slot function
class CObject
{
public:
int m_ObjIndex;
CObject( int idx )
{
m_ObjIndex = idx;
}
void slotFunc()
{
std::cout << "Object " << m_ObjIndex << std::endl;
}
};
int main( int argc, char** argv )
{
// create signal
typedef boost::signals2::signal<void ()> TSignalType;
TSignalType mSignal;
// create object
CObject *pObj1 = new CObject( 1 );
// connect signal /slot
mSignal.connect( std::bind( &CObject::slotFunc, pObj1 ) );
// emit signal
mSignal();
return 0;
}
*/
/*
#include "stdafx.h"
#include <stdlib.h>
#include <iostream>
#include <complex>
// include Boost header
#include <boost/signals2/signal.hpp>
// the class with slot function
class CObject
{
public:
int m_ObjIndex;
CObject( int idx )
{
m_ObjIndex = idx;
}
void slotFunc()
{
std::cout << "Object " << m_ObjIndex << std::endl;
}
};
int main( int argc, char** argv )
{
// create signal
typedef boost::signals2::signal<void ()> TSignalType;
TSignalType mSignal;
// create object
CObject *pObj1 = new CObject( 1 );
// connect signal /slot
mSignal.connect( std::bind( &CObject::slotFunc, pObj1 ) );
// emit signal
mSignal();
return 0;
}
*/
/*
#include "stdafx.h"
#include <stdlib.h>
#include <iostream>
#include <complex>
// include Boost header
#include <boost/signals2/signal.hpp>
// the class with slot function
class CObject
{
public:
int m_ObjIndex;
CObject( int idx )
{
m_ObjIndex = idx;
}
void slotFunc()
{
std::cout << "Object " << m_ObjIndex << std::endl;
}
};
int main( int argc, char** argv )
{
// create signal
typedef boost::signals2::signal<void ()> TSignalType;
TSignalType mSignal;
// create object
CObject *pObj1 = new CObject( 1 );
// connect signal /slot
{
boost::shared_ptr<CObject> spObj( pObj1 );
mSignal.connect(TSignalType::slot_type(&CObject::slotFunc, spObj.get()).track(spObj));
// emit signal
mSignal();
}
// emit signal
mSignal();
return 0;
}
*/