← Back to branch summary

~ubuntu-branches/ubuntu/wily/openms/wily

« back to all changes in this revision

Viewing changes to source/CONCEPT/ProgressLogger.C

  • Committer: Package Import Robot
  • Author(s): Filippo Rusconi
  • Date: 2013-12-20 11:30:16 UTC
  • mfrom: (5.1.2 sid)
  • Revision ID: package-import@ubuntu.com-20131220113016-wre5g9bteeheq6he
Tags: 1.11.1-3
* remove version number from libbost development package names;
* ensure that AUTHORS is correctly shipped in all packages.

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/CONCEPT/ProgressLogger.C
1
 
// -*- mode: C++; tab-width: 2; -*-
2
 
// vi: set ts=2:
3
 
//
4
 
// --------------------------------------------------------------------------
5
 
//                   OpenMS Mass Spectrometry Framework
6
 
// --------------------------------------------------------------------------
7
 
//  Copyright (C) 2003-2011 -- Oliver Kohlbacher, Knut Reinert
8
 
//
9
 
//  This library is free software; you can redistribute it and/or
10
 
//  modify it under the terms of the GNU Lesser General Public
11
 
//  License as published by the Free Software Foundation; either
12
 
//  version 2.1 of the License, or (at your option) any later version.
13
 
//
14
 
//  This library is distributed in the hope that it will be useful,
15
 
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
16
 
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17
 
//  Lesser General Public License for more details.
18
 
//
19
 
//  You should have received a copy of the GNU Lesser General Public
20
 
//  License along with this library; if not, write to the Free Software
21
 
//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
1
// --------------------------------------------------------------------------
 
2
//                   OpenMS -- Open-Source Mass Spectrometry
 
3
// --------------------------------------------------------------------------
 
4
// Copyright The OpenMS Team -- Eberhard Karls University Tuebingen,
 
5
// ETH Zurich, and Freie Universitaet Berlin 2002-2013.
 
6
//
 
7
// This software is released under a three-clause BSD license:
 
8
//  * Redistributions of source code must retain the above copyright
 
9
//    notice, this list of conditions and the following disclaimer.
 
10
//  * Redistributions in binary form must reproduce the above copyright
 
11
//    notice, this list of conditions and the following disclaimer in the
 
12
//    documentation and/or other materials provided with the distribution.
 
13
//  * Neither the name of any author or any participating institution
 
14
//    may be used to endorse or promote products derived from this software
 
15
//    without specific prior written permission.
 
16
// For a full list of authors, refer to the file AUTHORS.
 
17
// --------------------------------------------------------------------------
 
18
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 
19
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 
20
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 
21
// ARE DISCLAIMED. IN NO EVENT SHALL ANY OF THE AUTHORS OR THE CONTRIBUTING
 
22
// INSTITUTIONS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 
23
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 
24
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 
25
// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 
26
// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 
27
// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 
28
// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
22
29
//
23
30
// --------------------------------------------------------------------------
24
31
// $Maintainer: Stephan Aiche$
38
45
 
39
46
namespace OpenMS
40
47
{
41
 
        int ProgressLogger::recursion_depth_ = 0;
42
 
 
43
 
        ProgressLogger::ProgressLogger()
44
 
                :       type_(NONE),
45
 
                        begin_(0),
46
 
                        end_(0),
47
 
                        value_(0),
48
 
                        dlg_(0),
49
 
                        stop_watch_(),
50
 
                        last_invoke_()
51
 
        {
52
 
        }
53
 
 
54
 
        ProgressLogger::~ProgressLogger()
55
 
        {
56
 
                delete(dlg_);
57
 
        }
58
 
 
59
 
        void ProgressLogger::setLogType(LogType type) const
60
 
        {
61
 
                type_ = type;
62
 
        }
63
 
 
64
 
        ProgressLogger::LogType ProgressLogger::getLogType() const
65
 
        {
66
 
                return type_;
67
 
        }
68
 
 
69
 
 
70
 
        void ProgressLogger::startProgress(SignedSize begin, SignedSize end, const String& label) const
71
 
        {
72
 
                OPENMS_PRECONDITION(begin <= end, "ProgressLogger::init : invalid range!");
73
 
                last_invoke_ = time (NULL);
74
 
                
75
 
                switch (type_)
76
 
                {
77
 
                        case CMD:
78
 
                                begin_ = begin;
79
 
                                end_ = end;
80
 
                                if ( recursion_depth_ ) cout << '\n';
81
 
                                cout << string(2*recursion_depth_,' ') << "Progress of '" << label << "':" << endl;
82
 
                                stop_watch_.reset();
83
 
                                stop_watch_.start();
84
 
                                break;
85
 
                        case GUI:
86
 
                                begin_ = begin;
87
 
                                end_ = end;
88
 
                                if(!dlg_) dlg_ = new QProgressDialog(label.c_str(), QString(), int(begin), int(end));
89
 
                                dlg_->setWindowTitle(label.c_str());
90
 
                                dlg_->setWindowModality(Qt::WindowModal);
91
 
                                dlg_->show();
92
 
                                break;
93
 
                        case NONE:
94
 
                                break;
95
 
                };
96
 
                ++recursion_depth_;
97
 
                return;
98
 
        }
99
 
 
100
 
        void ProgressLogger::setProgress(SignedSize value) const
101
 
        {
102
 
                // update only if at least 1 second has passed
103
 
                if (last_invoke_ == time (NULL)) return;
104
 
                
105
 
                last_invoke_ = time (NULL);
106
 
        
107
 
                switch (type_)
108
 
                {
109
 
                        case CMD:
110
 
                                if (begin_==end_)
111
 
                                {
112
 
                                        cout << '.' << flush;
113
 
                                }
114
 
                                else if (value<begin_ || value >end_)
115
 
                                {
116
 
                                        cout << "ProgressLogger: Invalid progress value '" << value
117
 
                                                         << "'. Should be between '" << begin_ << "' and '" << end_ << "'!" << endl;
118
 
                                }
119
 
                                else
120
 
                                {
121
 
                                        cout << '\r' << string(2*recursion_depth_,' ') << QString::number(Real(value -begin_) / Real(end_ - begin_) * 100.0,'f',2).toStdString()  << " %               ";
122
 
                                        cout << flush;
123
 
                                }
124
 
                                break;
125
 
                        case GUI:
126
 
                                if (value<begin_ || value >end_)
127
 
                                {
128
 
                                        cout << "ProgressLogger: Invalid progress value '" << value << "'. Should be between '" << begin_ << "' and '" << end_ << "'!" << endl;
129
 
                                }
130
 
                                else
131
 
                                {
132
 
                                        if (dlg_)
133
 
                                        {
134
 
                                                dlg_->setValue((int)value);
135
 
                                        }
136
 
                                        else
137
 
                                        {
138
 
                                                cout << "ProgressLogger warning: 'setValue' called before 'startProgress'!" << endl;
139
 
                                        }
140
 
                                }
141
 
                                break;
142
 
                        case NONE:
143
 
                                break;
144
 
                };
145
 
        }
146
 
 
147
 
        void ProgressLogger::endProgress() const
148
 
        {
149
 
                if (recursion_depth_) --recursion_depth_;
150
 
                switch (type_)
151
 
                {
152
 
                        case CMD:
153
 
                                stop_watch_.stop();
154
 
                                if (begin_==end_)
155
 
                                {
156
 
                                        if ( recursion_depth_ ) cout << '\n';
157
 
          cout << endl << string(2*recursion_depth_,' ') << "-- done [took " << String::number(stop_watch_.getCPUTime(),3) << " s(CPU), " << String::number(stop_watch_.getClockTime(),3) << " s(Wall)] -- " << endl;
158
 
                                }
159
 
                                else
160
 
                                {
161
 
                                        cout << '\r' << string(2*recursion_depth_,' ') << "-- done [took " << String::number(stop_watch_.getCPUTime(),3) << " s(CPU), " << String::number(stop_watch_.getClockTime(),3) << " s(Wall)] -- " << endl;
162
 
                                }
163
 
                                break;
164
 
                        case GUI:
165
 
                                if (dlg_)
166
 
                                {
167
 
                                        dlg_->setValue((int)end_);
168
 
                                }
169
 
                                else
170
 
                                {
171
 
                                        cout << "ProgressLogger warning: 'endProgress' called before 'startProgress'!" << endl;
172
 
                                }
173
 
                                break;
174
 
                        case NONE:
175
 
                                break;
176
 
                };
177
 
        }
178
 
 
179
 
}//namespace OpenMS
 
48
  int ProgressLogger::recursion_depth_ = 0;
 
49
 
 
50
  ProgressLogger::ProgressLogger() :
 
51
    type_(NONE),
 
52
    begin_(0),
 
53
    end_(0),
 
54
    value_(0),
 
55
    dlg_(0),
 
56
    stop_watch_(),
 
57
    last_invoke_()
 
58
  {
 
59
  }
 
60
 
 
61
  ProgressLogger::~ProgressLogger()
 
62
  {
 
63
    delete(dlg_);
 
64
  }
 
65
 
 
66
  void ProgressLogger::setLogType(LogType type) const
 
67
  {
 
68
    type_ = type;
 
69
  }
 
70
 
 
71
  ProgressLogger::LogType ProgressLogger::getLogType() const
 
72
  {
 
73
    return type_;
 
74
  }
 
75
 
 
76
  void ProgressLogger::startProgress(SignedSize begin, SignedSize end, const String & label) const
 
77
  {
 
78
    OPENMS_PRECONDITION(begin <= end, "ProgressLogger::init : invalid range!");
 
79
    last_invoke_ = time(NULL);
 
80
 
 
81
    switch (type_)
 
82
    {
 
83
    case CMD:
 
84
      begin_ = begin;
 
85
      end_ = end;
 
86
      if (recursion_depth_)
 
87
        cout << '\n';
 
88
      cout << string(2 * recursion_depth_, ' ') << "Progress of '" << label << "':" << endl;
 
89
      stop_watch_.reset();
 
90
      stop_watch_.start();
 
91
      break;
 
92
 
 
93
    case GUI:
 
94
      begin_ = begin;
 
95
      end_ = end;
 
96
      if (!dlg_)
 
97
        dlg_ = new QProgressDialog(label.c_str(), QString(), int(begin), int(end));
 
98
      dlg_->setWindowTitle(label.c_str());
 
99
      dlg_->setWindowModality(Qt::WindowModal);
 
100
      dlg_->show();
 
101
      break;
 
102
 
 
103
    case NONE:
 
104
      break;
 
105
    }
 
106
    ++recursion_depth_;
 
107
    return;
 
108
  }
 
109
 
 
110
  void ProgressLogger::setProgress(SignedSize value) const
 
111
  {
 
112
    // update only if at least 1 second has passed
 
113
    if (last_invoke_ == time(NULL))
 
114
      return;
 
115
 
 
116
    last_invoke_ = time(NULL);
 
117
 
 
118
    switch (type_)
 
119
    {
 
120
    case CMD:
 
121
      if (begin_ == end_)
 
122
      {
 
123
        cout << '.' << flush;
 
124
      }
 
125
      else if (value < begin_ || value > end_)
 
126
      {
 
127
        cout << "ProgressLogger: Invalid progress value '" << value
 
128
             << "'. Should be between '" << begin_ << "' and '" << end_ << "'!" << endl;
 
129
      }
 
130
      else
 
131
      {
 
132
        cout << '\r' << string(2 * recursion_depth_, ' ') << QString::number(Real(value - begin_) / Real(end_ - begin_) * 100.0, 'f', 2).toStdString()  << " %               ";
 
133
        cout << flush;
 
134
      }
 
135
      break;
 
136
 
 
137
    case GUI:
 
138
      if (value < begin_ || value > end_)
 
139
      {
 
140
        cout << "ProgressLogger: Invalid progress value '" << value << "'. Should be between '" << begin_ << "' and '" << end_ << "'!" << endl;
 
141
      }
 
142
      else
 
143
      {
 
144
        if (dlg_)
 
145
        {
 
146
          dlg_->setValue((int)value);
 
147
        }
 
148
        else
 
149
        {
 
150
          cout << "ProgressLogger warning: 'setValue' called before 'startProgress'!" << endl;
 
151
        }
 
152
      }
 
153
      break;
 
154
 
 
155
    case NONE:
 
156
      break;
 
157
    }
 
158
  }
 
159
 
 
160
  void ProgressLogger::endProgress() const
 
161
  {
 
162
    if (recursion_depth_)
 
163
    {
 
164
      --recursion_depth_;
 
165
    }
 
166
 
 
167
    switch (type_)
 
168
    {
 
169
    case CMD:
 
170
      stop_watch_.stop();
 
171
      if (begin_ == end_)
 
172
      {
 
173
        if (recursion_depth_)
 
174
        {
 
175
          cout << '\n';
 
176
        }
 
177
        cout << endl << string(2 * recursion_depth_, ' ') << "-- done [took " << StopWatch::toString(stop_watch_.getCPUTime()) << " (CPU), " << StopWatch::toString(stop_watch_.getClockTime()) << " (Wall)] -- " << endl;
 
178
      }
 
179
      else
 
180
      {
 
181
        cout << '\r' << string(2 * recursion_depth_, ' ') << "-- done [took " << StopWatch::toString(stop_watch_.getCPUTime()) << " (CPU), " <<StopWatch::toString(stop_watch_.getClockTime()) << " (Wall)] -- " << endl;
 
182
      }
 
183
      break;
 
184
 
 
185
    case GUI:
 
186
      if (dlg_)
 
187
      {
 
188
        dlg_->setValue((int)end_);
 
189
      }
 
190
      else
 
191
      {
 
192
        cout << "ProgressLogger warning: 'endProgress' called before 'startProgress'!" << endl;
 
193
      }
 
194
      break;
 
195
 
 
196
    case NONE:
 
197
      break;
 
198
    }
 
199
  }
 
200
 
 
201
} //namespace OpenMS