LTP GCOV extension - code coverage report
Current view: directory - usr/include/tagcoll-2.0.11/tagcoll/diskindex - mmap.h
Test: lcov.info
Date: 2008-08-14 Instrumented lines: 4
Code covered: 100.0 % Executed lines: 4

       1                 : #ifndef TAGCOLL_DISKINDEX_MMAP_H
       2                 : #define TAGCOLL_DISKINDEX_MMAP_H
       3                 : 
       4                 : /** \file
       5                 :  * Basic infrastructure for implementing mmapped indexes
       6                 :  */
       7                 : 
       8                 : /*
       9                 :  * Copyright (C) 2006  Enrico Zini <enrico@debian.org>
      10                 :  *
      11                 :  * This program is free software; you can redistribute it and/or modify
      12                 :  * it under the terms of the GNU General Public License as published by
      13                 :  * the Free Software Foundation; either version 2 of the License, or
      14                 :  * (at your option) any later version.
      15                 :  *
      16                 :  * This program 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
      19                 :  * GNU General Public License for more details.
      20                 :  *
      21                 :  * You should have received a copy of the GNU General Public License
      22                 :  * along with this program; if not, write to the Free Software
      23                 :  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
      24                 :  */
      25                 : 
      26                 : #include <string>
      27                 : 
      28                 : namespace tagcoll {
      29                 : namespace diskindex {
      30                 : 
      31                 : class mmap;
      32                 : 
      33                 : /**
      34                 :  * Performs the memory management and mmapping tasks for mmapped indexes.
      35                 :  *
      36                 :  * One MMap can contain many indexes.  Indexes come chained one after the
      37                 :  * other, prefixed by an int that specifies their length:
      38                 :  *
      39                 :  * [size of index 1][index1][size of index 2][index]...
      40                 :  *
      41                 :  * Every index must make sure that its size is int-aligned, otherwise accessing
      42                 :  * it would cause a bus error in many architectures.
      43                 :  */
      44                 : class MasterMMap
      45                 : {
      46                 : protected:
      47                 :         std::string m_filename;
      48                 :         size_t m_size;
      49                 :         int m_fd;
      50                 :         const char* m_buf;
      51                 : 
      52                 : public:
      53                 :         MasterMMap();
      54                 :         MasterMMap(const std::string& filename);
      55                 :         ~MasterMMap();
      56                 : 
      57                 :         void init(const std::string& filename);
      58                 :         
      59                 :         friend class MMap;
      60                 : };
      61                 : 
      62                 : class MMap
      63                 : {
      64                 : protected:
      65                 :         const MasterMMap* m_master;
      66                 :         const char* m_buf;
      67                 :         size_t m_size;
      68                 : 
      69                 : public:
      70                 :         MMap();
      71                 :         MMap(const char* buf, int size);
      72                 :         MMap(const MasterMMap& master, size_t idx);
      73                 : 
      74                 :         void init(const char* buf, int size);
      75                 :         void init(const MasterMMap& master, size_t idx);
      76                 : 
      77                 :         /// Round a value to the next word size in the current architecture
      78                 :         template<class INT>
      79              12 :         static inline INT align(INT val)
      80                 :         {
      81              12 :                 return (val + sizeof(int) - 1) & ~(sizeof(int) - 1);
      82                 :         }
      83                 : };
      84                 : 
      85                 : /**
      86                 :  * Interface for indexers.
      87                 :  */
      88                 : class MMapIndexer
      89              20 : {
      90                 : public:
      91              20 :         virtual ~MMapIndexer() {}
      92                 : 
      93                 :         /// Return the size of the encoded index data (in bytes)
      94                 :         virtual int encodedSize() const = 0;
      95                 : 
      96                 :         /// Write the index data in the given buffer, which should be at least
      97                 :         /// encodedSize bytes
      98                 :         virtual void encode(char* buf) const = 0;
      99                 : };
     100                 : 
     101                 : /**
     102                 :  * Master index writer.  It allows to write many indexes in the same file,
     103                 :  * atomically: the file will be created as a tempfile and atomically renamed to
     104                 :  * the destination filename on class destruction.
     105                 :  */
     106                 : class MasterMMapIndexer
     107                 : {
     108                 : protected:
     109                 :         std::string finalname;
     110                 :         std::string tmpname;
     111                 :         int fd;
     112                 : 
     113                 : public:
     114                 :         MasterMMapIndexer(const std::string& filename);
     115                 :         ~MasterMMapIndexer();
     116                 : 
     117                 :         /// Close the file and perform the final rename
     118                 :         void commit();
     119                 : 
     120                 :         /// Append one subindex
     121                 :         void append(const MMapIndexer& idx);
     122                 : };
     123                 : 
     124                 : 
     125                 : }
     126                 : }
     127                 : 
     128                 : // vim:set ts=4 sw=4:
     129                 : #endif

Generated by: LTP GCOV extension version 1.6