#pragma once

 #include <vector>

 #include "boost/noncopyable.hpp"

 #include "boost/typeof/typeof.hpp"

 #include "boost/serialization/singleton.hpp"

 #include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()

 using namespace boost;

 using namespace std;

 using namespace boost::serialization;

 class CNo_copy_class : public noncopyable

 {

 public:

     CNo_copy_class() : a(){}

     int a;

 };

 void no_copy_test()

 {

     CNo_copy_class c1;

     //CNo_copy_class c2(c1);

 }

 vector<int> func()

 {

     return vector<int>(, );

 }

 void typeof_auto_test()

 {

     //decltype(20*3.0) x1 = 20*3.0;

     BOOST_TYPEOF(*3.0) x2 = *3.0;

     BOOST_AUTO(&a, new double[]);

     BOOST_AUTO(p, make_pair(, "string"));

     BOOST_AUTO(v ,func());

     //注册自定义类型

     BOOST_TYPEOF_REGISTER_TYPE(CNo_copy_class)

     BOOST_AUTO( pdef, new CNo_copy_class());

     cout<< typeid(pdef).name() << endl;

 }

 typedef singleton<CNo_copy_class> origin;

 void singleton_test()

 {

     cout << origin::get_const_instance().a << endl;

     //origin::get_const_instance().a = 5;

     cout << origin::get_mutable_instance().a << endl;

     origin::get_mutable_instance().a = ;

     cout << origin::get_const_instance().a << endl;

 }

 #pragma once

 #include "boost/filesystem.hpp"

 using namespace boost;

 using namespace std;

 void path_string_opt_test()

 {

     filesystem::path p1;

     assert(p1.empty());

     filesystem::path p2("c:/user/local/include/xx.js");

     cout << p2.string() << endl;

     if (p2.has_stem())        //xx,文件名，无后缀

     {

         cout << p2.stem() << endl;

     }

     if (p2.has_extension())    //.js,文件名后缀

     {

         cout << p2.extension() << endl;

     }

     if (p2.has_filename())    //xx.js，文件全名，有后缀

     {

         cout << p2.filename() << endl;

     }

     if (p2.has_parent_path())    //c:/user/local/include，除去文件名的路径

     {

         cout << p2.parent_path() << endl;

     }

     if (p2.has_root_name())        //windows路径为c:

     {

         cout << p2.root_name() << endl;

     }

     if (p2.has_root_directory())    //windows路径为/

     {

         cout << p2.root_directory() << endl;

     }

     if (p2.has_root_path())        //windows路径为c:/

     {

         cout << p2.root_path() << endl;

     }

     //修改文件路径

     cout << p2.replace_extension("hxx") << endl;        //修改扩展名，修改后为c:/user/local/include/xx

     cout << p2.replace_extension() << endl;        //修改扩展名，修改后为c:/user/local/include/xx

     cout << p2.remove_filename() << endl;        //移除文件名，修改后为c:/user/local/include

 }

 void GetModulePath()

 {

     char szPath[MAX_PATH];

     GetModuleFileName( NULL, szPath, MAX_PATH );

     cout << szPath << endl;

     //输出：p:\workspace\proj\test\boost_test\build\src\Debug\BOOST_TEST.exe

     cout << boost::filesystem::initial_path<filesystem::path>().string() <<endl;

     //输出：p:\workspace\proj\test\boost_test\build\src

     //

     cout << boost::filesystem::current_path().string() << endl;

 }

 void directory_test()

 {

     boost::filesystem::path p1(boost::filesystem::current_path());

     p1.append("123\\456");

     //循环创建目录

     if (!boost::filesystem::exists(p1))

     {

         boost::filesystem::create_directories(p1);

     }

     //递归删除最底层目录

     if (boost::filesystem::exists(p1))

     {

         boost::filesystem::remove_all(p1);

     }

 }

 #pragma once

 #include <map>

 #include <vector>

 #include "boost/array.hpp"

 #include "boost/any.hpp"

 #include "boost/foreach.hpp"

 using namespace boost;

 using namespace std;

 void array_test()

 {

     array<int, > ar = {,};

     array<string, > ars = {""};

     for (int i=; i<; i++)

     {

         cout << ars[i] << endl;

     }

 }

 void any_test()

 {

     any a();

     int n = any_cast<int>(a);

     any_cast<int&>(a) = ;

 }

 void foreach_test()

 {

     int a[] = {, , , , , };

     vector<int> vec(a , a + );

     BOOST_FOREACH(int x, vec)

     {

         cout << x << endl;

     }

     BOOST_REVERSE_FOREACH(int x, vec)

     {

         cout << x << endl;

     }

 }

 #pragma once

 #include<iostream>

 #include <vector>

 #include "boost/smart_ptr.hpp"

 using namespace boost;

 using namespace std;

 //

 void scoped_ptr_test()

 {

     scoped_ptr<int> p(new int);

     if (p)

     {

         *p = ;

         cout << *p << endl;

     }

     p.reset();

 }

 void scoped_array_test()

 {

     scoped_array<int> p(new int[]);

     fill_n(&p[], , );

     p[] = p[] + p[];

 }

 void shared_ptr_test()

 {

     shared_ptr<int> p(new int());

     *p = ;

     //shared_ptr< vector<int> > mp = make_shared< vector<int> >(100,5);

     //shardptr可以指定析构函数

 }

 void shared_array_test()

 {

     shared_array<int> p(new int[]);

     shared_array<int> p2 = p;

     p[] = ;

     assert( p2[] == );

 }

 void weak_ptr_test()

 {

     shared_ptr<int> sp(new int());

     assert(sp.use_count() == );

     weak_ptr<int> wp(sp);

     assert(wp.use_count() == );

     if (!wp.expired())

     {

         shared_ptr<int> sp2 = wp.lock();

         *sp2 = ;

         assert(wp.use_count() ==  );

     }

     assert(wp.use_count() == );

     sp.reset();

     assert(wp.expired());

     assert(!wp.lock());

 }

 #pragma once

 #include "boost/utility/result_of.hpp"

 #include "boost/any.hpp"

 #include "boost/bind.hpp"

 #include "boost/function.hpp"

 using namespace boost;

 using namespace std;

 template<typename T, typename T1>

 typename result_of<T(T1)>::type call_func(T t, T1 t1)

 {

     return t(t1);

 }

 void result_of_test()

 {

     typedef double (*Func)(double);

     Func func = sqrt;

     result_of<Func(double)>::type x = func(5.0);

     cout << typeid(x).name() << endl;

     any x2 = call_func(func, 5.0);

     cout << typeid(boost::any_cast<double>(x2)).name() << endl;

 }

 int f(int a, int b)

 {

     return a + b;

 }

 int g(int a, int b, int c)

 {

     return a + b*c;

 }

 void bind_test()

 {

     cout << bind(f, , )() << endl;

     int x = , y = , z = ;

     cout << bind(f, _1, )(x) << endl;    //使用占位符

     cout << bind(g, _3, _2, _2)(x, y, z) << endl;    //使用占位符，乱序

     //绑定成员函数

     class demo

     {

     public:

         int f(int a, int b)

         {

             cout << a << " "<< b << endl;

             return a + b;

         }

     } a;

     demo& b = a;

     demo* p = &a;

     cout << bind(&demo::f, a, _1, )() << endl;

     cout << bind(&demo::f, b, _2, _1)(, ) << endl;

     cout << bind(&demo::f, p, _1, _2)(, ) << endl;

     //算法容器

     class point

     {

     public:

         int x,y;

         point() : x(), y() {}

         void print()

         {

             cout << x << " " << y << endl;

         }

     };

     std::vector<point> v();

     for_each(v.begin(), v.end(), bind(&point::print, _1));    //成员函数_1表示函数指针

 }

 void function_test()

 {

     boost::function<int(int, int)> func = f;

     if (func)

     {

         cout << func(, ) << endl;

     }

     func.clear();

     boost::function<int(int)> func1 = boost::bind(f, _1, );

     if (func1)

     {

         cout << func1() << endl;

     }

 }

 #pragma once

 #include <vector>

 #include "boost/pool/pool.hpp"

 #include "boost/pool/object_pool.hpp"

 #include "boost/pool/singleton_pool.hpp"

 #include "boost/pool/pool_alloc.hpp"

 using namespace boost;

 using namespace std;

 class demo_class

 {

 public:

     int a,b,c;

     demo_class(int x = ,int y=, int z=):a(x), b(y), c(z)

     {

     }

 };

 typedef singleton_pool<demo_class , sizeof(demo_class)> spl;

 void pool_test()

 {

     pool<> pl(sizeof(int));

     int* p = static_cast<int*>(pl.ordered_malloc());

     assert(pl.is_from(p));

     pl.ordered_free(p);

     for (int i=; i<; i++)

     {

         pl.ordered_malloc();

     }

 }

 void object_pool_test()

 {

     object_pool<demo_class> pl;

     demo_class *p = pl.malloc();

     assert(pl.is_from(p));

     assert(p->a !=  || p->b !=  || p->c != );

     p =pl.construct(, , );

     assert(p->a == );

     object_pool<std::string> pls;

     for (int i=; i< ;i++)

     {

         std::string *ps = pls.construct("hello");

         cout<< ps->c_str() << endl;

     }

 }

 void singleton_pool_test()

 {

     demo_class* p = (demo_class*)spl::malloc();

     assert(spl::is_from(p));

     spl::release_memory();

 }

 void pool_alloc_test()

 {

     std::vector<int, pool_allocator<int> > v;

     v.push_back();

 }

 #pragma once

 #include <stack>

 #include <vector>

 #include "boost/thread.hpp"

 #include "boost/foreach.hpp"

 using namespace boost;

 using namespace std;

 boost::mutex io_mu_1;

 void time_test()

 {

     this_thread::sleep_for(chrono::seconds());

     this_thread::sleep_until(chrono::system_clock::now() + chrono::seconds());

 }

 void to_interrupt(int& x, const string& str)

 try

 {

     for (int i=; i<; i++)

     {

         boost::mutex::scoped_lock(io_mu_1);

         cout << str << ++x << std::endl;

         //this_thread::sleep_for(chrono::seconds(1));

         {

             //自动中断点

         }

         this_thread::interruption_point();

     }

 }

 catch(...)

 {

     cout << "thread_interrupted" << std::endl;

 };

 void thread_test()

 {

     int x = ;

     boost::thread t(to_interrupt, boost::ref(x), "hello");

     this_thread::sleep_for(chrono::seconds());

     t.interrupt();

     assert(t.interruption_requested());

     t.join();

 }

 //测试条件变量

 class buffer

 {

 public:

     buffer(int n) : un_read(),capacity(n)

     {

     }

     void put(int x)

     {

         {

             boost::mutex::scoped_lock lock(mu);

             while (if_full())

             {

                 {

                     //boost::mutex::scoped_lock lock2(io_mu_1);

                     cout<< "full waiting\n";

                 }

                 cond_put.wait(mu);

             }

         }

         stk.push(x);

         ++un_read;

         cond_get.notify_one();

     }

     void get(int* x)

     {

         {

             boost::mutex::scoped_lock lock(mu);

             while (is_empty())

             {

                 {

                     //boost::mutex::scoped_lock lock2(io_mu_1);

                     cout<< "empty waiting\n";

                 }

                 cond_get.wait(mu);

             }

         }

         --un_read;

         *x = stk.top();

         stk.pop();

         cond_put.notify_one();

     }

 private:

     boost::mutex mu;

     boost::condition_variable_any cond_put;

     boost::condition_variable_any cond_get;

     std::stack<int> stk;

     int un_read,capacity;

     bool if_full()

     {

         return un_read == capacity;

     }

     bool is_empty()

     {

         return un_read == ;

     }

 }    buf();

 void producer(int n)

 {

     for (int i=; i< n; i++)

     {

         {

             //boost::mutex::scoped_lock lock(io_mu_1);

             cout << "put " << i << std::endl;

         }

         buf.put(i);

     }

 }

 void consumer(int n)

 {

     int x;

     for (int i=; i< n; i++)

     {

         buf.get(&x);

         //boost::mutex::scoped_lock lock(io_mu_1);

         cout << "get " << x << std::endl;

     }

 }

 void condition_test()

 {

     boost::thread t1(producer, );

     boost::thread t2(consumer, );

     boost::thread t3(consumer, );

     t1.join();

     t2.join();

     t3.join();

     boost::this_thread::sleep_for(boost::chrono::seconds());

 }

 //共享互斥量

 class rw_data

 {

 public:

     rw_data() : m_x() {}

     void write()

     {

         unique_lock<shared_mutex> ul(rw_mu);

         ++m_x;

     }

     void read(int* x)

     {

         shared_lock<shared_mutex> sl(rw_mu);

         *x = m_x;

     }

 private:

     int m_x;

     shared_mutex rw_mu;

 };

 void writer(rw_data& d)

 {

     for (int i=; i< ; i++)

     {

         this_thread::sleep_for(chrono::milliseconds());

         d.write();

     }

 }

 void reader(rw_data& d)

 {

     int x;

     for (int i=; i< ; i++)

     {

         this_thread::sleep_for(chrono::milliseconds());

         d.read(&x);

         cout << this_thread::get_id()<< " read: "<<x<<std::endl;

     }

 }

 void shared_mutex_test()

 {

     rw_data d;

     boost::thread_group pool;

     pool.create_thread(bind(writer, boost::ref(d)));

     pool.create_thread(bind(writer, boost::ref(d)));

     pool.create_thread(bind(reader, boost::ref(d)));

     pool.create_thread(bind(reader, boost::ref(d)));

     pool.create_thread(bind(reader, boost::ref(d)));

     pool.create_thread(bind(reader, boost::ref(d)));

     pool.join_all();

     this_thread::sleep_for(chrono::seconds());

 }

 //future,线程返回执行结果

 int fab(int n)

 {

     if (n ==  || n == )

     {

         return ;

     }

     return fab(n-) + fab(n-);

 }

 void future_test()

 {

     //单个future

     boost::packaged_task<int> pt(bind(fab, ));

     boost::BOOST_THREAD_FUTURE<int> f = pt.get_future();

     boost::thread(boost::move(pt));

     f.wait();

     cout << f.get() << endl;

     this_thread::sleep_for(chrono::seconds());

     //多个future协调，wait for all/any

     typedef boost::packaged_task<int> pti_t;

     typedef boost::BOOST_THREAD_FUTURE<int> fi_t;

     boost::array<pti_t, > ap;

     boost::array<fi_t, > af;

     for (int i = ; i<;i++)

     {

         ap[i] = pti_t(bind(fab, i+ ));

         af[i] = ap[i].get_future();

         boost::thread(boost::move(ap[i]));

     }

     boost::wait_for_all(af.begin(), af.end());

     BOOST_FOREACH(fi_t& f, af)

     {

         cout << f.get() << endl;

     }

     for (int i = ; i<;i++)

     {

         boost::thread(boost::move(ap[i]));

     }

     boost::wait_for_any(af.begin(), af.end());

     BOOST_FOREACH(fi_t& f, af)

     {

         if (f.is_ready() && f.has_value())

         {

             cout << f.get() << endl;

         }

     }

     this_thread::sleep_for(chrono::seconds());

 }

 //线程本地存储

 boost::thread_specific_ptr<int> pi;        //本地线程存储一个int

 void printing()

 {

     pi.reset(new int());

     ++(*pi);

     cout << this_thread::get_id() << " thread, value = " << *pi << endl;

 }

 void tls_test()

 {

     (boost::thread(bind(printing)));

     (boost::thread(bind(printing)));

     this_thread::sleep_for(chrono::seconds());

 }

 #pragma once

 #include <vector>

 #include "boost/asio.hpp"

 #include "boost/date_time/posix_time/posix_time.hpp"

 #include "boost/smart_ptr.hpp"

 using namespace boost;

 using namespace boost::asio;

 using namespace std;

 boost::asio::io_service g_ios;    //所有的asio都要有个ios

 //同步定时器

 void deadlime_timer_sync_test()

 {

     boost::asio::deadline_timer t(g_ios, posix_time::seconds());

     cout << t.expires_at() << endl;        //终止绝对时间

     t.wait();

 }

 //异步定时器

 //异步定时器回调标准格式

 void print(system::error_code x)

 {

     cout << "deadline time\n";

 }

 void deadlime_timer_async_test()

 {

     boost::asio::deadline_timer t(g_ios, posix_time::seconds());

     cout << t.expires_at() << endl;        //终止绝对时间

     t.async_wait(print);

     cout << "deadline time\n";

     g_ios.run();

 }

 //tcp

 void tcp_address_test()

 {

     boost::asio::ip::address addr;

     //addr = addr.from_string("ab.12.23.34");

     //assert(addr.is_v6());

     addr = addr.from_string("127.0.0.1");

     assert(addr.is_v4());

     cout << addr.to_string() << endl;

     ip::tcp::endpoint ep(addr, );

     assert(ep.address() == addr);

     assert(ep.port() == );

 }

 //服务端

 void server_test()

 {

     ip::tcp::acceptor acceptor(g_ios,

         ip::tcp::endpoint(ip::tcp::v4(), ));

     while ()

     {

         ip::tcp::socket sock(g_ios);

         acceptor.accept(sock);

         cout << "recv client: " << sock.remote_endpoint().address() << endl;

         sock.write_some(boost::asio::buffer(std::string("hello")));        //发送数据

     }

 }

 //异步

 typedef boost::shared_ptr<ip::tcp::socket> sock_ptr;

 class server

 {

 public:

     server() : acceptor(g_ios,

         ip::tcp::endpoint(ip::tcp::v4(), ))

     {

         start();

     }

     void start()

     {

         sock_ptr sock(new ip::tcp::socket(g_ios));

         acceptor.async_accept(*sock,

             bind(&server::accept_handler, this, asio::placeholders::error, sock));

     }

     void accept_handler(const system::error_code& ec, sock_ptr sock)

     {

         if (ec)

         {

             return;

         }

         cout << sock->remote_endpoint().address() << endl;

         sock->async_write_some(boost::asio::buffer(std::string("hello")),

             bind(&server::write_handler, this, asio::placeholders::error));

         start();

     }

     void write_handler(const system::error_code& ec)

     {

         cout << "send msg ok\n";

     }

 private:

     ip::tcp::acceptor acceptor;

 };

 void async_server_test()

 {

     server ser;

     g_ios.run();

 }

 void DNS_test()

 {

     ip::tcp::socket sock(g_ios);

     ip::tcp::resolver rlv(sock.get_io_service());

     ip::tcp::resolver::query qry("www.baidu.com", lexical_cast<std::string>());

     ip::tcp::resolver::iterator iter = rlv.resolve(qry);

     ip::tcp::resolver::iterator end;

     system::error_code ec = error::host_not_found;

     for ( ; ec && iter != end; ++iter)

     {

         sock.close();

         sock.connect(*iter, ec);

     }

     if ( ec )

     {

         cout << "can't connect\n";

     }

 }

 #pragma once

 #include <vector>

 #include "boost/thread.hpp"

 #include "boost/asio.hpp"

 #include "boost/date_time/posix_time/posix_time.hpp"

 using namespace boost;

 using namespace boost::asio;

 using namespace std;

 boost::asio::io_service g_ios;    //所有的asio都要有个ios

 //客户端

 void client_test()

 {

     while ()

     {

         ip::tcp::socket sock(g_ios);

         ip::tcp::endpoint ep(ip::address::from_string("127.0.0.1"), );

         sock.connect(ep);

         std::string str;

         str.resize(, );

         sock.read_some(buffer(str));

         cout << "receive from " << sock.remote_endpoint().address() << endl;

         cout << "content : " << str << endl;

         sock.close();

         boost::this_thread::sleep_for(boost::chrono::seconds());

     }

 }

 //异步通信客户端

 typedef boost::shared_ptr<ip::tcp::socket> sock_ptr;

 typedef boost::shared_ptr<std::string> str_ptr;

 class client

 {

 public:

     client() : ep(ip::address::from_string("127.0.0.1"), )

     {

         start();

     }

     void start()

     {

         sock_ptr sock(new ip::tcp::socket(g_ios));

         sock->async_connect(ep,

             bind(&client::connect_handler, this, asio::placeholders::error, sock));

     }

     void connect_handler(const system::error_code& ec,

         sock_ptr sock)

     {

         if (ec)

         {

             return;

         }

         cout << "sock connect " << sock->remote_endpoint().address() << endl;

         str_ptr pstr(new std::string(,));

         sock->async_read_some(asio::buffer(*pstr),

             bind(&client::read_hander, this, asio::placeholders::error, pstr));

         start();

     }

     virtual void read_hander(const system::error_code& ec,

         shared_ptr<std::string> str)

     {

         cout <<"recv msg: " <<str << endl;

     }

 protected:

     ip::tcp::endpoint ep;

 };

 class client11 : public client

 {

     virtual void read_hander(const system::error_code& ec,

         shared_ptr<std::string> str)

     {

         cout <<"child recv msg: " <<str << endl;

     }

 };

 void async_client_test()

 {

     client11 cli;

     g_ios.run();

 }