CTR_TaggedIndex.h

Go to the documentation of this file.

/*
 * ***** BEGIN GPL LICENSE BLOCK *****
 *
 * This program 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 program 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 program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
 * All rights reserved.
 *
 * The Original Code is: all of this file.
 *
 * Contributor(s): none yet.
 *
 * ***** END GPL LICENSE BLOCK *****
 */

#ifndef NAN_INCLUDED_CTR_TaggedIndex_h
#define NAN_INCLUDED_CTR_TaggedIndex_h

#include <functional>

#include "MEM_sys_types.h"

enum {

    empty_tag = 0x0,
    empty_index = 0xffffffff
};

template <
    int tag_shift, 
    int index_mask
> class CTR_TaggedIndex {
public:
    CTR_TaggedIndex(
    ) : 
        m_val ((empty_tag << tag_shift) | (empty_index & index_mask))
    {
    }

    CTR_TaggedIndex(
        const int val
    ) :
        m_val ((val & index_mask) | ((empty_tag << tag_shift) & (~index_mask))) {
    }

    CTR_TaggedIndex(
        const unsigned int val
    ) :
        m_val ((val & index_mask) | ((empty_tag << tag_shift) & (~index_mask))) {
    }

    CTR_TaggedIndex(
        const long int val
    ) :
        m_val ( ((long int) val & index_mask)
                | ( (empty_tag << tag_shift)
                    & (~index_mask)) ) {
    }

    CTR_TaggedIndex(
        const long unsigned int val
    ) :
        m_val ( ((long unsigned int)val & index_mask)
                | ( (empty_tag << tag_shift)
                    & (~index_mask) ) ) {
    }


#if defined(_WIN64)
    CTR_TaggedIndex(
        const uint64_t val
    ) :
        m_val ( ((uint64_t)val & index_mask)
                | ( (empty_tag << tag_shift)
                    & (~index_mask) ) ) {
    }
#endif

    CTR_TaggedIndex(
        const CTR_TaggedIndex &my_index
    ):
        m_val(my_index.m_val)
    {
    }

        bool 
    operator == (
        const CTR_TaggedIndex& rhs
    ) const {

        return ((this->m_val & index_mask) == (rhs.m_val & index_mask));
    }       

    operator unsigned int () const {
        return m_val & index_mask;
    }

    operator unsigned long int () const {
        return (unsigned long int)(m_val & index_mask);
    }

    operator int () const {
        return int(m_val & index_mask);
    }

    operator long int () const {
        return (long int)(m_val & index_mask);
    }

#if defined(_WIN64)
    operator uint64_t () const {
            return (uint64_t)(m_val & index_mask);
        }
#endif

        bool
    IsEmpty(
    ) const {
        return ((m_val & index_mask) == (empty_index & index_mask));
    }


    static
        CTR_TaggedIndex
    Empty(
    ) {
        return CTR_TaggedIndex();
    }

        void
    Invalidate(
    ) {
        m_val = (empty_tag << tag_shift) | (empty_index & index_mask);
    }


        unsigned int 
    Tag (
    ) const {
        return m_val >> tag_shift;
    }
    
        void
    SetTag(
        unsigned int tag
    ) {
        m_val = (m_val & index_mask) | ((tag << tag_shift) & (~index_mask));
    }

        void
    EmptyTag(
    ) {
        m_val = (m_val & index_mask) | ((empty_tag << tag_shift) & (~index_mask));
    }

        bool
    IsEmptyTag(
    ) const {
        return (Tag() == Empty().Tag());
    }
    
    // functionals 

    struct greater : std::binary_function<CTR_TaggedIndex, CTR_TaggedIndex, bool>
    {
            bool 
        operator()(
            const CTR_TaggedIndex& a,
            const CTR_TaggedIndex& b
        ) const {
            return (int(a) > int(b));
        }
    };
    
    
private :
    CTR_TaggedIndex(
        const CTR_TaggedIndex *index
    ) {}; 

    unsigned int m_val;


};          

#endif