Changeset 3585


Ignore:
Timestamp:
Dec 17, 2013, 1:38:21 PM (5 years ago)
Author:
cameron
Message:

Use size_t instead of binding_t for binding set capacities and indexes

File:
1 edited

Legend:

Unmodified
Added
Removed
  • icXML/icXML-devel/src/icxmlc/XMLNamespaceBindingSet.hpp

    r3563 r3585  
    2222class BindingSetIterator;
    2323class FixedBindingSet;
    24 template<binding_t, binding_t> class BindingSets;
     24template<size_t, size_t> class BindingSets;
    2525
    2626//TODO: given that I know the binding sets will always be some power of 2 in size, I should be able to use
     
    4545#define CONSTRUCT_SINGLE_OPERATOR_HEADER(RETURN_TYPE, OPERATOR_TYPE)    \
    4646                IDISA_ALWAYS_INLINE \
    47                 RETURN_TYPE & OPERATOR_TYPE(const binding_t id)
     47                RETURN_TYPE & OPERATOR_TYPE(const size_t id)
    4848
    4949#define CONSTRUCT_NEW_SINGLE_OPERATOR_HEADER(RETURN_TYPE, OPERATOR_TYPE)        \
    5050                IDISA_ALWAYS_INLINE \
    51                 RETURN_TYPE OPERATOR_TYPE(const binding_t id) const \
     51                RETURN_TYPE OPERATOR_TYPE(const size_t id) const \
    5252
    5353/// *********************************************************************************************** ///
     
    5555class FixedBindingSet
    5656{
    57                 template<binding_t, binding_t> friend class BindingSets;
     57                template<size_t, size_t> friend class BindingSets;
    5858
    5959                friend class BindingSet;
     
    8080
    8181                IDISA_ALWAYS_INLINE
    82                 bool operator[](const binding_t id) const;
     82                bool operator[](const size_t id) const;
    8383
    8484        IDISA_ALWAYS_INLINE
     
    110110
    111111                IDISA_ALWAYS_INLINE
    112                 bool mask_and_extract(const FixedBindingSet & otherSet, const binding_t id) const;
    113 
    114                 IDISA_ALWAYS_INLINE
    115                 bool mask_and_extract(const BindingSet & otherSet, const binding_t id) const;
     112                bool mask_and_extract(const FixedBindingSet & otherSet, const size_t id) const;
     113
     114                IDISA_ALWAYS_INLINE
     115                bool mask_and_extract(const BindingSet & otherSet, const size_t id) const;
    116116
    117117                // --------------------------------------------------------------------------------------------------
     
    162162                        char closer = '0';
    163163
    164                         for (binding_t i = 0; i < _capacity; i++)
    165                         {
    166                                 binding_t itr = _bindingSet[i];
     164                        for (size_t i = 0; i < _capacity; i++)
     165                        {
     166                                size_t itr = _bindingSet[i];
    167167
    168168                                while (itr)
    169169                                {
    170                                         const binding_t pos =
     170                                        const size_t pos =
    171171                                                (i << FixedBindingSet::LOG_2_BITS_PER_BINDING) | scan_forward_zeroes(itr);
    172172
     
    191191
    192192                IDISA_ALWAYS_INLINE
    193                 binding_t capacity() const
     193                size_t capacity() const
    194194                {
    195195                        return _capacity << FixedBindingSet::LOG_2_BITS_PER_BINDING;
     
    198198        protected:
    199199
    200                 FixedBindingSet(binding_t * fixedSet, const binding_t capacity)
     200                FixedBindingSet(binding_t * fixedSet, const size_t capacity)
    201201                : _bindingSet(fixedSet)
    202202                , _capacity(capacity)
     
    208208
    209209                IDISA_ALWAYS_INLINE
    210         static bool bittest(const binding_t * a, const binding_t b)
     210        static bool bittest(const binding_t * a, const size_t b)
    211211                {
    212212            bool retval;
     
    243243                void do_operation(const binding_t value)
    244244                {
    245                         const binding_t idx = (value >> LOG_2_BITS_PER_BINDING);
    246                         const binding_t pos = (value & (BITS_PER_BINDING - 1));
     245                        const size_t idx = (value >> LOG_2_BITS_PER_BINDING);
     246                        const size_t pos = (value & (BITS_PER_BINDING - 1));
    247247                        const binding_t one = 1; //needed to prevent gcc from thinking this is a 32-bit int
    248248                        const binding_t val = (one << pos);
     
    261261                void do_operation(const binding_t value, binding_t * result) const
    262262                {
    263                         const binding_t idx = (value >> LOG_2_BITS_PER_BINDING);
    264                         const binding_t pos = (value & (BITS_PER_BINDING - 1));
     263                        const size_t idx = (value >> LOG_2_BITS_PER_BINDING);
     264                        const size_t pos = (value & (BITS_PER_BINDING - 1));
    265265                        const binding_t one = 1; //needed to prevent gcc from thinking this is a 32-bit int
    266266                        const binding_t val = (one << pos);
    267267
    268                         for (binding_t i = 0; unlikely(i < idx); i++)
     268                        for (size_t i = 0; unlikely(i < idx); i++)
    269269                        {
    270270                                result[i] = _bindingSet[i];
    271271                        }
    272272                        result[idx] = binary_op(_bindingSet[idx], val);
    273                         for (binding_t i = idx + 1; unlikely(i < _capacity); i++)
     273                        for (size_t i = idx + 1; unlikely(i < _capacity); i++)
    274274                        {
    275275                                result[i] = _bindingSet[i];
     
    282282                {
    283283                        result[0] = binary_op(_bindingSet[0], otherSet[0]);
    284                         for (binding_t i = 1; unlikely(i < _capacity); i++)
     284                        for (size_t i = 1; unlikely(i < _capacity); i++)
    285285                        {
    286286                                result[i] = binary_op(_bindingSet[i], otherSet[i]);
     
    289289
    290290                IDISA_ALWAYS_INLINE
    291                 void assign(binding_t * set, const binding_t capacity)
     291                void assign(binding_t * set, const size_t capacity)
    292292                {
    293293                        _bindingSet = set;
     
    303303class BindingSet : public FixedBindingSet
    304304{
    305                 template<binding_t, binding_t> friend class BindingSets;
     305                template<size_t, size_t> friend class BindingSets;
    306306
    307307                friend class FixedBindingSet;
     
    351351        BindingSet & operator=(const binding_t val);
    352352
    353                 BindingSet(const binding_t capacity)
     353                BindingSet(const size_t capacity)
    354354                : FixedBindingSet
    355355                (
     
    383383                        DEBUG_MESSAGE("expand(" << minimum << ')')
    384384
    385                         const binding_t capacity = _capacity;
    386                         //how many binding_t blocks are needed?
    387                         const binding_t newCapacity =
     385                        const size_t capacity = _capacity;
     386                        //how many size_t blocks are needed?
     387                        const size_t newCapacity =
    388388                                max
    389389                                (
     
    428428// --------------------------------------------------------------------------------------------------
    429429
    430 bool FixedBindingSet::operator[](const binding_t id) const
     430bool FixedBindingSet::operator[](const size_t id) const
    431431{
    432432    return bittest(_bindingSet, id);
     
    491491
    492492        binding_t diff = _bindingSet[0] ^ otherSet._bindingSet[0];
    493         for (binding_t i = 1; unlikely(i < _capacity); i++)
     493        for (size_t i = 1; unlikely(i < _capacity); i++)
    494494        {
    495495                diff |= _bindingSet[i] ^ otherSet._bindingSet[i];
     
    503503
    504504        binding_t diff = _bindingSet[0] ^ otherSet._bindingSet[0];
    505         for (binding_t i = 1; unlikely(i < _capacity); i++)
     505        for (size_t i = 1; unlikely(i < _capacity); i++)
    506506        {
    507507                diff |= _bindingSet[i] ^ otherSet._bindingSet[i];
     
    512512// --------------------------------------------------------------------------------------------------
    513513
    514 bool FixedBindingSet::mask_and_extract(const FixedBindingSet & otherSet, const binding_t id) const
     514bool FixedBindingSet::mask_and_extract(const FixedBindingSet & otherSet, const size_t id) const
    515515{
    516516    return bittest(_bindingSet, id) && bittest(otherSet._bindingSet, id);
    517517}
    518518
    519 bool FixedBindingSet::mask_and_extract(const BindingSet & otherSet, const binding_t id) const
     519bool FixedBindingSet::mask_and_extract(const BindingSet & otherSet, const size_t id) const
    520520{
    521521    return bittest(_bindingSet, id) && bittest(otherSet._bindingSet, id);
     
    562562
    563563#define CONSTRUCT_SINGLE_OPERATOR_FUNCTION(RETURN_TYPE, OPERATOR_TYPE, OPERATOR_FUNCTION)       \
    564         RETURN_TYPE & FixedBindingSet::OPERATOR_TYPE(const binding_t id) \
     564        RETURN_TYPE & FixedBindingSet::OPERATOR_TYPE(const size_t id) \
    565565        { \
    566566                do_operation<FixedBindingSet::OPERATOR_FUNCTION>(id); \
     
    569569
    570570#define CONSTRUCT_NEW_SINGLE_OPERATOR_FUNCTION(RETURN_TYPE, OPERATOR_TYPE, OPERATOR_FUNCTION)   \
    571         RETURN_TYPE FixedBindingSet::OPERATOR_TYPE(const binding_t id) const \
     571        RETURN_TYPE FixedBindingSet::OPERATOR_TYPE(const size_t id) const \
    572572        { \
    573573                RETURN_TYPE result(_capacity); \
     
    606606{
    607607        register binding_t bits = _bindingSet[0];
    608         for (binding_t i = 1; unlikely(i < _capacity); i++)
     608        for (size_t i = 1; unlikely(i < _capacity); i++)
    609609        {
    610610                bits |= _bindingSet[i];
     
    632632        register binding_t t;
    633633        register binding_t i = 0;
    634         register binding_t count = _capacity;
     634        register size_t count = _capacity;
    635635
    636636        do
     
    651651/// *********************************************************************************************** ///
    652652
    653 template<binding_t initialSetCount, binding_t initialBitCapacity = FixedBindingSet::BITS_PER_BINDING>
     653template<size_t initialSetCount, size_t initialBitCapacity = FixedBindingSet::BITS_PER_BINDING>
    654654class BindingSets
    655655{
     
    681681
    682682                IDISA_ALWAYS_INLINE
    683                 binding_t * get(const binding_t i)
     683                binding_t * get(const size_t i)
    684684                {
    685685                        return &_bindingSets[i << _log2BitCapacity];
     
    687687
    688688                IDISA_ALWAYS_INLINE
    689                 const binding_t * get(const binding_t i) const
     689                const binding_t * get(const size_t i) const
    690690                {
    691691                        return &_bindingSets[i << _log2BitCapacity];
     
    694694
    695695                IDISA_ALWAYS_INLINE
    696                 void set(const binding_t i, BindingSet & otherSet)
     696                void set(const size_t i, BindingSet & otherSet)
    697697                {
    698698                        binding_t * _bindingSet = get(i);
    699                         binding_t _capacity = 1 << _log2BitCapacity;
     699                        size_t _capacity = 1 << _log2BitCapacity;
    700700
    701701                        Array<binding_t>::copy(otherSet._bindingSet, _bindingSet, otherSet._capacity);
     
    704704
    705705                IDISA_ALWAYS_INLINE
    706                 FixedBindingSet operator[](const binding_t i)
     706                FixedBindingSet operator[](const size_t i)
    707707                {
    708708                        return FixedBindingSet(&_bindingSets[i << _log2BitCapacity], (binding_t)(1) << _log2BitCapacity);
     
    710710
    711711                IDISA_ALWAYS_INLINE
    712                 const FixedBindingSet operator[](const binding_t i) const
     712                const FixedBindingSet operator[](const size_t i) const
    713713                {
    714714                        return FixedBindingSet(&_bindingSets[i << _log2BitCapacity], (binding_t)(1) << _log2BitCapacity);
     
    723723
    724724                        //how many binding_t blocks do we have currently?
    725                         const binding_t bitCapacity = this->bitCapacity() >> FixedBindingSet::LOG_2_BITS_PER_BINDING;
    726                         const binding_t setCapacity = this->setCapacity();
     725                        const size_t bitCapacity = this->bitCapacity() >> FixedBindingSet::LOG_2_BITS_PER_BINDING;
     726                        const size_t setCapacity = this->setCapacity();
    727727
    728728                        //how many binding_t blocks are needed?
    729                         const binding_t newBitCapacity =
     729                        const size_t newBitCapacity =
    730730                                max
    731731                                (
     
    734734                                );
    735735
    736                         const binding_t capacity = bitCapacity * setCapacity;
    737                         const binding_t newCapacity = newBitCapacity * setCapacity;
     736                        const size_t capacity = bitCapacity * setCapacity;
     737                        const size_t newCapacity = newBitCapacity * setCapacity;
    738738
    739739                        binding_t * newBindingSet = Array<binding_t>::allocate(newCapacity);
    740740
    741741                        // copy the old data over into the expanded array into the appropriate positions
    742                         binding_t i = 0;
    743                         binding_t j = 0;
     742                        size_t i = 0;
     743                        size_t j = 0;
    744744
    745745                        do
     
    766766
    767767                        //how many binding_t blocks do we have currently?
    768                         const binding_t bitCapacity = this->bitCapacity() >> FixedBindingSet::LOG_2_BITS_PER_BINDING;
    769                         const binding_t setCapacity = this->setCapacity();
     768                        const size_t bitCapacity = this->bitCapacity() >> FixedBindingSet::LOG_2_BITS_PER_BINDING;
     769                        const size_t setCapacity = this->setCapacity();
    770770
    771771                        //how many sets are needed?
    772             const binding_t newSetCapacity = max(setCapacity * 2, minumum + (initialSetCount - minumum % initialSetCount));
    773 
    774                         const binding_t capacity = bitCapacity * setCapacity;
    775                         const binding_t newCapacity = bitCapacity * newSetCapacity;
     772            const size_t newSetCapacity = max(setCapacity * 2, minumum + (initialSetCount - minumum % initialSetCount));
     773
     774                        const size_t capacity = bitCapacity * setCapacity;
     775                        const size_t newCapacity = bitCapacity * newSetCapacity;
    776776
    777777                        binding_t * newBindingSet = Array<binding_t>::allocate(newCapacity);
     
    788788
    789789                IDISA_ALWAYS_INLINE
    790                 binding_t bitCapacity() const
     790                size_t bitCapacity() const
    791791                {
    792792                        return (1 << _log2BitCapacity) << FixedBindingSet::LOG_2_BITS_PER_BINDING;
     
    794794
    795795                IDISA_ALWAYS_INLINE
    796                 binding_t setCapacity() const
     796                size_t setCapacity() const
    797797                {
    798798                        return _setCapacity;
     
    814814
    815815                binding_t *                                                                                                             _bindingSets;
    816                 binding_t                                                                                                               _log2BitCapacity;
    817                 binding_t                                                                                                               _setCapacity;
     816                size_t                                                                                                          _log2BitCapacity;
     817                size_t                                                                                                          _setCapacity;
    818818                binding_t                                                                                                               _internalSets[initialSetCount * INITIAL_BINDING_CAPACITY];
    819819};
     
    834834                }
    835835
    836                 BindingSetIterator(const binding_t * set, const binding_t bitCapacity)
     836                BindingSetIterator(const binding_t * set, const size_t bitCapacity)
    837837        : fBindingSet(set)
    838838        , fCapacity(bitCapacity >> FixedBindingSet::LOG_2_BITS_PER_BINDING)
     
    876876
    877877        const binding_t *                               fBindingSet;
    878         const binding_t                                 fCapacity;
    879         binding_t                                               fIndex;
    880         binding_t                                               fIterator;
    881         binding_t                                               fPos;
     878        const size_t                                    fCapacity;
     879        size_t                                          fIndex;
     880        size_t                                          fIterator;
     881        size_t                                          fPos;
    882882};
    883883
     
    949949        const binding_t *                               fMaskSet;
    950950
    951         binding_t                                               fIterator;
    952         binding_t                                               fPos;
     951        size_t                                          fIterator;
     952        size_t                                          fPos;
    953953        const bool                      fComplement;
    954954
    955         const binding_t                                 fCapacity;
    956         binding_t                                               fIndex;
     955        const size_t                                    fCapacity;
     956        size_t                                          fIndex;
    957957};
    958958
Note: See TracChangeset for help on using the changeset viewer.