bitfield.h

Go to the documentation of this file.

// Copyright (C) 1997-2010 by Pawel Pilarczyk.
//
// This file is part of the Homology Library.  This library 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 2 of the License, or (at your option) any later version.
//
// This library 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, write to the
// Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
// MA 02111-1307, USA.

// 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 after, 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_