libstdc++: range_access.h Source File (original) (raw)

30#ifndef _GLIBCXX_RANGE_ACCESS_H

31#define _GLIBCXX_RANGE_ACCESS_H 1

33#pragma GCC system_header

35#if __cplusplus >= 201103L

37#include <type_traits>

40namespace std _GLIBCXX_VISIBILITY(default)

41{

42_GLIBCXX_BEGIN_NAMESPACE_VERSION

49 template<typename _Container>

50 [[__nodiscard__, __gnu__::__always_inline__]]

51 inline _GLIBCXX17_CONSTEXPR auto

53 { return __cont.begin(); }

60 template<typename _Container>

61 [[__nodiscard__, __gnu__::__always_inline__]]

62 inline _GLIBCXX17_CONSTEXPR auto

64 { return __cont.begin(); }

71 template<typename _Container>

72 [[__nodiscard__, __gnu__::__always_inline__]]

73 inline _GLIBCXX17_CONSTEXPR auto

75 { return __cont.end(); }

82 template<typename _Container>

83 [[__nodiscard__, __gnu__::__always_inline__]]

84 inline _GLIBCXX17_CONSTEXPR auto

86 { return __cont.end(); }

92 template<typename _Tp, size_t _Nm>

93 [[__nodiscard__, __gnu__::__always_inline__]]

94 inline _GLIBCXX14_CONSTEXPR _Tp*

95 begin(_Tp (&__arr)[_Nm]) noexcept

96 { return __arr; }

100

101

102

103 template<typename _Tp, size_t _Nm>

104 [[__nodiscard__, __gnu__::__always_inline__]]

105 inline _GLIBCXX14_CONSTEXPR _Tp*

106 end(_Tp (&__arr)[_Nm]) noexcept

107 { return __arr + _Nm; }

108

109#if __cplusplus >= 201402L

110

111 template<typename _Tp> class valarray;

112

113 template<typename _Tp> _Tp* begin(valarray<_Tp>&) noexcept;

114 template<typename _Tp> const _Tp* begin(const valarray<_Tp>&) noexcept;

115 template<typename _Tp> _Tp* end(valarray<_Tp>&) noexcept;

116 template<typename _Tp> const _Tp* end(const valarray<_Tp>&) noexcept;

117

118

119

120

121

122

123 template<typename _Container>

124 [[__nodiscard__, __gnu__::__always_inline__]]

125 constexpr auto

129

130

131

132

133

134

135 template<typename _Container>

136 [[__nodiscard__, __gnu__::__always_inline__]]

137 constexpr auto

141

142

143

144

145

146

147 template<typename _Container>

148 [[__nodiscard__, __gnu__::__always_inline__]]

149 inline _GLIBCXX17_CONSTEXPR auto

151 { return __cont.rbegin(); }

152

153

154

155

156

157

158 template<typename _Container>

159 [[__nodiscard__, __gnu__::__always_inline__]]

160 inline _GLIBCXX17_CONSTEXPR auto

162 { return __cont.rbegin(); }

163

164

165

166

167

168

169 template<typename _Container>

170 [[__nodiscard__, __gnu__::__always_inline__]]

171 inline _GLIBCXX17_CONSTEXPR auto

173 { return __cont.rend(); }

174

175

176

177

178

179

180 template<typename _Container>

181 [[__nodiscard__, __gnu__::__always_inline__]]

182 inline _GLIBCXX17_CONSTEXPR auto

184 { return __cont.rend(); }

185

186

187

188

189

190

191 template<typename _Tp, size_t _Nm>

192 [[__nodiscard__]]

193 inline _GLIBCXX17_CONSTEXPR reverse_iterator<_Tp*>

194 rbegin(_Tp (&__arr)[_Nm]) noexcept

196

197

198

199

200

201

202 template<typename _Tp, size_t _Nm>

203 [[__nodiscard__]]

204 inline _GLIBCXX17_CONSTEXPR reverse_iterator<_Tp*>

205 rend(_Tp (&__arr)[_Nm]) noexcept

207

208

209

210

211

212

213 template<typename _Tp>

214 [[__nodiscard__]]

215 inline _GLIBCXX17_CONSTEXPR reverse_iterator<const _Tp*>

218

219

220

221

222

223

224 template<typename _Tp>

225 [[__nodiscard__]]

226 inline _GLIBCXX17_CONSTEXPR reverse_iterator<const _Tp*>

229

230

231

232

233

234

235 template<typename _Container>

236 [[__nodiscard__, __gnu__::__always_inline__]]

237 inline _GLIBCXX17_CONSTEXPR auto

240

241

242

243

244

245

246 template<typename _Container>

247 [[__nodiscard__, __gnu__::__always_inline__]]

248 inline _GLIBCXX17_CONSTEXPR auto

251

252#endif

253

254#ifdef __glibcxx_nonmember_container_access

255

256

257

258

259 template <typename _Container>

260 [[nodiscard, __gnu__::__always_inline__]]

261 constexpr auto

263 -> decltype(__cont.size())

264 { return __cont.size(); }

265

266

267

268

269 template <typename _Tp, size_t _Nm>

270 [[nodiscard, __gnu__::__always_inline__]]

271 constexpr size_t

272 size(const _Tp (&)[_Nm]) noexcept

273 { return _Nm; }

274

275

276

277

278

279 template <typename _Container>

280 [[nodiscard, __gnu__::__always_inline__]]

281 constexpr auto

283 -> decltype(__cont.empty())

284 { return __cont.empty(); }

285

286

287

288

289 template <typename _Tp, size_t _Nm>

290 [[nodiscard, __gnu__::__always_inline__]]

291 constexpr bool

292 empty(const _Tp (&)[_Nm]) noexcept

293 { return false; }

294

295

296

297

298

299 template <typename _Tp>

300 [[nodiscard, __gnu__::__always_inline__]]

301 constexpr bool

303 { return __il.size() == 0;}

304

305

306

307

308

309 template <typename _Container>

310 [[nodiscard, __gnu__::__always_inline__]]

311 constexpr auto

313 -> decltype(__cont.data())

314 { return __cont.data(); }

315

316

317

318

319

320 template <typename _Container>

321 [[nodiscard, __gnu__::__always_inline__]]

322 constexpr auto

324 -> decltype(__cont.data())

325 { return __cont.data(); }

326

327

328

329

330

331 template <typename _Tp, size_t _Nm>

332 [[nodiscard, __gnu__::__always_inline__]]

333 constexpr _Tp*

334 data(_Tp (&__array)[_Nm]) noexcept

335 { return __array; }

336

337

338

339

340

341 template <typename _Tp>

342 [[nodiscard, __gnu__::__always_inline__]]

343 constexpr const _Tp*

345 { return __il.begin(); }

346#endif

347

348#ifdef __glibcxx_ssize

349 template<typename _Container>

350 [[nodiscard, __gnu__::__always_inline__]]

351 constexpr auto

352 ssize(const _Container& __cont)

353 noexcept(noexcept(__cont.size()))

355 {

357 return static_cast<common_type_t<ptrdiff_t, type>>(__cont.size());

358 }

359

360 template<typename _Tp, ptrdiff_t _Num>

361 [[nodiscard, __gnu__::__always_inline__]]

362 constexpr ptrdiff_t

363 ssize(const _Tp (&)[_Num]) noexcept

364 { return _Num; }

365#endif

366_GLIBCXX_END_NAMESPACE_VERSION

367}

368

369#endif

370#endif

typename common_type< _Tp... >::type common_type_t

Alias template for common_type.

typename make_signed< _Tp >::type make_signed_t

Alias template for make_signed.

_Tp * end(valarray< _Tp > &__va) noexcept

Return an iterator pointing to one past the last element of the valarray.

_Tp * begin(valarray< _Tp > &__va) noexcept

Return an iterator pointing to the first element of the valarray.

ISO C++ entities toplevel namespace is std.

constexpr auto crend(const _Container &__cont) -> decltype(std::rend(__cont))

Return a reverse iterator pointing one past the first element of the const container.

constexpr auto rend(_Container &__cont) -> decltype(__cont.rend())

Return a reverse iterator pointing one past the first element of the container.

constexpr auto cend(const _Container &__cont) noexcept(noexcept(std::end(__cont))) -> decltype(std::end(__cont))

Return an iterator pointing to one past the last element of the const container.

constexpr auto empty(const _Container &__cont) noexcept(noexcept(__cont.empty())) -> decltype(__cont.empty())

Return whether a container is empty.

constexpr auto size(const _Container &__cont) noexcept(noexcept(__cont.size())) -> decltype(__cont.size())

Return the size of a container.

constexpr auto rbegin(_Container &__cont) -> decltype(__cont.rbegin())

Return a reverse iterator pointing to the last element of the container.

constexpr auto crbegin(const _Container &__cont) -> decltype(std::rbegin(__cont))

Return a reverse iterator pointing to the last element of the const container.

constexpr auto data(_Container &__cont) noexcept(noexcept(__cont.data())) -> decltype(__cont.data())

Return the data pointer of a container.

constexpr auto cbegin(const _Container &__cont) noexcept(noexcept(std::begin(__cont))) -> decltype(std::begin(__cont))

Return an iterator pointing to the first element of the const container.