vrpn_EndpointContainer.h

浏览该文件的文档.

 
// 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_Shared.h"
 
#include "vrpn_Assert.h"
 
// Library/third-party includes
// - none
 
// Standard includes
#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 vrpn_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
 {
 // We can be a nullptr, so don't check 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
 {
 // We can be a nullptr, so don't check 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