[apt.git] / apt-pkg / cachefilter.h

// -*- mode: cpp; mode: fold -*-
// Description								/*{{{*/
/** \file cachefilter.h
   Collection of functor classes */
									/*}}}*/
#ifndef APT_CACHEFILTER_H
#define APT_CACHEFILTER_H
// Include Files							/*{{{*/
#include <apt-pkg/pkgcache.h>
#include <apt-pkg/cacheiterators.h>

#include <string>
#include <vector>

#include <regex.h>

class pkgCacheFile;
									/*}}}*/
namespace APT {
namespace CacheFilter {

class Matcher {
public:
   virtual bool operator() (pkgCache::PkgIterator const &/*Pkg*/) = 0;
   virtual bool operator() (pkgCache::GrpIterator const &/*Grp*/) = 0;
   virtual bool operator() (pkgCache::VerIterator const &/*Ver*/) = 0;
   virtual ~Matcher();
};

class PackageMatcher : public Matcher {
public:
   virtual bool operator() (pkgCache::PkgIterator const &Pkg) APT_OVERRIDE = 0;
   virtual bool operator() (pkgCache::VerIterator const &Ver) APT_OVERRIDE { return (*this)(Ver.ParentPkg()); }
   virtual bool operator() (pkgCache::GrpIterator const &/*Grp*/) APT_OVERRIDE { return false; }
   virtual ~PackageMatcher();
};

// Generica like True, False, NOT, AND, OR				/*{{{*/
class TrueMatcher : public Matcher {
public:
   virtual bool operator() (pkgCache::PkgIterator const &Pkg) APT_OVERRIDE;
   virtual bool operator() (pkgCache::GrpIterator const &Grp) APT_OVERRIDE;
   virtual bool operator() (pkgCache::VerIterator const &Ver) APT_OVERRIDE;
};

class FalseMatcher : public Matcher {
public:
   virtual bool operator() (pkgCache::PkgIterator const &Pkg) APT_OVERRIDE;
   virtual bool operator() (pkgCache::GrpIterator const &Grp) APT_OVERRIDE;
   virtual bool operator() (pkgCache::VerIterator const &Ver) APT_OVERRIDE;
};

class NOTMatcher : public Matcher {
   Matcher * const matcher;
public:
   explicit NOTMatcher(Matcher * const matcher);
   virtual bool operator() (pkgCache::PkgIterator const &Pkg) APT_OVERRIDE;
   virtual bool operator() (pkgCache::GrpIterator const &Grp) APT_OVERRIDE;
   virtual bool operator() (pkgCache::VerIterator const &Ver) APT_OVERRIDE;
   virtual ~NOTMatcher();
};

class ANDMatcher : public Matcher {
   std::vector<Matcher *> matchers;
public:
   // 5 ought to be enough for everybody… c++11 variadic templates would be nice
   ANDMatcher();
   explicit ANDMatcher(Matcher * const matcher1);
   ANDMatcher(Matcher * const matcher1, Matcher * const matcher2);
   ANDMatcher(Matcher * const matcher1, Matcher * const matcher2, Matcher * const matcher3);
   ANDMatcher(Matcher * const matcher1, Matcher * const matcher2, Matcher * const matcher3, Matcher * const matcher4);
   ANDMatcher(Matcher * const matcher1, Matcher * const matcher2, Matcher * const matcher3, Matcher * const matcher4, Matcher * const matcher5);
   ANDMatcher& AND(Matcher * const matcher);
   virtual bool operator() (pkgCache::PkgIterator const &Pkg) APT_OVERRIDE;
   virtual bool operator() (pkgCache::GrpIterator const &Grp) APT_OVERRIDE;
   virtual bool operator() (pkgCache::VerIterator const &Ver) APT_OVERRIDE;
   virtual ~ANDMatcher();
};
class ORMatcher : public Matcher {
   std::vector<Matcher *> matchers;
public:
   // 5 ought to be enough for everybody… c++11 variadic templates would be nice
   ORMatcher();
   explicit ORMatcher(Matcher * const matcher1);
   ORMatcher(Matcher * const matcher1, Matcher * const matcher2);
   ORMatcher(Matcher * const matcher1, Matcher * const matcher2, Matcher * const matcher3);
   ORMatcher(Matcher * const matcher1, Matcher * const matcher2, Matcher * const matcher3, Matcher * const matcher4);
   ORMatcher(Matcher * const matcher1, Matcher * const matcher2, Matcher * const matcher3, Matcher * const matcher4, Matcher * const matcher5);
   ORMatcher& OR(Matcher * const matcher);
   virtual bool operator() (pkgCache::PkgIterator const &Pkg) APT_OVERRIDE;
   virtual bool operator() (pkgCache::GrpIterator const &Grp) APT_OVERRIDE;
   virtual bool operator() (pkgCache::VerIterator const &Ver) APT_OVERRIDE;
   virtual ~ORMatcher();
};
									/*}}}*/
class PackageNameMatchesRegEx : public PackageMatcher {			/*{{{*/
	regex_t* pattern;
public:
	explicit PackageNameMatchesRegEx(std::string const &Pattern);
	virtual bool operator() (pkgCache::PkgIterator const &Pkg) APT_OVERRIDE;
	virtual bool operator() (pkgCache::GrpIterator const &Grp) APT_OVERRIDE;
	virtual ~PackageNameMatchesRegEx();
};
									/*}}}*/
class PackageNameMatchesFnmatch : public PackageMatcher {		/*{{{*/
	const std::string Pattern;
public:
	explicit PackageNameMatchesFnmatch(std::string const &Pattern);
	virtual bool operator() (pkgCache::PkgIterator const &Pkg) APT_OVERRIDE;
	virtual bool operator() (pkgCache::GrpIterator const &Grp) APT_OVERRIDE;
	virtual ~PackageNameMatchesFnmatch() {};
};
									/*}}}*/
class PackageArchitectureMatchesSpecification : public PackageMatcher {	/*{{{*/
/** \class PackageArchitectureMatchesSpecification
   \brief matching against architecture specification strings

   The strings are of the format <kernel>-<cpu> where either component,
   or the whole string, can be the wildcard "any" as defined in
   debian-policy §11.1 "Architecture specification strings".

   Examples: i386, mipsel, linux-any, any-amd64, any */
	std::string literal;
	std::string complete;
	bool isPattern;
public:
	/** \brief matching against architecture specification strings
	 *
	 * @param pattern is the architecture specification string
	 * @param isPattern defines if the given \b pattern is a
	 *        architecture specification pattern to match others against
	 *        or if it is the fixed string and matched against patterns
	 */
	PackageArchitectureMatchesSpecification(std::string const &pattern, bool const isPattern = true);
	bool operator() (char const * const &arch);
	virtual bool operator() (pkgCache::PkgIterator const &Pkg) APT_OVERRIDE;
	virtual ~PackageArchitectureMatchesSpecification();
};
									/*}}}*/
class PackageIsNewInstall : public PackageMatcher {			/*{{{*/
	pkgCacheFile * const Cache;
public:
	explicit PackageIsNewInstall(pkgCacheFile * const Cache);
	virtual bool operator() (pkgCache::PkgIterator const &Pkg) APT_OVERRIDE;
	virtual ~PackageIsNewInstall();
};
									/*}}}*/

}
}
#endif
Commit	Line	Data
9ba5aa3b DK	1	// -- mode: cpp; mode: fold --
	2	// Description /{{{/
	3	/** \file cachefilter.h
	4	Collection of functor classes */
	5	/}}}/
	6	#ifndef APT_CACHEFILTER_H
	7	#define APT_CACHEFILTER_H
	8	// Include Files /{{{/
	9	#include <apt-pkg/pkgcache.h>
453b82a3	10	#include <apt-pkg/cacheiterators.h>
9ba5aa3b DK	11
9ba5aa3b DK	12	#include <string>
3721cb01	13	#include <vector>
9ba5aa3b DK	14
9ba5aa3b DK	15	#include <regex.h>
3721cb01 DK	16
3721cb01 DK	17	class pkgCacheFile;
9ba5aa3b DK	18	/}}}/
	19	namespace APT {
	20	namespace CacheFilter {
b9179170	21
3721cb01 DK	22	class Matcher {
	23	public:
	24	virtual bool operator() (pkgCache::PkgIterator const &/Pkg/) = 0;
	25	virtual bool operator() (pkgCache::GrpIterator const &/Grp/) = 0;
	26	virtual bool operator() (pkgCache::VerIterator const &/Ver/) = 0;
	27	virtual ~Matcher();
b9179170 MV	28	};
b9179170 MV	29
3721cb01 DK	30	class PackageMatcher : public Matcher {
3721cb01 DK	31	public:
6d7122b5	32	virtual bool operator() (pkgCache::PkgIterator const &Pkg) APT_OVERRIDE = 0;
3b302846 DK	33	virtual bool operator() (pkgCache::VerIterator const &Ver) APT_OVERRIDE { return (*this)(Ver.ParentPkg()); }
3b302846 DK	34	virtual bool operator() (pkgCache::GrpIterator const &/Grp/) APT_OVERRIDE { return false; }
3721cb01 DK	35	virtual ~PackageMatcher();
	36	};
	37
	38	// Generica like True, False, NOT, AND, OR /{{{/
	39	class TrueMatcher : public Matcher {
	40	public:
3b302846 DK	41	virtual bool operator() (pkgCache::PkgIterator const &Pkg) APT_OVERRIDE;
	42	virtual bool operator() (pkgCache::GrpIterator const &Grp) APT_OVERRIDE;
	43	virtual bool operator() (pkgCache::VerIterator const &Ver) APT_OVERRIDE;
3721cb01 DK	44	};
	45
	46	class FalseMatcher : public Matcher {
	47	public:
3b302846 DK	48	virtual bool operator() (pkgCache::PkgIterator const &Pkg) APT_OVERRIDE;
	49	virtual bool operator() (pkgCache::GrpIterator const &Grp) APT_OVERRIDE;
	50	virtual bool operator() (pkgCache::VerIterator const &Ver) APT_OVERRIDE;
3721cb01 DK	51	};
	52
	53	class NOTMatcher : public Matcher {
	54	Matcher * const matcher;
	55	public:
e8afd168	56	explicit NOTMatcher(Matcher * const matcher);
3b302846 DK	57	virtual bool operator() (pkgCache::PkgIterator const &Pkg) APT_OVERRIDE;
	58	virtual bool operator() (pkgCache::GrpIterator const &Grp) APT_OVERRIDE;
	59	virtual bool operator() (pkgCache::VerIterator const &Ver) APT_OVERRIDE;
3721cb01 DK	60	virtual ~NOTMatcher();
	61	};
	62
	63	class ANDMatcher : public Matcher {
	64	std::vector<Matcher *> matchers;
	65	public:
	66	// 5 ought to be enough for everybody… c++11 variadic templates would be nice
	67	ANDMatcher();
e8afd168	68	explicit ANDMatcher(Matcher * const matcher1);
3721cb01 DK	69	ANDMatcher(Matcher * const matcher1, Matcher * const matcher2);
	70	ANDMatcher(Matcher * const matcher1, Matcher * const matcher2, Matcher * const matcher3);
	71	ANDMatcher(Matcher * const matcher1, Matcher * const matcher2, Matcher * const matcher3, Matcher * const matcher4);
	72	ANDMatcher(Matcher * const matcher1, Matcher * const matcher2, Matcher * const matcher3, Matcher * const matcher4, Matcher * const matcher5);
	73	ANDMatcher& AND(Matcher * const matcher);
3b302846 DK	74	virtual bool operator() (pkgCache::PkgIterator const &Pkg) APT_OVERRIDE;
	75	virtual bool operator() (pkgCache::GrpIterator const &Grp) APT_OVERRIDE;
	76	virtual bool operator() (pkgCache::VerIterator const &Ver) APT_OVERRIDE;
3721cb01 DK	77	virtual ~ANDMatcher();
	78	};
	79	class ORMatcher : public Matcher {
	80	std::vector<Matcher *> matchers;
	81	public:
	82	// 5 ought to be enough for everybody… c++11 variadic templates would be nice
	83	ORMatcher();
e8afd168	84	explicit ORMatcher(Matcher * const matcher1);
3721cb01 DK	85	ORMatcher(Matcher * const matcher1, Matcher * const matcher2);
	86	ORMatcher(Matcher * const matcher1, Matcher * const matcher2, Matcher * const matcher3);
	87	ORMatcher(Matcher * const matcher1, Matcher * const matcher2, Matcher * const matcher3, Matcher * const matcher4);
	88	ORMatcher(Matcher * const matcher1, Matcher * const matcher2, Matcher * const matcher3, Matcher * const matcher4, Matcher * const matcher5);
	89	ORMatcher& OR(Matcher * const matcher);
3b302846 DK	90	virtual bool operator() (pkgCache::PkgIterator const &Pkg) APT_OVERRIDE;
	91	virtual bool operator() (pkgCache::GrpIterator const &Grp) APT_OVERRIDE;
	92	virtual bool operator() (pkgCache::VerIterator const &Ver) APT_OVERRIDE;
3721cb01 DK	93	virtual ~ORMatcher();
	94	};
	95	/}}}/
	96	class PackageNameMatchesRegEx : public PackageMatcher { /{{{/
9ba5aa3b DK	97	regex_t* pattern;
9ba5aa3b DK	98	public:
e8afd168	99	explicit PackageNameMatchesRegEx(std::string const &Pattern);
3b302846 DK	100	virtual bool operator() (pkgCache::PkgIterator const &Pkg) APT_OVERRIDE;
3b302846 DK	101	virtual bool operator() (pkgCache::GrpIterator const &Grp) APT_OVERRIDE;
314a3f88	102	virtual ~PackageNameMatchesRegEx();
9ba5aa3b DK	103	};
9ba5aa3b DK	104	/}}}/
3721cb01 DK	105	class PackageNameMatchesFnmatch : public PackageMatcher { /{{{/
3721cb01 DK	106	const std::string Pattern;
b9179170	107	public:
e8afd168	108	explicit PackageNameMatchesFnmatch(std::string const &Pattern);
3b302846 DK	109	virtual bool operator() (pkgCache::PkgIterator const &Pkg) APT_OVERRIDE;
3b302846 DK	110	virtual bool operator() (pkgCache::GrpIterator const &Grp) APT_OVERRIDE;
314a3f88	111	virtual ~PackageNameMatchesFnmatch() {};
b9179170 MV	112	};
b9179170 MV	113	/}}}/
3721cb01	114	class PackageArchitectureMatchesSpecification : public PackageMatcher { /{{{/
424ff669 DK	115	/** \class PackageArchitectureMatchesSpecification
	116	\brief matching against architecture specification strings
	117
	118	The strings are of the format <kernel>-<cpu> where either component,
	119	or the whole string, can be the wildcard "any" as defined in
	120	debian-policy §11.1 "Architecture specification strings".
	121
	122	Examples: i386, mipsel, linux-any, any-amd64, any */
424ff669 DK	123	std::string literal;
	124	std::string complete;
	125	bool isPattern;
424ff669 DK	126	public:
	127	/** \brief matching against architecture specification strings
	128	*
	129	* @param pattern is the architecture specification string
	130	* @param isPattern defines if the given \b pattern is a
	131	* architecture specification pattern to match others against
	132	* or if it is the fixed string and matched against patterns
	133	*/
	134	PackageArchitectureMatchesSpecification(std::string const &pattern, bool const isPattern = true);
	135	bool operator() (char const * const &arch);
3b302846	136	virtual bool operator() (pkgCache::PkgIterator const &Pkg) APT_OVERRIDE;
314a3f88	137	virtual ~PackageArchitectureMatchesSpecification();
424ff669 DK	138	};
424ff669 DK	139	/}}}/
3721cb01 DK	140	class PackageIsNewInstall : public PackageMatcher { /{{{/
	141	pkgCacheFile * const Cache;
	142	public:
e8afd168	143	explicit PackageIsNewInstall(pkgCacheFile * const Cache);
3b302846	144	virtual bool operator() (pkgCache::PkgIterator const &Pkg) APT_OVERRIDE;
3721cb01 DK	145	virtual ~PackageIsNewInstall();
	146	};
	147	/}}}/
	148
9ba5aa3b DK	149	}
	150	}
	151	#endif