dependency.h

Go to the documentation of this file.

/*!\file dependency.h
        \brief Declerations for the calculations of Dependencies.
        Should be included wherever dependencies are used.*/

#ifndef __DEPENDENCY_H__
#define __DEPENDENCY_H__

#include "pmstring.h"
#include "packageversion.h"
#include <vector>

//!Small class used as bitmask for dependency flags.
/*!Used as a bitmask to set various flags about a particular DependentPackage.
   Should only really be needed by DependentPackage class.*/
class DependType
{
        public:
                DependType();                   //!<Constructor.
                void Reset();                   //!<Reset All the flags to eDisable.
        
                long EqualTo : 2;               //!<DependentPackage is equal to a particular version.
                long NewerThan : 2;             //!<DependentPackage has to be newer than this version.
                long OlderThan : 2;             //!<DependentPackage has to be older than this version.
                long Blocker : 2;               //!<DependentPackage is not allowed to be installed.
                long StartsWith : 2;    //!<DependentPackage starts with the version - i.e. 1.2 matches 1.2.2 here.
                long AnyRevision : 2;   //!<Any portage revision of a DependentPackage.
};

/*!Enum to set the above flags.*/
enum DependencyTypeStatus
{
        eDisable = 0,   //!<Disable the flag.
        eEnable                 //!<Enable the flag.
};

/*!Enum to say what kind of dependency a dependency is.*/
enum DependencyStage
{
        eCompile = 0,   //!<Needs to be installed before compile.
        eRun,                   //!<Needs to be instlled before running.
        ePost                   //!<Needs to be installed AFTER the package is installed.
};

//!Class to encapsulate the smaller dependency atoms.
/*!A dependent package details the string used to describe a package,
  and also the flags used to describe the dependency. Used to describe all
  the atoms except the || dependency. We have multiple dependent packages
  to deal with that.*/
class DependentPackage
{
        public:
                DependentPackage(PMString dependency);          //!<Constructor that processes the normal portage syntax.
                
                bool operator== (DependentPackage param);                                                               //!<Checks for equality between DependentPackage.
                bool operator!= (DependentPackage param);                                                               //!<Checks for non-equality between DependentPackage.
                bool AtomExamine(PMString category, PMString name, PMString version);   //!<Checks to see if the strings satisfy a dependency.
                
                PMString package;               //!<The string detailing the package that the dependency involves.
                DependType dependType;  //!<The flags regarding the dependency.
};

//!A Dependency encapsulates all the depedency atoms.
/*!A Dependency is the class that wraps the traditionally thought of dependency.
  Details all of portage's dependencys, including || ( or ) dependencies and
  all other forms of dependency. Its worth noting that std::vector<DependentPackage> packages
  can only contain multiple DependentPackage's if an || dependency is used.*/
class Dependency
{
        public:
                Dependency();                                                                                                   //!<Default Constructor.
                Dependency(DependencyStage passedStage);                                                //!<Constructor to set the stage.
                Dependency(PMString dependency, DependencyStage passedStage);   //!<Create the dependency using the traditional portage string.
        
                bool operator== (Dependency param);                                     //!<The equality operator.
                bool operator!= (Dependency param);                                     //!<The non equality operator.
                void AddDependency(PMString dependency);                        //!<Populate the packages with the dependencies detailed in dependency.
                void ClearDependencies();                                                       //!<Clear all DependentPackage's.
                bool SatisfyDependency(PackageVersion version);         //!<Check if the version satisfies the dependency.
                bool SatisfyDependency(PMString packageString);         //!<Check if the package string satisfies the dependency.
                
                std::vector<DependentPackage> packages; //!<Only contains multiple packages for ||.
                DependencyStage stage;                                  //!<The stage the dependency has to be installed by.
};

//!Encapsulates ALL of the dependencies of a particular PackageVersion.
/*!Encapsulates ALL of the dependencies of a particular PackageVersion. Does
   this by having a vector of dependencies. Encapsulates all three types of
   dependencies also, compile, run and post time.*/
class PackageVersionDependencies
{
        public:
                PackageVersionDependencies(std::vector<PMString> useFlags);                                                                                                     //!<Constructor.
                PackageVersionDependencies(PMString compile, PMString run, PMString post,std::vector<PMString> useFlags);       //!<Construct and Add passed dependencies.
                PackageVersionDependencies(PackageVersion version,std::vector<PMString> useFlags);                                                      //!<Construct and Add version's dependencies.
                ~PackageVersionDependencies();                                                                                                                                                          //!<Destructor.
        
                bool DependenciesMet(std::vector<PackageVersion> versions);             //!<Do versions meet the dependencies?.
                void AddDependencies(PMString depends,DependencyStage stage);   //!<Add the dependencies given.
                void SetFlags(std::vector<PMString> useFlags);                                  //!<Set _useFlags.
                void AddFlag(PMString flag);                                                                    //!<Add a useFlag.
        
                std::vector<Dependency> dependencies;   //!<The dependencies.
        
        protected:
                std::vector<PMString> _useFlags;                                        //!<The useFlags.
                void _AddDependency(Dependency depend);                         //!<Add the dependency, dont allow duplicates.
                std::vector<PMString>::iterator _BypassBrackets(std::vector<PMString>::iterator currentLocation,std::vector<PMString>::iterator endLocation);
                                                                                                                        //!<Return an iterator to where we have gone out of the selected bracket.
};

#endif

---