packagemanager.h

Go to the documentation of this file.

/*!\file packagemanager.h
        \brief Declerations for PackageManager and Virtual.
        Should be included in every interface that uses the PackageManager.*/

#ifndef __PACKAGEMANAGER_H__
#define __PACKAGEMANAGER_H__

#include "packageversiondatabase.h"
#include "packagedatabase.h"
#include "package.h"
#include "packageversion.h"
#include "installeddatabase.h"
#include "installedpackage.h"
#include <vector>
#include "pmstring.h"
#include "pstream.h"

/*NF means Not Fixing.
  NF - known issue with purge dist and not up to date, portage deletes ebuild
  NF - output is in wrong order - problem with popen or something
  NF - issue with having virtuals already provided in the list, ie someone does semerge xfree gnome will install xorg and xfree
  NF - dont check dependencies when we upgrade
  NF - cant work out dependencies of a vector of packageversions. This could prove to be a problem*/

//!Small struct to contain info about virtuals.
/*!Virtual is a struct that encapsulates all the info about a virtual. i.e. its
  text based form and its category/name version.*/
struct Virtual
{
        PMString virtualString; //!<The virtual string form of the virtual, i.e. virtual/x11.
        PMString category;              //!<The category of the corresponding package.
        PMString name;                  //!<The name of the corresponding package.
        PMString version;               //!<The version of the package that is required.
};

//!The main class that interfaces with the database backend.
/*!The Package Management system. This is the daddy that glues all the classes together
  and is the main interface for users. This should be the only class needed to interface
  with all the DB's. If there is any functionality missing, let me know ASAP.*/
class PackageManager
{
        public:
                PackageManager();                                                                                                                                                                               //!<Constructor.
                PackageManager(Keyword acceptKeyword, PMString useFlags, std::vector<Virtual> virtuals);                                //!<Constructor.
                ~PackageManager();                                                                                                                                                                              //!<Destructor.
        
                std::vector<Package> SearchPackageName(PMString name);                          //!<Search for name. Can be category/name or just name.
                std::vector<Package> SearchRegExpName(PMString expression);                     //!<Search for category/name using regexp.
                std::vector<Package> SearchNameContains(PMString lookup);                       //!<Search for category/name that contains lookup.
                std::vector<Package> SearchRegExpDescription(PMString expression);      //!<Search description for expression using regexp.
                std::vector<Package> SearchDescriptionContains(PMString lookup);        //!<Search for description containing lookup.
                
                PackageVersion SearchSpecificVersion(Package searchPackage,PMString version);                                                   //!<Search for version of searchPackage.
                PackageVersion GetLatestVersion(Package searchPackage, bool hardMasked = false, PMString slot = "");    //!<Get latest version of searchPackage.
                PackageVersion GetLatestAvailableVersion(Package searchPackage, PMString slot = "");                                    //!<Get latest available version of searchPackage.
                PackageVersion GetLatestVersionInstalled(Package passedPackage);                                                                                //!<Get latest version installed of passedPackage.
                PackageVersion GetVirtual(PMString virtualString);                                                                                                              //!<Get PackageVersion that should be installed for virtualString.
                
                std::vector<PackageVersion> FullSearchPackage(PMString searchString);                                                                                   //!<Search for PackageVersion using searchString ( cat/name-ver or name-ver ).
                std::vector<PackageVersion> GetVersions(Package searchPackage, bool hardMasked = false, PMString slot = "");    //!<Get all versions of searchPackage.
                std::vector<PackageVersion> GetAvailableVersions(Package searchPackage, PMString slot = "");                                    //!<Get available versions of searchPackage.
                std::vector<PackageVersion> GetVersionsInstalled(Package passedPackage);                                                                                //!<Get versions installed of passedPackage.
                std::vector<PackageVersion> CalculateNotInstalledDependencies(PackageVersion version);                                                  //!<Calculate all dependencies not installed for version.
                std::vector<PackageVersion> CalculateAllDependencies(PackageVersion version);                                                                   //!<Calculate all dependencies for version.
                
                bool SearchVersionExists(Package searchPackage,PMString version);       //!<Returns true if version of searchPackage exists.
                bool IsVersionInstalled(PackageVersion passedVersion);                          //!<Returns true if passedVersion is installed.
                bool IsPackageInstalled(Package passedPackage);                                         //!<Returns true if passedPackage is installed.
                bool IsPackageInWorld(Package passedPackage);                                           //!<Returns true if passedPackage is in world.
                bool IsSlotInstalled(Package passedPackage, PMString slot);             //!<Returns true if slot of package is installed.
                
                void CreateAllDatabases(bool clearCache = true,bool cacheFileSizes=false);                                      //!<Create the DB, also refill.
                void CreatePackageDatabases(bool clearCache = true, bool cacheFileSizes=false);                         //!<Create the DB's for packages - should be done after each sync.
                void CreateInstalledDatabase();                                                                                                                         //!<Create the installed DB - should be done whenever emerge is used.
                void SetPackageInstalled(PackageVersion version,bool upgrade = false,bool inWorld = true);      //!<Set version to be installed.
                void SetPackageRemoved(PackageVersion version,bool upgrade = false);                                            //!<Set version to be removed.
                void RegenWorldFile();                                                                                                                                          //!<Regenerate the world file from the InstalledDb.
                void AddToWorld(Package toAdd);                                                                                                                         //!<Add package to the world file.
                void RemoveFromWorld(Package toRemove);                                                                                                         //!<Remove package from the world file.
                
                void SetKeyword(PMString keyword);                              //!<Set keyword to keyword.
                void SetKeyword(Keyword keyword);                               //!<Set keyword to keyword.
                void AddUseFlag(PMString flag);                                 //!<Add a use flag.
                void SetUseFlags(PMString flags);                               //!<Set the use flags.
                void SetVirtuals(std::vector<Virtual> virtuals);//!<Set the virtuals.
                void AddVirtual(Virtual passedVirtual);                 //!<Add a virtual.
                
                void SetHardMaskedPackages(std::vector<PMString> hardMasked);   //!<Set the hardMasked package regexp.
                void SetUnstablePackages(std::vector<PMString> unStable);               //!<Set the unstable package regexp.
                void SetStablePackages(std::vector<PMString> stable);                   //!<Set the stable package regexp.
                
                void FetchPackages(PackageVersion version, redi::ipstream& streamToOutput);                                                                                                     //!<Fetch version.
                void InstallPackage(PackageVersion version, redi::ipstream& streamToOutput, bool threaded = false, bool inWorld = true);        //!<Install version.
                void RemovePackage(PackageVersion version, redi::ipstream& streamToOutput, bool threaded = false);                                                      //!<Remove version.
                
                Virtual GetVirtual(PackageVersion passedVersion);       //!<Returns the virtual that passedVersion provides.
                
                std::vector<InstalledPackage> GetWorldPackages();                                                               //!<Fetch all world packages.
                std::vector<InstalledPackage> GetAllInstalledPackages();                                                //!<Fetch all installed packages.
                std::vector<InstalledPackage> FindRedundantPackages();                                                  //!<Returns all the redundant packages.
                std::vector<InstalledPackage> ReverseDependencies(PackageVersion passedVersion);//!<Returns the reverse dependencies of passedVersion.

                std::vector<PackageUpgrade> GetWorldUpdates();  //!<Fetch all world updates.
                std::vector<PackageUpgrade> GetAllUpdates();    //!<Fetch all the updates on the system.
                
                std::vector<PMString> GetVirtualsProvided();            //!<Get all virtuals provided by installed packages.
                std::vector<PMString> FindRedundantSourceFiles();       //!<Finds source files not needed by anything installed.
                
        protected:
                void _FillDatabase(bool cacheFileSizes);        //!<Fill the PackageVersion and PackageName DB's.
                void _FillInstalledDatabase();                          //!<Fill the installed DB.
                
                bool _DependenciesArrange(std::vector<PackageVersion>& hayStack, PackageVersion dependency, PackageVersion mainPackage,DependencyStage stage);  //!<Adds dependency to hayStack based on the location of the dependent package, mainPackage.
                bool _FindRegExpMatch(std::vector<PMString> hayStack, PMString needle);                                                                                                                                                 //!<See if the needle matches any of the regular expressions in haystack.
                PMString PackageManager::_GetSlotFromPortageDB(PackageVersion version);                                                                                                                                                 //!<Return the slot from /var/db/pkg.
                PackageVersion _VirtualInList(std::vector<PackageVersion> list,PMString virtualString);                                                                                                                 //!<Returns the version that provides a virtual in the list.
                PackageVersion _FulfillDependency(Dependency dependency);                                                                                                                                                                               //!<Returns a PackageVersion to fulfill dependency
                
                PackageDatabase _packageNameDatabase;                   //!<Package Name DB.
                PackageVersionDatabase _packageVersionDatabase; //!<Package Version DB.
                InstalledDatabase _installedPackagesDatabase;   //!<Installed Packages DB.
                Keyword _acceptKeyword;                                                 //!<The Arch Keyword.
                PMString _useFlags;                                                             //!<Use flags.
                std::vector<Virtual> _virtuals;                                 //!<Virtuals.
                std::vector<PMString> _hardMaskedPackages;              //!<Hard masked packages regexps.
                std::vector<PMString> _unStablePackages;                //!<Unstable packages regexps.
                std::vector<PMString> _stablePackages;                  //!<Stable packages regexps.
};

#endif

---