/* ///////////////////////////////////////////////////////////////////////// * File: acestl/collections/message_queue_sequence.hpp * * Purpose: Sequence class for adapting ACE_Message_Queue to an STL sequence. * * Created: 15th September 2004 * Updated: 25th March 2010 * * Home: http://stlsoft.org/ * * Copyright (c) 2004-2010, Matthew Wilson and Synesis Software * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * - Redistributions of source code must retain the above copyright notice, this * list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright notice, * this list of conditions and the following disclaimer in the documentation * and/or other materials provided with the distribution. * - Neither the name(s) of Matthew Wilson and Synesis Software nor the names of * any contributors may be used to endorse or promote products derived from * this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. * * ////////////////////////////////////////////////////////////////////// */ /** \file acestl/collections/message_queue_sequence.hpp * * \brief [C++ only] Definition of the acestl::message_queue_sequence * collection class template * (\ref group__library__collections "Collections" Library). */ #ifndef ACESTL_INCL_ACESTL_COLLECTIONS_HPP_MESSAGE_QUEUE_SEQUENCE #define ACESTL_INCL_ACESTL_COLLECTIONS_HPP_MESSAGE_QUEUE_SEQUENCE #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION # define ACESTL_VER_ACESTL_COLLECTIONS_HPP_MESSAGE_QUEUE_SEQUENCE_MAJOR 2 # define ACESTL_VER_ACESTL_COLLECTIONS_HPP_MESSAGE_QUEUE_SEQUENCE_MINOR 1 # define ACESTL_VER_ACESTL_COLLECTIONS_HPP_MESSAGE_QUEUE_SEQUENCE_REVISION 8 # define ACESTL_VER_ACESTL_COLLECTIONS_HPP_MESSAGE_QUEUE_SEQUENCE_EDIT 58 #endif /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */ /* ///////////////////////////////////////////////////////////////////////// * Includes */ #ifndef ACESTL_INCL_ACESTL_HPP_ACESTL # include #endif /* !ACESTL_INCL_ACESTL_HPP_ACESTL */ #ifndef STLSOFT_INCL_STLSOFT_UTIL_STD_HPP_ITERATOR_HELPER # include #endif /* !STLSOFT_INCL_STLSOFT_UTIL_STD_HPP_ITERATOR_HELPER */ #ifndef STLSOFT_INCL_STLSOFT_COLLECTIONS_UTIL_HPP_COLLECTIONS # include #endif /* !STLSOFT_INCL_STLSOFT_COLLECTIONS_UTIL_HPP_COLLECTIONS */ #ifndef STLSOFT_INCL_STLSOFT_CONVERSION_HPP_SAP_CAST # include #endif /* !STLSOFT_INCL_STLSOFT_CONVERSION_HPP_SAP_CAST */ #ifndef STLSOFT_INCL_STLSOFT_ALGORITHMS_HPP_BOUNDED # include // for stlsoft::copy_n() #endif /* !STLSOFT_INCL_STLSOFT_ALGORITHMS_HPP_BOUNDED */ #if ACESTL_ACE_VERSION >= 0x00050004 // This stinks, but appears to be necessary in ACE versions later than 5.3 #ifndef STLSOFT_INCL_ACE_H_CONDITION_THREAD_MUTEX # define STLSOFT_INCL_ACE_H_CONDITION_THREAD_MUTEX # include #endif /* !STLSOFT_INCL_ACE_H_CONDITION_THREAD_MUTEX */ #ifndef STLSOFT_INCL_ACE_H_GUARD_T # define STLSOFT_INCL_ACE_H_GUARD_T # include #endif /* !STLSOFT_INCL_ACE_H_GUARD_T */ #ifndef STLSOFT_INCL_ACE_H_NULL_CONDITION # define STLSOFT_INCL_ACE_H_NULL_CONDITION # include #endif /* !STLSOFT_INCL_ACE_H_NULL_CONDITION */ #ifndef STLSOFT_INCL_ACE_H_NULL_MUTEX # define STLSOFT_INCL_ACE_H_NULL_MUTEX # include #endif /* !STLSOFT_INCL_ACE_H_NULL_MUTEX */ #ifndef STLSOFT_INCL_ACE_H_THREAD_MUTEX # define STLSOFT_INCL_ACE_H_THREAD_MUTEX # include #endif /* !STLSOFT_INCL_ACE_H_THREAD_MUTEX */ #endif /* ACESTL_ACE_VERSION */ #ifndef STLSOFT_INCL_ACE_H_MESSAGE_QUEUE_T # define STLSOFT_INCL_ACE_H_MESSAGE_QUEUE_T # include #endif /* !STLSOFT_INCL_ACE_H_MESSAGE_QUEUE_T */ #ifndef STLSOFT_INCL_ALGORITHM # define STLSOFT_INCL_ALGORITHM # include // for std::copy #endif /* !STLSOFT_INCL_ALGORITHM */ #ifdef STLSOFT_UNITTEST # include #endif /* STLSOFT_UNITTEST */ /* ///////////////////////////////////////////////////////////////////////// * Namespace */ #ifndef _ACESTL_NO_NAMESPACE # if defined(_STLSOFT_NO_NAMESPACE) || \ defined(STLSOFT_DOCUMENTATION_SKIP_SECTION) /* There is no stlsoft namespace, so must define ::acestl */ namespace acestl { # else /* Define stlsoft::acestl_project */ namespace stlsoft { namespace acestl_project { # endif /* _STLSOFT_NO_NAMESPACE */ #endif /* !_ACESTL_NO_NAMESPACE */ /* ///////////////////////////////////////////////////////////////////////// * Classes */ /** An \ref group__pattern__instance_adaptor "instance adaptor" that * adapts an instance of \c ACE_Message_Queue to provide an STL * input-sequence interface. * * \ingroup group__library__collections * * It is used as follows: \code using acestl::message_queue_sequence; using stlsoft::auto_buffer; ACE_Message_Queue &mq = . . . // Adapt the message queue into the sequence message_queue_sequence mqs(mq); // Allocate a contiguous buffer, using stlsoft::auto_buffer auto_buffer buff(mqs.size()); // Block copy into the buffer std::copy(&buff[0], &buff[0] + (buff.size()), mqs.begin()); \endcode * * \note Although this class provides Input Iterators, it * uses customisations of \c std algorithms to effect very favourable * performance, as described in chapter 31 of * \ref section__publishing__books__xstlv1. */ // [[synesis:class:collection: acestl::message_queue_sequence>]] template class message_queue_sequence : public stlsoft_ns_qual(stl_collection_tag) { /// \name Types /// @{ public: /// The value type typedef char value_type; /// The sequence type typedef ACE_Message_Queue sequence_type; /// The current parameterisation of the type typedef message_queue_sequence class_type; /// The size type typedef ss_size_t size_type; /** Iterator type for the message_queue_sequence class template * * \note Although this iterator class is an Input Iterator, it * uses customisations of \c std algorithms to effect very favourable * performance, as described in chapter 31 of Extended STL, * volume 1 (published by Addison-Wesley, June 2007). */ class iterator : public stlsoft_ns_qual(iterator_base) { private: friend class message_queue_sequence; typedef ACE_Message_Queue_Iterator mq_iterator_type; private: #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION struct shared_handle { public: typedef shared_handle class_type; // Members public: mq_iterator_type m_mqi; ACE_Message_Block* m_entry; as_size_t m_entryLength; as_size_t m_entryIndex; private: ss_sint32_t m_refCount; /// Construction public: ss_explicit_k shared_handle(sequence_type &mq) : m_mqi(mq) , m_entry(NULL) , m_entryLength(0) , m_entryIndex(0) , m_refCount(1) { if(m_mqi.next(m_entry)) { for(;;) { if(0 != (m_entryLength = m_entry->length())) { break; } else if(NULL == (m_entry = nextEntry())) { break; } } } } # if defined(STLSOFT_CF_COMPILER_WARNS_NO_PUBLIC_DTOR) protected: # else /* ? STLSOFT_CF_COMPILER_WARNS_NO_PUBLIC_DTOR */ private: # endif /* STLSOFT_CF_COMPILER_WARNS_NO_PUBLIC_DTOR */ ~shared_handle() stlsoft_throw_0() { ACESTL_MESSAGE_ASSERT("Shared search handle being destroyed with outstanding references!", 0 == m_refCount); } /// Accessors public: ss_bool_t is_end_point() const { return m_entryIndex == m_entryLength; } char ¤t() { ACESTL_ASSERT(NULL != m_entry); ACESTL_ASSERT(m_entryIndex != m_entryLength); return m_entryIndex[m_entry->rd_ptr()]; } char current() const { ACESTL_ASSERT(NULL != m_entry); ACESTL_ASSERT(m_entryIndex != m_entryLength); return m_entryIndex[m_entry->rd_ptr()]; } ss_bool_t advance() { ACESTL_MESSAGE_ASSERT("Invalid index", m_entryIndex < m_entryLength); if(++m_entryIndex == m_entryLength) { m_entryIndex = 0; for(;;) { if(NULL == (m_entry = nextEntry())) { return false; } else if(0 != (m_entryLength = m_entry->length())) { break; } } } return true; } /// Operations public: ss_sint32_t AddRef() { return ++m_refCount; } ss_sint32_t Release() { ss_sint32_t rc = --m_refCount; if(0 == rc) { delete this; } return rc; } void fast_copy(char const* f, char const* l, size_type n) { ACESTL_ASSERT(0 != n); ACESTL_ASSERT(f != l); if(0 != n) { size_type n1 = m_entryLength - m_entryIndex; if(n <= n1) { // Terminal case ::memcpy(&m_entryIndex[m_entry->rd_ptr()], f, n); ACESTL_ASSERT(n <= m_entryLength - m_entryIndex); m_entryIndex += n; ACESTL_ASSERT(m_entryIndex <= m_entryLength); } else { // Recursive case ::memcpy(&m_entryIndex[m_entry->rd_ptr()], f, n1); f += n1; m_entry = nextEntry(); ACESTL_MESSAGE_ASSERT("Attempt to walk off end of iterator's range", NULL != m_entry); m_entryIndex = 0; m_entryLength = m_entry->length(); fast_copy(f, l, n - n1); } } } void fast_copy(class_type const* l, char* o) { size_type n1 = m_entryLength - m_entryIndex; if( NULL != l && m_entry == l->m_entry) { // Terminal case ::memcpy(o, &m_entryIndex[m_entry->rd_ptr()], n1); } else { // Recursive case ::memcpy(o, &m_entryIndex[m_entry->rd_ptr()], n1); o += n1; m_entry = nextEntry(); if(NULL != m_entry) { m_entryIndex = 0; m_entryLength = m_entry->length(); fast_copy(l, o); } } } void fast_copy(size_type n, char* o) { size_type n1 = m_entryLength - m_entryIndex; if(n <= n1) { // Asking for less than (or equal to) the capacity // of the current entry. // // Advance the m_entryIndex member. // // This is the terminating case. ::memcpy(o, &m_entryIndex[m_entry->rd_ptr()], n); ACESTL_ASSERT(n <= m_entryLength - m_entryIndex); m_entryIndex += n; ACESTL_ASSERT(m_entryIndex <= m_entryLength); } else { ::memcpy(o, &m_entryIndex[m_entry->rd_ptr()], n1); o += n1; m_entry = nextEntry(); ACESTL_MESSAGE_ASSERT("Attempt to walk off end of iterator's range", (0 == n || NULL != m_entry)); if(NULL != m_entry) { m_entryIndex = 0; m_entryLength = m_entry->length(); fast_copy(n - n1, o); } } } // Implementation private: ACE_Message_Block* nextEntry() { ACE_Message_Block* entry = NULL; return m_mqi.advance() ? (m_mqi.next(entry), entry) : NULL; } // Not to be implemented private: shared_handle(class_type const&); class_type& operator =(class_type const&); }; #endif /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */ public: typedef iterator class_type; /// The value type typedef char value_type; private: iterator(sequence_type &mq) : m_handle(new shared_handle(mq)) {} public: iterator() : m_handle(NULL) {} iterator(class_type const& rhs) : m_handle(rhs.m_handle) { if(NULL != m_handle) { m_handle->AddRef(); } } ~iterator() stlsoft_throw_0() { if(NULL != m_handle) { m_handle->Release(); } } class_type& operator =(class_type const& rhs) { shared_handle* this_handle = m_handle; m_handle = rhs.m_handle; if(NULL != m_handle) { m_handle->AddRef(); } if(NULL != this_handle) { this_handle->Release(); } return *this; } public: class_type& operator ++() { ACESTL_ASSERT(NULL != m_handle); if(!m_handle->advance()) { m_handle->Release(); m_handle = NULL; } return *this; } class_type operator ++(int) { class_type ret(*this); operator ++(); return ret; } value_type& operator *() { ACESTL_ASSERT(NULL != m_handle); return m_handle->current(); } value_type operator *() const { ACESTL_ASSERT(NULL != m_handle); return m_handle->current(); } public: ss_bool_t equal(class_type const& rhs) const { return class_type::equal_(*this, rhs, iterator_category()); } ss_bool_t operator ==(class_type const& rhs) const { return equal(rhs); } ss_bool_t operator !=(class_type const& rhs) const { return !equal(rhs); } private: static ss_bool_t equal_(class_type const& lhs, class_type const& rhs, stlsoft_ns_qual_std(input_iterator_tag)) { // Input iterator return lhs.is_end_point() == rhs.is_end_point(); } #if 0 static ss_bool_t equal_(class_type const& lhs, class_type const& rhs, stlsoft_ns_qual_std(forward_iterator_tag)); // Forward or above if(is_end_point()) { return rhs.is_end_point(); } else { if(rhs.is_end_point()) { return false; } else { ACESTL_ASSERT(NULL != m_handle); ACESTL_ASSERT(NULL != rhs.m_handle); } } #endif /* 0 */ private: ss_bool_t is_end_point() const { return NULL == m_handle || m_handle->is_end_point(); } private: void fast_copy(char const* f, char const* l) { if(f != l) { ACESTL_ASSERT(NULL != m_handle); m_handle->fast_copy(f, l, static_cast(l - f)); } } void fast_copy(class_type const& l, char* o) { if(*this != l) { ACESTL_ASSERT(NULL != m_handle); m_handle->fast_copy(l.m_handle, o); } } void fast_copy(size_type n, char* o) { if(0 != n) { ACESTL_ASSERT(NULL != m_handle); m_handle->fast_copy(n, o); } } private: shared_handle* m_handle; }; /// @} // Construction public: /// Create an instance representing the given environment variable ss_explicit_k message_queue_sequence(sequence_type &mq) : m_mq(mq) {} /// \name Iteration /// @{ public: /// Begins the iteration /// /// \return An iterator representing the start of the sequence iterator begin() { return iterator(m_mq); } /// Ends the iteration /// /// \return An iterator representing the end of the sequence iterator end() { return iterator(); } /// @} /// \name Attributes /// @{ public: /// Returns the number of bytes in the message queue size_type size() const { return m_mq.message_length() /* - 1 */; } /// Indicates whethere there are any bytes in the message queue as_bool_t empty() const { return const_cast(m_mq).is_empty(); } /// @} /// \name Operations /// @{ public: static char* fast_copy(iterator f, iterator l, char* o) { #if defined(ACESTL_MQS_NO_FAST_COPY_TO) for(; f != l; ++f, ++o) { *o = *f; } #else /* ? ACESTL_MQS_NO_FAST_COPY_TO */ f.fast_copy(l, o); #endif /* ACESTL_MQS_NO_FAST_COPY_TO */ return o; } static char* fast_copy(iterator f, size_type n, char* o) { #if defined(ACESTL_MQS_NO_FAST_COPY_TO) for(; 0 != n; ++f, ++o, --n) { *o = *f; } #else /* ? ACESTL_MQS_NO_FAST_COPY_TO */ f.fast_copy(n, o); #endif /* ACESTL_MQS_NO_FAST_COPY_TO */ return o; } static iterator fast_copy(char const* f, char const* l, iterator o) { #if defined(ACESTL_MQS_NO_FAST_COPY_FROM) for(; f != l; ++f, ++o) { *o = *f; } #else /* ? ACESTL_MQS_NO_FAST_COPY_FROM */ o.fast_copy(f, l); #endif /* ACESTL_MQS_NO_FAST_COPY_FROM */ return o; } /// @} /// \name Members /// @{ private: sequence_type &m_mq; /// @} /// \name Not to be implemented /// @{ private: message_queue_sequence(class_type const&); class_type& operator =(class_type const&); /// @} }; //////////////////////////////////////////////////////////////////////////// // Unit-testing #ifdef STLSOFT_UNITTEST # include "./unittest/message_queue_sequence_unittest_.h" #endif /* STLSOFT_UNITTEST */ /* ////////////////////////////////////////////////////////////////////// */ #ifndef _ACESTL_NO_NAMESPACE # if defined(_STLSOFT_NO_NAMESPACE) || \ defined(STLSOFT_DOCUMENTATION_SKIP_SECTION) } // namespace acestl # else } // namespace acestl_project } // namespace stlsoft # endif /* _STLSOFT_NO_NAMESPACE */ #endif /* !_ACESTL_NO_NAMESPACE */ // Define specialisations in the std namespace #ifdef STLSOFT_CF_std_NAMESPACE namespace std { #endif /* STLSOFT_CF_std_NAMESPACE */ STLSOFT_TEMPLATE_SPECIALISATION inline char* copy( acestl_ns_qual(message_queue_sequence)::iterator f , acestl_ns_qual(message_queue_sequence)::iterator l , char* o) { return acestl_ns_qual(message_queue_sequence)::fast_copy(f, l, o); } STLSOFT_TEMPLATE_SPECIALISATION inline char* copy( acestl_ns_qual(message_queue_sequence)::iterator f , acestl_ns_qual(message_queue_sequence)::iterator l , char* o) { return acestl_ns_qual(message_queue_sequence)::fast_copy(f, l, o); } STLSOFT_TEMPLATE_SPECIALISATION inline signed char* copy( acestl_ns_qual(message_queue_sequence)::iterator f , acestl_ns_qual(message_queue_sequence)::iterator l , signed char* o) { return reinterpret_cast(acestl_ns_qual(message_queue_sequence)::fast_copy(f, l, reinterpret_cast(o))); } STLSOFT_TEMPLATE_SPECIALISATION inline signed char* copy( acestl_ns_qual(message_queue_sequence)::iterator f , acestl_ns_qual(message_queue_sequence)::iterator l , signed char* o) { return reinterpret_cast(acestl_ns_qual(message_queue_sequence)::fast_copy(f, l, reinterpret_cast(o))); } STLSOFT_TEMPLATE_SPECIALISATION inline unsigned char* copy( acestl_ns_qual(message_queue_sequence)::iterator f , acestl_ns_qual(message_queue_sequence)::iterator l , unsigned char* o) { return reinterpret_cast(acestl_ns_qual(message_queue_sequence)::fast_copy(f, l, reinterpret_cast(o))); } STLSOFT_TEMPLATE_SPECIALISATION inline unsigned char* copy( acestl_ns_qual(message_queue_sequence)::iterator f , acestl_ns_qual(message_queue_sequence)::iterator l , unsigned char* o) { return reinterpret_cast(acestl_ns_qual(message_queue_sequence)::fast_copy(f, l, reinterpret_cast(o))); } STLSOFT_TEMPLATE_SPECIALISATION inline acestl_ns_qual(message_queue_sequence)::iterator copy( char* f , char* l , acestl_ns_qual(message_queue_sequence)::iterator o) { return acestl_ns_qual(message_queue_sequence)::fast_copy(f, l, o); } STLSOFT_TEMPLATE_SPECIALISATION inline acestl_ns_qual(message_queue_sequence)::iterator copy( char* f , char* l , acestl_ns_qual(message_queue_sequence)::iterator o) { return acestl_ns_qual(message_queue_sequence)::fast_copy(f, l, o); } STLSOFT_TEMPLATE_SPECIALISATION inline acestl_ns_qual(message_queue_sequence)::iterator copy( signed char* f , signed char* l , acestl_ns_qual(message_queue_sequence)::iterator o) { return acestl_ns_qual(message_queue_sequence)::fast_copy(stlsoft_ns_qual(sap_cast)(f), stlsoft_ns_qual(sap_cast)(l), o); } STLSOFT_TEMPLATE_SPECIALISATION inline acestl_ns_qual(message_queue_sequence)::iterator copy( signed char* f , signed char* l , acestl_ns_qual(message_queue_sequence)::iterator o) { return acestl_ns_qual(message_queue_sequence)::fast_copy(stlsoft_ns_qual(sap_cast)(f), stlsoft_ns_qual(sap_cast)(l), o); } STLSOFT_TEMPLATE_SPECIALISATION inline acestl_ns_qual(message_queue_sequence)::iterator copy( unsigned char* f , unsigned char* l , acestl_ns_qual(message_queue_sequence)::iterator o) { return acestl_ns_qual(message_queue_sequence)::fast_copy(stlsoft_ns_qual(sap_cast)(f), stlsoft_ns_qual(sap_cast)(l), o); } STLSOFT_TEMPLATE_SPECIALISATION inline acestl_ns_qual(message_queue_sequence)::iterator copy( unsigned char* f , unsigned char* l , acestl_ns_qual(message_queue_sequence)::iterator o) { return acestl_ns_qual(message_queue_sequence)::fast_copy(stlsoft_ns_qual(sap_cast)(f), stlsoft_ns_qual(sap_cast)(l), o); } STLSOFT_TEMPLATE_SPECIALISATION inline acestl_ns_qual(message_queue_sequence)::iterator copy( char const* f , char const* l , acestl_ns_qual(message_queue_sequence)::iterator o) { return acestl_ns_qual(message_queue_sequence)::fast_copy(f, l, o); } STLSOFT_TEMPLATE_SPECIALISATION inline acestl_ns_qual(message_queue_sequence)::iterator copy( char const* f , char const* l , acestl_ns_qual(message_queue_sequence)::iterator o) { return acestl_ns_qual(message_queue_sequence)::fast_copy(f, l, o); } STLSOFT_TEMPLATE_SPECIALISATION inline acestl_ns_qual(message_queue_sequence)::iterator copy( signed char const* f , signed char const* l , acestl_ns_qual(message_queue_sequence)::iterator o) { return acestl_ns_qual(message_queue_sequence)::fast_copy(stlsoft_ns_qual(sap_cast)(f), stlsoft_ns_qual(sap_cast)(l), o); } STLSOFT_TEMPLATE_SPECIALISATION inline acestl_ns_qual(message_queue_sequence)::iterator copy( signed char const* f , signed char const* l , acestl_ns_qual(message_queue_sequence)::iterator o) { return acestl_ns_qual(message_queue_sequence)::fast_copy(stlsoft_ns_qual(sap_cast)(f), stlsoft_ns_qual(sap_cast)(l), o); } STLSOFT_TEMPLATE_SPECIALISATION inline acestl_ns_qual(message_queue_sequence)::iterator copy( unsigned char const* f , unsigned char const* l , acestl_ns_qual(message_queue_sequence)::iterator o) { return acestl_ns_qual(message_queue_sequence)::fast_copy(stlsoft_ns_qual(sap_cast)(f), stlsoft_ns_qual(sap_cast)(l), o); } STLSOFT_TEMPLATE_SPECIALISATION inline acestl_ns_qual(message_queue_sequence)::iterator copy( unsigned char const* f , unsigned char const* l , acestl_ns_qual(message_queue_sequence)::iterator o) { return acestl_ns_qual(message_queue_sequence)::fast_copy(stlsoft_ns_qual(sap_cast)(f), stlsoft_ns_qual(sap_cast)(l), o); } #ifdef STLSOFT_CF_std_NAMESPACE } // namespace std #endif /* STLSOFT_CF_std_NAMESPACE */ // Define specialisations in the stlsoft namespace #ifndef _STLSOFT_NO_NAMESPACE namespace stlsoft { #endif /* !_STLSOFT_NO_NAMESPACE */ STLSOFT_TEMPLATE_SPECIALISATION inline char* copy_n(acestl_ns_qual(message_queue_sequence)::iterator f , ss_size_t n , char* o) { return acestl_ns_qual(message_queue_sequence)::fast_copy(f, n, o); } STLSOFT_TEMPLATE_SPECIALISATION inline char* copy_n(acestl_ns_qual(message_queue_sequence)::iterator f , ss_size_t n , char* o) { return acestl_ns_qual(message_queue_sequence)::fast_copy(f, n, o); } STLSOFT_TEMPLATE_SPECIALISATION inline signed char* copy_n( acestl_ns_qual(message_queue_sequence)::iterator f , ss_size_t n , signed char* o) { return reinterpret_cast(acestl_ns_qual(message_queue_sequence)::fast_copy(f, n, reinterpret_cast(o))); } STLSOFT_TEMPLATE_SPECIALISATION inline signed char* copy_n( acestl_ns_qual(message_queue_sequence)::iterator f , ss_size_t n , signed char* o) { return reinterpret_cast(acestl_ns_qual(message_queue_sequence)::fast_copy(f, n, reinterpret_cast(o))); } STLSOFT_TEMPLATE_SPECIALISATION inline unsigned char* copy_n( acestl_ns_qual(message_queue_sequence)::iterator f , ss_size_t n , unsigned char* o) { return reinterpret_cast(acestl_ns_qual(message_queue_sequence)::fast_copy(f, n, reinterpret_cast(o))); } STLSOFT_TEMPLATE_SPECIALISATION inline unsigned char* copy_n( acestl_ns_qual(message_queue_sequence)::iterator f , ss_size_t n , unsigned char* o) { return reinterpret_cast(acestl_ns_qual(message_queue_sequence)::fast_copy(f, n, reinterpret_cast(o))); } STLSOFT_TEMPLATE_SPECIALISATION inline acestl_ns_qual(message_queue_sequence)::iterator copy_n( char* f , ss_size_t n , acestl_ns_qual(message_queue_sequence)::iterator o) { return acestl_ns_qual(message_queue_sequence)::fast_copy(f, f + n, o); } STLSOFT_TEMPLATE_SPECIALISATION inline acestl_ns_qual(message_queue_sequence)::iterator copy_n( char* f , ss_size_t n , acestl_ns_qual(message_queue_sequence)::iterator o) { return acestl_ns_qual(message_queue_sequence)::fast_copy(f, f + n, o); } STLSOFT_TEMPLATE_SPECIALISATION inline acestl_ns_qual(message_queue_sequence)::iterator copy_n( signed char* f , ss_size_t n , acestl_ns_qual(message_queue_sequence)::iterator o) { return acestl_ns_qual(message_queue_sequence)::fast_copy(stlsoft_ns_qual(sap_cast)(f), stlsoft_ns_qual(sap_cast)(f) + n, o); } STLSOFT_TEMPLATE_SPECIALISATION inline acestl_ns_qual(message_queue_sequence)::iterator copy_n( signed char* f , ss_size_t n , acestl_ns_qual(message_queue_sequence)::iterator o) { return acestl_ns_qual(message_queue_sequence)::fast_copy(stlsoft_ns_qual(sap_cast)(f), stlsoft_ns_qual(sap_cast)(f) + n, o); } STLSOFT_TEMPLATE_SPECIALISATION inline acestl_ns_qual(message_queue_sequence)::iterator copy_n( unsigned char* f , ss_size_t n , acestl_ns_qual(message_queue_sequence)::iterator o) { return acestl_ns_qual(message_queue_sequence)::fast_copy(stlsoft_ns_qual(sap_cast)(f), stlsoft_ns_qual(sap_cast)(f) + n, o); } STLSOFT_TEMPLATE_SPECIALISATION inline acestl_ns_qual(message_queue_sequence)::iterator copy_n( unsigned char* f , ss_size_t n , acestl_ns_qual(message_queue_sequence)::iterator o) { return acestl_ns_qual(message_queue_sequence)::fast_copy(stlsoft_ns_qual(sap_cast)(f), stlsoft_ns_qual(sap_cast)(f) + n, o); } STLSOFT_TEMPLATE_SPECIALISATION inline acestl_ns_qual(message_queue_sequence)::iterator copy_n( char const* f , ss_size_t n , acestl_ns_qual(message_queue_sequence)::iterator o) { return acestl_ns_qual(message_queue_sequence)::fast_copy(f, f + n, o); } STLSOFT_TEMPLATE_SPECIALISATION inline acestl_ns_qual(message_queue_sequence)::iterator copy_n( char const* f , ss_size_t n , acestl_ns_qual(message_queue_sequence)::iterator o) { return acestl_ns_qual(message_queue_sequence)::fast_copy(f, f + n, o); } STLSOFT_TEMPLATE_SPECIALISATION inline acestl_ns_qual(message_queue_sequence)::iterator copy_n( signed char const* f , ss_size_t n , acestl_ns_qual(message_queue_sequence)::iterator o) { return acestl_ns_qual(message_queue_sequence)::fast_copy(stlsoft_ns_qual(sap_cast)(f), stlsoft_ns_qual(sap_cast)(f) + n, o); } STLSOFT_TEMPLATE_SPECIALISATION inline acestl_ns_qual(message_queue_sequence)::iterator copy_n( signed char const* f , ss_size_t n , acestl_ns_qual(message_queue_sequence)::iterator o) { return acestl_ns_qual(message_queue_sequence)::fast_copy(stlsoft_ns_qual(sap_cast)(f), stlsoft_ns_qual(sap_cast)(f) + n, o); } STLSOFT_TEMPLATE_SPECIALISATION inline acestl_ns_qual(message_queue_sequence)::iterator copy_n( unsigned char const* f , ss_size_t n , acestl_ns_qual(message_queue_sequence)::iterator o) { return acestl_ns_qual(message_queue_sequence)::fast_copy(stlsoft_ns_qual(sap_cast)(f), stlsoft_ns_qual(sap_cast)(f) + n, o); } STLSOFT_TEMPLATE_SPECIALISATION inline acestl_ns_qual(message_queue_sequence)::iterator copy_n( unsigned char const* f , ss_size_t n , acestl_ns_qual(message_queue_sequence)::iterator o) { return acestl_ns_qual(message_queue_sequence)::fast_copy(stlsoft_ns_qual(sap_cast)(f), stlsoft_ns_qual(sap_cast)(f) + n, o); } #ifndef _STLSOFT_NO_NAMESPACE } // namespace stlsoft #endif /* !_STLSOFT_NO_NAMESPACE */ /* ////////////////////////////////////////////////////////////////////// */ #endif /* ACESTL_INCL_ACESTL_COLLECTIONS_HPP_MESSAGE_QUEUE_SEQUENCE */ /* ///////////////////////////// end of file //////////////////////////// */