diff options
Diffstat (limited to 'contrib/native/client/src/include/drill/collections.hpp')
| -rw-r--r-- | contrib/native/client/src/include/drill/collections.hpp | 179 |
1 files changed, 179 insertions, 0 deletions
diff --git a/contrib/native/client/src/include/drill/collections.hpp b/contrib/native/client/src/include/drill/collections.hpp new file mode 100644 index 000000000..9fbfcc5e2 --- /dev/null +++ b/contrib/native/client/src/include/drill/collections.hpp @@ -0,0 +1,179 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef _DRILL_COLLECTIONS_H +#define _DRILL_COLLECTIONS_H + +#include <iterator> + +#include <boost/noncopyable.hpp> +#include <boost/shared_ptr.hpp> + +namespace Drill { +namespace impl { + +/** + * Interface for internal iterators + */ +template<typename T> +class DrillIteratorImpl: private boost::noncopyable { +public: + typedef DrillIteratorImpl<T> iterator; + typedef boost::shared_ptr<iterator> iterator_ptr; + + typedef T value_type; + typedef value_type& reference; + typedef value_type* pointer; + + virtual ~DrillIteratorImpl() {}; + + // To allow conversion from non-const to const types + virtual operator typename DrillIteratorImpl<const T>::iterator_ptr() const = 0; + + virtual reference operator*() const = 0; + virtual pointer operator->() const = 0; + + virtual iterator& operator++() = 0; + + virtual bool operator==(const iterator& x) const = 0; + virtual bool operator!=(const iterator& x) const = 0; +}; + +/** + * Interface for internal collections + */ +template<typename T> +class DrillCollectionImpl: private boost::noncopyable { +public: + // STL-like iterator typedef + typedef DrillIteratorImpl<T> iterator; + typedef boost::shared_ptr<iterator> iterator_ptr; + typedef DrillIteratorImpl<const T> const_iterator; + typedef boost::shared_ptr<const_iterator> const_iterator_ptr; + + typedef T value_type; + typedef value_type& reference; + typedef const value_type& const_reference; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef int size_type; + + virtual ~DrillCollectionImpl() {} + + virtual iterator_ptr begin() = 0; + virtual const_iterator_ptr begin() const = 0; + virtual iterator_ptr end() = 0; + virtual const_iterator_ptr end() const = 0; +}; +} // namespace internal + +template<typename T> +class DrillCollection; + +template<typename T> +class DrillIterator: public std::iterator<std::input_iterator_tag, T> { +public: + typedef impl::DrillIteratorImpl<T> Impl; + typedef boost::shared_ptr<Impl> ImplPtr; + + typedef DrillIterator<T> iterator; + typedef std::iterator<std::input_iterator_tag, T> superclass; + typedef typename superclass::reference reference; + typedef typename superclass::pointer pointer; + + // Default constructor + DrillIterator(): m_pImpl() {}; + ~DrillIterator() {} + + // Iterators are CopyConstructible and CopyAssignable + DrillIterator(const iterator& it): m_pImpl(it.m_pImpl) {} + iterator& operator=(const iterator& it) { + m_pImpl = it.m_pImpl; + return *this; + } + + template<typename U> + DrillIterator(const DrillIterator<U>& it): m_pImpl(*it.m_pImpl) {} + + reference operator*() const { return m_pImpl->operator*(); } + pointer operator->() const { return m_pImpl->operator->(); } + + iterator& operator++() { m_pImpl->operator++(); return *this; } + + bool operator==(const iterator& x) const { + if (m_pImpl == x.m_pImpl) { + return true; + } + return m_pImpl && m_pImpl->operator==(*x.m_pImpl); + } + + bool operator!=(const iterator& x) const { + if (m_pImpl == x.m_pImpl) { + return false; + } + return !m_pImpl || m_pImpl->operator!=(*x.m_pImpl); + } + +private: + template<typename U> + friend class DrillCollection; + template<typename U> + friend class DrillIterator; + + ImplPtr m_pImpl; + + template<typename U> + DrillIterator(const boost::shared_ptr<impl::DrillIteratorImpl<U> >& pImpl): m_pImpl(pImpl) {} +}; + +template<typename T> +class DrillCollection { +public: + typedef impl::DrillCollectionImpl<T> Impl; + typedef boost::shared_ptr<Impl> ImplPtr; + + // STL-like iterator typedef + typedef DrillIterator<T> iterator; + typedef DrillIterator<const T> const_iterator; + typedef T value_type; + typedef value_type& reference; + typedef const value_type& const_reference; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef int size_type; + + iterator begin() { return iterator(m_pImpl->begin()); } + const_iterator begin() const { return const_iterator(boost::const_pointer_cast<const Impl>(m_pImpl)->begin()); } + iterator end() { return iterator(m_pImpl->end()); } + const_iterator end() const { return const_iterator(boost::const_pointer_cast<const Impl>(m_pImpl)->end()); } + +protected: + DrillCollection(const ImplPtr& impl): m_pImpl(impl) {} + + Impl& operator*() { return *m_pImpl; } + const Impl& operator*() const { return *m_pImpl; } + Impl* operator->() { return m_pImpl.get(); } + const Impl* operator->() const { return m_pImpl.get(); } + +private: + ImplPtr m_pImpl; +}; + + +} /* namespace Drill */ +#endif /* _DRILL_COLLECTIONS_H */ |