apt  2.2.4
About: Apt (Advanced Package Tool) is a management system for software packages (Debian/Ubuntu). Release series 2.2.
  Fossies Dox: apt-2.2.4.tar.gz  ("unofficial" and yet experimental doxygen-generated source code documentation)  

aptconfiguration.h
Go to the documentation of this file.
1 // -*- mode: cpp; mode: fold -*-
2 // Description /*{{{*/
3 /** \class APT::Configuration
4  * \brief Provide access methods to various configuration settings
5  *
6  * This class and their methods providing a layer around the usual access
7  * methods with _config to ensure that settings are correct and to be able
8  * to set defaults without the need to recheck it in every method again.
9  */
10  /*}}}*/
11 #ifndef APT_CONFIGURATION_H
12 #define APT_CONFIGURATION_H
13 // Include Files /*{{{*/
14 #include <apt-pkg/macros.h>
15 #include <limits>
16 #include <string>
17 #include <vector>
18  /*}}}*/
19 namespace APT {
20 namespace Configuration { /*{{{*/
21  /** \brief Returns a vector of usable Compression Types
22  *
23  * Files can be compressed in various ways to decrease the size of the
24  * download. Therefore the Acquiremethods support a few compression types
25  * and some archives provide also a few different types. This option
26  * group exists to give the user the choice to prefer one type over the
27  * other (some compression types are very resource intensive - great if you
28  * have a limited download, bad if you have a really lowpowered hardware.)
29  *
30  * This method ensures that the defaults are set and checks at runtime
31  * if the type can be used. E.g. the current default is to prefer bzip2
32  * over lzma and gz - if the bzip2 binary is not available it has not much
33  * sense in downloading the bz2 file, therefore we will not return bz2 as
34  * a usable compression type. The availability is checked with the settings
35  * in the Dir::Bin group.
36  *
37  * \param Cached saves the result so we need to calculated it only once
38  * this parameter should only be used for testing purposes.
39  *
40  * \return a vector of the compression types in the preferred usage order
41  */
42  APT_PUBLIC std::vector<std::string> const getCompressionTypes(bool const &Cached = true);
43 
44  /** \brief Returns a vector of Language Codes
45  *
46  * Languages can be defined with their two or five chars long code.
47  * This methods handles the various ways to set the preferred codes,
48  * honors the environment and ensures that the codes are not listed twice.
49  *
50  * The special word "environment" will be replaced with the long and the short
51  * code of the local settings and it will be insured that this will not add
52  * duplicates. So in an german local the setting "environment, de_DE, en, de"
53  * will result in "de_DE, de, en".
54  *
55  * Another special word is "none" which separates the preferred from all codes
56  * in this setting. So setting and method can be used to get codes the user want
57  * to see or to get all language codes APT (should) have Translations available.
58  *
59  * \param All return all codes or only codes for languages we want to use
60  * \param Cached saves the result so we need to calculated it only once
61  * this parameter should only be used for testing purposes.
62  * \param Locale don't get the locale from the system but use this one instead
63  * this parameter should only be used for testing purposes.
64  *
65  * \return a vector of (all) Language Codes in the preferred usage order
66  */
67  APT_PUBLIC std::vector<std::string> const getLanguages(bool const &All = false,
68  bool const &Cached = true, char const ** const Locale = 0);
69 
70  /** \brief Are we interested in the given Language?
71  *
72  * \param Lang is the language we want to check
73  * \param All defines if we check against all codes or only against used codes
74  * \return true if we are interested, false otherwise
75  */
76  APT_PUBLIC bool checkLanguage(std::string Lang, bool const All = false);
77 
78  /** \brief Returns a vector of Architectures we support
79  *
80  * \param Cached saves the result so we need to calculated it only once
81  * this parameter should only be used for testing purposes.
82  *
83  * \return a vector of Architectures in preferred order
84  */
85  APT_PUBLIC std::vector<std::string> const getArchitectures(bool const &Cached = true);
86 
87  /** \brief Are we interested in the given Architecture?
88  *
89  * \param Arch we want to check
90  * \return true if we are interested, false otherwise
91  */
92  APT_PUBLIC bool checkArchitecture(std::string const &Arch);
93 
94  /** \brief Representation of supported compressors */
96  std::string Name;
97  std::string Extension;
98  std::string Binary;
99  std::vector<std::string> CompressArgs;
100  std::vector<std::string> UncompressArgs;
101  unsigned short Cost;
102 
103  Compressor(char const *name, char const *extension, char const *binary,
104  char const *compressArg, char const *uncompressArg,
105  unsigned short const cost);
106  Compressor() : Cost(std::numeric_limits<unsigned short>::max()) {};
107  };
108 
109  /** \brief Return a vector of Compressors supported for data.tar's
110  *
111  * \param Cached saves the result so we need to calculated it only once
112  * this parameter should only be used for testing purposes.
113  *
114  * \return a vector of Compressors
115  */
116  APT_PUBLIC std::vector<Compressor> const getCompressors(bool const Cached = true);
117 
118  /** \brief Return a vector of extensions supported for data.tar's */
119  APT_PUBLIC std::vector<std::string> const getCompressorExtensions();
120 
121  /** \return Return a vector of enabled build profile specifications */
122  APT_PUBLIC std::vector<std::string> const getBuildProfiles();
123  /** \return Return a comma-separated list of enabled build profile specifications */
124  APT_PUBLIC std::string const getBuildProfilesString();
125 
126  std::string const getMachineID();
127 
128  /** \return Whether we are running in a chroot */
129  bool isChroot();
130  /*}}}*/
131 }
132  /*}}}*/
133 }
134 #endif
#define APT_PUBLIC
Definition: macros.h:77
std::string const getMachineID()
APT_PUBLIC bool checkLanguage(std::string Lang, bool const All=false)
Are we interested in the given Language?
APT_PUBLIC std::vector< std::string > const getArchitectures(bool const &Cached=true)
Returns a vector of Architectures we support.
APT_PUBLIC std::string const getBuildProfilesString()
APT_PUBLIC std::vector< std::string > const getCompressorExtensions()
Return a vector of extensions supported for data.tar's.
APT_PUBLIC std::vector< std::string > const getCompressionTypes(bool const &Cached=true)
Returns a vector of usable Compression Types.
APT_PUBLIC std::vector< Compressor > const getCompressors(bool const Cached=true)
Return a vector of Compressors supported for data.tar's.
APT_PUBLIC bool checkArchitecture(std::string const &Arch)
Are we interested in the given Architecture?
APT_PUBLIC std::vector< std::string > const getLanguages(bool const &All=false, bool const &Cached=true, char const **const Locale=0)
Returns a vector of Language Codes.
APT_PUBLIC std::vector< std::string > const getBuildProfiles()
Representation of supported compressors.
std::vector< std::string > CompressArgs
std::vector< std::string > UncompressArgs