/lab4/.minix-src/include/c++/functional - Annotate - LCOM1920-T02G10 - FEUP Project Manager

13

up20180614

// -*- C++ -*-

2

//===------------------------ functional ----------------------------------===//

3

//

4

//                     The LLVM Compiler Infrastructure

5

//

6

// This file is dual licensed under the MIT and the University of Illinois Open

7

// Source Licenses. See LICENSE.TXT for details.

8

//

9

//===----------------------------------------------------------------------===//

10

11

#ifndef _LIBCPP_FUNCTIONAL

12

#define _LIBCPP_FUNCTIONAL

13

14

/*

15

    functional synopsis

16

17

namespace std

18

19

20

template <class Arg, class Result>

21

struct unary_function

22

23

    typedef Arg    argument_type;

24

    typedef Result result_type;

25

};

26

27

template <class Arg1, class Arg2, class Result>

28

struct binary_function

29

30

    typedef Arg1   first_argument_type;

31

    typedef Arg2   second_argument_type;

32

    typedef Result result_type;

33

};

34

35

template <class T>

36

class reference_wrapper

37

    : public unary_function<T1, R> // if wrapping a unary functor

38

    : public binary_function<T1, T2, R> // if wraping a binary functor

39

40

public:

41

    // types

42

    typedef T type;

43

    typedef see below result_type; // Not always defined

44

45

    // construct/copy/destroy

46

    reference_wrapper(T&) noexcept;

47

    reference_wrapper(T&&) = delete; // do not bind to temps

48

    reference_wrapper(const reference_wrapper<T>& x) noexcept;

49

50

    // assignment

51

    reference_wrapper& operator=(const reference_wrapper<T>& x) noexcept;

52

53

    // access

54

    operator T& () const noexcept;

55

    T& get() const noexcept;

56

57

    // invoke

58

    template <class... ArgTypes>

59

      typename result_of<T&(ArgTypes&&...)>::type

60

          operator() (ArgTypes&&...) const;

61

};

62

63

template <class T> reference_wrapper<T> ref(T& t) noexcept;

64

template <class T> void ref(const T&& t) = delete;

65

template <class T> reference_wrapper<T> ref(reference_wrapper<T>t) noexcept;

66

67

template <class T> reference_wrapper<const T> cref(const T& t) noexcept;

68

template <class T> void cref(const T&& t) = delete;

69

template <class T> reference_wrapper<const T> cref(reference_wrapper<T> t) noexcept;

70

71

template <class T> // <class T=void> in C++14

72

struct plus : binary_function<T, T, T>

73

74

    T operator()(const T& x, const T& y) const;

75

};

76

77

template <class T> // <class T=void> in C++14

78

struct minus : binary_function<T, T, T>

79

80

    T operator()(const T& x, const T& y) const;

81

};

82

83

template <class T> // <class T=void> in C++14

84

struct multiplies : binary_function<T, T, T>

85

86

    T operator()(const T& x, const T& y) const;

87

};

88

89

template <class T> // <class T=void> in C++14

90

struct divides : binary_function<T, T, T>

91

92

    T operator()(const T& x, const T& y) const;

93

};

94

95

template <class T> // <class T=void> in C++14

96

struct modulus : binary_function<T, T, T>

97

98

    T operator()(const T& x, const T& y) const;

99

};

100

101

template <class T> // <class T=void> in C++14

102

struct negate : unary_function<T, T>

103

104

    T operator()(const T& x) const;

105

};

106

107

template <class T> // <class T=void> in C++14

108

struct equal_to : binary_function<T, T, bool>

109

110

    bool operator()(const T& x, const T& y) const;

111

};

112

113

template <class T> // <class T=void> in C++14

114

struct not_equal_to : binary_function<T, T, bool>

115

116

    bool operator()(const T& x, const T& y) const;

117

};

118

119

template <class T> // <class T=void> in C++14

120

struct greater : binary_function<T, T, bool>

121

122

    bool operator()(const T& x, const T& y) const;

123

};

124

125

template <class T> // <class T=void> in C++14

126

struct less : binary_function<T, T, bool>

127

128

    bool operator()(const T& x, const T& y) const;

129

};

130

131

template <class T> // <class T=void> in C++14

132

struct greater_equal : binary_function<T, T, bool>

133

134

    bool operator()(const T& x, const T& y) const;

135

};

136

137

template <class T> // <class T=void> in C++14

138

struct less_equal : binary_function<T, T, bool>

139

140

    bool operator()(const T& x, const T& y) const;

141

};

142

143

template <class T> // <class T=void> in C++14

144

struct logical_and : binary_function<T, T, bool>

145

146

    bool operator()(const T& x, const T& y) const;

147

};

148

149

template <class T> // <class T=void> in C++14

150

struct logical_or : binary_function<T, T, bool>

151

152

    bool operator()(const T& x, const T& y) const;

153

};

154

155

template <class T> // <class T=void> in C++14

156

struct logical_not : unary_function<T, bool>

157

158

    bool operator()(const T& x) const;

159

};

160

161

template <class T> // <class T=void> in C++14

162

struct bit_and : unary_function<T, bool>

163

164

    bool operator()(const T& x, const T& y) const;

165

};

166

167

template <class T> // <class T=void> in C++14

168

struct bit_or : unary_function<T, bool>

169

170

    bool operator()(const T& x, const T& y) const;

171

};

172

173

template <class T> // <class T=void> in C++14

174

struct bit_xor : unary_function<T, bool>

175

176

    bool operator()(const T& x, const T& y) const;

177

};

178

179

template <class T=void> // C++14

180

struct bit_xor : unary_function<T, bool>

181

182

    bool operator()(const T& x) const;

183

};

184

185

template <class Predicate>

186

class unary_negate

187

    : public unary_function<typename Predicate::argument_type, bool>

188

189

public:

190

    explicit unary_negate(const Predicate& pred);

191

    bool operator()(const typename Predicate::argument_type& x) const;

192

};

193

194

template <class Predicate> unary_negate<Predicate> not1(const Predicate& pred);

195

196

template <class Predicate>

197

class binary_negate

198

    : public binary_function<typename Predicate::first_argument_type,

199

                             typename Predicate::second_argument_type,

200

                             bool>

201

202

public:

203

    explicit binary_negate(const Predicate& pred);

204

    bool operator()(const typename Predicate::first_argument_type& x,

205

                    const typename Predicate::second_argument_type& y) const;

206

};

207

208

template <class Predicate> binary_negate<Predicate> not2(const Predicate& pred);

209

210

template<class T> struct is_bind_expression;

211

template<class T> struct is_placeholder;

212

213

template<class Fn, class... BoundArgs>

214

  unspecified bind(Fn&&, BoundArgs&&...);

215

template<class R, class Fn, class... BoundArgs>

216

  unspecified bind(Fn&&, BoundArgs&&...);

217

218

namespace placeholders {

219

  // M is the implementation-defined number of placeholders

220

  extern unspecified _1;

221

  extern unspecified _2;

  extern unspecified _Mp;

226

227

228

template <class Operation>

229

class binder1st

230

    : public unary_function<typename Operation::second_argument_type,

231

                            typename Operation::result_type>

232

233

protected:

234

    Operation                               op;

235

    typename Operation::first_argument_type value;

236

public:

237

    binder1st(const Operation& x, const typename Operation::first_argument_type y);

238

    typename Operation::result_type operator()(      typename Operation::second_argument_type& x) const;

239

    typename Operation::result_type operator()(const typename Operation::second_argument_type& x) const;

240

};

241

242

template <class Operation, class T>

243

binder1st<Operation> bind1st(const Operation& op, const T& x);

244

245

template <class Operation>

246

class binder2nd

247

    : public unary_function<typename Operation::first_argument_type,

248

                            typename Operation::result_type>

249

250

protected:

251

    Operation                                op;

252

    typename Operation::second_argument_type value;

253

public:

254

    binder2nd(const Operation& x, const typename Operation::second_argument_type y);

255

    typename Operation::result_type operator()(      typename Operation::first_argument_type& x) const;

256

    typename Operation::result_type operator()(const typename Operation::first_argument_type& x) const;

257

};

258

259

template <class Operation, class T>

260

binder2nd<Operation> bind2nd(const Operation& op, const T& x);

261

262

template <class Arg, class Result>

263

class pointer_to_unary_function : public unary_function<Arg, Result>

264

265

public:

266

    explicit pointer_to_unary_function(Result (*f)(Arg));

267

    Result operator()(Arg x) const;

268

};

269

270

template <class Arg, class Result>

271

pointer_to_unary_function<Arg,Result> ptr_fun(Result (*f)(Arg));

272

273

template <class Arg1, class Arg2, class Result>

274

class pointer_to_binary_function : public binary_function<Arg1, Arg2, Result>

275

276

public:

277

    explicit pointer_to_binary_function(Result (*f)(Arg1, Arg2));

278

    Result operator()(Arg1 x, Arg2 y) const;

279

};

280

281

template <class Arg1, class Arg2, class Result>

282

pointer_to_binary_function<Arg1,Arg2,Result> ptr_fun(Result (*f)(Arg1,Arg2));

283

284

template<class S, class T>

285

class mem_fun_t : public unary_function<T*, S>

286

287

public:

288

    explicit mem_fun_t(S (T::*p)());

289

    S operator()(T* p) const;

290

};

291

292

template<class S, class T, class A>

293

class mem_fun1_t : public binary_function<T*, A, S>

294

295

public:

296

    explicit mem_fun1_t(S (T::*p)(A));

297

    S operator()(T* p, A x) const;

298

};

299

300

template<class S, class T>          mem_fun_t<S,T>    mem_fun(S (T::*f)());

301

template<class S, class T, class A> mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A));

302

303

template<class S, class T>

304

class mem_fun_ref_t : public unary_function<T, S>

305

306

public:

307

    explicit mem_fun_ref_t(S (T::*p)());

308

    S operator()(T& p) const;

309

};

310

311

template<class S, class T, class A>

312

class mem_fun1_ref_t : public binary_function<T, A, S>

313

314

public:

315

    explicit mem_fun1_ref_t(S (T::*p)(A));

316

    S operator()(T& p, A x) const;

317

};

318

319

template<class S, class T>          mem_fun_ref_t<S,T>    mem_fun_ref(S (T::*f)());

320

template<class S, class T, class A> mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A));

321

322

template <class S, class T>

323

class const_mem_fun_t : public unary_function<const T*, S>

324

325

public:

326

    explicit const_mem_fun_t(S (T::*p)() const);

327

    S operator()(const T* p) const;

328

};

329

330

template <class S, class T, class A>

331

class const_mem_fun1_t : public binary_function<const T*, A, S>

332

333

public:

334

    explicit const_mem_fun1_t(S (T::*p)(A) const);

335

    S operator()(const T* p, A x) const;

336

};

337

338

template <class S, class T>          const_mem_fun_t<S,T>    mem_fun(S (T::*f)() const);

339

template <class S, class T, class A> const_mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A) const);

340

341

template <class S, class T>

342

class const_mem_fun_ref_t : public unary_function<T, S>

343

344

public:

345

    explicit const_mem_fun_ref_t(S (T::*p)() const);

346

    S operator()(const T& p) const;

347

};

348

349

template <class S, class T, class A>

350

class const_mem_fun1_ref_t : public binary_function<T, A, S>

351

352

public:

353

    explicit const_mem_fun1_ref_t(S (T::*p)(A) const);

354

    S operator()(const T& p, A x) const;

355

};

356

357

template <class S, class T>          const_mem_fun_ref_t<S,T>    mem_fun_ref(S (T::*f)() const);

358

template <class S, class T, class A> const_mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A) const);

359

360

template<class R, class T> unspecified mem_fn(R T::*);

361

362

class bad_function_call

363

    : public exception

364

365

};

366

367

template<class> class function; // undefined

368

369

template<class R, class... ArgTypes>

370

class function<R(ArgTypes...)>

371

  : public unary_function<T1, R>      // iff sizeof...(ArgTypes) == 1 and

372

                                      // ArgTypes contains T1

373

  : public binary_function<T1, T2, R> // iff sizeof...(ArgTypes) == 2 and

374

                                      // ArgTypes contains T1 and T2

375

376

public:

377

    typedef R result_type;

378

379

    // construct/copy/destroy:

380

    function() noexcept;

381

    function(nullptr_t) noexcept;

382

    function(const function&);

383

    function(function&&) noexcept;

384

    template<class F>

385

      function(F);

386

    template<Allocator Alloc>

387

      function(allocator_arg_t, const Alloc&) noexcept;

388

    template<Allocator Alloc>

389

      function(allocator_arg_t, const Alloc&, nullptr_t) noexcept;

390

    template<Allocator Alloc>

391

      function(allocator_arg_t, const Alloc&, const function&);

392

    template<Allocator Alloc>

393

      function(allocator_arg_t, const Alloc&, function&&);

394

    template<class F, Allocator Alloc>

395

      function(allocator_arg_t, const Alloc&, F);

396

397

    function& operator=(const function&);

398

    function& operator=(function&&) noexcept;

399

    function& operator=(nullptr_t) noexcept;

400

    template<class F>

401

      function& operator=(F&&);

402

    template<class F>

403

      function& operator=(reference_wrapper<F>) noexcept;

404

405

    ~function();

406

407

    // function modifiers:

408

    void swap(function&) noexcept;

409

    template<class F, class Alloc>

410

      void assign(F&&, const Alloc&);

411

412

    // function capacity:

413

    explicit operator bool() const noexcept;

414

415

    // function invocation:

416

    R operator()(ArgTypes...) const;

417

418

    // function target access:

419

    const std::type_info& target_type() const noexcept;

420

    template <typename T>       T* target() noexcept;

421

    template <typename T> const T* target() const noexcept;

422

};

423

424

// Null pointer comparisons:

425

template <class R, class ... ArgTypes>

426

  bool operator==(const function<R(ArgTypes...)>&, nullptr_t) noexcept;

427

428

template <class R, class ... ArgTypes>

429

  bool operator==(nullptr_t, const function<R(ArgTypes...)>&) noexcept;

430

431

template <class R, class ... ArgTypes>

432

  bool operator!=(const function<R(ArgTypes...)>&, nullptr_t) noexcept;

433

434

template <class  R, class ... ArgTypes>

435

  bool operator!=(nullptr_t, const function<R(ArgTypes...)>&) noexcept;

436

437

// specialized algorithms:

438

template <class  R, class ... ArgTypes>

439

  void swap(function<R(ArgTypes...)>&, function<R(ArgTypes...)>&) noexcept;

440

441

template <class T> struct hash;

442

443

template <> struct hash<bool>;

444

template <> struct hash<char>;

445

template <> struct hash<signed char>;

446

template <> struct hash<unsigned char>;

447

template <> struct hash<char16_t>;

448

template <> struct hash<char32_t>;

449

template <> struct hash<wchar_t>;

450

template <> struct hash<short>;

451

template <> struct hash<unsigned short>;

452

template <> struct hash<int>;

453

template <> struct hash<unsigned int>;

454

template <> struct hash<long>;

455

template <> struct hash<long long>;

456

template <> struct hash<unsigned long>;

457

template <> struct hash<unsigned long long>;

458

459

template <> struct hash<float>;

460

template <> struct hash<double>;

461

template <> struct hash<long double>;

462

463

template<class T> struct hash<T*>;

464

465

}  // std

466

467

POLICY:  For non-variadic implementations, the number of arguments is limited

468

         to 3.  It is hoped that the need for non-variadic implementations

469

         will be minimal.

470

471

*/

472

473

#include <__config>

474

#include <type_traits>

475

#include <typeinfo>

476

#include <exception>

477

#include <memory>

478

#include <tuple>

479

480

#include <__functional_base>

481

482

#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

483

#pragma GCC system_header

484

#endif

485

486

_LIBCPP_BEGIN_NAMESPACE_STD

487

488

#if _LIBCPP_STD_VER > 11

489

template <class _Tp = void>

490

#else

491

template <class _Tp>

492

#endif

493

struct _LIBCPP_TYPE_VIS_ONLY plus : binary_function<_Tp, _Tp, _Tp>

494

495

    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

496

    _Tp operator()(const _Tp& __x, const _Tp& __y) const

497

        {return __x + __y;}

498

};

499

500

#if _LIBCPP_STD_VER > 11

501

template <>

502

struct _LIBCPP_TYPE_VIS_ONLY plus<void>

503

504

    template <class _T1, class _T2>

505

    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

506

    auto operator()(_T1&& __t, _T2&& __u) const

507

    _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) + _VSTD::forward<_T2>(__u)))

508

    -> decltype        (_VSTD::forward<_T1>(__t) + _VSTD::forward<_T2>(__u))

509

        { return        _VSTD::forward<_T1>(__t) + _VSTD::forward<_T2>(__u); }

510

    typedef void is_transparent;

511

};

512

#endif

513

514

515

#if _LIBCPP_STD_VER > 11

516

template <class _Tp = void>

517

#else

518

template <class _Tp>

519

#endif

520

struct _LIBCPP_TYPE_VIS_ONLY minus : binary_function<_Tp, _Tp, _Tp>

521

522

    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

523

    _Tp operator()(const _Tp& __x, const _Tp& __y) const

524

        {return __x - __y;}

525

};

526

527

#if _LIBCPP_STD_VER > 11

528

template <>

529

struct _LIBCPP_TYPE_VIS_ONLY minus<void>

530

531

    template <class _T1, class _T2>

532

    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

533

    auto operator()(_T1&& __t, _T2&& __u) const

534

    _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) - _VSTD::forward<_T2>(__u)))

535

    -> decltype        (_VSTD::forward<_T1>(__t) - _VSTD::forward<_T2>(__u))

536

        { return        _VSTD::forward<_T1>(__t) - _VSTD::forward<_T2>(__u); }

537

    typedef void is_transparent;

538

};

539

#endif

540

541

542

#if _LIBCPP_STD_VER > 11

543

template <class _Tp = void>

544

#else

545

template <class _Tp>

546

#endif

547

struct _LIBCPP_TYPE_VIS_ONLY multiplies : binary_function<_Tp, _Tp, _Tp>

548

549

    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

550

    _Tp operator()(const _Tp& __x, const _Tp& __y) const

551

        {return __x * __y;}

552

};

553

554

#if _LIBCPP_STD_VER > 11

555

template <>

556

struct _LIBCPP_TYPE_VIS_ONLY multiplies<void>

557

558

    template <class _T1, class _T2>

559

    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

560

    auto operator()(_T1&& __t, _T2&& __u) const

561

    _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) * _VSTD::forward<_T2>(__u)))

562

    -> decltype        (_VSTD::forward<_T1>(__t) * _VSTD::forward<_T2>(__u))

563

        { return        _VSTD::forward<_T1>(__t) * _VSTD::forward<_T2>(__u); }

564

    typedef void is_transparent;

565

};

566

#endif

567

568

569

#if _LIBCPP_STD_VER > 11

570

template <class _Tp = void>

571

#else

572

template <class _Tp>

573

#endif

574

struct _LIBCPP_TYPE_VIS_ONLY divides : binary_function<_Tp, _Tp, _Tp>

575

576

    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

577

    _Tp operator()(const _Tp& __x, const _Tp& __y) const

578

        {return __x / __y;}

579

};

580

581

#if _LIBCPP_STD_VER > 11

582

template <>

583

struct _LIBCPP_TYPE_VIS_ONLY divides<void>

584

585

    template <class _T1, class _T2>

586

    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

587

    auto operator()(_T1&& __t, _T2&& __u) const

588

    _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) / _VSTD::forward<_T2>(__u)))

589

    -> decltype        (_VSTD::forward<_T1>(__t) / _VSTD::forward<_T2>(__u))

590

        { return        _VSTD::forward<_T1>(__t) / _VSTD::forward<_T2>(__u); }

591

    typedef void is_transparent;

592

};

593

#endif

594

595

596

#if _LIBCPP_STD_VER > 11

597

template <class _Tp = void>

598

#else

599

template <class _Tp>

600

#endif

601

struct _LIBCPP_TYPE_VIS_ONLY modulus : binary_function<_Tp, _Tp, _Tp>

602

603

    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

604

    _Tp operator()(const _Tp& __x, const _Tp& __y) const

605

        {return __x % __y;}

606

};

607

608

#if _LIBCPP_STD_VER > 11

609

template <>

610

struct _LIBCPP_TYPE_VIS_ONLY modulus<void>

611

612

    template <class _T1, class _T2>

613

    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

614

    auto operator()(_T1&& __t, _T2&& __u) const

615

    _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) % _VSTD::forward<_T2>(__u)))

616

    -> decltype        (_VSTD::forward<_T1>(__t) % _VSTD::forward<_T2>(__u))

617

        { return        _VSTD::forward<_T1>(__t) % _VSTD::forward<_T2>(__u); }

618

    typedef void is_transparent;

619

};

620

#endif

621

622

623

#if _LIBCPP_STD_VER > 11

624

template <class _Tp = void>

625

#else

626

template <class _Tp>

627

#endif

628

struct _LIBCPP_TYPE_VIS_ONLY negate : unary_function<_Tp, _Tp>

629

630

    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

631

    _Tp operator()(const _Tp& __x) const

632

        {return -__x;}

633

};

634

635

#if _LIBCPP_STD_VER > 11

636

template <>

637

struct _LIBCPP_TYPE_VIS_ONLY negate<void>

638

639

    template <class _Tp>

640

    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

641

    auto operator()(_Tp&& __x) const

642

    _NOEXCEPT_(noexcept(- _VSTD::forward<_Tp>(__x)))

643

    -> decltype        (- _VSTD::forward<_Tp>(__x))

644

        { return        - _VSTD::forward<_Tp>(__x); }

645

    typedef void is_transparent;

646

};

647

#endif

648

649

650

#if _LIBCPP_STD_VER > 11

651

template <class _Tp = void>

652

#else

653

template <class _Tp>

654

#endif

655

struct _LIBCPP_TYPE_VIS_ONLY equal_to : binary_function<_Tp, _Tp, bool>

656

657

    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

658

    bool operator()(const _Tp& __x, const _Tp& __y) const

659

        {return __x == __y;}

660

};

661

662

#if _LIBCPP_STD_VER > 11

663

template <>

664

struct _LIBCPP_TYPE_VIS_ONLY equal_to<void>

665

666

    template <class _T1, class _T2>

667

    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

668

    auto operator()(_T1&& __t, _T2&& __u) const

669

    _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) == _VSTD::forward<_T2>(__u)))

670

    -> decltype        (_VSTD::forward<_T1>(__t) == _VSTD::forward<_T2>(__u))

671

        { return        _VSTD::forward<_T1>(__t) == _VSTD::forward<_T2>(__u); }

672

    typedef void is_transparent;

673

};

674

#endif

675

676

677

#if _LIBCPP_STD_VER > 11

678

template <class _Tp = void>

679

#else

680

template <class _Tp>

681

#endif

682

struct _LIBCPP_TYPE_VIS_ONLY not_equal_to : binary_function<_Tp, _Tp, bool>

683

684

    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

685

    bool operator()(const _Tp& __x, const _Tp& __y) const

686

        {return __x != __y;}

687

};

688

689

#if _LIBCPP_STD_VER > 11

690

template <>

691

struct _LIBCPP_TYPE_VIS_ONLY not_equal_to<void>

692

693

    template <class _T1, class _T2>

694

    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

695

    auto operator()(_T1&& __t, _T2&& __u) const

696

    _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) != _VSTD::forward<_T2>(__u)))

697

    -> decltype        (_VSTD::forward<_T1>(__t) != _VSTD::forward<_T2>(__u))

698

        { return        _VSTD::forward<_T1>(__t) != _VSTD::forward<_T2>(__u); }

699

    typedef void is_transparent;

700

};

701

#endif

702

703

704

#if _LIBCPP_STD_VER > 11

705

template <class _Tp = void>

706

#else

707

template <class _Tp>

708

#endif

709

struct _LIBCPP_TYPE_VIS_ONLY greater : binary_function<_Tp, _Tp, bool>

710

711

    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

712

    bool operator()(const _Tp& __x, const _Tp& __y) const

713

        {return __x > __y;}

714

};

715

716

#if _LIBCPP_STD_VER > 11

717

template <>

718

struct _LIBCPP_TYPE_VIS_ONLY greater<void>

719

720

    template <class _T1, class _T2>

721

    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

722

    auto operator()(_T1&& __t, _T2&& __u) const

723

    _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) > _VSTD::forward<_T2>(__u)))

724

    -> decltype        (_VSTD::forward<_T1>(__t) > _VSTD::forward<_T2>(__u))

725

        { return        _VSTD::forward<_T1>(__t) > _VSTD::forward<_T2>(__u); }

726

    typedef void is_transparent;

727

};

728

#endif

729

730

731

// less in <__functional_base>

732

733

#if _LIBCPP_STD_VER > 11

734

template <class _Tp = void>

735

#else

736

template <class _Tp>

737

#endif

738

struct _LIBCPP_TYPE_VIS_ONLY greater_equal : binary_function<_Tp, _Tp, bool>

739

740

    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

741

    bool operator()(const _Tp& __x, const _Tp& __y) const

742

        {return __x >= __y;}

743

};

744

745

#if _LIBCPP_STD_VER > 11

746

template <>

747

struct _LIBCPP_TYPE_VIS_ONLY greater_equal<void>

748

749

    template <class _T1, class _T2>

750

    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

751

    auto operator()(_T1&& __t, _T2&& __u) const

752

    _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) >= _VSTD::forward<_T2>(__u)))

753

    -> decltype        (_VSTD::forward<_T1>(__t) >= _VSTD::forward<_T2>(__u))

754

        { return        _VSTD::forward<_T1>(__t) >= _VSTD::forward<_T2>(__u); }

755

    typedef void is_transparent;

756

};

757

#endif

758

759

760

#if _LIBCPP_STD_VER > 11

761

template <class _Tp = void>

762

#else

763

template <class _Tp>

764

#endif

765

struct _LIBCPP_TYPE_VIS_ONLY less_equal : binary_function<_Tp, _Tp, bool>

766

767

    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

768

    bool operator()(const _Tp& __x, const _Tp& __y) const

769

        {return __x <= __y;}

770

};

771

772

#if _LIBCPP_STD_VER > 11

773

template <>

774

struct _LIBCPP_TYPE_VIS_ONLY less_equal<void>

775

776

    template <class _T1, class _T2>

777

    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

778

    auto operator()(_T1&& __t, _T2&& __u) const

779

    _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) <= _VSTD::forward<_T2>(__u)))

780

    -> decltype        (_VSTD::forward<_T1>(__t) <= _VSTD::forward<_T2>(__u))

781

        { return        _VSTD::forward<_T1>(__t) <= _VSTD::forward<_T2>(__u); }

782

    typedef void is_transparent;

783

};

784

#endif

785

786

787

#if _LIBCPP_STD_VER > 11

788

template <class _Tp = void>

789

#else

790

template <class _Tp>

791

#endif

792

struct _LIBCPP_TYPE_VIS_ONLY logical_and : binary_function<_Tp, _Tp, bool>

793

794

    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

795

    bool operator()(const _Tp& __x, const _Tp& __y) const

796

        {return __x && __y;}

797

};

798

799

#if _LIBCPP_STD_VER > 11

800

template <>

801

struct _LIBCPP_TYPE_VIS_ONLY logical_and<void>

802

803

    template <class _T1, class _T2>

804

    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

805

    auto operator()(_T1&& __t, _T2&& __u) const

806

    _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) && _VSTD::forward<_T2>(__u)))

807

    -> decltype        (_VSTD::forward<_T1>(__t) && _VSTD::forward<_T2>(__u))

808

        { return        _VSTD::forward<_T1>(__t) && _VSTD::forward<_T2>(__u); }

809

    typedef void is_transparent;

810

};

811

#endif

812

813

814

#if _LIBCPP_STD_VER > 11

815

template <class _Tp = void>

816

#else

817

template <class _Tp>

818

#endif

819

struct _LIBCPP_TYPE_VIS_ONLY logical_or : binary_function<_Tp, _Tp, bool>

820

821

    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

822

    bool operator()(const _Tp& __x, const _Tp& __y) const

823

        {return __x || __y;}

824

};

825

826

#if _LIBCPP_STD_VER > 11

827

template <>

828

struct _LIBCPP_TYPE_VIS_ONLY logical_or<void>

829

830

    template <class _T1, class _T2>

831

    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

832

    auto operator()(_T1&& __t, _T2&& __u) const

833

    _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) || _VSTD::forward<_T2>(__u)))

834

    -> decltype        (_VSTD::forward<_T1>(__t) || _VSTD::forward<_T2>(__u))

835

        { return        _VSTD::forward<_T1>(__t) || _VSTD::forward<_T2>(__u); }

836

    typedef void is_transparent;

837

};

838

#endif

839

840

841

#if _LIBCPP_STD_VER > 11

842

template <class _Tp = void>

843

#else

844

template <class _Tp>

845

#endif

846

struct _LIBCPP_TYPE_VIS_ONLY logical_not : unary_function<_Tp, bool>

847

848

    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

849

    bool operator()(const _Tp& __x) const

850

        {return !__x;}

851

};

852

853

#if _LIBCPP_STD_VER > 11

854

template <>

855

struct _LIBCPP_TYPE_VIS_ONLY logical_not<void>

856

857

    template <class _Tp>

858

    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

859

    auto operator()(_Tp&& __x) const

860

    _NOEXCEPT_(noexcept(!_VSTD::forward<_Tp>(__x)))

861

    -> decltype        (!_VSTD::forward<_Tp>(__x))

862

        { return        !_VSTD::forward<_Tp>(__x); }

863

    typedef void is_transparent;

864

};

865

#endif

866

867

868

#if _LIBCPP_STD_VER > 11

869

template <class _Tp = void>

870

#else

871

template <class _Tp>

872

#endif

873

struct _LIBCPP_TYPE_VIS_ONLY bit_and : binary_function<_Tp, _Tp, _Tp>

874

875

    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

876

    _Tp operator()(const _Tp& __x, const _Tp& __y) const

877

        {return __x & __y;}

878

};

879

880

#if _LIBCPP_STD_VER > 11

881

template <>

882

struct _LIBCPP_TYPE_VIS_ONLY bit_and<void>

883

884

    template <class _T1, class _T2>

885

    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

886

    auto operator()(_T1&& __t, _T2&& __u) const

887

    _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) & _VSTD::forward<_T2>(__u)))

888

    -> decltype        (_VSTD::forward<_T1>(__t) & _VSTD::forward<_T2>(__u))

889

        { return        _VSTD::forward<_T1>(__t) & _VSTD::forward<_T2>(__u); }

890

    typedef void is_transparent;

891

};

892

#endif

893

894

895

#if _LIBCPP_STD_VER > 11

896

template <class _Tp = void>

897

#else

898

template <class _Tp>

899

#endif

900

struct _LIBCPP_TYPE_VIS_ONLY bit_or : binary_function<_Tp, _Tp, _Tp>

901

902

    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

903

    _Tp operator()(const _Tp& __x, const _Tp& __y) const

904

        {return __x | __y;}

905

};

906

907

#if _LIBCPP_STD_VER > 11

908

template <>

909

struct _LIBCPP_TYPE_VIS_ONLY bit_or<void>

910

911

    template <class _T1, class _T2>

912

    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

913

    auto operator()(_T1&& __t, _T2&& __u) const

914

    _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) | _VSTD::forward<_T2>(__u)))

915

    -> decltype        (_VSTD::forward<_T1>(__t) | _VSTD::forward<_T2>(__u))

916

        { return        _VSTD::forward<_T1>(__t) | _VSTD::forward<_T2>(__u); }

917

    typedef void is_transparent;

918

};

919

#endif

920

921

922

#if _LIBCPP_STD_VER > 11

923

template <class _Tp = void>

924

#else

925

template <class _Tp>

926

#endif

927

struct _LIBCPP_TYPE_VIS_ONLY bit_xor : binary_function<_Tp, _Tp, _Tp>

928

929

    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

930

    _Tp operator()(const _Tp& __x, const _Tp& __y) const

931

        {return __x ^ __y;}

932

};

933

934

#if _LIBCPP_STD_VER > 11

935

template <>

936

struct _LIBCPP_TYPE_VIS_ONLY bit_xor<void>

937

938

    template <class _T1, class _T2>

939

    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

940

    auto operator()(_T1&& __t, _T2&& __u) const

941

    _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) ^ _VSTD::forward<_T2>(__u)))

942

    -> decltype        (_VSTD::forward<_T1>(__t) ^ _VSTD::forward<_T2>(__u))

943

        { return        _VSTD::forward<_T1>(__t) ^ _VSTD::forward<_T2>(__u); }

944

    typedef void is_transparent;

945

};

946

#endif

947

948

949

#if _LIBCPP_STD_VER > 11

950

template <class _Tp = void>

951

struct _LIBCPP_TYPE_VIS_ONLY bit_not : unary_function<_Tp, _Tp>

952

953

    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

954

    _Tp operator()(const _Tp& __x) const

955

        {return ~__x;}

956

};

957

958

template <>

959

struct _LIBCPP_TYPE_VIS_ONLY bit_not<void>

960

961

    template <class _Tp>

962

    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

963

    auto operator()(_Tp&& __x) const

964

    _NOEXCEPT_(noexcept(~_VSTD::forward<_Tp>(__x)))

965

    -> decltype        (~_VSTD::forward<_Tp>(__x))

966

        { return        ~_VSTD::forward<_Tp>(__x); }

967

    typedef void is_transparent;

968

};

969

#endif

970

971

template <class _Predicate>

972

class _LIBCPP_TYPE_VIS_ONLY unary_negate

973

    : public unary_function<typename _Predicate::argument_type, bool>

974

975

    _Predicate __pred_;

976

public:

977

    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

978

    explicit unary_negate(const _Predicate& __pred)

979

        : __pred_(__pred) {}

980

    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

981

    bool operator()(const typename _Predicate::argument_type& __x) const

982

        {return !__pred_(__x);}

983

};

984

985

template <class _Predicate>

986

inline _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

987

unary_negate<_Predicate>

988

not1(const _Predicate& __pred) {return unary_negate<_Predicate>(__pred);}

989

990

template <class _Predicate>

991

class _LIBCPP_TYPE_VIS_ONLY binary_negate

992

    : public binary_function<typename _Predicate::first_argument_type,

993

                             typename _Predicate::second_argument_type,

994

                             bool>

995

996

    _Predicate __pred_;

997

public:

998

    _LIBCPP_INLINE_VISIBILITY explicit _LIBCPP_CONSTEXPR_AFTER_CXX11

999

    binary_negate(const _Predicate& __pred) : __pred_(__pred) {}

1000

1001

    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

1002

    bool operator()(const typename _Predicate::first_argument_type& __x,

1003

                    const typename _Predicate::second_argument_type& __y) const

1004

        {return !__pred_(__x, __y);}

1005

};

1006

1007

template <class _Predicate>

1008

inline _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY

1009

binary_negate<_Predicate>

1010

not2(const _Predicate& __pred) {return binary_negate<_Predicate>(__pred);}

1011

1012

template <class __Operation>

1013

class _LIBCPP_TYPE_VIS_ONLY binder1st

1014

    : public unary_function<typename __Operation::second_argument_type,

1015

                            typename __Operation::result_type>

1016

1017

protected:

1018

    __Operation                               op;

1019

    typename __Operation::first_argument_type value;

1020

public:

1021

    _LIBCPP_INLINE_VISIBILITY binder1st(const __Operation& __x,

1022

                               const typename __Operation::first_argument_type __y)

1023

        : op(__x), value(__y) {}

1024

    _LIBCPP_INLINE_VISIBILITY typename __Operation::result_type operator()

1025

        (typename __Operation::second_argument_type& __x) const

1026

            {return op(value, __x);}

1027

    _LIBCPP_INLINE_VISIBILITY typename __Operation::result_type operator()

1028

        (const typename __Operation::second_argument_type& __x) const

1029

            {return op(value, __x);}

1030

};

1031

1032

template <class __Operation, class _Tp>

1033

inline _LIBCPP_INLINE_VISIBILITY

1034

binder1st<__Operation>

1035

bind1st(const __Operation& __op, const _Tp& __x)

1036

    {return binder1st<__Operation>(__op, __x);}

1037

1038

template <class __Operation>

1039

class _LIBCPP_TYPE_VIS_ONLY binder2nd

1040

    : public unary_function<typename __Operation::first_argument_type,

1041

                            typename __Operation::result_type>

1042

1043

protected:

1044

    __Operation                                op;

1045

    typename __Operation::second_argument_type value;

1046

public:

1047

    _LIBCPP_INLINE_VISIBILITY

1048

    binder2nd(const __Operation& __x, const typename __Operation::second_argument_type __y)

1049

        : op(__x), value(__y) {}

1050

    _LIBCPP_INLINE_VISIBILITY typename __Operation::result_type operator()

1051

        (      typename __Operation::first_argument_type& __x) const

1052

            {return op(__x, value);}

1053

    _LIBCPP_INLINE_VISIBILITY typename __Operation::result_type operator()

1054

        (const typename __Operation::first_argument_type& __x) const

1055

            {return op(__x, value);}

1056

};

1057

1058

template <class __Operation, class _Tp>

1059

inline _LIBCPP_INLINE_VISIBILITY

1060

binder2nd<__Operation>

1061

bind2nd(const __Operation& __op, const _Tp& __x)

1062

    {return binder2nd<__Operation>(__op, __x);}

1063

1064

template <class _Arg, class _Result>

1065

class _LIBCPP_TYPE_VIS_ONLY pointer_to_unary_function

1066

    : public unary_function<_Arg, _Result>

1067

1068

    _Result (*__f_)(_Arg);

1069

public:

1070

    _LIBCPP_INLINE_VISIBILITY explicit pointer_to_unary_function(_Result (*__f)(_Arg))

1071

        : __f_(__f) {}

1072

    _LIBCPP_INLINE_VISIBILITY _Result operator()(_Arg __x) const

1073

        {return __f_(__x);}

1074

};

1075

1076

template <class _Arg, class _Result>

1077

inline _LIBCPP_INLINE_VISIBILITY

1078

pointer_to_unary_function<_Arg,_Result>

1079

ptr_fun(_Result (*__f)(_Arg))

1080

    {return pointer_to_unary_function<_Arg,_Result>(__f);}

1081

1082

template <class _Arg1, class _Arg2, class _Result>

1083

class _LIBCPP_TYPE_VIS_ONLY pointer_to_binary_function

1084

    : public binary_function<_Arg1, _Arg2, _Result>

1085

1086

    _Result (*__f_)(_Arg1, _Arg2);

1087

public:

1088

    _LIBCPP_INLINE_VISIBILITY explicit pointer_to_binary_function(_Result (*__f)(_Arg1, _Arg2))

1089

        : __f_(__f) {}

1090

    _LIBCPP_INLINE_VISIBILITY _Result operator()(_Arg1 __x, _Arg2 __y) const

1091

        {return __f_(__x, __y);}

1092

};

1093

1094

template <class _Arg1, class _Arg2, class _Result>

1095

inline _LIBCPP_INLINE_VISIBILITY

1096

pointer_to_binary_function<_Arg1,_Arg2,_Result>

1097

ptr_fun(_Result (*__f)(_Arg1,_Arg2))

1098

    {return pointer_to_binary_function<_Arg1,_Arg2,_Result>(__f);}

1099

1100

template<class _Sp, class _Tp>

1101

class _LIBCPP_TYPE_VIS_ONLY mem_fun_t : public unary_function<_Tp*, _Sp>

1102

1103

    _Sp (_Tp::*__p_)();

1104

public:

1105

    _LIBCPP_INLINE_VISIBILITY explicit mem_fun_t(_Sp (_Tp::*__p)())

1106

        : __p_(__p) {}

1107

    _LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp* __p) const

1108

        {return (__p->*__p_)();}

1109

};

1110

1111

template<class _Sp, class _Tp, class _Ap>

1112

class _LIBCPP_TYPE_VIS_ONLY mem_fun1_t : public binary_function<_Tp*, _Ap, _Sp>

1113

1114

    _Sp (_Tp::*__p_)(_Ap);

1115

public:

1116

    _LIBCPP_INLINE_VISIBILITY explicit mem_fun1_t(_Sp (_Tp::*__p)(_Ap))

1117

        : __p_(__p) {}

1118

    _LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp* __p, _Ap __x) const

1119

        {return (__p->*__p_)(__x);}

1120

};

1121

1122

template<class _Sp, class _Tp>

1123

inline _LIBCPP_INLINE_VISIBILITY

1124

mem_fun_t<_Sp,_Tp>

1125

mem_fun(_Sp (_Tp::*__f)())

1126

    {return mem_fun_t<_Sp,_Tp>(__f);}

1127

1128

template<class _Sp, class _Tp, class _Ap>

1129

inline _LIBCPP_INLINE_VISIBILITY

1130

mem_fun1_t<_Sp,_Tp,_Ap>

1131

mem_fun(_Sp (_Tp::*__f)(_Ap))

1132

    {return mem_fun1_t<_Sp,_Tp,_Ap>(__f);}

1133

1134

template<class _Sp, class _Tp>

1135

class _LIBCPP_TYPE_VIS_ONLY mem_fun_ref_t : public unary_function<_Tp, _Sp>

1136

1137

    _Sp (_Tp::*__p_)();

1138

public:

1139

    _LIBCPP_INLINE_VISIBILITY explicit mem_fun_ref_t(_Sp (_Tp::*__p)())

1140

        : __p_(__p) {}

1141

    _LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp& __p) const

1142

        {return (__p.*__p_)();}

1143

};

1144

1145

template<class _Sp, class _Tp, class _Ap>

1146

class _LIBCPP_TYPE_VIS_ONLY mem_fun1_ref_t : public binary_function<_Tp, _Ap, _Sp>

1147

1148

    _Sp (_Tp::*__p_)(_Ap);

1149

public:

1150

    _LIBCPP_INLINE_VISIBILITY explicit mem_fun1_ref_t(_Sp (_Tp::*__p)(_Ap))

1151

        : __p_(__p) {}

1152

    _LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp& __p, _Ap __x) const

1153

        {return (__p.*__p_)(__x);}

1154

};

1155

1156

template<class _Sp, class _Tp>

1157

inline _LIBCPP_INLINE_VISIBILITY

1158

mem_fun_ref_t<_Sp,_Tp>

1159

mem_fun_ref(_Sp (_Tp::*__f)())

1160

    {return mem_fun_ref_t<_Sp,_Tp>(__f);}

1161

1162

template<class _Sp, class _Tp, class _Ap>

1163

inline _LIBCPP_INLINE_VISIBILITY

1164

mem_fun1_ref_t<_Sp,_Tp,_Ap>

1165

mem_fun_ref(_Sp (_Tp::*__f)(_Ap))

1166

    {return mem_fun1_ref_t<_Sp,_Tp,_Ap>(__f);}

1167

1168

template <class _Sp, class _Tp>

1169

class _LIBCPP_TYPE_VIS_ONLY const_mem_fun_t : public unary_function<const _Tp*, _Sp>

1170

1171

    _Sp (_Tp::*__p_)() const;

1172

public:

1173

    _LIBCPP_INLINE_VISIBILITY explicit const_mem_fun_t(_Sp (_Tp::*__p)() const)

1174

        : __p_(__p) {}

1175

    _LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp* __p) const

1176

        {return (__p->*__p_)();}

1177

};

1178

1179

template <class _Sp, class _Tp, class _Ap>

1180

class _LIBCPP_TYPE_VIS_ONLY const_mem_fun1_t : public binary_function<const _Tp*, _Ap, _Sp>

1181

1182

    _Sp (_Tp::*__p_)(_Ap) const;

1183

public:

1184

    _LIBCPP_INLINE_VISIBILITY explicit const_mem_fun1_t(_Sp (_Tp::*__p)(_Ap) const)

1185

        : __p_(__p) {}

1186

    _LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp* __p, _Ap __x) const

1187

        {return (__p->*__p_)(__x);}

1188

};

1189

1190

template <class _Sp, class _Tp>

1191

inline _LIBCPP_INLINE_VISIBILITY

1192

const_mem_fun_t<_Sp,_Tp>

1193

mem_fun(_Sp (_Tp::*__f)() const)

1194

    {return const_mem_fun_t<_Sp,_Tp>(__f);}

1195

1196

template <class _Sp, class _Tp, class _Ap>

1197

inline _LIBCPP_INLINE_VISIBILITY

1198

const_mem_fun1_t<_Sp,_Tp,_Ap>

1199

mem_fun(_Sp (_Tp::*__f)(_Ap) const)

1200

    {return const_mem_fun1_t<_Sp,_Tp,_Ap>(__f);}

1201

1202

template <class _Sp, class _Tp>

1203

class _LIBCPP_TYPE_VIS_ONLY const_mem_fun_ref_t : public unary_function<_Tp, _Sp>

1204

1205

    _Sp (_Tp::*__p_)() const;

1206

public:

1207

    _LIBCPP_INLINE_VISIBILITY explicit const_mem_fun_ref_t(_Sp (_Tp::*__p)() const)

1208

        : __p_(__p) {}

1209

    _LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp& __p) const

1210

        {return (__p.*__p_)();}

1211

};

1212

1213

template <class _Sp, class _Tp, class _Ap>

1214

class _LIBCPP_TYPE_VIS_ONLY const_mem_fun1_ref_t

1215

    : public binary_function<_Tp, _Ap, _Sp>

1216

1217

    _Sp (_Tp::*__p_)(_Ap) const;

1218

public:

1219

    _LIBCPP_INLINE_VISIBILITY explicit const_mem_fun1_ref_t(_Sp (_Tp::*__p)(_Ap) const)

1220

        : __p_(__p) {}

1221

    _LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp& __p, _Ap __x) const

1222

        {return (__p.*__p_)(__x);}

1223

};

1224

1225

template <class _Sp, class _Tp>

1226

inline _LIBCPP_INLINE_VISIBILITY

1227

const_mem_fun_ref_t<_Sp,_Tp>

1228

mem_fun_ref(_Sp (_Tp::*__f)() const)

1229

    {return const_mem_fun_ref_t<_Sp,_Tp>(__f);}

1230

1231

template <class _Sp, class _Tp, class _Ap>

1232

inline _LIBCPP_INLINE_VISIBILITY

1233

const_mem_fun1_ref_t<_Sp,_Tp,_Ap>

1234

mem_fun_ref(_Sp (_Tp::*__f)(_Ap) const)

1235

    {return const_mem_fun1_ref_t<_Sp,_Tp,_Ap>(__f);}

1236

1237

////////////////////////////////////////////////////////////////////////////////

1238

//                                MEMFUN

1239

//==============================================================================

1240

1241

template <class _Tp>

1242

class __mem_fn

1243

    : public __weak_result_type<_Tp>

1244

1245

public:

1246

    // types

1247

    typedef _Tp type;

1248

private:

1249

    type __f_;

1250

1251

public:

1252

    _LIBCPP_INLINE_VISIBILITY __mem_fn(type __f) : __f_(__f) {}

1253

1254

#ifndef _LIBCPP_HAS_NO_VARIADICS

1255

    // invoke

1256

    template <class... _ArgTypes>

1257

    _LIBCPP_INLINE_VISIBILITY

1258

    typename __invoke_return<type, _ArgTypes...>::type

1259

    operator() (_ArgTypes&&... __args) const {

1260

        return __invoke(__f_, _VSTD::forward<_ArgTypes>(__args)...);

1261

1262

#else

1263

1264

    template <class _A0>

1265

    typename __invoke_return0<type, _A0>::type

1266

    operator() (_A0& __a0) const {

1267

        return __invoke(__f_, __a0);

1268

1269

1270

    template <class _A0, class _A1>

1271

    typename __invoke_return1<type, _A0, _A1>::type

1272

    operator() (_A0& __a0, _A1& __a1) const {

1273

        return __invoke(__f_, __a0, __a1);

1274

1275

1276

    template <class _A0, class _A1, class _A2>

1277

    typename __invoke_return2<type, _A0, _A1, _A2>::type

1278

    operator() (_A0& __a0, _A1& __a1, _A2& __a2) const {

1279

        return __invoke(__f_, __a0, __a1, __a2);

1280

1281

#endif

1282

};

1283

1284

template<class _Rp, class _Tp>

1285

inline _LIBCPP_INLINE_VISIBILITY

1286

__mem_fn<_Rp _Tp::*>

1287

mem_fn(_Rp _Tp::* __pm)

1288

1289

    return __mem_fn<_Rp _Tp::*>(__pm);

1290

1291

1292

////////////////////////////////////////////////////////////////////////////////

1293

//                                FUNCTION

1294

//==============================================================================

1295

1296

// bad_function_call

1297

1298

class _LIBCPP_EXCEPTION_ABI bad_function_call

1299

    : public exception

1300

1301

};

1302

1303

template<class _Fp> class _LIBCPP_TYPE_VIS_ONLY function; // undefined

1304

1305

namespace __function

1306

1307

1308

template<class _Rp>

1309

struct __maybe_derive_from_unary_function

1310

1311

};

1312

1313

template<class _Rp, class _A1>

1314

struct __maybe_derive_from_unary_function<_Rp(_A1)>

1315

    : public unary_function<_A1, _Rp>

1316

1317

};

1318

1319

template<class _Rp>

1320

struct __maybe_derive_from_binary_function

1321

1322

};

1323

1324

template<class _Rp, class _A1, class _A2>

1325

struct __maybe_derive_from_binary_function<_Rp(_A1, _A2)>

1326

    : public binary_function<_A1, _A2, _Rp>

1327

1328

};

1329

1330

template <class _Fp>

1331

_LIBCPP_INLINE_VISIBILITY

1332

bool __not_null(_Fp const&) { return true; }

1333

1334

template <class _Fp>

1335

_LIBCPP_INLINE_VISIBILITY

1336

bool __not_null(_Fp* __ptr) { return __ptr; }

1337

1338

template <class _Ret, class _Class>

1339

_LIBCPP_INLINE_VISIBILITY

1340

bool __not_null(_Ret _Class::*__ptr) { return __ptr; }

1341

1342

template <class _Fp>

1343

_LIBCPP_INLINE_VISIBILITY

1344

bool __not_null(function<_Fp> const& __f) { return !!__f; }

1345

1346

} // namespace __function

1347

1348

#ifndef _LIBCPP_HAS_NO_VARIADICS

1349

1350

namespace __function {

1351

1352

template<class _Fp> class __base;

1353

1354

template<class _Rp, class ..._ArgTypes>

1355

class __base<_Rp(_ArgTypes...)>

1356

1357

    __base(const __base&);

1358

    __base& operator=(const __base&);

1359

public:

1360

    _LIBCPP_INLINE_VISIBILITY __base() {}

1361

    _LIBCPP_INLINE_VISIBILITY virtual ~__base() {}

1362

    virtual __base* __clone() const = 0;

1363

    virtual void __clone(__base*) const = 0;

1364

    virtual void destroy() _NOEXCEPT = 0;

1365

    virtual void destroy_deallocate() _NOEXCEPT = 0;

1366

    virtual _Rp operator()(_ArgTypes&& ...) = 0;

1367

#ifndef _LIBCPP_NO_RTTI

1368

    virtual const void* target(const type_info&) const _NOEXCEPT = 0;

1369

    virtual const std::type_info& target_type() const _NOEXCEPT = 0;

1370

#endif  // _LIBCPP_NO_RTTI

1371

};

1372

1373

template<class _FD, class _Alloc, class _FB> class __func;

1374

1375

template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>

1376

class __func<_Fp, _Alloc, _Rp(_ArgTypes...)>

1377

    : public  __base<_Rp(_ArgTypes...)>

1378

1379

    __compressed_pair<_Fp, _Alloc> __f_;

1380

public:

1381

    _LIBCPP_INLINE_VISIBILITY

1382

    explicit __func(_Fp&& __f)

1383

        : __f_(piecewise_construct, _VSTD::forward_as_tuple(_VSTD::move(__f)),

1384

                                    _VSTD::forward_as_tuple()) {}

1385

    _LIBCPP_INLINE_VISIBILITY

1386

    explicit __func(const _Fp& __f, const _Alloc& __a)

1387

        : __f_(piecewise_construct, _VSTD::forward_as_tuple(__f),

1388

                                    _VSTD::forward_as_tuple(__a)) {}

1389

1390

    _LIBCPP_INLINE_VISIBILITY

1391

    explicit __func(const _Fp& __f, _Alloc&& __a)

1392

        : __f_(piecewise_construct, _VSTD::forward_as_tuple(__f),

1393

                                    _VSTD::forward_as_tuple(_VSTD::move(__a))) {}

1394

1395

    _LIBCPP_INLINE_VISIBILITY

1396

    explicit __func(_Fp&& __f, _Alloc&& __a)

1397

        : __f_(piecewise_construct, _VSTD::forward_as_tuple(_VSTD::move(__f)),

1398

                                    _VSTD::forward_as_tuple(_VSTD::move(__a))) {}

1399

    virtual __base<_Rp(_ArgTypes...)>* __clone() const;

1400

    virtual void __clone(__base<_Rp(_ArgTypes...)>*) const;

1401

    virtual void destroy() _NOEXCEPT;

1402

    virtual void destroy_deallocate() _NOEXCEPT;

1403

    virtual _Rp operator()(_ArgTypes&& ... __arg);

1404

#ifndef _LIBCPP_NO_RTTI

1405

    virtual const void* target(const type_info&) const _NOEXCEPT;

1406

    virtual const std::type_info& target_type() const _NOEXCEPT;

1407

#endif  // _LIBCPP_NO_RTTI

1408

};

1409

1410

template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>

1411

__base<_Rp(_ArgTypes...)>*

1412

__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::__clone() const

1413

1414

    typedef allocator_traits<_Alloc> __alloc_traits;

1415

    typedef typename __rebind_alloc_helper<__alloc_traits, __func>::type _Ap;

1416

    _Ap __a(__f_.second());

1417

    typedef __allocator_destructor<_Ap> _Dp;

1418

    unique_ptr<__func, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));

1419

    ::new (__hold.get()) __func(__f_.first(), _Alloc(__a));

1420

    return __hold.release();

1421

1422

1423

template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>

1424

void

1425

__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::__clone(__base<_Rp(_ArgTypes...)>* __p) const

1426

1427

    ::new (__p) __func(__f_.first(), __f_.second());

1428

1429

1430

template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>

1431

void

1432

__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy() _NOEXCEPT

1433

1434

    __f_.~__compressed_pair<_Fp, _Alloc>();

1435

1436

1437

template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>

1438

void

1439

__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy_deallocate() _NOEXCEPT

1440

1441

    typedef allocator_traits<_Alloc> __alloc_traits;

1442

    typedef typename __rebind_alloc_helper<__alloc_traits, __func>::type _Ap;

1443

    _Ap __a(__f_.second());

1444

    __f_.~__compressed_pair<_Fp, _Alloc>();

1445

    __a.deallocate(this, 1);

1446

1447

1448

template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>

1449

_Rp

1450

__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::operator()(_ArgTypes&& ... __arg)

1451

1452

    typedef __invoke_void_return_wrapper<_Rp> _Invoker;

1453

    return _Invoker::__call(__f_.first(), _VSTD::forward<_ArgTypes>(__arg)...);

1454

1455

1456

#ifndef _LIBCPP_NO_RTTI

1457

1458

template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>

1459

const void*

1460

__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::target(const type_info& __ti) const _NOEXCEPT

1461

1462

    if (__ti == typeid(_Fp))

1463

        return &__f_.first();

1464

    return (const void*)0;

1465

1466

1467

template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>

1468

const std::type_info&

1469

__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::target_type() const _NOEXCEPT

1470

1471

    return typeid(_Fp);

1472

1473

1474

#endif  // _LIBCPP_NO_RTTI

1475

1476

}  // __function

1477

1478

template<class _Rp, class ..._ArgTypes>

1479

class _LIBCPP_TYPE_VIS_ONLY function<_Rp(_ArgTypes...)>

1480

    : public __function::__maybe_derive_from_unary_function<_Rp(_ArgTypes...)>,

1481

      public __function::__maybe_derive_from_binary_function<_Rp(_ArgTypes...)>

1482

1483

    typedef __function::__base<_Rp(_ArgTypes...)> __base;

1484

    typename aligned_storage<3*sizeof(void*)>::type __buf_;

1485

    __base* __f_;

1486

1487

    template <class _Fp, bool = !is_same<_Fp, function>::value &&

1488

                                __invokable<_Fp&, _ArgTypes...>::value>

1489

        struct __callable;

1490

    template <class _Fp>

1491

        struct __callable<_Fp, true>

1492

1493

            static const bool value = is_same<void, _Rp>::value ||

1494

                is_convertible<typename __invoke_of<_Fp&, _ArgTypes...>::type,

1495

                               _Rp>::value;

1496

};

1497

    template <class _Fp>

1498

        struct __callable<_Fp, false>

1499

1500

            static const bool value = false;

1501

};

1502

public:

1503

    typedef _Rp result_type;

1504

1505

    // construct/copy/destroy:

1506

    _LIBCPP_INLINE_VISIBILITY

1507

    function() _NOEXCEPT : __f_(0) {}

1508

    _LIBCPP_INLINE_VISIBILITY

1509

    function(nullptr_t) _NOEXCEPT : __f_(0) {}

1510

    function(const function&);

1511

    function(function&&) _NOEXCEPT;

1512

    template<class _Fp>

1513

      function(_Fp, typename enable_if

1514

1515

                                        __callable<_Fp>::value &&

1516

                                        !is_same<_Fp, function>::value

1517

                                      >::type* = 0);

1518

1519

    template<class _Alloc>

1520

      _LIBCPP_INLINE_VISIBILITY

1521

      function(allocator_arg_t, const _Alloc&) _NOEXCEPT : __f_(0) {}

1522

    template<class _Alloc>

1523

      _LIBCPP_INLINE_VISIBILITY

1524

      function(allocator_arg_t, const _Alloc&, nullptr_t) _NOEXCEPT : __f_(0) {}

1525

    template<class _Alloc>

1526

      function(allocator_arg_t, const _Alloc&, const function&);

1527

    template<class _Alloc>

1528

      function(allocator_arg_t, const _Alloc&, function&&);

1529

    template<class _Fp, class _Alloc>

1530

      function(allocator_arg_t, const _Alloc& __a, _Fp __f,

1531

               typename enable_if<__callable<_Fp>::value>::type* = 0);

1532

1533

    function& operator=(const function&);

1534

    function& operator=(function&&) _NOEXCEPT;

1535

    function& operator=(nullptr_t) _NOEXCEPT;

1536

    template<class _Fp>

1537

      typename enable_if

1538

1539

        __callable<typename decay<_Fp>::type>::value &&

1540

        !is_same<typename remove_reference<_Fp>::type, function>::value,

1541

        function&

1542

      >::type

1543

      operator=(_Fp&&);

1544

1545

    ~function();

1546

1547

    // function modifiers:

1548

    void swap(function&) _NOEXCEPT;

1549

    template<class _Fp, class _Alloc>

1550

      _LIBCPP_INLINE_VISIBILITY

1551

      void assign(_Fp&& __f, const _Alloc& __a)

1552

        {function(allocator_arg, __a, _VSTD::forward<_Fp>(__f)).swap(*this);}

1553

1554

    // function capacity:

1555

    _LIBCPP_INLINE_VISIBILITY

1556

        _LIBCPP_EXPLICIT operator bool() const _NOEXCEPT {return __f_;}

1557

1558

    // deleted overloads close possible hole in the type system

1559

    template<class _R2, class... _ArgTypes2>

1560

      bool operator==(const function<_R2(_ArgTypes2...)>&) const = delete;

1561

    template<class _R2, class... _ArgTypes2>

1562

      bool operator!=(const function<_R2(_ArgTypes2...)>&) const = delete;

1563

public:

1564

    // function invocation:

1565

    _Rp operator()(_ArgTypes...) const;

1566

1567

#ifndef _LIBCPP_NO_RTTI

1568

    // function target access:

1569

    const std::type_info& target_type() const _NOEXCEPT;

1570

    template <typename _Tp> _Tp* target() _NOEXCEPT;

1571

    template <typename _Tp> const _Tp* target() const _NOEXCEPT;

1572

#endif  // _LIBCPP_NO_RTTI

1573

};

1574

1575

template<class _Rp, class ..._ArgTypes>

1576

function<_Rp(_ArgTypes...)>::function(const function& __f)

1577

1578

    if (__f.__f_ == 0)

1579

        __f_ = 0;

1580

    else if (__f.__f_ == (const __base*)&__f.__buf_)

1581

1582

        __f_ = (__base*)&__buf_;

1583

        __f.__f_->__clone(__f_);

1584

1585

    else

1586

        __f_ = __f.__f_->__clone();

1587

1588

1589

template<class _Rp, class ..._ArgTypes>

1590

template <class _Alloc>

1591

function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc&,

1592

                                     const function& __f)

1593

1594

    if (__f.__f_ == 0)

1595

        __f_ = 0;

1596

    else if (__f.__f_ == (const __base*)&__f.__buf_)

1597

1598

        __f_ = (__base*)&__buf_;

1599

        __f.__f_->__clone(__f_);

1600

1601

    else

1602

        __f_ = __f.__f_->__clone();

1603

1604

1605

template<class _Rp, class ..._ArgTypes>

1606

function<_Rp(_ArgTypes...)>::function(function&& __f) _NOEXCEPT

1607

1608

    if (__f.__f_ == 0)

1609

        __f_ = 0;

1610

    else if (__f.__f_ == (__base*)&__f.__buf_)

1611

1612

        __f_ = (__base*)&__buf_;

1613

        __f.__f_->__clone(__f_);

1614

1615

    else

1616

1617

        __f_ = __f.__f_;

1618

        __f.__f_ = 0;

template<class _Rp, class ..._ArgTypes>

1623

template <class _Alloc>

1624

function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc&,

1625

                                     function&& __f)

1626

1627

    if (__f.__f_ == 0)

1628

        __f_ = 0;

1629

    else if (__f.__f_ == (__base*)&__f.__buf_)

1630

1631

        __f_ = (__base*)&__buf_;

1632

        __f.__f_->__clone(__f_);

1633

1634

    else

1635

1636

        __f_ = __f.__f_;

1637

        __f.__f_ = 0;

template<class _Rp, class ..._ArgTypes>

1642

template <class _Fp>

1643

function<_Rp(_ArgTypes...)>::function(_Fp __f,

1644

                                     typename enable_if

1645

1646

                                        __callable<_Fp>::value &&

1647

                                        !is_same<_Fp, function>::value

1648

                                     >::type*)

1649

    : __f_(0)

1650

1651

    if (__function::__not_null(__f))

1652

1653

        typedef __function::__func<_Fp, allocator<_Fp>, _Rp(_ArgTypes...)> _FF;

1654

        if (sizeof(_FF) <= sizeof(__buf_) && is_nothrow_copy_constructible<_Fp>::value)

1655

1656

            __f_ = (__base*)&__buf_;

1657

            ::new (__f_) _FF(_VSTD::move(__f));

1658

1659

        else

1660

1661

            typedef allocator<_FF> _Ap;

1662

            _Ap __a;

1663

            typedef __allocator_destructor<_Ap> _Dp;

1664

            unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));

1665

            ::new (__hold.get()) _FF(_VSTD::move(__f), allocator<_Fp>(__a));

1666

            __f_ = __hold.release();

template<class _Rp, class ..._ArgTypes>

1672

template <class _Fp, class _Alloc>

1673

function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc& __a0, _Fp __f,

1674

                                     typename enable_if<__callable<_Fp>::value>::type*)

1675

    : __f_(0)

1676

1677

    typedef allocator_traits<_Alloc> __alloc_traits;

1678

    if (__function::__not_null(__f))

1679

1680

        typedef __function::__func<_Fp, _Alloc, _Rp(_ArgTypes...)> _FF;

1681

        typedef typename __rebind_alloc_helper<__alloc_traits, _FF>::type _Ap;

1682

        _Ap __a(__a0);

1683

        if (sizeof(_FF) <= sizeof(__buf_) &&

1684

            is_nothrow_copy_constructible<_Fp>::value && is_nothrow_copy_constructible<_Ap>::value)

1685

1686

            __f_ = (__base*)&__buf_;

1687

            ::new (__f_) _FF(_VSTD::move(__f), _Alloc(__a));

1688

1689

        else

1690

1691

            typedef __allocator_destructor<_Ap> _Dp;

1692

            unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));

1693

            ::new (__hold.get()) _FF(_VSTD::move(__f), _Alloc(__a));

1694

            __f_ = __hold.release();

template<class _Rp, class ..._ArgTypes>

1700

function<_Rp(_ArgTypes...)>&

1701

function<_Rp(_ArgTypes...)>::operator=(const function& __f)

1702

1703

    function(__f).swap(*this);

1704

    return *this;

1705

1706

1707

template<class _Rp, class ..._ArgTypes>

1708

function<_Rp(_ArgTypes...)>&

1709

function<_Rp(_ArgTypes...)>::operator=(function&& __f) _NOEXCEPT

1710

1711

    if (__f_ == (__base*)&__buf_)

1712

        __f_->destroy();

1713

    else if (__f_)

1714

        __f_->destroy_deallocate();

1715

    __f_ = 0;

1716

    if (__f.__f_ == 0)

1717

        __f_ = 0;

1718

    else if (__f.__f_ == (__base*)&__f.__buf_)

1719

1720

        __f_ = (__base*)&__buf_;

1721

        __f.__f_->__clone(__f_);

1722

1723

    else

1724

1725

        __f_ = __f.__f_;

1726

        __f.__f_ = 0;

1727

1728

    return *this;

1729

1730

1731

template<class _Rp, class ..._ArgTypes>

1732

function<_Rp(_ArgTypes...)>&

1733

function<_Rp(_ArgTypes...)>::operator=(nullptr_t) _NOEXCEPT

1734

1735

    if (__f_ == (__base*)&__buf_)

1736

        __f_->destroy();

1737

    else if (__f_)

1738

        __f_->destroy_deallocate();

1739

    __f_ = 0;

1740

    return *this;

1741

1742

1743

template<class _Rp, class ..._ArgTypes>

1744

template <class _Fp>

1745

typename enable_if

1746

1747

    function<_Rp(_ArgTypes...)>::template __callable<typename decay<_Fp>::type>::value &&

1748

    !is_same<typename remove_reference<_Fp>::type, function<_Rp(_ArgTypes...)>>::value,

1749

    function<_Rp(_ArgTypes...)>&

1750

>::type

1751

function<_Rp(_ArgTypes...)>::operator=(_Fp&& __f)

1752

1753

    function(_VSTD::forward<_Fp>(__f)).swap(*this);

1754

    return *this;

1755

1756

1757

template<class _Rp, class ..._ArgTypes>

1758

function<_Rp(_ArgTypes...)>::~function()

1759

1760

    if (__f_ == (__base*)&__buf_)

1761

        __f_->destroy();

1762

    else if (__f_)

1763

        __f_->destroy_deallocate();

1764

1765

1766

template<class _Rp, class ..._ArgTypes>

1767

void

1768

function<_Rp(_ArgTypes...)>::swap(function& __f) _NOEXCEPT

1769

1770

    if (__f_ == (__base*)&__buf_ && __f.__f_ == (__base*)&__f.__buf_)

1771

1772

        typename aligned_storage<sizeof(__buf_)>::type __tempbuf;

1773

        __base* __t = (__base*)&__tempbuf;

1774

        __f_->__clone(__t);

1775

        __f_->destroy();

1776

        __f_ = 0;

1777

        __f.__f_->__clone((__base*)&__buf_);

1778

        __f.__f_->destroy();

1779

        __f.__f_ = 0;

1780

        __f_ = (__base*)&__buf_;

1781

        __t->__clone((__base*)&__f.__buf_);

1782

        __t->destroy();

1783

        __f.__f_ = (__base*)&__f.__buf_;

1784

1785

    else if (__f_ == (__base*)&__buf_)

1786

1787

        __f_->__clone((__base*)&__f.__buf_);

1788

        __f_->destroy();

1789

        __f_ = __f.__f_;

1790

        __f.__f_ = (__base*)&__f.__buf_;

1791

1792

    else if (__f.__f_ == (__base*)&__f.__buf_)

1793

1794

        __f.__f_->__clone((__base*)&__buf_);

1795

        __f.__f_->destroy();

1796

        __f.__f_ = __f_;

1797

        __f_ = (__base*)&__buf_;

1798

1799

    else

1800

        _VSTD::swap(__f_, __f.__f_);

1801

1802

1803

template<class _Rp, class ..._ArgTypes>

1804

_Rp

1805

function<_Rp(_ArgTypes...)>::operator()(_ArgTypes... __arg) const

1806

1807

#ifndef _LIBCPP_NO_EXCEPTIONS

1808

    if (__f_ == 0)

1809

        throw bad_function_call();

1810

#endif  // _LIBCPP_NO_EXCEPTIONS

1811

    return (*__f_)(_VSTD::forward<_ArgTypes>(__arg)...);

1812

1813

1814

#ifndef _LIBCPP_NO_RTTI

1815

1816

template<class _Rp, class ..._ArgTypes>

1817

const std::type_info&

1818

function<_Rp(_ArgTypes...)>::target_type() const _NOEXCEPT

1819

1820

    if (__f_ == 0)

1821

        return typeid(void);

1822

    return __f_->target_type();

1823

1824

1825

template<class _Rp, class ..._ArgTypes>

1826

template <typename _Tp>

1827

_Tp*

1828

function<_Rp(_ArgTypes...)>::target() _NOEXCEPT

1829

1830

    if (__f_ == 0)

1831

        return (_Tp*)0;

1832

    return (_Tp*)__f_->target(typeid(_Tp));

1833

1834

1835

template<class _Rp, class ..._ArgTypes>

1836

template <typename _Tp>

1837

const _Tp*

1838

function<_Rp(_ArgTypes...)>::target() const _NOEXCEPT

1839

1840

    if (__f_ == 0)

1841

        return (const _Tp*)0;

1842

    return (const _Tp*)__f_->target(typeid(_Tp));

1843

1844

1845

#endif  // _LIBCPP_NO_RTTI

1846

1847

template <class _Rp, class... _ArgTypes>

1848

inline _LIBCPP_INLINE_VISIBILITY

1849

bool

1850

operator==(const function<_Rp(_ArgTypes...)>& __f, nullptr_t) _NOEXCEPT {return !__f;}

1851

1852

template <class _Rp, class... _ArgTypes>

1853

inline _LIBCPP_INLINE_VISIBILITY

1854

bool

1855

operator==(nullptr_t, const function<_Rp(_ArgTypes...)>& __f) _NOEXCEPT {return !__f;}

1856

1857

template <class _Rp, class... _ArgTypes>

1858

inline _LIBCPP_INLINE_VISIBILITY

1859

bool

1860

operator!=(const function<_Rp(_ArgTypes...)>& __f, nullptr_t) _NOEXCEPT {return (bool)__f;}

1861

1862

template <class _Rp, class... _ArgTypes>

1863

inline _LIBCPP_INLINE_VISIBILITY

1864

bool

1865

operator!=(nullptr_t, const function<_Rp(_ArgTypes...)>& __f) _NOEXCEPT {return (bool)__f;}

1866

1867

template <class _Rp, class... _ArgTypes>

1868

inline _LIBCPP_INLINE_VISIBILITY

1869

void

1870

swap(function<_Rp(_ArgTypes...)>& __x, function<_Rp(_ArgTypes...)>& __y) _NOEXCEPT

1871

{return __x.swap(__y);}

1872

1873

#else // _LIBCPP_HAS_NO_VARIADICS

1874

1875

#include <__functional_03>

1876

1877

#endif

1878

1879

////////////////////////////////////////////////////////////////////////////////

1880

//                                  BIND

1881

//==============================================================================

1882

1883

template<class _Tp> struct __is_bind_expression : public false_type {};

1884

template<class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_bind_expression

1885

    : public __is_bind_expression<typename remove_cv<_Tp>::type> {};

1886

1887

template<class _Tp> struct __is_placeholder : public integral_constant<int, 0> {};

1888

template<class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_placeholder

1889

    : public __is_placeholder<typename remove_cv<_Tp>::type> {};

1890

1891

namespace placeholders

1892

1893

1894

template <int _Np> struct __ph {};

1895

1896

_LIBCPP_FUNC_VIS extern __ph<1>   _1;

1897

_LIBCPP_FUNC_VIS extern __ph<2>   _2;

1898

_LIBCPP_FUNC_VIS extern __ph<3>   _3;

1899

_LIBCPP_FUNC_VIS extern __ph<4>   _4;

1900

_LIBCPP_FUNC_VIS extern __ph<5>   _5;

1901

_LIBCPP_FUNC_VIS extern __ph<6>   _6;

1902

_LIBCPP_FUNC_VIS extern __ph<7>   _7;

1903

_LIBCPP_FUNC_VIS extern __ph<8>   _8;

1904

_LIBCPP_FUNC_VIS extern __ph<9>   _9;

1905

_LIBCPP_FUNC_VIS extern __ph<10> _10;

1906

1907

}  // placeholders

1908

1909

template<int _Np>

1910

struct __is_placeholder<placeholders::__ph<_Np> >

1911

    : public integral_constant<int, _Np> {};

1912

1913

1914

#ifndef _LIBCPP_HAS_NO_VARIADICS

1915

1916

template <class _Tp, class _Uj>

1917

inline _LIBCPP_INLINE_VISIBILITY

1918

_Tp&

1919

__mu(reference_wrapper<_Tp> __t, _Uj&)

1920

1921

    return __t.get();

1922

1923

1924

template <class _Ti, class ..._Uj, size_t ..._Indx>

1925

inline _LIBCPP_INLINE_VISIBILITY

1926

typename __invoke_of<_Ti&, _Uj...>::type

1927

__mu_expand(_Ti& __ti, tuple<_Uj...>& __uj, __tuple_indices<_Indx...>)

1928

1929

    return __ti(_VSTD::forward<_Uj>(_VSTD::get<_Indx>(__uj))...);

1930

1931

1932

template <class _Ti, class ..._Uj>

1933

inline _LIBCPP_INLINE_VISIBILITY

1934

typename __lazy_enable_if

1935

1936

    is_bind_expression<_Ti>::value,

1937

    __invoke_of<_Ti&, _Uj...>

1938

>::type

1939

__mu(_Ti& __ti, tuple<_Uj...>& __uj)

1940

1941

    typedef typename __make_tuple_indices<sizeof...(_Uj)>::type __indices;

1942

    return  __mu_expand(__ti, __uj, __indices());

1943

1944

1945

template <bool IsPh, class _Ti, class _Uj>

1946

struct __mu_return2 {};

1947

1948

template <class _Ti, class _Uj>

1949

struct __mu_return2<true, _Ti, _Uj>

1950

1951

    typedef typename tuple_element<is_placeholder<_Ti>::value - 1, _Uj>::type type;

1952

};

1953

1954

template <class _Ti, class _Uj>

1955

inline _LIBCPP_INLINE_VISIBILITY

1956

typename enable_if

1957

1958

    0 < is_placeholder<_Ti>::value,

1959

    typename __mu_return2<0 < is_placeholder<_Ti>::value, _Ti, _Uj>::type

1960

>::type

1961

__mu(_Ti&, _Uj& __uj)

1962

1963

    const size_t _Indx = is_placeholder<_Ti>::value - 1;

1964

    return _VSTD::forward<typename tuple_element<_Indx, _Uj>::type>(_VSTD::get<_Indx>(__uj));

1965

1966

1967

template <class _Ti, class _Uj>

1968

inline _LIBCPP_INLINE_VISIBILITY

1969

typename enable_if

1970

1971

    !is_bind_expression<_Ti>::value &&

1972

    is_placeholder<_Ti>::value == 0 &&

1973

    !__is_reference_wrapper<_Ti>::value,

1974

    _Ti&

1975

>::type

1976

__mu(_Ti& __ti, _Uj&)

1977

1978

    return __ti;

1979

1980

1981

template <class _Ti, bool IsReferenceWrapper, bool IsBindEx, bool IsPh,

1982

          class _TupleUj>

1983

struct ____mu_return;

1984

1985

template <bool _Invokable, class _Ti, class ..._Uj>

1986

struct ____mu_return_invokable  // false

1987

1988

    typedef __nat type;

1989

};

1990

1991

template <class _Ti, class ..._Uj>

1992

struct ____mu_return_invokable<true, _Ti, _Uj...>

1993

1994

    typedef typename __invoke_of<_Ti&, _Uj...>::type type;

1995

};

1996

1997

template <class _Ti, class ..._Uj>

1998

struct ____mu_return<_Ti, false, true, false, tuple<_Uj...> >

1999

    : public ____mu_return_invokable<__invokable<_Ti&, _Uj...>::value, _Ti, _Uj...>

2000

2001

};

2002

2003

template <class _Ti, class _TupleUj>

2004

struct ____mu_return<_Ti, false, false, true, _TupleUj>

2005

2006

    typedef typename tuple_element<is_placeholder<_Ti>::value - 1,

2007

                                   _TupleUj>::type&& type;

2008

};

2009

2010

template <class _Ti, class _TupleUj>

2011

struct ____mu_return<_Ti, true, false, false, _TupleUj>

2012

2013

    typedef typename _Ti::type& type;

2014

};

2015

2016

template <class _Ti, class _TupleUj>

2017

struct ____mu_return<_Ti, false, false, false, _TupleUj>

2018

2019

    typedef _Ti& type;

2020

};

2021

2022

template <class _Ti, class _TupleUj>

2023

struct __mu_return

2024

    : public ____mu_return<_Ti,

2025

                           __is_reference_wrapper<_Ti>::value,

2026

                           is_bind_expression<_Ti>::value,

2027

                           0 < is_placeholder<_Ti>::value &&

2028

                           is_placeholder<_Ti>::value <= tuple_size<_TupleUj>::value,

2029

                           _TupleUj>

2030

2031

};

2032

2033

template <class _Fp, class _BoundArgs, class _TupleUj>

2034

struct __is_valid_bind_return

2035

2036

    static const bool value = false;

2037

};

2038

2039

template <class _Fp, class ..._BoundArgs, class _TupleUj>

2040

struct __is_valid_bind_return<_Fp, tuple<_BoundArgs...>, _TupleUj>

2041

2042

    static const bool value = __invokable<_Fp,

2043

                    typename __mu_return<_BoundArgs, _TupleUj>::type...>::value;

2044

};

2045

2046

template <class _Fp, class ..._BoundArgs, class _TupleUj>

2047

struct __is_valid_bind_return<_Fp, const tuple<_BoundArgs...>, _TupleUj>

2048

2049

    static const bool value = __invokable<_Fp,

2050

                    typename __mu_return<const _BoundArgs, _TupleUj>::type...>::value;

2051

};

2052

2053

template <class _Fp, class _BoundArgs, class _TupleUj,

2054

          bool = __is_valid_bind_return<_Fp, _BoundArgs, _TupleUj>::value>

2055

struct __bind_return;

2056

2057

template <class _Fp, class ..._BoundArgs, class _TupleUj>

2058

struct __bind_return<_Fp, tuple<_BoundArgs...>, _TupleUj, true>

2059

2060

    typedef typename __invoke_of

2061

2062

        _Fp&,

2063

        typename __mu_return

2064

2065

            _BoundArgs,

2066

            _TupleUj

2067

        >::type...

2068

    >::type type;

2069

};

2070

2071

template <class _Fp, class ..._BoundArgs, class _TupleUj>

2072

struct __bind_return<_Fp, const tuple<_BoundArgs...>, _TupleUj, true>

2073

2074

    typedef typename __invoke_of

2075

2076

        _Fp&,

2077

        typename __mu_return

2078

2079

            const _BoundArgs,

2080

            _TupleUj

2081

        >::type...

2082

    >::type type;

2083

};

2084

2085

template <class _Fp, class _BoundArgs, size_t ..._Indx, class _Args>

2086

inline _LIBCPP_INLINE_VISIBILITY

2087

typename __bind_return<_Fp, _BoundArgs, _Args>::type

2088

__apply_functor(_Fp& __f, _BoundArgs& __bound_args, __tuple_indices<_Indx...>,

2089

                _Args&& __args)

2090

2091

    return __invoke(__f, __mu(_VSTD::get<_Indx>(__bound_args), __args)...);

2092

2093

2094

template<class _Fp, class ..._BoundArgs>

2095

class __bind

2096

    : public __weak_result_type<typename decay<_Fp>::type>

2097

2098

protected:

2099

    typedef typename decay<_Fp>::type _Fd;

2100

    typedef tuple<typename decay<_BoundArgs>::type...> _Td;

2101

private:

2102

    _Fd __f_;

2103

    _Td __bound_args_;

2104

2105

    typedef typename __make_tuple_indices<sizeof...(_BoundArgs)>::type __indices;

2106

public:

2107

#ifdef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS

2108

2109

    _LIBCPP_INLINE_VISIBILITY

2110

    __bind(const __bind& __b)

2111

        : __f_(__b.__f_),

2112

          __bound_args_(__b.__bound_args_) {}

2113

2114

    _LIBCPP_INLINE_VISIBILITY

2115

    __bind& operator=(const __bind& __b)

2116

2117

        __f_ = __b.__f_;

2118

        __bound_args_ = __b.__bound_args_;

2119

        return *this;

2120

2121

2122

    _LIBCPP_INLINE_VISIBILITY

2123

    __bind(__bind&& __b)

2124

        : __f_(_VSTD::move(__b.__f_)),

2125

          __bound_args_(_VSTD::move(__b.__bound_args_)) {}

2126

2127

    _LIBCPP_INLINE_VISIBILITY

2128

    __bind& operator=(__bind&& __b)

2129

2130

        __f_ = _VSTD::move(__b.__f_);

2131

        __bound_args_ = _VSTD::move(__b.__bound_args_);

2132

        return *this;

2133

2134

2135

#endif  // _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS

2136

2137

    template <class _Gp, class ..._BA,

2138

              class = typename enable_if

2139

2140

                                  is_constructible<_Fd, _Gp>::value &&

2141

                                  !is_same<typename remove_reference<_Gp>::type,

2142

                                           __bind>::value

2143

                               >::type>

2144

      _LIBCPP_INLINE_VISIBILITY

2145

      explicit __bind(_Gp&& __f, _BA&& ...__bound_args)

2146

        : __f_(_VSTD::forward<_Gp>(__f)),

2147

          __bound_args_(_VSTD::forward<_BA>(__bound_args)...) {}

2148

2149

    template <class ..._Args>

2150

        _LIBCPP_INLINE_VISIBILITY

2151

        typename __bind_return<_Fd, _Td, tuple<_Args&&...> >::type

2152

        operator()(_Args&& ...__args)

2153

2154

            return __apply_functor(__f_, __bound_args_, __indices(),

2155

                                  tuple<_Args&&...>(_VSTD::forward<_Args>(__args)...));

2156

2157

2158

    template <class ..._Args>

2159

        _LIBCPP_INLINE_VISIBILITY

2160

        typename __bind_return<const _Fd, const _Td, tuple<_Args&&...> >::type

2161

        operator()(_Args&& ...__args) const

2162

2163

            return __apply_functor(__f_, __bound_args_, __indices(),

2164

                                   tuple<_Args&&...>(_VSTD::forward<_Args>(__args)...));

2165

2166

};

2167

2168

template<class _Fp, class ..._BoundArgs>

2169

struct __is_bind_expression<__bind<_Fp, _BoundArgs...> > : public true_type {};

2170

2171

template<class _Rp, class _Fp, class ..._BoundArgs>

2172

class __bind_r

2173

    : public __bind<_Fp, _BoundArgs...>

2174

2175

    typedef __bind<_Fp, _BoundArgs...> base;

2176

    typedef typename base::_Fd _Fd;

2177

    typedef typename base::_Td _Td;

2178

public:

2179

    typedef _Rp result_type;

2180

2181

#ifdef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS

2182

2183

    _LIBCPP_INLINE_VISIBILITY

2184

    __bind_r(const __bind_r& __b)

2185

        : base(_VSTD::forward<const base&>(__b)) {}

2186

2187

    _LIBCPP_INLINE_VISIBILITY

2188

    __bind_r& operator=(const __bind_r& __b)

2189

2190

        base::operator=(_VSTD::forward<const base&>(__b));

2191

        return *this;

2192

2193

2194

    _LIBCPP_INLINE_VISIBILITY

2195

    __bind_r(__bind_r&& __b)

2196

        : base(_VSTD::forward<base>(__b)) {}

2197

2198

    _LIBCPP_INLINE_VISIBILITY

2199

    __bind_r& operator=(__bind_r&& __b)

2200

2201

        base::operator=(_VSTD::forward<base>(__b));

2202

        return *this;

2203

2204

2205

#endif  // _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS

2206

2207

    template <class _Gp, class ..._BA,

2208

              class = typename enable_if

2209

2210

                                  is_constructible<_Fd, _Gp>::value &&

2211

                                  !is_same<typename remove_reference<_Gp>::type,

2212

                                           __bind_r>::value

2213

                               >::type>

2214

      _LIBCPP_INLINE_VISIBILITY

2215

      explicit __bind_r(_Gp&& __f, _BA&& ...__bound_args)

2216

        : base(_VSTD::forward<_Gp>(__f),

2217

               _VSTD::forward<_BA>(__bound_args)...) {}

2218

2219

    template <class ..._Args>

2220

        _LIBCPP_INLINE_VISIBILITY

2221

        typename enable_if

2222

2223

            is_convertible<typename __bind_return<_Fd, _Td, tuple<_Args&&...> >::type,

2224

                           result_type>::value || is_void<_Rp>::value,

2225

            result_type

2226

        >::type

2227

        operator()(_Args&& ...__args)

2228

2229

            typedef __invoke_void_return_wrapper<_Rp> _Invoker;

2230

            return _Invoker::__call(static_cast<base&>(*this), _VSTD::forward<_Args>(__args)...);

2231

2232

2233

    template <class ..._Args>

2234

        _LIBCPP_INLINE_VISIBILITY

2235

        typename enable_if

2236

2237

            is_convertible<typename __bind_return<const _Fd, const _Td, tuple<_Args&&...> >::type,

2238

                           result_type>::value || is_void<_Rp>::value,

2239

            result_type

2240

        >::type

2241

        operator()(_Args&& ...__args) const

2242

2243

            typedef __invoke_void_return_wrapper<_Rp> _Invoker;

2244

            return _Invoker::__call(static_cast<base const&>(*this), _VSTD::forward<_Args>(__args)...);

2245

2246

};

2247

2248

template<class _Rp, class _Fp, class ..._BoundArgs>

2249

struct __is_bind_expression<__bind_r<_Rp, _Fp, _BoundArgs...> > : public true_type {};

2250

2251

template<class _Fp, class ..._BoundArgs>

2252

inline _LIBCPP_INLINE_VISIBILITY

2253

__bind<_Fp, _BoundArgs...>

2254

bind(_Fp&& __f, _BoundArgs&&... __bound_args)

2255

2256

    typedef __bind<_Fp, _BoundArgs...> type;

2257

    return type(_VSTD::forward<_Fp>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...);

2258

2259

2260

template<class _Rp, class _Fp, class ..._BoundArgs>

2261

inline _LIBCPP_INLINE_VISIBILITY

2262

__bind_r<_Rp, _Fp, _BoundArgs...>

2263

bind(_Fp&& __f, _BoundArgs&&... __bound_args)

2264

2265

    typedef __bind_r<_Rp, _Fp, _BoundArgs...> type;

2266

    return type(_VSTD::forward<_Fp>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...);

2267

2268

2269

#endif  // _LIBCPP_HAS_NO_VARIADICS

2270

2271

template <>

2272

struct _LIBCPP_TYPE_VIS_ONLY hash<bool>

2273

    : public unary_function<bool, size_t>

2274

2275

    _LIBCPP_INLINE_VISIBILITY

2276

    size_t operator()(bool __v) const _NOEXCEPT {return static_cast<size_t>(__v);}

2277

};

2278

2279

template <>

2280

struct _LIBCPP_TYPE_VIS_ONLY hash<char>

2281

    : public unary_function<char, size_t>

2282

2283

    _LIBCPP_INLINE_VISIBILITY

2284

    size_t operator()(char __v) const _NOEXCEPT {return static_cast<size_t>(__v);}

2285

};

2286

2287

template <>

2288

struct _LIBCPP_TYPE_VIS_ONLY hash<signed char>

2289

    : public unary_function<signed char, size_t>

2290

2291

    _LIBCPP_INLINE_VISIBILITY

2292

    size_t operator()(signed char __v) const _NOEXCEPT {return static_cast<size_t>(__v);}

2293

};

2294

2295

template <>

2296

struct _LIBCPP_TYPE_VIS_ONLY hash<unsigned char>

2297

    : public unary_function<unsigned char, size_t>

2298

2299

    _LIBCPP_INLINE_VISIBILITY

2300

    size_t operator()(unsigned char __v) const _NOEXCEPT {return static_cast<size_t>(__v);}

2301

};

2302

2303

#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS

2304

2305

template <>

2306

struct _LIBCPP_TYPE_VIS_ONLY hash<char16_t>

2307

    : public unary_function<char16_t, size_t>

2308

2309

    _LIBCPP_INLINE_VISIBILITY

2310

    size_t operator()(char16_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);}

2311

};

2312

2313

template <>

2314

struct _LIBCPP_TYPE_VIS_ONLY hash<char32_t>

2315

    : public unary_function<char32_t, size_t>

2316

2317

    _LIBCPP_INLINE_VISIBILITY

2318

    size_t operator()(char32_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);}

2319

};

2320

2321

#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS

2322

2323

template <>

2324

struct _LIBCPP_TYPE_VIS_ONLY hash<wchar_t>

2325

    : public unary_function<wchar_t, size_t>

2326

2327

    _LIBCPP_INLINE_VISIBILITY

2328

    size_t operator()(wchar_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);}

2329

};

2330

2331

template <>

2332

struct _LIBCPP_TYPE_VIS_ONLY hash<short>

2333

    : public unary_function<short, size_t>

2334

2335

    _LIBCPP_INLINE_VISIBILITY

2336

    size_t operator()(short __v) const _NOEXCEPT {return static_cast<size_t>(__v);}

2337

};

2338

2339

template <>

2340

struct _LIBCPP_TYPE_VIS_ONLY hash<unsigned short>

2341

    : public unary_function<unsigned short, size_t>

2342

2343

    _LIBCPP_INLINE_VISIBILITY

2344

    size_t operator()(unsigned short __v) const _NOEXCEPT {return static_cast<size_t>(__v);}

2345

};

2346

2347

template <>

2348

struct _LIBCPP_TYPE_VIS_ONLY hash<int>

2349

    : public unary_function<int, size_t>

2350

2351

    _LIBCPP_INLINE_VISIBILITY

2352

    size_t operator()(int __v) const _NOEXCEPT {return static_cast<size_t>(__v);}

2353

};

2354

2355

template <>

2356

struct _LIBCPP_TYPE_VIS_ONLY hash<unsigned int>

2357

    : public unary_function<unsigned int, size_t>

2358

2359

    _LIBCPP_INLINE_VISIBILITY

2360

    size_t operator()(unsigned int __v) const _NOEXCEPT {return static_cast<size_t>(__v);}

2361

};

2362

2363

template <>

2364

struct _LIBCPP_TYPE_VIS_ONLY hash<long>

2365

    : public unary_function<long, size_t>

2366

2367

    _LIBCPP_INLINE_VISIBILITY

2368

    size_t operator()(long __v) const _NOEXCEPT {return static_cast<size_t>(__v);}

2369

};

2370

2371

template <>

2372

struct _LIBCPP_TYPE_VIS_ONLY hash<unsigned long>

2373

    : public unary_function<unsigned long, size_t>

2374

2375

    _LIBCPP_INLINE_VISIBILITY

2376

    size_t operator()(unsigned long __v) const _NOEXCEPT {return static_cast<size_t>(__v);}

2377

};

2378

2379

template <>

2380

struct _LIBCPP_TYPE_VIS_ONLY hash<long long>

2381

    : public __scalar_hash<long long>

2382

2383

};

2384

2385

template <>

2386

struct _LIBCPP_TYPE_VIS_ONLY hash<unsigned long long>

2387

    : public __scalar_hash<unsigned long long>

2388

2389

};

2390

2391

template <>

2392

struct _LIBCPP_TYPE_VIS_ONLY hash<float>

2393

    : public __scalar_hash<float>

2394

2395

    _LIBCPP_INLINE_VISIBILITY

2396

    size_t operator()(float __v) const _NOEXCEPT

2397

2398

        // -0.0 and 0.0 should return same hash

2399

       if (__v == 0)

2400

           return 0;

2401

        return __scalar_hash<float>::operator()(__v);

2402

2403

};

2404

2405

template <>

2406

struct _LIBCPP_TYPE_VIS_ONLY hash<double>

2407

    : public __scalar_hash<double>

2408

2409

    _LIBCPP_INLINE_VISIBILITY

2410

    size_t operator()(double __v) const _NOEXCEPT

2411

2412

        // -0.0 and 0.0 should return same hash

2413

       if (__v == 0)

2414

           return 0;

2415

        return __scalar_hash<double>::operator()(__v);

2416

2417

};

2418

2419

template <>

2420

struct _LIBCPP_TYPE_VIS_ONLY hash<long double>

2421

    : public __scalar_hash<long double>

2422

2423

    _LIBCPP_INLINE_VISIBILITY

2424

    size_t operator()(long double __v) const _NOEXCEPT

2425

2426

        // -0.0 and 0.0 should return same hash

2427

        if (__v == 0)

2428

            return 0;

2429

#if defined(__i386__)

2430

        // Zero out padding bits

2431

        union

2432

2433

            long double __t;

2434

            struct

2435

2436

                size_t __a;

2437

                size_t __b;

2438

                size_t __c;

2439

                size_t __d;

2440

            } __s;

2441

        } __u;

2442

        __u.__s.__a = 0;

2443

        __u.__s.__b = 0;

2444

        __u.__s.__c = 0;

2445

        __u.__s.__d = 0;

2446

        __u.__t = __v;

2447

        return __u.__s.__a ^ __u.__s.__b ^ __u.__s.__c ^ __u.__s.__d;

2448

#elif defined(__x86_64__)

2449

        // Zero out padding bits

2450

        union

2451

2452

            long double __t;

2453

            struct

2454

2455

                size_t __a;

2456

                size_t __b;

2457

            } __s;

2458

        } __u;

2459

        __u.__s.__a = 0;

2460

        __u.__s.__b = 0;

2461

        __u.__t = __v;

2462

        return __u.__s.__a ^ __u.__s.__b;

2463

#else

2464

        return __scalar_hash<long double>::operator()(__v);

2465

#endif

2466

2467

};

2468

2469

#if _LIBCPP_STD_VER > 11

2470

template <class _Tp>

2471

struct _LIBCPP_TYPE_VIS_ONLY hash

2472

    : public unary_function<_Tp, size_t>

2473

2474

    static_assert(is_enum<_Tp>::value, "This hash only works for enumeration types");

2475

2476

    _LIBCPP_INLINE_VISIBILITY

2477

    size_t operator()(_Tp __v) const _NOEXCEPT

2478

2479

        typedef typename underlying_type<_Tp>::type type;

2480

        return hash<type>{}(static_cast<type>(__v));

2481

2482

};

2483

#endif

2484

2485

2486

#if _LIBCPP_STD_VER > 14

2487

template <class _Fn, class ..._Args>

2488

result_of_t<_Fn&&(_Args&&...)>

2489

invoke(_Fn&& __f, _Args&&... __args) {

2490

    return __invoke(_VSTD::forward<_Fn>(__f), _VSTD::forward<_Args>(__args)...);

2491

2492

#endif

2493

2494

// struct hash<T*> in <memory>

2495

2496

_LIBCPP_END_NAMESPACE_STD

2497

2498

#endif  // _LIBCPP_FUNCTIONAL

Project

General

Profile

LCOM1920-T02G10

root / lab4 / .minix-src / include / c++ / functional @ 14