{
unsigned int I = sizeof(Head.Name) - 1;
for (; Head.Name[I] == ' ' || Head.Name[I] == '/'; I--);
- Memb->Name = string(Head.Name,I+1);
+ Memb->Name = std::string(Head.Name,I+1);
}
// Account for the AR header alignment
struct ARArchive::Member
{
// Fields from the header
- string Name;
+ std::string Name;
unsigned long MTime;
unsigned long UID;
unsigned long GID;
#include <algorithm>
-using std::min;
-
class ExtractTar
{
protected:
int GZPid;
FileFd InFd;
bool Eof;
- string DecompressProg;
+ std::string DecompressProg;
// Fork and reap gzip
bool StartGzip();
bool Go(pkgDirStream &Stream);
- ExtractTar(FileFd &Fd,unsigned long Max,string DecompressionProgram);
+ ExtractTar(FileFd &Fd,unsigned long Max,std::string DecompressionProgram);
virtual ~ExtractTar();
};
// ---------------------------------------------------------------------
/* This re-initializes the meta temporary directory if it hasn't yet
been inited for this cycle. The flag is the emptyness of MetaDir */
-bool pkgDataBase::GetMetaTmp(string &Dir)
+bool pkgDataBase::GetMetaTmp(std::string &Dir)
{
if (MetaDir.empty() == true)
if (InitMetaTmp(MetaDir) == false)
pkgCacheGenerator *Cache;
pkgFLCache *FList;
- string MetaDir;
- virtual bool InitMetaTmp(string &Dir) = 0;
+ std::string MetaDir;
+ virtual bool InitMetaTmp(std::string &Dir) = 0;
public:
inline pkgFLCache &GetFLCache() {return *FList;};
inline pkgCacheGenerator &GetGenerator() {return *Cache;};
- bool GetMetaTmp(string &Dir);
+ bool GetMetaTmp(std::string &Dir);
virtual bool ReadyFileList(OpProgress &Progress) = 0;
virtual bool ReadyPkgCache(OpProgress &Progress) = 0;
virtual bool LoadChanges() = 0;
return false;
// Get into the temporary directory
- string Cwd = SafeGetCWD();
- string Tmp;
+ std::string Cwd = SafeGetCWD();
+ std::string Tmp;
if (DB.GetMetaTmp(Tmp) == false)
return false;
if (chdir(Tmp.c_str()) != 0)
pkgCache::VerIterator debDebFile::MergeControl(pkgDataBase &DB)
{
// Open the control file
- string Tmp;
+ std::string Tmp;
if (DB.GetMetaTmp(Tmp) == false)
return pkgCache::VerIterator(DB.GetCache());
FileFd Fd(Tmp + "control",FileFd::ReadOnly);
char *Control;
pkgTagSection Section;
unsigned long Length;
- string Member;
+ std::string Member;
// Members from DirStream
virtual bool DoItem(Item &Itm,int &Fd);
bool TakeControl(const void *Data,unsigned long Size);
MemControlExtract() : IsControl(false), Control(0), Length(0), Member("control") {};
- MemControlExtract(string Member) : IsControl(false), Control(0), Length(0), Member(Member) {};
+ MemControlExtract(std::string Member) : IsControl(false), Control(0), Length(0), Member(Member) {};
~MemControlExtract() {delete [] Control;};
};
/*}}}*/
class debDpkgDB : public pkgDataBase
{
protected:
-
- string AdminDir;
+
+ std::string AdminDir;
DynamicMMap *CacheMap;
DynamicMMap *FileMap;
unsigned long DiverInode;
signed long DiverTime;
-
- virtual bool InitMetaTmp(string &Dir);
+
+ virtual bool InitMetaTmp(std::string &Dir);
bool ReadFList(OpProgress &Progress);
bool ReadDiversions();
bool ReadConfFiles();
bool HandleOverwrites(pkgFLCache::NodeIterator Nde,
bool DiverCheck = false);
- bool CheckDirReplace(string Dir,unsigned int Depth = 0);
+ bool CheckDirReplace(std::string Dir,unsigned int Depth = 0);
public:
class DiverIterator;
protected:
- string CacheFile;
+ std::string CacheFile;
DynamicMMap ⤅
map_ptrloc LastTreeLookup;
unsigned long LastLookupSize;
{
FetchItem *Next;
- string Uri;
- string DestFile;
+ std::string Uri;
+ std::string DestFile;
time_t LastModified;
bool IndexFile;
bool FailIgnore;
struct FetchResult
{
- string MD5Sum;
- string SHA1Sum;
- string SHA256Sum;
- string SHA512Sum;
- vector<string> GPGVOutput;
+ std::string MD5Sum;
+ std::string SHA1Sum;
+ std::string SHA256Sum;
+ std::string SHA512Sum;
+ std::vector<std::string> GPGVOutput;
time_t LastModified;
bool IMSHit;
- string Filename;
+ std::string Filename;
unsigned long long Size;
unsigned long long ResumePoint;
};
// State
- vector<string> Messages;
+ std::vector<std::string> Messages;
FetchItem *Queue;
FetchItem *QueueBack;
- string FailReason;
- string UsedMirror;
- string IP;
+ std::string FailReason;
+ std::string UsedMirror;
+ std::string IP;
// Handlers for messages
- virtual bool Configuration(string Message);
+ virtual bool Configuration(std::string Message);
virtual bool Fetch(FetchItem * /*Item*/) {return true;};
// Outgoing messages
void Fail(bool Transient = false);
- inline void Fail(const char *Why, bool Transient = false) {Fail(string(Why),Transient);};
- virtual void Fail(string Why, bool Transient = false);
+ inline void Fail(const char *Why, bool Transient = false) {Fail(std::string(Why),Transient);};
+ virtual void Fail(std::string Why, bool Transient = false);
virtual void URIStart(FetchResult &Res);
virtual void URIDone(FetchResult &Res,FetchResult *Alt = 0);
- bool MediaFail(string Required,string Drive);
+ bool MediaFail(std::string Required,std::string Drive);
virtual void Exit() {};
void PrintStatus(char const * const header, const char* Format, va_list &args) const;
void Log(const char *Format,...);
void Status(const char *Format,...);
- void Redirect(const string &NewURI);
+ void Redirect(const std::string &NewURI);
int Run(bool Single = false);
- inline void SetFailReason(string Msg) {FailReason = Msg;};
- inline void SetIP(string aIP) {IP = aIP;};
+ inline void SetFailReason(std::string Msg) {FailReason = Msg;};
+ inline void SetIP(std::string aIP) {IP = aIP;};
pkgAcqMethod(const char *Ver,unsigned long Flags = 0);
virtual ~pkgAcqMethod() {};
*
* \todo Doesn't this duplicate Config->Access?
*/
- string Access;
+ std::string Access;
/** \brief The PID of the subprocess. */
pid_t Process;
/** \brief The raw text values of messages received from the
* worker, in sequence.
*/
- vector<string> MessageQueue;
+ std::vector<std::string> MessageQueue;
/** \brief Buffers pending writes to the subprocess.
*
* \todo Wouldn't a std::dequeue be more appropriate?
*/
- string OutQueue;
+ std::string OutQueue;
/** \brief Common code for the constructor.
*
*
* \return \b true.
*/
- bool Capabilities(string Message);
+ bool Capabilities(std::string Message);
/** \brief Send a 601 Configuration message (containing the APT
* configuration) to the subprocess.
* 603 Media Changed, with the Failed field set to \b true if the
* user cancelled the media change).
*/
- bool MediaChange(string Message);
+ bool MediaChange(std::string Message);
/** \brief Invoked when the worked process dies unexpectedly.
*
/** \brief The most recent status string received from the
* subprocess.
*/
- string Status;
+ std::string Status;
/** \brief How many bytes of the file have been downloaded. Zero
* if the current progress of the file cannot be determined.
#include <vector>
#include <string>
-using std::vector;
-using std::string;
-
-
#include <sys/time.h>
#include <unistd.h>
friend class Item;
friend class Queue;
- typedef vector<Item *>::iterator ItemIterator;
- typedef vector<Item *>::const_iterator ItemCIterator;
+ typedef std::vector<Item *>::iterator ItemIterator;
+ typedef std::vector<Item *>::const_iterator ItemCIterator;
protected:
* This is built monotonically as items are created and only
* emptied when the download shuts down.
*/
- vector<Item *> Items;
+ std::vector<Item *> Items;
/** \brief The head of the list of active queues.
*
* \return the string-name of the queue in which a fetch request
* for the given URI should be placed.
*/
- string QueueName(string URI,MethodConfig const *&Config);
+ std::string QueueName(std::string URI,MethodConfig const *&Config);
/** \brief Build up the set of file descriptors upon which select() should
* block.
*
* \return the method whose name is Access, or \b NULL if no such method exists.
*/
- MethodConfig *GetConfig(string Access);
+ MethodConfig *GetConfig(std::string Access);
/** \brief Provides information on how a download terminated. */
enum RunResult {
*
* \return \b true if the directory exists and is readable.
*/
- bool Clean(string Dir);
+ bool Clean(std::string Dir);
/** \return the total size in bytes of all the items included in
* this download.
* only one Acquire class is in action at the time or an empty string
* if no lock file should be used.
*/
- bool Setup(pkgAcquireStatus *Progress = NULL, string const &Lock = "");
+ bool Setup(pkgAcquireStatus *Progress = NULL, std::string const &Lock = "");
void SetLog(pkgAcquireStatus *Progress) { Log = Progress; }
struct pkgAcquire::ItemDesc : public WeakPointable
{
/** \brief The URI from which to download this item. */
- string URI;
+ std::string URI;
/** brief A description of this item. */
- string Description;
+ std::string Description;
/** brief A shorter description of this item. */
- string ShortDesc;
+ std::string ShortDesc;
/** brief The underlying item which is to be downloaded. */
Item *Owner;
};
};
/** \brief The name of this queue. */
- string Name;
+ std::string Name;
/** \brief The head of the list of items contained in this queue.
*
* \return the first item in the queue whose URI is #URI and that
* is being downloaded by #Owner.
*/
- QItem *FindItem(string URI,pkgAcquire::Worker *Owner);
+ QItem *FindItem(std::string URI,pkgAcquire::Worker *Owner);
/** Presumably this should start downloading an item?
*
* \param Name The name of the new queue.
* \param Owner The download process that owns the new queue.
*/
- Queue(string Name,pkgAcquire *Owner);
+ Queue(std::string Name,pkgAcquire *Owner);
/** Shut down all the worker processes associated with this queue
* and empty the queue.
MethodConfig *Next;
/** \brief The name of this acquire method (e.g., http). */
- string Access;
+ std::string Access;
/** \brief The implementation version of this acquire method. */
- string Version;
+ std::string Version;
/** \brief If \b true, only one download queue should be created for this
* method.
* \todo This is a horrible blocking monster; it should be CPSed
* with prejudice.
*/
- virtual bool MediaChange(string Media,string Drive) = 0;
+ virtual bool MediaChange(std::string Media,std::string Drive) = 0;
/** \brief Invoked when an item is confirmed to be up-to-date.
#include <iostream>
-using std::ostream;
-
class pkgSimulate : public pkgPackageManager /*{{{*/
{
protected:
pkgDepCache::ActionGroup group;
// The Actuall installation implementation
- virtual bool Install(PkgIterator Pkg,string File);
+ virtual bool Install(PkgIterator Pkg,std::string File);
virtual bool Configure(PkgIterator Pkg);
virtual bool Remove(PkgIterator Pkg,bool Purge);
private:
void ShortBreaks();
- void Describe(PkgIterator iPkg,ostream &out,bool Current,bool Candidate);
+ void Describe(PkgIterator iPkg,std::ostream &out,bool Current,bool Candidate);
public:
if ((*o).empty() == true)
continue;
// ignore types we have no method ready to use
- if (_config->Exists(string("Acquire::CompressionTypes::").append(*o)) == false)
+ if (_config->Exists(std::string("Acquire::CompressionTypes::").append(*o)) == false)
continue;
// ignore types we have no app ready to use
- string const appsetting = string("Dir::Bin::").append(*o);
+ std::string const appsetting = std::string("Dir::Bin::").append(*o);
if (_config->Exists(appsetting) == true) {
std::string const app = _config->FindFile(appsetting.c_str(), "");
if (app.empty() == false && FileExists(app) == false)
if (std::find(types.begin(),types.end(),Types->Tag) != types.end())
continue;
// ignore types we have no app ready to use
- string const appsetting = string("Dir::Bin::").append(Types->Value);
+ std::string const appsetting = std::string("Dir::Bin::").append(Types->Value);
if (appsetting.empty() == false && _config->Exists(appsetting) == true) {
std::string const app = _config->FindFile(appsetting.c_str(), "");
if (app.empty() == false && FileExists(app) == false)
// add the special "uncompressed" type
if (std::find(types.begin(), types.end(), "uncompressed") == types.end())
{
- string const uncompr = _config->FindFile("Dir::Bin::uncompressed", "");
+ std::string const uncompr = _config->FindFile("Dir::Bin::uncompressed", "");
if (uncompr.empty() == true || FileExists(uncompr) == true)
types.push_back("uncompressed");
}
char const *binary,
char const *compressArg, char const *uncompressArg,
unsigned short const cost) {
- std::string const config = string("APT:Compressor::").append(name).append("::");
+ std::string const config = std::string("APT:Compressor::").append(name).append("::");
Name = _config->Find(std::string(config).append("Name"), name);
Extension = _config->Find(std::string(config).append("Extension"), extension);
Binary = _config->Find(std::string(config).append("Binary"), binary);
inline const char *Name() const {return S->Name == 0?0:Owner->StrP + S->Name;};
inline PkgIterator PackageList() const;
- PkgIterator FindPkg(string Arch = "any") const;
+ PkgIterator FindPkg(std::string Arch = "any") const;
/** \brief find the package with the "best" architecture
The best architecture is either the "native" or the first
inline VerFileIterator FileList() const;
bool Downloadable() const;
inline const char *PriorityType() const {return Owner->Priority(S->Priority);};
- string RelStr() const;
+ std::string RelStr() const;
bool Automatic() const;
VerFileIterator NewestFile() const;
inline const char *IndexType() const {return S->IndexType == 0?0:Owner->StrP + S->IndexType;};
bool IsOk();
- string RelStr();
+ std::string RelStr();
// Constructors
inline PkgFileIterator() : Iterator<PackageFile, PkgFileIterator>() {};
#include<vector>
-using namespace std;
-
class pkgCdromStatus /*{{{*/
{
protected:
// total steps
virtual void SetTotal(int total) { totalSteps = total; };
// update steps, will be called regularly as a "pulse"
- virtual void Update(string text="", int current=0) = 0;
+ virtual void Update(std::string text="", int current=0) = 0;
// ask for cdrom insert
virtual bool ChangeCdrom() = 0;
// ask for cdrom name
- virtual bool AskCdromName(string &Name) = 0;
+ virtual bool AskCdromName(std::string &Name) = 0;
// Progress indicator for the Index rewriter
virtual OpProgress* GetOpProgress() {return NULL; };
};
};
- bool FindPackages(string CD,
- vector<string> &List,
- vector<string> &SList,
- vector<string> &SigList,
- vector<string> &TransList,
- string &InfoDir, pkgCdromStatus *log,
+ bool FindPackages(std::string CD,
+ std::vector<std::string> &List,
+ std::vector<std::string> &SList,
+ std::vector<std::string> &SigList,
+ std::vector<std::string> &TransList,
+ std::string &InfoDir, pkgCdromStatus *log,
unsigned int Depth = 0);
- bool DropBinaryArch(vector<string> &List);
- bool DropRepeats(vector<string> &List,const char *Name);
- void ReduceSourcelist(string CD,vector<string> &List);
+ bool DropBinaryArch(std::vector<std::string> &List);
+ bool DropRepeats(std::vector<std::string> &List,const char *Name);
+ void ReduceSourcelist(std::string CD,std::vector<std::string> &List);
bool WriteDatabase(Configuration &Cnf);
- bool WriteSourceList(string Name,vector<string> &List,bool Source);
- int Score(string Path);
+ bool WriteSourceList(std::string Name,std::vector<std::string> &List,bool Source);
+ int Score(std::string Path);
public:
- bool Ident(string &ident, pkgCdromStatus *log);
+ bool Ident(std::string &ident, pkgCdromStatus *log);
bool Add(pkgCdromStatus *log);
};
/*}}}*/
// class that uses libudev to find cdrom/removable devices dynamically
struct CdromDevice /*{{{*/
{
- string DeviceName;
+ std::string DeviceName;
bool Mounted;
- string MountPath;
+ std::string MountPath;
};
/*}}}*/
class pkgUdevCdromDevices /*{{{*/
// convenience interface, this will just call ScanForRemovable
// with "APT::cdrom::CdromOnly"
- vector<CdromDevice> Scan();
+ std::vector<CdromDevice> Scan();
- vector<CdromDevice> ScanForRemovable(bool CdromOnly);
+ std::vector<CdromDevice> ScanForRemovable(bool CdromOnly);
};
/*}}}*/
// ---------------------------------------------------------------------
/* Scan the directory for files to erase, we check the version information
against our database to see if it is interesting */
-bool pkgArchiveCleaner::Go(string Dir,pkgCache &Cache)
+bool pkgArchiveCleaner::Go(std::string Dir,pkgCache &Cache)
{
bool CleanInstalled = _config->FindB("APT::Clean-Installed",true);
if (D == 0)
return _error->Errno("opendir",_("Unable to read %s"),Dir.c_str());
- string StartDir = SafeGetCWD();
+ std::string StartDir = SafeGetCWD();
if (chdir(Dir.c_str()) != 0)
{
closedir(D);
for (; *I != 0 && *I != '_';I++);
if (*I != '_')
continue;
- string Pkg = DeQuoteString(string(Dir->d_name,I-Dir->d_name));
+ std::string Pkg = DeQuoteString(std::string(Dir->d_name,I-Dir->d_name));
// Grab the version
const char *Start = I + 1;
for (I = Start; *I != 0 && *I != '_';I++);
if (*I != '_')
continue;
- string Ver = DeQuoteString(string(Start,I-Start));
+ std::string Ver = DeQuoteString(std::string(Start,I-Start));
// Grab the arch
Start = I + 1;
for (I = Start; *I != 0 && *I != '.' ;I++);
if (*I != '.')
continue;
- string const Arch = DeQuoteString(string(Start,I-Start));
+ std::string const Arch = DeQuoteString(std::string(Start,I-Start));
if (APT::Configuration::checkArchitecture(Arch) == false)
continue;
protected:
- virtual void Erase(const char * /*File*/,string /*Pkg*/,string /*Ver*/,struct stat & /*St*/) {};
+ virtual void Erase(const char * /*File*/,std::string /*Pkg*/,std::string /*Ver*/,struct stat & /*St*/) {};
public:
- bool Go(string Dir,pkgCache &Cache);
+ bool Go(std::string Dir,pkgCache &Cache);
virtual ~pkgArchiveCleaner() {};
};
#include <apti18n.h>
/*}}}*/
+using std::string;
+
// IsMounted - Returns true if the mount point is mounted /*{{{*/
// ---------------------------------------------------------------------
/* This is a simple algorithm that should always work, we stat the mount point
#include <string>
-using std::string;
-
// mount cdrom, DeviceName (e.g. /dev/sr0) is optional
-bool MountCdrom(string Path, string DeviceName="");
-bool UnmountCdrom(string Path);
-bool IdentCdrom(string CD,string &Res,unsigned int Version = 2);
-bool IsMounted(string &Path);
-string FindMountPointForDevice(const char *device);
+bool MountCdrom(std::string Path, std::string DeviceName="");
+bool UnmountCdrom(std::string Path);
+bool IdentCdrom(std::string CD,std::string &Res,unsigned int Version = 2);
+bool IsMounted(std::string &Path);
+std::string FindMountPointForDevice(const char *device);
#endif
#include <vector>
#include <iostream>
-using std::string;
-
class Configuration
{
public:
struct Item
{
- string Value;
- string Tag;
+ std::string Value;
+ std::string Tag;
Item *Parent;
Item *Child;
Item *Next;
- string FullTag(const Item *Stop = 0) const;
+ std::string FullTag(const Item *Stop = 0) const;
Item() : Parent(0), Child(0), Next(0) {};
};
public:
- string Find(const char *Name,const char *Default = 0) const;
- string Find(string const &Name,const char *Default = 0) const {return Find(Name.c_str(),Default);};
- string Find(string const &Name, string const &Default) const {return Find(Name.c_str(),Default.c_str());};
- string FindFile(const char *Name,const char *Default = 0) const;
- string FindDir(const char *Name,const char *Default = 0) const;
- std::vector<string> FindVector(const char *Name) const;
- std::vector<string> FindVector(string const &Name) const { return FindVector(Name.c_str()); };
+ std::string Find(const char *Name,const char *Default = 0) const;
+ std::string Find(std::string const &Name,const char *Default = 0) const {return Find(Name.c_str(),Default);};
+ std::string Find(std::string const &Name, std::string const &Default) const {return Find(Name.c_str(),Default.c_str());};
+ std::string FindFile(const char *Name,const char *Default = 0) const;
+ std::string FindDir(const char *Name,const char *Default = 0) const;
+ std::vector<std::string> FindVector(const char *Name) const;
+ std::vector<std::string> FindVector(std::string const &Name) const { return FindVector(Name.c_str()); };
int FindI(const char *Name,int const &Default = 0) const;
- int FindI(string const &Name,int const &Default = 0) const {return FindI(Name.c_str(),Default);};
+ int FindI(std::string const &Name,int const &Default = 0) const {return FindI(Name.c_str(),Default);};
bool FindB(const char *Name,bool const &Default = false) const;
- bool FindB(string const &Name,bool const &Default = false) const {return FindB(Name.c_str(),Default);};
- string FindAny(const char *Name,const char *Default = 0) const;
+ bool FindB(std::string const &Name,bool const &Default = false) const {return FindB(Name.c_str(),Default);};
+ std::string FindAny(const char *Name,const char *Default = 0) const;
- inline void Set(const string &Name,const string &Value) {Set(Name.c_str(),Value);};
- void CndSet(const char *Name,const string &Value);
+ inline void Set(const std::string &Name,const std::string &Value) {Set(Name.c_str(),Value);};
+ void CndSet(const char *Name,const std::string &Value);
void CndSet(const char *Name,const int Value);
- void Set(const char *Name,const string &Value);
+ void Set(const char *Name,const std::string &Value);
void Set(const char *Name,const int &Value);
- inline bool Exists(const string &Name) const {return Exists(Name.c_str());};
+ inline bool Exists(const std::string &Name) const {return Exists(Name.c_str());};
bool Exists(const char *Name) const;
bool ExistsAny(const char *Name) const;
// clear a whole tree
- void Clear(const string &Name);
+ void Clear(const std::string &Name);
// remove a certain value from a list (e.g. the list of "APT::Keep-Fds")
- void Clear(string const &List, string const &Value);
- void Clear(string const &List, int const &Value);
+ void Clear(std::string const &List, std::string const &Value);
+ void Clear(std::string const &List, int const &Value);
inline const Item *Tree(const char *Name) const {return Lookup(Name);};
extern Configuration *_config;
-bool ReadConfigFile(Configuration &Conf,const string &FName,
+bool ReadConfigFile(Configuration &Conf,const std::string &FName,
bool const &AsSectional = false,
unsigned const &Depth = 0);
-bool ReadConfigDir(Configuration &Conf,const string &Dir,
+bool ReadConfigDir(Configuration &Conf,const std::string &Dir,
bool const &AsSectional = false,
unsigned const &Depth = 0);
/* Define this for python-apt */
#define APT_HAS_GZIP 1
-using std::string;
-
class FileFd
{
protected:
enum LocalFlags {AutoClose = (1<<0),Fail = (1<<1),DelOnFail = (1<<2),
HitEof = (1<<3), Replace = (1<<4) };
unsigned long Flags;
- string FileName;
- string TemporaryFileName;
+ std::string FileName;
+ std::string TemporaryFileName;
gzFile gz;
public:
return T;
}
- bool Open(string FileName,OpenMode Mode,unsigned long Perms = 0666);
+ bool Open(std::string FileName,OpenMode Mode,unsigned long Perms = 0666);
bool OpenDescriptor(int Fd, OpenMode Mode, bool AutoClose=false);
bool Close();
bool Sync();
inline void EraseOnFailure() {Flags |= DelOnFail;};
inline void OpFail() {Flags |= Fail;};
inline bool Eof() {return (Flags & HitEof) == HitEof;};
- inline string &Name() {return FileName;};
+ inline std::string &Name() {return FileName;};
- FileFd(string FileName,OpenMode Mode,unsigned long Perms = 0666) : iFd(-1),
+ FileFd(std::string FileName,OpenMode Mode,unsigned long Perms = 0666) : iFd(-1),
Flags(0), gz(NULL)
{
Open(FileName,Mode,Perms);
bool RunScripts(const char *Cnf);
bool CopyFile(FileFd &From,FileFd &To);
-int GetLock(string File,bool Errors = true);
-bool FileExists(string File);
-bool RealFileExists(string File);
-bool DirectoryExists(string const &Path) __attrib_const;
-bool CreateDirectory(string const &Parent, string const &Path);
-time_t GetModificationTime(string const &Path);
+int GetLock(std::string File,bool Errors = true);
+bool FileExists(std::string File);
+bool RealFileExists(std::string File);
+bool DirectoryExists(std::string const &Path) __attrib_const;
+bool CreateDirectory(std::string const &Parent, std::string const &Path);
+time_t GetModificationTime(std::string const &Path);
/** \brief Ensure the existence of the given Path
*
* /apt/ will be removed before CreateDirectory call.
* \param Path which should exist after (successful) call
*/
-bool CreateAPTDirectoryIfNeeded(string const &Parent, string const &Path);
+bool CreateAPTDirectoryIfNeeded(std::string const &Parent, std::string const &Path);
-std::vector<string> GetListOfFilesInDir(string const &Dir, string const &Ext,
+std::vector<std::string> GetListOfFilesInDir(std::string const &Dir, std::string const &Ext,
bool const &SortList, bool const &AllowNoExt=false);
-std::vector<string> GetListOfFilesInDir(string const &Dir, std::vector<string> const &Ext,
+std::vector<std::string> GetListOfFilesInDir(std::string const &Dir, std::vector<std::string> const &Ext,
bool const &SortList);
-string SafeGetCWD();
+std::string SafeGetCWD();
void SetCloseExec(int Fd,bool Close);
void SetNonBlock(int Fd,bool Block);
bool WaitFd(int Fd,bool write = false,unsigned long timeout = 0);
bool ExecWait(pid_t Pid,const char *Name,bool Reap = false);
// File string manipulators
-string flNotDir(string File);
-string flNotFile(string File);
-string flNoLink(string File);
-string flExtension(string File);
-string flCombine(string Dir,string File);
+std::string flNotDir(std::string File);
+std::string flNotFile(std::string File);
+std::string flNoLink(std::string File);
+std::string flExtension(std::string File);
+std::string flCombine(std::string Dir,std::string File);
#endif
{
}
-HashString::HashString(string Type, string Hash) : Type(Type), Hash(Hash)
+HashString::HashString(std::string Type, std::string Hash) : Type(Type), Hash(Hash)
{
}
-HashString::HashString(string StringedHash) /*{{{*/
+HashString::HashString(std::string StringedHash) /*{{{*/
{
// legacy: md5sum without "MD5Sum:" prefix
- if (StringedHash.find(":") == string::npos && StringedHash.size() == 32)
+ if (StringedHash.find(":") == std::string::npos && StringedHash.size() == 32)
{
Type = "MD5Sum";
Hash = StringedHash;
return;
}
- string::size_type pos = StringedHash.find(":");
+ std::string::size_type pos = StringedHash.find(":");
Type = StringedHash.substr(0,pos);
Hash = StringedHash.substr(pos+1, StringedHash.size() - pos);
std::clog << "HashString(string): " << Type << " : " << Hash << std::endl;
}
/*}}}*/
-bool HashString::VerifyFile(string filename) const /*{{{*/
+bool HashString::VerifyFile(std::string filename) const /*{{{*/
{
- string fileHash;
+ std::string fileHash;
FileFd Fd(filename, FileFd::ReadOnly);
if(Type == "MD5Sum")
{
MD5Summation MD5;
MD5.AddFD(Fd.Fd(), Fd.Size());
- fileHash = (string)MD5.Result();
+ fileHash = (std::string)MD5.Result();
}
else if (Type == "SHA1")
{
SHA1Summation SHA1;
SHA1.AddFD(Fd.Fd(), Fd.Size());
- fileHash = (string)SHA1.Result();
+ fileHash = (std::string)SHA1.Result();
}
else if (Type == "SHA256")
{
SHA256Summation SHA256;
SHA256.AddFD(Fd.Fd(), Fd.Size());
- fileHash = (string)SHA256.Result();
+ fileHash = (std::string)SHA256.Result();
}
else if (Type == "SHA512")
{
SHA512Summation SHA512;
SHA512.AddFD(Fd.Fd(), Fd.Size());
- fileHash = (string)SHA512.Result();
+ fileHash = (std::string)SHA512.Result();
}
Fd.Close();
return (Type.empty() || Hash.empty());
}
-string HashString::toStr() const
+std::string HashString::toStr() const
{
- return Type+string(":")+Hash;
+ return Type + std::string(":") + Hash;
}
// Hashes::AddFD - Add the contents of the FD /*{{{*/
while (Size != 0 || ToEOF)
{
unsigned long long n = sizeof(Buf);
- if (!ToEOF) n = min(Size, n);
+ if (!ToEOF) n = std::min(Size, n);
Res = read(Fd,Buf,n);
if (Res < 0 || (!ToEOF && Res != (ssize_t) n)) // error, or short read
return false;
#include <vector>
#include <cstring>
-using std::min;
-using std::vector;
-
// helper class that contains hash function name
// and hash
class HashString
{
protected:
- string Type;
- string Hash;
+ std::string Type;
+ std::string Hash;
static const char * _SupportedHashes[10];
public:
- HashString(string Type, string Hash);
- HashString(string StringedHashString); // init from str as "type:hash"
+ HashString(std::string Type, std::string Hash);
+ HashString(std::string StringedHashString); // init from str as "type:hash"
HashString();
// get hash type used
- string HashType() { return Type; };
+ std::string HashType() { return Type; };
// verify the given filename against the currently loaded hash
- bool VerifyFile(string filename) const;
+ bool VerifyFile(std::string filename) const;
// helper
- string toStr() const; // convert to str as "type:hash"
+ std::string toStr() const; // convert to str as "type:hash"
bool empty() const;
// return the list of hashes we support
while (Size != 0 || ToEOF)
{
unsigned long long n = sizeof(Buf);
- if (!ToEOF) n = min(Size, n);
+ if (!ToEOF) n = std::min(Size, n);
Res = read(Fd, Buf, n);
if (Res < 0 || (!ToEOF && Res != (ssize_t) n)) // error, or short read
return false;
#include <algorithm>
#include <stdint.h>
-using std::string;
-using std::min;
-
template<int N>
class HashSumValue
{
return memcmp(Sum,rhs.Sum,sizeof(Sum)) == 0;
};
- string Value() const
+ std::string Value() const
{
char Conv[16] =
{ '0','1','2','3','4','5','6','7','8','9','a','b',
Result[I] = Conv[Sum[J] >> 4];
Result[I + 1] = Conv[Sum[J] & 0xF];
}
- return string(Result);
+ return std::string(Result);
};
inline void Value(unsigned char S[N/8])
S[I] = Sum[I];
};
- inline operator string() const
+ inline operator std::string() const
{
return Value();
};
- bool Set(string Str)
+ bool Set(std::string Str)
{
return Hex2Num(Str,Sum,sizeof(Sum));
};
Sum[I] = S[I];
};
- HashSumValue(string Str)
+ HashSumValue(std::string Str)
{
memset(Sum,0,sizeof(Sum));
Set(Str);
#include <algorithm>
#include <stdint.h>
-using std::string;
-using std::min;
-
#include "hashsum_template.h"
typedef HashSumValue<128> MD5SumValue;
#include <string>
#include <apt-pkg/fileutl.h>
-using std::string;
-
/* This should be a 32 bit type, larger tyes use too much ram and smaller
types are too small. Where ever possible 'unsigned long' should be used
instead of this internal type */
unsigned long RawAllocate(unsigned long long Size,unsigned long Aln = 0);
unsigned long Allocate(unsigned long ItemSize);
unsigned long WriteString(const char *String,unsigned long Len = (unsigned long)-1);
- inline unsigned long WriteString(const string &S) {return WriteString(S.c_str(),S.length());};
+ inline unsigned long WriteString(const std::string &S) {return WriteString(S.c_str(),S.length());};
void UsePools(Pool &P,unsigned int Count) {Pools = &P; PoolCount = Count;};
DynamicMMap(FileFd &F,unsigned long Flags,unsigned long const &WorkSpace = 2*1024*1024,
#include "netrc.h"
+using std::string;
/* Get user and password from .netrc when given a machine name */
// If login[0] != 0, search for password within machine and login.
int parsenetrc (char *host, char *login, char *password, char *filename);
-void maybe_add_auth (URI &Uri, string NetRCFile);
+void maybe_add_auth (URI &Uri, std::string NetRCFile);
#endif
#include <string>
#include <sys/time.h>
-using std::string;
-
class Configuration;
class OpProgress
{
// Change reduction code
struct timeval LastTime;
- string LastOp;
- string LastSubOp;
+ std::string LastOp;
+ std::string LastSubOp;
protected:
- string Op;
- string SubOp;
+ std::string Op;
+ std::string SubOp;
float Percent;
bool MajorChange;
public:
void Progress(unsigned long long Current);
- void SubProgress(unsigned long long SubTotal, const string &Op = "", float const Percent = -1);
+ void SubProgress(unsigned long long SubTotal, const std::string &Op = "", float const Percent = -1);
void OverallProgress(unsigned long long Current,unsigned long long Total,
- unsigned long long Size,const string &Op);
+ unsigned long long Size,const std::string &Op);
virtual void Done() {};
OpProgress();
class OpTextProgress : public OpProgress
{
protected:
-
- string OldOp;
+
+ std::string OldOp;
bool NoUpdate;
bool NoDisplay;
unsigned long LastLen;
#include <cstring>
#include <algorithm>
-using std::string;
-using std::min;
-
#include "hashsum_template.h"
typedef HashSumValue<160> SHA1SumValue;
#include "macros.h"
-using std::string;
-using std::vector;
-using std::ostream;
-
-bool UTF8ToCodeset(const char *codeset, const string &orig, string *dest);
+bool UTF8ToCodeset(const char *codeset, const std::string &orig, std::string *dest);
char *_strstrip(char *String);
char *_strtabexpand(char *String,size_t Len);
-bool ParseQuoteWord(const char *&String,string &Res);
-bool ParseCWord(const char *&String,string &Res);
-string QuoteString(const string &Str,const char *Bad);
-string DeQuoteString(const string &Str);
-string DeQuoteString(string::const_iterator const &begin, string::const_iterator const &end);
+bool ParseQuoteWord(const char *&String,std::string &Res);
+bool ParseCWord(const char *&String,std::string &Res);
+std::string QuoteString(const std::string &Str,const char *Bad);
+std::string DeQuoteString(const std::string &Str);
+std::string DeQuoteString(std::string::const_iterator const &begin, std::string::const_iterator const &end);
// unescape (\0XX and \xXX) from a string
-string DeEscapeString(const string &input);
-
-string SizeToStr(double Bytes);
-string TimeToStr(unsigned long Sec);
-string Base64Encode(const string &Str);
-string OutputInDepth(const unsigned long Depth, const char* Separator=" ");
-string URItoFileName(const string &URI);
-string TimeRFC1123(time_t Date);
+std::string DeEscapeString(const std::string &input);
+
+std::string SizeToStr(double Bytes);
+std::string TimeToStr(unsigned long Sec);
+std::string Base64Encode(const std::string &Str);
+std::string OutputInDepth(const unsigned long Depth, const char* Separator=" ");
+std::string URItoFileName(const std::string &URI);
+std::string TimeRFC1123(time_t Date);
bool RFC1123StrToTime(const char* const str,time_t &time) __must_check;
bool FTPMDTMStrToTime(const char* const str,time_t &time) __must_check;
-__deprecated bool StrToTime(const string &Val,time_t &Result);
-string LookupTag(const string &Message,const char *Tag,const char *Default = 0);
-int StringToBool(const string &Text,int Default = -1);
-bool ReadMessages(int Fd, vector<string> &List);
+__deprecated bool StrToTime(const std::string &Val,time_t &Result);
+std::string LookupTag(const std::string &Message,const char *Tag,const char *Default = 0);
+int StringToBool(const std::string &Text,int Default = -1);
+bool ReadMessages(int Fd, std::vector<std::string> &List);
bool StrToNum(const char *Str,unsigned long &Res,unsigned Len,unsigned Base = 0);
bool StrToNum(const char *Str,unsigned long long &Res,unsigned Len,unsigned Base = 0);
bool Base256ToNum(const char *Str,unsigned long &Res,unsigned int Len);
-bool Hex2Num(const string &Str,unsigned char *Num,unsigned int Length);
+bool Hex2Num(const std::string &Str,unsigned char *Num,unsigned int Length);
bool TokSplitString(char Tok,char *Input,char **List,
unsigned long ListMax);
-vector<string> VectorizeString(string const &haystack, char const &split) __attrib_const;
-void ioprintf(ostream &out,const char *format,...) __like_printf(2);
-void strprintf(string &out,const char *format,...) __like_printf(2);
+std::vector<std::string> VectorizeString(std::string const &haystack, char const &split) __attrib_const;
+void ioprintf(std::ostream &out,const char *format,...) __like_printf(2);
+void strprintf(std::string &out,const char *format,...) __like_printf(2);
char *safe_snprintf(char *Buffer,char *End,const char *Format,...) __like_printf(3);
-bool CheckDomainList(const string &Host, const string &List);
+bool CheckDomainList(const std::string &Host, const std::string &List);
int tolower_ascii(int const c) __attrib_const __hot;
-string StripEpoch(const string &VerStr);
+std::string StripEpoch(const std::string &VerStr);
#define APT_MKSTRCMP(name,func) \
inline int name(const char *A,const char *B) {return func(A,A+strlen(A),B,B+strlen(B));}; \
inline int name(const char *A,const char *AEnd,const char *B) {return func(A,AEnd,B,B+strlen(B));}; \
-inline int name(const string& A,const char *B) {return func(A.c_str(),A.c_str()+A.length(),B,B+strlen(B));}; \
-inline int name(const string& A,const string& B) {return func(A.c_str(),A.c_str()+A.length(),B.c_str(),B.c_str()+B.length());}; \
-inline int name(const string& A,const char *B,const char *BEnd) {return func(A.c_str(),A.c_str()+A.length(),B,BEnd);};
+inline int name(const std::string& A,const char *B) {return func(A.c_str(),A.c_str()+A.length(),B,B+strlen(B));}; \
+inline int name(const std::string& A,const std::string& B) {return func(A.c_str(),A.c_str()+A.length(),B.c_str(),B.c_str()+B.length());}; \
+inline int name(const std::string& A,const char *B,const char *BEnd) {return func(A.c_str(),A.c_str()+A.length(),B,BEnd);};
#define APT_MKSTRCMP2(name,func) \
inline int name(const char *A,const char *AEnd,const char *B) {return func(A,AEnd,B,B+strlen(B));}; \
-inline int name(const string& A,const char *B) {return func(A.begin(),A.end(),B,B+strlen(B));}; \
-inline int name(const string& A,const string& B) {return func(A.begin(),A.end(),B.begin(),B.end());}; \
-inline int name(const string& A,const char *B,const char *BEnd) {return func(A.begin(),A.end(),B,BEnd);};
+inline int name(const std::string& A,const char *B) {return func(A.begin(),A.end(),B,B+strlen(B));}; \
+inline int name(const std::string& A,const std::string& B) {return func(A.begin(),A.end(),B.begin(),B.end());}; \
+inline int name(const std::string& A,const char *B,const char *BEnd) {return func(A.begin(),A.end(),B,BEnd);};
int stringcmp(const char *A,const char *AEnd,const char *B,const char *BEnd);
int stringcasecmp(const char *A,const char *AEnd,const char *B,const char *BEnd);
case the definition of string::const_iterator is not the same as
const char * and we need these extra functions */
#if __GNUC__ >= 3
-int stringcmp(string::const_iterator A,string::const_iterator AEnd,
+int stringcmp(std::string::const_iterator A,std::string::const_iterator AEnd,
const char *B,const char *BEnd);
-int stringcmp(string::const_iterator A,string::const_iterator AEnd,
- string::const_iterator B,string::const_iterator BEnd);
-int stringcasecmp(string::const_iterator A,string::const_iterator AEnd,
+int stringcmp(std::string::const_iterator A,std::string::const_iterator AEnd,
+ std::string::const_iterator B,std::string::const_iterator BEnd);
+int stringcasecmp(std::string::const_iterator A,std::string::const_iterator AEnd,
const char *B,const char *BEnd);
-int stringcasecmp(string::const_iterator A,string::const_iterator AEnd,
- string::const_iterator B,string::const_iterator BEnd);
+int stringcasecmp(std::string::const_iterator A,std::string::const_iterator AEnd,
+ std::string::const_iterator B,std::string::const_iterator BEnd);
-inline int stringcmp(string::const_iterator A,string::const_iterator Aend,const char *B) {return stringcmp(A,Aend,B,B+strlen(B));};
-inline int stringcasecmp(string::const_iterator A,string::const_iterator Aend,const char *B) {return stringcasecmp(A,Aend,B,B+strlen(B));};
+inline int stringcmp(std::string::const_iterator A,std::string::const_iterator Aend,const char *B) {return stringcmp(A,Aend,B,B+strlen(B));};
+inline int stringcasecmp(std::string::const_iterator A,std::string::const_iterator Aend,const char *B) {return stringcasecmp(A,Aend,B,B+strlen(B));};
#endif
APT_MKSTRCMP2(stringcmp,stringcmp);
class URI
{
- void CopyFrom(const string &From);
+ void CopyFrom(const std::string &From);
public:
- string Access;
- string User;
- string Password;
- string Host;
- string Path;
+ std::string Access;
+ std::string User;
+ std::string Password;
+ std::string Host;
+ std::string Path;
unsigned int Port;
- operator string();
- inline void operator =(const string &From) {CopyFrom(From);};
+ operator std::string();
+ inline void operator =(const std::string &From) {CopyFrom(From);};
inline bool empty() {return Access.empty();};
- static string SiteOnly(const string &URI);
- static string NoUserPassword(const string &URI);
+ static std::string SiteOnly(const std::string &URI);
+ static std::string NoUserPassword(const std::string &URI);
- URI(string Path) {CopyFrom(Path);};
+ URI(std::string Path) {CopyFrom(Path);};
URI() : Port(0) {};
};
struct SubstVar
{
const char *Subst;
- const string *Contents;
+ const std::string *Contents;
};
-string SubstVar(string Str,const struct SubstVar *Vars);
-string SubstVar(const string &Str,const string &Subst,const string &Contents);
+std::string SubstVar(std::string Str,const struct SubstVar *Vars);
+std::string SubstVar(const std::string &Str,const std::string &Subst,const std::string &Contents);
struct RxChoiceList
{
void *d;
protected:
- string File;
+ std::string File;
public:
virtual const Type *GetType() const;
// Interface for acquire
- virtual string Describe(bool Short) const {return File;};
+ virtual std::string Describe(bool Short) const {return File;};
// Interface for the Cache Generator
virtual bool Exists() const;
bool Merge(pkgCacheGenerator &Gen,OpProgress *Prog, unsigned long const Flag) const;
virtual pkgCache::PkgFileIterator FindInCache(pkgCache &Cache) const;
- debStatusIndex(string File);
+ debStatusIndex(std::string File);
virtual ~debStatusIndex() {};
};
/** \brief dpointer placeholder (for later in case we need it) */
void *d;
- string URI;
- string Dist;
- string Section;
- string Architecture;
+ std::string URI;
+ std::string Dist;
+ std::string Section;
+ std::string Architecture;
- string Info(const char *Type) const;
- string IndexFile(const char *Type) const;
- string IndexURI(const char *Type) const;
+ std::string Info(const char *Type) const;
+ std::string IndexFile(const char *Type) const;
+ std::string IndexURI(const char *Type) const;
public:
virtual const Type *GetType() const;
// Stuff for accessing files on remote items
- virtual string ArchiveInfo(pkgCache::VerIterator Ver) const;
- virtual string ArchiveURI(string File) const {return URI + File;};
+ virtual std::string ArchiveInfo(pkgCache::VerIterator Ver) const;
+ virtual std::string ArchiveURI(std::string File) const {return URI + File;};
// Interface for acquire
- virtual string Describe(bool Short) const;
+ virtual std::string Describe(bool Short) const;
// Interface for the Cache Generator
virtual bool Exists() const;
virtual bool Merge(pkgCacheGenerator &Gen,OpProgress *Prog) const;
virtual pkgCache::PkgFileIterator FindInCache(pkgCache &Cache) const;
- debPackagesIndex(string const &URI, string const &Dist, string const &Section,
- bool const &Trusted, string const &Arch = "native");
+ debPackagesIndex(std::string const &URI, std::string const &Dist, std::string const &Section,
+ bool const &Trusted, std::string const &Arch = "native");
virtual ~debPackagesIndex() {};
};
/** \brief dpointer placeholder (for later in case we need it) */
void *d;
- string URI;
- string Dist;
- string Section;
+ std::string URI;
+ std::string Dist;
+ std::string Section;
const char * const Language;
- string Info(const char *Type) const;
- string IndexFile(const char *Type) const;
- string IndexURI(const char *Type) const;
+ std::string Info(const char *Type) const;
+ std::string IndexFile(const char *Type) const;
+ std::string IndexURI(const char *Type) const;
- inline string TranslationFile() const {return string("Translation-").append(Language);};
+ inline std::string TranslationFile() const {return std::string("Translation-").append(Language);};
public:
virtual const Type *GetType() const;
// Interface for acquire
- virtual string Describe(bool Short) const;
+ virtual std::string Describe(bool Short) const;
virtual bool GetIndexes(pkgAcquire *Owner) const;
// Interface for the Cache Generator
virtual bool Merge(pkgCacheGenerator &Gen,OpProgress *Prog) const;
virtual pkgCache::PkgFileIterator FindInCache(pkgCache &Cache) const;
- debTranslationsIndex(string URI,string Dist,string Section, char const * const Language);
+ debTranslationsIndex(std::string URI,std::string Dist,std::string Section, char const * const Language);
virtual ~debTranslationsIndex() {};
};
/** \brief dpointer placeholder (for later in case we need it) */
void *d;
- string URI;
- string Dist;
- string Section;
+ std::string URI;
+ std::string Dist;
+ std::string Section;
- string Info(const char *Type) const;
- string IndexFile(const char *Type) const;
- string IndexURI(const char *Type) const;
+ std::string Info(const char *Type) const;
+ std::string IndexFile(const char *Type) const;
+ std::string IndexURI(const char *Type) const;
public:
virtual const Type *GetType() const;
// Stuff for accessing files on remote items
- virtual string SourceInfo(pkgSrcRecords::Parser const &Record,
+ virtual std::string SourceInfo(pkgSrcRecords::Parser const &Record,
pkgSrcRecords::File const &File) const;
- virtual string ArchiveURI(string File) const {return URI + File;};
+ virtual std::string ArchiveURI(std::string File) const {return URI + File;};
// Interface for acquire
- virtual string Describe(bool Short) const;
+ virtual std::string Describe(bool Short) const;
// Interface for the record parsers
virtual pkgSrcRecords::Parser *CreateSrcParser() const;
virtual bool HasPackages() const {return false;};
virtual unsigned long Size() const;
- debSourcesIndex(string URI,string Dist,string Section,bool Trusted);
+ debSourcesIndex(std::string URI,std::string Dist,std::string Section,bool Trusted);
virtual ~debSourcesIndex() {};
};
#include <ctype.h>
/*}}}*/
+using std::string;
+
static debListParser::WordList PrioList[] = {{"important",pkgCache::State::Important},
{"required",pkgCache::State::Required},
{"standard",pkgCache::State::Standard},
pkgTagFile Tags;
pkgTagSection Section;
unsigned long iOffset;
- string Arch;
+ std::string Arch;
std::vector<std::string> Architectures;
bool MultiArchEnabled;
bool ParseDepends(pkgCache::VerIterator &Ver,const char *Tag,
unsigned int Type);
bool ParseProvides(pkgCache::VerIterator &Ver);
- bool NewProvidesAllArch(pkgCache::VerIterator &Ver, string const &Package, string const &Version);
- static bool GrabWord(string Word,WordList *List,unsigned char &Out);
+ bool NewProvidesAllArch(pkgCache::VerIterator &Ver, std::string const &Package, std::string const &Version);
+ static bool GrabWord(std::string Word,WordList *List,unsigned char &Out);
public:
- static unsigned char GetPrio(string Str);
+ static unsigned char GetPrio(std::string Str);
// These all operate against the current section
- virtual string Package();
- virtual string Architecture();
+ virtual std::string Package();
+ virtual std::string Architecture();
virtual bool ArchitectureAll();
- virtual string Version();
+ virtual std::string Version();
virtual bool NewVersion(pkgCache::VerIterator &Ver);
- virtual string Description();
- virtual string DescriptionLanguage();
+ virtual std::string Description();
+ virtual std::string DescriptionLanguage();
virtual MD5SumValue Description_md5();
virtual unsigned short VersionHash();
virtual bool UsePackage(pkgCache::PkgIterator &Pkg,
virtual bool Step();
bool LoadReleaseInfo(pkgCache::PkgFileIterator &FileI,FileFd &File,
- string section);
+ std::string section);
static const char *ParseDepends(const char *Start,const char *Stop,
- string &Package,string &Ver,unsigned int &Op,
+ std::string &Package,std::string &Ver,unsigned int &Op,
bool const &ParseArchFlags = false,
bool const &StripMultiArch = true);
static const char *ConvertRelation(const char *I,unsigned int &Op);
- debListParser(FileFd *File, string const &Arch = "");
+ debListParser(FileFd *File, std::string const &Arch = "");
virtual ~debListParser() {};
};
#include <langinfo.h>
/*}}}*/
+using std::string;
+
// RecordParser::debRecordParser - Constructor /*{{{*/
// ---------------------------------------------------------------------
/* */
orig = Section.FindS("Description").c_str();
else
{
- vector<string> const lang = APT::Configuration::getLanguages();
- for (vector<string>::const_iterator l = lang.begin();
+ std::vector<string> const lang = APT::Configuration::getLanguages();
+ for (std::vector<string>::const_iterator l = lang.begin();
orig.empty() && l != lang.end(); ++l)
orig = Section.FindS(string("Description-").append(*l).c_str());
}
public:
// These refer to the archive file for the Version
- virtual string FileName();
- virtual string MD5Hash();
- virtual string SHA1Hash();
- virtual string SHA256Hash();
- virtual string SHA512Hash();
- virtual string SourcePkg();
- virtual string SourceVer();
+ virtual std::string FileName();
+ virtual std::string MD5Hash();
+ virtual std::string SHA1Hash();
+ virtual std::string SHA256Hash();
+ virtual std::string SHA512Hash();
+ virtual std::string SourcePkg();
+ virtual std::string SourceVer();
// These are some general stats about the package
- virtual string Maintainer();
- virtual string ShortDesc();
- virtual string LongDesc();
- virtual string Name();
- virtual string Homepage();
+ virtual std::string Maintainer();
+ virtual std::string ShortDesc();
+ virtual std::string LongDesc();
+ virtual std::string Name();
+ virtual std::string Homepage();
// An arbitrary custom field
- virtual string RecordField(const char *fieldName);
+ virtual std::string RecordField(const char *fieldName);
virtual void GetRec(const char *&Start,const char *&Stop);
- debRecordParser(string FileName,pkgCache &Cache);
+ debRecordParser(std::string FileName,pkgCache &Cache);
virtual ~debRecordParser() {};
};
using std::max;
/*}}}*/
+using std::string;
+
// SrcRecordParser::Binaries - Return the binaries field /*{{{*/
// ---------------------------------------------------------------------
/* This member parses the binaries field into a pair of class arrays and
package/version records representing the build dependency. The returned
array need not be freed and will be reused by the next call to this
function */
-bool debSrcRecordParser::BuildDepends(vector<pkgSrcRecords::Parser::BuildDepRec> &BuildDeps,
+bool debSrcRecordParser::BuildDepends(
std::vector<pkgSrcRecords::Parser::BuildDepRec> &BuildDeps,
bool const &ArchOnly, bool const &StripMultiArch)
{
unsigned int I;
// ---------------------------------------------------------------------
/* This parses the list of files and returns it, each file is required to have
a complete source package */
-bool debSrcRecordParser::Files(vector<pkgSrcRecords::File> &List)
+bool debSrcRecordParser::Files(
std::vector<pkgSrcRecords::File> &List)
{
List.erase(List.begin(),List.end());
virtual bool Step() {iOffset = Tags.Offset(); return Tags.Step(Sect);};
virtual bool Jump(unsigned long const &Off) {iOffset = Off; return Tags.Jump(Sect,Off);};
- virtual string Package() const {return Sect.FindS("Package");};
- virtual string Version() const {return Sect.FindS("Version");};
- virtual string Maintainer() const {return Sect.FindS("Maintainer");};
- virtual string Section() const {return Sect.FindS("Section");};
+ virtual std::string Package() const {return Sect.FindS("Package");};
+ virtual std::string Version() const {return Sect.FindS("Version");};
+ virtual std::string Maintainer() const {return Sect.FindS("Maintainer");};
+ virtual std::string Section() const {return Sect.FindS("Section");};
virtual const char **Binaries();
- virtual bool BuildDepends(vector<BuildDepRec> &BuildDeps, bool const &ArchOnly, bool const &StripMultiArch = true);
+ virtual bool BuildDepends(std::vector<BuildDepRec> &BuildDeps, bool const &ArchOnly, bool const &StripMultiArch = true);
virtual unsigned long Offset() {return iOffset;};
- virtual string AsStr()
+ virtual std::string AsStr()
{
const char *Start=0,*Stop=0;
Sect.GetSection(Start,Stop);
- return string(Start,Stop);
+ return std::string(Start,Stop);
};
- virtual bool Files(vector<pkgSrcRecords::File> &F);
+ virtual bool Files(
std::vector<pkgSrcRecords::File> &F);
- debSrcRecordParser(string const &File,pkgIndexFile const *Index)
+ debSrcRecordParser(std::string const &File,pkgIndexFile const *Index)
: Parser(Index), Fd(File,FileFd::ReadOnlyGzip), Tags(&Fd,102400),
Buffer(0), BufSize(0) {}
virtual ~debSrcRecordParser();
#include <apti18n.h>
/*}}}*/
+using std::string;
+
debSystem debSys;
class debSystemPrivate {
// System::AddStatusFiles - Register the status files /*{{{*/
// ---------------------------------------------------------------------
/* */
-bool debSystem::AddStatusFiles(vector<pkgIndexFile *> &List)
+bool debSystem::AddStatusFiles(
std::vector<pkgIndexFile *> &List)
{
if (d->StatusFile == 0)
d->StatusFile = new debStatusIndex(_config->FindFile("Dir::State::status"));
// debVS::UpstreamVersion - Return the upstream version string /*{{{*/
// ---------------------------------------------------------------------
/* This strips all the debian specific information from the version number */
-string debVersioningSystem::UpstreamVersion(const char *Ver)
+std::string debVersioningSystem::UpstreamVersion(const char *Ver)
{
// Strip off the bit before the first colon
const char *I = Ver;
if (*I == '-')
Last = I - Ver;
- return string(Ver,Last);
+ return std::string(Ver,Last);
}
/*}}}*/
{
return DoCmpVersion(A,Aend,B,Bend);
}
- virtual string UpstreamVersion(const char *A);
+ virtual std::string UpstreamVersion(const char *A);
debVersioningSystem();
};
{
return debVS.DoCmpVersion(A,AEnd,B,BEnd);
}
-inline int pkgVersionCompare(string A,string B)
+inline int pkgVersionCompare(std::string A,std::string B)
{
return debVS.CmpVersion(A,B);
}
{
return debVS.CheckDep(PkgVer,Op,DepVer);
}
-inline string pkgBaseVersion(const char *Ver)
+inline std::string pkgBaseVersion(const char *Ver)
{
return debVS.UpstreamVersion(Ver);
}
#include <map>
#include <stdio.h>
-using std::vector;
-using std::map;
-
class pkgDPkgPMPrivate;
class pkgDPkgPM : public pkgPackageManager
needs to declare a Replaces on the disappeared package.
\param pkgname Name of the package that disappeared
*/
- void handleDisappearAction(string const &pkgname);
+ void handleDisappearAction(std::string const &pkgname);
protected:
int pkgFailures;
// the dpkg states that the pkg will run through, the string is
// the package, the vector contains the dpkg states that the package
// will go through
- map<string,vector<struct DpkgState> > PackageOps;
+ std::map<std::string,std::vector<struct DpkgState> > PackageOps;
// the dpkg states that are already done; the string is the package
// the int is the state that is already done (e.g. a package that is
// going to be install is already in state "half-installed")
- map<string,unsigned int> PackageOpsDone;
+ std::map<std::string,unsigned int> PackageOpsDone;
// progress reporting
unsigned int PackagesDone;
struct Item
{
enum Ops {Install, Configure, Remove, Purge, ConfigurePending, TriggersPending} Op;
- string File;
+ std::string File;
PkgIterator Pkg;
- Item(Ops Op,PkgIterator Pkg,string File = "") : Op(Op),
+ Item(Ops Op,PkgIterator Pkg,std::string File = "") : Op(Op),
File(File), Pkg(Pkg) {};
Item() {};
};
- vector<Item> List;
+ std::vector<Item> List;
// Helpers
bool RunScriptsWithPkgs(const char *Cnf);
bool SendV2Pkgs(FILE *F);
- void WriteHistoryTag(string const &tag, string value);
+ void WriteHistoryTag(std::string const &tag, std::string value);
// apport integration
void WriteApportReport(const char *pkgpath, const char *errormsg);
void ProcessDpkgStatusLine(int OutStatusFd, char *line);
// The Actuall installation implementation
- virtual bool Install(PkgIterator Pkg,string File);
+ virtual bool Install(PkgIterator Pkg,std::string File);
virtual bool Configure(PkgIterator Pkg);
virtual bool Remove(PkgIterator Pkg,bool Purge = false);
virtual bool Go(int StatusFd=-1);
#include <apti18n.h>
/*}}}*/
+
+using std::string;
+
// helper for Install-Recommends-Sections and Never-MarkAuto-Sections /*{{{*/
static bool
ConfigValueInSubTree(const char* SubTree, const char *needle)
inline Header &Head() {return *Cache->HeaderP;};
inline GrpIterator GrpBegin() {return Cache->GrpBegin();};
inline PkgIterator PkgBegin() {return Cache->PkgBegin();};
- inline GrpIterator FindGrp(string const &Name) {return Cache->FindGrp(Name);};
- inline PkgIterator FindPkg(string const &Name) {return Cache->FindPkg(Name);};
- inline PkgIterator FindPkg(string const &Name, string const &Arch) {return Cache->FindPkg(Name, Arch);};
+ inline GrpIterator FindGrp(std::string const &Name) {return Cache->FindGrp(Name);};
+ inline PkgIterator FindPkg(std::string const &Name) {return Cache->FindPkg(Name);};
+ inline PkgIterator FindPkg(std::string const &Name, std::string const &Arch) {return Cache->FindPkg(Name, Arch);};
inline pkgCache &GetCache() {return *Cache;};
inline pkgVersioningSystem &VS() {return *Cache->VS;};
virtual bool Merge(pkgCacheGenerator &Gen,OpProgress *Prog) const;
- edspIndex(string File);
+ edspIndex(std::string File);
};
#endif
/*}}}*/
// ListParser::edspListParser - Constructor /*{{{*/
-edspListParser::edspListParser(FileFd *File, string const &Arch) : debListParser(File, Arch)
+edspListParser::edspListParser(FileFd *File, std::string const &Arch) : debListParser(File, Arch)
{}
/*}}}*/
// ListParser::NewVersion - Fill in the version structure /*{{{*/
// ListParser::Description - Return the description string /*{{{*/
// ---------------------------------------------------------------------
/* Sorry, no description for the resolvers… */
-string edspListParser::Description()
+std::string edspListParser::Description()
{
return "";
}
-string edspListParser::DescriptionLanguage()
+std::string edspListParser::DescriptionLanguage()
{
return "";
}
/*}}}*/
// ListParser::LoadReleaseInfo - Load the release information /*{{{*/
bool edspListParser::LoadReleaseInfo(pkgCache::PkgFileIterator &FileI,
- FileFd &File, string component)
+ FileFd &File, std::string component)
{
return true;
}
{
public:
virtual bool NewVersion(pkgCache::VerIterator &Ver);
- virtual string Description();
- virtual string DescriptionLanguage();
+ virtual std::string Description();
+ virtual std::string DescriptionLanguage();
virtual MD5SumValue Description_md5();
virtual unsigned short VersionHash();
bool LoadReleaseInfo(pkgCache::PkgFileIterator &FileI,FileFd &File,
- string section);
+ std::string section);
- edspListParser(FileFd *File, string const &Arch = "");
+ edspListParser(FileFd *File, std::string const &Arch = "");
protected:
virtual bool ParseStatus(pkgCache::PkgIterator &Pkg,pkgCache::VerIterator &Ver);
}
/*}}}*/
// System::AddStatusFiles - Register the status files /*{{{*/
-bool edspSystem::AddStatusFiles(vector<pkgIndexFile *> &List)
+bool edspSystem::AddStatusFiles(
std::vector<pkgIndexFile *> &List)
{
if (StatusFile == 0)
{
#include <string>
#include <stdio.h>
-using std::string;
-using std::vector;
-
class pkgTagSection;
class FileFd;
class indexRecords;
pkgTagSection *Section;
- string ChopDirs(string Path,unsigned int Depth);
- bool ReconstructPrefix(string &Prefix,string OrigPath,string CD,
- string File);
- bool ReconstructChop(unsigned long &Chop,string Dir,string File);
- void ConvertToSourceList(string CD,string &Path);
- bool GrabFirst(string Path,string &To,unsigned int Depth);
- virtual bool GetFile(string &Filename,unsigned long long &Size) = 0;
- virtual bool RewriteEntry(FILE *Target,string File) = 0;
+ std::string ChopDirs(std::string Path,unsigned int Depth);
+ bool ReconstructPrefix(std::string &Prefix,std::string OrigPath,std::string CD,
+ std::string File);
+ bool ReconstructChop(unsigned long &Chop,std::string Dir,std::string File);
+ void ConvertToSourceList(std::string CD,std::string &Path);
+ bool GrabFirst(std::string Path,std::string &To,unsigned int Depth);
+ virtual bool GetFile(std::string &Filename,unsigned long long &Size) = 0;
+ virtual bool RewriteEntry(FILE *Target,std::string File) = 0;
virtual const char *GetFileName() = 0;
virtual const char *Type() = 0;
public:
- bool CopyPackages(string CDROM,string Name,vector<string> &List,
+ bool CopyPackages(std::string CDROM,std::string Name,std::vector<std::string> &List,
pkgCdromStatus *log);
virtual ~IndexCopy() {};
};
{
protected:
- virtual bool GetFile(string &Filename,unsigned long long &Size);
- virtual bool RewriteEntry(FILE *Target,string File);
+ virtual bool GetFile(std::string &Filename,unsigned long long &Size);
+ virtual bool RewriteEntry(FILE *Target,std::string File);
virtual const char *GetFileName() {return "Packages";};
virtual const char *Type() {return "Package";};
{
protected:
- virtual bool GetFile(string &Filename,unsigned long long &Size);
- virtual bool RewriteEntry(FILE *Target,string File);
+ virtual bool GetFile(std::string &Filename,unsigned long long &Size);
+ virtual bool RewriteEntry(FILE *Target,std::string File);
virtual const char *GetFileName() {return "Sources";};
virtual const char *Type() {return "Source";};
pkgTagSection *Section;
public:
- bool CopyTranslations(string CDROM,string Name,vector<string> &List,
+ bool CopyTranslations(std::string CDROM,std::string Name,std::vector<std::string> &List,
pkgCdromStatus *log);
};
/*}}}*/
/** \brief dpointer placeholder (for later in case we need it) */
void *d;
- bool Verify(string prefix,string file, indexRecords *records);
- bool CopyMetaIndex(string CDROM, string CDName,
- string prefix, string file);
+ bool Verify(std::string prefix,std::string file, indexRecords *records);
+ bool CopyMetaIndex(std::string CDROM, std::string CDName,
+ std::string prefix, std::string file);
public:
- bool CopyAndVerify(string CDROM,string Name,vector<string> &SigList,
- vector<string> PkgList,vector<string> SrcList);
+ bool CopyAndVerify(std::string CDROM,std::string Name,std::vector<std::string> &SigList,
+ std::vector<std::string> PkgList,std::vector<std::string> SrcList);
/** \brief generates and run the command to verify a file with gpgv */
static bool RunGPGV(std::string const &File, std::string const &FileOut,
// IndexFile::ArchiveInfo - Stub /*{{{*/
// ---------------------------------------------------------------------
/* */
-string pkgIndexFile::ArchiveInfo(pkgCache::VerIterator Ver) const
+std::string pkgIndexFile::ArchiveInfo(pkgCache::VerIterator Ver) const
{
- return string();
+ return std::string();
}
/*}}}*/
// IndexFile::FindInCache - Stub /*{{{*/
// IndexFile::SourceIndex - Stub /*{{{*/
// ---------------------------------------------------------------------
/* */
-string pkgIndexFile::SourceInfo(pkgSrcRecords::Parser const &Record,
+std::string pkgIndexFile::SourceInfo(pkgSrcRecords::Parser const &Record,
pkgSrcRecords::File const &File) const
{
- return string();
+ return std::string();
}
/*}}}*/
// IndexFile::TranslationsAvailable - Check if will use Translation /*{{{*/
/* As we have now possibly more than one LanguageCode this method is
supersided by a) private classmembers or b) getLanguages().
TODO: Remove method with next API break */
-__attribute__ ((deprecated)) string pkgIndexFile::LanguageCode() {
+__attribute__ ((deprecated)) std::string pkgIndexFile::LanguageCode() {
if (TranslationsAvailable() == false)
return "";
return APT::Configuration::getLanguages()[0];
#include <apt-pkg/pkgcache.h>
#include <apt-pkg/srcrecords.h>
#include <apt-pkg/pkgrecords.h>
-
-using std::string;
class pkgAcquire;
class pkgCacheGenerator;
virtual const Type *GetType() const = 0;
// Return descriptive strings of various sorts
- virtual string ArchiveInfo(pkgCache::VerIterator Ver) const;
- virtual string SourceInfo(pkgSrcRecords::Parser const &Record,
+ virtual std::string ArchiveInfo(pkgCache::VerIterator Ver) const;
+ virtual std::string SourceInfo(pkgSrcRecords::Parser const &Record,
pkgSrcRecords::File const &File) const;
- virtual string Describe(bool Short = false) const = 0;
+ virtual std::string Describe(bool Short = false) const = 0;
// Interface for acquire
- virtual string ArchiveURI(string /*File*/) const {return string();};
+ virtual std::string ArchiveURI(std::string /*File*/) const {return std::string();};
// Interface for the record parsers
virtual pkgSrcRecords::Parser *CreateSrcParser() const {return 0;};
static bool TranslationsAvailable();
static bool CheckLanguageCode(const char *Lang);
- static string LanguageCode();
+ static std::string LanguageCode();
bool IsTrusted() const { return Trusted; };
#include <apti18n.h>
/*}}}*/
+
+using std::string;
+
string indexRecords::GetDist() const
{
return this->Dist;
return true;
}
/*}}}*/
-vector<string> indexRecords::MetaKeys() /*{{{*/
+std::vector<string> indexRecords::MetaKeys() /*{{{*/
{
std::vector<std::string> keys;
std::map<string,checkSum *>::iterator I = Entries.begin();
class indexRecords
{
- bool parseSumData(const char *&Start, const char *End, string &Name,
- string &Hash, unsigned long long &Size);
+ bool parseSumData(const char *&Start, const char *End, std::string &Name,
+ std::string &Hash, unsigned long long &Size);
public:
struct checkSum;
- string ErrorText;
+ std::string ErrorText;
protected:
- string Dist;
- string Suite;
- string ExpectedDist;
+ std::string Dist;
+ std::string Suite;
+ std::string ExpectedDist;
time_t ValidUntil;
- std::map<string,checkSum *> Entries;
+ std::map<std::string,checkSum *> Entries;
public:
indexRecords();
- indexRecords(const string ExpectedDist);
+ indexRecords(const std::string ExpectedDist);
// Lookup function
- virtual const checkSum *Lookup(const string MetaKey);
+ virtual const checkSum *Lookup(const std::string MetaKey);
/** \brief tests if a checksum for this file is available */
- bool Exists(string const &MetaKey) const;
+ bool Exists(std::string const &MetaKey) const;
std::vector<std::string> MetaKeys();
- virtual bool Load(string Filename);
- string GetDist() const;
+ virtual bool Load(std::string Filename);
+ std::string GetDist() const;
time_t GetValidUntil() const;
- virtual bool CheckDist(const string MaybeDist) const;
- string GetExpectedDist() const;
+ virtual bool CheckDist(const std::string MaybeDist) const;
+ std::string GetExpectedDist() const;
virtual ~indexRecords(){};
};
struct indexRecords::checkSum
{
- string MetaKeyFilename;
+ std::string MetaKeyFilename;
HashString Hash;
unsigned long long Size;
};
}
// Read the configuration parts dir
- string Parts = Cnf.FindDir("Dir::Etc::parts");
+ std::string Parts = Cnf.FindDir("Dir::Etc::parts");
if (DirectoryExists(Parts) == true)
Res &= ReadConfigDir(Cnf,Parts);
else
_error->WarningE("DirectoryExists",_("Unable to read %s"),Parts.c_str());
// Read the main config file
- string FName = Cnf.FindFile("Dir::Etc::main");
+ std::string FName = Cnf.FindFile("Dir::Etc::main");
if (RealFileExists(FName) == true)
Res &= ReadConfigFile(Cnf,FName);
bool pkgInitSystem(Configuration &Cnf,pkgSystem *&Sys)
{
Sys = 0;
- string Label = Cnf.Find("Apt::System","");
+ std::string Label = Cnf.Find("Apt::System","");
if (Label.empty() == false)
{
Sys = pkgSystem::GetSystem(Label.c_str());
#include <apt-pkg/pkgrecords.h>
#include <apt-pkg/indexfile.h>
#include <apt-pkg/vendor.h>
-
-using std::string;
class pkgAcquire;
class pkgCacheGenerator;
class metaIndex
{
protected:
- vector <pkgIndexFile *> *Indexes;
+
std::vector <pkgIndexFile *> *Indexes;
const char *Type;
- string URI;
- string Dist;
+ std::string URI;
+ std::string Dist;
bool Trusted;
public:
// Various accessors
- virtual string GetURI() const {return URI;}
- virtual string GetDist() const {return Dist;}
+ virtual std::string GetURI() const {return URI;}
+ virtual std::string GetDist() const {return Dist;}
virtual const char* GetType() const {return Type;}
// Interface for acquire
- virtual string ArchiveURI(string const& /*File*/) const = 0;
+ virtual std::string ArchiveURI(std::string const& /*File*/) const = 0;
virtual bool GetIndexes(pkgAcquire *Owner, bool const &GetAll=false) const = 0;
- virtual vector<pkgIndexFile *> *GetIndexFiles() = 0;
+ virtual
std::vector<pkgIndexFile *> *GetIndexFiles() = 0;
virtual bool IsTrusted() const = 0;
- metaIndex(string const &URI, string const &Dist, char const * const Type) :
+ metaIndex(std::string const &URI, std::string const &Dist, char const * const Type) :
Indexes(NULL), Type(Type), URI(URI), Dist(Dist) {
}
virtual ~metaIndex() {
if (Indexes == 0)
return;
- for (vector<pkgIndexFile *>::iterator I = (*Indexes).begin(); I != (*Indexes).end(); ++I)
+ for (
std::vector<pkgIndexFile *>::iterator I = (*Indexes).begin(); I != (*Indexes).end(); ++I)
delete *I;
delete Indexes;
}
Package **End;
Package **List;
Package **AfterEnd;
- string *FileList;
+ std::string *FileList;
DepIterator Loops[20];
int LoopCount;
int Depth;
inline bool IsNow(PkgIterator Pkg) {return (Flags[Pkg->ID] & (States & (~Removed))) == 0;};
bool IsMissing(PkgIterator Pkg);
void WipeFlags(unsigned long F);
- void SetFileList(string *FileList) {this->FileList = FileList;};
+ void SetFileList(std::string *FileList) {this->FileList = FileList;};
// Accessors
inline iterator begin() {return List;};
// Ordering modes
bool OrderCritical();
- bool OrderUnpack(string *FileList = 0);
+ bool OrderUnpack(std::string *FileList = 0);
bool OrderConfigure();
int Score(PkgIterator Pkg);
#include <apt-pkg/depcache.h>
#include <set>
-using std::string;
-
class pkgAcquire;
class pkgDepCache;
class pkgSourceList;
static bool SigINTStop;
protected:
- string *FileNames;
+ std::string *FileNames;
pkgDepCache &Cache;
pkgOrderList *List;
bool Debug;
bool EarlyRemove(PkgIterator Pkg);
// The Actual installation implementation
- virtual bool Install(PkgIterator /*Pkg*/,string /*File*/) {return false;};
+ virtual bool Install(PkgIterator /*Pkg*/,std::string /*File*/) {return false;};
virtual bool Configure(PkgIterator /*Pkg*/) {return false;};
virtual bool Remove(PkgIterator /*Pkg*/,bool /*Purge*/=false) {return false;};
virtual bool Go(int statusFd=-1) {return true;};
if they provide no new information (e.g. there is no newer version than candidate)
If no version and/or section can be found "none" is used. */
std::ostream&
-operator<<(ostream& out, pkgCache::PkgIterator Pkg)
+operator<<(std::ostream& out, pkgCache::PkgIterator Pkg)
{
if (Pkg.end() == true)
return out << "invalid package";
// ostream operator to handle string representation of a dependecy /*{{{*/
// ---------------------------------------------------------------------
/* */
-std::ostream& operator<<(ostream& out, pkgCache::DepIterator D)
+std::ostream& operator<<(std::ostream& out, pkgCache::DepIterator D)
{
if (D.end() == true)
return out << "invalid dependency";
#include <time.h>
#include <apt-pkg/mmap.h>
-using std::string;
-
class pkgVersioningSystem;
class pkgCache /*{{{*/
{
protected:
// Memory mapped cache file
- string CacheFile;
+ std::string CacheFile;
MMap ⤅
- unsigned long sHash(const string &S) const;
+ unsigned long sHash(const std::string &S) const;
unsigned long sHash(const char *S) const;
public:
inline void *DataEnd() {return ((unsigned char *)Map.Data()) + Map.Size();};
// String hashing function (512 range)
- inline unsigned long Hash(const string &S) const {return sHash(S);};
+ inline unsigned long Hash(const std::string &S) const {return sHash(S);};
inline unsigned long Hash(const char *S) const {return sHash(S);};
// Useful transformation things
const char *Priority(unsigned char Priority);
// Accessors
- GrpIterator FindGrp(const string &Name);
- PkgIterator FindPkg(const string &Name);
- PkgIterator FindPkg(const string &Name, const string &Arch);
+ GrpIterator FindGrp(const std::string &Name);
+ PkgIterator FindPkg(const std::string &Name);
+ PkgIterator FindPkg(const std::string &Name, const std::string &Arch);
Header &Head() {return *HeaderP;};
inline GrpIterator GrpBegin();
private:
bool MultiArchEnabled;
- PkgIterator SingleArchFindPkg(const string &Name);
+ PkgIterator SingleArchFindPkg(const std::string &Name);
inline char const * const NativeArch() const;
};
/*}}}*/
pkgCache Cache;
OpProgress *Progress;
- string PkgFileName;
+ std::string PkgFileName;
pkgCache::PackageFile *CurrentFile;
// Flag file dependencies
bool FoundFileDeps;
- bool NewGroup(pkgCache::GrpIterator &Grp,const string &Name);
- bool NewPackage(pkgCache::PkgIterator &Pkg,const string &Name, const string &Arch);
+ bool NewGroup(pkgCache::GrpIterator &Grp,const std::string &Name);
+ bool NewPackage(pkgCache::PkgIterator &Pkg,const std::string &Name, const std::string &Arch);
bool NewFileVer(pkgCache::VerIterator &Ver,ListParser &List);
bool NewFileDesc(pkgCache::DescIterator &Desc,ListParser &List);
bool NewDepends(pkgCache::PkgIterator &Pkg, pkgCache::VerIterator &Ver,
- string const &Version, unsigned int const &Op,
+ std::string const &Version, unsigned int const &Op,
unsigned int const &Type, map_ptrloc* &OldDepLast);
- unsigned long NewVersion(pkgCache::VerIterator &Ver,const string &VerStr,unsigned long Next);
- map_ptrloc NewDescription(pkgCache::DescIterator &Desc,const string &Lang,const MD5SumValue &md5sum,map_ptrloc Next);
+ unsigned long NewVersion(pkgCache::VerIterator &Ver,const std::string &VerStr,unsigned long Next);
+ map_ptrloc NewDescription(pkgCache::DescIterator &Desc,const std::string &Lang,const MD5SumValue &md5sum,map_ptrloc Next);
public:
unsigned long WriteUniqString(const char *S,unsigned int Size);
- inline unsigned long WriteUniqString(const string &S) {return WriteUniqString(S.c_str(),S.length());};
+ inline unsigned long WriteUniqString(const std::string &S) {return WriteUniqString(S.c_str(),S.length());};
void DropProgress() {Progress = 0;};
- bool SelectFile(const string &File,const string &Site,pkgIndexFile const &Index,
+ bool SelectFile(const std::string &File,const std::string &Site,pkgIndexFile const &Index,
unsigned long Flags = 0);
bool MergeList(ListParser &List,pkgCache::VerIterator *Ver = 0);
inline pkgCache &GetCache() {return Cache;};
protected:
- inline unsigned long WriteUniqString(string S) {return Owner->WriteUniqString(S);};
+ inline unsigned long WriteUniqString(std::string S) {return Owner->WriteUniqString(S);};
inline unsigned long WriteUniqString(const char *S,unsigned int Size) {return Owner->WriteUniqString(S,Size);};
- inline unsigned long WriteString(const string &S) {return Owner->WriteStringInMap(S);};
+ inline unsigned long WriteString(const std::string &S) {return Owner->WriteStringInMap(S);};
inline unsigned long WriteString(const char *S,unsigned int Size) {return Owner->WriteStringInMap(S,Size);};
- bool NewDepends(pkgCache::VerIterator &Ver,const string &Package, const string &Arch,
- const string &Version,unsigned int Op,
+ bool NewDepends(pkgCache::VerIterator &Ver,const std::string &Package, const std::string &Arch,
+ const std::string &Version,unsigned int Op,
unsigned int Type);
- bool NewProvides(pkgCache::VerIterator &Ver,const string &PkgName,
- const string &PkgArch, const string &Version);
+ bool NewProvides(pkgCache::VerIterator &Ver,const std::string &PkgName,
+ const std::string &PkgArch, const std::string &Version);
public:
// These all operate against the current section
- virtual string Package() = 0;
- virtual string Architecture() = 0;
+ virtual std::string Package() = 0;
+ virtual std::string Architecture() = 0;
virtual bool ArchitectureAll() = 0;
- virtual string Version() = 0;
+ virtual std::string Version() = 0;
virtual bool NewVersion(pkgCache::VerIterator &Ver) = 0;
- virtual string Description() = 0;
- virtual string DescriptionLanguage() = 0;
+ virtual std::string Description() = 0;
+ virtual std::string DescriptionLanguage() = 0;
virtual MD5SumValue Description_md5() = 0;
virtual unsigned short VersionHash() = 0;
virtual bool UsePackage(pkgCache::PkgIterator &Pkg,
/* */
pkgRecords::~pkgRecords()
{
- for ( vector<Parser*>::iterator it = Files.begin();
+ for (
std::vector<Parser*>::iterator it = Files.begin();
it != Files.end();
++it)
{
friend class pkgRecords;
// These refer to the archive file for the Version
- virtual string FileName() {return string();};
- virtual string MD5Hash() {return string();};
- virtual string SHA1Hash() {return string();};
- virtual string SHA256Hash() {return string();};
- virtual string SHA512Hash() {return string();};
- virtual string SourcePkg() {return string();};
- virtual string SourceVer() {return string();};
+ virtual std::string FileName() {return std::string();};
+ virtual std::string MD5Hash() {return std::string();};
+ virtual std::string SHA1Hash() {return std::string();};
+ virtual std::string SHA256Hash() {return std::string();};
+ virtual std::string SHA512Hash() {return std::string();};
+ virtual std::string SourcePkg() {return std::string();};
+ virtual std::string SourceVer() {return std::string();};
// These are some general stats about the package
- virtual string Maintainer() {return string();};
- virtual string ShortDesc() {return string();};
- virtual string LongDesc() {return string();};
- virtual string Name() {return string();};
- virtual string Homepage() {return string();}
+ virtual std::string Maintainer() {return std::string();};
+ virtual std::string ShortDesc() {return std::string();};
+ virtual std::string LongDesc() {return std::string();};
+ virtual std::string Name() {return std::string();};
+ virtual std::string Homepage() {return std::string();}
// An arbitrary custom field
- virtual string RecordField(const char *fieldName) { return string();};
+ virtual std::string RecordField(const char *fieldName) { return std::string();};
// The record in binary form
virtual void GetRec(const char *&Start,const char *&Stop) {Start = Stop = 0;};
#include <apt-pkg/versionmatch.h>
#include <vector>
-using std::vector;
-
class pkgPolicy : public pkgDepCache::Policy
{
protected:
struct Pin
{
pkgVersionMatch::MatchType Type;
- string Data;
+ std::string Data;
signed short Priority;
Pin() : Type(pkgVersionMatch::None), Priority(0) {};
};
struct PkgPin : Pin
{
- string Pkg;
- PkgPin(string const &Pkg) : Pin(), Pkg(Pkg) {};
+ std::string Pkg;
+ PkgPin(std::string const &Pkg) : Pin(), Pkg(Pkg) {};
};
Pin *Pins;
signed short *PFPriority;
- vector<Pin> Defaults;
- vector<PkgPin> Unmatched;
+
std::vector<Pin> Defaults;
+
std::vector<PkgPin> Unmatched;
pkgCache *Cache;
bool StatusOverride;
public:
// Things for manipulating pins
- void CreatePin(pkgVersionMatch::MatchType Type,string Pkg,
- string Data,signed short Priority);
+ void CreatePin(pkgVersionMatch::MatchType Type,std::string Pkg,
+ std::string Data,signed short Priority);
pkgCache::VerIterator GetMatch(pkgCache::PkgIterator const &Pkg);
// Things for the cache interface.
virtual ~pkgPolicy() {delete [] PFPriority; delete [] Pins;};
};
-bool ReadPinFile(pkgPolicy &Plcy,string File = "");
-bool ReadPinDir(pkgPolicy &Plcy,string Dir = "");
+bool ReadPinFile(pkgPolicy &Plcy, std::string File = "");
+bool ReadPinDir(pkgPolicy &Plcy, std::string Dir = "");
#endif
#include <string>
-#include <vector>
-
-using std::string;
-using std::vector;
+#include <vector>
class pkgSourceList;
class pkgIndexFile;
// Describes a single file
struct File
{
- string MD5Hash;
+ std::string MD5Hash;
unsigned long Size;
- string Path;
- string Type;
+ std::string Path;
+ std::string Type;
};
// Abstract parser for each source record
struct BuildDepRec
{
- string Package;
- string Version;
+ std::string Package;
+ std::string Version;
unsigned int Op;
unsigned char Type;
};
virtual bool Step() = 0;
virtual bool Jump(unsigned long const &Off) = 0;
virtual unsigned long Offset() = 0;
- virtual string AsStr() = 0;
+ virtual std::string AsStr() = 0;
- virtual string Package() const = 0;
- virtual string Version() const = 0;
- virtual string Maintainer() const = 0;
- virtual string Section() const = 0;
+ virtual std::string Package() const = 0;
+ virtual std::string Version() const = 0;
+ virtual std::string Maintainer() const = 0;
+ virtual std::string Section() const = 0;
virtual const char **Binaries() = 0; // Ownership does not transfer
- virtual bool BuildDepends(vector<BuildDepRec> &BuildDeps, bool const &ArchOnly, bool const &StripMultiArch = true) = 0;
+ virtual bool BuildDepends(std::vector<BuildDepRec> &BuildDeps, bool const &ArchOnly, bool const &StripMultiArch = true) = 0;
static const char *BuildDepType(unsigned char const &Type);
- virtual bool Files(vector<pkgSrcRecords::File> &F) = 0;
+ virtual bool Files(
std::vector<pkgSrcRecords::File> &F) = 0;
Parser(const pkgIndexFile *Index) : iIndex(Index) {};
virtual ~Parser() {};
void *d;
// The list of files and the current parser pointer
- vector<Parser*> Files;
- vector<Parser *>::iterator Current;
+
std::vector<Parser*> Files;
+
std::vector<Parser *>::iterator Current;
public:
bool Find(const char *Tag,const char *&Start, const char *&End) const;
bool Find(const char *Tag,unsigned &Pos) const;
- string FindS(const char *Tag) const;
+ std::string FindS(const char *Tag) const;
signed int FindI(const char *Tag,signed long Default = 0) const ;
unsigned long long FindULL(const char *Tag, unsigned long long const &Default = 0) const;
bool FindFlag(const char *Tag,unsigned long &Flags,
delete FingerprintList;
}
-const string Vendor::LookupFingerprint(string Print) const
+const std::string Vendor::LookupFingerprint(std::string Print) const
{
- std::map<string,string>::const_iterator Elt = Fingerprints.find(Print);
+ std::map<std::string,std::string>::const_iterator Elt = Fingerprints.find(Print);
if (Elt == Fingerprints.end())
return "";
else
return (*Elt).second;
}
-bool Vendor::CheckDist(string Dist)
+bool Vendor::CheckDist(std::string Dist)
{
return true;
}
#include <apt-pkg/macros.h>
-using std::string;
-
-// A class representing a particular software provider.
+// A class representing a particular software provider.
class __deprecated Vendor
{
public:
struct Fingerprint
{
- string Print;
- string Description;
+ std::string Print;
+ std::string Description;
};
protected:
- string VendorID;
- string Origin;
- std::map<string, string> Fingerprints;
+ std::string VendorID;
+ std::string Origin;
+ std::map<std::string, std::string> Fingerprints;
public:
- Vendor(string VendorID, string Origin,
+ Vendor(std::string VendorID, std::string Origin,
std::vector<struct Fingerprint *> *FingerprintList);
- virtual const string& GetVendorID() const { return VendorID; };
- virtual const string LookupFingerprint(string Print) const;
- virtual bool CheckDist(string Dist);
+ virtual const std::string& GetVendorID() const { return VendorID; };
+ virtual const std::string LookupFingerprint(std::string Print) const;
+ virtual bool CheckDist(std::string Dist);
virtual ~Vendor(){};
};
#include <apt-pkg/vendorlist.h>
+using std::string;
+using std::vector;
+
pkgVendorList::~pkgVendorList()
{
for (vector<const Vendor *>::const_iterator I = VendorList.begin();
#include <apt-pkg/configuration.h>
#include <apt-pkg/macros.h>
-using std::string;
-using std::vector;
-
-
class __deprecated pkgVendorList
{
protected:
- vector<Vendor const *> VendorList;
+ std::vector<Vendor const *> VendorList;
bool CreateList(Configuration& Cnf);
- const Vendor* LookupFingerprint(string Fingerprint);
+ const Vendor* LookupFingerprint(std::string Fingerprint);
public:
- typedef vector<Vendor const *>::const_iterator const_iterator;
+ typedef std::vector<Vendor const *>::const_iterator const_iterator;
bool ReadMainList();
- bool Read(string File);
+ bool Read(std::string File);
// List accessors
inline const_iterator begin() const {return VendorList.begin();};
inline unsigned int size() const {return VendorList.size();};
inline bool empty() const {return VendorList.empty();};
- const Vendor* FindVendor(const vector<string> GPGVOutput);
+ const Vendor* FindVendor(const std::vector<std::string> GPGVOutput);
~pkgVendorList();
};
#include <apt-pkg/strutl.h>
#include <string>
-using std::string;
-
class pkgVersioningSystem
{
public:
virtual bool CheckDep(const char *PkgVer,int Op,const char *DepVer) = 0;
virtual int DoCmpReleaseVer(const char *A,const char *Aend,
const char *B,const char *Bend) = 0;
- virtual string UpstreamVersion(const char *A) = 0;
+ virtual std::string UpstreamVersion(const char *A) = 0;
// See if the given VS is compatible with this one..
virtual bool TestCompatibility(pkgVersioningSystem const &Against)
#include <regex.h>
/*}}}*/
+using std::string;
+
// VersionMatch::pkgVersionMatch - Constructor /*{{{*/
// ---------------------------------------------------------------------
/* Break up the data string according to the selected type */
#include <string>
#include <apt-pkg/pkgcache.h>
-using std::string;
-
class pkgVersionMatch
{
// Version Matching
- string VerStr;
+ std::string VerStr;
bool VerPrefixMatch;
// Release Matching
- string RelVerStr;
+ std::string RelVerStr;
bool RelVerPrefixMatch;
- string RelOrigin;
- string RelRelease;
- string RelCodename;
- string RelArchive;
- string RelLabel;
- string RelComponent;
- string RelArchitecture;
+ std::string RelOrigin;
+ std::string RelRelease;
+ std::string RelCodename;
+ std::string RelArchive;
+ std::string RelLabel;
+ std::string RelComponent;
+ std::string RelArchitecture;
bool MatchAll;
// Origin Matching
- string OrSite;
+ std::string OrSite;
public:
enum MatchType {None = 0,Version,Release,Origin} Type;
- bool MatchVer(const char *A,string B,bool Prefix);
+ bool MatchVer(const char *A,std::string B,bool Prefix);
bool ExpressionMatches(const char *pattern, const char *string);
bool ExpressionMatches(const std::string& pattern, const char *string);
bool FileMatch(pkgCache::PkgFileIterator File);
pkgCache::VerIterator Find(pkgCache::PkgIterator Pkg);
- pkgVersionMatch(string Data,MatchType Type);
+ pkgVersionMatch(std::string Data,MatchType Type);
};
#endif
+apt (0.8.16~exp7) experimental; urgency=low
+
+ [ David Kalnischkies ]
+ * do not pollute namespace in the headers with using (Closes: #500198)
+
+ -- David Kalnischkies <kalnischkies@gmail.com> Mon, 19 Sep 2011 13:25:58 +0200
+
apt (0.8.16~exp6) experimental; urgency=low
[ Christopher Baines ]
// CacheDB::ReadyDB - Ready the DB2 /*{{{*/
// ---------------------------------------------------------------------
/* This opens the DB2 file for caching package information */
-bool CacheDB::ReadyDB(string const &DB)
+bool CacheDB::ReadyDB(std::string const &DB)
{
int err;
DBLoaded = false;
Dbp = 0;
- DBFile = string();
+ DBFile = std::string();
if (DB.empty())
return true;
/*}}}*/
// CacheDB::GetFileInfo - Get all the info about the file /*{{{*/
// ---------------------------------------------------------------------
-bool CacheDB::GetFileInfo(string const &FileName, bool const &DoControl, bool const &DoContents,
+bool CacheDB::GetFileInfo(std::string const &FileName, bool const &DoControl, bool const &DoContents,
bool const &GenContentsOnly, bool const &DoMD5, bool const &DoSHA1,
bool const &DoSHA256, bool const &DoSHA512,
bool const &checkMtime)
}
/*}}}*/
-static string bytes2hex(uint8_t *bytes, size_t length) {
+static std::string bytes2hex(uint8_t *bytes, size_t length) {
char space[65];
if (length * 2 > sizeof(space) - 1) length = (sizeof(space) - 1) / 2;
for (size_t i = 0; i < length; i++)
snprintf(&space[i*2], 3, "%02x", bytes[i]);
- return string(space);
+ return std::string(space);
}
static inline unsigned char xdig2num(char const &dig) {
stringcmp(Colon + 1, (char *)Key.data+Key.size,"cl") == 0 ||
stringcmp(Colon + 1, (char *)Key.data+Key.size,"cn") == 0)
{
- if (FileExists(string((const char *)Key.data,Colon)) == true)
+ if (FileExists(std::string((const char *)Key.data,Colon)) == true)
continue;
}
}
DB *Dbp;
bool DBLoaded;
bool ReadOnly;
- string DBFile;
+ std::string DBFile;
// Generate a key for the DB of a given type
inline void InitQuery(const char *Type)
struct StatStore OldStat;
// 'set' state
- string FileName;
+ std::string FileName;
FileFd *Fd;
debDebFile *DebFile;
// Data collection helpers
debDebFile::MemControlExtract Control;
ContentsExtract Contents;
- string MD5Res;
- string SHA1Res;
- string SHA256Res;
- string SHA512Res;
+ std::string MD5Res;
+ std::string SHA1Res;
+ std::string SHA256Res;
+ std::string SHA512Res;
// Runtime statistics
struct Stats
Stats() : Bytes(0), MD5Bytes(0), SHA1Bytes(0), SHA256Bytes(0), Packages(0), Misses(0), DeLinkBytes(0) {};
} Stats;
- bool ReadyDB(string const &DB);
+ bool ReadyDB(std::string const &DB);
inline bool DBFailed() {return Dbp != 0 && DBLoaded == false;};
inline bool Loaded() {return DBLoaded == true;};
inline unsigned long long GetFileSize(void) {return CurStat.FileSize;}
- bool SetFile(string const &FileName,struct stat St,FileFd *Fd);
- bool GetFileInfo(string const &FileName, bool const &DoControl, bool const &DoContents, bool const &GenContentsOnly,
+ bool SetFile(std::string const &FileName,struct stat St,FileFd *Fd);
+ bool GetFileInfo(std::string const &FileName, bool const &DoControl, bool const &DoContents, bool const &GenContentsOnly,
bool const &DoMD5, bool const &DoSHA1, bool const &DoSHA256, bool const &DoSHA512, bool const &checkMtime = false);
bool Finish();
bool Clean();
- CacheDB(string const &DB) : Dbp(0), Fd(NULL), DebFile(0) {ReadyDB(DB);};
- ~CacheDB() {ReadyDB(string()); delete DebFile;};
+ CacheDB(std::string const &DB) : Dbp(0), Fd(NULL), DebFile(0) {ReadyDB(DB);};
+ ~CacheDB() {ReadyDB(std::string()); delete DebFile;};
};
#endif
// ContentsExtract::Add - Read the contents data into the sorter /*{{{*/
// ---------------------------------------------------------------------
/* */
-void ContentsExtract::Add(GenContents &Contents,string const &Package)
+void ContentsExtract::Add(GenContents &Contents,std::string const &Package)
{
const char *Start = Data;
char *Pkg = Contents.Mystrdup(Package.c_str());
virtual bool DoItem(Item &Itm,int &Fd);
void Reset() {CurSize = 0;};
bool TakeContents(const void *Data,unsigned long long Length);
- void Add(GenContents &Contents,string const &Package);
+ void Add(GenContents &Contents,std::string const &Package);
ContentsExtract() : Data(0), MaxSize(0), CurSize(0) {};
virtual ~ContentsExtract() {delete [] Data;};
// An output file
struct Files
{
- string Output;
+ std::string Output;
APT::Configuration::Compressor CompressProg;
Files *Next;
FileFd TmpFile;
bool Finalize(unsigned long long &OutSize);
bool OpenOld(int &Fd,pid_t &Proc);
bool CloseOld(int Fd,pid_t Proc);
- static bool GetStat(string const &Output,string const &Compress,struct stat &St);
+ static bool GetStat(std::string const &Output,std::string const &Compress,struct stat &St);
- MultiCompress(string const &Output,string const &Compress,
+ MultiCompress(std::string const &Output,std::string const &Compress,
mode_t const &Permissions, bool const &Write = true);
~MultiCompress();
};
bool Bzip2Method::Fetch(FetchItem *Itm)
{
URI Get = Itm->Uri;
- string Path = Get.Host + Get.Path; // To account for relative paths
+ std::string Path = Get.Host + Get.Path; // To account for relative paths
- string GzPathOption = "Dir::bin::"+string(Prog);
+ std::string GzPathOption = "Dir::bin::" + std::string(Prog);
FetchResult Res;
Res.Filename = Itm->DestFile;
SetCloseExec(STDOUT_FILENO,false);
const char *Args[3];
- string Tmp = _config->Find(GzPathOption,Prog);
+ std::string Tmp = _config->Find(GzPathOption,Prog);
Args[0] = Tmp.c_str();
Args[1] = "-d";
Args[2] = 0;
#include <apti18n.h>
/*}}}*/
-static string LastHost;
+static std::string LastHost;
static int LastPort = 0;
static struct addrinfo *LastHostAddr = 0;
static struct addrinfo *LastUsed = 0;
// Set of IP/hostnames that we timed out before or couldn't resolve
-static std::set<string> bad_addr;
+static std::set<std::string> bad_addr;
// RotateDNS - Select a new server from a DNS rotation /*{{{*/
// ---------------------------------------------------------------------
// DoConnect - Attempt a connect operation /*{{{*/
// ---------------------------------------------------------------------
/* This helper function attempts a connection to a single address. */
-static bool DoConnect(struct addrinfo *Addr,string Host,
+static bool DoConnect(struct addrinfo *Addr,std::string Host,
unsigned long TimeOut,int &Fd,pkgAcqMethod *Owner)
{
// Show a status indicator
Owner->Status(_("Connecting to %s (%s)"),Host.c_str(),Name);
// if that addr did timeout before, we do not try it again
- if(bad_addr.find(string(Name)) != bad_addr.end())
+ if(bad_addr.find(std::string(Name)) != bad_addr.end())
return false;
/* If this is an IP rotation store the IP we are using.. If something goes
/* This implements a timeout for connect by opening the connection
nonblocking */
if (WaitFd(Fd,true,TimeOut) == false) {
- bad_addr.insert(bad_addr.begin(), string(Name));
+ bad_addr.insert(bad_addr.begin(), std::string(Name));
Owner->SetFailReason("Timeout");
return _error->Error(_("Could not connect to %s:%s (%s), "
"connection timed out"),Host.c_str(),Service,Name);
Owner->SetFailReason("ConnectionRefused");
else if (errno == ETIMEDOUT)
Owner->SetFailReason("ConnectionTimedOut");
- bad_addr.insert(bad_addr.begin(), string(Name));
+ bad_addr.insert(bad_addr.begin(), std::string(Name));
return _error->Errno("connect",_("Could not connect to %s:%s (%s)."),Host.c_str(),
Service,Name);
}
// Connect - Connect to a server /*{{{*/
// ---------------------------------------------------------------------
/* Performs a connection to the server */
-bool Connect(string Host,int Port,const char *Service,int DefPort,int &Fd,
+bool Connect(std::string Host,int Port,const char *Service,int DefPort,int &Fd,
unsigned long TimeOut,pkgAcqMethod *Owner)
{
if (_error->PendingError() == true)
#include <string>
#include <apt-pkg/acquire-method.h>
-bool Connect(string To,int Port,const char *Service,int DefPort,
+bool Connect(std::string To,int Port,const char *Service,int DefPort,
int &Fd,unsigned long TimeOut,pkgAcqMethod *Owner);
void RotateDNS();
bool CopyMethod::Fetch(FetchItem *Itm)
{
URI Get = Itm->Uri;
- string File = Get.Path;
+ std::string File = Get.Path;
// Stat the file and send a start message
struct stat Buf;
bool FileMethod::Fetch(FetchItem *Itm)
{
URI Get = Itm->Uri;
- string File = Get.Path;
+ std::string File = Get.Path;
FetchResult Res;
if (Get.Host.empty() == false)
return _error->Error(_("Invalid URI, local URIS must not start with //"));
}
// See if we can compute a file without a .gz exentsion
- string::size_type Pos = File.rfind(".gz");
+ std::string::size_type Pos = File.rfind(".gz");
if (Pos + 3 == File.length())
{
- File = string(File,0,Pos);
+ File = std::string(File,0,Pos);
if (stat(File.c_str(),&Buf) == 0)
{
FetchResult AltRes;
socklen_t ServerAddrLen;
// Private helper functions
- bool ReadLine(string &Text);
+ bool ReadLine(std::string &Text);
bool Login();
bool CreateDataFd();
bool Finalize();
bool Comp(URI Other) {return Other.Host == ServerName.Host && Other.Port == ServerName.Port && Other.User == ServerName.User && Other.Password == ServerName.Password; };
// Raw connection IO
- bool ReadResp(unsigned int &Ret,string &Text);
- bool WriteMsg(unsigned int &Ret,string &Text,const char *Fmt,...);
+ bool ReadResp(unsigned int &Ret,std::string &Text);
+ bool WriteMsg(unsigned int &Ret,std::string &Text,const char *Fmt,...);
// Connection control
bool Open(pkgAcqMethod *Owner);
class FtpMethod : public pkgAcqMethod
{
virtual bool Fetch(FetchItem *Itm);
- virtual bool Configuration(string Message);
+ virtual bool Configuration(std::string Message);
FTPConn *Server;
- static string FailFile;
+ static std::string FailFile;
static int FailFd;
static time_t FailTime;
static void SigTerm(int);
#include <apti18n.h>
+using std::string;
+using std::vector;
+
#define GNUPGPREFIX "[GNUPG:]"
#define GNUPGBADSIG "[GNUPG:] BADSIG"
#define GNUPGNOPUBKEY "[GNUPG:] NO_PUBKEY"
bool GzipMethod::Fetch(FetchItem *Itm)
{
URI Get = Itm->Uri;
- string Path = Get.Host + Get.Path; // To account for relative paths
+ std::string Path = Get.Host + Get.Path; // To account for relative paths
FetchResult Res;
Res.Filename = Itm->DestFile;
unsigned long long Size;
unsigned long long InP;
unsigned long long OutP;
- string OutQueue;
+ std::string OutQueue;
unsigned long long StrPos;
unsigned long long MaxGet;
struct timeval Start;
// Read data in
bool Read(int Fd);
- bool Read(string Data);
+ bool Read(std::string Data);
// Write data out
bool Write(int Fd);
- bool WriteTillEl(string &Data,bool Single = false);
+ bool WriteTillEl(std::string &Data,bool Single = false);
// Control the write limit
void Limit(long long Max) {if (Max == -1) MaxGet = 0-1; else MaxGet = OutP + Max;}
enum {Chunked,Stream,Closes} Encoding;
enum {Header, Data} State;
bool Persistent;
- string Location;
+ std::string Location;
// This is a Persistent attribute of the server itself.
bool Pipeline;
int ServerFd;
URI ServerName;
- bool HeaderLine(string Line);
+ bool HeaderLine(std::string Line);
bool Comp(URI Other) const {return Other.Host == ServerName.Host && Other.Port == ServerName.Port;};
void Reset() {Major = 0; Minor = 0; Result = 0; Size = 0; StartPos = 0;
Encoding = Closes; time(&Date); ServerFd = -1;
/** \brief Try to AutoDetect the proxy */
bool AutoDetectProxy();
- virtual bool Configuration(string Message);
+ virtual bool Configuration(std::string Message);
// In the event of a fatal signal this file will be closed and timestamped.
- static string FailFile;
+ static std::string FailFile;
static int FailFd;
static time_t FailTime;
static void SigTerm(int);
protected:
virtual bool Fetch(FetchItem *);
- string NextURI;
- string AutoDetectProxyCmd;
+ std::string NextURI;
+ std::string AutoDetectProxyCmd;
public:
friend struct ServerState;
{
Debug = _config->FindB("Debug::pkgAcquire::RRed", false);
URI Get = Itm->Uri;
- string Path = Get.Host + Get.Path; // To account for relative paths
+ std::string Path = Get.Host + Get.Path; // To account for relative paths
FetchResult Res;
Res.Filename = Itm->DestFile;
and use the access time from the "old" file */
struct stat BufBase, BufPatch;
if (stat(Path.c_str(),&BufBase) != 0 ||
- stat(string(Path+".ed").c_str(),&BufPatch) != 0)
+ stat(std::string(Path+".ed").c_str(),&BufPatch) != 0)
return _error->Errno("stat",_("Failed to stat"));
struct utimbuf TimeBuf;
unsigned long TimeOut = 120;
Configuration::Item const *RshOptions = 0;
time_t RSHMethod::FailTime = 0;
-string RSHMethod::FailFile;
+std::string RSHMethod::FailFile;
int RSHMethod::FailFd = -1;
// RSHConn::RSHConn - Constructor /*{{{*/
// RSHConn::Connect - Fire up rsh and connect /*{{{*/
// ---------------------------------------------------------------------
/* */
-bool RSHConn::Connect(string Host, string User)
+bool RSHConn::Connect(std::string Host, std::string User)
{
// Create the pipes
int Pipes[4] = {-1,-1,-1,-1};
// RSHConn::ReadLine - Very simple buffered read with timeout /*{{{*/
// ---------------------------------------------------------------------
/* */
-bool RSHConn::ReadLine(string &Text)
+bool RSHConn::ReadLine(std::string &Text)
{
if (Process == -1 || ReadFd == -1)
return false;
continue;
I++;
- Text = string(Buffer,I);
+ Text = std::string(Buffer,I);
memmove(Buffer,Buffer+I,Len - I);
Len -= I;
return true;
// ---------------------------------------------------------------------
/* The remote sync flag appends a || echo which will insert blank line
once the command completes. */
-bool RSHConn::WriteMsg(string &Text,bool Sync,const char *Fmt,...)
+bool RSHConn::WriteMsg(std::string &Text,bool Sync,const char *Fmt,...)
{
va_list args;
va_start(args,Fmt);
bool RSHConn::Size(const char *Path,unsigned long long &Size)
{
// Query the size
- string Msg;
+ std::string Msg;
Size = 0;
if (WriteMsg(Msg,true,"find %s -follow -printf '%%s\\n'",Path) == false)
{
Time = time(&Time);
// Query the mod time
- string Msg;
+ std::string Msg;
if (WriteMsg(Msg,true,"TZ=UTC find %s -follow -printf '%%TY%%Tm%%Td%%TH%%TM%%TS\\n'",Path) == false)
return false;
}
// FIXME: Detect file-not openable type errors.
- string Jnk;
+ std::string Jnk;
if (WriteMsg(Jnk,false,"dd if=%s bs=2048 skip=%u", Path, Resume / 2048) == false)
return false;
/*}}}*/
// RSHMethod::Configuration - Handle a configuration message /*{{{*/
// ---------------------------------------------------------------------
-bool RSHMethod::Configuration(string Message)
+bool RSHMethod::Configuration(std::string Message)
{
char ProgStr[100];
URI ServerName;
// Private helper functions
- bool ReadLine(string &Text);
+ bool ReadLine(std::string &Text);
public:
pid_t Process;
// Raw connection IO
- bool WriteMsg(string &Text,bool Sync,const char *Fmt,...);
- bool Connect(string Host, string User);
+ bool WriteMsg(std::string &Text,bool Sync,const char *Fmt,...);
+ bool Connect(std::string Host, std::string User);
bool Comp(URI Other) const {return Other.Host == ServerName.Host && Other.Port == ServerName.Port;};
// Connection control
class RSHMethod : public pkgAcqMethod
{
virtual bool Fetch(FetchItem *Itm);
- virtual bool Configuration(string Message);
+ virtual bool Configuration(std::string Message);
RSHConn *Server;
- static string FailFile;
+ static std::string FailFile;
static int FailFd;
static time_t FailTime;
static void SigTerm(int);
#include <stdio.h>
#include <assert.h>
+#include <vector>
+
int main()
{
pkgUdevCdromDevices c;
assert(c.Dlopen());
- vector<CdromDevice> l;
+ std::vector<CdromDevice> l;
l = c.Scan();
assert(l.empty() == false);
for (size_t i = 0; i < l.size(); ++i)
#include <stdio.h>
#include <iostream>
-#define P(x) string(argv[1]).append("/").append(x)
+#define P(x) std::string(argv[1]).append("/").append(x)
int main(int argc,char *argv[])
{
equals(sha2.VerifyFile(argv[1]), true);
}
{
- HashString sha2("SHA256:"+string(argv[4]));
+ HashString sha2("SHA256:" + std::string(argv[4]));
equals(sha2.VerifyFile(argv[1]), true);
}
#include "assert.h"
int main(int argc,char *argv[]) {
- string Package;
- string Version;
+ std::string Package;
+ std::string Version;
unsigned int Op = 5;
unsigned int Null = 0;
bool StripMultiArch = true;
int main(int argc,char *argv[])
{
- string input, output, expected;
+ std::string input, output, expected;
// no input
input = "foobar";
HCoop / ntk / apt.git / commitdiff