← Back to branch summary

~thopiekar/zypper/libzypp-manual-import

« back to all changes in this revision

Viewing changes to zypp/ui/SelectableImpl.h

  • Committer: Thomas-Karl Pietrowski
  • Date: 2015-08-15 15:59:50 UTC
  • Revision ID: thopiekar@googlemail.com-20150815155950-j66qn38efmvn289t
syncing with "changes 15.13.0 (11)"  #9a0aca7e3a21d768491b141a8ae86ef0c3fbc227
* https://github.com/openSUSE/libzypp/commit/9a0aca7e3a21d768491b141a8ae86ef0c3fbc227

Show diffs side-by-side

added added

removed removed

Lines of Context:
zypp/ui/SelectableImpl.h
57
57
 
58
58
    public:
59
59
      template <class _Iterator>
60
 
      Impl( const ResObject::Kind & kind_r,
 
60
      Impl( const ResKind & kind_r,
61
61
            const std::string & name_r,
62
62
            _Iterator begin_r,
63
63
            _Iterator end_r )
80
80
      { return _ident; }
81
81
 
82
82
      /**  */
83
 
      ResObject::Kind kind() const
 
83
      ResKind kind() const
84
84
      { return _kind; }
85
85
 
86
86
      /**  */
127
127
       */
128
128
      PoolItem candidateObjFrom( Repository repo_r ) const
129
129
      {
130
 
        for_( it, availableBegin(), availableEnd() )
 
130
        for ( const PoolItem & pi : available() )
131
131
        {
132
 
          if ( (*it)->repository() == repo_r )
133
 
            return *it;
 
132
          if ( pi.repository() == repo_r )
 
133
            return pi;
134
134
        }
135
135
        return PoolItem();
136
136
      }
175
175
      PoolItem highestAvailableVersionObj() const
176
176
      {
177
177
        PoolItem ret;
178
 
        for_( it, availableBegin(), availableEnd() )
 
178
        for ( const PoolItem & pi : available() )
179
179
        {
180
 
          if ( !ret || (*it).satSolvable().edition() > ret.satSolvable().edition() )
181
 
            ret = *it;
 
180
          if ( !ret || pi.edition() > ret.edition() )
 
181
            ret = pi;
182
182
        }
183
183
        return ret;
184
184
      }
236
236
      available_size_type availableSize() const
237
237
      { return _availableItems.size(); }
238
238
 
239
 
      available_const_iterator availableBegin() const
 
239
      available_iterator availableBegin() const
240
240
      { return _availableItems.begin(); }
241
241
 
242
 
      available_const_iterator availableEnd() const
 
242
      available_iterator availableEnd() const
243
243
      { return _availableItems.end(); }
244
244
 
 
245
      inline Iterable<available_iterator>  available() const
 
246
      { return makeIterable( availableBegin(), availableEnd() ); }
 
247
 
245
248
      ////////////////////////////////////////////////////////////////////////
246
249
 
247
250
      bool installedEmpty() const
256
259
      installed_iterator installedEnd() const
257
260
      { return _installedItems.end(); }
258
261
 
 
262
      inline Iterable<installed_iterator>  installed() const
 
263
      { return makeIterable( installedBegin(), installedEnd() ); }
 
264
 
259
265
      ////////////////////////////////////////////////////////////////////////
260
266
 
261
267
      const PickList & picklist() const
264
270
        {
265
271
          _picklistPtr.reset( new PickList );
266
272
          // installed without identical avaialble first:
267
 
          for_( it, _installedItems.begin(), _installedItems.end() )
 
273
          for ( const PoolItem & pi : installed() )
268
274
          {
269
 
            if ( ! identicalAvailable( *it ) )
270
 
              _picklistPtr->push_back( *it );
 
275
            if ( ! identicalAvailable( pi ) )
 
276
              _picklistPtr->push_back( pi );
271
277
          }
272
278
          _picklistPtr->insert( _picklistPtr->end(), availableBegin(), availableEnd() );
273
279
        }
292
298
      { return availableEmpty(); }
293
299
 
294
300
      bool multiversionInstall() const
295
 
      { return sat::Pool::instance().isMultiversion( ident() ); }
 
301
      {
 
302
        for ( const PoolItem & pi : available() )
 
303
        {
 
304
          if ( pi.multiversionInstall() )
 
305
            return true;
 
306
        }
 
307
        return false;
 
308
      }
296
309
 
297
310
      bool pickInstall( const PoolItem & pi_r, ResStatus::TransactByValue causer_r, bool yesno_r );
298
311
 
339
352
    private:
340
353
      PoolItem transactingInstalled() const
341
354
      {
342
 
        for_( it, installedBegin(), installedEnd() )
 
355
        for ( const PoolItem & pi : installed() )
343
356
          {
344
 
            if ( (*it).status().transacts() )
345
 
              return (*it);
 
357
            if ( pi.status().transacts() )
 
358
              return pi;
346
359
          }
347
360
        return PoolItem();
348
361
      }
349
362
 
350
363
      PoolItem transactingCandidate() const
351
364
      {
352
 
        for_( it, availableBegin(), availableEnd() )
 
365
        for ( const PoolItem & pi : available() )
353
366
          {
354
 
            if ( (*it).status().transacts() )
355
 
              return (*it);
 
367
            if ( pi.status().transacts() )
 
368
              return pi;
356
369
          }
357
370
        return PoolItem();
358
371
      }
363
376
        {
364
377
          // prefer the installed objects arch and vendor
365
378
          bool solver_allowVendorChange( ResPool::instance().resolver().allowVendorChange() );
366
 
          for ( installed_const_iterator iit = installedBegin();
367
 
                iit != installedEnd(); ++iit )
 
379
          for ( const PoolItem & ipi : installed() )
368
380
          {
369
381
            PoolItem sameArch; // in case there's no same vendor at least stay with same arch.
370
 
            for ( available_const_iterator it = availableBegin();
371
 
                  it != availableEnd(); ++it )
 
382
            for (  const PoolItem & api : available() )
372
383
            {
373
384
              // 'same arch' includes allowed changes to/from noarch.
374
 
              if ( (*iit)->arch() == (*it)->arch() || (*iit)->arch() == Arch_noarch || (*it)->arch() == Arch_noarch )
 
385
              if ( ipi.arch() == api.arch() || ipi.arch() == Arch_noarch || api.arch() == Arch_noarch )
375
386
              {
376
387
                if ( ! solver_allowVendorChange )
377
388
                {
378
 
                  if ( VendorAttr::instance().equivalent( (*iit), (*it) ) )
379
 
                    return *it;
 
389
                  if ( VendorAttr::instance().equivalent( ipi, api ) )
 
390
                    return api;
380
391
                  else if ( ! sameArch ) // remember best same arch in case no same vendor found
381
 
                     sameArch = *it;
 
392
                     sameArch = api;
382
393
                }
383
394
                else // same arch is sufficient
384
 
                  return *it;
 
395
                  return api;
385
396
              }
386
397
            }
387
398
            if ( sameArch )
396
407
 
397
408
      bool allCandidatesLocked() const
398
409
      {
399
 
        for ( available_const_iterator it = availableBegin();
400
 
              it != availableEnd(); ++it )
 
410
        for ( const PoolItem & pi : available() )
401
411
          {
402
 
            if ( ! (*it).status().isLocked() )
 
412
            if ( ! pi.status().isLocked() )
403
413
              return false;
404
414
          }
405
415
        return( ! _availableItems.empty() );
407
417
 
408
418
      bool allInstalledLocked() const
409
419
      {
410
 
        for ( installed_const_iterator it = installedBegin();
411
 
              it != installedEnd(); ++it )
 
420
        for ( const PoolItem & pi : installed() )
412
421
          {
413
 
            if ( ! (*it).status().isLocked() )
 
422
            if ( ! pi.status().isLocked() )
414
423
              return false;
415
424
          }
416
425
        return( ! _installedItems.empty() );
419
428
 
420
429
    private:
421
430
      const IdString         _ident;
422
 
      const ResObject::Kind  _kind;
 
431
      const ResKind          _kind;
423
432
      const std::string      _name;
424
433
      InstalledItemSet       _installedItems;
425
434
      AvailableItemSet       _availableItems;
451
460
      {
452
461
        PoolItem icand( obj.installedObj() );
453
462
        str << "   (I " << obj.installedSize() << ") {" << endl;
454
 
        for_( it, obj.installedBegin(), obj.installedEnd() )
 
463
        for ( const PoolItem & pi : obj.installed() )
455
464
        {
456
465
          char t = ' ';
457
 
          if ( *it == icand )
 
466
          if ( pi == icand )
458
467
          {
459
468
            t = 'i';
460
469
          }
461
 
          str << " " << t << " " << *it << endl;
 
470
          str << " " << t << " " << pi << endl;
462
471
        }
463
472
        str << "}  ";
464
473
      }
472
481
        PoolItem cand( obj.candidateObj() );
473
482
        PoolItem up( obj.updateCandidateObj() );
474
483
        str << "(A " << obj.availableSize() << ") {" << endl;
475
 
        for_( it, obj.availableBegin(), obj.availableEnd() )
 
484
        for ( const PoolItem & pi : obj.available() )
476
485
        {
477
486
          char t = ' ';
478
 
          if ( *it == cand )
 
487
          if ( pi == cand )
479
488
          {
480
 
            t = *it == up ? 'C' : 'c';
 
489
            t = pi == up ? 'C' : 'c';
481
490
          }
482
 
          else if ( *it == up )
 
491
          else if ( pi == up )
483
492
          {
484
493
            t = 'u';
485
494
          }
486
 
          str << " " << t << " " << *it << endl;
 
495
          str << " " << t << " " << pi << endl;
487
496
        }
488
497
        str << "}  ";
489
498
      }
497
506
        PoolItem cand( obj.candidateObj() );
498
507
        PoolItem up( obj.updateCandidateObj() );
499
508
        str << "(P " << obj.picklistSize() << ") {" << endl;
500
 
        for_( it, obj.picklistBegin(), obj.picklistEnd() )
 
509
        for ( const PoolItem & pi : obj.picklist() )
501
510
        {
502
511
          char t = ' ';
503
 
          if ( *it == cand )
 
512
          if ( pi == cand )
504
513
          {
505
 
            t = *it == up ? 'C' : 'c';
 
514
            t = pi == up ? 'C' : 'c';
506
515
          }
507
 
          else if ( *it == up )
 
516
          else if ( pi == up )
508
517
          {
509
518
            t = 'u';
510
519
          }
511
 
          str << " " << t << " " << *it << "\t" << obj.pickStatus( *it ) << endl;
 
520
          str << " " << t << " " << pi << "\t" << obj.pickStatus( pi ) << endl;
512
521
        }
513
522
        str << "}  ";
514
523
      }