LTP GCOV extension - code coverage report
Current view: directory - usr/include/tagcoll-2.0.11/tagcoll - TextFormat.h
Test: lcov.info
Date: 2008-08-14 Instrumented lines: 7
Code covered: 14.3 % Executed lines: 1

       1                 : #ifndef TAGCOLL_TEXTFORMAT_H
       2                 : #define TAGCOLL_TEXTFORMAT_H
       3                 : 
       4                 : /** \file
       5                 :  * Serialize and deserialize a tagged collection to a text file
       6                 :  */
       7                 : 
       8                 : /*
       9                 :  * Copyright (C) 2003--2006  Enrico Zini <enrico@debian.org>
      10                 :  *
      11                 :  * This library is free software; you can redistribute it and/or
      12                 :  * modify it under the terms of the GNU Lesser General Public
      13                 :  * License as published by the Free Software Foundation; either
      14                 :  * version 2.1 of the License, or (at your option) any later version.
      15                 :  *
      16                 :  * This library is distributed in the hope that it will be useful,
      17                 :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      18                 :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      19                 :  * Lesser General Public License for more details.
      20                 :  *
      21                 :  * You should have received a copy of the GNU Lesser General Public
      22                 :  * License along with this library; if not, write to the Free Software
      23                 :  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
      24                 :  */
      25                 : 
      26                 : #include <wibble/mixin.h>
      27                 : #include <wibble/empty.h>
      28                 : #include <wibble/singleton.h>
      29                 : #include <tagcoll/input/base.h>
      30                 : 
      31                 : #include <stdio.h>
      32                 : 
      33                 : //#define TRACE_PARSE
      34                 : 
      35                 : namespace tagcoll
      36                 : {
      37                 : template<class ITEM, class TAG>
      38                 : class PatchList;
      39                 : template<class ITEM, class TAG>
      40                 : class Patch;
      41                 : 
      42                 : namespace textformat
      43                 : {
      44                 : 
      45                 : /**
      46                 :  * TagcollConsumer that serializes its input to an output stream
      47                 :  *
      48                 :  * The format of the output is:
      49                 :  *   lines of "comma+space"-separated items, followed by "colon+space",
      50                 :  *   followed by the corresponding "comma+space"-separated tags.
      51                 :  * Examples:
      52                 :  *   ITEM:
      53                 :  *   ITEM: TAG
      54                 :  *   ITEM: TAG1, TAG2, TAG3
      55                 :  *   ITEM1, ITEM2, ITEM3:
      56                 :  *   ITEM1, ITEM2, ITEM3: TAG1, TAG2, TAG3
      57                 :  */
      58                 : class StdioWriter : public wibble::mixin::OutputIterator<StdioWriter>
      59                 : {
      60                 : protected:
      61                 :         FILE* out;
      62                 : 
      63                 : public:
      64               1 :         StdioWriter(FILE* out) : out(out) {}
      65                 : 
      66                 :         template<typename Items, typename Tags>
      67                 :         StdioWriter& operator=(const std::pair<Items, Tags>& data);
      68                 : };
      69                 : 
      70                 : class OstreamWriter : public wibble::mixin::OutputIterator<OstreamWriter>
      71                 : {
      72                 : protected:
      73                 :         std::ostream& out;
      74                 : 
      75                 : public:
      76                 :         OstreamWriter(std::ostream& out) : out(out) {}
      77                 : 
      78                 :         template<typename Items, typename Tags>
      79                 :         OstreamWriter& operator=(const std::pair<Items, Tags>& data);
      80                 : };
      81                 : 
      82                 : /**
      83                 :  * Parse an element from input
      84                 :  *
      85                 :  * @retval item
      86                 :  *   The item found on input
      87                 :  * @return
      88                 :  *   the trailing separating char, that can be:
      89                 :  *   \li input::Input::Eof
      90                 :  *   \li '\n'
      91                 :  *   \li ':'
      92                 :  *   \li ','
      93                 :  */
      94                 : int parseElement(input::Input& in, std::string& item);
      95                 : 
      96                 : 
      97                 : /**
      98                 :  * Serialize a patch
      99                 :  */
     100                 : template<typename ITEM, typename TAG, typename ITEMSER, typename TAGSER>
     101                 : void outputPatch(
     102                 :                 ITEMSER& itemconv,
     103                 :                 TAGSER& tagconv,
     104                 :                 const PatchList<ITEM, TAG>& patch,
     105                 :                 FILE* out);
     106                 : 
     107                 : void outputPatch(
     108                 :                 const PatchList<std::string, std::string>& patch,
     109                 :                 FILE* out);
     110                 : 
     111                 : 
     112                 : /*
     113                 :  * Parse a tagged collection, sending the results to out.
     114                 :  *
     115                 :  * @param out
     116                 :  *   An output iterator accepting a std::pair<string, string>
     117                 :  */
     118                 : template<typename OUT>
     119                 : void parse(input::Input& in, OUT out);
     120                 : 
     121                 : /**
     122                 :  * Assemble a patch from a stream of "item: +added, -removed" items and tags
     123                 :  */
     124                 : template<typename OUT>
     125                 : class PatchAssembler : public wibble::mixin::OutputIterator< PatchAssembler<OUT> >
     126                 : {
     127                 :         OUT out;
     128                 : public:
     129               0 :         PatchAssembler(const OUT& out) : out(out) {}
     130                 : 
     131                 :         template<typename ITEMS, typename TAGS>
     132                 :         PatchAssembler& operator=(const std::pair<ITEMS, TAGS>& data);
     133                 : };
     134                 : 
     135                 : template<typename OUT>
     136               0 : PatchAssembler<OUT> patchAssembler(const OUT& out)
     137                 : {
     138               0 :         return PatchAssembler<OUT>(out);
     139                 : }
     140                 : 
     141                 : template<typename OUT>
     142               0 : void parsePatch(input::Input& in, OUT out)
     143                 : {
     144               0 :         parse(in, patchAssembler(out));
     145               0 : }
     146                 : 
     147                 : /**
     148                 :  * Parse a tagcoll patch
     149                 :  */
     150                 : template<typename ITEM, typename TAG, typename ITEMSER, typename TAGSER>
     151                 : PatchList<ITEM, TAG> parsePatch(
     152                 :                 ITEMSER& itemconv,
     153                 :                 TAGSER& tagconv,
     154                 :                 input::Input& in);
     155                 : 
     156                 : PatchList<std::string, std::string> parsePatch(input::Input& in);
     157                 : 
     158                 : 
     159                 : 
     160                 : template<typename ITEM, typename TAG, typename ITEMSER, typename TAGSER>
     161                 : class PatchBuilder : public wibble::mixin::OutputIterator< PatchBuilder<ITEM, TAG, ITEMSER, TAGSER> >
     162                 : {
     163                 : protected:
     164                 :         PatchList<ITEM, TAG>& patch;
     165                 :         const ITEMSER& itemconv;
     166                 :         const TAGSER& tagconv;
     167                 : 
     168                 : public:
     169                 :         PatchBuilder(
     170                 :                         PatchList<ITEM, TAG>& patch,
     171                 :                         const ITEMSER& itemconv,
     172                 :                         const TAGSER& tagconv)
     173                 :                 : patch(patch), itemconv(itemconv), tagconv(tagconv) {}
     174                 : 
     175                 :         template<typename ITEMS, typename TAGS>
     176                 :         PatchBuilder<ITEM, TAG, ITEMSER, TAGSER>& operator=(const std::pair<ITEMS, TAGS>& data);
     177                 : 
     178                 :         const PatchList<ITEM, TAG>& getPatch() const throw () { return patch; }
     179                 : };
     180                 : 
     181                 : template<typename ITEM, typename TAG, typename ITEMSER, typename TAGSER>
     182                 : PatchBuilder<ITEM, TAG, ITEMSER, TAGSER> patchBuilder(
     183                 :                         PatchList<ITEM, TAG>& patch,
     184                 :                         const ITEMSER& itemconv,
     185                 :                         const TAGSER& tagconv)
     186                 : {
     187                 :         return PatchBuilder<ITEM, TAG, ITEMSER, TAGSER>(patch, itemconv, tagconv);
     188                 : }
     189                 : 
     190                 : }
     191                 : }
     192                 : 
     193                 : // vim:set ts=4 sw=4:
     194                 : #endif

Generated by: LTP GCOV extension version 1.6