Terimber Corporation

00001 /*
00002  * The Software License
00003  * =================================================================================
00004  * Copyright (c) 2003-.The Terimber Corporation. All rights reserved.
00005  * =================================================================================
00006  * Redistributions of source code must retain the above copyright notice, 
00007  * this list of conditions and the following disclaimer.
00008  * Redistributions in binary form must reproduce the above copyright notice, 
00009  * this list of conditions and the following disclaimer in the documentation 
00010  * and/or other materials provided with the distribution.
00011  * The end-user documentation included with the redistribution, if any, 
00012  * must include the following acknowledgment:
00013  * "This product includes software developed by the Terimber Corporation."
00014  * =================================================================================
00015  * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED OR IMPLIED WARRANTIES, 
00016  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY 
00017  * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  
00018  * IN NO EVENT SHALL THE TERIMBER CORPORATION OR ITS CONTRIBUTORS BE LIABLE FOR 
00019  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 
00020  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
00021  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON 
00022  * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
00023  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
00024  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
00025  * ================================================================================
00026 */
00027 
00028 #ifndef _terimber_algorithm_hpp_
00029 #define _terimber_algorithm_hpp_
00030 
00031 #include "alg/algorith.h"
00032 
00033 BEGIN_TERIMBER_NAMESPACE
00034 #pragma pack(4)
00035 
00036 // class supports thread safe STL algorithms
00037 namespace algorithm
00038 {
00039         template< class Cont, class Pred >
00040     inline void find_if(Cont& cont, Pred& pr, const mutex& mtx)
00041         {       
00042                 mutex_keeper keeper(mtx);
00043                 TYPENAME Cont::iterator first = cont.begin(), last = cont.end();
00044                 for (; first != last; ++first)
00045                         if (pr(*first))
00046                                 break;
00047         }
00048         
00049         template< class Cont, class Pred >
00050     inline void for_each(Cont& cont, Pred& pr, const mutex& mtx)
00051         { 
00052                 mutex_keeper keeper(mtx); 
00053                 TYPENAME Cont::iterator first = cont.begin(), last = cont.end();
00054 
00055                 for (; first != last; ++first)
00056                         pr(*first);
00057         }
00058 
00059         template< class Cont, class Pred >
00060     inline void remove_if(Cont& cont, Pred& pr, const mutex& mtx)
00061         { 
00062                 mutex_keeper keeper(mtx); 
00063                 TYPENAME Cont::iterator first = cont.begin(), last = cont.end();
00064 
00065                 for (; first != last; ++first)
00066                         if (pr(*first))
00067                         {
00068                                 cont.erase(first);
00069                 break;
00070                         }
00071         }
00072 
00073         template< class Al, class Obj, class Cont >
00074     inline void push_back(Al& al, Cont& cont, Obj& obj, const mutex& mtx)
00075         { 
00076                 mutex_keeper keeper(mtx); 
00077                 cont.push_back(al, obj);
00078         }
00079 
00080         template< class Al, class Cont, class Pred, class Obj >
00081     inline bool push_back_if(Al& al, Cont& cont, Pred& pr, Obj& obj, const mutex& mtx)
00082         { 
00083                 mutex_keeper keeper(mtx); 
00084                 TYPENAME Cont::iterator first = cont.begin(), last = cont.end();
00085 
00086                 for (; first != last; ++first)
00087                         if (pr(*first))
00088                                 return false;
00089 
00090                 cont.push_back(al, obj);
00091                 return true;
00092         }
00093 
00094         template< class Obj, class Cont >
00095     inline void push_back(Cont& cont, Obj& obj, const mutex& mtx)
00096         { 
00097                 mutex_keeper keeper(mtx); 
00098                 cont.push_back(obj);
00099         }
00100 
00101         template< class Cont, class Pred, class Obj >
00102     inline bool push_back_if(Cont& cont, Pred& pr, Obj& obj, const mutex& mtx)
00103         { 
00104                 mutex_keeper keeper(mtx); 
00105                 TYPENAME Cont::iterator first = cont.begin(), last = cont.end();
00106 
00107                 for (; first != last; ++first)
00108                         if (pr(*first))
00109                                 return false;
00110 
00111                 cont.push_back(obj);
00112                 return true;
00113         }
00114 
00115         template< class Obj, class Cont >
00116     inline void remove(Cont& cont, Obj& obj, const mutex& mtx)
00117         { 
00118                 mutex_keeper keeper(mtx); 
00119                 cont.remove(obj);
00120         }
00121 
00122         template< class Obj >
00123     inline void swap(Obj& first, Obj& second)
00124         {
00125                 Obj temp(first);
00126                 first = second;
00127                 second = temp;
00128         }
00129 }
00130 
00131 #pragma pack()
00132 END_TERIMBER_NAMESPACE
00133 
00134 #endif // _terimber_algorithm_hpp_
00135
algorith.hpp
