├── .dep.inc
├── CommServer.cpp
├── CommServer.h
├── Epoll.cpp
├── Epoll.h
├── Lock.cpp
├── Lock.h
├── Makefile
├── MemPool.cpp
├── MemPool.h
├── Parser.cpp
├── Parser.h
├── README.md
├── Semaphore.cpp
├── Semaphore.h
├── Singleton.h
├── Sock.cpp
├── Sock.h
├── TcpEpollClient.cpp
├── TcpEpollClient.h
├── TcpEpollServer.cpp
├── TcpEpollServer.h
├── TcpSock.cpp
├── TcpSock.h
├── Thread.cpp
├── Thread.h
├── ThreadLoop.cpp
├── ThreadLoop.h
├── ThreadPool.cpp
├── ThreadPool.h
├── Time.cpp
├── Time.h
├── TimeSpan.cpp
├── TimeSpan.h
├── build
    └── Debug
    │   └── MinGW-Windows
    │       ├── Lock.o
    │       └── Lock.o.d
├── nbproject
    ├── Makefile-Debug.mk
    ├── Makefile-Release.mk
    ├── Makefile-impl.mk
    ├── Makefile-variables.mk
    ├── Package-Debug.bash
    ├── Package-Release.bash
    ├── configurations.xml
    └── project.xml
├── readme.txt
├── tests
    ├── BoostMemPoolTest.cpp
    ├── TestEpoll.cpp
    ├── TestTcpEpollClient.cpp
    ├── TestThreadPoolandMemPoolself.cpp
    ├── defaultMemTest.cpp
    ├── newcunittest.c
    ├── newsimpletest.cpp
    ├── newsimpletest3.cpp
    ├── newsimpletest4.cpp
    └── newsimpletest5.cpp
└── 测试.md


/.dep.inc:
--------------------------------------------------------------------------------
1 | # This code depends on make tool being used
2 | DEPFILES=$(wildcard $(addsuffix .d, ${OBJECTFILES}))
3 | ifneq (${DEPFILES},)
4 | include ${DEPFILES}
5 | endif
6 | 


--------------------------------------------------------------------------------
/CommServer.cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | #include "CommServer.h"
 3 | 
 4 | namespace CommLib {
 5 | 
 6 |     CommSockImp::CommSockImp(int sock, boost::shared_ptr<MemPool> pMemPool
 7 |             , TcpEpollServerImp* pEServ,
 8 |             int timeOut
 9 |             )
10 |     : TcpEpollSockImp(sock, pEServ),
11 |     TimeOut_(timeOut),
12 |     pMemPool_(pMemPool) {
13 |         LastRecvTime_ = Time::GetCurrentTime();
14 |     }
15 | 
16 |     void CommSockImp::SetLastRecvTime() {
17 |         LastRecvTime_ = Time::GetCurrentTime();
18 |     };
19 | 
20 |     bool CommSockImp::CheckValid() {
21 |         Time t = Time::GetCurrentTime();
22 |         if (t - LastRecvTime_ > TimeOut_) {
23 |             //超时
24 |             printf("超时\r\n");
25 |             Close();
26 |             return false;
27 |         }
28 | 
29 |         return true;
30 |     }
31 | 
32 |     int CommSockImp::OnRecv() {
33 |         SetLastRecvTime();
34 |         AllocPack* pack = pMemPool_->Alloc(1024);
35 |         if (pack) {
36 |             int len = Recv((void*) pack->getbuffer(), pack->getsize());
37 | 
38 |             if (len > 0) {
39 |                 pack->SetLength(len);
40 |                 OnRecvPack(pack);
41 |             }
42 |             pack->release();
43 | 
44 |             return len;
45 |         }
46 |         return -1;
47 |     }
48 | 
49 | }
50 | 


--------------------------------------------------------------------------------
/CommServer.h:
--------------------------------------------------------------------------------
 1 | /* 
 2 |  * File:   CommonServer.h
 3 |  * Author: gwm <wenmao@eastmoney.com>
 4 |  *
 5 |  * Created on 2014年4月4日, 上午9:55
 6 |  */
 7 | 
 8 | #ifndef COMMONSERVER_H
 9 | #define	COMMONSERVER_H
10 | 
11 | #include "TcpEpollServer.h"
12 | 
13 | namespace CommLib {
14 | 
15 |     template<class ClientType>
16 |     class CommonServer : public TcpEpollServerImp {
17 |     public:
18 | 
19 |         CommonServer(
20 |                 boost::shared_ptr<Epoll> epoll,
21 |                 boost::shared_ptr<MemPool> mempool)
22 |         : TcpEpollServerImp(epoll, "CommonServer", "check", 5), mempool_(mempool) {
23 |         }
24 | 
25 |         typedef std::list<boost::shared_ptr<TcpEpollSockImp> >::iterator pClientList;
26 | 
27 |     private:
28 | 
29 |         virtual boost::shared_ptr<TcpEpollSockImp> MakeNewClient(int socket) {
30 |             return boost::shared_ptr<TcpEpollSockImp>(new ClientType(socket, mempool_, this));
31 |         }
32 | 
33 |         virtual void OnAddClient(boost::shared_ptr<TcpEpollSockImp> sock) {
34 |             CAutoLock lock(lock_);
35 |             ClientList_.push_back(sock);
36 |         }
37 | 
38 |         virtual void OnClientClose(boost::shared_ptr<TcpEpollSockImp> sock) {
39 |             CAutoLock lock(lock_);
40 |             std::list<boost::shared_ptr<TcpEpollSockImp> >::iterator iter = ClientList_.begin();
41 |             for (; iter != ClientList_.end(); iter++) {
42 |                 if (sock == *iter)
43 |                     ClientList_.erase(iter);
44 |             }
45 |         };
46 | 
47 |         void Check() {
48 |             CAutoLock lock(lock_);
49 |             std::list<boost::shared_ptr<TcpEpollSockImp> >::iterator iter = ClientList_.begin();
50 |             for (; iter != ClientList_.end();) {
51 |                 if (!(*iter)->CheckValid()) {
52 |                     OnCloseClient((*iter));
53 |                     ClientList_.erase(iter++);
54 |                     continue;
55 |                 }
56 |                 iter++;
57 |             }
58 |         }
59 | 
60 |     private:
61 | 
62 |         boost::shared_ptr<MemPool> mempool_;
63 | 
64 |         CMutexLock lock_;
65 |         std::list<boost::shared_ptr<TcpEpollSockImp> > ClientList_;
66 |     };
67 | 
68 |     class CommSockImp : public TcpEpollSockImp {
69 |     public:
70 | 
71 |         CommSockImp(int sock, boost::shared_ptr<MemPool> pMemPool
72 |                 , TcpEpollServerImp* pEServ, int timeOut = 15
73 |                 );
74 | 
75 |     private:
76 |         virtual int OnRecvPack(AllocPack* pack) = 0;
77 | 
78 |         int OnRecv();
79 | 
80 |         void SetLastRecvTime();
81 | 
82 |         bool CheckValid();
83 | 
84 |     private:
85 |         boost::shared_ptr<MemPool> pMemPool_;
86 | 
87 |         Time LastRecvTime_;
88 |         TimeSpan TimeOut_;
89 |     };
90 | }
91 | #endif	/* COMMONSERVER_H */
92 | 
93 | 


--------------------------------------------------------------------------------
/Epoll.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 |  * File:   Epoll.cpp
 3 |  * Author: Administrator
 4 |  * 
 5 |  * Created on 2014年1月27日, 下午2:13
 6 |  */
 7 | 
 8 | #include "Epoll.h"
 9 | #include "Sock.h"
10 | #include <assert.h>
11 | 
12 | namespace CommLib {
13 | 
14 |     Epoll::Epoll(int size) {
15 |         assert(size <= Epoll_MaxSize);
16 |         epollsize_ = size;
17 |         pEvents_ = new struct epoll_event[epollsize_];
18 |         epoll_ = epoll_create(epollsize_);
19 |     }
20 | 
21 |     Epoll::~Epoll() {
22 |         close(epoll_);
23 |     }
24 | 
25 |     int Epoll::epollctl(EpollOp op, Sock* sock, int event) {
26 |         struct epoll_event ev;
27 |         ev.events = event;
28 |         ev.data.fd = sock->Getsock();
29 |         ev.data.ptr = sock;
30 |         return epoll_ctl(epoll_, op, sock->Getsock(), &ev);
31 |     }
32 | 
33 |     int Epoll::epollwait(struct epoll_event *events, int maxevents, int timeout) {
34 |         return epoll_wait(epoll_, events, maxevents, timeout);
35 |     }
36 | 
37 |     int Epoll::epollAdd(Sock* sock, int event) {
38 |         return epollctl(Op_ADD, sock, event);
39 |     }
40 | 
41 |     int Epoll::epollDel(Sock* sock) {
42 |         return epollctl(Op_DEL, sock, 0);
43 |     }
44 | 
45 |     int Epoll::epollMod(Sock* sock, int event) {
46 |         return epollctl(Op_MOD, sock, event);
47 |     }
48 | 
49 |     EpollSimple::EpollSimple(int size)
50 |     : Epoll(size) {
51 |     }
52 | 
53 |     EpollSimple::~EpollSimple() {
54 |     }
55 | 
56 |     bool EpollSimple::Schedule(int sec) {
57 | 
58 |         int nfds = epollwait(pEvents_, GetEpollSize(), sec);
59 |         if (-1 != nfds) {
60 |             for (int i = 0; i < nfds; i++) {
61 |                 Sock* sk = (Sock*) pEvents_[i].data.ptr;
62 |                 if (pEvents_[i].events & Epoll::EVENT_CLOSE) {
63 |                     sk->OnClose();
64 |                     this->epollDel(sk);
65 |                 } else {
66 |                     if (pEvents_[i].events & Epoll::EVENT_READ)
67 |                         sk->OnRecv();
68 | 
69 |                     if (pEvents_[i].events & Epoll::EVENT_WRITE)
70 |                         sk->OnSend();
71 |                 }
72 |             }
73 |             return true;
74 |         }
75 |         
76 |         if ( errno == EINTR )  
77 |         {
78 |            return true;  
79 |         }
80 |         
81 |         perror("EpollSimple::Schedule");
82 |         return false;
83 |     }
84 | }
85 | 


--------------------------------------------------------------------------------
/Epoll.h:
--------------------------------------------------------------------------------
 1 | /* 
 2 |  * File:   Epoll.h
 3 |  * Author: Administrator
 4 |  *
 5 |  * Created on 2014年1月27日, 下午2:13
 6 |  */
 7 | 
 8 | #ifndef EPOLL_H
 9 | #define	EPOLL_H
10 | 
11 | #include <sys/epoll.h>
12 | #include <boost/noncopyable.hpp>
13 | 
14 | #define Epoll_MaxSize 1024
15 | 
16 | namespace CommLib {
17 | 
18 |     class Sock;
19 | 
20 |     class Epoll : boost::noncopyable {
21 |     public:
22 | 
23 |         enum EpollEvent {
24 |             EVENT_READ = EPOLLIN,
25 |             EVENT_WRITE = EPOLLOUT,
26 |             EVENT_CLOSE = EPOLLHUP,
27 |             EVENT_LET = EPOLLET, //边缘触发  默认水平触发
28 |         };
29 | 
30 |         enum EpollOp {
31 |             Op_ADD = EPOLL_CTL_ADD,
32 |             Op_DEL = EPOLL_CTL_DEL,
33 |             Op_MOD = EPOLL_CTL_MOD,
34 |         };
35 | 
36 |         Epoll(int size = Epoll_MaxSize);
37 |         virtual ~Epoll();
38 | 
39 |         virtual bool Schedule(int sec) = 0;
40 |         int epollAdd(Sock* sock, int event);
41 |         int epollDel(Sock* sock);
42 |         int epollMod(Sock* sock, int event);
43 | 
44 |         virtual int epollwait(struct epoll_event *events, int maxevents, int timeout);
45 | 
46 |         int GetEpollSize()
47 |         {
48 |             return epollsize_;
49 |         }
50 |     protected:
51 |         struct epoll_event* pEvents_;
52 | 
53 |     private:
54 |         int epoll_;
55 |         int epollsize_;
56 |         int epollctl(EpollOp op, Sock* sock, int event);
57 |     };
58 | 
59 |     class EpollSimple : public Epoll {
60 |     public:
61 | 
62 |         EpollSimple(int size = Epoll_MaxSize);
63 |         ~EpollSimple();
64 |         virtual bool Schedule(int sec);
65 |     };
66 | }
67 | #endif	/* EPOOL_H */
68 | 
69 | 


--------------------------------------------------------------------------------
/Lock.cpp:
--------------------------------------------------------------------------------
  1 | #include "Lock.h"
  2 | #include <assert.h>
  3 | #include <bits/time.h>
  4 | #include <sys/time.h>
  5 | 
  6 | #define CHECK(ret) ({ __typeof__ (ret) errnum = (ret);         \
  7 |                        assert(errnum == 0); (void) errnum;})
  8 | 
  9 | namespace CommLib {
 10 | 
 11 |     CMutexLock::CMutexLock() {
 12 |         CHECK(pthread_mutex_init(&mutex_, NULL));
 13 |     }
 14 | 
 15 |     CMutexLock::~CMutexLock() {
 16 |         CHECK(pthread_mutex_destroy(&mutex_));
 17 |     }
 18 | 
 19 |     void CMutexLock::Lock() {
 20 |         CHECK(pthread_mutex_lock(&mutex_));
 21 |     }
 22 | 
 23 |     void CMutexLock::UnLock() {
 24 |         CHECK(pthread_mutex_unlock(&mutex_));
 25 |     }
 26 | 
 27 |     bool CMutexLock::TryLock() {
 28 |         return ( 0 == pthread_mutex_trylock(&mutex_));
 29 |     }
 30 | 
 31 |     CAutoLock::CAutoLock(CMutexLock& lock) : Lock_(lock) {
 32 |         Lock_.Lock();
 33 |     }
 34 | 
 35 |     CAutoLock::~CAutoLock() {
 36 |         Lock_.UnLock();
 37 |     }
 38 | 
 39 |     RwLock::RwLock() {
 40 |         CHECK(pthread_rwlock_init(&rwlock_, NULL));
 41 | 
 42 |     }
 43 | 
 44 |     RwLock::~RwLock() {
 45 |         CHECK(pthread_rwlock_destroy(&rwlock_));
 46 |     }
 47 | 
 48 |     void RwLock::RdLock() {
 49 |         CHECK(pthread_rwlock_rdlock(&rwlock_));
 50 |     }
 51 | 
 52 |     void RwLock::WrLock() {
 53 |         CHECK(pthread_rwlock_wrlock(&rwlock_));
 54 |     }
 55 | 
 56 |     void RwLock::UnLock() {
 57 |         CHECK(pthread_rwlock_unlock(&rwlock_));
 58 |     }
 59 | 
 60 |     bool RwLock::TryRdLock() {
 61 |         return ( 0 == pthread_rwlock_tryrdlock(&rwlock_));
 62 |     }
 63 | 
 64 |     bool RwLock::TryWrLock() {
 65 |         return (0 == pthread_rwlock_trywrlock(&rwlock_));
 66 |     }
 67 | 
 68 |     Condition::Condition() {
 69 |         CHECK(pthread_cond_init(&cond_, NULL));
 70 |     }
 71 | 
 72 |     Condition::~Condition() {
 73 |         CHECK(pthread_cond_destroy(&cond_));
 74 |     }
 75 | 
 76 |     void Condition::Signal() {
 77 |         CHECK(pthread_cond_signal(&cond_));
 78 |     }
 79 | 
 80 |     void Condition::Broadcast() {
 81 |         CHECK(pthread_cond_broadcast(&cond_));
 82 |     }
 83 | 
 84 |     void Condition::Wait() {
 85 |         CAutoLock al(Lock_);
 86 |         CHECK(pthread_cond_wait(&cond_, &Lock_.GetMutex()));
 87 |     }
 88 | 
 89 |     int Condition::TimeWait(int sec) {
 90 |         CAutoLock al(Lock_);
 91 | 
 92 |         timeval now;
 93 |         gettimeofday(&now, NULL);
 94 | 
 95 |         timespec spec;
 96 |         spec.tv_sec = now.tv_sec + sec;
 97 |         spec.tv_nsec = now.tv_usec * 1000;
 98 |         int iret = pthread_cond_timedwait(&cond_, &Lock_.GetMutex(), &spec);
 99 | 
100 |         return iret;
101 |     }
102 | }
103 | 


--------------------------------------------------------------------------------
/Lock.h:
--------------------------------------------------------------------------------
 1 | /* 
 2 |  * File:   Lock.h
 3 |  * Author: Administrator
 4 |  *
 5 |  * Created on 2014年1月23日, 下午5:21
 6 |  */
 7 | 
 8 | #ifndef LOCK_H
 9 | #define	LOCK_H
10 | 
11 | #include <boost/noncopyable.hpp>
12 | #include <pthread.h>
13 | 
14 | namespace CommLib {
15 |     //临界区
16 | 
17 |     class CMutexLock : boost::noncopyable {
18 |     public:
19 |         CMutexLock();
20 |         ~CMutexLock();
21 | 
22 |         void Lock();
23 |         void UnLock();
24 | 
25 |         bool TryLock();
26 | 
27 |         pthread_mutex_t& GetMutex() {
28 |             return mutex_;
29 |         }
30 | 
31 |     private:
32 |         pthread_mutex_t mutex_;
33 |     };
34 | 
35 |     //自旋锁
36 | 
37 |     class CAutoLock : boost::noncopyable {
38 |     public:
39 |         CAutoLock(CMutexLock& lock);
40 |         ~CAutoLock();
41 | 
42 |     private:
43 |         CMutexLock& Lock_;
44 |     };
45 | 
46 |     //读写锁
47 | 
48 |     class RwLock : boost::noncopyable {
49 |     public:
50 |         RwLock();
51 |         ~RwLock();
52 | 
53 |         void RdLock();
54 |         void WrLock();
55 |         void UnLock();
56 | 
57 |         bool TryRdLock();
58 |         bool TryWrLock();
59 | 
60 |     private:
61 |         pthread_rwlock_t rwlock_;
62 |     };
63 | 
64 |     //事件
65 | 
66 |     class Condition : boost::noncopyable {
67 |     public:
68 |         Condition();
69 |         ~Condition();
70 | 
71 |         void Signal();
72 |         void Broadcast();
73 |         void Wait();
74 | 
75 |         int TimeWait(int sec);
76 | 
77 |     private:
78 | 
79 |         CMutexLock Lock_;
80 |         pthread_cond_t cond_;
81 |     };
82 | }
83 | #endif	/* LOCK_H */
84 | 
85 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
  1 | #
  2 | #  There exist several targets which are by default empty and which can be 
  3 | #  used for execution of your targets. These targets are usually executed 
  4 | #  before and after some main targets. They are: 
  5 | #
  6 | #     .build-pre:              called before 'build' target
  7 | #     .build-post:             called after 'build' target
  8 | #     .clean-pre:              called before 'clean' target
  9 | #     .clean-post:             called after 'clean' target
 10 | #     .clobber-pre:            called before 'clobber' target
 11 | #     .clobber-post:           called after 'clobber' target
 12 | #     .all-pre:                called before 'all' target
 13 | #     .all-post:               called after 'all' target
 14 | #     .help-pre:               called before 'help' target
 15 | #     .help-post:              called after 'help' target
 16 | #
 17 | #  Targets beginning with '.' are not intended to be called on their own.
 18 | #
 19 | #  Main targets can be executed directly, and they are:
 20 | #  
 21 | #     build                    build a specific configuration
 22 | #     clean                    remove built files from a configuration
 23 | #     clobber                  remove all built files
 24 | #     all                      build all configurations
 25 | #     help                     print help mesage
 26 | #  
 27 | #  Targets .build-impl, .clean-impl, .clobber-impl, .all-impl, and
 28 | #  .help-impl are implemented in nbproject/makefile-impl.mk.
 29 | #
 30 | #  Available make variables:
 31 | #
 32 | #     CND_BASEDIR                base directory for relative paths
 33 | #     CND_DISTDIR                default top distribution directory (build artifacts)
 34 | #     CND_BUILDDIR               default top build directory (object files, ...)
 35 | #     CONF                       name of current configuration
 36 | #     CND_PLATFORM_${CONF}       platform name (current configuration)
 37 | #     CND_ARTIFACT_DIR_${CONF}   directory of build artifact (current configuration)
 38 | #     CND_ARTIFACT_NAME_${CONF}  name of build artifact (current configuration)
 39 | #     CND_ARTIFACT_PATH_${CONF}  path to build artifact (current configuration)
 40 | #     CND_PACKAGE_DIR_${CONF}    directory of package (current configuration)
 41 | #     CND_PACKAGE_NAME_${CONF}   name of package (current configuration)
 42 | #     CND_PACKAGE_PATH_${CONF}   path to package (current configuration)
 43 | #
 44 | # NOCDDL
 45 | 
 46 | 
 47 | # Environment 
 48 | MKDIR=mkdir
 49 | CP=cp
 50 | CCADMIN=CCadmin
 51 | 
 52 | 
 53 | # build
 54 | build: .build-post
 55 | 
 56 | .build-pre:
 57 | # Add your pre 'build' code here...
 58 | 
 59 | .build-post: .build-impl
 60 | # Add your post 'build' code here...
 61 | 
 62 | 
 63 | # clean
 64 | clean: .clean-post
 65 | 
 66 | .clean-pre:
 67 | # Add your pre 'clean' code here...
 68 | 
 69 | .clean-post: .clean-impl
 70 | # Add your post 'clean' code here...
 71 | 
 72 | 
 73 | # clobber
 74 | clobber: .clobber-post
 75 | 
 76 | .clobber-pre:
 77 | # Add your pre 'clobber' code here...
 78 | 
 79 | .clobber-post: .clobber-impl
 80 | # Add your post 'clobber' code here...
 81 | 
 82 | 
 83 | # all
 84 | all: .all-post
 85 | 
 86 | .all-pre:
 87 | # Add your pre 'all' code here...
 88 | 
 89 | .all-post: .all-impl
 90 | # Add your post 'all' code here...
 91 | 
 92 | 
 93 | # build tests
 94 | build-tests: .build-tests-post
 95 | 
 96 | .build-tests-pre:
 97 | # Add your pre 'build-tests' code here...
 98 | 
 99 | .build-tests-post: .build-tests-impl
100 | # Add your post 'build-tests' code here...
101 | 
102 | 
103 | # run tests
104 | test: .test-post
105 | 
106 | .test-pre: build-tests
107 | # Add your pre 'test' code here...
108 | 
109 | .test-post: .test-impl
110 | # Add your post 'test' code here...
111 | 
112 | 
113 | # help
114 | help: .help-post
115 | 
116 | .help-pre:
117 | # Add your pre 'help' code here...
118 | 
119 | .help-post: .help-impl
120 | # Add your post 'help' code here...
121 | 
122 | 
123 | 
124 | # include project implementation makefile
125 | include nbproject/Makefile-impl.mk
126 | 
127 | # include project make variables
128 | include nbproject/Makefile-variables.mk
129 | 


--------------------------------------------------------------------------------
/MemPool.cpp:
--------------------------------------------------------------------------------
  1 | /* 
  2 |  * File:   MemPool.cpp
  3 |  * Author: Administrator
  4 |  * 
  5 |  * Created on 2014年1月22日, 下午1:56
  6 |  */
  7 | 
  8 | #include <iostream>
  9 | #include <list>
 10 | #include <pthread.h>
 11 | #include "Lock.h"
 12 | #include "MemPool.h"
 13 | namespace CommLib {
 14 | 
 15 |     AllocPack::AllocPack(int size, AllocPackList* palloc) {
 16 |         buff_ = new char[size];
 17 |         size_ = size;
 18 |         len_ = 0;
 19 |         pAllocList_ = palloc;
 20 |     }
 21 | 
 22 |     AllocPack::~AllocPack() {
 23 |         delete buff_;
 24 |     }
 25 | 
 26 |     const char* AllocPack::getbuffer() {
 27 |         return buff_;
 28 |     }
 29 | 
 30 |     int AllocPack::getlengh() {
 31 |         return len_;
 32 |     }
 33 | 
 34 |     void AllocPack::SetLength(int len) {
 35 |         len_ = len;
 36 |     }
 37 | 
 38 |     int AllocPack::getsize() {
 39 |         return size_;
 40 |     }
 41 | 
 42 |     void AllocPack::reset() {
 43 |         len_ = 0;
 44 |     }
 45 | 
 46 |     void AllocPack::release() {
 47 |         pAllocList_->Free(this);
 48 |     }
 49 | 
 50 |     bool AllocPack::Append(char* buff, int len) {
 51 |         int len2 = len_ + len;
 52 |         if (len2 > size_)
 53 |             return false;
 54 | 
 55 |         memcpy(buff_ + len_, buff, len);
 56 |         len_ = len2;
 57 |         return 0;
 58 |     }
 59 | 
 60 |     template<typename T>
 61 |     bool AllocPack::Append(T n) {
 62 |         int len2 = len_ + sizeof (T);
 63 |         if (len2 > size_)
 64 |             return false;
 65 | 
 66 |         memcpy(buff_ + len_, &n, sizeof (T));
 67 |         len_ = len2;
 68 |         return 0;
 69 |     }
 70 | 
 71 |     AllocPackList::AllocPackList(int ind) {
 72 |         buffsize_ = (1 << (ind + MIN_SIZE)) - 1;
 73 |     }
 74 | 
 75 |     AllocPackList::~AllocPackList() {
 76 |         for (std::deque<AllocPack*>::iterator iter = PackFreeList_.begin();
 77 |                 iter != PackFreeList_.end(); iter++) {
 78 |             delete (*iter);
 79 |         }
 80 |         PackFreeList_.clear();
 81 |     }
 82 | 
 83 |     AllocPack* AllocPackList::Alloc() {
 84 |         CAutoLock al(lock_);
 85 |         AllocPack* pPack = NULL;
 86 | 
 87 |         if (!PackFreeList_.empty()) {
 88 |             pPack = PackFreeList_.front();
 89 |             PackFreeList_.pop_front();
 90 |         } else {
 91 |             pPack = new AllocPack(buffsize_, this);
 92 |         }
 93 | 
 94 |         return pPack;
 95 |     }
 96 | 
 97 |     void AllocPackList::Free(AllocPack* pPack) {
 98 |         CAutoLock al(lock_);
 99 | 
100 |         pPack->reset();
101 |         PackFreeList_.push_back(pPack);
102 |     }
103 | 
104 |     void AllocPackList::PrintfSelf(std::ostream& os) {
105 |         CAutoLock al(lock_);
106 |         os << " free:" << PackFreeList_.size() << std::endl;
107 |     }
108 | 
109 |     AllocPackList2::AllocPackList2(int ind) : AllocPackList(ind) {
110 |     }
111 | 
112 |     AllocPackList2::~AllocPackList2() {
113 |         for (std::list<AllocPack*>::iterator iter = PackUsingList_.begin();
114 |                 iter != PackUsingList_.end(); iter++) {
115 |             delete (*iter);
116 |         }
117 |         PackUsingList_.clear();
118 |     }
119 | 
120 |     AllocPack* AllocPackList2::Alloc() {
121 |         CAutoLock al(lock_);
122 |         AllocPack* pPack = NULL;
123 | 
124 |         if (!PackFreeList_.empty()) {
125 |             pPack = PackFreeList_.front();
126 |             PackFreeList_.pop_front();
127 |             PackUsingList_.push_back(pPack);
128 |         } else {
129 |             pPack = new AllocPack(buffsize_, this);
130 |             PackUsingList_.push_back(pPack);
131 |         }
132 | 
133 |         return pPack;
134 |     }
135 | 
136 |     void AllocPackList2::Free(AllocPack* pPack) {
137 |         CAutoLock al(lock_);
138 | 
139 |         pPack->reset();
140 | 
141 |         PackUsingList_.remove(pPack);
142 |         PackFreeList_.push_back(pPack);
143 |     }
144 | 
145 |     void AllocPackList2::PrintfSelf(std::ostream& os) {
146 |         CAutoLock al(lock_);
147 |         os << " using:" << PackUsingList_.size();
148 |         os << " free:" << PackFreeList_.size() << std::endl;
149 |     }
150 | 
151 |     AllocPackListSimple::AllocPackListSimple(int ind)
152 |     : AllocPackList(ind)
153 |     //    ,testpool( (1 << (ind + MIN_SIZE)) - 1 )
154 |     {
155 |     }
156 | 
157 |     AllocPackListSimple::~AllocPackListSimple() {
158 |         for (AllocPack2* pPack = PackList.RemoveHead();
159 |                 pPack != NULL; pPack = PackList.RemoveHead()) {
160 |             delete pPack;
161 |         }
162 |     }
163 | 
164 |     void AllocPackListSimple::PrintfSelf(std::ostream& os) {
165 |         CAutoLock al(lock_);
166 |         os << " free:" << PackList.size() << std::endl;
167 |     }
168 | 
169 |     AllocPack* AllocPackListSimple::Alloc() {
170 |         AllocPack* pPack = NULL;
171 |         //        {
172 |         //            CAutoLock al(lock_);
173 |         //            pPack = ( AllocPack* )testpool.malloc();
174 |         //            return pPack;
175 |         //        }
176 |         {
177 |             CAutoLock al(lock_);
178 |             pPack = PackList.RemoveHead();
179 |         }
180 | 
181 |         if (!pPack)
182 |             pPack = new AllocPack2(buffsize_, this);
183 |         return pPack;
184 |     }
185 | 
186 |     void AllocPackListSimple::Free(AllocPack* pPack) {
187 |         pPack->reset();
188 | 
189 |         CAutoLock al(lock_);
190 |         //        testpool.free((void*)pPack );
191 |         //        return;
192 |         PackList.AddTail((AllocPack2*) pPack);
193 |     }
194 | 
195 |     AllocPackListBoost::AllocPackListBoost(int ind)
196 |     : AllocPackList(ind), boostPackpool_((1 << (ind + MIN_SIZE)) - 1 + sizeof (AllocPack)) {
197 |     }
198 | 
199 |     AllocPackListBoost::~AllocPackListBoost() {
200 |     }
201 | 
202 |     void AllocPackListBoost::PrintfSelf(std::ostream& os) {
203 |         CAutoLock al(lock_);
204 |         //        os << " free:" << testpool. << std::endl;
205 |     }
206 | 
207 |     AllocPack* AllocPackListBoost::Alloc() {
208 |         AllocPack* pPack = NULL;
209 |         CAutoLock al(lock_);
210 |         pPack = (AllocPack*) boostPackpool_.malloc();
211 |         pPack->size_ = buffsize_;
212 |         pPack->len_ = 0;
213 |         pPack->pAllocList_  = this;
214 |         pPack->buff_ = ( (char*)pPack + sizeof(AllocPack) );
215 | 
216 |         return pPack;
217 |     }
218 | 
219 |     void AllocPackListBoost::Free(AllocPack* pPack) {
220 |         CAutoLock al(lock_);
221 |         boostPackpool_.free((void*) pPack);
222 |         return;
223 |     }
224 | 
225 |     MemPool::MemPool(MemPoolType type) {
226 |         VectSize_ = MAX_SIZE - MIN_SIZE + 1;
227 | 
228 |         AllocPackListVec_.resize(VectSize_);
229 | 
230 |         for (int i = 0; i < VectSize_; i++) {
231 |             if (default_Mp == type)
232 |                 AllocPackListVec_[i] = new AllocPackList(i);
233 |             else if (careusing_Mp == type)
234 |                 AllocPackListVec_[i] = new AllocPackList2(i);
235 |             else if (Boost_Mp == type)
236 |                 AllocPackListVec_[i] = new AllocPackListBoost(i);
237 |             else
238 |                 AllocPackListVec_[i] = new AllocPackListSimple(i);
239 |         }
240 |     }
241 | 
242 |     MemPool::~MemPool() {
243 | 
244 |         for (int i = 0; i < VectSize_; i++) {
245 |             delete AllocPackListVec_[i];
246 |         }
247 | 
248 |         AllocPackListVec_.clear();
249 |     }
250 | 
251 |     AllocPack* MemPool::Alloc(int size) {
252 |         AllocPack* pPack = NULL;
253 | 
254 |         int ind = hashbit(size);
255 |         if (-1 == ind)
256 |             return pPack;
257 | 
258 |         return AllocPackListVec_[ind]->Alloc();
259 |     }
260 | 
261 |     void MemPool::Free(AllocPack* pPack) {
262 |         int ind = hashbit(pPack->getsize());
263 |         if (-1 == ind)
264 |             return;
265 | 
266 |         AllocPackListVec_[ind]->Free(pPack);
267 |     }
268 | 
269 |     void MemPool::PrintfSelf(std::ostream& os) {
270 |         for (int i = 0; i < VectSize_; i++) {
271 |             os << "ind:" << i;
272 |             AllocPackListVec_[i]->PrintfSelf(os);
273 |         }
274 |     }
275 | 
276 |     int bits(int value) //how many bits
277 |     {
278 |         int x = 0;
279 |         while (value) {
280 |             value >>= 1;
281 |             x++;
282 |         }
283 |         return x;
284 |     }
285 | 
286 |     int MemPool::hashbit(int n) {
287 |         if (0 == n)
288 |             return -1;
289 | 
290 |         int nbits = bits(n);
291 | 
292 |         if (nbits <= MIN_SIZE)
293 |             return 0;
294 |         else if (nbits > MAX_SIZE)
295 |             return -1;
296 |         else
297 |             return ( nbits - MIN_SIZE);
298 |     }
299 | 
300 |     int MemPool::hash(int n) {
301 |         if (0 == n)
302 |             return -1;
303 | 
304 |         if (n > AllocPackListVec_[VectSize_ - 1]->Size()) {
305 |             return -1;
306 |         }
307 | 
308 |         int i = 0;
309 |         for (; i < VectSize_; i++) {
310 |             if (n > AllocPackListVec_[i]->Size()) {
311 |             } else
312 |                 break;
313 |         }
314 | 
315 |         return i;
316 |     }
317 | }
318 | 


--------------------------------------------------------------------------------
/MemPool.h:
--------------------------------------------------------------------------------
  1 | /* 
  2 |  * File:   MemPool.h
  3 |  * Author: Administrator
  4 |  *
  5 |  * Created on 2014年1月22日, 下午1:56
  6 |  */
  7 | 
  8 | #ifndef MEMPOOL_H
  9 | #define	MEMPOOL_H
 10 | 
 11 | #include <math.h>
 12 | #include <vector>
 13 | #include <pthread.h>
 14 | #include <iostream>
 15 | #include <list>
 16 | #include <deque>
 17 | 
 18 | #include <boost/pool/pool.hpp>
 19 | #include <boost/pool/poolfwd.hpp>
 20 | #include <boost/pool/singleton_pool.hpp>
 21 | 
 22 | #include "Lock.h"
 23 | 
 24 | namespace CommLib {
 25 | 
 26 |     template<typename T>
 27 |     class SimpleList {
 28 |     public:
 29 | 
 30 |         SimpleList() {
 31 |             head_ = NULL;
 32 |             tail_ = NULL;
 33 |             size_ = 0;
 34 |         }
 35 | 
 36 |         ~SimpleList() {
 37 |         }
 38 | 
 39 |         void AddTail(T* node) {
 40 |             if (tail_) {
 41 |                 tail_->next_ = node;
 42 |                 tail_ = node;
 43 |             } else
 44 |                 head_ = tail_ = node;
 45 | 
 46 |             size_++;
 47 |         }
 48 | 
 49 |         T* RemoveHead() {
 50 |             T* temp = head_;
 51 |             if (temp) {
 52 |                 head_ = temp->next_;
 53 |                 size_--;
 54 |                 if (0 == size_) {
 55 |                     tail_ = NULL;
 56 |                 }
 57 |             }
 58 | 
 59 |             return temp;
 60 |         }
 61 | 
 62 |         int size() {
 63 |             return size_;
 64 |         }
 65 |     private:
 66 |         T* head_;
 67 |         T* tail_;
 68 |         int size_;
 69 |     };
 70 | 
 71 |     class AllocPackList;
 72 | 
 73 |     class AllocPack : boost::noncopyable {
 74 |     public:
 75 |         const char* getbuffer();
 76 | 
 77 |         int getlengh();
 78 |         int getsize();
 79 | 
 80 |         virtual void reset();
 81 |         void release();
 82 | 
 83 |         void SetLength(int len);
 84 |     protected:
 85 |         friend class AllocPackList;
 86 |         friend class AllocPackList2;
 87 |         friend class AllocPackListBoost;
 88 | 
 89 |         AllocPackList* pAllocList_;
 90 |         AllocPack(int size, AllocPackList* palloc);
 91 |         ~AllocPack();
 92 | 
 93 |     protected:
 94 |         int len_;
 95 |         char *buff_;
 96 |         int size_;
 97 | 
 98 |         bool Append(char* buff, int len);
 99 | 
100 |         template<typename T>
101 |         bool Append(T n);
102 |     };
103 | 
104 |     //include the ptr point to the next
105 | 
106 |     class AllocPack2 : public AllocPack {
107 |     protected:
108 |         AllocPack2* next_;
109 |         friend class SimpleList<AllocPack2>;
110 |         friend class AllocPackListSimple;
111 | 
112 |     protected:
113 | 
114 |         virtual void reset() {
115 |             next_ = NULL;
116 |             AllocPack::reset();
117 |         }
118 | 
119 |         AllocPack2(int size, AllocPackList* palloc)
120 |         : AllocPack(size, palloc) {
121 |             next_ = NULL;
122 |         }
123 |     };
124 | 
125 |     //
126 |     // Min Size:7 Bytes
127 | #define MIN_SIZE 3
128 |     //
129 |     // Max Size:32M -1
130 | #define MAX_SIZE 25
131 | 
132 |     class MemPool;
133 | 
134 |     class AllocPackList : boost::noncopyable {
135 |     public:
136 |         AllocPackList(int ind);
137 |         virtual ~AllocPackList();
138 | 
139 |         virtual AllocPack* Alloc();
140 |         virtual void Free(AllocPack* pPack);
141 |         virtual void PrintfSelf(std::ostream& os);
142 | 
143 |         int Size() {
144 |             return buffsize_;
145 |         }
146 | 
147 |     protected:
148 |         int buffsize_;
149 | 
150 |     protected:
151 |         CMutexLock lock_;
152 |         std::deque<AllocPack*> PackFreeList_;
153 |     };
154 | 
155 |     //care the mem using
156 | 
157 |     class AllocPackList2 : public AllocPackList {
158 |     public:
159 |         AllocPackList2(int ind);
160 |         virtual ~AllocPackList2();
161 | 
162 |         virtual AllocPack* Alloc();
163 |         virtual void Free(AllocPack* pPack);
164 |         virtual void PrintfSelf(std::ostream& os);
165 |     private:
166 |         std::list<AllocPack*> PackUsingList_;
167 | 
168 | 
169 |     };
170 | 
171 |     //using SimpleList Writen by self
172 | 
173 |     class AllocPackListSimple : public AllocPackList {
174 |     public:
175 |         AllocPackListSimple(int ind);
176 |         virtual ~AllocPackListSimple();
177 | 
178 |         virtual void PrintfSelf(std::ostream& os);
179 | 
180 |         virtual AllocPack* Alloc();
181 | 
182 |         virtual void Free(AllocPack* pPack);
183 |     private:
184 |         SimpleList<AllocPack2> PackList;
185 |         //        boost::pool<boost::default_user_allocator_new_delete> testpool;
186 |     };
187 | 
188 |     //using boost memPool
189 | 
190 |     class AllocPackListBoost : public AllocPackList {
191 |     public:
192 |         AllocPackListBoost(int ind);
193 |         virtual ~AllocPackListBoost();
194 | 
195 |         virtual void PrintfSelf(std::ostream& os);
196 | 
197 |         virtual AllocPack* Alloc();
198 | 
199 |         virtual void Free(AllocPack* pPack);
200 |     private:
201 |         boost::pool<boost::default_user_allocator_new_delete> boostPackpool_;
202 |     };
203 | 
204 |     class MemPool : boost::noncopyable {
205 |     public:
206 | 
207 |         enum MemPoolType {
208 |             default_Mp, //using deque
209 |             careusing_Mp, //care memory using
210 |             SimpleList_Mp, //using the list self
211 |             Boost_Mp,   // using boost mempool to hash MemPool
212 |         };
213 | 
214 |         static MemPool* defaultMp() {
215 |             static MemPool* defmp = new MemPool();
216 |             return defmp;
217 |         }
218 | 
219 |         //default 0,no care the mem using,else care
220 |         MemPool(MemPoolType type = default_Mp);
221 |         virtual ~MemPool();
222 | 
223 |         AllocPack* Alloc(int size);
224 |         void Free(AllocPack* pPack);
225 | 
226 |         void PrintfSelf(std::ostream& os);
227 |     private:
228 |         std::vector<AllocPackList*> AllocPackListVec_;
229 |         int VectSize_;
230 | 
231 |     private:
232 | 
233 |         int hash(int n);
234 |         int hashbit(int n);
235 |     };
236 | }
237 | #endif	/* MEMPOOL_H */
238 | 
239 | 


--------------------------------------------------------------------------------
/Parser.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 |  * File:   Parser.cpp
 3 |  * Author: Administrator
 4 |  * 
 5 |  * Created on 2014年1月27日, 下午4:12
 6 |  */
 7 | 
 8 | #include "Parser.h"
 9 | namespace CommLib {
10 | 
11 |     Parser::Parser() {
12 |     }
13 | 
14 |     Parser::Parser(const Parser& orig) {
15 |     }
16 | 
17 |     Parser::~Parser() {
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/Parser.h:
--------------------------------------------------------------------------------
 1 | /* 
 2 |  * File:   Parser.h
 3 |  * Author: Administrator
 4 |  *
 5 |  * Created on 2014年1月27日, 下午4:12
 6 |  */
 7 | 
 8 | #ifndef PARSER_H
 9 | #define	PARSER_H
10 | namespace CommLib {
11 | 
12 |     class Parser {
13 |     public:
14 |         Parser();
15 |         Parser(const Parser& orig);
16 |         virtual ~Parser();
17 |     private:
18 | 
19 |     };
20 | 
21 |     class ProtocolParser : public Parser {
22 |     public:
23 |         virtual bool parse(char* buff, int len) = 0;
24 |     };
25 | }
26 | #endif	/* PARSER_H */
27 | 
28 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | CommLib
2 | =======
3 | 
4 | linux常用库,使用boost和标准库编写的常用库,包含线程池、内存池、通信、日志、时间处理、定时器
5 | 
6 | 注:本库实现的内存池为不定长内存池,包含了子内存池数组，采用了hash算法，按位进行hash运算，
7 | hash到各个子内存池中，以满足动态内存易变化的需求，以提供给网络库使用
8 | 


--------------------------------------------------------------------------------
/Semaphore.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 |  * File:   Semaphore.cpp
 3 |  * Author: Administrator
 4 |  * 
 5 |  * Created on 2014年1月26日, 下午3:21
 6 |  */
 7 | 
 8 | #include "Semaphore.h"
 9 | namespace CommLib {
10 | 
11 |     Semaphore::Semaphore(int pshared, int value) {
12 |         sem_init(&semt_, pshared, value);
13 |     }
14 | 
15 |     Semaphore::~Semaphore() {
16 |         sem_destroy(&semt_);
17 |     }
18 | 
19 |     void Semaphore::post() {
20 |         sem_post(&semt_);
21 |     }
22 | 
23 |     void Semaphore::wait() {
24 |         sem_wait(&semt_);
25 |     }
26 | 
27 | }
28 | 
29 | 


--------------------------------------------------------------------------------
/Semaphore.h:
--------------------------------------------------------------------------------
 1 | /* 
 2 |  * File:   Semaphore.h
 3 |  * Author: Administrator
 4 |  *
 5 |  * Created on 2014年1月26日, 下午3:21
 6 |  */
 7 | 
 8 | #ifndef SEMAPHORE_H
 9 | #define	SEMAPHORE_H
10 | 
11 | #include <boost/noncopyable.hpp>
12 | #include <semaphore.h>
13 | namespace CommLib {
14 | 
15 |     class Semaphore : boost::noncopyable {
16 |     public:
17 |         Semaphore(int pshared, int value);
18 | 
19 |         virtual ~Semaphore();
20 | 
21 |         void post();
22 |         void wait();
23 | 
24 |     private:
25 |         sem_t semt_;
26 | 
27 |     };
28 | }
29 | #endif	/* SEMAPHORE_H */
30 | 
31 | 


--------------------------------------------------------------------------------
/Singleton.h:
--------------------------------------------------------------------------------
 1 | /* 
 2 |  * File:   Singleton.h
 3 |  * Author: Administrator
 4 |  *
 5 |  * Created on 2014年1月28日, 上午10:31
 6 |  */
 7 | 
 8 | #ifndef SINGLETON_H
 9 | #define	SINGLETON_H
10 | namespace CommLib {
11 | 
12 |     template <class T>
13 |     class Singleton : boost::noncopyable {
14 |     public:
15 | 
16 |         static T& instance() {
17 |             static T _instance;
18 |             return _instance;
19 |         };
20 |     protected:
21 | 
22 |         Singleton(void) {
23 |         };
24 | 
25 |         virtual ~Singleton(void) {
26 |         };
27 | 
28 |     };
29 | }
30 | #endif	/* SINGLETON_H */
31 | 
32 | 


--------------------------------------------------------------------------------
/Sock.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 |  * File:   Sock.cpp
 3 |  * Author: Administrator
 4 |  * 
 5 |  * Created on 2014年1月27日, 下午2:47
 6 |  */
 7 | 
 8 | #include <fcntl.h>
 9 | #include <sys/socket.h>
10 | 
11 | #include "Sock.h"
12 | 
13 | 
14 | namespace CommLib {
15 | 
16 |     Sock::Sock()
17 |     {
18 |     }
19 |     
20 |     Sock::Sock(int __domain, int __type, int __protocol) {
21 |         sock_ = socket(__domain, __type, __protocol);
22 |     }
23 | 
24 |     int Sock::Bind(SockAddr& addr) {
25 |         localaddr_ = addr;
26 |         return bind(sock_, (struct sockaddr*) &addr.GetAddr_in(), sizeof (addr));
27 |     }
28 | 
29 |     int Sock::Connect(SockAddr& addr) {
30 |         remoteaddr_ = addr;
31 |         return connect(sock_, (struct sockaddr*) &addr.GetAddr_in(), sizeof (addr));
32 |     }
33 | 
34 |     int Sock::Listen(int nlistens) {
35 |         return listen(sock_, nlistens);
36 |     }
37 | 
38 |     int Sock::Setnonblocking() {
39 |         int ctl = fcntl(sock_, F_GETFL);
40 |         return fcntl(sock_, F_SETFL, ctl | O_NONBLOCK);
41 |     }
42 | 
43 |     Sock::~Sock() {
44 |     }
45 | 
46 |     void Sock::Attach(int sock) {
47 |         sock_ = sock;
48 |     }
49 | 
50 |     int Sock::SetLocalAddr(SockAddr& addr) {
51 |         localaddr_ = addr;
52 |     }
53 | 
54 |     SockAddr& Sock::GetLocalAddr() {
55 |         return localaddr_;
56 |     }
57 | 
58 |     int Sock::SetRemoteAddr(SockAddr& addr) {
59 |         remoteaddr_ = addr;
60 |     }
61 | 
62 |     SockAddr& Sock::GetRemoteAddr() {
63 |         return remoteaddr_;
64 |     }
65 | 
66 |     int Sock::Getsock() {
67 |         return sock_;
68 |     }
69 | 
70 |     void Sock::Close() {
71 |         close(sock_);
72 |     }
73 | 
74 | }
75 | 
76 | 


--------------------------------------------------------------------------------
/Sock.h:
--------------------------------------------------------------------------------
 1 | /* 
 2 |  * File:   Sock.h
 3 |  * Author: Administrator
 4 |  *
 5 |  * Created on 2014年1月27日, 下午2:47
 6 |  */
 7 | 
 8 | #ifndef SOCK_H
 9 | #define	SOCK_H
10 | 
11 | #include <netinet/in.h>
12 | #include <arpa/inet.h>
13 | 
14 | #include <string>
15 | #include <boost/noncopyable.hpp>
16 | 
17 | namespace CommLib {
18 | 
19 |     class Sock;
20 | 
21 |     class SockAddr {
22 |     public:
23 |         SockAddr() {
24 |         }
25 | 
26 |         SockAddr(short sin_port, std::string addr, int sin_family) {
27 |             addr_.sin_port = htons(sin_port);
28 |             addr_.sin_family = sin_family;
29 |             addr_.sin_addr.s_addr = inet_addr(addr.c_str());
30 |         }
31 | 
32 |         SockAddr( sockaddr_in& addr )
33 |         {
34 |             addr_ = addr;
35 |         }
36 |         
37 |         sockaddr_in& GetAddr_in() {
38 |             return addr_;
39 |         }
40 |         
41 |         void SetAddr_in(sockaddr_in& addr) {
42 |             addr_ = addr;
43 |         }
44 | 
45 |     private:
46 |         struct sockaddr_in addr_;
47 |         friend class Sock;
48 |     };
49 | 
50 |     class Sock : boost::noncopyable {
51 |     public:
52 | 
53 |         enum {
54 |             IP = PF_INET,
55 |             TCP = SOCK_STREAM,
56 |             UDP = SOCK_DGRAM,
57 |         };
58 | 
59 |         Sock();
60 |         Sock(int __domain, int __type, int __protocol);
61 | 
62 |         void Attach(int sock);
63 |         int Bind(SockAddr& addr);
64 |         int Connect(SockAddr& addr);
65 |         int Listen(int nlistens);
66 | 
67 |         int SetLocalAddr(SockAddr& addr);
68 |         SockAddr& GetLocalAddr();
69 |         int SetRemoteAddr(SockAddr& addr);
70 |         SockAddr& GetRemoteAddr();
71 |         
72 |         int Setnonblocking();
73 |         int Getsock();
74 |         void Close();
75 | 
76 |         virtual int Send(void *buf, int nbytes) = 0;
77 |         virtual int Recv(void *buf, int nbytes) = 0;
78 | 
79 |         virtual int OnRecv() = 0;
80 |         virtual int OnSend() = 0;
81 |         virtual int OnClose() = 0;
82 | 
83 |         virtual ~Sock();
84 |         
85 |     private:
86 |         int sock_;
87 | 
88 |         SockAddr localaddr_;
89 |         SockAddr remoteaddr_;
90 |     };
91 | 
92 |     
93 | }
94 | #endif	/* SOCK_H */
95 | 
96 | 


--------------------------------------------------------------------------------
/TcpEpollClient.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 |  * File:   TcpEpollClient.cpp
 3 |  * Author: gwm <wenmao@eastmoney.com>
 4 |  * 
 5 |  * Created on 2014年4月15日, 下午3:02
 6 |  */
 7 | 
 8 | #include "TcpEpollClient.h"
 9 | #include "Epoll.h"
10 | #include "MemPool.h"
11 | 
12 | namespace CommLib {
13 | 
14 |     TcpEpollClientImp::TcpEpollClientImp(boost::shared_ptr<Epoll> epoll, boost::shared_ptr<MemPool> pMemPool)
15 |     : epoll_(epoll),mempool_(pMemPool) {
16 |     }
17 | 
18 |     TcpEpollClientImp::~TcpEpollClientImp() {
19 |     }
20 | 
21 |     int TcpEpollClientImp::OnConnected() {
22 |         epoll_->epollAdd(this, Epoll::EVENT_READ);
23 |     }
24 | 
25 |     int TcpEpollClientImp::OnClose() {
26 |         epoll_->epollDel(this);
27 |     }
28 | 
29 |     int TcpEpollClientImp::OnRecv() {
30 |         AllocPack* pack = mempool_->Alloc(1024);
31 |         if (pack) {
32 |             int len = Recv((void*) pack->getbuffer(), pack->getsize());
33 | 
34 |             if (len > 0) {
35 |                 pack->SetLength(len);
36 |                 OnRecvPack(pack);
37 |             }
38 |             pack->release();
39 | 
40 |             return len;
41 |         }
42 |         return -1;
43 |     };
44 | 
45 |     int TcpEpollClientImp::OnSend() {
46 |         return 1;
47 |     };
48 | 
49 | }
50 | 


--------------------------------------------------------------------------------
/TcpEpollClient.h:
--------------------------------------------------------------------------------
 1 | /* 
 2 |  * File:   TcpEpollClient.h
 3 |  * Author: gwm <wenmao@eastmoney.com>
 4 |  *
 5 |  * Created on 2014年4月15日, 下午3:02
 6 |  */
 7 | 
 8 | #ifndef TCPEPOLLCLIENT_H
 9 | #define	TCPEPOLLCLIENT_H
10 | #include <boost/shared_ptr.hpp>
11 | #include "TcpSock.h"
12 | 
13 | namespace CommLib {
14 | 
15 |     class AllocPack;
16 |     class MemPool;
17 |     class Epoll;
18 |     
19 |     class TcpEpollClientImp:public TcpClientSock {
20 |     public:
21 |         TcpEpollClientImp(boost::shared_ptr<Epoll> epoll, boost::shared_ptr<MemPool> pMemPool);
22 |         virtual ~TcpEpollClientImp();
23 | 
24 |     public:
25 |         virtual int OnRecvPack(AllocPack* pack) = 0;
26 | 
27 |     private:
28 | 
29 |         virtual int OnConnected();
30 |         virtual int OnClose();
31 |         virtual int OnRecv();
32 |         virtual int OnSend();
33 | 
34 | 
35 |         boost::shared_ptr<Epoll> epoll_;
36 |         boost::shared_ptr<MemPool> mempool_;
37 |     };
38 | }
39 | #endif	/* TCPEPOLLCLIENT_H */
40 | 
41 | 


--------------------------------------------------------------------------------
/TcpEpollServer.cpp:
--------------------------------------------------------------------------------
  1 | /* 
  2 |  * File:   TcpEpoolServer.cpp
  3 |  * Author: Administrator
  4 |  * 
  5 |  * Created on 2014年1月28日, 下午2:29
  6 |  */
  7 | 
  8 | #include "TcpEpollServer.h"
  9 | 
 10 | namespace CommLib {
 11 | 
 12 |     TcpEpollSockImp::TcpEpollSockImp(int sock
 13 |             , TcpEpollServerImp* pEServ
 14 |             )
 15 |     : TcpSock(sock)
 16 |     , pEServ_(pEServ) {
 17 | 
 18 |     }
 19 | 
 20 |     int TcpEpollSockImp::OnSend() {
 21 |         return 0;
 22 |     }
 23 | 
 24 |     int TcpEpollSockImp::OnClose() {
 25 |         Close();
 26 | 
 27 |         pEServ_->OnCloseClient(shared_from_this());
 28 |         pEServ_->OnClientClose(shared_from_this());
 29 |         return 0;
 30 |     }
 31 | 
 32 |     void CheckLoop::LoopTask() {
 33 |         pImp->Check();
 34 |     }
 35 | 
 36 |     TcpEpollServerImp::TcpEpollServerImp(
 37 |             boost::shared_ptr<Epoll> epoll,
 38 |             std::string thrname,
 39 |             std::string checklpname, int looptime)
 40 |     : epoll_(epoll), bStarted_(false),
 41 |     Thread(boost::bind(&TcpEpollServerImp::Schedule, this), thrname),
 42 |     checkloop_(checklpname, looptime) {
 43 |         checkloop_.pImp = this;
 44 |     }
 45 | 
 46 |     bool TcpEpollServerImp::Start(int nPort) {
 47 |         if (bStarted_)
 48 |             return false;
 49 |         bStarted_ = true;
 50 | 
 51 |         SockAddr addr(nPort, "0.0.0.0", Sock::IP);
 52 | 
 53 |         if (-1 == Bind(addr)) {
 54 |             perror("TcpEpollServer::Start false");
 55 |             return false;
 56 |         }
 57 | 
 58 |         if (-1 == Listen(10)) {
 59 |             perror("TcpEpollServer::Start false");
 60 |             return false;
 61 |         }
 62 | 
 63 |         assert(0 == epoll_->epollAdd(this, Epoll::EVENT_READ));
 64 |         this->Setnonblocking();
 65 | 
 66 |         StartThread();
 67 | 
 68 |         checkloop_.StartThread();
 69 |     }
 70 | 
 71 |     bool TcpEpollServerImp::Stop() {
 72 | 
 73 |         //            Epoll_->Close();
 74 |         if (!bStarted_)
 75 |             return false;
 76 |         bStarted_ = false;
 77 | 
 78 |         Join();
 79 | 
 80 |         checkloop_.StopLoop();
 81 |         checkloop_.Join();
 82 |     }
 83 | 
 84 |     bool TcpEpollServerImp::Schedule() {
 85 |         while (epoll_->Schedule(10));
 86 |         return false;
 87 |     }
 88 | 
 89 |     //         
 90 | 
 91 |     int TcpEpollServerImp::OnAccept() {
 92 |         sockaddr_in addr;
 93 |         socklen_t addrlen = sizeof (sockaddr_in);
 94 |         int socket = accept(Getsock(), (struct sockaddr *) &addr, &addrlen);
 95 |         if (socket < 0) {
 96 |             return 0;
 97 |         }
 98 | 
 99 |         boost::shared_ptr<TcpEpollSockImp> sock = MakeNewClient(socket);
100 |         SockAddr skAddr(addr);
101 | 
102 |         sock->Setnonblocking();
103 |         assert(0 == epoll_->epollAdd(sock.get(), Epoll::EVENT_READ));
104 |         sock->SetRemoteAddr(skAddr);
105 | 
106 |         OnAddClient(sock);
107 |         return 1;
108 |     }
109 | 
110 |     int TcpEpollServerImp::OnSend() {
111 |         return 1;
112 |     };
113 | 
114 |     int TcpEpollServerImp::OnClose() {
115 |         Close();
116 |         return Stop();
117 |     };
118 | 
119 |     void TcpEpollServerImp::OnCloseClient(boost::shared_ptr<TcpEpollSockImp> sock) {
120 |         epoll_->epollDel(sock.get());
121 |     }
122 | 
123 | }
124 | 


--------------------------------------------------------------------------------
/TcpEpollServer.h:
--------------------------------------------------------------------------------
  1 | /* 
  2 |  * File:   TcpEpoolServer.h
  3 |  * Author: Administrator
  4 |  *
  5 |  * Created on 2014年1月28日, 下午2:29
  6 |  */
  7 | 
  8 | #ifndef TCPEPOOLSERVER_H
  9 | #define	TCPEPOOLSERVER_H
 10 | #include <boost/noncopyable.hpp>
 11 | #include <boost/shared_ptr.hpp>
 12 | #include <boost/enable_shared_from_this.hpp>
 13 | #include <boost/bind.hpp>
 14 | 
 15 | #include "ThreadLoop.h"
 16 | #include "Thread.h"
 17 | #include "MemPool.h"
 18 | #include "Epoll.h"
 19 | #include "TcpSock.h"
 20 | #include "Time.h"
 21 | 
 22 | namespace CommLib {
 23 | 
 24 |     //    template<class ClientType>
 25 | 
 26 |     class TcpEpollServerImp;
 27 | 
 28 |     class TcpEpollSockImp : public TcpSock, public boost::enable_shared_from_this<TcpEpollSockImp> {
 29 |     public:
 30 | 
 31 |         TcpEpollSockImp(int sock
 32 |                 , TcpEpollServerImp* pEServ
 33 |                 );
 34 | 
 35 |     public:
 36 |         virtual bool CheckValid() = 0;
 37 | 
 38 |     private:
 39 |         int OnSend();
 40 |         int OnClose();
 41 | 
 42 |     private:
 43 | 
 44 |         TcpEpollServerImp* pEServ_;
 45 |     };
 46 | 
 47 |     class CheckLoop : public ThreadLoop {
 48 |     public:
 49 | 
 50 |         CheckLoop(std::string name = "", int loopTime = 3)
 51 |         : ThreadLoop(name, loopTime) {
 52 |         }
 53 | 
 54 |         virtual void LoopTask();
 55 |         TcpEpollServerImp* pImp;
 56 |     };
 57 | 
 58 |     class TcpEpollServerImp : public Thread, public TcpServImp {
 59 |     public:
 60 | 
 61 | 
 62 |         TcpEpollServerImp(
 63 |                 boost::shared_ptr<Epoll> epoll,
 64 |                 std::string thrname = "TcpEpollServerImp",
 65 |                 std::string checklpname = "", int looptime = 3);
 66 | 
 67 |         virtual ~TcpEpollServerImp() {
 68 |         }
 69 | 
 70 |     public:
 71 |         bool Start(int nPort);
 72 |         bool Stop();
 73 | 
 74 |         virtual void Check() = 0;
 75 |         
 76 |         void OnCloseClient(boost::shared_ptr<TcpEpollSockImp> sock);
 77 |         //         
 78 |     private:
 79 |         int OnAccept();
 80 |         int OnSend();
 81 |         int OnClose();
 82 | 
 83 | 
 84 |         bool Schedule();
 85 |         
 86 | 
 87 |     private:
 88 |         virtual boost::shared_ptr<TcpEpollSockImp> MakeNewClient(int socket) = 0;
 89 | 
 90 |         virtual void OnAddClient(boost::shared_ptr<TcpEpollSockImp> sock) = 0;
 91 | 
 92 |     public:
 93 |         virtual void OnClientClose(boost::shared_ptr<TcpEpollSockImp> sock) = 0;
 94 | 
 95 |     private:
 96 |         bool bStarted_;
 97 |         boost::shared_ptr<Epoll> epoll_;
 98 | 
 99 |         CheckLoop checkloop_;
100 |     };
101 | 
102 | }
103 | 
104 | #endif	/* TCPEPOOLSERVER_H */
105 | 
106 | 


--------------------------------------------------------------------------------
/TcpSock.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * File:   TcpSock.cpp
 3 |  * Author: Administrator
 4 |  *
 5 |  * Created on 2014年1月28日, 上午10:17
 6 |  */
 7 | #include <assert.h>
 8 | 
 9 | #include "TcpSock.h"
10 | #include "Epoll.h"
11 | #include "MemPool.h"
12 | #include "Parser.h"
13 | 
14 | namespace CommLib {
15 | 
16 |     TcpSock::TcpSock()
17 |     : Sock(PF_INET, SOCK_STREAM, 0) {
18 |     }
19 | 
20 |     TcpSock::TcpSock(int sock) {
21 |         this->Attach(sock);
22 |     }
23 | 
24 |     TcpSock::~TcpSock() {
25 |     }
26 | 
27 |     int TcpSock::Send(void *buf, int nbytes) {
28 |         return send(Getsock(), buf, nbytes, 0);
29 |     }
30 | 
31 |     int TcpSock::Recv(void *buf, int nbytes) {
32 |         return recv(Getsock(), buf, nbytes, 0);
33 |     }
34 | 
35 |     //    int TcpSock::OnRecv() {
36 |     //        AllocPack* pack = MemPool::defaultMp()->Alloc(1024);
37 |     //        if (pack) {
38 |     //            int len = Recv((void*) pack->getbuffer(), pack->getsize());
39 |     //
40 |     //            if (len > 0) {
41 |     //                pack->SetLength(len);
42 |     ////                pParser_->parse((char*) pack->getbuffer(), pack->getlengh());
43 |     //            }
44 |     //            pack->release();
45 |     //
46 |     //            return len;
47 |     //        }
48 |     //        return -1;
49 |     //    }
50 |     //
51 |     //    int TcpSock::RegistEpoll() {
52 |     //        return pPoll_->epollAdd(this, Epoll::EVENT_READ);
53 |     //    }
54 |     //
55 |     //    int TcpSock::UnRegistEpoll() {
56 |     //        return pPoll_->epollDel(this);
57 |     //    }
58 | 
59 |     //    int TcpSock::OnSend() {
60 |     //        return 0;
61 |     //    }
62 |     //
63 |     //    int TcpSock::OnClose() {
64 |     //  //      perror("OnClose");
65 |     ////        UnRegistEpoll();
66 |     //        Close();
67 |     //        return 1;
68 |     //    }
69 | 
70 |     int TcpServImp::OnRecv() {
71 |         return OnAccept();
72 |     }
73 | 
74 |     TcpClientSock::TcpClientSock()
75 |     : bConnected_(false) {
76 |     }
77 | 
78 |     bool TcpClientSock::InitConnect(char* szIp, int nPort) {
79 |         SockAddr addr(nPort, szIp, Sock::IP);
80 |         if (-1 == Connect(addr))
81 |             return false;
82 | 
83 |         //      assert(0 == Epoll_->epollAdd(this, Epoll::EVENT_READ));
84 |         this->Setnonblocking();
85 |         bConnected_ = true;
86 |         OnConnected();
87 |         return true;
88 |     }
89 | 
90 | }
91 | 


--------------------------------------------------------------------------------
/TcpSock.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * File:   TcpSock.h
 3 |  * Author: Administrator
 4 |  *
 5 |  * Created on 2014年1月28日, 上午10:17
 6 |  */
 7 | 
 8 | #ifndef TCPSOCK_H
 9 | #define	TCPSOCK_H
10 | 
11 | #include "Sock.h"
12 | 
13 | namespace CommLib {
14 |     //    class ProtocolParser;
15 |     //    class Epoll;
16 | 
17 |     class TcpSock : public Sock {
18 |     public:
19 | 
20 |         TcpSock();
21 | 
22 |         TcpSock(int sock);
23 | 
24 |         ~TcpSock();
25 | 
26 |     public:
27 |         virtual int Send(void *buf, int nbytes);
28 |         virtual int Recv(void *buf, int nbytes);
29 |     };
30 | 
31 |     class TcpServImp : public TcpSock {
32 |     public:
33 | 
34 |     public:
35 |         int OnRecv();
36 | 
37 |         virtual int OnAccept() = 0;
38 | 
39 | 
40 | 
41 |     };
42 | 
43 |     class TcpClientSock : public TcpSock {
44 |     public:
45 |         TcpClientSock();
46 |     public:
47 |         bool InitConnect(char* szIp, int nPort);
48 |         virtual int OnConnected() = 0;
49 |         //        virtual int OnRecv() = 0;
50 |         //        virtual int OnSend() = 0;
51 |         //        virtual int OnClose() = 0;
52 | 
53 |     private:
54 |         bool bConnected_;
55 |     };
56 | }
57 | #endif	/* TCPSOCK_H */
58 | 
59 | 


--------------------------------------------------------------------------------
/Thread.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 |  * File:   Thread.cpp
 3 |  * Author: Administrator
 4 |  * 
 5 |  * Created on 2014年1月23日, 上午10:27
 6 |  */
 7 | 
 8 | #include "Thread.h"
 9 | namespace CommLib {
10 | 
11 |     Thread::Thread( boost::function<void () > func,std::string name )
12 |     : ThrData_(name, func) {
13 |     }
14 | 
15 |     Thread::~Thread() {
16 |     }
17 | 
18 | 
19 |     void* ThreadFunc(void* arg) {
20 |         ThreadData* pThr = static_cast<ThreadData*> (arg);
21 |         pThr->func_();
22 |     }
23 | 
24 |     void Thread::StartThread() {
25 |         ThrData_.pID_ = pthread_create(&ThrData_.pHandle_, NULL, ThreadFunc, &ThrData_);
26 |     }
27 | 
28 |     void Thread::Join() {
29 |         pthread_join(ThrData_.pHandle_, NULL);
30 |     }
31 | 
32 |     int Thread::Thread_id() {
33 |         return ThrData_.pID_;
34 |     }
35 | 
36 |     std::string Thread::ThreadName() {
37 |         return ThrData_.name_;
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/Thread.h:
--------------------------------------------------------------------------------
 1 | /* 
 2 |  * File:   Thread.h
 3 |  * Author: Administrator
 4 |  *
 5 |  * Created on 2014年1月23日, 上午10:27
 6 |  */
 7 | 
 8 | #ifndef THREAD_H
 9 | #define	THREAD_H
10 | 
11 | #include <pthread.h>
12 | #include <boost/function.hpp>
13 | #include <boost/noncopyable.hpp>
14 | #include <string>
15 | 
16 | namespace CommLib {
17 |     class Thread;
18 | 
19 |     class ThreadData : boost::noncopyable {
20 |     protected:
21 | 
22 |         ThreadData(std::string name, boost::function<void () > func)
23 |         : pID_(0), pHandle_(0)
24 |         , name_(name), func_(func) {
25 |         };
26 | 
27 |         std::string name_;
28 |         pthread_t pHandle_;
29 |         int pID_;
30 |         friend class Thread;
31 | 
32 |     public:        
33 |          boost::function<void () > func_;
34 | 
35 |     };
36 | 
37 |     class Thread : boost::noncopyable {
38 |     public:
39 |         Thread( boost::function<void () > func,std::string name="");
40 |         virtual ~Thread();
41 | 
42 |         void StartThread();
43 |         void Join();
44 | 
45 |         int Thread_id();
46 |         std::string ThreadName();
47 | 
48 |     private:
49 |         ThreadData ThrData_;
50 | 
51 |     };
52 | }
53 | #endif	/* THREAD_H */
54 | 
55 | 


--------------------------------------------------------------------------------
/ThreadLoop.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 |  * File:   ThreadLoop.cpp
 3 |  * Author: Administrator
 4 |  * 
 5 |  * Created on 2014年1月27日, 上午10:09
 6 |  */
 7 | #include <boost/bind.hpp>
 8 | #include "ThreadLoop.h"
 9 | namespace CommLib {
10 | 
11 |     ThreadLoop::ThreadLoop(std::string name, int loopTime)
12 |     : Thread( boost::bind(&ThreadLoop::ThreadFunc, this),name)
13 |     , loopTime_(loopTime) {
14 |     }
15 | 
16 |     ThreadLoop::~ThreadLoop() {
17 |     }
18 | 
19 |     void ThreadLoop::ThreadFunc() {
20 |         while (ETIMEDOUT == con_.TimeWait(loopTime_)) {
21 |             LoopTask();
22 |         }
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/ThreadLoop.h:
--------------------------------------------------------------------------------
 1 | /* 
 2 |  * File:   ThreadLoop.h
 3 |  * Author: Administrator
 4 |  *
 5 |  * Created on 2014年1月27日, 上午10:09
 6 |  */
 7 | 
 8 | #ifndef THREADLOOP_H
 9 | #define	THREADLOOP_H
10 | 
11 | #include "Thread.h"
12 | #include "Lock.h"
13 | namespace CommLib {
14 | 
15 |     class ThreadLoop : public Thread {
16 |     public:
17 |         ThreadLoop(std::string name ="", int loopTime=3);
18 |         virtual ~ThreadLoop();
19 | 
20 |         virtual void LoopTask() = 0;
21 | 
22 |         void StopLoop() {
23 |             con_.Signal();
24 |         }
25 |         void ThreadFunc();
26 |     private:
27 |         int loopTime_;
28 | 
29 |         Condition con_;
30 | 
31 |     };
32 | }
33 | #endif	/* CTHREADLOOP_H */
34 | 
35 | 


--------------------------------------------------------------------------------
/ThreadPool.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 |  * File:   ThreadPool.cpp
 3 |  * Author: Administrator
 4 |  * 
 5 |  * Created on 2014年1月24日, 上午10:04
 6 |  */
 7 | #include <boost/function.hpp>
 8 | #include <boost/bind.hpp>
 9 | 
10 | #include "ThreadPool.h"
11 | #include "Semaphore.h"
12 | namespace CommLib {
13 | ThreadPool::ThreadPool() : bRuning_(false) ,sem_(0,0){
14 | }
15 | 
16 | ThreadPool::~ThreadPool() {
17 |     ClearTaskList();
18 |     Stop();
19 | }
20 | 
21 | void ThreadPool::AddTask(boost::function<void () > func) {
22 | 
23 |     {
24 |         CAutoLock al(lock_);
25 |         tasklist_.push_back(func);
26 |     }
27 | 
28 |     sem_.post();
29 | }
30 | 
31 | int ThreadPool::GetCurrTaskSize() {
32 |     CAutoLock al(lock_);
33 |     return tasklist_.size();
34 | }
35 | 
36 | bool ThreadPool::PopTask(boost::function<void () >& func) {
37 |     sem_.wait();
38 | 
39 |     CAutoLock al(lock_);
40 | 
41 |     if (!tasklist_.empty()) {
42 |         func = tasklist_.front();
43 |         tasklist_.pop_front();
44 |         return true;
45 |     } else
46 |         return false;
47 | }
48 | 
49 | void ThreadPool::ThreadFunc() {
50 |     while ( bRunning() ) {
51 |         boost::function<void () > func;
52 | 
53 |         while (PopTask(func)) {
54 |             func();
55 |         }
56 |     }
57 | }
58 | 
59 | bool ThreadPool::Init(int threadCnt) {
60 |     CAutoLock al(lockOp_);
61 | 
62 |     if ((!bRuning_) &&(threadCnt < MAX_THREADPOOLSIZE)) {
63 |         threadvec_.resize(threadCnt);
64 |         bRuning_ = true;
65 |         for (int i = 0; i < threadCnt; i++) {
66 |             threadvec_[i] = new Thread( boost::bind(&ThreadPool::ThreadFunc, this),"");
67 |             threadvec_[i]->StartThread();
68 |         }
69 | 
70 |         return true;
71 |     }
72 |     return false;
73 | }
74 | 
75 | void ThreadPool::Stop() {
76 |     CAutoLock al(lockOp_);
77 | 
78 |     if (bRuning_) {
79 |         bRuning_ = false;
80 | //        con_.Broadcast();
81 | 
82 |         int threadCnt = threadvec_.size();
83 |         
84 |         for(int i = 0; i < threadCnt; i++)
85 |         {
86 |             sem_.post();
87 |         }
88 |         
89 |         for (int i = 0; i < threadCnt; i++) {
90 |             threadvec_[i]->Join();
91 |             delete threadvec_[i];
92 |         }
93 | 
94 |         threadvec_.clear();
95 |     }
96 | }
97 | }
98 | 


--------------------------------------------------------------------------------
/ThreadPool.h:
--------------------------------------------------------------------------------
 1 | /* 
 2 |  * File:   ThreadPool.h
 3 |  * Author: Administrator
 4 |  *
 5 |  * Created on 2014年1月24日, 上午10:04
 6 |  */
 7 | 
 8 | #ifndef THREADPOOL_H
 9 | #define	THREADPOOL_H
10 | 
11 | #include <list>
12 | #include <vector>
13 | 
14 | #include "Thread.h"
15 | #include "Lock.h"
16 | #include "Semaphore.h"
17 | 
18 | #define MAX_THREADPOOLSIZE 100
19 | namespace CommLib {
20 | 
21 |     class ThreadPool : boost::noncopyable {
22 |     public:
23 |         ThreadPool();
24 |         virtual ~ThreadPool();
25 | 
26 |         void AddTask(boost::function<void () > func);
27 |         int GetCurrTaskSize();
28 | 
29 |         void ClearTaskList() {
30 |             CAutoLock al(lock_);
31 |             tasklist_.clear();
32 |         }
33 | 
34 |         void ThreadFunc();
35 |         bool Init(int threadCnt);
36 |         void Stop();
37 | 
38 |         bool bRunning() {
39 |             return bRuning_;
40 |         }
41 | 
42 |     private:
43 | 
44 |         bool PopTask(boost::function<void () >& func);
45 |     private:
46 |         bool bRuning_;
47 |         CMutexLock lock_;
48 |         CMutexLock lockOp_;
49 |         std::vector<Thread*> threadvec_;
50 |         std::list<boost::function<void () > > tasklist_;
51 |         //   CCondition con_;
52 | 
53 |         Semaphore sem_;
54 |     };
55 | }
56 | #endif	/* THREADPOOL_H */
57 | 
58 | 


--------------------------------------------------------------------------------
/Time.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * File:   CTime.cpp
  3 |  * Author: Administrator
  4 |  *
  5 |  * Created on 2014年1月26日, 下午4:49
  6 |  */
  7 | 
  8 | #include <bits/time.h>
  9 | #include <sys/time.h>
 10 | 
 11 | #include "Time.h"
 12 | namespace CommLib {
 13 | 
 14 |     Time::Time(time_t tt) : tt_(tt) {
 15 |         localtime_r(&tt, &tm_);
 16 |     }
 17 | 
 18 |     Time::Time() : tt_(0) {
 19 |     }
 20 | 
 21 |     unsigned long mktime(unsigned int year, unsigned int mon,
 22 |             unsigned int day, unsigned int hour,
 23 |             unsigned int min, unsigned int sec) {
 24 |         if (0 >= (int) (mon -= 2)) { /* 1..12 -> 11,12,1..10 */
 25 |             mon += 12; /* Puts Feb last since it has leap day */
 26 |             year -= 1;
 27 |         }
 28 | 
 29 |         return (((
 30 |                 (unsigned long) (year / 4 - year / 100 + year / 400 + 367 * mon / 12 + day) +
 31 |                 year * 365 - 719499
 32 |                 )*24 + hour /* now have hours */
 33 |                 )*60 + min /* now have minutes */
 34 |                 )*60 + sec; /* finally seconds */
 35 |     }
 36 | 
 37 |     Time::Time(int nYear, int nMonth, int nDay, int nHour, int nMin, int nSec) {
 38 |         tt_ = mktime(nYear, nMonth, nDay, nHour, nMin, nSec) + __timezone;
 39 |         localtime_r(&tt_, &tm_);
 40 | 
 41 |     }
 42 | 
 43 |     Time::Time(const Time& orig) : tm_(orig.tm_), tt_(orig.tt_) {
 44 |     }
 45 | 
 46 |     Time::~Time() {
 47 |     }
 48 | 
 49 |     Time Time::GetCurrentTime() {
 50 |         time_t _tt = time(NULL);
 51 |         return Time(_tt);
 52 |     }
 53 | 
 54 |     long Time::GetCurrTick() {
 55 |         timeval tm;
 56 |         gettimeofday(&tm, NULL);
 57 |         return ( tm.tv_sec * 1000000 + tm.tv_usec);
 58 |     }
 59 | 
 60 |     int Time::GetDay() {
 61 |         return tm_.tm_yday + 1;
 62 |     }
 63 | 
 64 |     int Time::GetDayOfWeek() {
 65 |         return tm_.tm_wday;
 66 |     }
 67 | 
 68 |     int Time::GetHour() {
 69 |         return tm_.tm_hour;
 70 |     }
 71 | 
 72 |     int Time::GetMinute() {
 73 |         return tm_.tm_min;
 74 |     }
 75 | 
 76 |     int Time::GetMonth() {
 77 |         return tm_.tm_mon + 1;
 78 |     }
 79 | 
 80 |     int Time::GetSecond() {
 81 |         return tm_.tm_sec;
 82 |     }
 83 | 
 84 |     time_t Time::GetTime() {
 85 |         return tt_;
 86 |     }
 87 | 
 88 |     int Time::GetYear() {
 89 |         return tm_.tm_year + 1900;
 90 |     }
 91 | 
 92 |     Time Time::operator +(TimeSpan &span) {
 93 |         return Time(tt_ + span.GetTimeSpan());
 94 |     }
 95 | 
 96 |     Time Time::operator -(TimeSpan &span) {
 97 |         return Time(tt_ - span.GetTimeSpan());
 98 |     }
 99 | 
100 |     TimeSpan Time::operator -(Time &tm) {
101 |         return TimeSpan(tt_ - tm.tt_);
102 |     }
103 | 
104 |     Time Time::operator +(time_t tt) {
105 |         return Time(tt_ + tt);
106 |     }
107 | 
108 |     Time Time::operator -(time_t tt) {
109 |         return Time(tt_ - tt);
110 |     }
111 | }
112 | 


--------------------------------------------------------------------------------
/Time.h:
--------------------------------------------------------------------------------
 1 | /* 
 2 |  * File:   CTime.h
 3 |  * Author: Administrator
 4 |  *
 5 |  * Created on 2014年1月26日, 下午4:49
 6 |  */
 7 | 
 8 | #ifndef TIME_H
 9 | #define	TIME_H
10 | 
11 | #include "TimeSpan.h"
12 | namespace CommLib {
13 | 
14 |     class Time {
15 |     public:
16 |         Time(time_t tt);
17 |         Time();
18 |         Time(int nYear, int nMonth, int nDay, int nHour, int nMin, int nSec);
19 |         Time(const Time& orig);
20 |         virtual ~Time();
21 | 
22 |         int GetDay();
23 |         int GetDayOfWeek();
24 |         int GetHour();
25 |         int GetMinute();
26 |         int GetMonth();
27 |         int GetSecond();
28 |         time_t GetTime();
29 |         int GetYear();
30 | 
31 |         static Time GetCurrentTime();
32 |         static long GetCurrTick();
33 | 
34 |         Time operator +(TimeSpan &span);
35 |         Time operator +(time_t tt);
36 |         Time operator -(time_t tt);
37 | 
38 |         Time operator -(TimeSpan &span);
39 |         TimeSpan operator -(Time &tm);
40 |     private:
41 |         tm tm_;
42 |         time_t tt_;
43 |     };
44 | }
45 | #endif	/* CTIME_H */
46 | 
47 | 


--------------------------------------------------------------------------------
/TimeSpan.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 |  * File:   TimeSpan.cpp
 3 |  * Author: Administrator
 4 |  * 
 5 |  * Created on 2014年1月27日, 上午8:51
 6 |  */
 7 | 
 8 | #include "TimeSpan.h"
 9 | namespace CommLib {
10 | 
11 |     TimeSpan::TimeSpan() : lDays_(0), nHours_(0), nMins_(0), nSecs_(0), tt_(0) {
12 |     }
13 | 
14 |     TimeSpan::TimeSpan(time_t tt) {
15 |         tt_ = tt;
16 |         nSecs_ = tt % 60;
17 |         tt = tt / 60;
18 | 
19 |         nMins_ = tt % 60;
20 |         tt = tt / 60;
21 | 
22 |         nHours_ = tt % 24;
23 |         lDays_ = tt / 24;
24 |     }
25 | 
26 |     TimeSpan::TimeSpan(const TimeSpan& orig)
27 |     : lDays_(orig.lDays_), nHours_(orig.nHours_), nMins_(orig.nMins_), nSecs_(orig.nSecs_)
28 |     , tt_(orig.tt_) {
29 |     }
30 | 
31 |     TimeSpan::~TimeSpan() {
32 |     }
33 | 
34 |     TimeSpan::TimeSpan(long lDays, int nHours, int nMins, int nSecs)
35 |     : lDays_(lDays), nHours_(nHours), nMins_(nMins), nSecs_(nSecs) {
36 |         tt_ = ((lDays_ * 24 + nHours_)*60 + nMins_)*60 + nSecs_;
37 |     }
38 | 
39 |     long TimeSpan::GetDays() {
40 |         return lDays_;
41 |     }
42 | 
43 |     int TimeSpan::GetHours() {
44 |         return nHours_;
45 |     }
46 | 
47 |     int TimeSpan::GetMinutes() {
48 |         return nMins_;
49 |     }
50 | 
51 |     int TimeSpan::GetSeconds() {
52 |         return nSecs_;
53 |     }
54 | 
55 |     time_t TimeSpan::GetTimeSpan() {
56 |         return tt_;
57 |     }
58 | 
59 |     TimeSpan TimeSpan::operator +(TimeSpan &span) {
60 |         TimeSpan rSpan(tt_ + span.tt_);
61 |         return rSpan;
62 |     }
63 | 
64 |     TimeSpan TimeSpan::operator -(TimeSpan &span) {
65 |         TimeSpan rSpan(tt_ - span.tt_);
66 |         return rSpan;
67 |     }
68 | 
69 |     bool TimeSpan::operator>(TimeSpan &span) {
70 |         return (tt_ > span.tt_);
71 |     }
72 | }
73 | 


--------------------------------------------------------------------------------
/TimeSpan.h:
--------------------------------------------------------------------------------
 1 | /* 
 2 |  * File:   TimeSpan.h
 3 |  * Author: Administrator
 4 |  *
 5 |  * Created on 2014年1月27日, 上午8:51
 6 |  */
 7 | 
 8 | #ifndef TIMESPAN_H
 9 | #define	TIMESPAN_H
10 | 
11 | #include <time.h>
12 | namespace CommLib {
13 | 
14 |     class TimeSpan {
15 |     public:
16 |         TimeSpan();
17 |         TimeSpan(time_t tt);
18 |         TimeSpan(const TimeSpan& orig);
19 |         TimeSpan(long lDays, int nHours, int nMins, int nSecs);
20 |         virtual ~TimeSpan();
21 | 
22 |         long GetDays();
23 |         int GetHours();
24 |         int GetMinutes();
25 |         int GetSeconds();
26 |         time_t GetTimeSpan();
27 | 
28 |         TimeSpan operator +(TimeSpan &span);
29 |         TimeSpan operator -(TimeSpan &span);
30 |         bool operator>(TimeSpan &span);
31 | 
32 |     private:
33 |         long lDays_;
34 |         int nHours_;
35 |         int nMins_;
36 |         int nSecs_;
37 |         time_t tt_;
38 |     };
39 | }
40 | #endif	/* CTIMESPAN_H */
41 | 
42 | 


--------------------------------------------------------------------------------
/build/Debug/MinGW-Windows/Lock.o:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jixuduxing/CommLib/f5e3b6585b9ff969ae0541faf9040b29056da0c6/build/Debug/MinGW-Windows/Lock.o


--------------------------------------------------------------------------------
/build/Debug/MinGW-Windows/Lock.o.d:
--------------------------------------------------------------------------------
1 | build/Debug/MinGW-Windows/Lock.o: Lock.cpp
2 | 


--------------------------------------------------------------------------------
/nbproject/Makefile-Debug.mk:
--------------------------------------------------------------------------------
  1 | #
  2 | # Generated Makefile - do not edit!
  3 | #
  4 | # Edit the Makefile in the project folder instead (../Makefile). Each target
  5 | # has a -pre and a -post target defined where you can add customized code.
  6 | #
  7 | # This makefile implements configuration specific macros and targets.
  8 | 
  9 | 
 10 | # Environment
 11 | MKDIR=mkdir
 12 | CP=cp
 13 | GREP=grep
 14 | NM=nm
 15 | CCADMIN=CCadmin
 16 | RANLIB=ranlib
 17 | CC=gcc
 18 | CCC=g++
 19 | CXX=g++
 20 | FC=gfortran
 21 | AS=as
 22 | 
 23 | # Macros
 24 | CND_PLATFORM=GNU-Linux-x86
 25 | CND_DLIB_EXT=so
 26 | CND_CONF=Debug
 27 | CND_DISTDIR=dist
 28 | CND_BUILDDIR=build
 29 | 
 30 | # Include project Makefile
 31 | include Makefile
 32 | 
 33 | # Object Directory
 34 | OBJECTDIR=${CND_BUILDDIR}/${CND_CONF}/${CND_PLATFORM}
 35 | 
 36 | # Object Files
 37 | OBJECTFILES= \
 38 | 	${OBJECTDIR}/CommServer.o \
 39 | 	${OBJECTDIR}/Epoll.o \
 40 | 	${OBJECTDIR}/Lock.o \
 41 | 	${OBJECTDIR}/MemPool.o \
 42 | 	${OBJECTDIR}/Parser.o \
 43 | 	${OBJECTDIR}/Semaphore.o \
 44 | 	${OBJECTDIR}/Sock.o \
 45 | 	${OBJECTDIR}/TcpEpollClient.o \
 46 | 	${OBJECTDIR}/TcpEpollServer.o \
 47 | 	${OBJECTDIR}/TcpSock.o \
 48 | 	${OBJECTDIR}/Thread.o \
 49 | 	${OBJECTDIR}/ThreadLoop.o \
 50 | 	${OBJECTDIR}/ThreadPool.o \
 51 | 	${OBJECTDIR}/Time.o \
 52 | 	${OBJECTDIR}/TimeSpan.o
 53 | 
 54 | # Test Directory
 55 | TESTDIR=${CND_BUILDDIR}/${CND_CONF}/${CND_PLATFORM}/tests
 56 | 
 57 | # Test Files
 58 | TESTFILES= \
 59 | 	${TESTDIR}/TestFiles/BoostMemPoolTest \
 60 | 	${TESTDIR}/TestFiles/MemPoolTest \
 61 | 	${TESTDIR}/TestFiles/TestCopyable \
 62 | 	${TESTDIR}/TestFiles/TestCTime \
 63 | 	${TESTDIR}/TestFiles/TestEpoll \
 64 | 	${TESTDIR}/TestFiles/TestMemPool \
 65 | 	${TESTDIR}/TestFiles/f9 \
 66 | 	${TESTDIR}/TestFiles/TestThreadLoop \
 67 | 	${TESTDIR}/TestFiles/TestThreadPool
 68 | 
 69 | # C Compiler Flags
 70 | CFLAGS=
 71 | 
 72 | # CC Compiler Flags
 73 | CCFLAGS=
 74 | CXXFLAGS=
 75 | 
 76 | # Fortran Compiler Flags
 77 | FFLAGS=
 78 | 
 79 | # Assembler Flags
 80 | ASFLAGS=
 81 | 
 82 | # Link Libraries and Options
 83 | LDLIBSOPTIONS=
 84 | 
 85 | # Build Targets
 86 | .build-conf: ${BUILD_SUBPROJECTS}
 87 | 	"${MAKE}"  -f nbproject/Makefile-${CND_CONF}.mk ${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM}/libgithub.a
 88 | 
 89 | ${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM}/libgithub.a: ${OBJECTFILES}
 90 | 	${MKDIR} -p ${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM}
 91 | 	${RM} ${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM}/libgithub.a
 92 | 	${AR} -rv ${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM}/libgithub.a ${OBJECTFILES} 
 93 | 	$(RANLIB) ${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM}/libgithub.a
 94 | 
 95 | ${OBJECTDIR}/CommServer.o: CommServer.cpp 
 96 | 	${MKDIR} -p ${OBJECTDIR}
 97 | 	${RM} "$@.d"
 98 | 	$(COMPILE.cc) -g -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/CommServer.o CommServer.cpp
 99 | 
100 | ${OBJECTDIR}/Epoll.o: Epoll.cpp 
101 | 	${MKDIR} -p ${OBJECTDIR}
102 | 	${RM} "$@.d"
103 | 	$(COMPILE.cc) -g -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/Epoll.o Epoll.cpp
104 | 
105 | ${OBJECTDIR}/Lock.o: Lock.cpp 
106 | 	${MKDIR} -p ${OBJECTDIR}
107 | 	${RM} "$@.d"
108 | 	$(COMPILE.cc) -g -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/Lock.o Lock.cpp
109 | 
110 | ${OBJECTDIR}/MemPool.o: MemPool.cpp 
111 | 	${MKDIR} -p ${OBJECTDIR}
112 | 	${RM} "$@.d"
113 | 	$(COMPILE.cc) -g -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/MemPool.o MemPool.cpp
114 | 
115 | ${OBJECTDIR}/Parser.o: Parser.cpp 
116 | 	${MKDIR} -p ${OBJECTDIR}
117 | 	${RM} "$@.d"
118 | 	$(COMPILE.cc) -g -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/Parser.o Parser.cpp
119 | 
120 | ${OBJECTDIR}/Semaphore.o: Semaphore.cpp 
121 | 	${MKDIR} -p ${OBJECTDIR}
122 | 	${RM} "$@.d"
123 | 	$(COMPILE.cc) -g -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/Semaphore.o Semaphore.cpp
124 | 
125 | ${OBJECTDIR}/Sock.o: Sock.cpp 
126 | 	${MKDIR} -p ${OBJECTDIR}
127 | 	${RM} "$@.d"
128 | 	$(COMPILE.cc) -g -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/Sock.o Sock.cpp
129 | 
130 | ${OBJECTDIR}/TcpEpollClient.o: TcpEpollClient.cpp 
131 | 	${MKDIR} -p ${OBJECTDIR}
132 | 	${RM} "$@.d"
133 | 	$(COMPILE.cc) -g -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/TcpEpollClient.o TcpEpollClient.cpp
134 | 
135 | ${OBJECTDIR}/TcpEpollServer.o: TcpEpollServer.cpp 
136 | 	${MKDIR} -p ${OBJECTDIR}
137 | 	${RM} "$@.d"
138 | 	$(COMPILE.cc) -g -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/TcpEpollServer.o TcpEpollServer.cpp
139 | 
140 | ${OBJECTDIR}/TcpSock.o: TcpSock.cpp 
141 | 	${MKDIR} -p ${OBJECTDIR}
142 | 	${RM} "$@.d"
143 | 	$(COMPILE.cc) -g -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/TcpSock.o TcpSock.cpp
144 | 
145 | ${OBJECTDIR}/Thread.o: Thread.cpp 
146 | 	${MKDIR} -p ${OBJECTDIR}
147 | 	${RM} "$@.d"
148 | 	$(COMPILE.cc) -g -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/Thread.o Thread.cpp
149 | 
150 | ${OBJECTDIR}/ThreadLoop.o: ThreadLoop.cpp 
151 | 	${MKDIR} -p ${OBJECTDIR}
152 | 	${RM} "$@.d"
153 | 	$(COMPILE.cc) -g -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/ThreadLoop.o ThreadLoop.cpp
154 | 
155 | ${OBJECTDIR}/ThreadPool.o: ThreadPool.cpp 
156 | 	${MKDIR} -p ${OBJECTDIR}
157 | 	${RM} "$@.d"
158 | 	$(COMPILE.cc) -g -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/ThreadPool.o ThreadPool.cpp
159 | 
160 | ${OBJECTDIR}/Time.o: Time.cpp 
161 | 	${MKDIR} -p ${OBJECTDIR}
162 | 	${RM} "$@.d"
163 | 	$(COMPILE.cc) -g -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/Time.o Time.cpp
164 | 
165 | ${OBJECTDIR}/TimeSpan.o: TimeSpan.cpp 
166 | 	${MKDIR} -p ${OBJECTDIR}
167 | 	${RM} "$@.d"
168 | 	$(COMPILE.cc) -g -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/TimeSpan.o TimeSpan.cpp
169 | 
170 | # Subprojects
171 | .build-subprojects:
172 | 
173 | # Build Test Targets
174 | .build-tests-conf: .build-conf ${TESTFILES}
175 | ${TESTDIR}/TestFiles/BoostMemPoolTest: ${TESTDIR}/tests/BoostMemPoolTest.o ${OBJECTFILES:%.o=%_nomain.o}
176 | 	${MKDIR} -p ${TESTDIR}/TestFiles
177 | 	${LINK.cc}   -o ${TESTDIR}/TestFiles/BoostMemPoolTest $^ ${LDLIBSOPTIONS} -lpthread 
178 | 
179 | ${TESTDIR}/TestFiles/MemPoolTest: ${TESTDIR}/tests/defaultMemTest.o ${OBJECTFILES:%.o=%_nomain.o}
180 | 	${MKDIR} -p ${TESTDIR}/TestFiles
181 | 	${LINK.cc}   -o ${TESTDIR}/TestFiles/MemPoolTest $^ ${LDLIBSOPTIONS} -lpthread 
182 | 
183 | ${TESTDIR}/TestFiles/TestCopyable: ${TESTDIR}/tests/newsimpletest5.o ${OBJECTFILES:%.o=%_nomain.o}
184 | 	${MKDIR} -p ${TESTDIR}/TestFiles
185 | 	${LINK.cc}   -o ${TESTDIR}/TestFiles/TestCopyable $^ ${LDLIBSOPTIONS} -lpthread 
186 | 
187 | ${TESTDIR}/TestFiles/TestCTime: ${TESTDIR}/tests/newsimpletest3.o ${OBJECTFILES:%.o=%_nomain.o}
188 | 	${MKDIR} -p ${TESTDIR}/TestFiles
189 | 	${LINK.cc}   -o ${TESTDIR}/TestFiles/TestCTime $^ ${LDLIBSOPTIONS} -lpthread 
190 | 
191 | ${TESTDIR}/TestFiles/TestEpoll: ${TESTDIR}/tests/TestEpoll.o ${OBJECTFILES:%.o=%_nomain.o}
192 | 	${MKDIR} -p ${TESTDIR}/TestFiles
193 | 	${LINK.cc}   -o ${TESTDIR}/TestFiles/TestEpoll $^ ${LDLIBSOPTIONS} -lpthread 
194 | 
195 | ${TESTDIR}/TestFiles/TestMemPool: ${TESTDIR}/tests/newsimpletest.o ${OBJECTFILES:%.o=%_nomain.o}
196 | 	${MKDIR} -p ${TESTDIR}/TestFiles
197 | 	${LINK.cc}   -o ${TESTDIR}/TestFiles/TestMemPool $^ ${LDLIBSOPTIONS} -lpthread 
198 | 
199 | ${TESTDIR}/TestFiles/f9: ${TESTDIR}/tests/TestTcpEpollClient.o ${OBJECTFILES:%.o=%_nomain.o}
200 | 	${MKDIR} -p ${TESTDIR}/TestFiles
201 | 	${LINK.cc}   -o ${TESTDIR}/TestFiles/f9 $^ ${LDLIBSOPTIONS} -lpthread 
202 | 
203 | ${TESTDIR}/TestFiles/TestThreadLoop: ${TESTDIR}/tests/newsimpletest4.o ${OBJECTFILES:%.o=%_nomain.o}
204 | 	${MKDIR} -p ${TESTDIR}/TestFiles
205 | 	${LINK.cc}   -o ${TESTDIR}/TestFiles/TestThreadLoop $^ ${LDLIBSOPTIONS} -lpthread 
206 | 
207 | ${TESTDIR}/TestFiles/TestThreadPool: ${TESTDIR}/tests/TestThreadPoolandMemPoolself.o ${OBJECTFILES:%.o=%_nomain.o}
208 | 	${MKDIR} -p ${TESTDIR}/TestFiles
209 | 	${LINK.cc}   -o ${TESTDIR}/TestFiles/TestThreadPool $^ ${LDLIBSOPTIONS} -lpthread 
210 | 
211 | 
212 | ${TESTDIR}/tests/BoostMemPoolTest.o: tests/BoostMemPoolTest.cpp 
213 | 	${MKDIR} -p ${TESTDIR}/tests
214 | 	${RM} "$@.d"
215 | 	$(COMPILE.cc) -g -I. -MMD -MP -MF "$@.d" -o ${TESTDIR}/tests/BoostMemPoolTest.o tests/BoostMemPoolTest.cpp
216 | 
217 | 
218 | ${TESTDIR}/tests/defaultMemTest.o: tests/defaultMemTest.cpp 
219 | 	${MKDIR} -p ${TESTDIR}/tests
220 | 	${RM} "$@.d"
221 | 	$(COMPILE.cc) -g -I. -MMD -MP -MF "$@.d" -o ${TESTDIR}/tests/defaultMemTest.o tests/defaultMemTest.cpp
222 | 
223 | 
224 | ${TESTDIR}/tests/newsimpletest5.o: tests/newsimpletest5.cpp 
225 | 	${MKDIR} -p ${TESTDIR}/tests
226 | 	${RM} "$@.d"
227 | 	$(COMPILE.cc) -g -I. -MMD -MP -MF "$@.d" -o ${TESTDIR}/tests/newsimpletest5.o tests/newsimpletest5.cpp
228 | 
229 | 
230 | ${TESTDIR}/tests/newsimpletest3.o: tests/newsimpletest3.cpp 
231 | 	${MKDIR} -p ${TESTDIR}/tests
232 | 	${RM} "$@.d"
233 | 	$(COMPILE.cc) -g -I. -MMD -MP -MF "$@.d" -o ${TESTDIR}/tests/newsimpletest3.o tests/newsimpletest3.cpp
234 | 
235 | 
236 | ${TESTDIR}/tests/TestEpoll.o: tests/TestEpoll.cpp 
237 | 	${MKDIR} -p ${TESTDIR}/tests
238 | 	${RM} "$@.d"
239 | 	$(COMPILE.cc) -g -I. -MMD -MP -MF "$@.d" -o ${TESTDIR}/tests/TestEpoll.o tests/TestEpoll.cpp
240 | 
241 | 
242 | ${TESTDIR}/tests/newsimpletest.o: tests/newsimpletest.cpp 
243 | 	${MKDIR} -p ${TESTDIR}/tests
244 | 	${RM} "$@.d"
245 | 	$(COMPILE.cc) -g -I. -MMD -MP -MF "$@.d" -o ${TESTDIR}/tests/newsimpletest.o tests/newsimpletest.cpp
246 | 
247 | 
248 | ${TESTDIR}/tests/TestTcpEpollClient.o: tests/TestTcpEpollClient.cpp 
249 | 	${MKDIR} -p ${TESTDIR}/tests
250 | 	${RM} "$@.d"
251 | 	$(COMPILE.cc) -g -I. -MMD -MP -MF "$@.d" -o ${TESTDIR}/tests/TestTcpEpollClient.o tests/TestTcpEpollClient.cpp
252 | 
253 | 
254 | ${TESTDIR}/tests/newsimpletest4.o: tests/newsimpletest4.cpp 
255 | 	${MKDIR} -p ${TESTDIR}/tests
256 | 	${RM} "$@.d"
257 | 	$(COMPILE.cc) -g -I. -MMD -MP -MF "$@.d" -o ${TESTDIR}/tests/newsimpletest4.o tests/newsimpletest4.cpp
258 | 
259 | 
260 | ${TESTDIR}/tests/TestThreadPoolandMemPoolself.o: tests/TestThreadPoolandMemPoolself.cpp 
261 | 	${MKDIR} -p ${TESTDIR}/tests
262 | 	${RM} "$@.d"
263 | 	$(COMPILE.cc) -g -I. -MMD -MP -MF "$@.d" -o ${TESTDIR}/tests/TestThreadPoolandMemPoolself.o tests/TestThreadPoolandMemPoolself.cpp
264 | 
265 | 
266 | ${OBJECTDIR}/CommServer_nomain.o: ${OBJECTDIR}/CommServer.o CommServer.cpp 
267 | 	${MKDIR} -p ${OBJECTDIR}
268 | 	@NMOUTPUT=`${NM} ${OBJECTDIR}/CommServer.o`; \
269 | 	if (echo "$$NMOUTPUT" | ${GREP} '|main$$') || \
270 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T main$$') || \
271 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T _main$$'); \
272 | 	then  \
273 | 	    ${RM} "$@.d";\
274 | 	    $(COMPILE.cc) -g -Dmain=__nomain -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/CommServer_nomain.o CommServer.cpp;\
275 | 	else  \
276 | 	    ${CP} ${OBJECTDIR}/CommServer.o ${OBJECTDIR}/CommServer_nomain.o;\
277 | 	fi
278 | 
279 | ${OBJECTDIR}/Epoll_nomain.o: ${OBJECTDIR}/Epoll.o Epoll.cpp 
280 | 	${MKDIR} -p ${OBJECTDIR}
281 | 	@NMOUTPUT=`${NM} ${OBJECTDIR}/Epoll.o`; \
282 | 	if (echo "$$NMOUTPUT" | ${GREP} '|main$$') || \
283 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T main$$') || \
284 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T _main$$'); \
285 | 	then  \
286 | 	    ${RM} "$@.d";\
287 | 	    $(COMPILE.cc) -g -Dmain=__nomain -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/Epoll_nomain.o Epoll.cpp;\
288 | 	else  \
289 | 	    ${CP} ${OBJECTDIR}/Epoll.o ${OBJECTDIR}/Epoll_nomain.o;\
290 | 	fi
291 | 
292 | ${OBJECTDIR}/Lock_nomain.o: ${OBJECTDIR}/Lock.o Lock.cpp 
293 | 	${MKDIR} -p ${OBJECTDIR}
294 | 	@NMOUTPUT=`${NM} ${OBJECTDIR}/Lock.o`; \
295 | 	if (echo "$$NMOUTPUT" | ${GREP} '|main$$') || \
296 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T main$$') || \
297 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T _main$$'); \
298 | 	then  \
299 | 	    ${RM} "$@.d";\
300 | 	    $(COMPILE.cc) -g -Dmain=__nomain -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/Lock_nomain.o Lock.cpp;\
301 | 	else  \
302 | 	    ${CP} ${OBJECTDIR}/Lock.o ${OBJECTDIR}/Lock_nomain.o;\
303 | 	fi
304 | 
305 | ${OBJECTDIR}/MemPool_nomain.o: ${OBJECTDIR}/MemPool.o MemPool.cpp 
306 | 	${MKDIR} -p ${OBJECTDIR}
307 | 	@NMOUTPUT=`${NM} ${OBJECTDIR}/MemPool.o`; \
308 | 	if (echo "$$NMOUTPUT" | ${GREP} '|main$$') || \
309 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T main$$') || \
310 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T _main$$'); \
311 | 	then  \
312 | 	    ${RM} "$@.d";\
313 | 	    $(COMPILE.cc) -g -Dmain=__nomain -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/MemPool_nomain.o MemPool.cpp;\
314 | 	else  \
315 | 	    ${CP} ${OBJECTDIR}/MemPool.o ${OBJECTDIR}/MemPool_nomain.o;\
316 | 	fi
317 | 
318 | ${OBJECTDIR}/Parser_nomain.o: ${OBJECTDIR}/Parser.o Parser.cpp 
319 | 	${MKDIR} -p ${OBJECTDIR}
320 | 	@NMOUTPUT=`${NM} ${OBJECTDIR}/Parser.o`; \
321 | 	if (echo "$$NMOUTPUT" | ${GREP} '|main$$') || \
322 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T main$$') || \
323 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T _main$$'); \
324 | 	then  \
325 | 	    ${RM} "$@.d";\
326 | 	    $(COMPILE.cc) -g -Dmain=__nomain -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/Parser_nomain.o Parser.cpp;\
327 | 	else  \
328 | 	    ${CP} ${OBJECTDIR}/Parser.o ${OBJECTDIR}/Parser_nomain.o;\
329 | 	fi
330 | 
331 | ${OBJECTDIR}/Semaphore_nomain.o: ${OBJECTDIR}/Semaphore.o Semaphore.cpp 
332 | 	${MKDIR} -p ${OBJECTDIR}
333 | 	@NMOUTPUT=`${NM} ${OBJECTDIR}/Semaphore.o`; \
334 | 	if (echo "$$NMOUTPUT" | ${GREP} '|main$$') || \
335 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T main$$') || \
336 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T _main$$'); \
337 | 	then  \
338 | 	    ${RM} "$@.d";\
339 | 	    $(COMPILE.cc) -g -Dmain=__nomain -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/Semaphore_nomain.o Semaphore.cpp;\
340 | 	else  \
341 | 	    ${CP} ${OBJECTDIR}/Semaphore.o ${OBJECTDIR}/Semaphore_nomain.o;\
342 | 	fi
343 | 
344 | ${OBJECTDIR}/Sock_nomain.o: ${OBJECTDIR}/Sock.o Sock.cpp 
345 | 	${MKDIR} -p ${OBJECTDIR}
346 | 	@NMOUTPUT=`${NM} ${OBJECTDIR}/Sock.o`; \
347 | 	if (echo "$$NMOUTPUT" | ${GREP} '|main$$') || \
348 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T main$$') || \
349 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T _main$$'); \
350 | 	then  \
351 | 	    ${RM} "$@.d";\
352 | 	    $(COMPILE.cc) -g -Dmain=__nomain -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/Sock_nomain.o Sock.cpp;\
353 | 	else  \
354 | 	    ${CP} ${OBJECTDIR}/Sock.o ${OBJECTDIR}/Sock_nomain.o;\
355 | 	fi
356 | 
357 | ${OBJECTDIR}/TcpEpollClient_nomain.o: ${OBJECTDIR}/TcpEpollClient.o TcpEpollClient.cpp 
358 | 	${MKDIR} -p ${OBJECTDIR}
359 | 	@NMOUTPUT=`${NM} ${OBJECTDIR}/TcpEpollClient.o`; \
360 | 	if (echo "$$NMOUTPUT" | ${GREP} '|main$$') || \
361 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T main$$') || \
362 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T _main$$'); \
363 | 	then  \
364 | 	    ${RM} "$@.d";\
365 | 	    $(COMPILE.cc) -g -Dmain=__nomain -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/TcpEpollClient_nomain.o TcpEpollClient.cpp;\
366 | 	else  \
367 | 	    ${CP} ${OBJECTDIR}/TcpEpollClient.o ${OBJECTDIR}/TcpEpollClient_nomain.o;\
368 | 	fi
369 | 
370 | ${OBJECTDIR}/TcpEpollServer_nomain.o: ${OBJECTDIR}/TcpEpollServer.o TcpEpollServer.cpp 
371 | 	${MKDIR} -p ${OBJECTDIR}
372 | 	@NMOUTPUT=`${NM} ${OBJECTDIR}/TcpEpollServer.o`; \
373 | 	if (echo "$$NMOUTPUT" | ${GREP} '|main$$') || \
374 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T main$$') || \
375 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T _main$$'); \
376 | 	then  \
377 | 	    ${RM} "$@.d";\
378 | 	    $(COMPILE.cc) -g -Dmain=__nomain -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/TcpEpollServer_nomain.o TcpEpollServer.cpp;\
379 | 	else  \
380 | 	    ${CP} ${OBJECTDIR}/TcpEpollServer.o ${OBJECTDIR}/TcpEpollServer_nomain.o;\
381 | 	fi
382 | 
383 | ${OBJECTDIR}/TcpSock_nomain.o: ${OBJECTDIR}/TcpSock.o TcpSock.cpp 
384 | 	${MKDIR} -p ${OBJECTDIR}
385 | 	@NMOUTPUT=`${NM} ${OBJECTDIR}/TcpSock.o`; \
386 | 	if (echo "$$NMOUTPUT" | ${GREP} '|main$$') || \
387 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T main$$') || \
388 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T _main$$'); \
389 | 	then  \
390 | 	    ${RM} "$@.d";\
391 | 	    $(COMPILE.cc) -g -Dmain=__nomain -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/TcpSock_nomain.o TcpSock.cpp;\
392 | 	else  \
393 | 	    ${CP} ${OBJECTDIR}/TcpSock.o ${OBJECTDIR}/TcpSock_nomain.o;\
394 | 	fi
395 | 
396 | ${OBJECTDIR}/Thread_nomain.o: ${OBJECTDIR}/Thread.o Thread.cpp 
397 | 	${MKDIR} -p ${OBJECTDIR}
398 | 	@NMOUTPUT=`${NM} ${OBJECTDIR}/Thread.o`; \
399 | 	if (echo "$$NMOUTPUT" | ${GREP} '|main$$') || \
400 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T main$$') || \
401 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T _main$$'); \
402 | 	then  \
403 | 	    ${RM} "$@.d";\
404 | 	    $(COMPILE.cc) -g -Dmain=__nomain -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/Thread_nomain.o Thread.cpp;\
405 | 	else  \
406 | 	    ${CP} ${OBJECTDIR}/Thread.o ${OBJECTDIR}/Thread_nomain.o;\
407 | 	fi
408 | 
409 | ${OBJECTDIR}/ThreadLoop_nomain.o: ${OBJECTDIR}/ThreadLoop.o ThreadLoop.cpp 
410 | 	${MKDIR} -p ${OBJECTDIR}
411 | 	@NMOUTPUT=`${NM} ${OBJECTDIR}/ThreadLoop.o`; \
412 | 	if (echo "$$NMOUTPUT" | ${GREP} '|main$$') || \
413 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T main$$') || \
414 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T _main$$'); \
415 | 	then  \
416 | 	    ${RM} "$@.d";\
417 | 	    $(COMPILE.cc) -g -Dmain=__nomain -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/ThreadLoop_nomain.o ThreadLoop.cpp;\
418 | 	else  \
419 | 	    ${CP} ${OBJECTDIR}/ThreadLoop.o ${OBJECTDIR}/ThreadLoop_nomain.o;\
420 | 	fi
421 | 
422 | ${OBJECTDIR}/ThreadPool_nomain.o: ${OBJECTDIR}/ThreadPool.o ThreadPool.cpp 
423 | 	${MKDIR} -p ${OBJECTDIR}
424 | 	@NMOUTPUT=`${NM} ${OBJECTDIR}/ThreadPool.o`; \
425 | 	if (echo "$$NMOUTPUT" | ${GREP} '|main$$') || \
426 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T main$$') || \
427 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T _main$$'); \
428 | 	then  \
429 | 	    ${RM} "$@.d";\
430 | 	    $(COMPILE.cc) -g -Dmain=__nomain -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/ThreadPool_nomain.o ThreadPool.cpp;\
431 | 	else  \
432 | 	    ${CP} ${OBJECTDIR}/ThreadPool.o ${OBJECTDIR}/ThreadPool_nomain.o;\
433 | 	fi
434 | 
435 | ${OBJECTDIR}/Time_nomain.o: ${OBJECTDIR}/Time.o Time.cpp 
436 | 	${MKDIR} -p ${OBJECTDIR}
437 | 	@NMOUTPUT=`${NM} ${OBJECTDIR}/Time.o`; \
438 | 	if (echo "$$NMOUTPUT" | ${GREP} '|main$$') || \
439 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T main$$') || \
440 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T _main$$'); \
441 | 	then  \
442 | 	    ${RM} "$@.d";\
443 | 	    $(COMPILE.cc) -g -Dmain=__nomain -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/Time_nomain.o Time.cpp;\
444 | 	else  \
445 | 	    ${CP} ${OBJECTDIR}/Time.o ${OBJECTDIR}/Time_nomain.o;\
446 | 	fi
447 | 
448 | ${OBJECTDIR}/TimeSpan_nomain.o: ${OBJECTDIR}/TimeSpan.o TimeSpan.cpp 
449 | 	${MKDIR} -p ${OBJECTDIR}
450 | 	@NMOUTPUT=`${NM} ${OBJECTDIR}/TimeSpan.o`; \
451 | 	if (echo "$$NMOUTPUT" | ${GREP} '|main$$') || \
452 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T main$$') || \
453 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T _main$$'); \
454 | 	then  \
455 | 	    ${RM} "$@.d";\
456 | 	    $(COMPILE.cc) -g -Dmain=__nomain -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/TimeSpan_nomain.o TimeSpan.cpp;\
457 | 	else  \
458 | 	    ${CP} ${OBJECTDIR}/TimeSpan.o ${OBJECTDIR}/TimeSpan_nomain.o;\
459 | 	fi
460 | 
461 | # Run Test Targets
462 | .test-conf:
463 | 	@if [ "${TEST}" = "" ]; \
464 | 	then  \
465 | 	    ${TESTDIR}/TestFiles/BoostMemPoolTest || true; \
466 | 	    ${TESTDIR}/TestFiles/MemPoolTest || true; \
467 | 	    ${TESTDIR}/TestFiles/TestCopyable || true; \
468 | 	    ${TESTDIR}/TestFiles/TestCTime || true; \
469 | 	    ${TESTDIR}/TestFiles/TestEpoll || true; \
470 | 	    ${TESTDIR}/TestFiles/TestMemPool || true; \
471 | 	    ${TESTDIR}/TestFiles/f9 || true; \
472 | 	    ${TESTDIR}/TestFiles/TestThreadLoop || true; \
473 | 	    ${TESTDIR}/TestFiles/TestThreadPool || true; \
474 | 	else  \
475 | 	    ./${TEST} || true; \
476 | 	fi
477 | 
478 | # Clean Targets
479 | .clean-conf: ${CLEAN_SUBPROJECTS}
480 | 	${RM} -r ${CND_BUILDDIR}/${CND_CONF}
481 | 	${RM} ${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM}/libgithub.a
482 | 
483 | # Subprojects
484 | .clean-subprojects:
485 | 
486 | # Enable dependency checking
487 | .dep.inc: .depcheck-impl
488 | 
489 | include .dep.inc
490 | 


--------------------------------------------------------------------------------
/nbproject/Makefile-Release.mk:
--------------------------------------------------------------------------------
  1 | #
  2 | # Generated Makefile - do not edit!
  3 | #
  4 | # Edit the Makefile in the project folder instead (../Makefile). Each target
  5 | # has a -pre and a -post target defined where you can add customized code.
  6 | #
  7 | # This makefile implements configuration specific macros and targets.
  8 | 
  9 | 
 10 | # Environment
 11 | MKDIR=mkdir
 12 | CP=cp
 13 | GREP=grep
 14 | NM=nm
 15 | CCADMIN=CCadmin
 16 | RANLIB=ranlib
 17 | CC=gcc
 18 | CCC=g++
 19 | CXX=g++
 20 | FC=gfortran
 21 | AS=as
 22 | 
 23 | # Macros
 24 | CND_PLATFORM=MinGW-Windows
 25 | CND_DLIB_EXT=dll
 26 | CND_CONF=Release
 27 | CND_DISTDIR=dist
 28 | CND_BUILDDIR=build
 29 | 
 30 | # Include project Makefile
 31 | include Makefile
 32 | 
 33 | # Object Directory
 34 | OBJECTDIR=${CND_BUILDDIR}/${CND_CONF}/${CND_PLATFORM}
 35 | 
 36 | # Object Files
 37 | OBJECTFILES= \
 38 | 	${OBJECTDIR}/CommServer.o \
 39 | 	${OBJECTDIR}/Epoll.o \
 40 | 	${OBJECTDIR}/Lock.o \
 41 | 	${OBJECTDIR}/MemPool.o \
 42 | 	${OBJECTDIR}/Parser.o \
 43 | 	${OBJECTDIR}/Semaphore.o \
 44 | 	${OBJECTDIR}/Sock.o \
 45 | 	${OBJECTDIR}/TcpEpollClient.o \
 46 | 	${OBJECTDIR}/TcpEpollServer.o \
 47 | 	${OBJECTDIR}/TcpSock.o \
 48 | 	${OBJECTDIR}/Thread.o \
 49 | 	${OBJECTDIR}/ThreadLoop.o \
 50 | 	${OBJECTDIR}/ThreadPool.o \
 51 | 	${OBJECTDIR}/Time.o \
 52 | 	${OBJECTDIR}/TimeSpan.o
 53 | 
 54 | # Test Directory
 55 | TESTDIR=${CND_BUILDDIR}/${CND_CONF}/${CND_PLATFORM}/tests
 56 | 
 57 | # Test Files
 58 | TESTFILES= \
 59 | 	${TESTDIR}/TestFiles/f8 \
 60 | 	${TESTDIR}/TestFiles/f3 \
 61 | 	${TESTDIR}/TestFiles/f6 \
 62 | 	${TESTDIR}/TestFiles/f4 \
 63 | 	${TESTDIR}/TestFiles/f7 \
 64 | 	${TESTDIR}/TestFiles/f1 \
 65 | 	${TESTDIR}/TestFiles/f9 \
 66 | 	${TESTDIR}/TestFiles/f5 \
 67 | 	${TESTDIR}/TestFiles/f2
 68 | 
 69 | # C Compiler Flags
 70 | CFLAGS=
 71 | 
 72 | # CC Compiler Flags
 73 | CCFLAGS=
 74 | CXXFLAGS=
 75 | 
 76 | # Fortran Compiler Flags
 77 | FFLAGS=
 78 | 
 79 | # Assembler Flags
 80 | ASFLAGS=
 81 | 
 82 | # Link Libraries and Options
 83 | LDLIBSOPTIONS=
 84 | 
 85 | # Build Targets
 86 | .build-conf: ${BUILD_SUBPROJECTS}
 87 | 	"${MAKE}"  -f nbproject/Makefile-${CND_CONF}.mk ${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM}/libgithub.a
 88 | 
 89 | ${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM}/libgithub.a: ${OBJECTFILES}
 90 | 	${MKDIR} -p ${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM}
 91 | 	${RM} ${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM}/libgithub.a
 92 | 	${AR} -rv ${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM}/libgithub.a ${OBJECTFILES} 
 93 | 	$(RANLIB) ${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM}/libgithub.a
 94 | 
 95 | ${OBJECTDIR}/CommServer.o: CommServer.cpp 
 96 | 	${MKDIR} -p ${OBJECTDIR}
 97 | 	${RM} "$@.d"
 98 | 	$(COMPILE.cc) -O2 -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/CommServer.o CommServer.cpp
 99 | 
100 | ${OBJECTDIR}/Epoll.o: Epoll.cpp 
101 | 	${MKDIR} -p ${OBJECTDIR}
102 | 	${RM} "$@.d"
103 | 	$(COMPILE.cc) -O2 -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/Epoll.o Epoll.cpp
104 | 
105 | ${OBJECTDIR}/Lock.o: Lock.cpp 
106 | 	${MKDIR} -p ${OBJECTDIR}
107 | 	${RM} "$@.d"
108 | 	$(COMPILE.cc) -O2 -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/Lock.o Lock.cpp
109 | 
110 | ${OBJECTDIR}/MemPool.o: MemPool.cpp 
111 | 	${MKDIR} -p ${OBJECTDIR}
112 | 	${RM} "$@.d"
113 | 	$(COMPILE.cc) -O2 -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/MemPool.o MemPool.cpp
114 | 
115 | ${OBJECTDIR}/Parser.o: Parser.cpp 
116 | 	${MKDIR} -p ${OBJECTDIR}
117 | 	${RM} "$@.d"
118 | 	$(COMPILE.cc) -O2 -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/Parser.o Parser.cpp
119 | 
120 | ${OBJECTDIR}/Semaphore.o: Semaphore.cpp 
121 | 	${MKDIR} -p ${OBJECTDIR}
122 | 	${RM} "$@.d"
123 | 	$(COMPILE.cc) -O2 -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/Semaphore.o Semaphore.cpp
124 | 
125 | ${OBJECTDIR}/Sock.o: Sock.cpp 
126 | 	${MKDIR} -p ${OBJECTDIR}
127 | 	${RM} "$@.d"
128 | 	$(COMPILE.cc) -O2 -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/Sock.o Sock.cpp
129 | 
130 | ${OBJECTDIR}/TcpEpollClient.o: TcpEpollClient.cpp 
131 | 	${MKDIR} -p ${OBJECTDIR}
132 | 	${RM} "$@.d"
133 | 	$(COMPILE.cc) -O2 -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/TcpEpollClient.o TcpEpollClient.cpp
134 | 
135 | ${OBJECTDIR}/TcpEpollServer.o: TcpEpollServer.cpp 
136 | 	${MKDIR} -p ${OBJECTDIR}
137 | 	${RM} "$@.d"
138 | 	$(COMPILE.cc) -O2 -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/TcpEpollServer.o TcpEpollServer.cpp
139 | 
140 | ${OBJECTDIR}/TcpSock.o: TcpSock.cpp 
141 | 	${MKDIR} -p ${OBJECTDIR}
142 | 	${RM} "$@.d"
143 | 	$(COMPILE.cc) -O2 -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/TcpSock.o TcpSock.cpp
144 | 
145 | ${OBJECTDIR}/Thread.o: Thread.cpp 
146 | 	${MKDIR} -p ${OBJECTDIR}
147 | 	${RM} "$@.d"
148 | 	$(COMPILE.cc) -O2 -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/Thread.o Thread.cpp
149 | 
150 | ${OBJECTDIR}/ThreadLoop.o: ThreadLoop.cpp 
151 | 	${MKDIR} -p ${OBJECTDIR}
152 | 	${RM} "$@.d"
153 | 	$(COMPILE.cc) -O2 -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/ThreadLoop.o ThreadLoop.cpp
154 | 
155 | ${OBJECTDIR}/ThreadPool.o: ThreadPool.cpp 
156 | 	${MKDIR} -p ${OBJECTDIR}
157 | 	${RM} "$@.d"
158 | 	$(COMPILE.cc) -O2 -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/ThreadPool.o ThreadPool.cpp
159 | 
160 | ${OBJECTDIR}/Time.o: Time.cpp 
161 | 	${MKDIR} -p ${OBJECTDIR}
162 | 	${RM} "$@.d"
163 | 	$(COMPILE.cc) -O2 -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/Time.o Time.cpp
164 | 
165 | ${OBJECTDIR}/TimeSpan.o: TimeSpan.cpp 
166 | 	${MKDIR} -p ${OBJECTDIR}
167 | 	${RM} "$@.d"
168 | 	$(COMPILE.cc) -O2 -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/TimeSpan.o TimeSpan.cpp
169 | 
170 | # Subprojects
171 | .build-subprojects:
172 | 
173 | # Build Test Targets
174 | .build-tests-conf: .build-conf ${TESTFILES}
175 | ${TESTDIR}/TestFiles/f8: ${TESTDIR}/tests/BoostMemPoolTest.o ${OBJECTFILES:%.o=%_nomain.o}
176 | 	${MKDIR} -p ${TESTDIR}/TestFiles
177 | 	${LINK.cc}   -o ${TESTDIR}/TestFiles/f8 $^ ${LDLIBSOPTIONS} 
178 | 
179 | ${TESTDIR}/TestFiles/f3: ${TESTDIR}/tests/defaultMemTest.o ${OBJECTFILES:%.o=%_nomain.o}
180 | 	${MKDIR} -p ${TESTDIR}/TestFiles
181 | 	${LINK.cc}   -o ${TESTDIR}/TestFiles/f3 $^ ${LDLIBSOPTIONS} 
182 | 
183 | ${TESTDIR}/TestFiles/f6: ${TESTDIR}/tests/newsimpletest5.o ${OBJECTFILES:%.o=%_nomain.o}
184 | 	${MKDIR} -p ${TESTDIR}/TestFiles
185 | 	${LINK.cc}   -o ${TESTDIR}/TestFiles/f6 $^ ${LDLIBSOPTIONS} 
186 | 
187 | ${TESTDIR}/TestFiles/f4: ${TESTDIR}/tests/newsimpletest3.o ${OBJECTFILES:%.o=%_nomain.o}
188 | 	${MKDIR} -p ${TESTDIR}/TestFiles
189 | 	${LINK.cc}   -o ${TESTDIR}/TestFiles/f4 $^ ${LDLIBSOPTIONS} 
190 | 
191 | ${TESTDIR}/TestFiles/f7: ${TESTDIR}/tests/TestEpoll.o ${OBJECTFILES:%.o=%_nomain.o}
192 | 	${MKDIR} -p ${TESTDIR}/TestFiles
193 | 	${LINK.cc}   -o ${TESTDIR}/TestFiles/f7 $^ ${LDLIBSOPTIONS} 
194 | 
195 | ${TESTDIR}/TestFiles/f1: ${TESTDIR}/tests/newsimpletest.o ${OBJECTFILES:%.o=%_nomain.o}
196 | 	${MKDIR} -p ${TESTDIR}/TestFiles
197 | 	${LINK.cc}   -o ${TESTDIR}/TestFiles/f1 $^ ${LDLIBSOPTIONS} 
198 | 
199 | ${TESTDIR}/TestFiles/f9: ${TESTDIR}/tests/TestTcpEpollClient.o ${OBJECTFILES:%.o=%_nomain.o}
200 | 	${MKDIR} -p ${TESTDIR}/TestFiles
201 | 	${LINK.cc}   -o ${TESTDIR}/TestFiles/f9 $^ ${LDLIBSOPTIONS} 
202 | 
203 | ${TESTDIR}/TestFiles/f5: ${TESTDIR}/tests/newsimpletest4.o ${OBJECTFILES:%.o=%_nomain.o}
204 | 	${MKDIR} -p ${TESTDIR}/TestFiles
205 | 	${LINK.cc}   -o ${TESTDIR}/TestFiles/f5 $^ ${LDLIBSOPTIONS} 
206 | 
207 | ${TESTDIR}/TestFiles/f2: ${TESTDIR}/tests/TestThreadPoolandMemPoolself.o ${OBJECTFILES:%.o=%_nomain.o}
208 | 	${MKDIR} -p ${TESTDIR}/TestFiles
209 | 	${LINK.cc}   -o ${TESTDIR}/TestFiles/f2 $^ ${LDLIBSOPTIONS} -lcunit 
210 | 
211 | 
212 | ${TESTDIR}/tests/BoostMemPoolTest.o: tests/BoostMemPoolTest.cpp 
213 | 	${MKDIR} -p ${TESTDIR}/tests
214 | 	${RM} "$@.d"
215 | 	$(COMPILE.cc) -O2 -I. -MMD -MP -MF "$@.d" -o ${TESTDIR}/tests/BoostMemPoolTest.o tests/BoostMemPoolTest.cpp
216 | 
217 | 
218 | ${TESTDIR}/tests/defaultMemTest.o: tests/defaultMemTest.cpp 
219 | 	${MKDIR} -p ${TESTDIR}/tests
220 | 	${RM} "$@.d"
221 | 	$(COMPILE.cc) -O2 -I. -MMD -MP -MF "$@.d" -o ${TESTDIR}/tests/defaultMemTest.o tests/defaultMemTest.cpp
222 | 
223 | 
224 | ${TESTDIR}/tests/newsimpletest5.o: tests/newsimpletest5.cpp 
225 | 	${MKDIR} -p ${TESTDIR}/tests
226 | 	${RM} "$@.d"
227 | 	$(COMPILE.cc) -O2 -I. -MMD -MP -MF "$@.d" -o ${TESTDIR}/tests/newsimpletest5.o tests/newsimpletest5.cpp
228 | 
229 | 
230 | ${TESTDIR}/tests/newsimpletest3.o: tests/newsimpletest3.cpp 
231 | 	${MKDIR} -p ${TESTDIR}/tests
232 | 	${RM} "$@.d"
233 | 	$(COMPILE.cc) -O2 -I. -MMD -MP -MF "$@.d" -o ${TESTDIR}/tests/newsimpletest3.o tests/newsimpletest3.cpp
234 | 
235 | 
236 | ${TESTDIR}/tests/TestEpoll.o: tests/TestEpoll.cpp 
237 | 	${MKDIR} -p ${TESTDIR}/tests
238 | 	${RM} "$@.d"
239 | 	$(COMPILE.cc) -O2 -I. -MMD -MP -MF "$@.d" -o ${TESTDIR}/tests/TestEpoll.o tests/TestEpoll.cpp
240 | 
241 | 
242 | ${TESTDIR}/tests/newsimpletest.o: tests/newsimpletest.cpp 
243 | 	${MKDIR} -p ${TESTDIR}/tests
244 | 	${RM} "$@.d"
245 | 	$(COMPILE.cc) -O2 -I. -MMD -MP -MF "$@.d" -o ${TESTDIR}/tests/newsimpletest.o tests/newsimpletest.cpp
246 | 
247 | 
248 | ${TESTDIR}/tests/TestTcpEpollClient.o: tests/TestTcpEpollClient.cpp 
249 | 	${MKDIR} -p ${TESTDIR}/tests
250 | 	${RM} "$@.d"
251 | 	$(COMPILE.cc) -O2 -I. -MMD -MP -MF "$@.d" -o ${TESTDIR}/tests/TestTcpEpollClient.o tests/TestTcpEpollClient.cpp
252 | 
253 | 
254 | ${TESTDIR}/tests/newsimpletest4.o: tests/newsimpletest4.cpp 
255 | 	${MKDIR} -p ${TESTDIR}/tests
256 | 	${RM} "$@.d"
257 | 	$(COMPILE.cc) -O2 -I. -MMD -MP -MF "$@.d" -o ${TESTDIR}/tests/newsimpletest4.o tests/newsimpletest4.cpp
258 | 
259 | 
260 | ${TESTDIR}/tests/TestThreadPoolandMemPoolself.o: tests/TestThreadPoolandMemPoolself.cpp 
261 | 	${MKDIR} -p ${TESTDIR}/tests
262 | 	${RM} "$@.d"
263 | 	$(COMPILE.cc) -O2 -I. -MMD -MP -MF "$@.d" -o ${TESTDIR}/tests/TestThreadPoolandMemPoolself.o tests/TestThreadPoolandMemPoolself.cpp
264 | 
265 | 
266 | ${OBJECTDIR}/CommServer_nomain.o: ${OBJECTDIR}/CommServer.o CommServer.cpp 
267 | 	${MKDIR} -p ${OBJECTDIR}
268 | 	@NMOUTPUT=`${NM} ${OBJECTDIR}/CommServer.o`; \
269 | 	if (echo "$$NMOUTPUT" | ${GREP} '|main$$') || \
270 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T main$$') || \
271 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T _main$$'); \
272 | 	then  \
273 | 	    ${RM} "$@.d";\
274 | 	    $(COMPILE.cc) -O2 -Dmain=__nomain -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/CommServer_nomain.o CommServer.cpp;\
275 | 	else  \
276 | 	    ${CP} ${OBJECTDIR}/CommServer.o ${OBJECTDIR}/CommServer_nomain.o;\
277 | 	fi
278 | 
279 | ${OBJECTDIR}/Epoll_nomain.o: ${OBJECTDIR}/Epoll.o Epoll.cpp 
280 | 	${MKDIR} -p ${OBJECTDIR}
281 | 	@NMOUTPUT=`${NM} ${OBJECTDIR}/Epoll.o`; \
282 | 	if (echo "$$NMOUTPUT" | ${GREP} '|main$$') || \
283 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T main$$') || \
284 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T _main$$'); \
285 | 	then  \
286 | 	    ${RM} "$@.d";\
287 | 	    $(COMPILE.cc) -O2 -Dmain=__nomain -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/Epoll_nomain.o Epoll.cpp;\
288 | 	else  \
289 | 	    ${CP} ${OBJECTDIR}/Epoll.o ${OBJECTDIR}/Epoll_nomain.o;\
290 | 	fi
291 | 
292 | ${OBJECTDIR}/Lock_nomain.o: ${OBJECTDIR}/Lock.o Lock.cpp 
293 | 	${MKDIR} -p ${OBJECTDIR}
294 | 	@NMOUTPUT=`${NM} ${OBJECTDIR}/Lock.o`; \
295 | 	if (echo "$$NMOUTPUT" | ${GREP} '|main$$') || \
296 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T main$$') || \
297 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T _main$$'); \
298 | 	then  \
299 | 	    ${RM} "$@.d";\
300 | 	    $(COMPILE.cc) -O2 -Dmain=__nomain -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/Lock_nomain.o Lock.cpp;\
301 | 	else  \
302 | 	    ${CP} ${OBJECTDIR}/Lock.o ${OBJECTDIR}/Lock_nomain.o;\
303 | 	fi
304 | 
305 | ${OBJECTDIR}/MemPool_nomain.o: ${OBJECTDIR}/MemPool.o MemPool.cpp 
306 | 	${MKDIR} -p ${OBJECTDIR}
307 | 	@NMOUTPUT=`${NM} ${OBJECTDIR}/MemPool.o`; \
308 | 	if (echo "$$NMOUTPUT" | ${GREP} '|main$$') || \
309 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T main$$') || \
310 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T _main$$'); \
311 | 	then  \
312 | 	    ${RM} "$@.d";\
313 | 	    $(COMPILE.cc) -O2 -Dmain=__nomain -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/MemPool_nomain.o MemPool.cpp;\
314 | 	else  \
315 | 	    ${CP} ${OBJECTDIR}/MemPool.o ${OBJECTDIR}/MemPool_nomain.o;\
316 | 	fi
317 | 
318 | ${OBJECTDIR}/Parser_nomain.o: ${OBJECTDIR}/Parser.o Parser.cpp 
319 | 	${MKDIR} -p ${OBJECTDIR}
320 | 	@NMOUTPUT=`${NM} ${OBJECTDIR}/Parser.o`; \
321 | 	if (echo "$$NMOUTPUT" | ${GREP} '|main$$') || \
322 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T main$$') || \
323 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T _main$$'); \
324 | 	then  \
325 | 	    ${RM} "$@.d";\
326 | 	    $(COMPILE.cc) -O2 -Dmain=__nomain -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/Parser_nomain.o Parser.cpp;\
327 | 	else  \
328 | 	    ${CP} ${OBJECTDIR}/Parser.o ${OBJECTDIR}/Parser_nomain.o;\
329 | 	fi
330 | 
331 | ${OBJECTDIR}/Semaphore_nomain.o: ${OBJECTDIR}/Semaphore.o Semaphore.cpp 
332 | 	${MKDIR} -p ${OBJECTDIR}
333 | 	@NMOUTPUT=`${NM} ${OBJECTDIR}/Semaphore.o`; \
334 | 	if (echo "$$NMOUTPUT" | ${GREP} '|main$$') || \
335 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T main$$') || \
336 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T _main$$'); \
337 | 	then  \
338 | 	    ${RM} "$@.d";\
339 | 	    $(COMPILE.cc) -O2 -Dmain=__nomain -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/Semaphore_nomain.o Semaphore.cpp;\
340 | 	else  \
341 | 	    ${CP} ${OBJECTDIR}/Semaphore.o ${OBJECTDIR}/Semaphore_nomain.o;\
342 | 	fi
343 | 
344 | ${OBJECTDIR}/Sock_nomain.o: ${OBJECTDIR}/Sock.o Sock.cpp 
345 | 	${MKDIR} -p ${OBJECTDIR}
346 | 	@NMOUTPUT=`${NM} ${OBJECTDIR}/Sock.o`; \
347 | 	if (echo "$$NMOUTPUT" | ${GREP} '|main$$') || \
348 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T main$$') || \
349 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T _main$$'); \
350 | 	then  \
351 | 	    ${RM} "$@.d";\
352 | 	    $(COMPILE.cc) -O2 -Dmain=__nomain -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/Sock_nomain.o Sock.cpp;\
353 | 	else  \
354 | 	    ${CP} ${OBJECTDIR}/Sock.o ${OBJECTDIR}/Sock_nomain.o;\
355 | 	fi
356 | 
357 | ${OBJECTDIR}/TcpEpollClient_nomain.o: ${OBJECTDIR}/TcpEpollClient.o TcpEpollClient.cpp 
358 | 	${MKDIR} -p ${OBJECTDIR}
359 | 	@NMOUTPUT=`${NM} ${OBJECTDIR}/TcpEpollClient.o`; \
360 | 	if (echo "$$NMOUTPUT" | ${GREP} '|main$$') || \
361 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T main$$') || \
362 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T _main$$'); \
363 | 	then  \
364 | 	    ${RM} "$@.d";\
365 | 	    $(COMPILE.cc) -O2 -Dmain=__nomain -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/TcpEpollClient_nomain.o TcpEpollClient.cpp;\
366 | 	else  \
367 | 	    ${CP} ${OBJECTDIR}/TcpEpollClient.o ${OBJECTDIR}/TcpEpollClient_nomain.o;\
368 | 	fi
369 | 
370 | ${OBJECTDIR}/TcpEpollServer_nomain.o: ${OBJECTDIR}/TcpEpollServer.o TcpEpollServer.cpp 
371 | 	${MKDIR} -p ${OBJECTDIR}
372 | 	@NMOUTPUT=`${NM} ${OBJECTDIR}/TcpEpollServer.o`; \
373 | 	if (echo "$$NMOUTPUT" | ${GREP} '|main$$') || \
374 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T main$$') || \
375 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T _main$$'); \
376 | 	then  \
377 | 	    ${RM} "$@.d";\
378 | 	    $(COMPILE.cc) -O2 -Dmain=__nomain -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/TcpEpollServer_nomain.o TcpEpollServer.cpp;\
379 | 	else  \
380 | 	    ${CP} ${OBJECTDIR}/TcpEpollServer.o ${OBJECTDIR}/TcpEpollServer_nomain.o;\
381 | 	fi
382 | 
383 | ${OBJECTDIR}/TcpSock_nomain.o: ${OBJECTDIR}/TcpSock.o TcpSock.cpp 
384 | 	${MKDIR} -p ${OBJECTDIR}
385 | 	@NMOUTPUT=`${NM} ${OBJECTDIR}/TcpSock.o`; \
386 | 	if (echo "$$NMOUTPUT" | ${GREP} '|main$$') || \
387 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T main$$') || \
388 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T _main$$'); \
389 | 	then  \
390 | 	    ${RM} "$@.d";\
391 | 	    $(COMPILE.cc) -O2 -Dmain=__nomain -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/TcpSock_nomain.o TcpSock.cpp;\
392 | 	else  \
393 | 	    ${CP} ${OBJECTDIR}/TcpSock.o ${OBJECTDIR}/TcpSock_nomain.o;\
394 | 	fi
395 | 
396 | ${OBJECTDIR}/Thread_nomain.o: ${OBJECTDIR}/Thread.o Thread.cpp 
397 | 	${MKDIR} -p ${OBJECTDIR}
398 | 	@NMOUTPUT=`${NM} ${OBJECTDIR}/Thread.o`; \
399 | 	if (echo "$$NMOUTPUT" | ${GREP} '|main$$') || \
400 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T main$$') || \
401 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T _main$$'); \
402 | 	then  \
403 | 	    ${RM} "$@.d";\
404 | 	    $(COMPILE.cc) -O2 -Dmain=__nomain -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/Thread_nomain.o Thread.cpp;\
405 | 	else  \
406 | 	    ${CP} ${OBJECTDIR}/Thread.o ${OBJECTDIR}/Thread_nomain.o;\
407 | 	fi
408 | 
409 | ${OBJECTDIR}/ThreadLoop_nomain.o: ${OBJECTDIR}/ThreadLoop.o ThreadLoop.cpp 
410 | 	${MKDIR} -p ${OBJECTDIR}
411 | 	@NMOUTPUT=`${NM} ${OBJECTDIR}/ThreadLoop.o`; \
412 | 	if (echo "$$NMOUTPUT" | ${GREP} '|main$$') || \
413 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T main$$') || \
414 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T _main$$'); \
415 | 	then  \
416 | 	    ${RM} "$@.d";\
417 | 	    $(COMPILE.cc) -O2 -Dmain=__nomain -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/ThreadLoop_nomain.o ThreadLoop.cpp;\
418 | 	else  \
419 | 	    ${CP} ${OBJECTDIR}/ThreadLoop.o ${OBJECTDIR}/ThreadLoop_nomain.o;\
420 | 	fi
421 | 
422 | ${OBJECTDIR}/ThreadPool_nomain.o: ${OBJECTDIR}/ThreadPool.o ThreadPool.cpp 
423 | 	${MKDIR} -p ${OBJECTDIR}
424 | 	@NMOUTPUT=`${NM} ${OBJECTDIR}/ThreadPool.o`; \
425 | 	if (echo "$$NMOUTPUT" | ${GREP} '|main$$') || \
426 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T main$$') || \
427 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T _main$$'); \
428 | 	then  \
429 | 	    ${RM} "$@.d";\
430 | 	    $(COMPILE.cc) -O2 -Dmain=__nomain -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/ThreadPool_nomain.o ThreadPool.cpp;\
431 | 	else  \
432 | 	    ${CP} ${OBJECTDIR}/ThreadPool.o ${OBJECTDIR}/ThreadPool_nomain.o;\
433 | 	fi
434 | 
435 | ${OBJECTDIR}/Time_nomain.o: ${OBJECTDIR}/Time.o Time.cpp 
436 | 	${MKDIR} -p ${OBJECTDIR}
437 | 	@NMOUTPUT=`${NM} ${OBJECTDIR}/Time.o`; \
438 | 	if (echo "$$NMOUTPUT" | ${GREP} '|main$$') || \
439 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T main$$') || \
440 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T _main$$'); \
441 | 	then  \
442 | 	    ${RM} "$@.d";\
443 | 	    $(COMPILE.cc) -O2 -Dmain=__nomain -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/Time_nomain.o Time.cpp;\
444 | 	else  \
445 | 	    ${CP} ${OBJECTDIR}/Time.o ${OBJECTDIR}/Time_nomain.o;\
446 | 	fi
447 | 
448 | ${OBJECTDIR}/TimeSpan_nomain.o: ${OBJECTDIR}/TimeSpan.o TimeSpan.cpp 
449 | 	${MKDIR} -p ${OBJECTDIR}
450 | 	@NMOUTPUT=`${NM} ${OBJECTDIR}/TimeSpan.o`; \
451 | 	if (echo "$$NMOUTPUT" | ${GREP} '|main$$') || \
452 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T main$$') || \
453 | 	   (echo "$$NMOUTPUT" | ${GREP} 'T _main$$'); \
454 | 	then  \
455 | 	    ${RM} "$@.d";\
456 | 	    $(COMPILE.cc) -O2 -Dmain=__nomain -MMD -MP -MF "$@.d" -o ${OBJECTDIR}/TimeSpan_nomain.o TimeSpan.cpp;\
457 | 	else  \
458 | 	    ${CP} ${OBJECTDIR}/TimeSpan.o ${OBJECTDIR}/TimeSpan_nomain.o;\
459 | 	fi
460 | 
461 | # Run Test Targets
462 | .test-conf:
463 | 	@if [ "${TEST}" = "" ]; \
464 | 	then  \
465 | 	    ${TESTDIR}/TestFiles/f8 || true; \
466 | 	    ${TESTDIR}/TestFiles/f3 || true; \
467 | 	    ${TESTDIR}/TestFiles/f6 || true; \
468 | 	    ${TESTDIR}/TestFiles/f4 || true; \
469 | 	    ${TESTDIR}/TestFiles/f7 || true; \
470 | 	    ${TESTDIR}/TestFiles/f1 || true; \
471 | 	    ${TESTDIR}/TestFiles/f9 || true; \
472 | 	    ${TESTDIR}/TestFiles/f5 || true; \
473 | 	    ${TESTDIR}/TestFiles/f2 || true; \
474 | 	else  \
475 | 	    ./${TEST} || true; \
476 | 	fi
477 | 
478 | # Clean Targets
479 | .clean-conf: ${CLEAN_SUBPROJECTS}
480 | 	${RM} -r ${CND_BUILDDIR}/${CND_CONF}
481 | 	${RM} ${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM}/libgithub.a
482 | 
483 | # Subprojects
484 | .clean-subprojects:
485 | 
486 | # Enable dependency checking
487 | .dep.inc: .depcheck-impl
488 | 
489 | include .dep.inc
490 | 


--------------------------------------------------------------------------------
/nbproject/Makefile-impl.mk:
--------------------------------------------------------------------------------
  1 | # 
  2 | # Generated Makefile - do not edit! 
  3 | # 
  4 | # Edit the Makefile in the project folder instead (../Makefile). Each target
  5 | # has a pre- and a post- target defined where you can add customization code.
  6 | #
  7 | # This makefile implements macros and targets common to all configurations.
  8 | #
  9 | # NOCDDL
 10 | 
 11 | 
 12 | # Building and Cleaning subprojects are done by default, but can be controlled with the SUB
 13 | # macro. If SUB=no, subprojects will not be built or cleaned. The following macro
 14 | # statements set BUILD_SUB-CONF and CLEAN_SUB-CONF to .build-reqprojects-conf
 15 | # and .clean-reqprojects-conf unless SUB has the value 'no'
 16 | SUB_no=NO
 17 | SUBPROJECTS=${SUB_${SUB}}
 18 | BUILD_SUBPROJECTS_=.build-subprojects
 19 | BUILD_SUBPROJECTS_NO=
 20 | BUILD_SUBPROJECTS=${BUILD_SUBPROJECTS_${SUBPROJECTS}}
 21 | CLEAN_SUBPROJECTS_=.clean-subprojects
 22 | CLEAN_SUBPROJECTS_NO=
 23 | CLEAN_SUBPROJECTS=${CLEAN_SUBPROJECTS_${SUBPROJECTS}}
 24 | 
 25 | 
 26 | # Project Name
 27 | PROJECTNAME=GitHub
 28 | 
 29 | # Active Configuration
 30 | DEFAULTCONF=Debug
 31 | CONF=${DEFAULTCONF}
 32 | 
 33 | # All Configurations
 34 | ALLCONFS=Debug Release 
 35 | 
 36 | 
 37 | # build
 38 | .build-impl: .build-pre .validate-impl .depcheck-impl
 39 | 	@#echo "=> Running $@... Configuration=$(CONF)"
 40 | 	"${MAKE}" -f nbproject/Makefile-${CONF}.mk QMAKE=${QMAKE} SUBPROJECTS=${SUBPROJECTS} .build-conf
 41 | 
 42 | 
 43 | # clean
 44 | .clean-impl: .clean-pre .validate-impl .depcheck-impl
 45 | 	@#echo "=> Running $@... Configuration=$(CONF)"
 46 | 	"${MAKE}" -f nbproject/Makefile-${CONF}.mk QMAKE=${QMAKE} SUBPROJECTS=${SUBPROJECTS} .clean-conf
 47 | 
 48 | 
 49 | # clobber 
 50 | .clobber-impl: .clobber-pre .depcheck-impl
 51 | 	@#echo "=> Running $@..."
 52 | 	for CONF in ${ALLCONFS}; \
 53 | 	do \
 54 | 	    "${MAKE}" -f nbproject/Makefile-$${CONF}.mk QMAKE=${QMAKE} SUBPROJECTS=${SUBPROJECTS} .clean-conf; \
 55 | 	done
 56 | 
 57 | # all 
 58 | .all-impl: .all-pre .depcheck-impl
 59 | 	@#echo "=> Running $@..."
 60 | 	for CONF in ${ALLCONFS}; \
 61 | 	do \
 62 | 	    "${MAKE}" -f nbproject/Makefile-$${CONF}.mk QMAKE=${QMAKE} SUBPROJECTS=${SUBPROJECTS} .build-conf; \
 63 | 	done
 64 | 
 65 | # build tests
 66 | .build-tests-impl: .build-impl .build-tests-pre
 67 | 	@#echo "=> Running $@... Configuration=$(CONF)"
 68 | 	"${MAKE}" -f nbproject/Makefile-${CONF}.mk SUBPROJECTS=${SUBPROJECTS} .build-tests-conf
 69 | 
 70 | # run tests
 71 | .test-impl: .build-tests-impl .test-pre
 72 | 	@#echo "=> Running $@... Configuration=$(CONF)"
 73 | 	"${MAKE}" -f nbproject/Makefile-${CONF}.mk SUBPROJECTS=${SUBPROJECTS} .test-conf
 74 | 
 75 | # dependency checking support
 76 | .depcheck-impl:
 77 | 	@echo "# This code depends on make tool being used" >.dep.inc
 78 | 	@if [ -n "${MAKE_VERSION}" ]; then \
 79 | 	    echo "DEPFILES=\$$(wildcard \$$(addsuffix .d, \$${OBJECTFILES}))" >>.dep.inc; \
 80 | 	    echo "ifneq (\$${DEPFILES},)" >>.dep.inc; \
 81 | 	    echo "include \$${DEPFILES}" >>.dep.inc; \
 82 | 	    echo "endif" >>.dep.inc; \
 83 | 	else \
 84 | 	    echo ".KEEP_STATE:" >>.dep.inc; \
 85 | 	    echo ".KEEP_STATE_FILE:.make.state.\$${CONF}" >>.dep.inc; \
 86 | 	fi
 87 | 
 88 | # configuration validation
 89 | .validate-impl:
 90 | 	@if [ ! -f nbproject/Makefile-${CONF}.mk ]; \
 91 | 	then \
 92 | 	    echo ""; \
 93 | 	    echo "Error: can not find the makefile for configuration '${CONF}' in project ${PROJECTNAME}"; \
 94 | 	    echo "See 'make help' for details."; \
 95 | 	    echo "Current directory: " `pwd`; \
 96 | 	    echo ""; \
 97 | 	fi
 98 | 	@if [ ! -f nbproject/Makefile-${CONF}.mk ]; \
 99 | 	then \
100 | 	    exit 1; \
101 | 	fi
102 | 
103 | 
104 | # help
105 | .help-impl: .help-pre
106 | 	@echo "This makefile supports the following configurations:"
107 | 	@echo "    ${ALLCONFS}"
108 | 	@echo ""
109 | 	@echo "and the following targets:"
110 | 	@echo "    build  (default target)"
111 | 	@echo "    clean"
112 | 	@echo "    clobber"
113 | 	@echo "    all"
114 | 	@echo "    help"
115 | 	@echo ""
116 | 	@echo "Makefile Usage:"
117 | 	@echo "    make [CONF=<CONFIGURATION>] [SUB=no] build"
118 | 	@echo "    make [CONF=<CONFIGURATION>] [SUB=no] clean"
119 | 	@echo "    make [SUB=no] clobber"
120 | 	@echo "    make [SUB=no] all"
121 | 	@echo "    make help"
122 | 	@echo ""
123 | 	@echo "Target 'build' will build a specific configuration and, unless 'SUB=no',"
124 | 	@echo "    also build subprojects."
125 | 	@echo "Target 'clean' will clean a specific configuration and, unless 'SUB=no',"
126 | 	@echo "    also clean subprojects."
127 | 	@echo "Target 'clobber' will remove all built files from all configurations and,"
128 | 	@echo "    unless 'SUB=no', also from subprojects."
129 | 	@echo "Target 'all' will will build all configurations and, unless 'SUB=no',"
130 | 	@echo "    also build subprojects."
131 | 	@echo "Target 'help' prints this message."
132 | 	@echo ""
133 | 
134 | 


--------------------------------------------------------------------------------
/nbproject/Makefile-variables.mk:
--------------------------------------------------------------------------------
 1 | #
 2 | # Generated - do not edit!
 3 | #
 4 | # NOCDDL
 5 | #
 6 | CND_BASEDIR=`pwd`
 7 | CND_BUILDDIR=build
 8 | CND_DISTDIR=dist
 9 | # Debug configuration
10 | CND_PLATFORM_Debug=GNU-Linux-x86
11 | CND_ARTIFACT_DIR_Debug=dist/Debug/GNU-Linux-x86
12 | CND_ARTIFACT_NAME_Debug=libgithub.a
13 | CND_ARTIFACT_PATH_Debug=dist/Debug/GNU-Linux-x86/libgithub.a
14 | CND_PACKAGE_DIR_Debug=dist/Debug/GNU-Linux-x86/package
15 | CND_PACKAGE_NAME_Debug=GitHub.tar
16 | CND_PACKAGE_PATH_Debug=dist/Debug/GNU-Linux-x86/package/GitHub.tar
17 | # Release configuration
18 | CND_PLATFORM_Release=MinGW-Windows
19 | CND_ARTIFACT_DIR_Release=dist/Release/MinGW-Windows
20 | CND_ARTIFACT_NAME_Release=libgithub.a
21 | CND_ARTIFACT_PATH_Release=dist/Release/MinGW-Windows/libgithub.a
22 | CND_PACKAGE_DIR_Release=dist/Release/MinGW-Windows/package
23 | CND_PACKAGE_NAME_Release=GitHub.tar
24 | CND_PACKAGE_PATH_Release=dist/Release/MinGW-Windows/package/GitHub.tar
25 | #
26 | # include compiler specific variables
27 | #
28 | # dmake command
29 | ROOT:sh = test -f nbproject/private/Makefile-variables.mk || \
30 | 	(mkdir -p nbproject/private && touch nbproject/private/Makefile-variables.mk)
31 | #
32 | # gmake command
33 | .PHONY: $(shell test -f nbproject/private/Makefile-variables.mk || (mkdir -p nbproject/private && touch nbproject/private/Makefile-variables.mk))
34 | #
35 | include nbproject/private/Makefile-variables.mk
36 | 


--------------------------------------------------------------------------------
/nbproject/Package-Debug.bash:
--------------------------------------------------------------------------------
 1 | #!/bin/bash -x
 2 | 
 3 | #
 4 | # Generated - do not edit!
 5 | #
 6 | 
 7 | # Macros
 8 | TOP=`pwd`
 9 | CND_PLATFORM=GNU-Linux-x86
10 | CND_CONF=Debug
11 | CND_DISTDIR=dist
12 | CND_BUILDDIR=build
13 | CND_DLIB_EXT=so
14 | NBTMPDIR=${CND_BUILDDIR}/${CND_CONF}/${CND_PLATFORM}/tmp-packaging
15 | TMPDIRNAME=tmp-packaging
16 | OUTPUT_PATH=${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM}/libgithub.a
17 | OUTPUT_BASENAME=libgithub.a
18 | PACKAGE_TOP_DIR=GitHub/
19 | 
20 | # Functions
21 | function checkReturnCode
22 | {
23 |     rc=$?
24 |     if [ $rc != 0 ]
25 |     then
26 |         exit $rc
27 |     fi
28 | }
29 | function makeDirectory
30 | # $1 directory path
31 | # $2 permission (optional)
32 | {
33 |     mkdir -p "$1"
34 |     checkReturnCode
35 |     if [ "$2" != "" ]
36 |     then
37 |       chmod $2 "$1"
38 |       checkReturnCode
39 |     fi
40 | }
41 | function copyFileToTmpDir
42 | # $1 from-file path
43 | # $2 to-file path
44 | # $3 permission
45 | {
46 |     cp "$1" "$2"
47 |     checkReturnCode
48 |     if [ "$3" != "" ]
49 |     then
50 |         chmod $3 "$2"
51 |         checkReturnCode
52 |     fi
53 | }
54 | 
55 | # Setup
56 | cd "${TOP}"
57 | mkdir -p ${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM}/package
58 | rm -rf ${NBTMPDIR}
59 | mkdir -p ${NBTMPDIR}
60 | 
61 | # Copy files and create directories and links
62 | cd "${TOP}"
63 | makeDirectory "${NBTMPDIR}/GitHub/lib"
64 | copyFileToTmpDir "${OUTPUT_PATH}" "${NBTMPDIR}/${PACKAGE_TOP_DIR}lib/${OUTPUT_BASENAME}" 0644
65 | 
66 | 
67 | # Generate tar file
68 | cd "${TOP}"
69 | rm -f ${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM}/package/GitHub.tar
70 | cd ${NBTMPDIR}
71 | tar -vcf ../../../../${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM}/package/GitHub.tar *
72 | checkReturnCode
73 | 
74 | # Cleanup
75 | cd "${TOP}"
76 | rm -rf ${NBTMPDIR}
77 | 


--------------------------------------------------------------------------------
/nbproject/Package-Release.bash:
--------------------------------------------------------------------------------
 1 | #!/bin/bash -x
 2 | 
 3 | #
 4 | # Generated - do not edit!
 5 | #
 6 | 
 7 | # Macros
 8 | TOP=`pwd`
 9 | CND_PLATFORM=MinGW-Windows
10 | CND_CONF=Release
11 | CND_DISTDIR=dist
12 | CND_BUILDDIR=build
13 | CND_DLIB_EXT=dll
14 | NBTMPDIR=${CND_BUILDDIR}/${CND_CONF}/${CND_PLATFORM}/tmp-packaging
15 | TMPDIRNAME=tmp-packaging
16 | OUTPUT_PATH=${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM}/libgithub.a
17 | OUTPUT_BASENAME=libgithub.a
18 | PACKAGE_TOP_DIR=GitHub/
19 | 
20 | # Functions
21 | function checkReturnCode
22 | {
23 |     rc=$?
24 |     if [ $rc != 0 ]
25 |     then
26 |         exit $rc
27 |     fi
28 | }
29 | function makeDirectory
30 | # $1 directory path
31 | # $2 permission (optional)
32 | {
33 |     mkdir -p "$1"
34 |     checkReturnCode
35 |     if [ "$2" != "" ]
36 |     then
37 |       chmod $2 "$1"
38 |       checkReturnCode
39 |     fi
40 | }
41 | function copyFileToTmpDir
42 | # $1 from-file path
43 | # $2 to-file path
44 | # $3 permission
45 | {
46 |     cp "$1" "$2"
47 |     checkReturnCode
48 |     if [ "$3" != "" ]
49 |     then
50 |         chmod $3 "$2"
51 |         checkReturnCode
52 |     fi
53 | }
54 | 
55 | # Setup
56 | cd "${TOP}"
57 | mkdir -p ${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM}/package
58 | rm -rf ${NBTMPDIR}
59 | mkdir -p ${NBTMPDIR}
60 | 
61 | # Copy files and create directories and links
62 | cd "${TOP}"
63 | makeDirectory "${NBTMPDIR}/GitHub/lib"
64 | copyFileToTmpDir "${OUTPUT_PATH}" "${NBTMPDIR}/${PACKAGE_TOP_DIR}lib/${OUTPUT_BASENAME}" 0644
65 | 
66 | 
67 | # Generate tar file
68 | cd "${TOP}"
69 | rm -f ${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM}/package/GitHub.tar
70 | cd ${NBTMPDIR}
71 | tar -vcf ../../../../${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM}/package/GitHub.tar *
72 | checkReturnCode
73 | 
74 | # Cleanup
75 | cd "${TOP}"
76 | rm -rf ${NBTMPDIR}
77 | 


--------------------------------------------------------------------------------
/nbproject/configurations.xml:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="UTF-8"?>
  2 | <configurationDescriptor version="90">
  3 |   <logicalFolder name="root" displayName="root" projectFiles="true" kind="ROOT">
  4 |     <logicalFolder name="HeaderFiles" displayName="头文件" projectFiles="true">
  5 |       <itemPath>CommServer.h</itemPath>
  6 |       <itemPath>Epoll.h</itemPath>
  7 |       <itemPath>Lock.h</itemPath>
  8 |       <itemPath>MemPool.h</itemPath>
  9 |       <itemPath>Parser.h</itemPath>
 10 |       <itemPath>Semaphore.h</itemPath>
 11 |       <itemPath>Singleton.h</itemPath>
 12 |       <itemPath>Sock.h</itemPath>
 13 |       <itemPath>TcpEpollServer.h</itemPath>
 14 |       <itemPath>TcpSock.h</itemPath>
 15 |       <itemPath>Thread.h</itemPath>
 16 |       <itemPath>ThreadLoop.h</itemPath>
 17 |       <itemPath>ThreadPool.h</itemPath>
 18 |       <itemPath>Time.h</itemPath>
 19 |       <itemPath>TimeSpan.h</itemPath>
 20 |     </logicalFolder>
 21 |     <logicalFolder name="SourceFiles" displayName="源文件" projectFiles="true">
 22 |       <itemPath>CommServer.cpp</itemPath>
 23 |       <itemPath>Epoll.cpp</itemPath>
 24 |       <itemPath>Lock.cpp</itemPath>
 25 |       <itemPath>MemPool.cpp</itemPath>
 26 |       <itemPath>Parser.cpp</itemPath>
 27 |       <itemPath>Semaphore.cpp</itemPath>
 28 |       <itemPath>Sock.cpp</itemPath>
 29 |       <itemPath>TcpEpollServer.cpp</itemPath>
 30 |       <itemPath>TcpSock.cpp</itemPath>
 31 |       <itemPath>Thread.cpp</itemPath>
 32 |       <itemPath>ThreadLoop.cpp</itemPath>
 33 |       <itemPath>ThreadPool.cpp</itemPath>
 34 |       <itemPath>Time.cpp</itemPath>
 35 |       <itemPath>TimeSpan.cpp</itemPath>
 36 |     </logicalFolder>
 37 |     <logicalFolder name="ResourceFiles" displayName="资源文件" projectFiles="true">
 38 |     </logicalFolder>
 39 |     <logicalFolder name="TestFiles"
 40 |                    displayName="测试文件"
 41 |                    projectFiles="false"
 42 |                    kind="TEST_LOGICAL_FOLDER">
 43 |       <logicalFolder name="f8"
 44 |                      displayName="BoostMemPoolTest"
 45 |                      projectFiles="true"
 46 |                      kind="TEST">
 47 |         <itemPath>tests/BoostMemPoolTest.cpp</itemPath>
 48 |       </logicalFolder>
 49 |       <logicalFolder name="f3"
 50 |                      displayName="MemPoolTest"
 51 |                      projectFiles="true"
 52 |                      kind="TEST">
 53 |         <itemPath>tests/defaultMemTest.cpp</itemPath>
 54 |       </logicalFolder>
 55 |       <logicalFolder name="f6"
 56 |                      displayName="TestCopyable"
 57 |                      projectFiles="true"
 58 |                      kind="TEST">
 59 |         <itemPath>tests/newsimpletest5.cpp</itemPath>
 60 |       </logicalFolder>
 61 |       <logicalFolder name="f4"
 62 |                      displayName="TestCTime"
 63 |                      projectFiles="true"
 64 |                      kind="TEST">
 65 |         <itemPath>tests/newsimpletest3.cpp</itemPath>
 66 |       </logicalFolder>
 67 |       <logicalFolder name="f7"
 68 |                      displayName="TestEpoll"
 69 |                      projectFiles="true"
 70 |                      kind="TEST">
 71 |         <itemPath>tests/TestEpoll.cpp</itemPath>
 72 |       </logicalFolder>
 73 |       <logicalFolder name="f1"
 74 |                      displayName="TestMemPool"
 75 |                      projectFiles="true"
 76 |                      kind="TEST">
 77 |         <itemPath>tests/newsimpletest.cpp</itemPath>
 78 |       </logicalFolder>
 79 |       <logicalFolder name="f9"
 80 |                      displayName="TestTcpEpollClient"
 81 |                      projectFiles="true"
 82 |                      kind="TEST">
 83 |         <itemPath>tests/TestTcpEpollClient.cpp</itemPath>
 84 |       </logicalFolder>
 85 |       <logicalFolder name="f5"
 86 |                      displayName="TestThreadLoop"
 87 |                      projectFiles="true"
 88 |                      kind="TEST">
 89 |         <itemPath>tests/newsimpletest4.cpp</itemPath>
 90 |       </logicalFolder>
 91 |       <logicalFolder name="f2"
 92 |                      displayName="TestThreadPool"
 93 |                      projectFiles="true"
 94 |                      kind="TEST">
 95 |         <itemPath>tests/TestThreadPoolandMemPoolself.cpp</itemPath>
 96 |       </logicalFolder>
 97 |     </logicalFolder>
 98 |     <logicalFolder name="ExternalFiles"
 99 |                    displayName="重要文件"
100 |                    projectFiles="false"
101 |                    kind="IMPORTANT_FILES_FOLDER">
102 |       <itemPath>Makefile</itemPath>
103 |     </logicalFolder>
104 |     <itemPath>TcpEpollClient.cpp</itemPath>
105 |     <itemPath>TcpEpollClient.h</itemPath>
106 |   </logicalFolder>
107 |   <projectmakefile>Makefile</projectmakefile>
108 |   <confs>
109 |     <conf name="Debug" type="3">
110 |       <toolsSet>
111 |         <compilerSet>default</compilerSet>
112 |         <dependencyChecking>true</dependencyChecking>
113 |         <rebuildPropChanged>false</rebuildPropChanged>
114 |       </toolsSet>
115 |       <compileType>
116 |         <archiverTool>
117 |         </archiverTool>
118 |       </compileType>
119 |       <item path="CommServer.cpp" ex="false" tool="1" flavor2="0">
120 |       </item>
121 |       <item path="CommServer.h" ex="false" tool="3" flavor2="0">
122 |       </item>
123 |       <item path="Epoll.cpp" ex="false" tool="1" flavor2="0">
124 |       </item>
125 |       <item path="Epoll.h" ex="false" tool="3" flavor2="0">
126 |       </item>
127 |       <item path="Lock.cpp" ex="false" tool="1" flavor2="0">
128 |       </item>
129 |       <item path="Lock.h" ex="false" tool="3" flavor2="0">
130 |       </item>
131 |       <item path="MemPool.cpp" ex="false" tool="1" flavor2="0">
132 |       </item>
133 |       <item path="MemPool.h" ex="false" tool="3" flavor2="0">
134 |       </item>
135 |       <item path="Parser.cpp" ex="false" tool="1" flavor2="0">
136 |       </item>
137 |       <item path="Parser.h" ex="false" tool="3" flavor2="0">
138 |       </item>
139 |       <item path="Semaphore.cpp" ex="false" tool="1" flavor2="0">
140 |       </item>
141 |       <item path="Semaphore.h" ex="false" tool="3" flavor2="0">
142 |       </item>
143 |       <item path="Singleton.h" ex="false" tool="3" flavor2="0">
144 |       </item>
145 |       <item path="Sock.cpp" ex="false" tool="1" flavor2="0">
146 |       </item>
147 |       <item path="Sock.h" ex="false" tool="3" flavor2="0">
148 |       </item>
149 |       <item path="TcpEpollClient.cpp" ex="false" tool="1" flavor2="0">
150 |       </item>
151 |       <item path="TcpEpollClient.h" ex="false" tool="3" flavor2="0">
152 |       </item>
153 |       <item path="TcpEpollServer.cpp" ex="false" tool="1" flavor2="0">
154 |       </item>
155 |       <item path="TcpEpollServer.h" ex="false" tool="3" flavor2="0">
156 |       </item>
157 |       <item path="TcpSock.cpp" ex="false" tool="1" flavor2="0">
158 |       </item>
159 |       <item path="TcpSock.h" ex="false" tool="3" flavor2="0">
160 |       </item>
161 |       <item path="Thread.cpp" ex="false" tool="1" flavor2="0">
162 |       </item>
163 |       <item path="Thread.h" ex="false" tool="3" flavor2="0">
164 |       </item>
165 |       <item path="ThreadLoop.cpp" ex="false" tool="1" flavor2="0">
166 |       </item>
167 |       <item path="ThreadLoop.h" ex="false" tool="3" flavor2="0">
168 |       </item>
169 |       <item path="ThreadPool.cpp" ex="false" tool="1" flavor2="0">
170 |       </item>
171 |       <item path="ThreadPool.h" ex="false" tool="3" flavor2="0">
172 |       </item>
173 |       <item path="Time.cpp" ex="false" tool="1" flavor2="0">
174 |       </item>
175 |       <item path="Time.h" ex="false" tool="3" flavor2="0">
176 |       </item>
177 |       <item path="TimeSpan.cpp" ex="false" tool="1" flavor2="0">
178 |       </item>
179 |       <item path="TimeSpan.h" ex="false" tool="3" flavor2="0">
180 |       </item>
181 |       <folder path="TestFiles/f1">
182 |         <cTool>
183 |           <incDir>
184 |             <pElem>.</pElem>
185 |           </incDir>
186 |         </cTool>
187 |         <ccTool>
188 |           <incDir>
189 |             <pElem>.</pElem>
190 |           </incDir>
191 |         </ccTool>
192 |         <linkerTool>
193 |           <output>${TESTDIR}/TestFiles/TestMemPool</output>
194 |           <linkerLibItems>
195 |             <linkerLibStdlibItem>PosixThreads</linkerLibStdlibItem>
196 |           </linkerLibItems>
197 |         </linkerTool>
198 |       </folder>
199 |       <folder path="TestFiles/f2">
200 |         <cTool>
201 |           <incDir>
202 |             <pElem>.</pElem>
203 |           </incDir>
204 |         </cTool>
205 |         <ccTool>
206 |           <incDir>
207 |             <pElem>.</pElem>
208 |           </incDir>
209 |         </ccTool>
210 |         <linkerTool>
211 |           <output>${TESTDIR}/TestFiles/TestThreadPool</output>
212 |           <linkerLibItems>
213 |             <linkerLibStdlibItem>PosixThreads</linkerLibStdlibItem>
214 |           </linkerLibItems>
215 |         </linkerTool>
216 |       </folder>
217 |       <folder path="TestFiles/f3">
218 |         <cTool>
219 |           <incDir>
220 |             <pElem>.</pElem>
221 |           </incDir>
222 |         </cTool>
223 |         <ccTool>
224 |           <incDir>
225 |             <pElem>.</pElem>
226 |           </incDir>
227 |         </ccTool>
228 |         <linkerTool>
229 |           <output>${TESTDIR}/TestFiles/MemPoolTest</output>
230 |           <linkerLibItems>
231 |             <linkerLibStdlibItem>PosixThreads</linkerLibStdlibItem>
232 |           </linkerLibItems>
233 |         </linkerTool>
234 |       </folder>
235 |       <folder path="TestFiles/f4">
236 |         <cTool>
237 |           <incDir>
238 |             <pElem>.</pElem>
239 |           </incDir>
240 |         </cTool>
241 |         <ccTool>
242 |           <incDir>
243 |             <pElem>.</pElem>
244 |           </incDir>
245 |         </ccTool>
246 |         <linkerTool>
247 |           <output>${TESTDIR}/TestFiles/TestCTime</output>
248 |           <linkerLibItems>
249 |             <linkerLibStdlibItem>PosixThreads</linkerLibStdlibItem>
250 |           </linkerLibItems>
251 |         </linkerTool>
252 |       </folder>
253 |       <folder path="TestFiles/f5">
254 |         <cTool>
255 |           <incDir>
256 |             <pElem>.</pElem>
257 |           </incDir>
258 |         </cTool>
259 |         <ccTool>
260 |           <incDir>
261 |             <pElem>.</pElem>
262 |           </incDir>
263 |         </ccTool>
264 |         <linkerTool>
265 |           <output>${TESTDIR}/TestFiles/TestThreadLoop</output>
266 |           <linkerLibItems>
267 |             <linkerLibStdlibItem>PosixThreads</linkerLibStdlibItem>
268 |           </linkerLibItems>
269 |         </linkerTool>
270 |       </folder>
271 |       <folder path="TestFiles/f6">
272 |         <cTool>
273 |           <incDir>
274 |             <pElem>.</pElem>
275 |           </incDir>
276 |         </cTool>
277 |         <ccTool>
278 |           <incDir>
279 |             <pElem>.</pElem>
280 |           </incDir>
281 |         </ccTool>
282 |         <linkerTool>
283 |           <output>${TESTDIR}/TestFiles/TestCopyable</output>
284 |           <linkerLibItems>
285 |             <linkerLibStdlibItem>PosixThreads</linkerLibStdlibItem>
286 |           </linkerLibItems>
287 |         </linkerTool>
288 |       </folder>
289 |       <folder path="TestFiles/f7">
290 |         <cTool>
291 |           <incDir>
292 |             <pElem>.</pElem>
293 |           </incDir>
294 |         </cTool>
295 |         <ccTool>
296 |           <incDir>
297 |             <pElem>.</pElem>
298 |           </incDir>
299 |         </ccTool>
300 |         <linkerTool>
301 |           <output>${TESTDIR}/TestFiles/TestEpoll</output>
302 |           <linkerLibItems>
303 |             <linkerLibStdlibItem>PosixThreads</linkerLibStdlibItem>
304 |           </linkerLibItems>
305 |         </linkerTool>
306 |       </folder>
307 |       <folder path="TestFiles/f8">
308 |         <cTool>
309 |           <incDir>
310 |             <pElem>.</pElem>
311 |           </incDir>
312 |         </cTool>
313 |         <ccTool>
314 |           <incDir>
315 |             <pElem>.</pElem>
316 |           </incDir>
317 |         </ccTool>
318 |         <linkerTool>
319 |           <output>${TESTDIR}/TestFiles/BoostMemPoolTest</output>
320 |           <linkerLibItems>
321 |             <linkerLibStdlibItem>PosixThreads</linkerLibStdlibItem>
322 |           </linkerLibItems>
323 |         </linkerTool>
324 |       </folder>
325 |       <folder path="TestFiles/f9">
326 |         <cTool>
327 |           <incDir>
328 |             <pElem>.</pElem>
329 |           </incDir>
330 |         </cTool>
331 |         <ccTool>
332 |           <incDir>
333 |             <pElem>.</pElem>
334 |           </incDir>
335 |         </ccTool>
336 |         <linkerTool>
337 |           <output>${TESTDIR}/TestFiles/f9</output>
338 |           <linkerLibItems>
339 |             <linkerLibStdlibItem>PosixThreads</linkerLibStdlibItem>
340 |           </linkerLibItems>
341 |         </linkerTool>
342 |       </folder>
343 |       <item path="tests/BoostMemPoolTest.cpp" ex="false" tool="1" flavor2="0">
344 |       </item>
345 |       <item path="tests/TestEpoll.cpp" ex="false" tool="1" flavor2="0">
346 |       </item>
347 |       <item path="tests/TestTcpEpollClient.cpp" ex="false" tool="1" flavor2="0">
348 |       </item>
349 |       <item path="tests/TestThreadPoolandMemPoolself.cpp"
350 |             ex="false"
351 |             tool="1"
352 |             flavor2="0">
353 |       </item>
354 |       <item path="tests/defaultMemTest.cpp" ex="false" tool="1" flavor2="0">
355 |       </item>
356 |       <item path="tests/newsimpletest.cpp" ex="false" tool="1" flavor2="0">
357 |       </item>
358 |       <item path="tests/newsimpletest3.cpp" ex="false" tool="1" flavor2="0">
359 |       </item>
360 |       <item path="tests/newsimpletest4.cpp" ex="false" tool="1" flavor2="0">
361 |       </item>
362 |       <item path="tests/newsimpletest5.cpp" ex="false" tool="1" flavor2="0">
363 |       </item>
364 |     </conf>
365 |     <conf name="Release" type="3">
366 |       <toolsSet>
367 |         <compilerSet>default</compilerSet>
368 |         <dependencyChecking>true</dependencyChecking>
369 |         <rebuildPropChanged>false</rebuildPropChanged>
370 |       </toolsSet>
371 |       <compileType>
372 |         <cTool>
373 |           <developmentMode>5</developmentMode>
374 |         </cTool>
375 |         <ccTool>
376 |           <developmentMode>5</developmentMode>
377 |         </ccTool>
378 |         <fortranCompilerTool>
379 |           <developmentMode>5</developmentMode>
380 |         </fortranCompilerTool>
381 |         <asmTool>
382 |           <developmentMode>5</developmentMode>
383 |         </asmTool>
384 |         <archiverTool>
385 |         </archiverTool>
386 |       </compileType>
387 |       <item path="CommServer.cpp" ex="false" tool="1" flavor2="0">
388 |       </item>
389 |       <item path="CommServer.h" ex="false" tool="3" flavor2="0">
390 |       </item>
391 |       <item path="Epoll.cpp" ex="false" tool="1" flavor2="0">
392 |       </item>
393 |       <item path="Epoll.h" ex="false" tool="3" flavor2="0">
394 |       </item>
395 |       <item path="Lock.cpp" ex="false" tool="1" flavor2="0">
396 |       </item>
397 |       <item path="Lock.h" ex="false" tool="3" flavor2="0">
398 |       </item>
399 |       <item path="MemPool.cpp" ex="false" tool="1" flavor2="0">
400 |       </item>
401 |       <item path="MemPool.h" ex="false" tool="3" flavor2="0">
402 |       </item>
403 |       <item path="Parser.cpp" ex="false" tool="1" flavor2="0">
404 |       </item>
405 |       <item path="Parser.h" ex="false" tool="3" flavor2="0">
406 |       </item>
407 |       <item path="Semaphore.cpp" ex="false" tool="1" flavor2="0">
408 |       </item>
409 |       <item path="Semaphore.h" ex="false" tool="3" flavor2="0">
410 |       </item>
411 |       <item path="Singleton.h" ex="false" tool="3" flavor2="0">
412 |       </item>
413 |       <item path="Sock.cpp" ex="false" tool="1" flavor2="0">
414 |       </item>
415 |       <item path="Sock.h" ex="false" tool="3" flavor2="0">
416 |       </item>
417 |       <item path="TcpEpollClient.cpp" ex="false" tool="1" flavor2="0">
418 |       </item>
419 |       <item path="TcpEpollClient.h" ex="false" tool="3" flavor2="0">
420 |       </item>
421 |       <item path="TcpEpollServer.cpp" ex="false" tool="1" flavor2="0">
422 |       </item>
423 |       <item path="TcpEpollServer.h" ex="false" tool="3" flavor2="0">
424 |       </item>
425 |       <item path="TcpSock.cpp" ex="false" tool="1" flavor2="0">
426 |       </item>
427 |       <item path="TcpSock.h" ex="false" tool="3" flavor2="0">
428 |       </item>
429 |       <item path="Thread.cpp" ex="false" tool="1" flavor2="0">
430 |       </item>
431 |       <item path="Thread.h" ex="false" tool="3" flavor2="0">
432 |       </item>
433 |       <item path="ThreadLoop.cpp" ex="false" tool="1" flavor2="0">
434 |       </item>
435 |       <item path="ThreadLoop.h" ex="false" tool="3" flavor2="0">
436 |       </item>
437 |       <item path="ThreadPool.cpp" ex="false" tool="1" flavor2="0">
438 |       </item>
439 |       <item path="ThreadPool.h" ex="false" tool="3" flavor2="0">
440 |       </item>
441 |       <item path="Time.cpp" ex="false" tool="1" flavor2="0">
442 |       </item>
443 |       <item path="Time.h" ex="false" tool="3" flavor2="0">
444 |       </item>
445 |       <item path="TimeSpan.cpp" ex="false" tool="1" flavor2="0">
446 |       </item>
447 |       <item path="TimeSpan.h" ex="false" tool="3" flavor2="0">
448 |       </item>
449 |       <folder path="TestFiles/f1">
450 |         <cTool>
451 |           <incDir>
452 |             <pElem>.</pElem>
453 |           </incDir>
454 |         </cTool>
455 |         <ccTool>
456 |           <incDir>
457 |             <pElem>.</pElem>
458 |           </incDir>
459 |         </ccTool>
460 |         <linkerTool>
461 |           <output>${TESTDIR}/TestFiles/f1</output>
462 |         </linkerTool>
463 |       </folder>
464 |       <folder path="TestFiles/f2">
465 |         <cTool>
466 |           <incDir>
467 |             <pElem>.</pElem>
468 |           </incDir>
469 |         </cTool>
470 |         <ccTool>
471 |           <incDir>
472 |             <pElem>.</pElem>
473 |           </incDir>
474 |         </ccTool>
475 |         <linkerTool>
476 |           <output>${TESTDIR}/TestFiles/f2</output>
477 |           <linkerLibItems>
478 |             <linkerOptionItem>-lcunit</linkerOptionItem>
479 |           </linkerLibItems>
480 |         </linkerTool>
481 |       </folder>
482 |       <folder path="TestFiles/f3">
483 |         <cTool>
484 |           <incDir>
485 |             <pElem>.</pElem>
486 |           </incDir>
487 |         </cTool>
488 |         <ccTool>
489 |           <incDir>
490 |             <pElem>.</pElem>
491 |           </incDir>
492 |         </ccTool>
493 |         <linkerTool>
494 |           <output>${TESTDIR}/TestFiles/f3</output>
495 |         </linkerTool>
496 |       </folder>
497 |       <folder path="TestFiles/f4">
498 |         <cTool>
499 |           <incDir>
500 |             <pElem>.</pElem>
501 |           </incDir>
502 |         </cTool>
503 |         <ccTool>
504 |           <incDir>
505 |             <pElem>.</pElem>
506 |           </incDir>
507 |         </ccTool>
508 |         <linkerTool>
509 |           <output>${TESTDIR}/TestFiles/f4</output>
510 |         </linkerTool>
511 |       </folder>
512 |       <folder path="TestFiles/f5">
513 |         <cTool>
514 |           <incDir>
515 |             <pElem>.</pElem>
516 |           </incDir>
517 |         </cTool>
518 |         <ccTool>
519 |           <incDir>
520 |             <pElem>.</pElem>
521 |           </incDir>
522 |         </ccTool>
523 |         <linkerTool>
524 |           <output>${TESTDIR}/TestFiles/f5</output>
525 |         </linkerTool>
526 |       </folder>
527 |       <folder path="TestFiles/f6">
528 |         <cTool>
529 |           <incDir>
530 |             <pElem>.</pElem>
531 |           </incDir>
532 |         </cTool>
533 |         <ccTool>
534 |           <incDir>
535 |             <pElem>.</pElem>
536 |           </incDir>
537 |         </ccTool>
538 |         <linkerTool>
539 |           <output>${TESTDIR}/TestFiles/f6</output>
540 |         </linkerTool>
541 |       </folder>
542 |       <folder path="TestFiles/f7">
543 |         <cTool>
544 |           <incDir>
545 |             <pElem>.</pElem>
546 |           </incDir>
547 |         </cTool>
548 |         <ccTool>
549 |           <incDir>
550 |             <pElem>.</pElem>
551 |           </incDir>
552 |         </ccTool>
553 |         <linkerTool>
554 |           <output>${TESTDIR}/TestFiles/f7</output>
555 |         </linkerTool>
556 |       </folder>
557 |       <folder path="TestFiles/f8">
558 |         <cTool>
559 |           <incDir>
560 |             <pElem>.</pElem>
561 |           </incDir>
562 |         </cTool>
563 |         <ccTool>
564 |           <incDir>
565 |             <pElem>.</pElem>
566 |           </incDir>
567 |         </ccTool>
568 |         <linkerTool>
569 |           <output>${TESTDIR}/TestFiles/f8</output>
570 |         </linkerTool>
571 |       </folder>
572 |       <folder path="TestFiles/f9">
573 |         <cTool>
574 |           <incDir>
575 |             <pElem>.</pElem>
576 |           </incDir>
577 |         </cTool>
578 |         <ccTool>
579 |           <incDir>
580 |             <pElem>.</pElem>
581 |           </incDir>
582 |         </ccTool>
583 |         <linkerTool>
584 |           <output>${TESTDIR}/TestFiles/f9</output>
585 |         </linkerTool>
586 |       </folder>
587 |       <item path="tests/BoostMemPoolTest.cpp" ex="false" tool="1" flavor2="0">
588 |       </item>
589 |       <item path="tests/TestEpoll.cpp" ex="false" tool="1" flavor2="0">
590 |       </item>
591 |       <item path="tests/TestTcpEpollClient.cpp" ex="false" tool="1" flavor2="0">
592 |       </item>
593 |       <item path="tests/TestThreadPoolandMemPoolself.cpp"
594 |             ex="false"
595 |             tool="1"
596 |             flavor2="0">
597 |       </item>
598 |       <item path="tests/defaultMemTest.cpp" ex="false" tool="1" flavor2="0">
599 |       </item>
600 |       <item path="tests/newsimpletest.cpp" ex="false" tool="1" flavor2="0">
601 |       </item>
602 |       <item path="tests/newsimpletest3.cpp" ex="false" tool="1" flavor2="0">
603 |       </item>
604 |       <item path="tests/newsimpletest4.cpp" ex="false" tool="1" flavor2="0">
605 |       </item>
606 |       <item path="tests/newsimpletest5.cpp" ex="false" tool="1" flavor2="0">
607 |       </item>
608 |     </conf>
609 |   </confs>
610 | </configurationDescriptor>
611 | 


--------------------------------------------------------------------------------
/nbproject/project.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <project xmlns="http://www.netbeans.org/ns/project/1">
 3 |     <type>org.netbeans.modules.cnd.makeproject</type>
 4 |     <configuration>
 5 |         <data xmlns="http://www.netbeans.org/ns/make-project/1">
 6 |             <name>CommLib</name>
 7 |             <c-extensions/>
 8 |             <cpp-extensions>cpp</cpp-extensions>
 9 |             <header-extensions>h</header-extensions>
10 |             <sourceEncoding>UTF-8</sourceEncoding>
11 |             <make-dep-projects/>
12 |             <sourceRootList/>
13 |             <confList>
14 |                 <confElem>
15 |                     <name>Debug</name>
16 |                     <type>3</type>
17 |                 </confElem>
18 |                 <confElem>
19 |                     <name>Release</name>
20 |                     <type>3</type>
21 |                 </confElem>
22 |             </confList>
23 |             <formatting>
24 |                 <project-formatting-style>false</project-formatting-style>
25 |             </formatting>
26 |         </data>
27 |     </configuration>
28 | </project>
29 | 


--------------------------------------------------------------------------------
/readme.txt:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jixuduxing/CommLib/f5e3b6585b9ff969ae0541faf9040b29056da0c6/readme.txt


--------------------------------------------------------------------------------
/tests/BoostMemPoolTest.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 |  * File:   newsimpletest1.cpp
 3 |  * Author: Administrator
 4 |  *
 5 |  * Created on 2014-1-24, 11:13:06
 6 |  */
 7 | 
 8 | #include <stdlib.h>
 9 | #include <iostream>
10 | 
11 | #include <boost/shared_ptr.hpp>
12 | #include <boost/bind.hpp>
13 | 
14 | #include "../ThreadPool.h"
15 | #include "../MemPool.h"
16 | 
17 | std::list<void*> m_dynamiclist;
18 | 
19 | 
20 | using namespace CommLib;
21 | CMutexLock lock_;
22 | void threadFun(boost::shared_ptr<MemPool> mp) {
23 |     //   std::cout << "this thread:" << pthread_self() << std::endl;
24 |     //    return;
25 |     srand(10000);
26 |     for (int i = 1; i < 10000; i += 1) {
27 |         //        int count = rand()%10000000000;
28 |         int count = i;
29 |         AllocPack* pPack = mp->Alloc(count);
30 | 
31 | //        if (pPack)
32 | //            pPack->release();
33 |         {
34 |             CAutoLock lock(lock_);
35 |             m_dynamiclist.push_back((void*) pPack);
36 |             if (pPack && (m_dynamiclist.size() > 1000)) {
37 |                 {
38 |                     std::list<void*>::iterator it = m_dynamiclist.begin();
39 |                     for (size_t i = 0; i < 600; i++) {
40 |                         pPack = (AllocPack*) (*it);
41 | //                        mp->Free(pPack );
42 |                         pPack->release();
43 | 
44 |                         it = m_dynamiclist.erase(it);
45 |                     }
46 |                 }
47 |             }
48 |             //            pPack->release();
49 |             //            if (i % 127) {
50 |             //                mp->free(pPack);
51 |         }
52 |         //        } else {
53 |         //            std::cout << "over" << std::endl;
54 |         //            break;
55 |         //        }
56 |     }
57 |     //   mp->printfself(std::cout);
58 | }
59 | 
60 | #include <sys/time.h>
61 | 
62 | int main() {
63 |     timeval tm;
64 |     gettimeofday(&tm, NULL);
65 |     std::cout << "m:" << tm.tv_sec << " hm" << tm.tv_usec << std::endl;
66 | 
67 |     boost::shared_ptr<MemPool> mp(new MemPool(MemPool::Boost_Mp));
68 | 
69 |     //    typedef boost::function<void () > MyFun;
70 |     //    MyFun func = boost::bind(&threadFun, mp);
71 |     ThreadPool thrpool;
72 | 
73 |     thrpool.Init(99);
74 |     sleep(1);
75 | 
76 |     for (int i = 0; i < 10000; i++)
77 |         thrpool.AddTask(boost::bind(&threadFun, mp));
78 | 
79 |     thrpool.Stop();
80 | 
81 |     mp->PrintfSelf(std::cout);
82 |     timeval tm2;
83 |     gettimeofday(&tm2, NULL);
84 | 
85 |     std::cout << "m:" << (tm2.tv_sec - tm.tv_sec) << " hm" << (tm2.tv_usec - tm.tv_usec) << std::endl;
86 | 
87 |     return 1;
88 | }
89 | 


--------------------------------------------------------------------------------
/tests/TestEpoll.cpp:
--------------------------------------------------------------------------------
  1 | /* 
  2 |  * File:   TestEpoll.cpp
  3 |  * Author: Administrator
  4 |  *
  5 |  * Created on 2014-1-28, 11:10:10
  6 |  */
  7 | 
  8 | #include <stdlib.h>
  9 | #include <iostream>
 10 | 
 11 | #include <boost/shared_ptr.hpp>
 12 | #include <boost/enable_shared_from_this.hpp>
 13 | 
 14 | #include "../TcpSock.h"
 15 | #include "../Parser.h"
 16 | #include "../Epoll.h"
 17 | #include "../MemPool.h"
 18 | #include "../CommServer.h"
 19 | #include "../Time.h"
 20 | 
 21 | /*
 22 |  * Simple C++ Test Suite
 23 |  */
 24 | class TestParser : public CommLib::ProtocolParser {
 25 | public:
 26 | 
 27 |     virtual bool parse(char* buff, int len) {
 28 |         char *buffnew = new char[ len + 1 ];
 29 |         memcpy(buffnew, buff, len);
 30 |         buffnew[ len ] = 0;
 31 | 
 32 |         std::cout << buffnew << std::endl;
 33 |     }
 34 | };
 35 | 
 36 | void test1() {
 37 |     std::cout << "TestEpoll test 1" << std::endl;
 38 | 
 39 |     //    CommLib::Epoll2 ep;
 40 |     //    TestParser* parser = new TestParser();
 41 |     //
 42 |     //    CommLib::SockAddr addr(2080, "0.0.0.0", CommLib::Sock::IP);
 43 |     //
 44 |     //    CommLib::TcpServSock ssock(parser, &ep);
 45 |     //    ssock.Bind(addr);
 46 |     //    ssock.Listen(10);
 47 |     //    ssock.RegistEpoll();
 48 |     //
 49 |     //    while (ep.Schedule(10)) {
 50 |     //    }
 51 | 
 52 |     std::cout << " end " << std::endl;
 53 | }
 54 | 
 55 | 
 56 | //在该类中做计时、超时处理
 57 | 
 58 | class MyTcpSock : public CommLib::CommSockImp {
 59 | public:
 60 | 
 61 |     MyTcpSock(int sock, boost::shared_ptr<CommLib::MemPool> pMemPool, CommLib::TcpEpollServerImp* pEServ) :
 62 |     CommLib::CommSockImp(sock, pMemPool, pEServ,15),
 63 |     pParser_(new TestParser()) {
 64 |     }
 65 | 
 66 |     virtual int OnSend() {
 67 |         return 1;
 68 |     };
 69 | 
 70 |     virtual int OnClose() {
 71 |         return 1;
 72 |     };
 73 | 
 74 |     virtual int OnRecvPack(CommLib::AllocPack* pack) {
 75 | 
 76 |         pParser_->parse((char*) pack->getbuffer(), pack->getlengh());
 77 |         Send((char*) pack->getbuffer(), pack->getlengh());
 78 | 
 79 |         return 1;
 80 |     }
 81 | 
 82 | private:
 83 |     boost::shared_ptr<TestParser> pParser_;
 84 | };
 85 | 
 86 | void test2() {
 87 | 
 88 |     CommLib::CommonServer<MyTcpSock> server(
 89 |             boost::shared_ptr<CommLib::Epoll >(new CommLib::EpollSimple()),
 90 |             boost::shared_ptr<CommLib::MemPool >(new CommLib::MemPool()));
 91 |     server.Start(2080);
 92 |     while (1) {
 93 |         sleep(1);
 94 |         //        server.Schedule();
 95 |     }
 96 | 
 97 |     std::cout << "TestEpoll test 2" << std::endl;
 98 |     //    std::cout << "%TEST_FAILED% time=0 testname=test2 (TestEpoll) message=error message sample" << std::endl;
 99 | }
100 | 
101 | int main(int argc, char** argv) {
102 |     std::cout << "%SUITE_STARTING% TestEpoll" << std::endl;
103 |     std::cout << "%SUITE_STARTED%" << std::endl;
104 | 
105 |     std::cout << "%TEST_STARTED% test1 (TestEpoll)" << std::endl;
106 |     test1();
107 |     std::cout << "%TEST_FINISHED% time=0 test1 (TestEpoll)" << std::endl;
108 | 
109 |     std::cout << "%TEST_STARTED% test2 (TestEpoll)\n" << std::endl;
110 |     test2();
111 |     std::cout << "%TEST_FINISHED% time=0 test2 (TestEpoll)" << std::endl;
112 | 
113 |     std::cout << "%SUITE_FINISHED% time=0" << std::endl;
114 | 
115 |     return (EXIT_SUCCESS);
116 | }
117 | 
118 | 


--------------------------------------------------------------------------------
/tests/TestTcpEpollClient.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 |  * File:   TestTcpEpollClient.cpp
 3 |  * Author: gwm <wenmao@eastmoney.com>
 4 |  *
 5 |  * Created on 2014-4-15, 15:24:58
 6 |  */
 7 | 
 8 | #include <stdlib.h>
 9 | #include <iostream>
10 | #include "TcpEpollClient.h"
11 | #include "Epoll.h"
12 | #include "MemPool.h"
13 | 
14 | class myClient : public CommLib::TcpEpollClientImp {
15 | public:
16 | 
17 |     myClient(boost::shared_ptr<CommLib::Epoll> epoll, boost::shared_ptr<CommLib::MemPool> pMemPool)
18 |     : CommLib::TcpEpollClientImp(epoll,pMemPool) {
19 |     };
20 | 
21 |     virtual int OnRecvPack(CommLib::AllocPack* pack) {
22 | 
23 |         int len = pack->getlengh();
24 |         char *buffnew = new char[ len + 1 ];
25 |         memcpy(buffnew, pack->getbuffer(), len);
26 |         buffnew[ len ] = 0;
27 | 
28 |         std::cout << buffnew << std::endl;
29 | //        pParser_->parse((char*) pack->getbuffer(), pack->getlengh());
30 |         Send((char*) pack->getbuffer(), pack->getlengh());
31 | 
32 |         return 1;
33 |     }
34 |     
35 |    
36 | };
37 | 
38 | /*
39 |  * Simple C++ Test Suite
40 |  */
41 | 
42 | void test1() {
43 |     std::cout << "TestTcpEpollClient test 1" << std::endl;
44 | }
45 | 
46 | void test2() {
47 |     std::cout << "TestTcpEpollClient test 2" << std::endl;
48 |     std::cout << "%TEST_FAILED% time=0 testname=test2 (TestTcpEpollClient) message=error message sample" << std::endl;
49 | }
50 | 
51 | int main(int argc, char** argv) {
52 |     
53 |     boost::shared_ptr<CommLib::Epoll > ep(new CommLib::EpollSimple());
54 |     myClient mm( ep,boost::shared_ptr<CommLib::MemPool >(new CommLib::MemPool()) );
55 |     mm.InitConnect("127.0.0.1",2080);
56 |     mm.Send((void*)"sdsd",4);
57 |     while(ep->Schedule(10))
58 |         sleep(2);
59 |     
60 | //    std::cout << "%SUITE_STARTING% TestTcpEpollClient" << std::endl;
61 | //    std::cout << "%SUITE_STARTED%" << std::endl;
62 | //
63 | //    std::cout << "%TEST_STARTED% test1 (TestTcpEpollClient)" << std::endl;
64 | //    test1();
65 | //    std::cout << "%TEST_FINISHED% time=0 test1 (TestTcpEpollClient)" << std::endl;
66 | //
67 | //    std::cout << "%TEST_STARTED% test2 (TestTcpEpollClient)\n" << std::endl;
68 | //    test2();
69 | //    std::cout << "%TEST_FINISHED% time=0 test2 (TestTcpEpollClient)" << std::endl;
70 | //
71 | //    std::cout << "%SUITE_FINISHED% time=0" << std::endl;
72 | 
73 |     return (EXIT_SUCCESS);
74 | }
75 | 
76 | 


--------------------------------------------------------------------------------
/tests/TestThreadPoolandMemPoolself.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 |  * File:   newsimpletest1.cpp
 3 |  * Author: Administrator
 4 |  *
 5 |  * Created on 2014-1-24, 11:13:06
 6 |  */
 7 | 
 8 | #include <stdlib.h>
 9 | #include <iostream>
10 | 
11 | #include <boost/shared_ptr.hpp>
12 | #include <boost/bind.hpp>
13 | 
14 | #include "../ThreadPool.h"
15 | #include "../MemPool.h"
16 | 
17 | std::list<void*> m_dynamiclist;
18 | 
19 | 
20 | using namespace CommLib;
21 | CMutexLock lock_;
22 | 
23 | void threadFun(boost::shared_ptr<MemPool> mp) {
24 |     //   std::cout << "this thread:" << pthread_self() << std::endl;
25 |     //    return;
26 |     srand(10000);
27 |     for (int i = 1; i < 10000; i += 1) {
28 |         //        int count = rand()%10000000000;
29 |         int count = i;
30 |         AllocPack* pPack = mp->Alloc(count);
31 | //        if (pPack)
32 | //            pPack->release();
33 |         {
34 |             CAutoLock lock(lock_);
35 |             m_dynamiclist.push_back((void*) pPack);
36 |             if (pPack && (m_dynamiclist.size() > 1000)) {
37 |                 {
38 |                     std::list<void*>::iterator it = m_dynamiclist.begin();
39 |                     for (size_t i = 0; i < 600; i++) {
40 |                         pPack = (AllocPack*) (*it);
41 |                         //                        mp->Free(pPack );
42 |                         pPack->release();
43 | 
44 |                         it = m_dynamiclist.erase(it);
45 |                     }
46 |                 }
47 |             }
48 |             //            pPack->release();
49 |             //            if (i % 127) {
50 |             //                mp->free(pPack);
51 |         }
52 |         //        } else {
53 |         //            std::cout << "over" << std::endl;
54 |         //            break;
55 |         //        }
56 |     }
57 |     //   mp->printfself(std::cout);
58 | }
59 | 
60 | #include <sys/time.h>
61 | 
62 | int main() {
63 |     timeval tm;
64 |     gettimeofday(&tm, NULL);
65 |     std::cout << "m:" << tm.tv_sec << " hm" << tm.tv_usec << std::endl;
66 | 
67 |     boost::shared_ptr<MemPool> mp(new MemPool(MemPool::SimpleList_Mp));
68 | 
69 |     //    typedef boost::function<void () > MyFun;
70 |     //    MyFun func = boost::bind(&threadFun, mp);
71 |     ThreadPool thrpool;
72 | 
73 |     thrpool.Init(99);
74 |     sleep(1);
75 | 
76 |     for (int i = 0; i < 10000; i++)
77 |         thrpool.AddTask(boost::bind(&threadFun, mp));
78 | 
79 |     thrpool.Stop();
80 | 
81 |     mp->PrintfSelf(std::cout);
82 |     timeval tm2;
83 |     gettimeofday(&tm2, NULL);
84 | 
85 |     std::cout << "m:" << (tm2.tv_sec - tm.tv_sec) << " hm" << (tm2.tv_usec - tm.tv_usec) << std::endl;
86 | 
87 |     return 1;
88 | }
89 | 


--------------------------------------------------------------------------------
/tests/defaultMemTest.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 |  * File:   newsimpletest1.cpp
 3 |  * Author: Administrator
 4 |  *
 5 |  * Created on 2014-1-24, 11:13:06
 6 |  */
 7 | 
 8 | #include <stdlib.h>
 9 | #include <iostream>
10 | 
11 | #include <boost/shared_ptr.hpp>
12 | #include <boost/bind.hpp>
13 | 
14 | #include "../ThreadPool.h"
15 | #include "../MemPool.h"
16 | 
17 | using namespace CommLib;
18 | 
19 | std::list<void*> m_dynamiclist;
20 | CMutexLock lock_;
21 | 
22 | void threadFun(boost::shared_ptr<MemPool> mp) {
23 |     //  std::cout << "this thread:" << pthread_self() << std::endl;
24 |     //    return;
25 |     srand(10000);
26 |     for (int i = 1; i < 10000; i += 1) {
27 |         //        int count = rand()%10000000000;
28 |         int count = i;
29 |         char* buff = new char[i];
30 | //        delete buff;
31 |         
32 |         {
33 |             CAutoLock lock(lock_);
34 |             m_dynamiclist.push_back((void*) buff);
35 |             if (buff && (m_dynamiclist.size() > 1000)) {
36 |                 {
37 |                     std::list<void*>::iterator it = m_dynamiclist.begin();
38 |                     for (size_t i = 0; i < 600; i++) {
39 |                         buff = (char*) (*it);
40 |                         delete buff;
41 | 
42 |                         it = m_dynamiclist.erase(it);
43 |                     }
44 |                 }
45 |             }
46 |         }
47 | 
48 |     }
49 |     //   mp->printfself(std::cout);
50 | }
51 | 
52 | #include <sys/time.h>
53 | 
54 | int main() {
55 |     timeval tm;
56 |     gettimeofday(&tm, NULL);
57 |     std::cout << "m:" << tm.tv_sec << " hm" << tm.tv_usec << std::endl;
58 | 
59 |     boost::shared_ptr<MemPool> mp(new MemPool(MemPool::SimpleList_Mp));
60 | 
61 |     //    typedef boost::function<void () > MyFun;
62 |     //    MyFun func = boost::bind(&threadFun, mp);
63 |     ThreadPool thrpool;
64 | 
65 |     thrpool.Init(99);
66 |     sleep(1);
67 | 
68 |     for (int i = 0; i < 10000; i++)
69 |         thrpool.AddTask(boost::bind(&threadFun, mp));
70 | 
71 |     thrpool.Stop();
72 | 
73 |     mp->PrintfSelf(std::cout);
74 |     timeval tm2;
75 |     gettimeofday(&tm2, NULL);
76 | 
77 |     std::cout << "m:" << (tm2.tv_sec - tm.tv_sec) << " hm" << (tm2.tv_usec - tm.tv_usec) << std::endl;
78 | 
79 |     return 1;
80 | }
81 | 


--------------------------------------------------------------------------------
/tests/newcunittest.c:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * File:   newcunittest.c
 3 |  * Author: Administrator
 4 |  *
 5 |  * Created on 2014-1-24, 11:11:51
 6 |  */
 7 | 
 8 | #include <stdio.h>
 9 | #include <stdlib.h>
10 | #include <CUnit/Basic.h>
11 | 
12 | /*
13 |  * CUnit Test Suite
14 |  */
15 | 
16 | int init_suite(void) {
17 |     return 0;
18 | }
19 | 
20 | int clean_suite(void) {
21 |     return 0;
22 | }
23 | 
24 | void test1() {
25 |     CU_ASSERT(2 * 2 == 4);
26 | }
27 | 
28 | void test2() {
29 |     CU_ASSERT(2 * 2 == 5);
30 | }
31 | 
32 | int main() {
33 |     CU_pSuite pSuite = NULL;
34 | 
35 |     /* Initialize the CUnit test registry */
36 |     if (CUE_SUCCESS != CU_initialize_registry())
37 |         return CU_get_error();
38 | 
39 |     /* Add a suite to the registry */
40 |     pSuite = CU_add_suite("newcunittest", init_suite, clean_suite);
41 |     if (NULL == pSuite) {
42 |         CU_cleanup_registry();
43 |         return CU_get_error();
44 |     }
45 | 
46 |     /* Add the tests to the suite */
47 |     if ((NULL == CU_add_test(pSuite, "test1", test1)) ||
48 |             (NULL == CU_add_test(pSuite, "test2", test2))) {
49 |         CU_cleanup_registry();
50 |         return CU_get_error();
51 |     }
52 | 
53 |     /* Run all tests using the CUnit Basic interface */
54 |     CU_basic_set_mode(CU_BRM_VERBOSE);
55 |     CU_basic_run_tests();
56 |     CU_cleanup_registry();
57 |     return CU_get_error();
58 | }
59 | 


--------------------------------------------------------------------------------
/tests/newsimpletest.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 |  * File:   newsimpletest.cpp
 3 |  * Author: Administrator
 4 |  *
 5 |  * Created on 2014-1-23, 17:25:08
 6 |  */
 7 | 
 8 | #include <stdlib.h>
 9 | #include <iostream>
10 | #include <boost/shared_ptr.hpp>
11 | #include <boost/bind.hpp>
12 | 
13 | #include "../Thread.h"
14 | #include "../MemPool.h"
15 | using namespace CommLib;
16 | /*
17 |  * Simple C++ Test Suite
18 |  */
19 | 
20 | void test1() {
21 |     std::cout << "newsimpletest test 1" << std::endl;
22 | }
23 | 
24 | void test2() {
25 |     std::cout << "newsimpletest test 2" << std::endl;
26 |     std::cout << "%TEST_FAILED% time=0 testname=test2 (newsimpletest) message=error message sample" << std::endl;
27 | }
28 | 
29 | void threadFun( boost::shared_ptr<MemPool> mp) {
30 |     std::cout << "this thread:" << pthread_self() << std::endl;
31 |     //    return;
32 |     srand(10000);
33 |     for (int i = 1; i < 10000; i += 1) {
34 | //        int count = rand()%10000000000;
35 |         int count = i;
36 |         AllocPack* pPack = mp->Alloc(count);
37 | 
38 |         if (pPack) {
39 | //            if (i % 127) {
40 |                 mp->Free(pPack);
41 |             }
42 | //        } else {
43 | //            std::cout << "over" << std::endl;
44 | //            break;
45 | //        }
46 |     }
47 |     mp->PrintfSelf(std::cout);
48 | }
49 | 
50 | 
51 | int main() {
52 |     boost::shared_ptr<MemPool> mp(new MemPool(MemPool::SimpleList_Mp));
53 |     
54 |     typedef boost::function<void () > MyFun;
55 |     MyFun func = boost::bind(&threadFun, mp);
56 | 
57 |     Thread thr1(func,"1");
58 |     Thread thr2(func,"2");
59 |     Thread thr3(func,"3");
60 |     Thread thr4(func,"4");
61 | 
62 | //    thr1.SetFunc(func);
63 | //    thr2.SetFunc(func);
64 | //    thr3.SetFunc(func);
65 | //    thr4.SetFunc(func);
66 | 
67 |     thr1.StartThread();
68 |     thr2.StartThread();
69 |     thr3.StartThread();
70 |     thr4.StartThread();
71 | 
72 |     thr1.Join();
73 |     thr2.Join();
74 |     thr3.Join();
75 |     thr4.Join();
76 | 
77 |     return 1;
78 | }
79 | 
80 | 
81 | int main2(int argc, char** argv) {
82 |     std::cout << "%SUITE_STARTING% newsimpletest" << std::endl;
83 |     std::cout << "%SUITE_STARTED%" << std::endl;
84 | 
85 |     std::cout << "%TEST_STARTED% test1 (newsimpletest)" << std::endl;
86 |     test1();
87 |     std::cout << "%TEST_FINISHED% time=0 test1 (newsimpletest)" << std::endl;
88 | 
89 |     std::cout << "%TEST_STARTED% test2 (newsimpletest)\n" << std::endl;
90 |     test2();
91 |     std::cout << "%TEST_FINISHED% time=0 test2 (newsimpletest)" << std::endl;
92 | 
93 |     std::cout << "%SUITE_FINISHED% time=0" << std::endl;
94 | 
95 |     return (EXIT_SUCCESS);
96 | }
97 | 
98 | 


--------------------------------------------------------------------------------
/tests/newsimpletest3.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 |  * File:   newsimpletest3.cpp
 3 |  * Author: Administrator
 4 |  *
 5 |  * Created on 2014-1-27, 9:25:39
 6 |  */
 7 | 
 8 | #include <stdlib.h>
 9 | #include <iostream>
10 | 
11 | #include "Time.h"
12 | using namespace CommLib;
13 | /*
14 |  * Simple C++ Test Suite
15 |  */
16 | 
17 | void test1() {
18 |     Time tm = Time::GetCurrentTime();
19 |     std::cout<<tm.GetHour()<<":";
20 |     std::cout<<tm.GetMinute()<<":";
21 |     std::cout<<tm.GetSecond()<<" ";
22 |     std::cout<<tm.GetYear()<<":";
23 |     std::cout<<tm.GetMonth()<<":";
24 |     std::cout<<tm.GetDay()<<"周";
25 |     std::cout<<tm.GetDayOfWeek()<<" ";
26 | 
27 |     tm = tm + 28800*3;
28 | 
29 |     std::cout<<tm.GetHour()<<":";
30 |     std::cout<<tm.GetMinute()<<":";
31 |     std::cout<<tm.GetSecond()<<" ";
32 |     std::cout<<tm.GetYear()<<":";
33 |     std::cout<<tm.GetMonth()<<":";
34 |     std::cout<<tm.GetDay()<<"周";
35 |     std::cout<<tm.GetDayOfWeek()<<" ";
36 |     std::cout << "newsimpletest3 test 1" << std::endl;
37 | }
38 | 
39 | void test2() {
40 |     std::cout << "newsimpletest3 test 2" << std::endl;
41 | //    std::cout << "%TEST_FAILED% time=0 testname=test2 (newsimpletest3) message=error message sample" << std::endl;
42 | }
43 | 
44 | int main(int argc, char** argv) {
45 |     std::cout << "%SUITE_STARTING% newsimpletest3" << std::endl;
46 |     std::cout << "%SUITE_STARTED%" << std::endl;
47 | 
48 |     std::cout << "%TEST_STARTED% test1 (newsimpletest3)" << std::endl;
49 |     test1();
50 |     std::cout << "%TEST_FINISHED% time=0 test1 (newsimpletest3)" << std::endl;
51 | 
52 |     std::cout << "%TEST_STARTED% test2 (newsimpletest3)\n" << std::endl;
53 |     test2();
54 |     std::cout << "%TEST_FINISHED% time=0 test2 (newsimpletest3)" << std::endl;
55 | 
56 |     std::cout << "%SUITE_FINISHED% time=0" << std::endl;
57 | 
58 |     return (EXIT_SUCCESS);
59 | }
60 | 
61 | 


--------------------------------------------------------------------------------
/tests/newsimpletest4.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 |  * File:   newsimpletest4.cpp
 3 |  * Author: Administrator
 4 |  *
 5 |  * Created on 2014-1-27, 10:47:59
 6 |  */
 7 | 
 8 | #include <stdlib.h>
 9 | #include <iostream>
10 | #include "ThreadLoop.h"
11 | #include "Time.h"
12 | using namespace CommLib;
13 | /*
14 |  * Simple C++ Test Suite
15 |  */
16 | class TestLoop : public ThreadLoop {
17 | public:
18 | 
19 |     TestLoop(int looptime) : ThreadLoop("TestLoop", looptime) {
20 |     }
21 | 
22 |     virtual void LoopTask() {
23 |         std::cout << this->ThreadName() << " Time:" << Time::GetCurrTick() << std::endl;
24 |     }
25 | 
26 | };
27 | 
28 | void test1() {
29 |     
30 |     TestLoop loop( 5 );
31 |     loop.StartThread();
32 |     
33 |     sleep(60);
34 |     loop.StopLoop();
35 |     loop.Join();
36 |     
37 |     std::cout << "newsimpletest4 test 1" << std::endl;
38 | }
39 | 
40 | void test2() {
41 |     std::cout << "newsimpletest4 test 2" << std::endl;
42 | //    std::cout << "%TEST_FAILED% time=0 testname=test2 (newsimpletest4) message=error message sample" << std::endl;
43 | }
44 | 
45 | int main(int argc, char** argv) {
46 |     std::cout << "%SUITE_STARTING% newsimpletest4" << std::endl;
47 |     std::cout << "%SUITE_STARTED%" << std::endl;
48 | 
49 |     std::cout << "%TEST_STARTED% test1 (newsimpletest4)" << std::endl;
50 |     test1();
51 |     std::cout << "%TEST_FINISHED% time=0 test1 (newsimpletest4)" << std::endl;
52 | 
53 |     std::cout << "%TEST_STARTED% test2 (newsimpletest4)\n" << std::endl;
54 |     test2();
55 |     std::cout << "%TEST_FINISHED% time=0 test2 (newsimpletest4)" << std::endl;
56 | 
57 |     std::cout << "%SUITE_FINISHED% time=0" << std::endl;
58 | 
59 |     return (EXIT_SUCCESS);
60 | }
61 | 
62 | 


--------------------------------------------------------------------------------
/tests/newsimpletest5.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 |  * File:   newsimpletest5.cpp
 3 |  * Author: Administrator
 4 |  *
 5 |  * Created on 2014-1-27, 13:41:15
 6 |  */
 7 | 
 8 | #include <stdlib.h>
 9 | #include <iostream>
10 | #include <boost/noncopyable.hpp>
11 | #include <boost/pool/pool.hpp>
12 | #include <boost/pool/singleton_pool.hpp>
13 | #include <bitset>
14 | std::bitset<2> bset;
15 | 
16 | class CopyAble:boost::noncopyable
17 | {
18 | public:
19 |     int a_;
20 | };
21 | /*
22 |  * Simple C++ Test Suite
23 |  */
24 | 
25 | void test(CopyAble a)
26 | {
27 |     a.a_ = 2;
28 | }
29 | 
30 | void test1() {
31 |     CopyAble ca;
32 |     ca.a_ = 1;
33 |     
34 | //    CopyAble ca2 = ca;
35 | //    CopyAble ca3( ca );
36 | //    test( ca );
37 |     
38 |     std::cout << "newsimpletest5 test 1" << std::endl;
39 | }
40 | 
41 | void test2() {
42 |     std::cout << "newsimpletest5 test 2" << std::endl;
43 | //    std::cout << "%TEST_FAILED% time=0 testname=test2 (newsimpletest5) message=error message sample" << std::endl;
44 | }
45 | 
46 | int main(int argc, char** argv) {
47 |     std::cout << "%SUITE_STARTING% newsimpletest5" << std::endl;
48 |     std::cout << "%SUITE_STARTED%" << std::endl;
49 | 
50 |     std::cout << "%TEST_STARTED% test1 (newsimpletest5)" << std::endl;
51 |     test1();
52 |     std::cout << "%TEST_FINISHED% time=0 test1 (newsimpletest5)" << std::endl;
53 | 
54 |     std::cout << "%TEST_STARTED% test2 (newsimpletest5)\n" << std::endl;
55 |     test2();
56 |     std::cout << "%TEST_FINISHED% time=0 test2 (newsimpletest5)" << std::endl;
57 | 
58 |     std::cout << "%SUITE_FINISHED% time=0" << std::endl;
59 | 
60 |     return (EXIT_SUCCESS);
61 | }
62 | 
63 | 


--------------------------------------------------------------------------------
/测试.md:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jixuduxing/CommLib/f5e3b6585b9ff969ae0541faf9040b29056da0c6/测试.md


--------------------------------------------------------------------------------