vcl_bvector.h

来自「DTMK软件开发包,此为开源软件,是一款很好的医学图像开发资源.」· C头文件 代码 · 共 503 行 · 第 1/2 页

/*
 *
 * Copyright (c) 1994
 * Hewlett-Packard Company
 *
 * Permission to use, copy, modify, distribute and sell this software
 * and its documentation for any purpose is hereby granted without fee,
 * provided that the above copyright notice appear in all copies and
 * that both that copyright notice and this permission notice appear
 * in supporting documentation.  Hewlett-Packard Company makes no
 * representations about the suitability of this software for any
 * purpose.  It is provided "as is" without express or implied warranty.
 *
 *
 * Copyright (c) 1996
 * Silicon Graphics Computer Systems, Inc.
 *
 * Permission to use, copy, modify, distribute and sell this software
 * and its documentation for any purpose is hereby granted without fee,
 * provided that the above copyright notice appear in all copies and
 * that both that copyright notice and this permission notice appear
 * in supporting documentation.  Silicon Graphics makes no
 * representations about the suitability of this software for any
 * purpose.  It is provided "as is" without express or implied warranty.
 *
 * Copyright (c) 1997
 * Moscow Center for SPARC Technology
 *
 * Permission to use, copy, modify, distribute and sell this software
 * and its documentation for any purpose is hereby granted without fee,
 * provided that the above copyright notice appear in all copies and
 * that both that copyright notice and this permission notice appear
 * in supporting documentation.  Moscow Center for SPARC Technology makes no
 * representations about the suitability of this software for any
 * purpose.  It is provided "as is" without express or implied warranty.
 *
 */

// vcl_vector<bool> is replaced by vcl_bit_vector at present because partial
// specialization is not yet implemented.

#ifndef vcl_emulation_bvector_h
#define vcl_emulation_bvector_h

#include <vcl_cstddef.h>
#include "vcl_algobase.h"
#include "vcl_alloc.h"

#define __WORD_BIT (int(CHAR_BIT*sizeof(unsigned int)))

// fbp : give a chance to overload vcl_allocator
# if ! defined ( Alloc )
#  define __AUTO_BVEC_ALLOC
#  define Alloc vcl_alloc
# endif

class __bvec_iterator;
class __bvec_const_iterator;

class __bvec_reference {
    friend class __bvec_iterator;
    friend class __bvec_const_iterator;
    typedef __bvec_reference reference;
protected:
    unsigned int* p;
    unsigned int mask;
    __bvec_reference(unsigned int* x, unsigned int y) : p(x), mask(y) {}
public:
    __bvec_reference() : p(0), mask(0) {}
    operator bool() const { return !(!(*p & mask)); }
    reference& operator=(bool x) {
        if (x)
            *p |= mask;
        else
            *p &= ~mask;
        return *this;
    }
    reference& operator=(const reference& x) { return *this = bool(x); }
    bool operator==(const reference& x) const {
        return bool(*this) == bool(x);
    }
    bool operator<(const reference& x) const {
        return ! bool(*this) && bool(x); // was: bool(*this) < bool(x);
    }
    void flip() { *p ^= mask; }
};


class __bvec_iterator {
    friend class vcl_bit_vector;
    friend class __bvec_const_iterator;
    typedef __bvec_iterator iterator;
    typedef __bvec_const_iterator const_iterator;
    typedef __bvec_reference reference;
    typedef bool const_reference;
    typedef bool value_type;
    typedef vcl_ptrdiff_t difference_type;
    typedef vcl_size_t size_type;
protected:
    unsigned int* p;
    unsigned int offset;
    void bump_up() {
        if (offset++ == __WORD_BIT - 1) {
            offset = 0;
            ++p;
        }
    }
    void bump_down() {
        if (offset-- == 0) {
            offset = __WORD_BIT - 1;
            --p;
        }
    }
public:
    __bvec_iterator() : p(0), offset(0) {}
    __bvec_iterator(unsigned int* x, unsigned int y) : p(x), offset(y) {}
    reference operator*() const { return reference(p, 1U << offset); }
    iterator& operator++() {
        bump_up();
        return *this;
    }
    iterator operator++(int) {
        iterator tmp = *this;
        bump_up();
        return tmp;
    }
    iterator& operator--() {
        bump_down();
        return *this;
    }
    iterator operator--(int) {
        iterator tmp = *this;
        bump_down();
        return tmp;
    }
    iterator& operator+=(difference_type i) {
        difference_type n = i + offset;
        p += n / __WORD_BIT;
        n = n % __WORD_BIT;
        if (n < 0) {
            offset = n + __WORD_BIT;
            --p;
        } else
            offset = n;
        return *this;
    }
    iterator& operator-=(difference_type i) {
        *this += -i;
        return *this;
    }
    iterator operator+(difference_type i) const {
        iterator tmp = *this;
        return tmp += i;
    }
    iterator operator-(difference_type i) const {
        iterator tmp = *this;
        return tmp -= i;
    }
    difference_type operator-(iterator x) const {
        return __WORD_BIT * (p - x.p) + offset - x.offset;
    }
    reference operator[](difference_type i) { return *(*this + i); }
    bool operator==(const iterator& x) const {
        return p == x.p && offset == x.offset;
    }
    bool operator!=(const iterator& x) const {
        return p != x.p || offset != x.offset;
    }
    bool operator<(iterator x) const {
        return p < x.p || (p == x.p && offset < x.offset);
    }
};

class __bvec_const_iterator
{
    friend class vcl_bit_vector;
    typedef __bvec_iterator iterator;
    typedef __bvec_const_iterator const_iterator;
    typedef __bvec_reference reference;
    typedef bool value_type;
    typedef bool const_reference;
    typedef vcl_ptrdiff_t difference_type;
    typedef vcl_size_t size_type;
protected:
    unsigned int* p;
    unsigned int offset;
    void bump_up() {
        if (offset++ == __WORD_BIT - 1) {
            offset = 0;
            ++p;
        }
    }
    void bump_down() {
        if (offset-- == 0) {
            offset = __WORD_BIT - 1;
            --p;
        }
    }
public:
    __bvec_const_iterator() : p(0), offset(0) {}
    __bvec_const_iterator(unsigned int* x, unsigned int y) : p(x), offset(y) {}
    __bvec_const_iterator(const iterator& x) : p(x.p), offset(x.offset) {}
    const_reference operator*() const {
        return reference(p, 1U << offset);
    }
    const_iterator& operator++() {
        bump_up();
        return *this;
    }
    const_iterator operator++(int) {
        const_iterator tmp = *this;
        bump_up();
        return tmp;
    }
    const_iterator& operator--() {
        bump_down();
        return *this;
    }
    const_iterator operator--(int) {
        const_iterator tmp = *this;
        bump_down();
        return tmp;
    }
    const_iterator& operator+=(difference_type i) {
        difference_type n = i + offset;
        p += n / __WORD_BIT;
        n = n % __WORD_BIT;
        if (n < 0) {
            offset = n + __WORD_BIT;
            --p;
        } else
            offset = n;
        return *this;
    }
    const_iterator& operator-=(difference_type i) {
        *this += -i;
        return *this;
    }
    const_iterator operator+(difference_type i) const {
        const_iterator tmp = *this;
        return tmp += i;
    }
    const_iterator operator-(difference_type i) const {
        const_iterator tmp = *this;
        return tmp -= i;
    }
    difference_type operator-(const_iterator x) const {
        return __WORD_BIT * (p - x.p) + offset - x.offset;
    }
    const_reference operator[](difference_type i) {
        return *(*this + i);
    }