CTR_TaggedIndex.h

Go to the documentation of this file.

/*
 * $Id: CTR_TaggedIndex.h 36860 2011-05-24 11:19:11Z blendix $
 * ***** 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