MDA
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Groups
DomainArchitecture.hpp
1 /*
2  * Domain.h
3  *
4  * Created on: Jun 2, 2013
5  * Author: Carsten Kemena
6  */
7 
8 #ifndef DomainArchitecture_HPP_
9 #define DomainArchitecture_HPP_
10 
11 
12 // C++ header
13 #include <algorithm>
14 #include <memory>
15 #include <string>
16 #include <vector>
17 #include <iostream>
18 #include <iomanip>
19 
20 // MDAT header
21 #include "Domain.hpp"
22 
23 namespace MDAT
24 {
25 
26 
31  CleanNested = 0x01,
32  CleanOverlap = 0x02,
33  CleanMerged = 0x04,
34  //CleanRepeat = 0x08,//!< CleanRepeat
35 };
36 
37 
42 {
43 private:
44  int _id;
45  size_t _n_members;
46  std::vector<Domain> _domains;
47 
48 public:
49 
50  /***********************************************************************
51  * Constructors & Destructors *
52  ***********************************************************************/
53 
55 
56 
60 
64  virtual ~DomainArchitecture();
65 
72  void
73  add_domain(const Domain &domain)
74  {
75  _domains.push_back(domain);
76  }
77 
78 
79 
80 
85  size_t
86  size() const
87  {
88  return _domains.size();
89  }
90 
91  void
92  resize(size_t new_size)
93  {
94  _domains.resize(new_size);
95  }
96 
101  size_t
102  length() const
103  {
104  return _domains.size();
105  }
106 
107 
108  Domain &operator[](unsigned int index)
109  {
110  return _domains[index];
111  }
112 
116  const Domain &operator[](unsigned int index) const
117  {
118  return _domains[index];
119  }
120 
121 
128  friend bool operator== (const DomainArchitecture &dom1, const DomainArchitecture &dom2)
129  {
130  if (dom1.length() != dom2.length())
131  return false;
132  size_t length = std::min(dom1.length(), dom2.length());
133  for (size_t i=0; i<length; ++i)
134  {
135  if ((dom1[i].id() != dom2[i].id()) || (dom1[i].repeated() != dom2[i].repeated()))
136  return false;
137  }
138  return true;
139  }
140 
141 
149  {
150  if (dom1.length() != dom2.length())
151  return true;
152  size_t length = std::min(dom1.length(), dom2.length());
153  for (size_t i=0; i<length; ++i)
154  {
155  if ((dom1[i].id() != dom2[i].id()) || (dom1[i].repeated() != dom2[i].repeated()))
156  return true;
157  }
158  return false;
159  }
160 
161 
162  friend std::ostream& operator<< (std::ostream &out, const DomainArchitecture &archi);
163 
168  int id() const
169  {
170  return _id;
171  }
172 
177  void id(int id)
178  {
179  _id=id;
180  }
181 
186  size_t n_members() const
187  {
188  return _n_members;
189  }
190 
195  void n_members(size_t value)
196  {
197  _n_members=value;
198  }
199 
207  void clean_up(unsigned char options);
208 
209 
213  void sort();
214 
220  void insert_gaps(std::string edit_string);
221 
225  void
227 };
228 
229 /*
230 void
231 print_archis(std::vector<DomainArchitecture> vec);
232 */
233 
238 {
239 private:
240  std::vector<DomainArchitecture > _archis;
241 
242 public:
243 
245 
246 
250 
258 
259 
265  DomainArchitecture &operator[](unsigned int index)
266  {
267  return _archis[index];
268  }
269 
273  const DomainArchitecture &operator[](unsigned int index) const
274  {
275  return _archis[index];
276  }
281 
282 
287  void
289  {
290  _archis.push_back(archi);
291  }
292 
297  size_t size() const
298  {
299  return _archis.size();
300  }
301 
302  size_t
303  max_length() const
304  {
305  size_t n_archis=_archis.size();
306  size_t min=0;
307  for (size_t i=0; i<n_archis; ++i)
308  {
309  if (_archis[i].length()>min)
310  min=_archis[i].length();
311  }
312 
313  return min;
314  }
315 
316 
321  void
322  sort(const std::string stort_type="gap_pattern");
331  friend std::ostream& operator<< (std::ostream &out, const DomainArchitectureSet &archi);
332 
336  void
338 
339 };
340 
341 
342 
343 
344 } /* namespace Sequence */
345 #endif /* DOMAIN_H_ */
346 
347