← Back to branch summary

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

« back to all changes in this revision

Viewing changes to source/METADATA/SpectrumSettings.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/METADATA/SpectrumSettings.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: Andreas Bertsch $
33
40
namespace OpenMS
34
41
{
35
42
 
36
 
        const std::string SpectrumSettings::NamesOfSpectrumType[] = {"Unknown","Peak data","Raw data"};
37
 
 
38
 
        SpectrumSettings::SpectrumSettings()
39
 
                : MetaInfoInterface(),
40
 
                        type_(UNKNOWN),
41
 
                        native_id_(),
42
 
                        comment_(),
43
 
                        instrument_settings_(),
44
 
                        source_file_(),
45
 
                        acquisition_info_(),
46
 
                        precursors_(),
47
 
                        products_(),
48
 
                        identification_(),
49
 
                        data_processing_()
50
 
        {
51
 
        }
52
 
 
53
 
        SpectrumSettings::SpectrumSettings(const SpectrumSettings& source)
54
 
                : MetaInfoInterface(source),
55
 
                        type_(source.type_),
56
 
                        native_id_(source.native_id_),
57
 
                        comment_(source.comment_),
58
 
                        instrument_settings_(source.instrument_settings_),
59
 
                        source_file_(source.source_file_),
60
 
                        acquisition_info_(source.acquisition_info_),
61
 
                        precursors_(source.precursors_),
62
 
                        products_(source.products_),
63
 
                        identification_(source.identification_),
64
 
                        data_processing_(source.data_processing_)
65
 
        {
66
 
        }
67
 
        
68
 
        SpectrumSettings::~SpectrumSettings()
69
 
        {         
70
 
        }
71
 
        
72
 
        SpectrumSettings& SpectrumSettings::operator = (const SpectrumSettings& source)
73
 
        {
74
 
          if (&source == this) return *this;
75
 
          
76
 
          MetaInfoInterface::operator=(source);
77
 
          type_ = source.type_;
78
 
          native_id_ = source.native_id_;
 
43
  const std::string SpectrumSettings::NamesOfSpectrumType[] = {"Unknown", "Peak data", "Raw data"};
 
44
 
 
45
  SpectrumSettings::SpectrumSettings() :
 
46
    MetaInfoInterface(),
 
47
    type_(UNKNOWN),
 
48
    native_id_(),
 
49
    comment_(),
 
50
    instrument_settings_(),
 
51
    source_file_(),
 
52
    acquisition_info_(),
 
53
    precursors_(),
 
54
    products_(),
 
55
    identification_(),
 
56
    data_processing_()
 
57
  {
 
58
  }
 
59
 
 
60
  SpectrumSettings::SpectrumSettings(const SpectrumSettings & source) :
 
61
    MetaInfoInterface(source),
 
62
    type_(source.type_),
 
63
    native_id_(source.native_id_),
 
64
    comment_(source.comment_),
 
65
    instrument_settings_(source.instrument_settings_),
 
66
    source_file_(source.source_file_),
 
67
    acquisition_info_(source.acquisition_info_),
 
68
    precursors_(source.precursors_),
 
69
    products_(source.products_),
 
70
    identification_(source.identification_),
 
71
    data_processing_(source.data_processing_)
 
72
  {
 
73
  }
 
74
 
 
75
  SpectrumSettings::~SpectrumSettings()
 
76
  {
 
77
  }
 
78
 
 
79
  SpectrumSettings & SpectrumSettings::operator=(const SpectrumSettings & source)
 
80
  {
 
81
    if (&source == this)
 
82
      return *this;
 
83
 
 
84
    MetaInfoInterface::operator=(source);
 
85
    type_ = source.type_;
 
86
    native_id_ = source.native_id_;
79
87
    comment_ = source.comment_;
80
88
    instrument_settings_ = source.instrument_settings_;
81
89
    acquisition_info_ = source.acquisition_info_;
82
90
    source_file_ = source.source_file_;
83
91
    precursors_ = source.precursors_;
84
 
          products_ = source.products_;
 
92
    products_ = source.products_;
85
93
    identification_ = source.identification_;
86
 
          data_processing_ = source.data_processing_;
87
 
                
88
 
          return *this;
89
 
        }
90
 
 
91
 
  bool SpectrumSettings::operator== (const SpectrumSettings& rhs) const
92
 
  {
93
 
        return
94
 
                MetaInfoInterface::operator==(rhs) &&
95
 
                type_ == rhs.type_ &&
96
 
                        native_id_ == rhs.native_id_ &&
97
 
            comment_ == rhs.comment_ &&
98
 
            instrument_settings_ == rhs.instrument_settings_ &&
99
 
            acquisition_info_ == rhs.acquisition_info_ &&
100
 
                  source_file_ == rhs.source_file_ &&
101
 
            precursors_ == rhs.precursors_ &&
102
 
            products_ == rhs.products_ &&
103
 
            identification_ == rhs.identification_ &&
104
 
                        data_processing_ == rhs.data_processing_
105
 
                ;
106
 
  }
107
 
 
108
 
  bool SpectrumSettings::operator!= (const SpectrumSettings& rhs) const
109
 
  {
110
 
        return !(operator==(rhs));
111
 
        }
112
 
 
113
 
  void SpectrumSettings::unify(const SpectrumSettings& rhs)
 
94
    data_processing_ = source.data_processing_;
 
95
 
 
96
    return *this;
 
97
  }
 
98
 
 
99
  bool SpectrumSettings::operator==(const SpectrumSettings & rhs) const
 
100
  {
 
101
    return MetaInfoInterface::operator==(rhs) &&
 
102
           type_ == rhs.type_ &&
 
103
           native_id_ == rhs.native_id_ &&
 
104
           comment_ == rhs.comment_ &&
 
105
           instrument_settings_ == rhs.instrument_settings_ &&
 
106
           acquisition_info_ == rhs.acquisition_info_ &&
 
107
           source_file_ == rhs.source_file_ &&
 
108
           precursors_ == rhs.precursors_ &&
 
109
           products_ == rhs.products_ &&
 
110
           identification_ == rhs.identification_ &&
 
111
           data_processing_ == rhs.data_processing_;
 
112
  }
 
113
 
 
114
  bool SpectrumSettings::operator!=(const SpectrumSettings & rhs) const
 
115
  {
 
116
    return !(operator==(rhs));
 
117
  }
 
118
 
 
119
  void SpectrumSettings::unify(const SpectrumSettings & rhs)
114
120
  {
115
121
    // append metavalues (overwrite when already present)
116
 
    std::vector< UInt > keys;
117
 
    rhs.getKeys (keys);
118
 
    for (Size i=0;i<keys.size();++i) setMetaValue(keys[i], rhs.getMetaValue(keys[i]));
119
 
    
120
 
    
121
 
    if (type_ != rhs.type_) type_ = UNKNOWN; // only keep if both are equal
 
122
    std::vector<UInt> keys;
 
123
    rhs.getKeys(keys);
 
124
    for (Size i = 0; i < keys.size(); ++i)
 
125
      setMetaValue(keys[i], rhs.getMetaValue(keys[i]));
 
126
 
 
127
 
 
128
    if (type_ != rhs.type_)
 
129
      type_ = UNKNOWN;                       // only keep if both are equal
122
130
    //native_id_ == rhs.native_id_ // keep
123
 
          comment_ += rhs.comment_;      // append
124
 
          //instrument_settings_ == rhs.instrument_settings_  // keep
125
 
          //acquisition_info_ == rhs.acquisition_info_ 
126
 
                //source_file_ == rhs.source_file_ &&
 
131
    comment_ += rhs.comment_;        // append
 
132
    //instrument_settings_ == rhs.instrument_settings_  // keep
 
133
    //acquisition_info_ == rhs.acquisition_info_
 
134
    //source_file_ == rhs.source_file_ &&
127
135
    precursors_.insert(precursors_.end(), rhs.precursors_.begin(), rhs.precursors_.end());
128
 
          products_.insert(products_.end(), rhs.products_.begin(), rhs.products_.end() );
129
 
    identification_.insert(identification_.end(), rhs.identification_.begin(), rhs.identification_.end() );
130
 
          data_processing_.insert(data_processing_.end(), rhs.data_processing_.begin(), rhs.data_processing_.end() );
131
 
  }
132
 
 
133
 
        SpectrumSettings::SpectrumType SpectrumSettings::getType() const
134
 
        {
135
 
                return type_;   
136
 
        }
137
 
 
138
 
        void SpectrumSettings::setType(SpectrumSettings::SpectrumType type)
139
 
        {
140
 
                type_ = type;
141
 
        }
142
 
        
143
 
        const String& SpectrumSettings::getComment() const 
144
 
        {
145
 
          return comment_; 
146
 
        }
147
 
        
148
 
        void SpectrumSettings::setComment(const String& comment)
149
 
        {
150
 
          comment_ = comment; 
151
 
        }
152
 
        
153
 
        const InstrumentSettings& SpectrumSettings::getInstrumentSettings() const 
154
 
        {
155
 
          return instrument_settings_; 
156
 
        }
157
 
        
158
 
        InstrumentSettings&  SpectrumSettings::getInstrumentSettings()
159
 
        {
160
 
          return instrument_settings_; 
161
 
        }
162
 
        
163
 
        void SpectrumSettings::setInstrumentSettings(const InstrumentSettings& instrument_settings)
164
 
        {
165
 
          instrument_settings_ = instrument_settings; 
166
 
        }
167
 
        
168
 
        const AcquisitionInfo& SpectrumSettings::getAcquisitionInfo() const 
169
 
        {
170
 
          return acquisition_info_; 
171
 
        }
172
 
        
173
 
        AcquisitionInfo&  SpectrumSettings::getAcquisitionInfo()
174
 
        {
175
 
          return acquisition_info_; 
176
 
        }
177
 
        
178
 
        void SpectrumSettings::setAcquisitionInfo(const AcquisitionInfo& acquisition_info)
179
 
        {
180
 
          acquisition_info_ = acquisition_info; 
181
 
        }
182
 
        
183
 
        const SourceFile& SpectrumSettings::getSourceFile() const 
184
 
        {
185
 
          return source_file_; 
186
 
        }
187
 
        
188
 
        SourceFile&  SpectrumSettings::getSourceFile()
189
 
        {
190
 
          return source_file_; 
191
 
        }
192
 
        
193
 
        void SpectrumSettings::setSourceFile(const SourceFile& source_file)
194
 
        {
195
 
          source_file_ = source_file; 
196
 
        }
197
 
        
198
 
        const vector<Precursor>& SpectrumSettings::getPrecursors() const 
199
 
        {
200
 
          return precursors_; 
201
 
        }
202
 
        
203
 
        vector<Precursor>&  SpectrumSettings::getPrecursors()
204
 
        {
205
 
          return precursors_; 
206
 
        }
207
 
        
208
 
        void SpectrumSettings::setPrecursors(const vector<Precursor>& precursors)
209
 
        {
210
 
          precursors_ = precursors; 
211
 
        }
212
 
 
213
 
        const vector<Product>& SpectrumSettings::getProducts() const 
214
 
        {
215
 
          return products_; 
216
 
        }
217
 
        
218
 
        vector<Product>&  SpectrumSettings::getProducts()
219
 
        {
220
 
          return products_; 
221
 
        }
222
 
        
223
 
        void SpectrumSettings::setProducts(const vector<Product>& products)
224
 
        {
225
 
          products_ = products; 
226
 
        }
227
 
 
228
 
        std::ostream& operator << (std::ostream& os, const SpectrumSettings& /*spec*/)
229
 
        {
230
 
                os << "-- SPECTRUMSETTINGS BEGIN --"<<std::endl;
231
 
                os << "-- SPECTRUMSETTINGS END --"<<std::endl;          
232
 
                return os;
233
 
        }
234
 
        
235
 
  const std::vector<PeptideIdentification>& SpectrumSettings::getPeptideIdentifications() const 
236
 
  {
237
 
        return identification_;
238
 
  }
239
 
 
240
 
  std::vector<PeptideIdentification>& SpectrumSettings::getPeptideIdentifications() 
241
 
  {
242
 
        return identification_;
243
 
  }
244
 
 
245
 
        void SpectrumSettings::setPeptideIdentifications(const std::vector<PeptideIdentification>& identification)
246
 
        {
247
 
                identification_ = identification;
248
 
        }
249
 
 
250
 
  const String& SpectrumSettings::getNativeID() const
251
 
        {
252
 
                return native_id_;
253
 
        }
254
 
        
255
 
  void SpectrumSettings::setNativeID(const String& native_id)
256
 
        {
257
 
                native_id_ = native_id;
258
 
        }
259
 
 
260
 
        const vector<DataProcessing>& SpectrumSettings::getDataProcessing() const 
261
 
        {
262
 
          return data_processing_; 
263
 
        }
264
 
        
265
 
        vector<DataProcessing>&  SpectrumSettings::getDataProcessing()
266
 
        {
267
 
          return data_processing_; 
268
 
        }
269
 
        
270
 
        void SpectrumSettings::setDataProcessing(const vector<DataProcessing>& processing_method)
271
 
        {
272
 
          data_processing_ = processing_method; 
273
 
        }
274
 
        
 
136
    products_.insert(products_.end(), rhs.products_.begin(), rhs.products_.end());
 
137
    identification_.insert(identification_.end(), rhs.identification_.begin(), rhs.identification_.end());
 
138
    data_processing_.insert(data_processing_.end(), rhs.data_processing_.begin(), rhs.data_processing_.end());
 
139
  }
 
140
 
 
141
  SpectrumSettings::SpectrumType SpectrumSettings::getType() const
 
142
  {
 
143
    return type_;
 
144
  }
 
145
 
 
146
  void SpectrumSettings::setType(SpectrumSettings::SpectrumType type)
 
147
  {
 
148
    type_ = type;
 
149
  }
 
150
 
 
151
  const String & SpectrumSettings::getComment() const
 
152
  {
 
153
    return comment_;
 
154
  }
 
155
 
 
156
  void SpectrumSettings::setComment(const String & comment)
 
157
  {
 
158
    comment_ = comment;
 
159
  }
 
160
 
 
161
  const InstrumentSettings & SpectrumSettings::getInstrumentSettings() const
 
162
  {
 
163
    return instrument_settings_;
 
164
  }
 
165
 
 
166
  InstrumentSettings & SpectrumSettings::getInstrumentSettings()
 
167
  {
 
168
    return instrument_settings_;
 
169
  }
 
170
 
 
171
  void SpectrumSettings::setInstrumentSettings(const InstrumentSettings & instrument_settings)
 
172
  {
 
173
    instrument_settings_ = instrument_settings;
 
174
  }
 
175
 
 
176
  const AcquisitionInfo & SpectrumSettings::getAcquisitionInfo() const
 
177
  {
 
178
    return acquisition_info_;
 
179
  }
 
180
 
 
181
  AcquisitionInfo & SpectrumSettings::getAcquisitionInfo()
 
182
  {
 
183
    return acquisition_info_;
 
184
  }
 
185
 
 
186
  void SpectrumSettings::setAcquisitionInfo(const AcquisitionInfo & acquisition_info)
 
187
  {
 
188
    acquisition_info_ = acquisition_info;
 
189
  }
 
190
 
 
191
  const SourceFile & SpectrumSettings::getSourceFile() const
 
192
  {
 
193
    return source_file_;
 
194
  }
 
195
 
 
196
  SourceFile & SpectrumSettings::getSourceFile()
 
197
  {
 
198
    return source_file_;
 
199
  }
 
200
 
 
201
  void SpectrumSettings::setSourceFile(const SourceFile & source_file)
 
202
  {
 
203
    source_file_ = source_file;
 
204
  }
 
205
 
 
206
  const vector<Precursor> & SpectrumSettings::getPrecursors() const
 
207
  {
 
208
    return precursors_;
 
209
  }
 
210
 
 
211
  vector<Precursor> & SpectrumSettings::getPrecursors()
 
212
  {
 
213
    return precursors_;
 
214
  }
 
215
 
 
216
  void SpectrumSettings::setPrecursors(const vector<Precursor> & precursors)
 
217
  {
 
218
    precursors_ = precursors;
 
219
  }
 
220
 
 
221
  const vector<Product> & SpectrumSettings::getProducts() const
 
222
  {
 
223
    return products_;
 
224
  }
 
225
 
 
226
  vector<Product> & SpectrumSettings::getProducts()
 
227
  {
 
228
    return products_;
 
229
  }
 
230
 
 
231
  void SpectrumSettings::setProducts(const vector<Product> & products)
 
232
  {
 
233
    products_ = products;
 
234
  }
 
235
 
 
236
  std::ostream & operator<<(std::ostream & os, const SpectrumSettings & /*spec*/)
 
237
  {
 
238
    os << "-- SPECTRUMSETTINGS BEGIN --" << std::endl;
 
239
    os << "-- SPECTRUMSETTINGS END --" << std::endl;
 
240
    return os;
 
241
  }
 
242
 
 
243
  const std::vector<PeptideIdentification> & SpectrumSettings::getPeptideIdentifications() const
 
244
  {
 
245
    return identification_;
 
246
  }
 
247
 
 
248
  std::vector<PeptideIdentification> & SpectrumSettings::getPeptideIdentifications()
 
249
  {
 
250
    return identification_;
 
251
  }
 
252
 
 
253
  void SpectrumSettings::setPeptideIdentifications(const std::vector<PeptideIdentification> & identification)
 
254
  {
 
255
    identification_ = identification;
 
256
  }
 
257
 
 
258
  const String & SpectrumSettings::getNativeID() const
 
259
  {
 
260
    return native_id_;
 
261
  }
 
262
 
 
263
  void SpectrumSettings::setNativeID(const String & native_id)
 
264
  {
 
265
    native_id_ = native_id;
 
266
  }
 
267
 
 
268
  const vector<DataProcessing> & SpectrumSettings::getDataProcessing() const
 
269
  {
 
270
    return data_processing_;
 
271
  }
 
272
 
 
273
  vector<DataProcessing> & SpectrumSettings::getDataProcessing()
 
274
  {
 
275
    return data_processing_;
 
276
  }
 
277
 
 
278
  void SpectrumSettings::setDataProcessing(const vector<DataProcessing> & processing_method)
 
279
  {
 
280
    data_processing_ = processing_method;
 
281
  }
 
282
 
275
283
}
276
 
 
277
 
 
278
 
 
279