LCOV - code coverage report
Current view: top level - src - filter.h (source / functions) Hit Total Coverage
Test: test_coverage.info Lines: 47 59 79.7 %
Date: 2017-06-21 14:32:49 Functions: 4 5 80.0 %

          Line data    Source code
       1             : //////////////////////////////////////////////////////////////////////
       2             : //
       3             : //  FILE:       filter.h
       4             : //              Filter and CompressedFilter Classes
       5             : //
       6             : //  Part of:    Scid (Shane's Chess Information Database)
       7             : //  Version:    1.4
       8             : //
       9             : //  Notice:     Copyright (c) 2000  Shane Hudson.  All rights reserved.
      10             : //
      11             : //  Author:     Shane Hudson (sgh@users.sourceforge.net)
      12             : //
      13             : //////////////////////////////////////////////////////////////////////
      14             : 
      15             : 
      16             : #ifndef SCID_FILTER_H
      17             : #define SCID_FILTER_H
      18             : 
      19             : #include "common.h"
      20             : #include <algorithm>
      21             : 
      22             : //////////////////////////////////////////////////////////////////////
      23             : //
      24             : // Filter class:
      25             : //
      26             : //    Holds the results of a database search: one byte per game,
      27             : //    indicating whether that game is included in the filter or not.
      28             : //    A value of 0 indicates the game is excluded, or 1-255 indicates
      29             : //    the game is included, and what position to show when the game
      30             : //    is loaded: 1 means the start position, 2 means the position after
      31             : //    Whites first move, etc.
      32             : class Filter
      33             : {
      34             :   private:
      35             :     gamenumT FilterSize;     // Number of values in filter.
      36             :     gamenumT FilterCount;    // Number of nonzero values in filter.
      37             :     gamenumT Capacity;       // Number of values allocated for Data[].
      38             :     byte *   Data;           // The actual filter data.
      39             : 
      40             :     Filter(const Filter&);
      41             :     Filter& operator=(const Filter&);
      42             :     void Allocate();
      43             :     void Free();
      44             :     void SetCapacity (gamenumT size);
      45             :     friend class CompressedFilter;
      46             :     
      47             :   public:
      48         768 :     Filter (gamenumT size) :Data(NULL) { Init (size); }
      49         768 :     ~Filter() { Free(); }
      50             : 
      51             :     void    Init (gamenumT size);
      52             :     uint    Size() const { return FilterSize; }
      53             :     uint    Count () const { return FilterCount; }
      54             :     bool    isWhole () const { return FilterCount == FilterSize; }
      55             :     void    Set (gamenumT index, byte value); // Sets the value at index.
      56             :     byte    Get (gamenumT index) const;       // Gets the value at index.
      57             :     void    Fill (byte value);                // Sets all values.
      58             :     void    Append (byte value);              // Appends one value.
      59             : };
      60             : 
      61             : //////////////////////////////////////////////////////////////////////
      62             : //
      63             : // CompressedFilter class:
      64             : //    Holds the same data as a filter, in compressed format.
      65             : //    Random access to individual values is not possible.
      66             : //    A CompressedFilter is created from, or restored to, a regular
      67             : //    filter with the methods CompressFrom() and UncompressTo().
      68             : class CompressedFilter
      69             : {
      70             :   private:
      71             : 
      72             :     uint    CFilterSize;
      73             :     uint    CFilterCount;
      74             :     uint    CompressedLength;
      75             :     byte *  CompressedData;
      76             : 
      77             :   public:
      78        4000 :     CompressedFilter (void)     { Init(); }
      79             :     ~CompressedFilter (void) {
      80        2000 :         if (CompressedData != NULL) delete[] CompressedData;
      81             :     }
      82             : 
      83             :     inline void Clear();
      84             : 
      85             :     uint Size() const { return CFilterSize; }
      86             :     uint Count() { return CFilterCount; }
      87             : 
      88             :     errorT Verify (Filter * filter);
      89             : 
      90             :     void CompressFrom (Filter * filter);
      91             :     errorT UncompressTo(Filter * filter) const;
      92             : 
      93             :   private:
      94             :     CompressedFilter(const CompressedFilter&);
      95             :     void operator=(const CompressedFilter&);
      96             : 
      97             :     inline void Init();
      98             : };
      99             : 
     100             : 
     101             : inline void Filter::Init (uint size) {
     102         416 :     Free();
     103         416 :     FilterSize = size;
     104         416 :     FilterCount = size;
     105         416 :     Capacity = size;
     106          32 :     Data = NULL;
     107             : }
     108             : 
     109         209 : inline void Filter::Allocate()
     110             : {
     111         209 :     Free();
     112         209 :     Capacity = FilterSize > Capacity ? FilterSize : Capacity;
     113         209 :     Data = new byte [Capacity];
     114         209 :     byte * pb = Data;
     115         209 :     for (uint i=0; i < FilterSize; i++) { *pb++ = 1; }
     116         209 : }
     117             : 
     118             : inline void Filter::Free()
     119             : {
     120         625 :     if(Data != NULL) {
     121         209 :         delete[] Data;
     122          12 :         Data = NULL;
     123             :     }
     124             : }
     125             : 
     126        3380 : inline void Filter::Set (uint index, byte value)
     127             : {
     128        3380 :     ASSERT (index < FilterSize);
     129        3380 :     if (Data == NULL) {
     130         614 :         if (value == 1) return;
     131         202 :         Allocate();
     132             :     }
     133        2968 :     if (Data[index] != 0) FilterCount--;
     134        2968 :     if (value != 0) FilterCount++;
     135        2968 :     Data[index] = value;
     136             : }
     137             : 
     138             : inline byte Filter::Get (uint index) const
     139             : {
     140     4032418 :     ASSERT (index < FilterSize);
     141     4032418 :     byte res = (Data == NULL) ? 1 : Data[index];
     142             :     return res;
     143             : }
     144             : 
     145          37 : inline void Filter::Fill (byte value)
     146             : {
     147          37 :     if (value == 1) {
     148          18 :         if (Data != NULL) Free();
     149          18 :         FilterCount = FilterSize;
     150             :     } else {
     151          19 :         if (Data == NULL) Allocate();
     152          19 :         FilterCount = (value != 0) ? FilterSize : 0;
     153          19 :         std::fill(Data, Data + FilterSize, value);
     154             :     }
     155          37 : }
     156             : 
     157          22 : inline void Filter::Append (byte value)
     158             : {
     159          22 :     if (value != 0) FilterCount++;
     160          22 :     if (value != 1 && Data == NULL) Allocate();
     161          22 :     if (Data != NULL) {
     162           0 :         if (FilterSize >= Capacity) {
     163           0 :             SetCapacity(FilterSize > 512 ? FilterSize * 2 : 1024);
     164             :         }
     165           0 :         Data[FilterSize] = value;
     166             :     }
     167          22 :     FilterSize++;
     168          22 : }
     169             : 
     170           0 : inline void Filter::SetCapacity(gamenumT size)
     171             : {
     172           0 :     if (size > Capacity) {
     173           0 :         Capacity = size;
     174           0 :         if (Data != NULL) {
     175           0 :             byte * newData = new byte [Capacity];
     176           0 :             for (uint i=0; i < FilterSize; i++) newData[i] = Data[i];
     177           0 :             delete[] Data;
     178           0 :             Data = newData;
     179             :         }
     180             :     }
     181           0 : }
     182             : 
     183             : inline void
     184             : CompressedFilter::Init ()
     185             : {
     186        2000 :     CFilterSize = 0;
     187        2000 :     CFilterCount = 0;
     188        2000 :     CompressedLength = 0;
     189        2000 :     CompressedData = NULL;
     190             : }
     191             : 
     192             : inline void
     193             : CompressedFilter::Clear ()
     194             : {
     195             :     if (CompressedData != NULL) { delete[] CompressedData; }
     196             :     Init();
     197             : }
     198             : 
     199             : 
     200             : #endif  // #ifndef SCID_FILTER_H
     201             : 
     202             : //////////////////////////////////////////////////////////////////////
     203             : //  EOF: filter.h
     204             : //////////////////////////////////////////////////////////////////////

Generated by: LCOV version 1.12