POCO c++ 使用例子

.定时器
  #include "Poco/Timer.h"
    #include "Poco/Thread.h"
    using Poco::Timer;
    using Poco::TimerCallback;  

    class TimerExample
    {
        public:
        void onTimer(Poco::Timer& timer)
        {
            std::cout << "onTimer called." << std::endl;
        }
    };  

    int main(int argc, char** argv)
    {
        TimerExample te;
        Timer timer(, ); // fire after 250ms, repeat every 500ms
        timer.start(TimerCallback<TimerExample>(te, &TimerExample::onTimer));
        Thread::sleep();
        timer.stop();
        return ;
    }  

2.管道
    #include "Poco/Process.h"
    #include "Poco/PipeStream.h"
    #include "Poco/StreamCopier.h"
    #include <fstream>
    using Poco::Process;
    using Poco::ProcessHandle;
    int main(int argc, char** argv)
    {
        std::string cmd("/bin/ps");
        std::vector<std::string> args;
        args.push_back("-ax");
        Poco::Pipe outPipe;
        ProcessHandle ph = Process::launch(cmd, args, 0, &outPipe, 0);
        Poco::PipeInputStream istr(outPipe);
        std::ofstream ostr("processes.txt");
        Poco::StreamCopier::copyStream(istr, ostr);
        return 0;
    }

.poco 默认线程池
#include "stdafx.h"
#include "Poco/ThreadPool.h"
#include "Poco/Runnable.h"
#include <iostream>
class HelloRunnable: public Poco::Runnable
{
    virtual void run()
    {
        std::cout << "Hello, bingzhe" << std::endl;
    }
};
int main(int argc, char** argv)
{
    HelloRunnable runnable;
    Poco::ThreadPool::defaultPool().start(runnable);
    Poco::ThreadPool::defaultPool().joinAll();
    return ;
}

.内存池
    #include "Poco/MemoryPool.h"
    #include <string>
    #include <iostream>
    using Poco::MemoryPool;
    int main(int argc, char** argv)
    {
        MemoryPool pool(); // unlimited number of 1024 byte blocks
        // MemoryPool pool(1024, 4, 16); // at most 16 blocks; 4 preallocated
        char* buffer = reinterpret_cast<char*>(pool.get());
        std::cin.read(buffer, pool.blockSize());
        std::streamsize n = std::cin.gcount();
        std::string s(buffer, n);
        pool.release(buffer);
        std::cout << s << std::endl;
        return ;
    }  

.任务
  #include "Poco/Task.h"
    #include "Poco/TaskManager.h"
    #include "Poco/TaskNotification.h"
    #include "Poco/Observer.h"  

    using Poco::Observer;
    class SampleTask: public Poco::Task
    {
    public:
        SampleTask(const std::string& name): Task(name)
        {}  

        void runTask()
        {
            for (int i = ; i < ; ++i)
            {
                setProgress(float(i)/); // report progress
                if (sleep())
                    break;
            }
        }
    };  

    class ProgressHandler
    {
    public:
        void onProgress(Poco::TaskProgressNotification* pNf)
        {
            std::cout << pNf->task()->name()
                << " progress: " << pNf->progress() << std::endl;
            pNf->release();
        }
        void onFinished(Poco::TaskFinishedNotification* pNf)
        {
            std::cout << pNf->task()->name() << " finished." << std::endl;
            pNf->release();
        }
    };  

    int main(int argc, char** argv)
    {
        Poco::TaskManager tm;
        ProgressHandler pm;
        tm.addObserver(
            Observer<ProgressHandler, Poco::TaskProgressNotification>
            (pm, &ProgressHandler::onProgress)
            );
        tm.addObserver(
            Observer<ProgressHandler, Poco::TaskFinishedNotification>
            (pm, &ProgressHandler::onFinished)
            );
        tm.start(new SampleTask("Task 1")); // tm takes ownership
        tm.start(new SampleTask("Task 2"));
        tm.joinAll();
        return ;
    }  

.通知
#include "stdafx.h"
    #include "Poco/NotificationCenter.h"
    #include "Poco/Notification.h"
    #include "Poco/Observer.h"
    #include "Poco/NObserver.h"
    #include "Poco/AutoPtr.h"
    #include <iostream>
    using Poco::NotificationCenter;
    using Poco::Notification;
    using Poco::Observer;
    using Poco::NObserver;
    using Poco::AutoPtr;
    class BaseNotification: public Notification
    {
    public: void dosome(){
            printf("fuck!");
        }
    };
    class SubNotification: public BaseNotification
    {  

    };  

    class Target
    {
    public:
        void handleBase(BaseNotification* pNf)
        {
            std::cout << "handleBase: " << pNf->name() << std::endl;
            pNf->dosome();
            pNf->release(); // we got ownership, so we must release
        }
        void handleSub(const AutoPtr<SubNotification>& pNf)
        {
            std::cout << "handleSub: " << pNf->name() << std::endl;
        }
    };  

    int main(int argc, char** argv)
    {
        NotificationCenter nc;
        Target target;
        nc.addObserver(
            Observer<Target, BaseNotification>(target, &Target::handleBase)
            );
        nc.addObserver(
            NObserver<Target, SubNotification>(target, &Target::handleSub)
            );
        nc.postNotification(new BaseNotification);
        nc.postNotification(new SubNotification);
        nc.removeObserver(
            Observer<Target, BaseNotification>(target, &Target::handleBase)
            );
        nc.removeObserver(
            NObserver<Target, SubNotification>(target, &Target::handleSub)
            );
        return ;
    }  

.线程
    #include "Poco/Thread.h"
    #include "Poco/Runnable.h"
    #include <iostream>
    class HelloRunnable: public Poco::Runnable
    {
           virtual void run()
           {
                std::cout << "Hello, bingzhe!" << std::endl;
           }
    };
    int main(int argc, char** argv)
    {
           HelloRunnable runnable;
           Poco::Thread thread;
           thread.start(runnable);
           thread.join();
           return ;
    }  

.线程对象
    #include "Poco/Activity.h"
    #include "Poco/Thread.h"
    #include <iostream>
    using Poco::Thread;
    class ActivityExample
    {
    public:
          ActivityExample(): _activity(this,
             &ActivityExample::runActivity)
          {}
          void start()
          {
               _activity.start();
          }
          void stop()
          {
               _activity.stop(); // request stop
               _activity.wait(); // wait until activity actually stops
          }
    protected:
          void runActivity()
         {
              while (!_activity.isStopped())
             {
                  std::cout << "bingzhe running." << std::endl;
                  Thread::sleep();
             }
          }
    private:
          Poco::Activity<ActivityExample> _activity;
    };  

    int main(int argc, char** argv)
    {
          ActivityExample example;
          example.start();
          Thread::sleep();
          example.stop();
          return ;
    }  

.异步通知

#include "stdafx.h"
      #include "Poco/Notification.h"
    #include "Poco/NotificationQueue.h"
    #include "Poco/ThreadPool.h"
    #include "Poco/Runnable.h"
    #include "Poco/AutoPtr.h"
    using Poco::Notification;
    using Poco::NotificationQueue;
    using Poco::ThreadPool;
    using Poco::Runnable;
    using Poco::AutoPtr;
    class WorkNotification: public Notification
    {
    public:
        WorkNotification(int data): _data(data) {}
        int data() const
        {
            return _data;
        }
    private:
        int _data;
    };  

    class Worker: public Runnable
    {
    public:
        Worker(NotificationQueue& queue): _queue(queue) {}
        void run()
        {
            AutoPtr<Notification> pNf(_queue.waitDequeueNotification());
            while (pNf)
            {
                WorkNotification* pWorkNf =
                    dynamic_cast<WorkNotification*>(pNf.get());
                if (pWorkNf)
                {
                    printf("hi!bingzhe");
                //    Sleep(100);
                }
                pNf = _queue.waitDequeueNotification();
            }
        }
    private:
        NotificationQueue& _queue;
    };  

    int main(int argc, char** argv)
    {
        NotificationQueue queue;
        Worker worker1(queue); // create worker threads
        Worker worker2(queue);
        ThreadPool::defaultPool().start(worker1); // start workers
        ThreadPool::defaultPool().start(worker2);
        // create some work
        for (int i = ; i < ; ++i)
        {
            queue.enqueueNotification(new WorkNotification(i));
        }
        while (!queue.empty()) // wait until all work is done
            Poco::Thread::sleep();
        queue.wakeUpAll(); // tell workers they're done
        ThreadPool::defaultPool().joinAll();
        return ;
    }