← Back to branch summary

~ubuntu-branches/debian/jessie/ugene/jessie

« back to all changes in this revision

Viewing changes to src/plugins_3rdparty/ball/src/include/BALL/DATATYPE/quadruple.h

  • Committer: Package Import Robot
  • Author(s): Steffen Moeller
  • Date: 2011-11-02 13:29:07 UTC
  • mfrom: (1.2.1) (3.1.11 natty)
  • Revision ID: package-import@ubuntu.com-20111102132907-o34gwnt0uj5g6hen
Tags: 1.9.8+repack-1
* First release to Debian
  - added README.Debian
  - increased policy version to 3.9.2
  - added URLs for version control system
* Added debug package.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/plugins_3rdparty/ball/src/include/BALL/DATATYPE/quadruple.h
 
1
// -*- Mode: C++; tab-width: 2; -*-
 
2
// vi: set ts=2:
 
3
//
 
4
// $Id: quadruple.h,v 1.13 2003-08-26 08:04:11 oliver Exp $
 
5
//
 
6
 
 
7
#ifndef BALL_DATATYPE_QUADRUPLE_H
 
8
#define BALL_DATATYPE_QUADRUPLE_H
 
9
 
 
10
#ifndef BALL_COMMON_H
 
11
#       include <BALL/common.h>
 
12
#endif
 
13
 
 
14
namespace BALL 
 
15
{
 
16
        /**     Quadruple Class.
 
17
                        This template class is used to represent quadruples of arbitrary types
 
18
                        (like the STL type <tt>pair</tt>).
 
19
        \ingroup  DatatypeMiscellaneous
 
20
        */
 
21
        template <typename T1, typename T2, typename T3, typename T4>
 
22
        class Quadruple
 
23
        {
 
24
                public:
 
25
 
 
26
                /**     @name   Constructors and Destructors 
 
27
                */
 
28
                //@{
 
29
 
 
30
                BALL_CREATE(Quadruple)
 
31
 
 
32
                /**     Default constructor.
 
33
                                Creates a new Quadruple object.
 
34
                */
 
35
                Quadruple() throw();
 
36
 
 
37
                /**     Copy constructor.
 
38
                                Creates a new Quadruple object from another.
 
39
                                @param  quadruple the Quadruple object to be copied
 
40
                                @param  deep not used (needed for a consistent interface only)
 
41
                */
 
42
                Quadruple(const Quadruple& quadruple, bool deep = true) throw();
 
43
 
 
44
                /**     Detailled constructor.
 
45
                                Creates a new Quadruple object from the quadruple's four
 
46
                                members.
 
47
                                @param  new_first       the first quadruple member
 
48
                                @param  new_second      the second quadruple member
 
49
                                @param  new_third       the third quadruple member
 
50
                                @param  new_fourth      the fourth quadruple member
 
51
                */
 
52
                Quadruple(const T1& new_first, const T2& new_second,
 
53
                                                        const T3& new_third, const T4& new_fourth) throw();
 
54
 
 
55
                /**     Destructor.
 
56
                                Destructs the Quadruple object.
 
57
                */
 
58
                virtual ~Quadruple() throw();
 
59
                //@}
 
60
 
 
61
                /** Clear method.
 
62
                */
 
63
                virtual void clear() throw();
 
64
 
 
65
                /**     @name   Assignment
 
66
                */
 
67
                //@{
 
68
 
 
69
                /**     Assignment operator.
 
70
                                Assigns the contents of a quadruple to another.
 
71
                                @param  quadruple the quadruple to be copied
 
72
                */
 
73
                const Quadruple& operator = (const Quadruple& quadruple) throw();
 
74
 
 
75
                /**
 
76
                */
 
77
                void set(const T1& t1, const T2& t2, const T3& t3, const T4& t4) throw();
 
78
 
 
79
                /**
 
80
                */
 
81
                void get(T1& first, T2& second, T3& third, T4& fourth) const throw();
 
82
 
 
83
                //@}
 
84
                /**     @name   Predicates
 
85
                */
 
86
                //@{
 
87
 
 
88
                /**     Equality operator 
 
89
                                Two instances are equal if they have the same members.
 
90
                */
 
91
                bool operator == (const Quadruple& quadruple) const throw();
 
92
 
 
93
                /**     Inequality operator 
 
94
                */
 
95
                bool operator != (const Quadruple& quadruple) const throw();
 
96
 
 
97
                /**     Lesser than operator.   
 
98
                                One instance is lesser than an other if all members from first to
 
99
                                third are equal or less than the members of the other instance and at least
 
100
                                fourth is less.
 
101
                */
 
102
                bool operator < (const Quadruple& quadruple) const throw();
 
103
 
 
104
                /**     Lesser or equal than operator.  
 
105
                */
 
106
                bool operator <= (const Quadruple& quadruple) const throw();
 
107
 
 
108
                /**     Greater or equal than operator. 
 
109
                */
 
110
                bool operator >= (const Quadruple& quadruple) const throw();
 
111
 
 
112
                /**     Greater than operator.  
 
113
                */
 
114
                bool operator > (const Quadruple& quadruple) const throw();
 
115
 
 
116
                //@}
 
117
                
 
118
                /**     @name   Attributes
 
119
                */
 
120
                //@{
 
121
 
 
122
                /**     The first quadruple member
 
123
                */
 
124
                T1 first;
 
125
 
 
126
                /**     The second quadruple member
 
127
                */
 
128
                T2 second;
 
129
 
 
130
                /**     The third quadruple member
 
131
                */
 
132
                T3 third;
 
133
 
 
134
                /**     The fourth quadruple member
 
135
                */
 
136
                T4 fourth;
 
137
                //@}
 
138
        };
 
139
 
 
140
        template <typename T1, typename T2, typename T3, typename T4>
 
141
        Quadruple<T1, T2, T3, T4>::Quadruple()  throw()
 
142
        {
 
143
        }
 
144
 
 
145
        template <typename T1, typename T2, typename T3, typename T4>
 
146
        Quadruple<T1, T2, T3, T4>::Quadruple
 
147
                (const Quadruple<T1, T2, T3, T4>& quadruple, bool /* deep */)
 
148
                 throw()
 
149
                :       first(quadruple.first),
 
150
                        second(quadruple.second),
 
151
                        third(quadruple.third),
 
152
                        fourth(quadruple.fourth)
 
153
        {
 
154
        }
 
155
 
 
156
        template <typename T1, typename T2, typename T3, typename T4>
 
157
        Quadruple<T1, T2, T3, T4>::Quadruple
 
158
                (const T1& new_first, const T2& new_second, const T3& new_third, const T4& fourth)
 
159
                 throw()
 
160
                :       first(new_first),
 
161
                        second(new_second),
 
162
                        third(new_third),
 
163
                        fourth(fourth)
 
164
        {
 
165
        }
 
166
 
 
167
        template <typename T1, typename T2, typename T3, typename T4>
 
168
        Quadruple<T1, T2, T3, T4>::~Quadruple()  throw()
 
169
        {
 
170
        }
 
171
 
 
172
        template <typename T1, typename T2, typename T3, typename T4>
 
173
        BALL_INLINE 
 
174
        void Quadruple<T1, T2, T3, T4>::set(const T1& new_first, const T2& new_second,
 
175
                                                                                                                                                  const T3& new_third, const T4& new_fourth)
 
176
         throw()
 
177
        {
 
178
                first           = new_first;
 
179
                second  = new_second;
 
180
                third           = new_third;
 
181
                fourth  = new_fourth;
 
182
        }
 
183
 
 
184
        template <typename T1, typename T2, typename T3, typename T4>
 
185
        BALL_INLINE 
 
186
        const Quadruple<T1, T2, T3, T4>& Quadruple<T1, T2, T3, T4>::operator = 
 
187
                (const Quadruple<T1, T2, T3, T4>& quadruple) throw()
 
188
        {
 
189
                first = quadruple.first;
 
190
                second = quadruple.second;
 
191
                third = quadruple.third;
 
192
                fourth = quadruple.fourth;
 
193
 
 
194
                return *this;
 
195
        }
 
196
 
 
197
        template <typename T1, typename T2, typename T3, typename T4>
 
198
        BALL_INLINE 
 
199
        void Quadruple<T1, T2, T3, T4>::get(T1& t1, T2& t2,     T3& t3, T4& t4) 
 
200
                const throw()
 
201
        {
 
202
                t1 = first;
 
203
                t2 = second;
 
204
                t3 = third;
 
205
                t4 = fourth;
 
206
        }
 
207
 
 
208
        template <typename T1, typename T2, typename T3, typename T4>
 
209
        BALL_INLINE 
 
210
        bool Quadruple<T1, T2, T3, T4>::operator ==     (const Quadruple& quadruple) 
 
211
                const throw()
 
212
        {
 
213
                return (first  == quadruple.first
 
214
                                                                        && second == quadruple.second
 
215
                                                                        && third  == quadruple.third
 
216
                                                                        && fourth == quadruple.fourth);
 
217
        }
 
218
 
 
219
        template <typename T1, typename T2, typename T3, typename T4>
 
220
        BALL_INLINE 
 
221
        bool Quadruple<T1, T2, T3, T4>::operator != (const Quadruple& quadruple)
 
222
                const throw()
 
223
        {
 
224
                return (first != quadruple.first
 
225
                                                                        || second != quadruple.second
 
226
                                                                        || third  != quadruple.third
 
227
                                                                        || fourth != quadruple.fourth);
 
228
        }
 
229
 
 
230
        template <typename T1, typename T2, typename T3, typename T4>
 
231
        BALL_INLINE 
 
232
        void Quadruple<T1, T2, T3, T4>::clear() 
 
233
                throw()
 
234
        {
 
235
                first = T1();
 
236
                second = T2();
 
237
                third = T3();
 
238
                fourth = T4();
 
239
        }
 
240
 
 
241
        template <typename T1, typename T2, typename T3, typename T4>
 
242
        BALL_INLINE 
 
243
        bool Quadruple<T1, T2, T3, T4>::operator <
 
244
                (const Quadruple<T1, T2, T3, T4>& quadruple) const throw()
 
245
        {
 
246
                return (first  <  quadruple.first       || 
 
247
                                                (first  == quadruple.first && second <  quadruple.second)                                                                                                                       || 
 
248
                                                (first  == quadruple.first && second == quadruple.second && third < quadruple.third)    ||
 
249
                                                (first  == quadruple.first && second == quadruple.second && third  == quadruple.third 
 
250
                                                                                         && fourth < quadruple.fourth));
 
251
        }
 
252
 
 
253
        template <typename T1, typename T2, typename T3, typename T4>
 
254
        BALL_INLINE 
 
255
        bool Quadruple<T1, T2, T3, T4>::operator <=
 
256
                (const Quadruple<T1, T2, T3, T4>& quadruple) const throw()
 
257
        {
 
258
                return (first < quadruple.first ||
 
259
                                                (first == quadruple.first       && second < quadruple.second) || 
 
260
                                                (first == quadruple.first       && second == quadruple.second   && third < quadruple.third) ||
 
261
                                                (first == quadruple.first       && second == quadruple.second   && third == quadruple.third
 
262
                                                                                        && fourth <= quadruple.fourth));
 
263
        }
 
264
 
 
265
        template <typename T1, typename T2, typename T3, typename T4>
 
266
        BALL_INLINE 
 
267
        bool Quadruple<T1, T2, T3, T4>::operator >=
 
268
                (const Quadruple<T1, T2, T3, T4>& quadruple) const throw()
 
269
        {
 
270
                return (first > quadruple.first || 
 
271
                                                (first == quadruple.first       && second > quadruple.second) || 
 
272
                                                (first == quadruple.first       && second == quadruple.second && third > quadruple.third) || 
 
273
                                                (first == quadruple.first       && second == quadruple.second   && third == quadruple.third
 
274
                                                                                        && fourth >= quadruple.fourth));
 
275
        }
 
276
 
 
277
        template <typename T1, typename T2, typename T3, typename T4>
 
278
        BALL_INLINE 
 
279
        bool Quadruple<T1, T2, T3, T4>::operator >
 
280
                (const Quadruple<T1, T2, T3, T4>& quadruple) const throw()
 
281
        {
 
282
                return (first > quadruple.first || 
 
283
                                                (first == quadruple.first       && second > quadruple.second)   || 
 
284
                                                (first == quadruple.first       && second == quadruple.second   && third > quadruple.third)     || 
 
285
                                                (first == quadruple.first       && second == quadruple.second   && third == quadruple.third
 
286
                                                                                        && fourth > quadruple.fourth));
 
287
        }
 
288
} // namespace BALL
 
289
 
 
290
#endif // BALL_DATATYPE_QUADRUPLE_H