LTP GCOV extension - code coverage report
Current view: | directory - ept/apt - apt.h
Test: | lcov.info
Date: | 2008-08-14 |  | Instrumented lines: | 6
Code covered: | 50.0 % |  | Executed lines: | 3

           1                 : // -*- C++ -*-
           2                 : #ifndef EPT_APT_APT_H
           3                 : #define EPT_APT_APT_H
           4                 :
           5                 : /** \file
           6                 :  * High-level front-end to libapt-pkg, as a data provider for the ept framework.
           7                 :  */
           8                 :
           9                 : /*
          10                 :  * Copyright (C) 2007,2008  Enrico Zini <enrico@enricozini.org>
          11                 :  *
          12                 :  * This library is free software; you can redistribute it and/or
          13                 :  * modify it under the terms of the GNU Lesser General Public
          14                 :  * License as published by the Free Software Foundation; either
          15                 :  * version 2.1 of the License, or (at your option) any later version.
          16                 :  *
          17                 :  * This library is distributed in the hope that it will be useful,
          18                 :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
          19                 :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
          20                 :  * Lesser General Public License for more details.
          21                 :  *
          22                 :  * You should have received a copy of the GNU Lesser General Public
          23                 :  * License along with this library; if not, write to the Free Software
          24                 :  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
          25                 :  */
          26                 :
          27                 : #include <wibble/exception.h>
          28                 : #include <ept/apt/version.h>
          29                 : #include <ept/core/apt.h>
          30                 :
          31                 : #include <iterator>
          32                 :
          33                 : namespace ept {
          34                 : namespace apt {
          35                 :
          36                 : class Exception : public wibble::exception::Generic
          37                 : {
          38                 : protected:
          39                 :         std::string m_message;
          40                 :
          41                 : public:
          42                 :         Exception(const std::string& context) throw ();
          43               0 :         ~Exception() throw () {}
          44                 :
          45               0 :         virtual const char* type() const throw () { return "Apt"; }
          46               0 :         virtual std::string desc() const throw () { return m_message; }
          47                 : };
          48                 :
          49                 : class Apt;
          50                 : class AptImplementation;
          51                 : class RecordIteratorImpl;
          52                 : using core::PackageState;
          53                 :
          54                 : /**
          55                 :  * High-level access to the Apt cache, as a data provider for the ept
          56                 :  * framework.
          57                 :  *
          58                 :  * This class wraps the Apt cache and allows to query it in various ways.
          59                 :  */
          60                 : class Apt
          61                 : {
          62                 : protected:
          63                 :         AptImplementation* impl;
          64                 :
          65                 : public:
          66                 :         // Iterate Packages in the Apt cache
          67                 :         class Iterator : public std::iterator<std::input_iterator_tag, std::string, void, void, void>
          68                 :         {
          69                 :                 void* cur;
          70                 :
          71                 :         protected:
          72                 :                 // Construct a valid iterator
          73               4 :                 Iterator(void* cur) : cur(cur) {}
          74                 :
          75                 :                 // Construct and end iterator
          76            3581 :                 Iterator() : cur(0) {}
          77                 :
          78                 :         public:
          79                 :                 // Copy constructor
          80                 :                 Iterator(const Iterator&);
          81                 :                 ~Iterator();
          82                 :                 std::string operator*();
          83                 :                 Iterator& operator++();
          84                 :                 Iterator& operator=(const Iterator&);
          85                 :                 bool operator==(const Iterator&) const;
          86                 :                 bool operator!=(const Iterator&) const;
          87                 :
          88                 :                 // FIXME: Iterator operator++(int); cannot be easily implemented
          89                 :                 // because of how Apt's pkgIterator works
          90                 :
          91                 :                 friend class Apt;
          92                 :         };
          93                 :
          94                 :         // Iterate Package records in the Apt cache
          95                 :         class RecordIterator : public std::iterator<std::input_iterator_tag, std::string, void, void, void>
          96                 :         {
          97                 :                 RecordIteratorImpl* impl;
          98                 :                 size_t pos;
          99                 :                 std::string cur;
         100                 :                 size_t cur_pos;
         101                 :
         102                 :         protected:
         103                 :                 // Construct a valid iterator
         104                 :                 RecordIterator(RecordIteratorImpl* cur, size_t pos = 0);
         105                 :
         106                 :                 // Construct and end iterator
         107            3481 :                 RecordIterator() : impl(0), pos(0), cur_pos(0) {}
         108                 :
         109                 :         public:
         110                 :                 // Copy constructor
         111                 :                 RecordIterator(const RecordIterator& r);
         112                 :
         113                 :                 ~RecordIterator();
         114                 :                 std::string operator*();
         115                 :                 std::string* operator->();
         116                 :                 RecordIterator& operator++();
         117                 :                 RecordIterator& operator=(const RecordIterator& r);
         118                 :                 bool operator==(const RecordIterator&) const;
         119                 :                 bool operator!=(const RecordIterator&) const;
         120                 :
         121                 :                 // FIXME: Iterator operator++(int); cannot be easily implemented
         122                 :                 // because of how Apt's pkgIterator works
         123                 :
         124                 :                 friend class Apt;
         125                 :         };
         126                 :
         127                 :         typedef Iterator iterator;
         128                 :         typedef RecordIterator record_iterator;
         129                 :
         130                 :         /**
         131                 :          * Create the Apt data provider
         132                 :          */
         133                 :         Apt();
         134                 :         ~Apt();
         135                 :
         136                 :         iterator begin() const;
         137                 :         iterator end() const;
         138                 :
         139                 :         record_iterator recordBegin() const;
         140                 :         record_iterator recordEnd() const;
         141                 :
         142                 :
         143                 :         /// Return the number of packages in the archive
         144                 :         size_t size() const;
         145                 :
         146                 :         /**
         147                 :          * Validate a package name, returning trye if it exists in the APT database,
         148                 :          * or false if it does not.
         149                 :          */
         150                 :         bool isValid(const std::string& pkg) const;
         151                 :
         152                 :         /// Validate a package name, returning it if it exists in the APT database,
         153                 :         /// or returning the empty string if it does not.
         154                 :         std::string validate(const std::string& pkg) const
         155                 :         {
         156                 :                 if (isValid(pkg))
         157                 :                         return pkg;
         158                 :                 return std::string();
         159                 :         }
         160                 :
         161                 :         /// Validate a Version, returning it if it exists in the APT database, or
         162                 :         /// returning the invalid version if it does not.
         163                 :         Version validate(const Version& ver) const;
         164                 :
         165                 :         /// Return the installed version for a package
         166                 :         Version installedVersion(const std::string& pkg) const;
         167                 :
         168                 :         /// Return the candidate version for a package
         169                 :         Version candidateVersion(const std::string& pkg) const;
         170                 :
         171                 :         /**
         172                 :          * Return the candidate version for a package, if available, or the
         173                 :          * installed version otherwise
         174                 :          */
         175                 :         Version anyVersion(const std::string& pkg) const;
         176                 :
         177                 :         /// Return state information on a package
         178                 :         PackageState state(const std::string& pkg) const;
         179                 :
         180                 :         /**
         181                 :          * Perform a package search.
         182                 :          *
         183                 :          * All packages for which the functor filter returns true, are passed to
         184                 :          * the functor out.
         185                 :          */
         186                 :         //template<typename FILTER, typename OUT>
         187                 :         //void search(const FILTER& filter, OUT& out);
         188                 :
         189                 :         /// Get the raw package record for the given Version
         190                 :         std::string rawRecord(const std::string& pkg) const;
         191                 :
         192                 :         /// Get the raw package record for the given Version
         193                 :         std::string rawRecord(const Version& ver) const;
         194                 :
         195                 :         /// Timestamp of when the apt index was last modified
         196                 :         time_t timestamp();
         197                 :
         198                 :         /**
         199                 :          * Check if the cache has been changed by another process, and reopen it if
         200                 :          * that is the case.
         201                 :          *
         202                 :          * Note that this method can invalidate all existing iterators.
         203                 :          */
         204                 :         void checkCacheUpdates();
         205                 :
         206                 :         /**
         207                 :          * Invalidate the cache timestamp used to track cache updates.
         208                 :          *
         209                 :          * @warning Do not use this method: it is here only to support the test
         210                 :          * cases, and may disappear in any future version.
         211                 :          */
         212                 :         void invalidateTimestamp();
         213                 : };
         214                 :
         215                 : }
         216                 : }
         217                 :
         218                 : // vim:set ts=4 sw=4:
         219                 : #endif

Generated by: LTP GCOV extension version 1.6