LTP GCOV extension - code coverage report
Current view: directory - ept/debtags - tag.h
Test: lcov.info
Date: 2008-08-14 Instrumented lines: 16
Code covered: 93.8 % Executed lines: 15

       1                 : // -*- C++ -*-
       2                 : #ifndef EPT_DEBTAGS_TAG_H
       3                 : #define EPT_DEBTAGS_TAG_H
       4                 : 
       5                 : /** \file
       6                 :  * Debtags facets and tags
       7                 :  */
       8                 : 
       9                 : /*
      10                 :  * Copyright (C) 2005,2006,2007  Enrico Zini <enrico@debian.org>
      11                 :  *
      12                 :  * This program is free software; you can redistribute it and/or modify
      13                 :  * it under the terms of the GNU General Public License as published by
      14                 :  * the Free Software Foundation; either version 2 of the License, or
      15                 :  * (at your option) any later version.
      16                 :  *
      17                 :  * This program 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
      20                 :  * GNU General Public License for more details.
      21                 :  *
      22                 :  * You should have received a copy of the GNU General Public License
      23                 :  * along with this program; if not, write to the Free Software
      24                 :  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
      25                 :  */
      26                 : 
      27                 : #include <set>
      28                 : #include <string>
      29                 : 
      30                 : namespace ept {
      31                 : namespace debtags {
      32                 : 
      33                 : class Vocabulary;
      34                 : 
      35                 : class Tag;
      36                 : 
      37                 : /**
      38                 :  * Representation of a facet.
      39                 :  *
      40                 :  * ept::debtags::Facet represents a Facet with all its informations.
      41                 :  * It is guaranteed to have fast value-copy semantics, so it can be passed
      42                 :  * around freely and efficiently without worrying about memory management
      43                 :  * issues.
      44                 :  *
      45                 :  * The class is normally instantiated using a Vocabulary:
      46                 :  * \code
      47                 :  *      Facet facet = vocabulary.faceByName("made-of");
      48                 :  * \endcode
      49                 :  *
      50                 :  * Facets can contain an "invalid" value, in which case using any of their
      51                 :  * methods will likely produce segfault.  The "invalid" facets are useful as
      52                 :  * "none" return values:
      53                 :  *
      54                 :  * \code
      55                 :  *    Facet facet = vocabulary.facetByName("made-of");
      56                 :  *    if (!facet)
      57                 :  *       throw SomeException("facet \"made-of\" has not been defined");
      58                 :  * \endcode
      59                 :  */
      60                 : class Facet
      61                 : {
      62                 : protected:
      63                 :         const Vocabulary* m_tags;
      64                 :         int m_id;
      65                 : 
      66             120 :         Facet(const Vocabulary* tags, int id) : m_tags(tags), m_id(id) {}
      67                 : 
      68                 : public:
      69                 :         Facet() : m_tags(0), m_id(-1) {}
      70             265 :         ~Facet() {}
      71                 : 
      72              29 :         bool operator==(const Facet& f) const { return m_id == f.m_id; }
      73                 :         bool operator!=(const Facet& f) const { return m_id != f.m_id; }
      74             600 :         bool operator<(const Facet& f) const { return m_id < f.m_id; }
      75                 : 
      76                 :         /**
      77                 :          * Return true if the facet is valid
      78                 :          */
      79               0 :         operator bool() const { return m_id != -1; }
      80             353 :         bool valid() const { return m_id != -1; }
      81                 : 
      82                 :         /**
      83                 :          * Return the name of the facet
      84                 :          * @throws std::out_of_range if the facet is not valid
      85                 :          */
      86                 :         std::string name() const;
      87                 :         /**
      88                 :          * Return the name of the facet
      89                 :          * 
      90                 :          * Returns d if the facet is not valid.
      91                 :          */
      92                 :         std::string name(const std::string& d) const;
      93                 : 
      94                 :         /**
      95                 :          * Return the short description of the facet
      96                 :          * @throws std::out_of_range if the facet is not valid
      97                 :          */
      98                 :         std::string shortDescription() const;
      99                 :         /**
     100                 :          * Return the short description of the facet
     101                 :          *
     102                 :          * Returns d if the facet is not valid.
     103                 :          */
     104                 :         std::string shortDescription(const std::string& d) const;
     105                 : 
     106                 :         /**
     107                 :          * Return the long description of the facet
     108                 :          * @throws std::out_of_range if the facet is not valid
     109                 :          */
     110                 :         std::string longDescription() const;
     111                 :         /**
     112                 :          * Return the long description of the facet
     113                 :          *
     114                 :          * Returns d if the facet is not valid.
     115                 :          */
     116                 :         std::string longDescription(const std::string& d) const;
     117                 : 
     118                 :         /**
     119                 :          * Return true if the facet has a tag with the given name (name, not fullname)
     120                 :          */
     121                 :         bool hasTag(const std::string& name) const;
     122                 : 
     123                 :         /**
     124                 :          * Return the list of tags in this facet
     125                 :          */
     126                 :         std::set<Tag> tags() const;
     127                 : 
     128                 :         /**
     129                 :          * Return the ID of this facet
     130                 :          *
     131                 :          * @warning This method is exported to help in writing tests, but it is not
     132                 :          * part of the normal API: do not use it, because future implementations may
     133                 :          * not be based on IDs and therefore not have this method.
     134                 :          */
     135              58 :         int id() const { return m_id; }
     136                 : 
     137                 :         friend class Vocabulary;
     138                 : };
     139                 : 
     140                 : /**
     141                 :  * Representation of a tag.
     142                 :  *
     143                 :  * ept::debtags::Tag represents a Tag with all its informations.
     144                 :  * It is guaranteed to have fast value-copy semantics, so it can be passed
     145                 :  * around freely and efficiently without worrying about memory management
     146                 :  * issues.
     147                 :  *
     148                 :  * The class is normally instantiated using a Vocabulary:
     149                 :  * \code
     150                 :  *      Tag tag = vocabulary.tagByName("made-of::lang:c++");
     151                 :  * \endcode
     152                 :  *
     153                 :  * Tags can contain an "invalid" value, in which case using any of their
     154                 :  * methods will likely produce segfault.  The "invalid" facets are useful as
     155                 :  * "none" return values:
     156                 :  *
     157                 :  * \code
     158                 :  *    Tag tag = vocabulary.tagByName("made-of");
     159                 :  *    if (!tag)
     160                 :  *       throw SomeException("tag \"mytag\" has not been defined");
     161                 :  * \endcode
     162                 :  */
     163                 : class Tag
     164                 : {
     165                 : protected:
     166                 :         const Vocabulary* m_tags;
     167                 :         int m_id;
     168                 : 
     169          745056 :         Tag(const Vocabulary* tags, int id) : m_tags(tags), m_id(id) {}
     170                 : 
     171                 : public:
     172                 :         typedef std::set< Tag > Set;
     173                 : 
     174               2 :         Tag() : m_tags(0), m_id(-1) {}
     175         2229812 :         ~Tag() {}
     176                 : 
     177            1228 :         bool operator==(const Tag& f) const { return m_id == f.m_id; }
     178               5 :         bool operator!=(const Tag& f) const { return m_id != f.m_id; }
     179         2300524 :         bool operator<(const Tag& f) const { return m_id < f.m_id; }
     180                 : 
     181               1 :         operator bool() const { return m_id != -1; }
     182          324422 :         bool valid() const { return m_id != -1; }
     183                 : 
     184                 :         Facet facet() const;
     185                 : 
     186                 :         /**
     187                 :          * Return the name of the tag, without the facet:: prefix
     188                 :          * @throws std::out_of_range if the tag is not valid
     189                 :          */
     190                 :         std::string name() const;
     191                 :         /**
     192                 :          * Return the short description of the tag
     193                 :          *
     194                 :          * Returns d if the tag is not valid.
     195                 :          */
     196                 :         std::string name(const std::string& d) const;
     197                 : 
     198                 :         /**
     199                 :          * Return the name of the tag, with the facet:: prefix
     200                 :          * @throws std::out_of_range if the tag is not valid
     201                 :          */
     202                 :         std::string fullname() const;
     203                 :         /**
     204                 :          * Return the short description of the tag
     205                 :          *
     206                 :          * Returns d if the tag is not valid.
     207                 :          */
     208                 :         std::string fullname(const std::string& d) const;
     209                 : 
     210                 :         /**
     211                 :          * Return the short description of the tag
     212                 :          * @throws std::out_of_range if the tag is not valid
     213                 :          */
     214                 :         std::string shortDescription() const;
     215                 :         /**
     216                 :          * Return the short description of the tag
     217                 :          *
     218                 :          * Returns d if the tag is not valid.
     219                 :          */
     220                 :         std::string shortDescription(const std::string& d) const;
     221                 : 
     222                 :         /**
     223                 :          * Return the long description of the tag
     224                 :          *
     225                 :          * @throws std::out_of_range if the tag is not valid
     226                 :          */
     227                 :         std::string longDescription() const;
     228                 :         /**
     229                 :          * Return the long description of the tag
     230                 :          *
     231                 :          * Returns d if the tag is not valid.
     232                 :          */
     233                 :         std::string longDescription(const std::string& d) const;
     234                 : 
     235                 :         /**
     236                 :          * Return the ID of this tag
     237                 :          *
     238                 :          * @warning This method is exported to help in writing tests, but it is not
     239                 :          * part of the normal API: do not use it, because future implementations may
     240                 :          * not be based on IDs and therefore not have this method.
     241                 :          */
     242          106853 :         int id() const { return m_id; }
     243                 : 
     244                 :         friend class Vocabulary;
     245                 : };
     246                 : 
     247                 : }
     248                 : }
     249                 : 
     250                 : // vim:set ts=3 sw=3:
     251                 : #endif

Generated by: LTP GCOV extension version 1.6