LTP GCOV extension - code coverage report
Current view: | directory - ept/popcon - popcon.h
Test: | lcov.info
Date: | 2008-08-14 |  | Instrumented lines: | 25
Code covered: | 96.0 % |  | Executed lines: | 24

           1                 : // -*- mode: c++; tab-width: 4; indent-tabs-mode: t -*-
           2                 : #ifndef EPT_POPCON_POPCON_H
           3                 : #define EPT_POPCON_POPCON_H
           4                 :
           5                 : /** @file
           6                 :  * @author Enrico Zini <enrico@enricozini.org>
           7                 :  * Access popcon data
           8                 :  */
           9                 :
          10                 : /*
          11                 :  * Copyright (C) 2007  Enrico Zini <enrico@debian.org>
          12                 :  *
          13                 :  * This program is free software; you can redistribute it and/or modify
          14                 :  * it under the terms of the GNU General Public License as published by
          15                 :  * the Free Software Foundation; either version 2 of the License, or
          16                 :  * (at your option) any later version.
          17                 :  *
          18                 :  * This program is distributed in the hope that it will be useful,
          19                 :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
          20                 :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
          21                 :  * GNU General Public License for more details.
          22                 :  *
          23                 :  * You should have received a copy of the GNU General Public License
          24                 :  * along with this program; if not, write to the Free Software
          25                 :  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
          26                 :  */
          27                 :
          28                 : #include <tagcoll/diskindex/mmap.h>
          29                 : #include <string>
          30                 :
          31                 : namespace ept {
          32                 : namespace apt {
          33                 : class Apt;
          34                 : }
          35                 :
          36                 : namespace popcon {
          37                 :
          38                 : /**
          39                 :  * Store the score information in the popcon cache.
          40                 :  *
          41                 :  * Currently, this is only one float; more can be added in the future.
          42                 :  */
          43                 : class Score
          44                 : {
          45                 : protected:
          46                 :         unsigned offset;
          47                 :
          48                 : public:
          49                 :         float score;
          50                 :
          51           69910 :         Score(float score) : offset(offset), score(score) {}
          52                 :
          53                 :         friend class Popcon;
          54                 :         friend class PopconIndexer;
          55                 :         friend class PopconGenerator;
          56                 : };
          57                 :
          58                 : /**
          59                 :  * Maps Packages to IDs and vice-versa.
          60                 :  *
          61                 :  * This is used in building the Debtags fast index, which works representing
          62                 :  * tags and packages as int IDs.
          63                 :  *
          64                 :  * Index building works like this:
          65                 :  *  1. The file all-popcon-results.txt.gz is downloaded from
          66                 :  *     http://popcon.debian.org/all-popcon-results.txt.gz
          67                 :  *  2. The file is put in either ~/.popcon/all-popcon-results.txt.gz
          68                 :  *     or in /var/lib/popcon/all-popcon-results.txt.gz
          69                 :  *  3. If the file is newer than the index, it will be automatically used to
          70                 :  *     recompute the scores and rebuild the index.
          71                 :  */
          72                 : class Popcon : public tagcoll::diskindex::MMap
          73               7 : {
          74                 :         struct GeneralInfo : public tagcoll::diskindex::MMap
          75               7 :         {
          76                 :                 size_t submissions() const;
          77                 :         };
          78                 :
          79                 :         tagcoll::diskindex::MasterMMap mastermmap;
          80                 :         time_t m_timestamp;
          81                 :
          82                 :         GeneralInfo m_info;
          83                 :
          84                 :         /// Get the score structure by index
          85          102350 :         const Score* structByIndex(size_t idx) const
          86                 :         {
          87          102350 :                 if (idx >= 0 && idx < size())
          88          102350 :                         return (Score*)m_buf + idx;
          89               0 :                 return 0;
          90                 :         }
          91                 :
          92                 : public:
          93                 :         Popcon();
          94                 :
          95                 :         /// Get the timestamp of when the index was last updated
          96               1 :         time_t timestamp() const { return m_timestamp; }
          97                 :
          98                 :         /// Return true if this data source has data, false if it's empty
          99               1 :         bool hasData() const { return m_timestamp != 0; }
         100                 :
         101                 :         /// Return the total number of popcon submissions
         102               3 :         size_t submissions() const { return m_info.submissions(); }
         103                 :
         104                 :         /// Get the number of packages in the index
         105          174055 :         size_t size() const
         106                 :         {
         107          174055 :                 if (m_buf)
         108          174053 :                         return ((Score*)m_buf)->offset / sizeof(Score);
         109                 :                 else
         110               2 :                         return 0;
         111                 :         }
         112                 :
         113                 :         /**
         114                 :          * Get a package name by index
         115                 :          *
         116                 :          * If the index is not valid, returns the empty string.
         117                 :          */
         118           30678 :         std::string name(size_t idx) const
         119                 :         {
         120           30678 :                 const Score* s = structByIndex(idx);
         121           30678 :                 if (s == 0) return std::string();
         122           30678 :                 return std::string(m_buf + s->offset);
         123                 :         }
         124                 :
         125                 :         /// Get the score by index
         126           71672 :         float scoreByIndex(size_t idx) const
         127                 :         {
         128           71672 :                 const Score* s = structByIndex(idx);
         129           71672 :                 if (!s) return 0;
         130           71672 :                 return s->score;
         131                 :         }
         132                 :
         133                 :         /// Get the score structure by package name
         134                 :         float scoreByName(const std::string& name) const;
         135                 :
         136                 :         /// Get the score by index
         137           71672 :         float score(size_t idx) const { return scoreByIndex(idx); }
         138                 :
         139                 :         /// Get the score by index
         140                 :         float operator[](int idx) const { return scoreByIndex(idx); }
         141                 :
         142                 :         /// Get the score by name
         143            1790 :         float score(const std::string& name) const { return scoreByName(name); }
         144                 :
         145                 :         /// Get the score structure by package name
         146               2 :         float operator[](const std::string& name) const { return scoreByName(name); }
         147                 : };
         148                 :
         149                 : }
         150                 : }
         151                 :
         152                 : // vim:set ts=4 sw=4:
         153                 : #endif

Generated by: LTP GCOV extension version 1.6