← Back to branch summary

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

« back to all changes in this revision

Viewing changes to include/OpenMS/FORMAT/FastaIteratorIntern.h

  • 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:
include/OpenMS/FORMAT/FastaIteratorIntern.h
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: Clemens Groepl, Andreas Bertsch $
36
43
namespace OpenMS
37
44
{
38
45
 
39
 
        /**
40
 
                @brief Iterator for a FASTA file
41
 
                
42
 
                In comparision to FastaIterator the FASTA file will be loaded first and stored to RAM, while the FastaIterator just iterates over the FASTA file without loading it completly to memory.
43
 
                
44
 
                @see FastaIterator
45
 
        */
46
 
        class OPENMS_DLLAPI FastaIteratorIntern : public PepIterator
47
 
        {
48
 
        
49
 
                public: 
50
 
                        
51
 
                        typedef std::pair<String,String> FASTAEntry;
52
 
                        
53
 
                        /**
54
 
                        @brief constructor
55
 
                        */
56
 
                        FastaIteratorIntern();
57
 
                        
58
 
                        /**
59
 
                        @brief copy constructor
60
 
                        */
61
 
                        FastaIteratorIntern(const FastaIteratorIntern&);
62
 
                
63
 
                        /**
64
 
                        @brief constructor
65
 
                        */
66
 
                        virtual ~FastaIteratorIntern();
67
 
                
68
 
                        /**
69
 
                        @brief * Operator for derefering of iterator
70
 
                        @return FASTEEntry iterator at actual position
71
 
                        @throw Exception::InvalidIterator if iterator has not been initialized
72
 
                        */
73
 
                        virtual FASTAEntry operator*();
74
 
                        
75
 
                        /**
76
 
                        @brief ++ Operator for the iterator
77
 
                        @return reference to PepIterator
78
 
                        @throw Exception::InvalidIterator if iterator has not been initialized
79
 
                        */
80
 
                        virtual PepIterator & operator++();
81
 
                        
82
 
                        /**
83
 
                        @brief ++ Operator for the iterator
84
 
                        @return pointer to PepIterator
85
 
                        @throw Exception::InvalidIterator if iterator has not been initialized
86
 
                        */
87
 
                        virtual PepIterator * operator++(int i);
88
 
                        
89
 
                        /**
90
 
                        @brief setter for FASTA file
91
 
                        @param f const String reference representing file location
92
 
                        @throw Exception::FileNotFound
93
 
                        @throw Exception::ParseError
94
 
                        */
95
 
                        virtual void setFastaFile (const String & f);
96
 
                
97
 
                        /**
98
 
                        @brief getter for FASTA file
99
 
                        @return String with file location
100
 
                        */
101
 
                        virtual String getFastaFile();
102
 
                        
103
 
                        /**
104
 
                        @brief setter for spectrum
105
 
                        @note note availeble for FastaIterator
106
 
                        @throw Exception::NotImplemented 
107
 
                        */
108
 
                        virtual void setSpectrum (const std::vector<DoubleReal> & /*spec*/)
109
 
                        {
110
 
                                throw Exception::NotImplemented(__FILE__, __LINE__, __PRETTY_FUNCTION__);
111
 
                        };
112
 
                
113
 
                        /**
114
 
                        @brief getter for spectrum
115
 
                        @note note availeble for FastaIterator
116
 
                        @throw Exception::NotImplemented 
117
 
                        */
118
 
                        virtual const std::vector<DoubleReal> & getSpectrum ()
119
 
                        {
120
 
                                throw Exception::NotImplemented(__FILE__, __LINE__, __PRETTY_FUNCTION__);
121
 
                        };
122
 
                        
123
 
                        /**
124
 
                        @brief setter for tolerance
125
 
                        @note note availeble for FastaIterator
126
 
                        @throw Exception::NotImplemented 
127
 
                        */
128
 
                        virtual void setTolerance (DoubleReal /* t */)
129
 
                        {
130
 
                                throw Exception::NotImplemented(__FILE__, __LINE__, __PRETTY_FUNCTION__);
131
 
                        };
132
 
                        
133
 
                        /**
134
 
                        @brief getter for tolerance
135
 
                        @note note availeble for FastaIterator
136
 
                        @return tolerance
137
 
                        @throw Exception::NotImplemented 
138
 
                        */
139
 
                        virtual DoubleReal getTolerance()
140
 
                        {
141
 
                                throw Exception::NotImplemented(__FILE__, __LINE__, __PRETTY_FUNCTION__);
142
 
                        };
143
 
                
144
 
                        /**
145
 
                        @brief initializing of iterator
146
 
                        @return true if everything went rigth
147
 
                        @throw Exception::InvalidIterator if fastaFile was not set
148
 
                        */      
149
 
                        virtual bool begin ();
150
 
                        
151
 
                        /**
152
 
                        @brief indicates whether iterator is at end
153
 
                        @return bool true if interator is at end
154
 
                        */
155
 
                        virtual bool isAtEnd ();
156
 
                
157
 
                        /**
158
 
                        @brief needed by Factory
159
 
                        @return const string name of class
160
 
                        */
161
 
                        static const std::string getProductName()
162
 
                        {
163
 
                                return "FastaIteratorIntern";
164
 
                        }
165
 
                
166
 
                        /**
167
 
                        @brief needed by Factory
168
 
                        @return poiter to new object
169
 
                        */
170
 
                        static PepIterator * create()
171
 
                        {
172
 
                                return new FastaIteratorIntern;
173
 
                        }
174
 
                        
175
 
                
176
 
                
177
 
                protected:
178
 
        
179
 
                        String fasta_file_; ///< location of the fasta file
180
 
                
181
 
                        std::vector<FASTAEntry > entrys_; ///< content of fasta file
182
 
                
183
 
                        std::vector<FASTAEntry >::iterator it_; ///< iterator over fasta file content
184
 
        
185
 
        };
 
46
  /**
 
47
      @brief Iterator for a FASTA file
 
48
 
 
49
      In comparision to FastaIterator the FASTA file will be loaded first and stored to RAM, while the FastaIterator just iterates over the FASTA file without loading it completly to memory.
 
50
 
 
51
      @see FastaIterator
 
52
  */
 
53
  class OPENMS_DLLAPI FastaIteratorIntern :
 
54
    public PepIterator
 
55
  {
 
56
 
 
57
public:
 
58
 
 
59
    typedef std::pair<String, String> FASTAEntry;
 
60
 
 
61
    /**
 
62
    @brief constructor
 
63
    */
 
64
    FastaIteratorIntern();
 
65
 
 
66
    /**
 
67
    @brief copy constructor
 
68
    */
 
69
    FastaIteratorIntern(const FastaIteratorIntern &);
 
70
 
 
71
    /**
 
72
    @brief constructor
 
73
    */
 
74
    virtual ~FastaIteratorIntern();
 
75
 
 
76
    /**
 
77
    @brief * Operator for derefering of iterator
 
78
    @return FASTEEntry iterator at actual position
 
79
    @throw Exception::InvalidIterator if iterator has not been initialized
 
80
    */
 
81
    virtual FASTAEntry operator*();
 
82
 
 
83
    /**
 
84
    @brief ++ Operator for the iterator
 
85
    @return reference to PepIterator
 
86
    @throw Exception::InvalidIterator if iterator has not been initialized
 
87
    */
 
88
    virtual PepIterator & operator++();
 
89
 
 
90
    /**
 
91
    @brief ++ Operator for the iterator
 
92
    @return pointer to PepIterator
 
93
    @throw Exception::InvalidIterator if iterator has not been initialized
 
94
    */
 
95
    virtual PepIterator * operator++(int i);
 
96
 
 
97
    /**
 
98
    @brief setter for FASTA file
 
99
    @param f const String reference representing file location
 
100
    @throw Exception::FileNotFound
 
101
    @throw Exception::ParseError
 
102
    */
 
103
    virtual void setFastaFile(const String & f);
 
104
 
 
105
    /**
 
106
    @brief getter for FASTA file
 
107
    @return String with file location
 
108
    */
 
109
    virtual String getFastaFile();
 
110
 
 
111
    /**
 
112
    @brief setter for spectrum
 
113
    @note note availeble for FastaIterator
 
114
    @throw Exception::NotImplemented
 
115
    */
 
116
    virtual void setSpectrum(const std::vector<DoubleReal> & /*spec*/)
 
117
    {
 
118
      throw Exception::NotImplemented(__FILE__, __LINE__, __PRETTY_FUNCTION__);
 
119
    }
 
120
 
 
121
    /**
 
122
    @brief getter for spectrum
 
123
    @note note availeble for FastaIterator
 
124
    @throw Exception::NotImplemented
 
125
    */
 
126
    virtual const std::vector<DoubleReal> & getSpectrum()
 
127
    {
 
128
      throw Exception::NotImplemented(__FILE__, __LINE__, __PRETTY_FUNCTION__);
 
129
    }
 
130
 
 
131
    /**
 
132
    @brief setter for tolerance
 
133
    @note note availeble for FastaIterator
 
134
    @throw Exception::NotImplemented
 
135
    */
 
136
    virtual void setTolerance(DoubleReal /* t */)
 
137
    {
 
138
      throw Exception::NotImplemented(__FILE__, __LINE__, __PRETTY_FUNCTION__);
 
139
    }
 
140
 
 
141
    /**
 
142
    @brief getter for tolerance
 
143
    @note note availeble for FastaIterator
 
144
    @return tolerance
 
145
    @throw Exception::NotImplemented
 
146
    */
 
147
    virtual DoubleReal getTolerance()
 
148
    {
 
149
      throw Exception::NotImplemented(__FILE__, __LINE__, __PRETTY_FUNCTION__);
 
150
    }
 
151
 
 
152
    /**
 
153
    @brief initializing of iterator
 
154
    @return true if everything went rigth
 
155
    @throw Exception::InvalidIterator if fastaFile was not set
 
156
    */
 
157
    virtual bool begin();
 
158
 
 
159
    /**
 
160
    @brief indicates whether iterator is at end
 
161
    @return bool true if interator is at end
 
162
    */
 
163
    virtual bool isAtEnd();
 
164
 
 
165
    /**
 
166
    @brief needed by Factory
 
167
    @return const string name of class
 
168
    */
 
169
    static const std::string getProductName()
 
170
    {
 
171
      return "FastaIteratorIntern";
 
172
    }
 
173
 
 
174
    /**
 
175
    @brief needed by Factory
 
176
    @return poiter to new object
 
177
    */
 
178
    static PepIterator * create()
 
179
    {
 
180
      return new FastaIteratorIntern;
 
181
    }
 
182
 
 
183
protected:
 
184
 
 
185
    String fasta_file_;         ///< location of the fasta file
 
186
 
 
187
    std::vector<FASTAEntry> entrys_;          ///< content of fasta file
 
188
 
 
189
    std::vector<FASTAEntry>::iterator it_;          ///< iterator over fasta file content
 
190
 
 
191
  };
186
192
 
187
193
}
188
194