~ubuntu-branches/ubuntu/precise/python-apt/precise-proposed : revision 1

1

// -*- mode: cpp; mode: fold -*-

2

// Description /*{{{*/

3

// $Id: cache.cc,v 1.3 2002/02/26 01:36:15 mdz Exp $

4

/* ######################################################################

5

6

Cache - Wrapper for the cache related functions

7

8

##################################################################### */

9

/*}}}*/

10

// Include Files /*{{{*/

11

#include "generic.h"

12

#include "apt_pkgmodule.h"

13

14

#include <apt-pkg/pkgcache.h>

15

#include <apt-pkg/cachefile.h>

16

#include <apt-pkg/sptr.h>

17

18

#include <Python.h>

19

/*}}}*/

20

21

struct PkgListStruct

22

{

23

pkgCache::PkgIterator Iter;

24

unsigned long LastIndex;

25

26

PkgListStruct(pkgCache::PkgIterator const &I) : Iter(I), LastIndex(0) {}

27

PkgListStruct() {abort();}; // G++ Bug..

28

};

29

30

struct RDepListStruct

31

{

32

pkgCache::DepIterator Iter;

33

pkgCache::DepIterator Start;

34

unsigned long LastIndex;

35

unsigned long Len;

36

37

RDepListStruct(pkgCache::DepIterator const &I) : Iter(I), Start(I),

38

LastIndex(0)

39

{

40

Len = 0;

41

pkgCache::DepIterator D = I;

42

for (; D.end() == false; D++)

43

Len++;

44

}

45

RDepListStruct() {abort();}; // G++ Bug..

46

};

47

48

static PyObject *CreateProvides(PyObject *Owner,pkgCache::PrvIterator I)

49

{

50

PyObject *List = PyList_New(0);

51

for (; I.end() == false; I++)

52

{

53

PyObject *Obj;

54

PyObject *Ver;

55

Ver = CppOwnedPyObject_NEW<pkgCache::VerIterator>(Owner,&VersionType,

56

I.OwnerVer());

57

Obj = Py_BuildValue("ssN",I.ParentPkg().Name(),I.ProvideVersion(),

58

Ver);

59

PyList_Append(List,Obj);

60

Py_DECREF(Obj);

61

}

62

return List;

63

}

64

65

// Cache Class /*{{{*/

66

// ---------------------------------------------------------------------

67

static PyObject *CacheAttr(PyObject *Self,char *Name)

68

{

69

pkgCache *Cache = GetCpp<pkgCache *>(Self);

70

71

if (strcmp("Packages",Name) == 0)

72

return CppOwnedPyObject_NEW<PkgListStruct>(Self,&PkgListType,Cache->PkgBegin());

73

else if (strcmp("PackageCount",Name) == 0)

74

return Py_BuildValue("i",Cache->HeaderP->PackageCount);

75

else if (strcmp("VersionCount",Name) == 0)

76

return Py_BuildValue("i",Cache->HeaderP->VersionCount);

77

else if (strcmp("DependsCount",Name) == 0)

78

return Py_BuildValue("i",Cache->HeaderP->DependsCount);

79

else if (strcmp("PackageFileCount",Name) == 0)

80

return Py_BuildValue("i",Cache->HeaderP->PackageFileCount);

81

else if (strcmp("VerFileCount",Name) == 0)

82

return Py_BuildValue("i",Cache->HeaderP->VerFileCount);

83

else if (strcmp("ProvidesCount",Name) == 0)

84

return Py_BuildValue("i",Cache->HeaderP->ProvidesCount);

85

else if (strcmp("FileList",Name) == 0)

86

{

87

PyObject *List = PyList_New(0);

88

for (pkgCache::PkgFileIterator I = Cache->FileBegin(); I.end() == false; I++)

89

{

90

PyObject *Obj;

91

Obj = CppOwnedPyObject_NEW<pkgCache::PkgFileIterator>(Self,&PackageFileType,I);

92

PyList_Append(List,Obj);

93

Py_DECREF(Obj);

94

}

95

return List;

96

}

97

98

PyErr_SetString(PyExc_AttributeError,Name);

99

return 0;

100

}

101

102

// Map access, operator []

103

static PyObject *CacheMapOp(PyObject *Self,PyObject *Arg)

104

{

105

pkgCache *Cache = GetCpp<pkgCache *>(Self);

106

107

if (PyString_Check(Arg) == 0)

108

{

109

PyErr_SetNone(PyExc_TypeError);

110

return 0;

111

}

112

113

// Search for the package

114

const char *Name = PyString_AsString(Arg);

115

pkgCache::PkgIterator Pkg = Cache->FindPkg(Name);

116

if (Pkg.end() == true)

117

{

118

PyErr_SetString(PyExc_KeyError,Name);

119

return 0;

120

}

121

122

return CppOwnedPyObject_NEW<pkgCache::PkgIterator>(Self,&PackageType,Pkg);

123

}

124

125

static PyMappingMethods CacheMap = {0,CacheMapOp,0};

126

PyTypeObject PkgCacheType =

127

{

128

PyObject_HEAD_INIT(&PyType_Type)

129

0, // ob_size

130

"pkgCache", // tp_name

131

sizeof(CppOwnedPyObject<pkgCache *>), // tp_basicsize

132

0, // tp_itemsize

133

// Methods

134

CppOwnedDealloc<pkgCache *>, // tp_dealloc

135

0, // tp_print

136

CacheAttr, // tp_getattr

137

0, // tp_setattr

138

0, // tp_compare

139

0, // tp_repr

140

0, // tp_as_number

141

0, // tp_as_sequence

142

&CacheMap, // tp_as_mapping

143

0, // tp_hash

144

};

145

146

/*}}}*/

147

// Package List Class /*{{{*/

148

// ---------------------------------------------------------------------

149

static int PkgListLen(PyObject *Self)

150

{

151

return GetCpp<PkgListStruct>(Self).Iter.Cache()->HeaderP->PackageCount;

152

}

153

154

static PyObject *PkgListItem(PyObject *iSelf,int Index)

155

{

156

PkgListStruct &Self = GetCpp<PkgListStruct>(iSelf);

157

if (Index < 0 || (unsigned)Index >= Self.Iter.Cache()->HeaderP->PackageCount)

158

{

159

PyErr_SetNone(PyExc_IndexError);

160

return 0;

161

}

162

163

if ((unsigned)Index < Self.LastIndex)

164

{

165

Self.LastIndex = 0;

166

Self.Iter = Self.Iter.Cache()->PkgBegin();

167

}

168

169

while ((unsigned)Index > Self.LastIndex)

170

{

171

Self.LastIndex++;

172

Self.Iter++;

173

if (Self.Iter.end() == true)

174

{

175

PyErr_SetNone(PyExc_IndexError);

176

return 0;

177

}

178

}

179

180

return CppOwnedPyObject_NEW<pkgCache::PkgIterator>(GetOwner<PkgListStruct>(iSelf),&PackageType,

181

Self.Iter);

182

}

183

184

static PySequenceMethods PkgListSeq =

185

{

186

PkgListLen,

187

0, // concat

188

0, // repeat

189

PkgListItem,

190

0, // slice

191

0, // assign item

192

0 // assign slice

193

};

194

195

PyTypeObject PkgListType =

196

{

197

PyObject_HEAD_INIT(&PyType_Type)

198

0, // ob_size

199

"pkgCache::PkgIterator", // tp_name

200

sizeof(CppOwnedPyObject<PkgListStruct>), // tp_basicsize

201

0, // tp_itemsize

202

// Methods

203

CppOwnedDealloc<PkgListStruct>, // tp_dealloc

204

0, // tp_print

205

0, // tp_getattr

206

0, // tp_setattr

207

0, // tp_compare

208

0, // tp_repr

209

0, // tp_as_number

210

&PkgListSeq, // tp_as_sequence

211

0, // tp_as_mapping

212

0, // tp_hash

213

};

214

215

/*}}}*/

216

// Package Class /*{{{*/

217

// ---------------------------------------------------------------------

218

static PyObject *PackageAttr(PyObject *Self,char *Name)

219

{

220

pkgCache::PkgIterator &Pkg = GetCpp<pkgCache::PkgIterator>(Self);

221

PyObject *Owner = GetOwner<pkgCache::PkgIterator>(Self);

222

223

if (strcmp("Name",Name) == 0)

224

return PyString_FromString(Pkg.Name());

225

else if (strcmp("VersionList",Name) == 0)

226

{

227

PyObject *List = PyList_New(0);

228

for (pkgCache::VerIterator I = Pkg.VersionList(); I.end() == false; I++)

229

{

230

PyObject *Obj;

231

Obj = CppOwnedPyObject_NEW<pkgCache::VerIterator>(Owner,&VersionType,I);

232

PyList_Append(List,Obj);

233

Py_DECREF(Obj);

234

}

235

return List;

236

}

237

else if (strcmp("CurrentVer",Name) == 0)

238

{

239

if (Pkg->CurrentVer == 0)

240

{

241

Py_INCREF(Py_None);

242

return Py_None;

243

}

244

245

return CppOwnedPyObject_NEW<pkgCache::VerIterator>(Owner,&VersionType,

246

Pkg.CurrentVer());

247

}

248

else if (strcmp("Section",Name) == 0)

249

return Safe_FromString(Pkg.Section());

250

else if (strcmp("RevDependsList",Name) == 0)

251

return CppOwnedPyObject_NEW<RDepListStruct>(Owner,&RDepListType,

252

Pkg.RevDependsList());

253

else if (strcmp("ProvidesList",Name) == 0)

254

return CreateProvides(Owner,Pkg.ProvidesList());

255

else if (strcmp("SelectedState",Name) == 0)

256

return Py_BuildValue("i",Pkg->SelectedState);

257

else if (strcmp("InstState",Name) == 0)

258

return Py_BuildValue("i",Pkg->InstState);

259

else if (strcmp("CurrentState",Name) == 0)

260

return Py_BuildValue("i",Pkg->CurrentState);

261

else if (strcmp("ID",Name) == 0)

262

return Py_BuildValue("i",Pkg->ID);

263

else if (strcmp("Auto",Name) == 0)

264

return Py_BuildValue("i",(Pkg->Flags & pkgCache::Flag::Auto) != 0);

265

else if (strcmp("Essential",Name) == 0)

266

return Py_BuildValue("i",(Pkg->Flags & pkgCache::Flag::Essential) != 0);

267

else if (strcmp("Important",Name) == 0)

268

return Py_BuildValue("i",(Pkg->Flags & pkgCache::Flag::Important) != 0);

269

270

PyErr_SetString(PyExc_AttributeError,Name);

271

return 0;

272

}

273

274

static PyObject *PackageRepr(PyObject *Self)

275

{

276

pkgCache::PkgIterator &Pkg = GetCpp<pkgCache::PkgIterator>(Self);

277

278

char S[300];

279

snprintf(S,sizeof(S),"<pkgCache::Package object: Name:'%s' Section: '%s'"

280

" ID:%u Flags:0x%lX>",

281

Pkg.Name(),Pkg.Section(),Pkg->ID,Pkg->Flags);

282

return PyString_FromString(S);

283

}

284

285

PyTypeObject PackageType =

286

{

287

PyObject_HEAD_INIT(&PyType_Type)

288

0, // ob_size

289

"pkgCache::Package", // tp_name

290

sizeof(CppOwnedPyObject<pkgCache::PkgIterator>), // tp_basicsize

291

0, // tp_itemsize

292

// Methods

293

CppOwnedDealloc<pkgCache::PkgIterator>, // tp_dealloc

294

0, // tp_print

295

PackageAttr, // tp_getattr

296

0, // tp_setattr

297

0, // tp_compare

298

PackageRepr, // tp_repr

299

0, // tp_as_number

300

0, // tp_as_sequence

301

0, // tp_as_mapping

302

0, // tp_hash

303

};

304

/*}}}*/

305

// Version Class /*{{{*/

306

// ---------------------------------------------------------------------

307

308

/* This is the simple depends result, the elements are split like

309

ParseDepends does */

310

static PyObject *MakeDepends(PyObject *Owner,pkgCache::VerIterator &Ver,

311

bool AsObj)

312

{

313

PyObject *Dict = PyDict_New();

314

PyObject *LastDep = 0;

315

unsigned LastDepType = 0;

316

for (pkgCache::DepIterator D = Ver.DependsList(); D.end() == false; D++)

317

{

318

pkgCache::DepIterator Start;

319

pkgCache::DepIterator End;

320

D.GlobOr(Start,End);

321

322

// Switch/create a new dict entry

323

if (LastDepType != Start->Type || LastDep != 0)

324

{

325

PyObject *Dep = PyString_FromString(Start.DepType());

326

LastDepType = Start->Type;

327

LastDep = PyDict_GetItem(Dict,Dep);

328

if (LastDep == 0)

329

{

330

LastDep = PyList_New(0);

331

PyDict_SetItem(Dict,Dep,LastDep);

332

Py_DECREF(LastDep);

333

}

334

Py_DECREF(Dep);

335

}

336

337

PyObject *OrGroup = PyList_New(0);

338

while (1)

339

{

340

PyObject *Obj;

341

if (AsObj == true)

342

Obj = CppOwnedPyObject_NEW<pkgCache::DepIterator>(Owner,&DependencyType,

343

Start);

344

else

345

{

346

if (Start->Version == 0)

347

Obj = Py_BuildValue("sss",

348

Start.TargetPkg().Name(),

349

"",

350

Start.CompType());

351

else

352

Obj = Py_BuildValue("sss",

353

Start.TargetPkg().Name(),

354

Start.TargetVer(),

355

Start.CompType());

356

}

357

PyList_Append(OrGroup,Obj);

358

Py_DECREF(Obj);

359

360

if (Start == End)

361

break;

362

Start++;

363

}

364

365

PyList_Append(LastDep,OrGroup);

366

Py_DECREF(OrGroup);

367

}

368

369

return Dict;

370

}

371

372

static PyObject *VersionAttr(PyObject *Self,char *Name)

373

{

374

pkgCache::VerIterator &Ver = GetCpp<pkgCache::VerIterator>(Self);

375

PyObject *Owner = GetOwner<pkgCache::VerIterator>(Self);

376

377

if (strcmp("VerStr",Name) == 0)

378

return PyString_FromString(Ver.VerStr());

379

else if (strcmp("Section",Name) == 0)

380

return Safe_FromString(Ver.Section());

381

else if (strcmp("Arch",Name) == 0)

382

return Safe_FromString(Ver.Arch());

383

else if (strcmp("FileList",Name) == 0)

384

{

385

/* The second value in the tuple is the index of the VF item. If the

386

user wants to request a lookup then that number will be used.

387

Maybe later it can become an object. */

388

PyObject *List = PyList_New(0);

389

for (pkgCache::VerFileIterator I = Ver.FileList(); I.end() == false; I++)

390

{

391

PyObject *PkgFile;

392

PyObject *Obj;

393

PkgFile = CppOwnedPyObject_NEW<pkgCache::PkgFileIterator>(Owner,&PackageFileType,I.File());

394

Obj = Py_BuildValue("Nl",PkgFile,I.Index());

395

PyList_Append(List,Obj);

396

Py_DECREF(Obj);

397

}

398

return List;

399

}

400

else if (strcmp("DependsListStr",Name) == 0)

401

return MakeDepends(Owner,Ver,false);

402

else if (strcmp("DependsList",Name) == 0)

403

return MakeDepends(Owner,Ver,true);

404

else if (strcmp("ParentPkg",Name) == 0)

405

return CppOwnedPyObject_NEW<pkgCache::PkgIterator>(Owner,&PackageType,

406

Ver.ParentPkg());

407

else if (strcmp("ProvidesList",Name) == 0)

408

return CreateProvides(Owner,Ver.ProvidesList());

409

else if (strcmp("Size",Name) == 0)

410

return Py_BuildValue("i",Ver->Size);

411

else if (strcmp("InstalledSize",Name) == 0)

412

return Py_BuildValue("i",Ver->InstalledSize);

413

else if (strcmp("Hash",Name) == 0)

414

return Py_BuildValue("i",Ver->Hash);

415

else if (strcmp("ID",Name) == 0)

416

return Py_BuildValue("i",Ver->ID);

417

else if (strcmp("Priority",Name) == 0)

418

return Py_BuildValue("i",Ver->Priority);

419

else if (strcmp("PriorityStr",Name) == 0)

420

return PyString_FromString(Ver.PriorityType());

421

422

PyErr_SetString(PyExc_AttributeError,Name);

423

return 0;

424

}

425

426

static PyObject *VersionRepr(PyObject *Self)

427

{

428

pkgCache::VerIterator &Ver = GetCpp<pkgCache::VerIterator>(Self);

429

430

char S[300];

431

snprintf(S,sizeof(S),"<pkgCache::Version object: Pkg:'%s' Ver:'%s' "

432

"Section:'%s' Arch:'%s' Size:%lu ISize:%lu Hash:%u "

433

"ID:%u Priority:%u>",

434

Ver.ParentPkg().Name(),Ver.VerStr(),Ver.Section(),Ver.Arch(),

435

(unsigned long)Ver->Size,(unsigned long)Ver->InstalledSize,

436

Ver->Hash,Ver->ID,Ver->Priority);

437

return PyString_FromString(S);

438

}

439

440

PyTypeObject VersionType =

441

{

442

PyObject_HEAD_INIT(&PyType_Type)

443

0, // ob_size

444

"pkgCache::VerIterator", // tp_name

445

sizeof(CppOwnedPyObject<pkgCache::VerIterator>), // tp_basicsize

446

0, // tp_itemsize

447

// Methods

448

CppOwnedDealloc<pkgCache::VerIterator>, // tp_dealloc

449

0, // tp_print

450

VersionAttr, // tp_getattr

451

0, // tp_setattr

452

0, // tp_compare

453

VersionRepr, // tp_repr

454

0, // tp_as_number

455

0, // tp_as_sequence

456

0, // tp_as_mapping

457

0, // tp_hash

458

};

459

460

/*}}}*/

461

// PackageFile Class /*{{{*/

462

// ---------------------------------------------------------------------

463

static PyObject *PackageFileAttr(PyObject *Self,char *Name)

464

{

465

pkgCache::PkgFileIterator &File = GetCpp<pkgCache::PkgFileIterator>(Self);

466

// PyObject *Owner = GetOwner<pkgCache::PkgFileIterator>(Self);

467

468

if (strcmp("FileName",Name) == 0)

469

return Safe_FromString(File.FileName());

470

else if (strcmp("Archive",Name) == 0)

471

return Safe_FromString(File.Archive());

472

else if (strcmp("Component",Name) == 0)

473

return Safe_FromString(File.Component());

474

else if (strcmp("Version",Name) == 0)

475

return Safe_FromString(File.Version());

476

else if (strcmp("Origin",Name) == 0)

477

return Safe_FromString(File.Origin());

478

else if (strcmp("Label",Name) == 0)

479

return Safe_FromString(File.Label());

480

else if (strcmp("Architecture",Name) == 0)

481

return Safe_FromString(File.Architecture());

482

else if (strcmp("Site",Name) == 0)

483

return Safe_FromString(File.Site());

484

else if (strcmp("IndexType",Name) == 0)

485

return Safe_FromString(File.IndexType());

486

else if (strcmp("Size",Name) == 0)

487

return Py_BuildValue("i",File->Size);

488

else if (strcmp("NotSource",Name) == 0)

489

return Py_BuildValue("i",(File->Flags & pkgCache::Flag::NotSource) != 0);

490

else if (strcmp("NotAutomatic",Name) == 0)

491

return Py_BuildValue("i",(File->Flags & pkgCache::Flag::NotAutomatic) != 0);

492

else if (strcmp("ID",Name) == 0)

493

return Py_BuildValue("i",File->ID);

494

/* mtime is really a cookie these days and has no meaning outside the

495

list handlers */

496

497

PyErr_SetString(PyExc_AttributeError,Name);

498

return 0;

499

}

500

501

static PyObject *PackageFileRepr(PyObject *Self)

502

{

503

pkgCache::PkgFileIterator &File = GetCpp<pkgCache::PkgFileIterator>(Self);

504

505

char S[300];

506

snprintf(S,sizeof(S),"<pkgCache::PackageFile object: "

507

"File:'%s' a=%s,c=%s,v=%s,o=%s,l=%s "

508

"Arch='%s' Site='%s' IndexType='%s' Size=%lu "

509

"Flags=0x%lX ID:%u>",

510

File.FileName(),File.Archive(),File.Component(),File.Version(),

511

File.Origin(),File.Label(),File.Architecture(),File.Site(),

512

File.IndexType(),File->Size,File->Flags,File->ID);

513

return PyString_FromString(S);

514

}

515

516

PyTypeObject PackageFileType =

517

{

518

PyObject_HEAD_INIT(&PyType_Type)

519

0, // ob_size

520

"pkgCache::PkgFileIterator", // tp_name

521

sizeof(CppOwnedPyObject<pkgCache::PkgFileIterator>), // tp_basicsize

522

0, // tp_itemsize

523

// Methods

524

CppOwnedDealloc<pkgCache::PkgFileIterator>, // tp_dealloc

525

0, // tp_print

526

PackageFileAttr, // tp_getattr

527

0, // tp_setattr

528

0, // tp_compare

529

PackageFileRepr, // tp_repr

530

0, // tp_as_number

531

0, // tp_as_sequence

532

0, // tp_as_mapping

533

0, // tp_hash

534

};

535

536

537

static PyObject *DependencyRepr(PyObject *Self)

538

{

539

pkgCache::DepIterator &Dep = GetCpp<pkgCache::DepIterator>(Self);

540

541

char S[300];

542

snprintf(S,sizeof(S),"<pkgCache::Dependency object: "

543

"Pkg:'%s' Ver:'%s' Comp:'%s'>",

544

Dep.TargetPkg().Name(),

545

(Dep.TargetVer() == 0?"":Dep.TargetVer()),

546

Dep.CompType());

547

return PyString_FromString(S);

548

}

549

550

static PyObject *DepSmartTargetPkg(PyObject *Self,PyObject *Args)

551

{

552

if (PyArg_ParseTuple(Args,"") == 0)

553

return 0;

554

555

pkgCache::DepIterator &Dep = GetCpp<pkgCache::DepIterator>(Self);

556

PyObject *Owner = GetOwner<pkgCache::DepIterator>(Self);

557

558

pkgCache::PkgIterator P;

559

if (Dep.SmartTargetPkg(P) == false)

560

{

561

Py_INCREF(Py_None);

562

return Py_None;

563

}

564

565

return CppOwnedPyObject_NEW<pkgCache::PkgIterator>(Owner,&PackageType,P);

566

}

567

568

static PyObject *DepAllTargets(PyObject *Self,PyObject *Args)

569

{

570

if (PyArg_ParseTuple(Args,"") == 0)

571

return 0;

572

573

pkgCache::DepIterator &Dep = GetCpp<pkgCache::DepIterator>(Self);

574

PyObject *Owner = GetOwner<pkgCache::DepIterator>(Self);

575

576

SPtr<pkgCache::Version *> Vers = Dep.AllTargets();

577

PyObject *List = PyList_New(0);

578

for (pkgCache::Version **I = Vers; *I != 0; I++)

579

{

580

PyObject *Obj;

581

Obj = CppOwnedPyObject_NEW<pkgCache::VerIterator>(Owner,&VersionType,

582

pkgCache::VerIterator(*Dep.Cache(),*I));

583

PyList_Append(List,Obj);

584

Py_DECREF(Obj);

585

}

586

return List;

587

}

588

589

static PyMethodDef DependencyMethods[] =

590

{

591

{"SmartTargetPkg",DepSmartTargetPkg,METH_VARARGS,"Returns the natural Target or None"},

592

{"AllTargets",DepAllTargets,METH_VARARGS,"Returns all possible Versions that match this dependency"},

593

{}

594

};

595

596

// Dependency Class /*{{{*/

597

// ---------------------------------------------------------------------

598

599

static PyObject *DependencyAttr(PyObject *Self,char *Name)

600

{

601

pkgCache::DepIterator &Dep = GetCpp<pkgCache::DepIterator>(Self);

602

PyObject *Owner = GetOwner<pkgCache::DepIterator>(Self);

603

604

if (strcmp("TargetVer",Name) == 0)

605

{

606

if (Dep->Version == 0)

607

return PyString_FromString("");

608

return PyString_FromString(Dep.TargetVer());

609

}

610

else if (strcmp("TargetPkg",Name) == 0)

611

return CppOwnedPyObject_NEW<pkgCache::PkgIterator>(Owner,&PackageType,

612

Dep.TargetPkg());

613

else if (strcmp("ParentVer",Name) == 0)

614

return CppOwnedPyObject_NEW<pkgCache::VerIterator>(Owner,&VersionType,

615

Dep.ParentVer());

616

else if (strcmp("ParentPkg",Name) == 0)

617

return CppOwnedPyObject_NEW<pkgCache::PkgIterator>(Owner,&PackageType, Dep.ParentPkg());

618

else if (strcmp("CompType",Name) == 0)

619

return PyString_FromString(Dep.CompType());

620

else if (strcmp("DepType",Name) == 0)

621

return PyString_FromString(Dep.DepType());

622

else if (strcmp("ID",Name) == 0)

623

return Py_BuildValue("i",Dep->ID);

624

625

return Py_FindMethod(DependencyMethods,Self,Name);

626

}

627

628

PyTypeObject DependencyType =

629

{

630

PyObject_HEAD_INIT(&PyType_Type)

631

0, // ob_size

632

"pkgCache::DepIterator", // tp_name

633

sizeof(CppOwnedPyObject<pkgCache::DepIterator>), // tp_basicsize

634

0, // tp_itemsize

635

// Methods

636

CppOwnedDealloc<pkgCache::DepIterator>, // tp_dealloc

637

0, // tp_print

638

DependencyAttr, // tp_getattr

639

0, // tp_setattr

640

0, // tp_compare

641

DependencyRepr, // tp_repr

642

0, // tp_as_number

643

0, // tp_as_sequence

644

0, // tp_as_mapping

645

0, // tp_hash

646

};

647

648

/*}}}*/

649

/*}}}*/

650

// Reverse Dependency List Class /*{{{*/

651

// ---------------------------------------------------------------------

652

static int RDepListLen(PyObject *Self)

653

{

654

return GetCpp<RDepListStruct>(Self).Len;

655

}

656

657

static PyObject *RDepListItem(PyObject *iSelf,int Index)

658

{

659

RDepListStruct &Self = GetCpp<RDepListStruct>(iSelf);

660

if (Index < 0 || (unsigned)Index >= Self.Len)

661

{

662

PyErr_SetNone(PyExc_IndexError);

663

return 0;

664

}

665

666

if ((unsigned)Index < Self.LastIndex)

667

{

668

Self.LastIndex = 0;

669

Self.Iter = Self.Start;

670

}

671

672

while ((unsigned)Index > Self.LastIndex)

673

{

674

Self.LastIndex++;

675

Self.Iter++;

676

if (Self.Iter.end() == true)

677

{

678

PyErr_SetNone(PyExc_IndexError);

679

return 0;

680

}

681

}

682

683

return CppOwnedPyObject_NEW<pkgCache::DepIterator>(GetOwner<RDepListStruct>(iSelf),

684

&DependencyType,Self.Iter);

685

}

686

687

static PySequenceMethods RDepListSeq =

688

{

689

RDepListLen,

690

0, // concat

691

0, // repeat

692

RDepListItem,

693

0, // slice

694

0, // assign item

695

0 // assign slice

696

};

697

698

PyTypeObject RDepListType =

699

{

700

PyObject_HEAD_INIT(&PyType_Type)

701

0, // ob_size

702

"pkgCache::DepIterator", // tp_name

703

sizeof(CppOwnedPyObject<RDepListStruct>), // tp_basicsize

704

0, // tp_itemsize

705

// Methods

706

CppOwnedDealloc<RDepListStruct>, // tp_dealloc

707

0, // tp_print

708

0, // tp_getattr

709

0, // tp_setattr

710

0, // tp_compare

711

0, // tp_repr

712

0, // tp_as_number

713

&RDepListSeq, // tp_as_sequence

714

0, // tp_as_mapping

715

0, // tp_hash

716

};

717

718

/*}}}*/

719

720

PyObject *TmpGetCache(PyObject *Self,PyObject *Args)

721

{

722

if (PyArg_ParseTuple(Args,"") == 0)

723

return 0;

724

725

pkgCacheFile *Cache = new pkgCacheFile();

726

OpTextProgress Prog;

727

if (Cache->Open(Prog,false) == false)

728

return HandleErrors();

729

730

return CppOwnedPyObject_NEW<pkgCache *>(0,&PkgCacheType,(pkgCache *)(*Cache));

731

}