vrpn_EndpointContainer.h

Go to the documentation of this file.

 
// Copyright 2015 Sensics, Inc.
// Distributed under the Boost Software License, Version 1.0.
//    (See accompanying file LICENSE_1_0.txt or copy at
//          http://www.boost.org/LICENSE_1_0.txt)
 
#ifndef INCLUDED_vrpn_EndpointContainer_h_GUID_DB073DE8_5BBC_46BF_255B_71264D47A639
#define INCLUDED_vrpn_EndpointContainer_h_GUID_DB073DE8_5BBC_46BF_255B_71264D47A639
 
// Internal Includes
#include "vrpn_Types.h"
#include "vrpn_Configure.h"
 
#include "vrpn_Assert.h"
 
// Library/third-party includes
// - none
 
// Standard includes
#include <vector>
#include <stddef.h> // for NULL
 
class VRPN_API vrpn_Endpoint;
class VRPN_API vrpn_Endpoint_IP;
 
namespace vrpn {
 
    class EndpointIterator;
 
    class EndpointContainer {
    public:
        typedef vrpn_Endpoint_IP T;
        typedef T &reference;
        typedef T *pointer;
        typedef vrpn_Endpoint *base_pointer;
 
    private:
        typedef std::vector<pointer> container_type;
 
    public:
        typedef container_type::size_type size_type;
        typedef EndpointIterator iterator;
        typedef EndpointIterator const_iterator;
 
        EndpointContainer();
 
        ~EndpointContainer();
 
        void clear();
 
        pointer front() const { return get_by_index(0); }
 
        template <typename T> T *acquire(T *endpoint)
        {
            acquire_(endpoint);
            return endpoint;
        }
 
        void compact();
 
        bool full() const;
 
        bool is_valid(size_type i) const;
 
        bool destroy(base_pointer endpoint);
 
        pointer get_by_index(size_type i) const;
 
        size_type get_full_container_size() const;
 
        iterator begin() const;
 
        iterator end() const;
 
    private:
        typedef container_type::iterator raw_iterator;
        typedef container_type::const_iterator raw_const_iterator;
        raw_iterator begin_() { return container_.begin(); }
        raw_const_iterator begin_() const { return container_.begin(); }
        raw_iterator end_() { return container_.end(); }
        raw_const_iterator end_() const { return container_.end(); }
        // @}
        void acquire_(pointer endpoint);
        void compact_();
 
        container_type container_;
        bool needsCompact_;
    };
 
#define VRPN_ECITERATOR_ASSERT_INVARIANT()                                     \
    VRPN_ASSERT_MSG(valid() != equal_to_default_(),                            \
                    "Class invariant for EndpointIterator")
 
    class EndpointIterator {
    public:
        // typedef EndpointIteratorBase<ContainerType> type;
        typedef EndpointIterator type;
        typedef EndpointContainer const container_type;
        typedef container_type::pointer pointer;
        typedef container_type::reference reference;
        typedef container_type::size_type size_type;
 
        EndpointIterator()
            : index_(0)
            , container_(NULL)
        {
            VRPN_ASSERT_MSG(equal_to_default_(),
                            "Default constructed value should be equal to "
                            "default: verifies that 'equal_to_default_()' is "
                            "equivalent to '*this == EndpointIterator()'");
            VRPN_ASSERT_MSG(!valid(),
                            "Default constructed value should not be valid");
        }
 
        EndpointIterator(container_type &container)
            : index_(0)
            , container_(&container)
        {
            // Advance index as required to maintain the class invariant.
            skip_nulls_();
            VRPN_ECITERATOR_ASSERT_INVARIANT();
        }
 
        EndpointIterator(container_type &container, size_type index)
            : index_(index)
            , container_(&container)
        {
            // Advance index as required to maintain the class invariant.
            skip_nulls_();
            VRPN_ECITERATOR_ASSERT_INVARIANT();
        }
 
        bool valid() const
        {
            return container_ && container_->is_valid(index_);
        }
 
        pointer get_pointer() const
        {
            VRPN_ECITERATOR_ASSERT_INVARIANT();
            // Only need to condition on container validity: invalid indexes
            // safely return null from get_raw_()
            return container_ ? (get_raw_()) : NULL;
        }
 
        operator pointer() const
        {
            VRPN_ECITERATOR_ASSERT_INVARIANT();
            return get_pointer();
        }
 
        type &operator++()
        {
            if (equal_to_default_()) {
                // Early out if we're already the end sentinel (default
                // constructor value)
                return *this;
            }
 
            // Increment until we either go out of bounds or get a non-null
            // entry
            index_++;
            skip_nulls_();
            VRPN_ECITERATOR_ASSERT_INVARIANT();
            return *this;
        }
 
        pointer operator->() const
        {
            VRPN_ECITERATOR_ASSERT_INVARIANT();
            return get_pointer();
        }
 
        reference operator*() const
        {
            VRPN_ECITERATOR_ASSERT_INVARIANT();
            return *get_raw_();
        }
 
        bool operator==(type const &other) const
        {
            return (container_ == other.container_) && (index_ == other.index_);
        }
        bool operator!=(type const &other) const
        {
            return (container_ != other.container_) || (index_ != other.index_);
        }
 
    private:
        bool equal_to_default_() const
        {
            return (NULL == container_) && (index_ == 0);
        }
        void skip_nulls_()
        {
            while (index_in_bounds_() && (get_raw_() == NULL)) {
                index_++;
            }
            // We may have run out of elements, so check the invariant
            enforce_invariant_();
        }
        void enforce_invariant_()
        {
            if (!valid()) {
                *this = type();
            }
        }
 
        pointer get_raw_() const { return container_->get_by_index(index_); }
 
        bool index_in_bounds_() const
        {
            return index_ < container_->get_full_container_size();
        }
 
        size_type index_;
        container_type *container_;
    };
#undef VRPN_ECITERATOR_ASSERT_INVARIANT
 
    // Inline Implementations //
 
    inline bool
    EndpointContainer::is_valid(EndpointContainer::size_type i) const
    {
        return (i < get_full_container_size()) && (NULL != container_[i]);
    }
 
    inline EndpointContainer::pointer
    EndpointContainer::get_by_index(size_type i) const
    {
        if (!is_valid(i)) {
            return NULL;
        }
        return container_[i];
    }
 
    inline EndpointContainer::size_type
    EndpointContainer::get_full_container_size() const
    {
        return container_.size();
    }
 
    // making this condition inline so that it has minimal overhead if
    // we don't actually need to perform a compaction.
    inline void EndpointContainer::compact()
    {
        if (needsCompact_) {
            compact_();
        }
    }
 
    inline EndpointIterator EndpointContainer::begin() const
    {
        return EndpointIterator(*this);
    }
 
    inline EndpointIterator EndpointContainer::end() const
    {
        return EndpointIterator();
    }
 
} // namespace vrpn
 
#endif // INCLUDED_vrpn_EndpointContainer_h_GUID_DB073DE8_5BBC_46BF_255B_71264D47A639