CopyHandler

Clone
ixen <ixen@copyhandler.com>
committed
d9527df
on 04 Dec 16
Removed unnecessary includes. Sorted member initialization in constructors. (CH-318)
ch-1.40 + 2 more
src/ch/TSubTaskProgressInfo.cpp (deleted)
1   // ============================================================================
2   //  Copyright (C) 2001-2010 by Jozef Starosczyk
3   //  ixen@copyhandler.com
4   //
5   //  This program is free software; you can redistribute it and/or modify
6   //  it under the terms of the GNU Library General Public License
7   //  (version 2) as published by the Free Software Foundation;
8   //
9   //  This program is distributed in the hope that it will be useful,
10   //  but WITHOUT ANY WARRANTY; without even the implied warranty of
11   //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12   //  GNU General Public License for more details.
13   //
14   //  You should have received a copy of the GNU Library General Public
15   //  License along with this program; if not, write to the
16   //  Free Software Foundation, Inc.,
17   //  59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
18   // ============================================================================
19   /// @file  TSubTaskProgressInfo.cpp
20   /// @date  2010/09/19
21   /// @brief Contains implementation of class handling progress information for subtasks.
22   // ============================================================================
23   #include "stdafx.h"
24   #include "TSubTaskProgressInfo.h"
25   /*
26  
27   ///////////////////////////////////////////////////////////////////////////
28   // TSubTaskProgressInfo
29   TSubTaskProgressInfo::TSubTaskProgressInfo() :
30           m_stProcessedCount(0),
31           m_stTotalCount(0),
32           m_ullProcessedSize(0),
33           m_ullTotalSize(0),
34           m_timeElapsed(0),
35           m_timeLast(-1)
36   {
37   }
38  
39   TSubTaskProgressInfo::~TSubTaskProgressInfo()
40   {
41   }
42  
43   void TSubTaskProgressInfo::GetSnapshot(TSubTaskProgressInfo& rDst) const
44   {
45           boost::unique_lock<boost::shared_mutex> dst_lock(rDst.m_lock);
46           boost::shared_lock<boost::shared_mutex> lock(m_lock);
47  
48           rDst.m_stProcessedCount = m_stProcessedCount;
49           rDst.m_stTotalCount = m_stTotalCount;
50  
51           rDst.m_ullProcessedSize = m_ullProcessedSize;
52           rDst.m_ullTotalSize = m_ullTotalSize;
53  
54           if(m_timeLast != -1)
55                   rDst.m_timeElapsed = m_timeElapsed + time(NULL) - m_timeLast;   // not storing current time to avoid writing to this object
56           else
57                   rDst.m_timeElapsed = m_timeElapsed;
58  
59           rDst.m_timeLast = -1;
60   }
61  
62   void TSubTaskProgressInfo::Clear()
63   {
64           m_stProcessedCount = 0;
65           m_stTotalCount = 0;
66           m_ullProcessedSize = 0;
67           m_ullTotalSize = 0;
68           m_timeElapsed = 0;
69           m_timeLast = -1;
70   }
71  
72   // count-based progress
73   void TSubTaskProgressInfo::IncreaseProcessedCount(size_t stAdd)
74   {
75           boost::unique_lock<boost::shared_mutex> lock(m_lock);
76           m_stProcessedCount += stAdd;
77   }
78  
79   void TSubTaskProgressInfo::DecreaseProcessedCount(size_t stSub)
80   {
81           boost::unique_lock<boost::shared_mutex> lock(m_lock);
82           m_stProcessedCount -= stSub;
83   }
84  
85   void TSubTaskProgressInfo::SetProcessedCount(size_t stSet)
86   {
87           boost::unique_lock<boost::shared_mutex> lock(m_lock);
88           m_stProcessedCount = stSet;
89   }
90  
91   size_t TSubTaskProgressInfo::GetProcessedCount() const
92   {
93           boost::shared_lock<boost::shared_mutex> lock(m_lock);
94           return m_stProcessedCount;
95   }
96  
97   size_t TSubTaskProgressInfo::GetUnProcessedCount() const
98   {
99           boost::shared_lock<boost::shared_mutex> lock(m_lock);
100           return m_stTotalCount - m_stProcessedCount;
101   }
102  
103   void TSubTaskProgressInfo::IncreaseTotalCount(size_t stAdd)
104   {
105           boost::unique_lock<boost::shared_mutex> lock(m_lock);
106           m_stTotalCount += stAdd;
107   }
108  
109   void TSubTaskProgressInfo::DecreaseTotalCount(size_t stSub)
110   {
111           boost::unique_lock<boost::shared_mutex> lock(m_lock);
112           m_stTotalCount -= stSub;
113   }
114  
115   void TSubTaskProgressInfo::SetTotalCount(size_t stSet)
116   {
117           boost::unique_lock<boost::shared_mutex> lock(m_lock);
118           m_stTotalCount = stSet;
119   }
120  
121   size_t TSubTaskProgressInfo::GetTotalCount() const
122   {
123           boost::shared_lock<boost::shared_mutex> lock(m_lock);
124           return m_stTotalCount;
125   }
126  
127   double TSubTaskProgressInfo::GetCountProgressInPercent() const
128   {
129           boost::shared_lock<boost::shared_mutex> lock(m_lock);
130  
131           long double dPercent = 0;
132  
133           if(m_stTotalCount != 0)
134                   dPercent = (long double)m_stProcessedCount / (long double)m_stTotalCount;
135  
136           return (double)dPercent;
137   }
138  
139   // size-based progress
140   void TSubTaskProgressInfo::IncreaseProcessedSize(unsigned long long ullAdd)
141   {
142           boost::unique_lock<boost::shared_mutex> lock(m_lock);
143           m_ullProcessedSize += ullAdd;
144   }
145  
146   void TSubTaskProgressInfo::DecreaseProcessedSize(unsigned long long ullSub)
147   {
148           boost::unique_lock<boost::shared_mutex> lock(m_lock);
149           m_ullProcessedSize -= ullSub;
150   }
151  
152   void TSubTaskProgressInfo::SetProcessedSize(unsigned long long ullSet)
153   {
154           boost::unique_lock<boost::shared_mutex> lock(m_lock);
155           m_ullProcessedSize = ullSet;
156   }
157  
158   unsigned long long TSubTaskProgressInfo::GetProcessedSize() const
159   {
160           boost::shared_lock<boost::shared_mutex> lock(m_lock);
161           return m_ullProcessedSize;
162   }
163  
164   unsigned long long TSubTaskProgressInfo::GetUnProcessedSize() const
165   {
166           boost::shared_lock<boost::shared_mutex> lock(m_lock);
167           return m_ullTotalSize - m_ullProcessedSize;
168   }
169  
170   void TSubTaskProgressInfo::IncreaseTotalSize(unsigned long long ullAdd)
171   {
172           boost::unique_lock<boost::shared_mutex> lock(m_lock);
173           m_ullTotalSize += ullAdd;
174   }
175  
176   void TSubTaskProgressInfo::DecreaseTotalSize(unsigned long long ullSub)
177   {
178           boost::unique_lock<boost::shared_mutex> lock(m_lock);
179           m_ullTotalSize -= ullSub;
180   }
181  
182   void TSubTaskProgressInfo::SetTotalSize(unsigned long long ullSet)
183   {
184           boost::unique_lock<boost::shared_mutex> lock(m_lock);
185           m_ullTotalSize = ullSet;
186   }
187  
188   unsigned long long TSubTaskProgressInfo::GetTotalSize() const
189   {
190           boost::shared_lock<boost::shared_mutex> lock(m_lock);
191           return m_ullTotalSize;
192   }
193  
194   double TSubTaskProgressInfo::GetSizeProgressInPercent() const
195   {
196           boost::shared_lock<boost::shared_mutex> lock(m_lock);
197  
198           long double dPercent = 0;
199  
200           if(m_ullTotalSize != 0)
201                   dPercent = (long double)m_ullProcessedSize / (long double)m_ullTotalSize;
202  
203           return (double)dPercent;
204   }
205  
206   void TSubTaskProgressInfo::SetTimeElapsed(time_t timeElapsed)
207   {
208           boost::unique_lock<boost::shared_mutex> lock(m_lock);
209           m_timeElapsed = timeElapsed;
210   }
211  
212   time_t TSubTaskProgressInfo::GetTimeElapsed()
213   {
214           UpdateTime();
215  
216           boost::shared_lock<boost::shared_mutex> lock(m_lock);
217           return m_timeElapsed;
218   }
219  
220   void TSubTaskProgressInfo::EnableTimeTracking()
221   {
222           boost::upgrade_lock<boost::shared_mutex> lock(m_lock);
223           if(m_timeLast == -1)
224           {
225                   boost::upgrade_to_unique_lock<boost::shared_mutex> lock_upgraded(lock);
226                   m_timeLast = time(NULL);
227           }
228   }
229  
230   void TSubTaskProgressInfo::DisableTimeTracking()
231   {
232           UpdateTime();
233  
234           boost::upgrade_lock<boost::shared_mutex> lock(m_lock);
235           if(m_timeLast != -1)
236           {
237                   boost::upgrade_to_unique_lock<boost::shared_mutex> lock_upgraded(lock);
238                   m_timeLast = -1;
239           }
240   }
241  
242   void TSubTaskProgressInfo::UpdateTime()
243   {
244           boost::upgrade_lock<boost::shared_mutex> lock(m_lock);
245           if(m_timeLast != -1)
246           {
247                   time_t timeCurrent = time(NULL);
248  
249                   boost::upgrade_to_unique_lock<boost::shared_mutex> lock_upgraded(lock);
250                   m_timeElapsed += timeCurrent - m_timeLast;
251                   m_timeLast = timeCurrent;
252           }
253   }
254   */