SeqAn3  3.0.3
The Modern C++ library for sequence analysis.
concept.hpp
Go to the documentation of this file.
1 // -----------------------------------------------------------------------------------------------------
2 // Copyright (c) 2006-2021, Knut Reinert & Freie Universität Berlin
3 // Copyright (c) 2016-2021, Knut Reinert & MPI für molekulare Genetik
4 // This file may be used, modified and/or redistributed under the terms of the 3-clause BSD-License
5 // shipped with this file and also available at: https://github.com/seqan/seqan3/blob/master/LICENSE.md
6 // -----------------------------------------------------------------------------------------------------
7 
13 #pragma once
14 
15 #include <seqan3/std/concepts>
16 #include <initializer_list>
17 #include <seqan3/std/iterator>
18 #include <type_traits>
19 
20 #include <seqan3/core/platform.hpp>
21 
22 #if SEQAN3_WORKAROUND_GCC_NO_CXX11_ABI || SEQAN3_WORKAROUND_GCC_83328
23 #include <string>
24 
25 namespace seqan3::detail
26 {
27 
30 template <typename basic_string_t>
31 struct is_basic_string : std::false_type
32 {};
33 
36 template <typename value_t, typename traits_t, typename allocator_t>
37 struct is_basic_string<std::basic_string<value_t, traits_t, allocator_t>> : std::true_type
38 {};
39 
42 template <typename basic_string_t>
43 constexpr bool is_basic_string_v = is_basic_string<basic_string_t>::value;
44 
45 } // seqan3::detail
46 #endif // SEQAN3_WORKAROUND_GCC_NO_CXX11_ABI || SEQAN3_WORKAROUND_GCC_83328
47 
48 namespace seqan3
49 {
50 
71 template <typename type>
72 SEQAN3_CONCEPT container = requires (type val, type val2, type const cval, typename type::iterator it)
73 {
74  // member types
75  typename type::value_type;
76  typename type::reference;
77  typename type::const_reference;
78 /*
79  typename type::iterator;
80  requires std::forward_iterator<typename type::iterator>;
81  // NOTE check whether iterator is const convertible
82  SEQAN3_RETURN_TYPE_CONSTRAINT(it, std::same_as, typename type::const_iterator);
83 
84  typename type::const_iterator;
85  requires std::forward_iterator<typename type::const_iterator>;
86 
87  typename type::difference_type;
88  typename type::size_type;
89  requires std::is_same_v<
90  typename type::difference_type,
91  typename std::iterator_traits<typename type::iterator>::difference_type
92  >;
93  requires std::is_same_v<
94  typename std::iterator_traits<typename type::iterator>::difference_type,
95  typename std::iterator_traits<typename type::const_iterator>::difference_type
96  >;
97 */
98  // methods and operator
99  SEQAN3_RETURN_TYPE_CONSTRAINT(type{}, std::same_as, type); // default constructor
100  SEQAN3_RETURN_TYPE_CONSTRAINT(type{type{}}, std::same_as, type); // copy/move constructor
101  SEQAN3_RETURN_TYPE_CONSTRAINT(val = val2, std::same_as, type &); // assignment
102  { (&val)->~type() }; // destructor
103 
104  SEQAN3_RETURN_TYPE_CONSTRAINT(val.begin(), std::same_as, typename type::iterator);
105  SEQAN3_RETURN_TYPE_CONSTRAINT(val.end(), std::same_as, typename type::iterator);
106  SEQAN3_RETURN_TYPE_CONSTRAINT(cval.begin(), std::same_as, typename type::const_iterator);
107  SEQAN3_RETURN_TYPE_CONSTRAINT(cval.end(), std::same_as, typename type::const_iterator);
108  SEQAN3_RETURN_TYPE_CONSTRAINT(val.cbegin(), std::same_as, typename type::const_iterator);
109  SEQAN3_RETURN_TYPE_CONSTRAINT(val.cend(), std::same_as, typename type::const_iterator);
110 
111  requires !std::equality_comparable<typename type::value_type> || std::equality_comparable<type>;
112 
113  SEQAN3_RETURN_TYPE_CONSTRAINT(val.swap(val2), std::same_as, void);
114  SEQAN3_RETURN_TYPE_CONSTRAINT(swap(val, val2), std::same_as, void);
115  SEQAN3_RETURN_TYPE_CONSTRAINT(std::swap(val, val2), std::same_as, void);
116 
117  SEQAN3_RETURN_TYPE_CONSTRAINT(val.size(), std::same_as, typename type::size_type);
118  SEQAN3_RETURN_TYPE_CONSTRAINT(val.max_size(), std::same_as, typename type::size_type);
119  SEQAN3_RETURN_TYPE_CONSTRAINT(val.empty(), std::same_as, bool);
120 };
122 
138 template <typename type>
139 SEQAN3_CONCEPT sequence_container = requires (type val, type val2, type const cval)
140 {
141  requires container<type>;
142 
143  // construction
144  { type(typename type::size_type{}, typename type::value_type{}) };
145  { type{val2.begin(), val2.end()} }; // NOTE that this could be any input iterator:
146  { type{std::initializer_list<typename type::value_type>{}} };
147  SEQAN3_RETURN_TYPE_CONSTRAINT(val = std::initializer_list<typename type::value_type>{}, std::same_as, type &);
148 
149  // assignment NOTE return type is type & for std::string and void for other stl containers:
150  { val.assign(val2.begin(), val2.end()) };
151  { val.assign(std::initializer_list<typename type::value_type>{}) };
152  { val.assign(typename type::size_type{}, typename type::value_type{}) };
153 
154  // modify container
155  // TODO: how do you model this?
156  // SEQAN3_RETURN_TYPE_CONSTRAINT(val.emplace(typename type::const_iterator{}, ?),
157  // std::same_as, typename type::iterator);
158 #if SEQAN3_WORKAROUND_GCC_NO_CXX11_ABI
159  SEQAN3_RETURN_TYPE_CONSTRAINT(val.insert(val.begin(), val2.front()), std::same_as, typename type::iterator);
160  SEQAN3_RETURN_TYPE_CONSTRAINT(val.insert(val.begin(), typename type::value_type{}),
161  std::same_as, typename type::iterator);
162 
163  // std::string is missing the const_iterator versions for insert in pre-C++11 ABI
164  requires detail::is_basic_string_v<type> || requires(type val, type val2)
165 #else // ^^^ workaround / no workaround vvv
166  requires requires(type val, type val2)
167 #endif // SEQAN3_WORKAROUND_GCC_NO_CXX11_ABI
168  {
169  SEQAN3_RETURN_TYPE_CONSTRAINT(val.insert(val.cbegin(), val2.front()), std::same_as, typename type::iterator);
170  SEQAN3_RETURN_TYPE_CONSTRAINT(val.insert(val.cbegin(), typename type::value_type{}),
171  std::same_as, typename type::iterator);
172  SEQAN3_RETURN_TYPE_CONSTRAINT(val.insert(val.cbegin(), typename type::size_type{}, typename type::value_type{}),
173  std::same_as, typename type::iterator);
174  SEQAN3_RETURN_TYPE_CONSTRAINT(val.insert(val.cbegin(), val2.begin(), val2.end()),
175  std::same_as, typename type::iterator);
176 #if SEQAN3_WORKAROUND_GCC_83328
177  };
178 
179  requires detail::is_basic_string_v<type> || requires(type val)
180  {
181 // This function is not defined on strings (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=83328).
182 #endif // SEQAN3_WORKAROUND_GCC_83328
183  SEQAN3_RETURN_TYPE_CONSTRAINT(val.insert(val.cbegin(), std::initializer_list<typename type::value_type>{}),
184  std::same_as, typename type::iterator);
185  };
186 
187 #if SEQAN3_WORKAROUND_GCC_NO_CXX11_ABI
188  // std::string is missing the const_iterator versions for erase in pre-C++11 ABI
189  requires detail::is_basic_string_v<type> || requires(type val)
190 #else // ^^^ workaround / no workaround vvv
191  requires requires(type val)
192 #endif // SEQAN3_WORKAROUND_GCC_NO_CXX11_ABI
193  {
194  SEQAN3_RETURN_TYPE_CONSTRAINT(val.erase(val.cbegin()), std::same_as, typename type::iterator);
195  SEQAN3_RETURN_TYPE_CONSTRAINT(val.erase(val.cbegin(), val.cend()), std::same_as, typename type::iterator);
196  };
197 
198  SEQAN3_RETURN_TYPE_CONSTRAINT(val.push_back(val.front()), std::same_as, void);
199  SEQAN3_RETURN_TYPE_CONSTRAINT(val.push_back(typename type::value_type{}), std::same_as, void);
200  SEQAN3_RETURN_TYPE_CONSTRAINT(val.pop_back(), std::same_as, void);
201  SEQAN3_RETURN_TYPE_CONSTRAINT(val.clear(), std::same_as, void);
202 
203  // access container
204  SEQAN3_RETURN_TYPE_CONSTRAINT(val.front(), std::same_as, typename type::reference);
205  SEQAN3_RETURN_TYPE_CONSTRAINT(cval.front(), std::same_as, typename type::const_reference);
206  SEQAN3_RETURN_TYPE_CONSTRAINT(val.back(), std::same_as, typename type::reference);
207  SEQAN3_RETURN_TYPE_CONSTRAINT(cval.back(), std::same_as, typename type::const_reference);
208 };
210 
226 template <typename type>
227 SEQAN3_CONCEPT random_access_container = requires (type val)
228 {
229  requires sequence_container<type>;
230 
231  // access container
232  SEQAN3_RETURN_TYPE_CONSTRAINT(val[0], std::same_as, typename type::reference);
233  SEQAN3_RETURN_TYPE_CONSTRAINT(val.at(0), std::same_as, typename type::reference);
234 
235  // modify container
236  SEQAN3_RETURN_TYPE_CONSTRAINT(val.resize(0), std::same_as, void);
237  SEQAN3_RETURN_TYPE_CONSTRAINT(val.resize(0, typename type::value_type{}), std::same_as, void);
238 };
240 
254 template <typename type>
255 SEQAN3_CONCEPT reservible_container = requires (type val)
256 {
257  requires random_access_container<type>;
258 
259  SEQAN3_RETURN_TYPE_CONSTRAINT(val.capacity(), std::same_as, typename type::size_type);
260  SEQAN3_RETURN_TYPE_CONSTRAINT(val.reserve(0), std::same_as, void);
261  SEQAN3_RETURN_TYPE_CONSTRAINT(val.shrink_to_fit(), std::same_as, void);
262 };
264 
266 
267 } // namespace seqan3
concepts
The Concepts library.
container
The (most general) container concept as defined by the standard library.
random_access_container
A more refined container concept than seqan3::sequence_container.
reservible_container
A more refined container concept than seqan3::random_access_container.
sequence_container
A more refined container concept than seqan3::container.
iterator
Provides C++20 additions to the <iterator> header.
seqan3
The main SeqAn3 namespace.
Definition: aligned_sequence_concept.hpp:29
std
SeqAn specific customisations in the standard namespace.
platform.hpp
Provides platform and dependency checks.
SEQAN3_RETURN_TYPE_CONSTRAINT
#define SEQAN3_RETURN_TYPE_CONSTRAINT(expression, concept_name,...)
Same as writing {expression} -> concept_name<type1[, ...]> in a concept definition.
Definition: platform.hpp:57
std::swap
T swap(T... args)