stabilize build system: depends, installer, boost/bdb fixes, cross targets groundwork

depends/x86_64-pc-linux-gnu/include/boost/compute/container/basic_string.hpp

@@ -0,0 +1,331 @@
+//---------------------------------------------------------------------------//
+// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com>
+//
+// 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
+//
+// See http://boostorg.github.com/compute for more information.
+//---------------------------------------------------------------------------//
+
+#ifndef BOOST_COMPUTE_CONTAINER_BASIC_STRING_HPP
+#define BOOST_COMPUTE_CONTAINER_BASIC_STRING_HPP
+
+#include <string>
+#include <cstring>
+
+#include <boost/compute/cl.hpp>
+#include <boost/compute/algorithm/find.hpp>
+#include <boost/compute/algorithm/search.hpp>
+#include <boost/compute/container/vector.hpp>
+#include <boost/compute/system.hpp>
+#include <boost/compute/command_queue.hpp>
+#include <iosfwd>
+
+namespace boost {
+namespace compute {
+
+/// \class basic_string
+/// \brief A template for a dynamically-sized character sequence.
+///
+/// The \c basic_string class provides a generic template for a dynamically-
+/// sized character sequence. This is most commonly used through the \c string
+/// typedef (for \c basic_string<char>).
+///
+/// For example, to create a string on the device with its contents copied
+/// from a C-string on the host:
+/// \code
+/// boost::compute::string str("hello, world!");
+/// \endcode
+///
+/// \see \ref vector "vector<T>"
+template<class CharT, class Traits = std::char_traits<CharT> >
+class basic_string
+{
+public:
+    typedef Traits traits_type;
+    typedef typename Traits::char_type value_type;
+    typedef size_t size_type;
+    static const size_type npos = size_type(-1);
+    typedef typename ::boost::compute::vector<CharT>::reference reference;
+    typedef typename ::boost::compute::vector<CharT>::const_reference const_reference;
+    typedef typename ::boost::compute::vector<CharT>::iterator iterator;
+    typedef typename ::boost::compute::vector<CharT>::const_iterator const_iterator;
+    typedef typename ::boost::compute::vector<CharT>::reverse_iterator reverse_iterator;
+    typedef typename ::boost::compute::vector<CharT>::const_reverse_iterator const_reverse_iterator;
+
+    basic_string()
+    {
+    }
+
+    basic_string(size_type count, CharT ch)
+        : m_data(count)
+    {
+        std::fill(m_data.begin(), m_data.end(), ch);
+    }
+
+    basic_string(const basic_string &other,
+                 size_type pos,
+                 size_type count = npos)
+        : m_data(other.begin() + pos,
+                 other.begin() + (std::min)(other.size(), count))
+    {
+    }
+
+    basic_string(const char *s, size_type count)
+        : m_data(s, s + count)
+    {
+    }
+
+    basic_string(const char *s)
+        : m_data(s, s + std::strlen(s))
+    {
+    }
+
+    template<class InputIterator>
+    basic_string(InputIterator first, InputIterator last)
+        : m_data(first, last)
+    {
+    }
+
+    basic_string(const basic_string<CharT, Traits> &other)
+        : m_data(other.m_data)
+    {
+    }
+
+    basic_string<CharT, Traits>& operator=(const basic_string<CharT, Traits> &other)
+    {
+        if(this != &other){
+            m_data = other.m_data;
+        }
+
+        return *this;
+    }
+
+    ~basic_string()
+    {
+    }
+
+    reference at(size_type pos)
+    {
+        return m_data.at(pos);
+    }
+
+    const_reference at(size_type pos) const
+    {
+        return m_data.at(pos);
+    }
+
+    reference operator[](size_type pos)
+    {
+        return m_data[pos];
+    }
+
+    const_reference operator[](size_type pos) const
+    {
+        return m_data[pos];
+    }
+
+    reference front()
+    {
+        return m_data.front();
+    }
+
+    const_reference front() const
+    {
+        return m_data.front();
+    }
+
+    reference back()
+    {
+        return m_data.back();
+    }
+
+    const_reference back() const
+    {
+        return m_data.back();
+    }
+
+    iterator begin()
+    {
+        return m_data.begin();
+    }
+
+    const_iterator begin() const
+    {
+        return m_data.begin();
+    }
+
+    const_iterator cbegin() const
+    {
+        return m_data.cbegin();
+    }
+
+    iterator end()
+    {
+        return m_data.end();
+    }
+
+    const_iterator end() const
+    {
+        return m_data.end();
+    }
+
+    const_iterator cend() const
+    {
+        return m_data.cend();
+    }
+
+    reverse_iterator rbegin()
+    {
+        return m_data.rbegin();
+    }
+
+    const_reverse_iterator rbegin() const
+    {
+        return m_data.rbegin();
+    }
+
+    const_reverse_iterator crbegin() const
+    {
+        return m_data.crbegin();
+    }
+
+    reverse_iterator rend()
+    {
+        return m_data.rend();
+    }
+
+    const_reverse_iterator rend() const
+    {
+        return m_data.rend();
+    }
+
+    const_reverse_iterator crend() const
+    {
+        return m_data.crend();
+    }
+
+    bool empty() const
+    {
+        return m_data.empty();
+    }
+
+    size_type size() const
+    {
+        return m_data.size();
+    }
+
+    size_type length() const
+    {
+        return m_data.size();
+    }
+
+    size_type max_size() const
+    {
+        return m_data.max_size();
+    }
+
+    void reserve(size_type size)
+    {
+        m_data.reserve(size);
+    }
+
+    size_type capacity() const
+    {
+        return m_data.capacity();
+    }
+
+    void shrink_to_fit()
+    {
+        m_data.shrink_to_fit();
+    }
+
+    void clear()
+    {
+        m_data.clear();
+    }
+
+    void swap(basic_string<CharT, Traits> &other)
+    {
+        if(this != &other)
+        {
+            ::boost::compute::vector<CharT> temp_data(other.m_data);
+            other.m_data = m_data;
+            m_data = temp_data;
+        }
+    }
+
+    basic_string<CharT, Traits> substr(size_type pos = 0,
+                                       size_type count = npos) const
+    {
+        return basic_string<CharT, Traits>(*this, pos, count);
+    }
+
+    /// Finds the first character \p ch
+    size_type find(CharT ch, size_type pos = 0) const
+    {
+        const_iterator iter = ::boost::compute::find(begin() + pos, end(), ch);
+        if(iter == end()){
+            return npos;
+        }
+        else {
+            return static_cast<size_type>(std::distance(begin(), iter));
+        }
+    }
+
+    /// Finds the first substring equal to \p str
+    size_type find(basic_string& str, size_type pos = 0) const
+    {
+        const_iterator iter = ::boost::compute::search(begin() + pos, end(),
+                                                       str.begin(), str.end());
+        if(iter == end()){
+            return npos;
+        }
+        else {
+            return static_cast<size_type>(std::distance(begin(), iter));
+        }
+    }
+
+    /// Finds the first substring equal to the character string
+    /// pointed to by \p s.
+    /// The length of the string is determined by the first null character.
+    ///
+    /// For example, the following code
+    /// \snippet test/test_string.cpp string_find
+    ///
+    /// will return 5 as position.
+    size_type find(const char* s, size_type pos = 0) const
+    {
+        basic_string str(s);
+        const_iterator iter = ::boost::compute::search(begin() + pos, end(),
+                                                       str.begin(), str.end());
+        if(iter == end()){
+            return npos;
+        }
+        else {
+            return static_cast<size_type>(std::distance(begin(), iter));
+        }
+    }
+
+private:
+    ::boost::compute::vector<CharT> m_data;
+};
+
+template<class CharT, class Traits>
+std::ostream&
+operator<<(std::ostream& stream,
+           boost::compute::basic_string<CharT, Traits>const& outStr)
+{
+    command_queue queue = ::boost::compute::system::default_queue();
+    boost::compute::copy(outStr.begin(),
+                        outStr.end(),
+                        std::ostream_iterator<CharT>(stream),
+                        queue);
+    return stream;
+}
+
+} // end compute namespace
+} // end boost namespace
+
+#endif // BOOST_COMPUTE_CONTAINER_BASIC_STRING_HPP