bitfield.h

Go to the documentation of this file.

 
 
 
// Copyright (C) 1997-2020 by Pawel Pilarczyk.
//
// This file is part of my research software package. This is free software:
// you can redistribute it and/or modify it under the terms of the GNU
// General Public License as published by the Free Software Foundation,
// either version 3 of the License, or (at your option) any later version.
//
// This software is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this software; see the file "license.txt". If not,
// please, see <https://www.gnu.org/licenses/>.
 
// Started in April 1999. Last revision: May 24, 2010.
 
 
#ifndef _CHOMP_STRUCT_BITFIELD_H_
#define _CHOMP_STRUCT_BITFIELD_H_
 
#include "chomp/system/config.h"
 
#include <iostream>
#include <cstdlib>
 
namespace chomp {
namespace homology {
 
 
// classes defined within this header file:
class BitField;
class SetOfBitFields;
 
typedef BitField bitfield;
 
typedef SetOfBitFields bitfieldset;
 
 
// --------------------------------------------------
// ------------------- BitField ---------------------
// --------------------------------------------------
 
class BitField
{
public:
        BitField ();
 
        ~BitField ();
 
        bool defined () const;
 
        void define (unsigned char *buf, int_t length);
 
        void allocate (int_t length);
 
        void free ();
 
        void set (int_t n);
 
        void clear (int_t n);
 
        int test (int_t n) const;
 
        void takebits (const BitField &from, int_t length);
 
        void clearall (int_t length);
 
        int find (int_t first, int_t length) const;
 
        int_t hashkey (int_t length) const;
 
        int_t hashadd (int_t length) const;
 
        friend bool thesame (const BitField &b1, const BitField &b2,
                int_t length);
 
        friend void int2bits (int bits, int_t length, BitField &field);
 
        friend int bits2int (const BitField &field, int_t length);
 
private:
        unsigned char *table;
 
}; /* BitField */
 
// --------------------------------------------------
 
inline BitField::BitField ()
{
        table = NULL;
        return;
} /* BitField::BitField */
 
inline bool BitField::defined () const
{
        return !!table;
} /* BitField::defined */
 
inline void BitField::free ()
{
        delete [] table;
        table = NULL;
        return;
} /* BitField::free */
 
inline BitField::~BitField ()
{
        return;
} /* BitField::~BitField */
 
inline void BitField::set (int_t n)
{
        table [n >> 3] |= static_cast<unsigned char> (0x01 << (n & 0x07));
        return;
} /* BitField::set */
 
inline void BitField::clear (int_t n)
{
        table [n >> 3] &= static_cast<unsigned char> (~(0x01 << (n & 0x07)));
        return;
} /* BitField::clear */
 
inline int BitField::test (int_t n) const
{
        return !!(table [n >> 3] & (0x01 << (n & 0x07)));
} /* BitField::test */
 
inline void int2bits (int bits, int_t length, BitField &field)
{
        unsigned char *tab = field. table;
        if (!tab)
                throw "Trying to set values to an undefined bitfield.";
        while (length >= 0)
        {
                *(tab ++) = static_cast<unsigned char> (bits & 0xFF);
                bits >>= 8;
                length -= 8;
        }
        return;
} /* int2bits */
 
inline int bits2int (const BitField &field, int_t length)
{
        const unsigned char *tab = field. table;
        if (!tab)
                throw "Trying to set values to an undefined bitfield.";
        int n = 0;
        int shiftvalue = 0;
        while (length >= 8)
        {
                n |= (*(tab ++)) << shiftvalue;
                length -= 8;
                shiftvalue += 8;
        }
        const int bitmasks [] = {0x00, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x7F, 0xFF};
        if (length > 0)
                n |= ((*(tab ++)) & bitmasks [length]) << shiftvalue;
        return n;
} /* bits2int */
 
 
// --------------------------------------------------
// ----------------- SetOfBitFields -----------------
// --------------------------------------------------
 
class SetOfBitFields
{
public:
        SetOfBitFields (int_t len, int_t maxelem);
 
        ~SetOfBitFields ();
 
        int add (const BitField &b, int value);
 
        int check (const BitField &b) const;
 
        int used (void) const;
 
        void forget ();
 
private:
        int avail;
 
        int usedcount;
 
        int_t size;
 
        int_t length;
 
        BitField *bf;
 
        BitField values;
 
        unsigned char *buf;
 
        unsigned char *bufcur;
 
}; /* class SetOfBitFields */
 
// --------------------------------------------------
 
inline SetOfBitFields::~SetOfBitFields ()
{
        if (bf)
                delete [] bf;
        if (buf)
                delete [] buf;
        if (length)
                values. free ();
        return;
} /* SetOfBitFields::~SetOfBitFields */
 
inline int SetOfBitFields::used () const
{
        return usedcount;
} /* SetOfBitFields::used */
 
inline void SetOfBitFields::forget ()
{
        if (bf)
                delete [] bf;
        bf = NULL;
        if (buf)
                delete [] buf;
        buf = NULL;
        if (length)
                values. free ();
        length = 0;
        size = 0;
        avail = 0;
        return;
} /* SetOfBitFields::forget */
 
 
} // namespace homology
} // namespace chomp
 
#endif // _CHOMP_STRUCT_BITFIELD_H_