9
Copyright or © or Copr. CNRS, (November 17, 2004)
11
This software is a computer program whose purpose is to provide classes
12
for sequences analysis.
14
This software is governed by the CeCILL license under French law and
15
abiding by the rules of distribution of free software. You can use,
16
modify and/ or redistribute the software under the terms of the CeCILL
17
license as circulated by CEA, CNRS and INRIA at the following URL
18
"http://www.cecill.info".
20
As a counterpart to the access to the source code and rights to copy,
21
modify and redistribute granted by the license, users are provided only
22
with a limited warranty and the software's author, the holder of the
23
economic rights, and the successive licensors have only limited
26
In this respect, the user's attention is drawn to the risks associated
27
with loading, using, modifying and/or developing or reproducing the
28
software by the user in light of its specific status of free software,
29
that may mean that it is complicated to manipulate, and that also
30
therefore means that it is reserved for developers and experienced
31
professionals having in-depth computer knowledge. Users are therefore
32
encouraged to load and test the software's suitability as regards their
33
requirements in conditions enabling the security of their systems and/or
34
data to be ensured and, more generally, to use and operate it in the
35
same conditions as regards security.
37
The fact that you are presently reading this means that you have had
38
knowledge of the CeCILL license and that you accept its terms.
9
Copyright or © or Copr. CNRS, (November 17, 2004)
11
This software is a computer program whose purpose is to provide classes
12
for sequences analysis.
14
This software is governed by the CeCILL license under French law and
15
abiding by the rules of distribution of free software. You can use,
16
modify and/ or redistribute the software under the terms of the CeCILL
17
license as circulated by CEA, CNRS and INRIA at the following URL
18
"http://www.cecill.info".
20
As a counterpart to the access to the source code and rights to copy,
21
modify and redistribute granted by the license, users are provided only
22
with a limited warranty and the software's author, the holder of the
23
economic rights, and the successive licensors have only limited
26
In this respect, the user's attention is drawn to the risks associated
27
with loading, using, modifying and/or developing or reproducing the
28
software by the user in light of its specific status of free software,
29
that may mean that it is complicated to manipulate, and that also
30
therefore means that it is reserved for developers and experienced
31
professionals having in-depth computer knowledge. Users are therefore
32
encouraged to load and test the software's suitability as regards their
33
requirements in conditions enabling the security of their systems and/or
34
data to be ensured and, more generally, to use and operate it in the
35
same conditions as regards security.
37
The fact that you are presently reading this means that you have had
38
knowledge of the CeCILL license and that you accept its terms.
41
41
#include "VectorSequenceContainer.h"
42
42
#include <Bpp/Text/TextTools.h>
47
47
/** Class constructors: *******************************************************/
49
49
VectorSequenceContainer::VectorSequenceContainer(
50
const std::vector<const Sequence*>& vs,
51
const Alphabet* alpha)
52
throw (AlphabetMismatchException):
53
AbstractSequenceContainer(alpha),
50
const std::vector<const Sequence*>& vs,
51
const Alphabet* alpha)
52
throw (AlphabetMismatchException) :
53
AbstractSequenceContainer(alpha),
56
for (std::vector<const Sequence *>::const_iterator i = vs.begin() ; i < vs.end() ; i++)
56
for (std::vector<const Sequence*>::const_iterator i = vs.begin(); i < vs.end(); i++)
62
62
/** Copy constructors: ********************************************************/
64
64
VectorSequenceContainer::VectorSequenceContainer(
65
const VectorSequenceContainer& vsc):
66
AbstractSequenceContainer(vsc),
65
const VectorSequenceContainer& vsc) :
66
AbstractSequenceContainer(vsc),
69
unsigned int max = vsc.getNumberOfSequences();
70
for (unsigned int i = 0 ; i < max ; i++)
69
size_t max = vsc.getNumberOfSequences();
70
for (size_t i = 0; i < max; i++)
71
72
addSequence(vsc.getSequence(i), false);
74
76
VectorSequenceContainer::VectorSequenceContainer(
75
const OrderedSequenceContainer& osc):
76
AbstractSequenceContainer(osc.getAlphabet()),
77
const OrderedSequenceContainer& osc) :
78
AbstractSequenceContainer(osc.getAlphabet()),
79
// Sequences insertion
80
for (unsigned int i = 0; i < osc.getNumberOfSequences(); i++)
81
// Sequences insertion
82
for (unsigned int i = 0; i < osc.getNumberOfSequences(); i++)
81
84
addSequence(osc.getSequence(i), false);
84
88
VectorSequenceContainer::VectorSequenceContainer(
85
const SequenceContainer& sc):
86
AbstractSequenceContainer(sc.getAlphabet()),
89
const SequenceContainer& sc) :
90
AbstractSequenceContainer(sc.getAlphabet()),
89
// Sequences insertion
90
std::vector<std::string> names = sc.getSequencesNames();
93
// Sequences insertion
94
std::vector<std::string> names = sc.getSequencesNames();
91
95
for (unsigned int i = 0; i < names.size(); i++)
93
97
addSequence(sc.getSequence(names[i]), false);
96
setGeneralComments(sc.getGeneralComments());
100
setGeneralComments(sc.getGeneralComments());
99
103
/** Assignation operator: *****************************************************/
101
105
VectorSequenceContainer& VectorSequenceContainer::operator=(
102
const VectorSequenceContainer& vsc)
106
const VectorSequenceContainer& vsc)
105
109
AbstractSequenceContainer::operator=(vsc);
107
// Sequences insertion
108
unsigned int max = vsc.getNumberOfSequences();
109
for (unsigned int i = 0 ; i < max ; i++)
111
// Sequences insertion
112
size_t max = vsc.getNumberOfSequences();
113
for (size_t i = 0; i < max; i++)
110
115
addSequence(vsc.getSequence(i), false);
115
121
VectorSequenceContainer& VectorSequenceContainer::operator=(
116
const OrderedSequenceContainer& osc)
122
const OrderedSequenceContainer& osc)
119
125
AbstractSequenceContainer::operator=(osc);
121
// Sequences insertion
122
unsigned int max = osc.getNumberOfSequences();
123
for (unsigned int i = 0 ; i < max ; i++)
127
// Sequences insertion
128
size_t max = osc.getNumberOfSequences();
129
for (unsigned int i = 0; i < max; i++)
124
131
addSequence(osc.getSequence(i), false);
129
137
/******************************************************************************/
148
156
/******************************************************************************/
150
const Sequence& VectorSequenceContainer::getSequence(unsigned int sequenceIndex) const throw (IndexOutOfBoundsException)
158
const Sequence& VectorSequenceContainer::getSequence(size_t sequenceIndex) const throw (IndexOutOfBoundsException)
152
// Specified sequence existence verification
153
if (sequenceIndex < sequences_.size()) return *sequences_[sequenceIndex];
154
throw IndexOutOfBoundsException("VectorSequenceContainer::getSequence.", sequenceIndex, 0, sequences_.size() - 1);
160
// Specified sequence existence verification
161
if (sequenceIndex < sequences_.size())
162
return *sequences_[sequenceIndex];
163
throw IndexOutOfBoundsException("VectorSequenceContainer::getSequence.", sequenceIndex, 0, sequences_.size() - 1);
157
166
/******************************************************************************/
159
168
bool VectorSequenceContainer::hasSequence(const string& name) const
161
// Specified sequence name research into all sequences
162
for (unsigned int i = 0; i < sequences_.size(); i++)
163
if (sequences_[i]->getName() == name)
170
// Specified sequence name research into all sequences
171
for (size_t i = 0; i < sequences_.size(); i++)
173
if (sequences_[i]->getName() == name)
168
179
/******************************************************************************/
170
181
const Sequence& VectorSequenceContainer::getSequence(const string& name) const throw (SequenceNotFoundException)
172
// Specified sequence name research into all sequences
173
for (unsigned int i = 0; i < sequences_.size(); i++)
174
if (sequences_[i]->getName() == name)
183
// Specified sequence name research into all sequences
184
for (size_t i = 0; i < sequences_.size(); i++)
186
if (sequences_[i]->getName() == name)
175
187
return *sequences_[i];
176
throw SequenceNotFoundException("VectorSequenceContainer::getSequence : Specified sequence doesn't exist", name);
189
throw SequenceNotFoundException("VectorSequenceContainer::getSequence : Specified sequence doesn't exist", name);
179
192
/******************************************************************************/
181
Sequence& VectorSequenceContainer::getSequence_(unsigned int sequenceIndex) throw (IndexOutOfBoundsException)
194
Sequence& VectorSequenceContainer::getSequence_(size_t sequenceIndex) throw (IndexOutOfBoundsException)
183
// Specified sequence existence verification
184
if (sequenceIndex < sequences_.size()) return *sequences_[sequenceIndex];
185
throw IndexOutOfBoundsException("VectorSequenceContainer::getSequence.", sequenceIndex, 0, sequences_.size() - 1);
196
// Specified sequence existence verification
197
if (sequenceIndex < sequences_.size())
198
return *sequences_[sequenceIndex];
199
throw IndexOutOfBoundsException("VectorSequenceContainer::getSequence.", sequenceIndex, 0, sequences_.size() - 1);
188
202
/******************************************************************************/
190
204
Sequence& VectorSequenceContainer::getSequence_(const string& name) throw (SequenceNotFoundException)
192
// Specified sequence name research into all sequences
193
for (unsigned int i = 0; i < sequences_.size(); i++) {
194
if (sequences_[i]->getName() == name) return *sequences_[i];
196
throw SequenceNotFoundException("VectorSequenceContainer::getSequence : Specified sequence doesn't exist", name);
199
/******************************************************************************/
201
unsigned int VectorSequenceContainer::getSequencePosition(const string& name) const throw (SequenceNotFoundException)
203
// Specified sequence name research into all sequences
204
for (unsigned int i = 0; i < sequences_.size(); i++) {
205
if (sequences_[i] -> getName() == name) return i;
207
throw SequenceNotFoundException("VectorSequenceContainer::getSequencePosition : Specified sequence doesn't exist", name);
210
/******************************************************************************/
212
void VectorSequenceContainer::setSequence(unsigned int sequenceIndex, const Sequence& sequence, bool checkName) throw (Exception)
214
// Sequence's name existence checking
216
// For all names in vector : throw exception if name already exists
217
for (unsigned int j = 0; j < sequences_.size(); j++) {
218
if (sequences_[j] -> getName() == sequence.getName())
219
if (j != sequenceIndex) throw Exception("VectorSequenceContainer::setSequence : Sequence's name already exists in container");
223
// New sequence's alphabet and sequence container's alphabet matching verification
224
if (sequence.getAlphabet()->getAlphabetType() == getAlphabet()->getAlphabetType())
226
// Delete old sequence
227
delete sequences_[sequenceIndex];
228
// New sequence insertion in sequence container
229
sequences_[sequenceIndex] = dynamic_cast<Sequence *>(sequence.clone());
206
// Specified sequence name research into all sequences
207
for (size_t i = 0; i < sequences_.size(); i++)
209
if (sequences_[i]->getName() == name)
210
return *sequences_[i];
212
throw SequenceNotFoundException("VectorSequenceContainer::getSequence : Specified sequence doesn't exist", name);
215
/******************************************************************************/
217
size_t VectorSequenceContainer::getSequencePosition(const string& name) const throw (SequenceNotFoundException)
219
// Specified sequence name research into all sequences
220
for (size_t i = 0; i < sequences_.size(); i++)
222
if (sequences_[i]->getName() == name)
225
throw SequenceNotFoundException("VectorSequenceContainer::getSequencePosition : Specified sequence doesn't exist", name);
228
/******************************************************************************/
230
void VectorSequenceContainer::setSequence(size_t sequenceIndex, const Sequence& sequence, bool checkName) throw (Exception)
232
// Sequence's name existence checking
235
// For all names in vector : throw exception if name already exists
236
for (size_t j = 0; j < sequences_.size(); j++)
238
if (sequences_[j]->getName() == sequence.getName())
239
if (j != sequenceIndex)
240
throw Exception("VectorSequenceContainer::setSequence : Sequence's name already exists in container");
244
// New sequence's alphabet and sequence container's alphabet matching verification
245
if (sequence.getAlphabet()->getAlphabetType() == getAlphabet()->getAlphabetType())
247
// Delete old sequence
248
delete sequences_[sequenceIndex];
249
// New sequence insertion in sequence container
250
sequences_[sequenceIndex] = dynamic_cast<Sequence*>(sequence.clone());
232
253
throw AlphabetMismatchException("VectorSequenceContainer::setSequence : Alphabets don't match", getAlphabet(), sequence.getAlphabet());
235
256
/******************************************************************************/
237
Sequence* VectorSequenceContainer::removeSequence(unsigned int sequenceIndex) throw (IndexOutOfBoundsException)
258
Sequence* VectorSequenceContainer::removeSequence(size_t sequenceIndex) throw (IndexOutOfBoundsException)
240
if (sequenceIndex >= sequences_.size())
241
throw IndexOutOfBoundsException("VectorSequenceContainer::removeSequence.", sequenceIndex, 0, sequences_.size() - 1);
261
if (sequenceIndex >= sequences_.size())
262
throw IndexOutOfBoundsException("VectorSequenceContainer::removeSequence.", sequenceIndex, 0, sequences_.size() - 1);
242
263
Sequence* old = sequences_[sequenceIndex];
243
// Remove pointer toward old sequence:
244
sequences_.erase(sequences_.begin() + sequenceIndex);
264
// Remove pointer toward old sequence:
265
sequences_.erase(sequences_.begin() + sequenceIndex);
249
270
/******************************************************************************/
251
void VectorSequenceContainer::deleteSequence(unsigned int sequenceIndex) throw (IndexOutOfBoundsException)
272
void VectorSequenceContainer::deleteSequence(size_t sequenceIndex) throw (IndexOutOfBoundsException)
254
if (sequenceIndex >= sequences_.size())
255
throw IndexOutOfBoundsException("VectorSequenceContainer::deleteSequence.", sequenceIndex, 0, sequences_.size() - 1);
275
if (sequenceIndex >= sequences_.size())
276
throw IndexOutOfBoundsException("VectorSequenceContainer::deleteSequence.", sequenceIndex, 0, sequences_.size() - 1);
256
277
delete sequences_[sequenceIndex];
257
// Remove pointer toward old sequence:
258
sequences_.erase(sequences_.begin() + sequenceIndex);
278
// Remove pointer toward old sequence:
279
sequences_.erase(sequences_.begin() + sequenceIndex);
261
282
/******************************************************************************/
263
284
void VectorSequenceContainer::addSequence(const Sequence& sequence, bool checkName) throw (Exception)
265
// Sequence's name existence checking
286
// Sequence's name existence checking
268
// For all names in vector : throw exception if name already exists
269
for (unsigned int i = 0; i < sequences_.size(); i++)
289
// For all names in vector : throw exception if name already exists
290
for (size_t i = 0; i < sequences_.size(); i++)
271
if (sequences_[i] -> getName() == sequence.getName())
272
throw Exception("VectorSequenceContainer::addSequence : Sequence '" + sequence.getName() + "' already exists in container");
292
if (sequences_[i]->getName() == sequence.getName())
293
throw Exception("VectorSequenceContainer::addSequence : Sequence '" + sequence.getName() + "' already exists in container");
276
// New sequence's alphabet and sequence container's alphabet matching verification
277
if (sequence.getAlphabet()->getAlphabetType() == getAlphabet()->getAlphabetType())
297
// New sequence's alphabet and sequence container's alphabet matching verification
298
if (sequence.getAlphabet()->getAlphabetType() == getAlphabet()->getAlphabetType())
279
//push_back(new Sequence(sequence.getName(), sequence.getContent(), alphabet));
280
sequences_.push_back(dynamic_cast<Sequence*>(sequence.clone()));
300
// push_back(new Sequence(sequence.getName(), sequence.getContent(), alphabet));
301
sequences_.push_back(dynamic_cast<Sequence*>(sequence.clone()));
283
304
throw AlphabetMismatchException("VectorSequenceContainer::addSequence : Alphabets don't match", getAlphabet(), sequence.getAlphabet());
286
void VectorSequenceContainer::addSequence(const Sequence& sequence, unsigned int sequenceIndex, bool checkName) throw (Exception)
307
void VectorSequenceContainer::addSequence(const Sequence& sequence, size_t sequenceIndex, bool checkName) throw (Exception)
288
// Sequence's name existence checking
309
// Sequence's name existence checking
291
// For all names in vector : throw exception if name already exists
292
for (unsigned int i = 0; i < sequences_.size(); i++)
312
// For all names in vector : throw exception if name already exists
313
for (size_t i = 0; i < sequences_.size(); i++)
294
if (sequences_[i] -> getName() == sequence.getName())
295
throw Exception("VectorSequenceContainer::addSequence : Sequence '" + sequence.getName() + "' already exists in container");
315
if (sequences_[i]->getName() == sequence.getName())
316
throw Exception("VectorSequenceContainer::addSequence : Sequence '" + sequence.getName() + "' already exists in container");
299
// New sequence's alphabet and sequence container's alphabet matching verification
300
if (sequence.getAlphabet()->getAlphabetType() == getAlphabet()->getAlphabetType())
320
// New sequence's alphabet and sequence container's alphabet matching verification
321
if (sequence.getAlphabet()->getAlphabetType() == getAlphabet()->getAlphabetType())
302
//insert(begin() + pos, new Sequence(sequence.getName(), sequence.getContent(), alphabet));
303
sequences_.insert(sequences_.begin() + sequenceIndex, dynamic_cast<Sequence*>(sequence.clone()));
323
// insert(begin() + pos, new Sequence(sequence.getName(), sequence.getContent(), alphabet));
324
sequences_.insert(sequences_.begin() + sequenceIndex, dynamic_cast<Sequence*>(sequence.clone()));
306
327
throw AlphabetMismatchException("VectorSequenceContainer::addSequence : Alphabets don't match", getAlphabet(), sequence.getAlphabet());
311
332
std::vector<std::string> VectorSequenceContainer::getSequencesNames() const
313
334
std::vector<std::string> names;
314
for (unsigned int i = 0; i < sequences_.size(); i++)
335
for (size_t i = 0; i < sequences_.size(); i++)
315
337
names.push_back(sequences_[i]->getName());
319
342
/******************************************************************************/
321
344
void VectorSequenceContainer::setSequencesNames(
322
const std::vector<std::string> & names,
345
const std::vector<std::string>& names,
326
if (names.size() != getNumberOfSequences())
327
throw BadIntegerException("VectorSequenceContainer::setSequenceNames : bad number of names", names.size());
330
for (unsigned int i = 0; i < names.size(); i++) {
331
// For all names in vector : throw exception if name already exists
332
for (unsigned int j = 0; j < i; j++) {
333
if (names[j] == names[i])
334
throw Exception("VectorSiteContainer::setSequencesNames : Sequence's name already exists in container");
338
for (unsigned int i = 0; i < names.size(); i++)
340
sequences_[i]->setName(names[i]);
349
if (names.size() != getNumberOfSequences())
350
throw IndexOutOfBoundsException("VectorSequenceContainer::setSequenceNames : bad number of names", names.size(), getNumberOfSequences(), getNumberOfSequences());
353
for (size_t i = 0; i < names.size(); i++)
355
// For all names in vector : throw exception if name already exists
356
for (size_t j = 0; j < i; j++)
358
if (names[j] == names[i])
359
throw Exception("VectorSiteContainer::setSequencesNames : Sequence's name already exists in container");
363
for (size_t i = 0; i < names.size(); i++)
365
sequences_[i]->setName(names[i]);
344
369
/******************************************************************************/
346
371
void VectorSequenceContainer::clear()
349
for (unsigned int i = 0; i < sequences_.size(); i++)
374
for (size_t i = 0; i < sequences_.size(); i++)
350
376
delete sequences_[i];
351
// Delete all sequence pointers
378
// Delete all sequence pointers
355
382
/******************************************************************************/
357
void VectorSequenceContainer::setComments(unsigned int sequenceIndex, const Comments & comments) throw (IndexOutOfBoundsException)
384
void VectorSequenceContainer::setComments(size_t sequenceIndex, const Comments& comments) throw (IndexOutOfBoundsException)
359
sequences_[sequenceIndex]->setComments(comments);
386
sequences_[sequenceIndex]->setComments(comments);
362
389
/******************************************************************************/
364
391
VectorSequenceContainer* VectorSequenceContainer::createEmptyContainer() const
366
VectorSequenceContainer* vsc = new VectorSequenceContainer(getAlphabet());
367
vsc->setGeneralComments(getGeneralComments());
393
VectorSequenceContainer* vsc = new VectorSequenceContainer(getAlphabet());
394
vsc->setGeneralComments(getGeneralComments());
371
398
/******************************************************************************/
added
removed
src/Bpp/Seq/Container/VectorSequenceContainer.cpp
