python/include/boost/python/class.hpp at python313 · boostorg/python · GitHub

History

610 lines (517 loc) · 17.5 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

529

530

531

532

533

534

535

536

537

538

539

540

541

542

543

544

545

546

547

548

549

550

551

552

553

554

555

556

557

558

559

560

561

562

563

564

565

566

567

568

569

570

571

572

573

574

575

576

577

578

579

580

581

582

583

584

585

586

587

588

589

590

591

592

593

594

595

596

597

598

599

600

601

602

603

604

605

606

607

608

609

610

// Copyright David Abrahams 2002.

// Distributed under the Boost Software License, Version 1.0. (See

// accompanying file LICENSE_1_0.txt or copy at

// http://www.boost.org/LICENSE_1_0.txt)

#ifndef CLASS_DWA200216_HPP

# define CLASS_DWA200216_HPP

# include <boost/python/detail/prefix.hpp>

# include <boost/noncopyable.hpp>

# include <boost/python/class_fwd.hpp>

# include <boost/python/object/class.hpp>

# include <boost/python/object.hpp>

# include <boost/python/type_id.hpp>

# include <boost/python/data_members.hpp>

# include <boost/python/make_function.hpp>

# include <boost/python/signature.hpp>

# include <boost/python/init.hpp>

# include <boost/python/args_fwd.hpp>

# include <boost/python/object/class_metadata.hpp>

# include <boost/python/object/pickle_support.hpp>

# include <boost/python/object/add_to_namespace.hpp>

# include <boost/python/detail/overloads_fwd.hpp>

# include <boost/python/detail/operator_id.hpp>

# include <boost/python/detail/def_helper.hpp>

# include <boost/python/detail/force_instantiate.hpp>

# include <boost/python/detail/type_traits.hpp>

# include <boost/python/detail/unwrap_type_id.hpp>

# include <boost/python/detail/unwrap_wrapper.hpp>

# include <boost/mpl/size.hpp>

# include <boost/mpl/for_each.hpp>

# include <boost/mpl/bool.hpp>

# include <boost/mpl/not.hpp>

# include <boost/detail/workaround.hpp>

# if BOOST_WORKAROUND(__MWERKS__, <= 0x3004) \

/* pro9 reintroduced the bug */ \

|| (BOOST_WORKAROUND(__MWERKS__, > 0x3100) \

&& BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3201)))

# define BOOST_PYTHON_NO_MEMBER_POINTER_ORDERING 1

# endif

# ifdef BOOST_PYTHON_NO_MEMBER_POINTER_ORDERING

# include <boost/mpl/and.hpp>

# endif

namespace boost { namespace python {

template <class DerivedVisitor> class def_visitor;

enum no_init_t { no_init };

namespace detail

{

// This function object is used with mpl::for_each to write the id

// of the type a pointer to which is passed as its 2nd compile-time

// argument. into the iterator pointed to by its runtime argument

struct write_type_id

{

write_type_id(type_info**p) : p(p) {}

// Here's the runtime behavior

template <class T>

void operator()(T*) const

{

*(*p)++ = type_id<T>();

}

type_info** p;

};

template <class T>

struct is_data_member_pointer

: mpl::and_<

detail::is_member_pointer<T>

, mpl::not_<detail::is_member_function_pointer<T> >

{};

# ifdef BOOST_PYTHON_NO_MEMBER_POINTER_ORDERING

# define BOOST_PYTHON_DATA_MEMBER_HELPER(D) , detail::is_data_member_pointer<D>()

# define BOOST_PYTHON_YES_DATA_MEMBER , mpl::true_

# define BOOST_PYTHON_NO_DATA_MEMBER , mpl::false_

# elif defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)

# define BOOST_PYTHON_DATA_MEMBER_HELPER(D) , 0

# define BOOST_PYTHON_YES_DATA_MEMBER , int

# define BOOST_PYTHON_NO_DATA_MEMBER , ...

# else

# define BOOST_PYTHON_DATA_MEMBER_HELPER(D)

# define BOOST_PYTHON_YES_DATA_MEMBER

# define BOOST_PYTHON_NO_DATA_MEMBER

# endif

namespace error

{

// A meta-assertion mechanism which prints nice error messages and

// backtraces on lots of compilers. Usage:

// assertion<C>::failed

// where C is an MPL metafunction class

template <class C> struct assertion_failed { };

template <class C> struct assertion_ok { typedef C failed; };

template <class C>

struct assertion

: mpl::if_<C, assertion_ok<C>, assertion_failed<C> >::type

{};

// Checks for validity of arguments used to define virtual

// functions with default implementations.

template <class Default>

void not_a_derived_class_member(Default) {}

template <class T, class Fn>

struct virtual_function_default

{

template <class Default>

static void

must_be_derived_class_member(Default const&)

{

// https://svn.boost.org/trac/boost/ticket/5803

//typedef typename assertion<mpl::not_<detail::is_same<Default,Fn> > >::failed test0;

# if !BOOST_WORKAROUND(__MWERKS__, <= 0x2407)

typedef typename assertion<detail::is_polymorphic<T> >::failed test1 BOOST_ATTRIBUTE_UNUSED;

# endif

typedef typename assertion<detail::is_member_function_pointer<Fn> >::failed test2 BOOST_ATTRIBUTE_UNUSED;

not_a_derived_class_member<Default>(Fn());

}

};

}

// This is the primary mechanism through which users will expose

// C++ classes to Python.

template <

class W // class being wrapped

, class X1 // = detail::not_specified

, class X2 // = detail::not_specified

, class X3 // = detail::not_specified

class class_ : public objects::class_base

{

public: // types

typedef objects::class_base base;

typedef class_<W,X1,X2,X3> self;

typedef typename objects::class_metadata<W,X1,X2,X3> metadata;

typedef W wrapped_type;

private: // types

// A helper class which will contain an array of id objects to be

// passed to the base class constructor

struct id_vector

{

typedef typename metadata::bases bases;

id_vector()

{

// Stick the derived class id into the first element of the array

ids[0] = detail::unwrap_type_id((W*)0, (W*)0);

// Write the rest of the elements into succeeding positions.

type_info* p = ids + 1;

mpl::for_each(detail::write_type_id(&p), (bases*)0, (add_pointer<mpl::_>*)0);

}

BOOST_STATIC_CONSTANT(

std::size_t, size = mpl::size<bases>::value + 1);

type_info ids[size];

};

friend struct id_vector;

public: // constructors

// Construct with the class name, with or without docstring, and default __init__() function

class_(char const* name, char const* doc = 0);

// Construct with class name, no docstring, and an uncallable __init__ function

class_(char const* name, no_init_t);

// Construct with class name, docstring, and an uncallable __init__ function

class_(char const* name, char const* doc, no_init_t);

// Construct with class name and init<> function

template <class DerivedT>

inline class_(char const* name, init_base<DerivedT> const& i)

: base(name, id_vector::size, id_vector().ids)

{

this->initialize(i);

}

// Construct with class name, docstring and init<> function

template <class DerivedT>

inline class_(char const* name, char const* doc, init_base<DerivedT> const& i)

: base(name, id_vector::size, id_vector().ids, doc)

{

this->initialize(i);

}

public: // member functions

// Generic visitation

template <class Derived>

self& def(def_visitor<Derived> const& visitor)

{

visitor.visit(*this);

return *this;

}

// Wrap a member function or a non-member function which can take

// a T, T cv&, or T cv* as its first parameter, a callable

// python object, or a generic visitor.

template <class F>

self& def(char const* name, F f)

{

this->def_impl(

detail::unwrap_wrapper((W*)0)

, name, f, detail::def_helper<char const*>(0), &f);

return *this;

}

template <class A1, class A2>

self& def(char const* name, A1 a1, A2 const& a2)

{

this->def_maybe_overloads(name, a1, a2, &a2);

return *this;

}

template <class Fn, class A1, class A2>

self& def(char const* name, Fn fn, A1 const& a1, A2 const& a2)

{

// The arguments are definitely:

// def(name, function, policy, doc_string)

// def(name, function, doc_string, policy)

this->def_impl(

detail::unwrap_wrapper((W*)0)

, name, fn

, detail::def_helper<A1,A2>(a1,a2)

, &fn);

return *this;

}

template <class Fn, class A1, class A2, class A3>

self& def(char const* name, Fn fn, A1 const& a1, A2 const& a2, A3 const& a3)

{

this->def_impl(

detail::unwrap_wrapper((W*)0)

, name, fn

, detail::def_helper<A1,A2,A3>(a1,a2,a3)

, &fn);

return *this;

}

// Data member access

template <class D>

self& def_readonly(char const* name, D const& d, char const* doc=0)

{

return this->def_readonly_impl(name, d, doc BOOST_PYTHON_DATA_MEMBER_HELPER(D));

}

template <class D>

self& def_readwrite(char const* name, D const& d, char const* doc=0)

{

return this->def_readwrite_impl(name, d, doc BOOST_PYTHON_DATA_MEMBER_HELPER(D));

}

template <class D>

self& def_readonly(char const* name, D& d, char const* doc=0)

{

return this->def_readonly_impl(name, d, doc BOOST_PYTHON_DATA_MEMBER_HELPER(D));

}

template <class D>

self& def_readwrite(char const* name, D& d, char const* doc=0)

{

return this->def_readwrite_impl(name, d, doc BOOST_PYTHON_DATA_MEMBER_HELPER(D));

}

// Property creation

template <class Get>

self& add_property(char const* name, Get fget, char const* docstr = 0)

{

base::add_property(name, this->make_getter(fget), docstr);

return *this;

}

template <class Get, class Set>

self& add_property(char const* name, Get fget, Set fset, char const* docstr = 0)

{

base::add_property(

name, this->make_getter(fget), this->make_setter(fset), docstr);

return *this;

}

template <class Get>

self& add_static_property(char const* name, Get fget)

{

base::add_static_property(name, object(fget));

return *this;

}

template <class Get, class Set>

self& add_static_property(char const* name, Get fget, Set fset)

{

base::add_static_property(name, object(fget), object(fset));

return *this;

}

template <class U>

self& setattr(char const* name, U const& x)

{

this->base::setattr(name, object(x));

return *this;

}

// Pickle support

template <typename PickleSuiteType>

self& def_pickle(PickleSuiteType const& x)

{

error_messages::must_be_derived_from_pickle_suite(x);

detail::pickle_suite_finalize<PickleSuiteType>::register_(

*this,

&PickleSuiteType::getinitargs,

&PickleSuiteType::getstate,

&PickleSuiteType::setstate,

PickleSuiteType::getstate_manages_dict());

return *this;

}

self& enable_pickling()

{

this->base::enable_pickling_(false);

return *this;

}

self& staticmethod(char const* name)

{

this->make_method_static(name);

return *this;

}

private: // helper functions

// Builds a method for this class around the given [member]

// function pointer or object, appropriately adjusting the type of

// the first signature argument so that if f is a member of a

// (possibly not wrapped) base class of T, an lvalue argument of

// type T will be required.

// @group PropertyHelpers {

template <class F>

object make_getter(F f)

{

typedef typename api::is_object_operators<F>::type is_obj_or_proxy;

return objects::add_doc(

this->make_fn_impl(

detail::unwrap_wrapper((W*)0)

, f, is_obj_or_proxy(), (char*)0, detail::is_data_member_pointer<F>()

), NULL);

}

template <class F>

object make_setter(F f)

{

typedef typename api::is_object_operators<F>::type is_obj_or_proxy;

return objects::add_doc(

this->make_fn_impl(

detail::unwrap_wrapper((W*)0)

, f, is_obj_or_proxy(), (int*)0, detail::is_data_member_pointer<F>()

), NULL);

}

template <class T, class F>

object make_fn_impl(T*, F const& f, mpl::false_, void*, mpl::false_)

{

return python::make_function(f, default_call_policies(), detail::get_signature(f, (T*)0));

}

template <class T, class D, class B>

object make_fn_impl(T*, D B::*pm_, mpl::false_, char*, mpl::true_)

{

D T::*pm = pm_;

return python::make_getter(pm);

}

template <class T, class D, class B>

object make_fn_impl(T*, D B::*pm_, mpl::false_, int*, mpl::true_)

{

D T::*pm = pm_;

return python::make_setter(pm);

}

template <class T, class F>

object make_fn_impl(T*, F const& x, mpl::true_, void*, mpl::false_)

{

return x;

}

// }

template <class D, class B>

self& def_readonly_impl(

char const* name, D B::*pm_, char const* doc BOOST_PYTHON_YES_DATA_MEMBER)

{

return this->add_property(name, pm_, doc);

}

template <class D, class B>

self& def_readwrite_impl(

char const* name, D B::*pm_, char const* doc BOOST_PYTHON_YES_DATA_MEMBER)

{

return this->add_property(name, pm_, pm_, doc);

}

template <class D>

self& def_readonly_impl(

char const* name, D& d, char const* BOOST_PYTHON_NO_DATA_MEMBER)

{

return this->add_static_property(name, python::make_getter(d));

}

template <class D>

self& def_readwrite_impl(

char const* name, D& d, char const* BOOST_PYTHON_NO_DATA_MEMBER)

{

return this->add_static_property(name, python::make_getter(d), python::make_setter(d));

}

template <class DefVisitor>

inline void initialize(DefVisitor const& i)

{

metadata::register_(); // set up runtime metadata/conversions

typedef typename metadata::holder holder;

this->set_instance_size( objects::additional_instance_size<holder>::value );

this->def(i);

}

inline void initialize(no_init_t)

{

metadata::register_(); // set up runtime metadata/conversions

this->def_no_init();

}

// These two overloads discriminate between def() as applied to a

// generic visitor and everything else.

// @group def_impl {

template <class T, class Helper, class LeafVisitor, class Visitor>

inline void def_impl(

, char const* name

, LeafVisitor

, Helper const& helper

, def_visitor<Visitor> const* v

)

{

v->visit(*this, name, helper);

}

template <class T, class Fn, class Helper>

inline void def_impl(

, char const* name

, Fn fn

, Helper const& helper

, ...

)

{

objects::add_to_namespace(

*this

, name

, make_function(

, helper.policies()

, helper.keywords()

, detail::get_signature(fn, (T*)0)

)

, helper.doc()

);

this->def_default(name, fn, helper, mpl::bool_<Helper::has_default_implementation>());

}

// }

// These two overloads handle the definition of default

// implementation overloads for virtual functions. The second one

// handles the case where no default implementation was specified.

// @group def_default {

template <class Fn, class Helper>

inline void def_default(

char const* name

, Fn

, Helper const& helper

, mpl::bool_<true>)

{

detail::error::virtual_function_default<W,Fn>::must_be_derived_class_member(

helper.default_implementation());

objects::add_to_namespace(

*this, name,

make_function(

helper.default_implementation(), helper.policies(), helper.keywords())

);

}

template <class Fn, class Helper>

inline void def_default(char const*, Fn, Helper const&, mpl::bool_<false>)

{ }

// }

// These two overloads discriminate between def() as applied to

// regular functions and def() as applied to the result of

// BOOST_PYTHON_FUNCTION_OVERLOADS(). The final argument is used to

// discriminate.

// @group def_maybe_overloads {

template <class OverloadsT, class SigT>

void def_maybe_overloads(

char const* name

, SigT sig

, OverloadsT const& overloads

, detail::overloads_base const*)

{

// convert sig to a type_list (see detail::get_signature in signature.hpp)

// before calling detail::define_with_defaults.

detail::define_with_defaults(

name, overloads, *this, detail::get_signature(sig));

}

template <class Fn, class A1>

void def_maybe_overloads(

char const* name

, Fn fn

, A1 const& a1

, ...)

{

this->def_impl(

detail::unwrap_wrapper((W*)0)

, name

, fn

, detail::def_helper<A1>(a1)

, &fn

);

}

// }

};

// implementations

template <class W, class X1, class X2, class X3>

inline class_<W,X1,X2,X3>::class_(char const* name, char const* doc)

: base(name, id_vector::size, id_vector().ids, doc)

{

this->initialize(init<>());

// select_holder::assert_default_constructible();

}

template <class W, class X1, class X2, class X3>

inline class_<W,X1,X2,X3>::class_(char const* name, no_init_t)

: base(name, id_vector::size, id_vector().ids)

{

this->initialize(no_init);

}

template <class W, class X1, class X2, class X3>

inline class_<W,X1,X2,X3>::class_(char const* name, char const* doc, no_init_t)

: base(name, id_vector::size, id_vector().ids, doc)

{

this->initialize(no_init);

}

}} // namespace boost::python

# undef BOOST_PYTHON_DATA_MEMBER_HELPER

# undef BOOST_PYTHON_YES_DATA_MEMBER

# undef BOOST_PYTHON_NO_DATA_MEMBER

# undef BOOST_PYTHON_NO_MEMBER_POINTER_ORDERING

#endif // CLASS_DWA200216_HPP

python/include/boost/python/class.hpp at python313 · boostorg/python · GitHub

Uh oh!

Expand file tree

Breadcrumbs

class.hpp

Latest commit

History

Breadcrumbs

class.hpp

File metadata and controls