Attachment #20650 for bug #57789

View | Details | Raw Unified | Return to bug 57789
Collapse All | Expand All




   }
}
									/*}}}*/
// IsVirtualPackage - Check if package is virtual (no versions, has providers)	/*{{{*/
// ---------------------------------------------------------------------
/* Virtual packages have no actual versions but are provided by other packages */
static inline bool IsVirtualPackage(pkgCache::PkgIterator const &Pkg)
{
   return (Pkg->VersionList == 0) && (Pkg->ProvidesList != 0);
}
									/*}}}*/
// GetInstalledProviders - Get installed providers of a virtual package	/*{{{*/
// ---------------------------------------------------------------------
/* Returns list of all installed packages that provide the given virtual pkg */
static std::vector<pkgCache::PkgIterator> GetInstalledProviders(
   pkgCache::PkgIterator const &VirtualPkg,
   pkgDepCache &Dep)
{
   std::vector<pkgCache::PkgIterator> Providers;

   for (pkgCache::PrvIterator Prv = VirtualPkg.ProvidesList();
        not Prv.end(); ++Prv)
   {
      pkgCache::PkgIterator Provider = Prv.OwnerPkg();
      if ((Provider->CurrentState == pkgCache::State::Installed) ||
          Dep[Provider].Install())
      {
         Providers.push_back(Provider);
      }
   }

   return Providers;
}

bool pkgDoAuto(std::ostream &c1out, const CommandLine &CmdL, int &auto_mark_changed, pkgDepCache &Dep)
{

   for (const char **I = CmdL.FileList + 1; *I != 0; ++I)
   {
      auto pkgiter = Dep.FindPkg(*I);
      if (pkgiter.end())
      {
         continue;
      }

      // Handle virtual packages: apply to all installed providers
      if (IsVirtualPackage(pkgiter))
      {
         std::vector<pkgCache::PkgIterator> Providers = GetInstalledProviders(pkgiter, Dep);

         if (Providers.empty())
         {
            ioprintf(c1out, _("%s is a virtual package with no installed providers.\n"), pkgiter.Name());
            continue;
         }

         // Apply to each installed provider
         for (auto const &Provider : Providers)
         {
            if (((Dep[Provider].Flags & pkgCache::Flag::Auto) == pkgCache::Flag::Auto) == MarkAuto)
            {
               if (!MarkAuto)
               {
                  ioprintf(c1out, _("%s (provider of %s) was already set to manually installed.\n"),
                           Provider.Name(), pkgiter.Name());
               }
               else
               {
                  ioprintf(c1out, _("%s (provider of %s) was already set to automatically installed.\n"),
                           Provider.Name(), pkgiter.Name());
               }
               continue;
            }

            if (!MarkAuto)
            {
               ioprintf(c1out, _("%s (provider of %s) set to manually installed.\n"),
                        Provider.Name(), pkgiter.Name());
            }
            else
            {
               ioprintf(c1out, _("%s (provider of %s) set to automatically installed.\n"),
                        Provider.Name(), pkgiter.Name());
            }

            Dep.MarkAuto(Provider, MarkAuto ? pkgDepCache::AutoMarkFlag::Auto : pkgDepCache::AutoMarkFlag::Manual);
            ++AutoMarkChanged;
         }
         continue;
      }

      // Handle real packages (existing logic)
      if ((pkgiter->CurrentState == pkgCache::State::NotInstalled) && (!Dep[pkgiter].NewInstall()))
      {
         ioprintf(c1out, _("%s can not be marked as it is not installed.\n"), pkgiter.Name());
         continue;
      }

      if (((Dep[pkgiter].Flags & pkgCache::Flag::Auto) == pkgCache::Flag::Auto) == MarkAuto)
      {
         if (!MarkAuto)
         {
            ioprintf(c1out,_("%s was already set to manually installed.\n"), pkgiter.Name());
         }
         else
         {
            ioprintf(c1out,_("%s was already set to automatically installed.\n"), pkgiter.Name());
         }

         continue;
         ++AutoMarkChanged;
      }

      if (!MarkAuto)
      {
         ioprintf(c1out,_("%s set to manually installed.\n"), pkgiter.Name());
      }
      else
      {
         ioprintf(c1out,_("%s set to automatically installed.\n"), pkgiter.Name());
      }

      Dep.MarkAuto(pkgiter, MarkAuto ? pkgDepCache::AutoMarkFlag::Auto : pkgDepCache::AutoMarkFlag::Manual);
      ++AutoMarkChanged;
   }

   auto_mark_changed = AutoMarkChanged;

      for (const char **I = CmdL.FileList + 1; *I != 0; ++I)
      {
         auto pkgiter = Dep.FindPkg(*I);
         if (pkgiter.end())
         {
            continue;
         }

         // Handle virtual packages: show state of all installed providers
         if (IsVirtualPackage(pkgiter))
         {
            std::vector<pkgCache::PkgIterator> Providers = GetInstalledProviders(pkgiter, Dep);

            for (auto const &Provider : Providers)
            {
               bool current_state_is_auto = ((Dep[Provider].Flags & pkgCache::Flag::Auto) == pkgCache::Flag::Auto);
               if (ShowState)
               {
                  std::stringstream str;
                  str << Provider.Name() << " " << (current_state_is_auto ? "auto" : "manual");
                  packages.push_back(str.str());
               }
               else if (current_state_is_auto == ShowAuto)
               {
                  packages.push_back(Provider.Name());
               }
            }
            continue;
         }

         // Handle real packages (existing logic)
         if ((pkgiter->CurrentState == pkgCache::State::Installed) || (Dep[pkgiter].Install()))
         {
            bool current_state_is_auto = ((Dep[pkgiter].Flags & pkgCache::Flag::Auto) == pkgCache::Flag::Auto);
            if (ShowState)
            {
               std::stringstream str;
               str << pkgiter.Name() << " " << (current_state_is_auto ? "auto" : "manual");
               packages.push_back(str.str());
            }
            else if (current_state_is_auto == ShowAuto)
            {
               packages.push_back(pkgiter.Name());
            }
         }
      }
   }

Return to bug 57789

Lines 1295-1300 void Stats(std::ostream &out, std::ostream &l_c3out, pkgDepCache &Dep, pkgDepCac Link Here

(-)a/apt-pkg/cachefile.cc (-16 / +120 lines)
1295	}	1295	}
1296	}	1296	}
1297	/}}}/	1297	/}}}/
		1298	// IsVirtualPackage - Check if package is virtual (no versions, has providers) /{{{/
		1299	// ---------------------------------------------------------------------
		1300	/* Virtual packages have no actual versions but are provided by other packages */
		1301	static inline bool IsVirtualPackage(pkgCache::PkgIterator const &Pkg)
		1302	{
		1303	return (Pkg->VersionList == 0) && (Pkg->ProvidesList != 0);
		1304	}
		1305	/}}}/
		1306	// GetInstalledProviders - Get installed providers of a virtual package /{{{/
		1307	// ---------------------------------------------------------------------
		1308	/* Returns list of all installed packages that provide the given virtual pkg */
		1309	static std::vector<pkgCache::PkgIterator> GetInstalledProviders(
		1310	pkgCache::PkgIterator const &VirtualPkg,
		1311	pkgDepCache &Dep)
		1312	{
		1313	std::vector<pkgCache::PkgIterator> Providers;
		1314
		1315	for (pkgCache::PrvIterator Prv = VirtualPkg.ProvidesList();
		1316	not Prv.end(); ++Prv)
		1317	{
		1318	pkgCache::PkgIterator Provider = Prv.OwnerPkg();
		1319	if ((Provider->CurrentState == pkgCache::State::Installed) \|\|
		1320	Dep[Provider].Install())
		1321	{
		1322	Providers.push_back(Provider);
		1323	}
		1324	}
		1325
		1326	return Providers;
		1327	}
1298		1328
1299	bool pkgDoAuto(std::ostream &c1out, const CommandLine &CmdL, int &auto_mark_changed, pkgDepCache &Dep)	1329	bool pkgDoAuto(std::ostream &c1out, const CommandLine &CmdL, int &auto_mark_changed, pkgDepCache &Dep)
1300	{	1330	{
Lines 1309-1348 bool pkgDoAuto(std::ostream &c1out, const CommandLine &CmdL, int &auto_mark_chan Link Here
1309	for (const char *I = CmdL.FileList + 1; I != 0; ++I)	1339	for (const char *I = CmdL.FileList + 1; I != 0; ++I)
1310	{	1340	{
1311	auto pkgiter = Dep.FindPkg(*I);	1341	auto pkgiter = Dep.FindPkg(*I);
1312	if (!pkgiter.end())	1342	if (pkgiter.end())
		1343	{
		1344	continue;
		1345	}
		1346
		1347	// Handle virtual packages: apply to all installed providers
		1348	if (IsVirtualPackage(pkgiter))
1313	{	1349	{
1314	if ((pkgiter->CurrentState == pkgCache::State::NotInstalled) && (!Dep[pkgiter].NewInstall()))	1350	std::vector<pkgCache::PkgIterator> Providers = GetInstalledProviders(pkgiter, Dep);
		1351
		1352	if (Providers.empty())
1315	{	1353	{
1316	ioprintf(c1out, _("%s can not be marked as it is not installed.\n"), pkgiter.Name());	1354	ioprintf(c1out, _("%s is a virtual package with no installed providers.\n"), pkgiter.Name());
1317	continue;	1355	continue;
1318	}	1356	}
1319		1357
1320	else if (((Dep[pkgiter].Flags & pkgCache::Flag::Auto) == pkgCache::Flag::Auto) == MarkAuto)	1358	// Apply to each installed provider
		1359	for (auto const &Provider : Providers)
1321	{	1360	{
		1361	if (((Dep[Provider].Flags & pkgCache::Flag::Auto) == pkgCache::Flag::Auto) == MarkAuto)
		1362	{
		1363	if (!MarkAuto)
		1364	{
		1365	ioprintf(c1out, _("%s (provider of %s) was already set to manually installed.\n"),
		1366	Provider.Name(), pkgiter.Name());
		1367	}
		1368	else
		1369	{
		1370	ioprintf(c1out, _("%s (provider of %s) was already set to automatically installed.\n"),
		1371	Provider.Name(), pkgiter.Name());
		1372	}
		1373	continue;
		1374	}
		1375
1322	if (!MarkAuto)	1376	if (!MarkAuto)
1323	{	1377	{
1324	ioprintf(c1out,_("%s was already set to manually installed.\n"), pkgiter.Name());	1378	ioprintf(c1out, _("%s (provider of %s) set to manually installed.\n"),
		1379	Provider.Name(), pkgiter.Name());
1325	}	1380	}
1326	else	1381	else
1327	{	1382	{
1328	ioprintf(c1out,_("%s was already set to automatically installed.\n"), pkgiter.Name());	1383	ioprintf(c1out, _("%s (provider of %s) set to automatically installed.\n"),
		1384	Provider.Name(), pkgiter.Name());
1329	}	1385	}
1330		1386
1331	continue;	1387	Dep.MarkAuto(Provider, MarkAuto ? pkgDepCache::AutoMarkFlag::Auto : pkgDepCache::AutoMarkFlag::Manual);
		1388	++AutoMarkChanged;
1332	}	1389	}
		1390	continue;
		1391	}
1333		1392
		1393	// Handle real packages (existing logic)
		1394	if ((pkgiter->CurrentState == pkgCache::State::NotInstalled) && (!Dep[pkgiter].NewInstall()))
		1395	{
		1396	ioprintf(c1out, _("%s can not be marked as it is not installed.\n"), pkgiter.Name());
		1397	continue;
		1398	}
		1399
		1400	if (((Dep[pkgiter].Flags & pkgCache::Flag::Auto) == pkgCache::Flag::Auto) == MarkAuto)
		1401	{
1334	if (!MarkAuto)	1402	if (!MarkAuto)
1335	{	1403	{
1336	ioprintf(c1out,_("%s set to manually installed.\n"), pkgiter.Name());	1404	ioprintf(c1out,_("%s was already set to manually installed.\n"), pkgiter.Name());
1337	}	1405	}
1338	else	1406	else
1339	{	1407	{
1340	ioprintf(c1out,_("%s set to automatically installed.\n"), pkgiter.Name());	1408	ioprintf(c1out,_("%s was already set to automatically installed.\n"), pkgiter.Name());
1341	}	1409	}
1342		1410
1343	Dep.MarkAuto(pkgiter, MarkAuto ? pkgDepCache::AutoMarkFlag::Auto : pkgDepCache::AutoMarkFlag::Manual);	1411	continue;
1344	++AutoMarkChanged;
1345	}	1412	}
		1413
		1414	if (!MarkAuto)
		1415	{
		1416	ioprintf(c1out,_("%s set to manually installed.\n"), pkgiter.Name());
		1417	}
		1418	else
		1419	{
		1420	ioprintf(c1out,_("%s set to automatically installed.\n"), pkgiter.Name());
		1421	}
		1422
		1423	Dep.MarkAuto(pkgiter, MarkAuto ? pkgDepCache::AutoMarkFlag::Auto : pkgDepCache::AutoMarkFlag::Manual);
		1424	++AutoMarkChanged;
1346	}	1425	}
1347		1426
1348	auto_mark_changed = AutoMarkChanged;	1427	auto_mark_changed = AutoMarkChanged;
Lines 1394-1415 bool pkgDoShowAuto(std::ostream &cout, const CommandLine &CmdL, pkgDepCache &Dep Link Here
1394	for (const char *I = CmdL.FileList + 1; I != 0; ++I)	1473	for (const char *I = CmdL.FileList + 1; I != 0; ++I)
1395	{	1474	{
1396	auto pkgiter = Dep.FindPkg(*I);	1475	auto pkgiter = Dep.FindPkg(*I);
1397	if (!pkgiter.end())	1476	if (pkgiter.end())
		1477	{
		1478	continue;
		1479	}
		1480
		1481	// Handle virtual packages: show state of all installed providers
		1482	if (IsVirtualPackage(pkgiter))
1398	{	1483	{
1399	if ((pkgiter->CurrentState == pkgCache::State::Installed) \|\| (Dep[pkgiter].Install()))	1484	std::vector<pkgCache::PkgIterator> Providers = GetInstalledProviders(pkgiter, Dep);
		1485
		1486	for (auto const &Provider : Providers)
1400	{	1487	{
1401	bool current_state_is_auto = ((Dep[pkgiter].Flags & pkgCache::Flag::Auto) == pkgCache::Flag::Auto);	1488	bool current_state_is_auto = ((Dep[Provider].Flags & pkgCache::Flag::Auto) == pkgCache::Flag::Auto);
1402	if (ShowState)	1489	if (ShowState)
1403	{	1490	{
1404	std::stringstream str;	1491	std::stringstream str;
1405	str << pkgiter.Name() << " " << (current_state_is_auto ? "auto" : "manual");	1492	str << Provider.Name() << " " << (current_state_is_auto ? "auto" : "manual");
1406	packages.push_back(str.str());	1493	packages.push_back(str.str());
1407	}	1494	}
1408	else if (current_state_is_auto == ShowAuto)	1495	else if (current_state_is_auto == ShowAuto)
1409	{	1496	{
1410	packages.push_back(pkgiter.Name());	1497	packages.push_back(Provider.Name());
1411	}	1498	}
1412	}	1499	}
		1500	continue;
		1501	}
		1502
		1503	// Handle real packages (existing logic)
		1504	if ((pkgiter->CurrentState == pkgCache::State::Installed) \|\| (Dep[pkgiter].Install()))
		1505	{
		1506	bool current_state_is_auto = ((Dep[pkgiter].Flags & pkgCache::Flag::Auto) == pkgCache::Flag::Auto);
		1507	if (ShowState)
		1508	{
		1509	std::stringstream str;
		1510	str << pkgiter.Name() << " " << (current_state_is_auto ? "auto" : "manual");
		1511	packages.push_back(str.str());
		1512	}
		1513	else if (current_state_is_auto == ShowAuto)
		1514	{
		1515	packages.push_back(pkgiter.Name());
		1516	}
1413	}	1517	}
1414	}	1518	}
1415	}	1519	}