---

SharedValidity.hh

Go to the documentation of this file.

#ifndef MANGO_PTR_SHARED_VALIDATOR_H
#define MANGO_PTR_SHARED_VALIDATOR_H

#include <assert.h> // use inline
#include <algorithm> // use swap
#include "nullness.hh"

namespace MangoPtr 
{
    
class SharedValidity
{
    private:
        struct State 
        {
            static const unsigned short bitsPerByte = 8;
            static const size_t countBits = bitsPerByte*sizeof(size_t) - 1;
            
            size_t count:countBits; 
            size_t valid:1;         
            
            State(): count(1), valid(false) {}
        };
    
    protected:
        SharedValidity(): state(NullPtr) {}
        inline SharedValidity(bool);
        inline SharedValidity(const SharedValidity&);
        inline SharedValidity& operator=(const SharedValidity&);
        inline ~SharedValidity() { if (isNotNull(state)) freeCount(); }
        inline void reset(bool);
        inline void setValid(bool);
   
    public:
        bool isValid()  const {return (isNotNull(state)) && state->valid;}
        bool isShared() const {return (isNotNull(state)) && state->count > 1;}
        size_t getRefCount() const {return isNull(state) ? 1 : state->count;}
        inline void swap(SharedValidity& rhs) { std::swap(state, rhs.state); }
        
        #if ! defined NDEBUG && defined TEST_SHARED
        static void setDeleted(bool);
        static void test();
        #endif
    
    private:
        void setValid()   {assert(isNotNull(state)); state->valid = true;}
        void setInvalid() {assert(isNotNull(state)); state->valid = false;}
        
        static inline State* newCount();
        inline State* getCountPtr() const;
        inline void freeCount();
    
    private: // data
        typedef State* SP;
        mutable SP state;
};

inline 
SharedValidity::SharedValidity(const bool valid)
    : state(NullPtr) 
{
    // only bother creating a new counter if 
    // setting to true since count=null implies false.
    if (valid) 
    {
        state = newCount(); // could throw bad_alloc
        setValid();
    }
}

inline 
SharedValidity::SharedValidity(const SharedValidity& vv)
    : state(vv.getCountPtr()) // could throw bad_alloc
{
    assert(isNotNull(state));
    state->count ++;
}

inline SharedValidity& 
SharedValidity::operator=(const SharedValidity& vv)
{
    State* const tmp = vv.getCountPtr(); // could throw bad_alloc
    if (tmp != state) // otherwise, self-assignment
    {
        if (isNotNull(state)) freeCount();
        (state = tmp)->count ++;
    }
    return *this;
}

inline SharedValidity::State* 
SharedValidity::newCount() 
{ 
    #if ! defined NDEBUG && defined TEST_SHARED
    setDeleted(false);
    #endif
    return new State; 
}

inline void
SharedValidity::freeCount()
{
    assert(isNotNull(state));
    state->count --; 
    // always true: assert(state->count >= 0);
    if (0 == state->count) 
    {
        delete state;
        #if ! defined NDEBUG && defined TEST_SHARED
        setDeleted(true);
        #endif
    }
}
   
inline SharedValidity::State*
SharedValidity::getCountPtr() 
const
{
    if (isNull(state)) state = newCount();
    assert(isNotNull(state));
    return state;
}

inline void 
SharedValidity::setValid(const bool valid) 
{
    if (valid) 
    {
        if (isNull(state)) state = newCount();
        setValid();
    }
    else
    {
        if (isValid()) setInvalid();
    }
}

inline void 
SharedValidity::reset(const bool valid)
{
    if (isShared())
    {
        assert(isNotNull(state));
        if (valid) 
        {
            State* tmp = newCount(); // could throw
            state->count --; 
            state = tmp;
            setValid();
        }
        else // false, just nullify pointer
        {
            state->count --; 
            nullify(state); // doesn't affect those who share our validity
        }
    }
    else setValid(valid);
}

} // namespace MangoPtr

#endif // MANGO_PTR_SHARED_VALIDATOR_H

---