1 files changed, 0 insertions, 154 deletions
diff --git a/src/itoheap.h b/src/itoheap.h
deleted file mode 100644
index a5aad05..0000000
--- a/src/itoheap.h
+++ /dev/null
@@ -1,154 +0,0 @@
-/*
- * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
- *
- * This file is part of the libbu++ library and is released under the
- * terms of the license contained in the file LICENSE.
- */
-#ifndef BU_ITO_HEAP_H
-#define BU_ITO_HEAP_H
-#include "bu/heap.h"
-#include "bu/itomutex.h"
-#include "bu/itocondition.h"
-namespace Bu
-{
-        class ItoMutex;
-        class ItoCondition;
-        template<typename item, typename cmpfunc=__basicLTCmp<item>,
-                typename itemalloc=std::allocator<item> >
-        class ItoHeap
-        {
-        public:
-                ItoHeap()
-                {
-                }
-                virtual ~ItoHeap()
-                {
-                }
-                void enqueue( item i )
-                {
-                        imData.lock();
-                        hData.enqueue( i );
-                        icBlock.signal();
-                        imData.unlock();
-                }
-                item dequeue( bool bBlock=false )
-                {
-                        imData.lock();
-                        if( hData.isEmpty() )
-                        {
-                                imData.unlock();
-                                if( bBlock )
-                                {
-                                        icBlock.lock();
-                                        while( hData.isEmpty() )
-                                                icBlock.wait();
-                                        imData.lock();
-                                        try
-                                        {
-                                                item iRet = hData.dequeue();
-                                                imData.unlock();
-                                                icBlock.unlock();
-                                                return iRet;
-                                        }
-                                        catch(...)
-                                        {
-                                                imData.unlock();
-                                                icBlock.unlock();
-                                                throw;
-                                        }
-                                }
-                                throw HeapException("Heap empty.");
-                        }
-                        else
-                        {
-                                try
-                                {
-                                        item iRet = hData.dequeue();
-                                        imData.unlock();
-                                        return iRet;
-                                }
-                                catch(...)
-                                {
-                                        imData.unlock();
-                                        throw;
-                                }
-                        }
-                }
-                item dequeue( int iSec, int iUSec )
-                {
-                        imData.lock();
-                        if( hData.isEmpty() )
-                        {
-                                imData.unlock();
-                                icBlock.lock();
-                                icBlock.wait( iSec, iUSec );
-                                imData.lock();
-                                try
-                                {
-                                        item iRet = hData.dequeue();
-                                        imData.unlock();
-                                        icBlock.unlock();
-                                        return iRet;
-                                }
-                                catch(...)
-                                {
-                                        imData.unlock();
-                                        icBlock.unlock();
-                                        throw;
-                                }
-                        }
-                        else
-                        {
-                                try
-                                {
-                                        item iRet = hData.dequeue();
-                                        imData.unlock();
-                                        return iRet;
-                                }
-                                catch(...)
-                                {
-                                        imData.unlock();
-                                        throw;
-                                }
-                        }
-                }
-                
-                bool isEmpty()
-                {
-                        imData.lock();
-                        bool bRet = hData.isEmpty();
-                        imData.unlock();
-                        return bRet;
-                }
-                int getSize()
-                {
-                        imData.lock();
-                        int iRet = hData.getSize();
-                        imData.unlock();
-                        return iRet;
-                }
-        private:
-                Heap< item, cmpfunc, itemalloc > hData;
-                ItoMutex imData;
-                ItoCondition icBlock;
-        };
-};
-#endif

diff --git a/src/itoheap.h b/src/itoheap.h deleted file mode 100644 index a5aad05..0000000 --- a/src/itoheap.h +++ /dev/null
@@ -1,154 +0,0 @@
1	/*
2	* Copyright (C) 2007-2011 Xagasoft, All rights reserved.
3	*
4	* This file is part of the libbu++ library and is released under the
5	* terms of the license contained in the file LICENSE.
6	*/
7
8	#ifndef BU_ITO_HEAP_H
9	#define BU_ITO_HEAP_H
10
11	#include "bu/heap.h"
12	#include "bu/itomutex.h"
13	#include "bu/itocondition.h"
14
15	namespace Bu
16	{
17	class ItoMutex;
18	class ItoCondition;
19
20	template<typename item, typename cmpfunc=__basicLTCmp<item>,
21	typename itemalloc=std::allocator<item> >
22	class ItoHeap
23	{
24	public:
25	ItoHeap()
26	{
27	}
28
29	virtual ~ItoHeap()
30	{
31	}
32
33	void enqueue( item i )
34	{
35	imData.lock();
36	hData.enqueue( i );
37	icBlock.signal();
38	imData.unlock();
39	}
40
41	item dequeue( bool bBlock=false )
42	{
43	imData.lock();
44	if( hData.isEmpty() )
45	{
46	imData.unlock();
47
48	if( bBlock )
49	{
50	icBlock.lock();
51
52	while( hData.isEmpty() )
53	icBlock.wait();
54
55	imData.lock();
56	try
57	{
58	item iRet = hData.dequeue();
59	imData.unlock();
60	icBlock.unlock();
61	return iRet;
62	}
63	catch(...)
64	{
65	imData.unlock();
66	icBlock.unlock();
67	throw;
68	}
69	}
70	throw HeapException("Heap empty.");
71	}
72	else
73	{
74	try
75	{
76	item iRet = hData.dequeue();
77	imData.unlock();
78	return iRet;
79	}
80	catch(...)
81	{
82	imData.unlock();
83	throw;
84	}
85	}
86	}
87
88	item dequeue( int iSec, int iUSec )
89	{
90	imData.lock();
91	if( hData.isEmpty() )
92	{
93	imData.unlock();
94
95	icBlock.lock();
96
97	icBlock.wait( iSec, iUSec );
98
99	imData.lock();
100	try
101	{
102	item iRet = hData.dequeue();
103	imData.unlock();
104	icBlock.unlock();
105	return iRet;
106	}
107	catch(...)
108	{
109	imData.unlock();
110	icBlock.unlock();
111	throw;
112	}
113	}
114	else
115	{
116	try
117	{
118	item iRet = hData.dequeue();
119	imData.unlock();
120	return iRet;
121	}
122	catch(...)
123	{
124	imData.unlock();
125	throw;
126	}
127	}
128	}
129
130	bool isEmpty()
131	{
132	imData.lock();
133	bool bRet = hData.isEmpty();
134	imData.unlock();
135	return bRet;
136	}
137
138	int getSize()
139	{
140	imData.lock();
141	int iRet = hData.getSize();
142	imData.unlock();
143	return iRet;
144	}
145
146	private:
147	Heap< item, cmpfunc, itemalloc > hData;
148	ItoMutex imData;
149	ItoCondition icBlock;
150	};
151	};
152
153	#endif
154