hunk.code_window: android {
     compileSdkVersion 27
     buildToolsVersion "27.0.3"
     defaultConfig {
       minSdkVersion 19
  
hunk.labels: keep keep keep replace keep keep keep
hunk.file_path: android/versioned-abis/expoview-abi28_0_0/build.gradle
hunk.type: replace
file: //---------------------------------------------------------------------------//
  // Copyright (c) 2013-2014 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_MEMORY_SVM_PTR_HPP
  #define BOOST_COMPUTE_MEMORY_SVM_PTR_HPP
  
  #include <boost/type_traits.hpp>
  #include <boost/static_assert.hpp>
  #include <boost/assert.hpp>
  
  #include <boost/compute/cl.hpp>
  #include <boost/compute/kernel.hpp>
  #include <boost/compute/context.hpp>
  #include <boost/compute/command_queue.hpp>
  #include <boost/compute/type_traits/is_device_iterator.hpp>
  
  namespace boost {
  namespace compute {
  
  // forward declaration for svm_ptr<T>
  template<class T>
  class svm_ptr;
  
  // svm functions require OpenCL 2.0
  #if defined(CL_VERSION_2_0) || defined(BOOST_COMPUTE_DOXYGEN_INVOKED)
  namespace detail {
  
  template<class T, class IndexExpr>
  struct svm_ptr_index_expr
  {
      typedef T result_type;
  
      svm_ptr_index_expr(const svm_ptr<T> &svm_ptr,
                         const IndexExpr &expr)
          : m_svm_ptr(svm_ptr),
            m_expr(expr)
      {
      }
  
      operator T() const
      {
          BOOST_STATIC_ASSERT_MSG(boost::is_integral<IndexExpr>::value,
                                  "Index expression must be integral");
  
          BOOST_ASSERT(m_svm_ptr.get());
  
          const context &context = m_svm_ptr.get_context();
          const device &device = context.get_device();
          command_queue queue(context, device);
  
          T value;
          T* ptr =
              static_cast<T*>(m_svm_ptr.get()) + static_cast<std::ptrdiff_t>(m_expr);
          queue.enqueue_svm_map(static_cast<void*>(ptr), sizeof(T), CL_MAP_READ);
          value = *(ptr);
          queue.enqueue_svm_unmap(static_cast<void*>(ptr)).wait();
  
          return value;
      }
  
      const svm_ptr<T> &m_svm_ptr;
      IndexExpr m_expr;
  };
  
  } // end detail namespace
  #endif
  
  template<class T>
  class svm_ptr
  {
  public:
      typedef T value_type;
      typedef std::ptrdiff_t difference_type;
      typedef T* pointer;
      typedef T& reference;
      typedef std::random_access_iterator_tag iterator_category;
  
      svm_ptr()
          : m_ptr(0)
      {
      }
  
      svm_ptr(void *ptr, const context &context)
          : m_ptr(static_cast<T*>(ptr)),
            m_context(context)
      {
      }
  
      svm_ptr(const svm_ptr<T> &other)
          : m_ptr(other.m_ptr),
            m_context(other.m_context)
      {
      }
  
      svm_ptr<T>& operator=(const svm_ptr<T> &other)
      {
          m_ptr = other.m_ptr;
          m_context = other.m_context;
          return *this;
      }
  
      ~svm_ptr()
      {
      }
  
      void* get() const
      {
          return m_ptr;
      }
  
      svm_ptr<T> operator+(difference_type n)
      {
          return svm_ptr<T>(m_ptr + n, m_context);
      }
  
      difference_type operator-(svm_ptr<T> other)
      {
          BOOST_ASSERT(other.m_context == m_context);
          return m_ptr - other.m_ptr;
      }
  
      context& get_context() const
      {
          return m_context;
      }
  
      // svm functions require OpenCL 2.0
      #if defined(CL_VERSION_2_0) || defined(BOOST_COMPUTE_DOXYGEN_INVOKED)
      /// \internal_
      template<class Expr>
      detail::svm_ptr_index_expr<T, Expr>
      operator[](const Expr &expr) const
      {
          BOOST_ASSERT(m_ptr);
  
          return detail::svm_ptr_index_expr<T, Expr>(*this,
                                                     expr);
      }
      #endif
  
  private:
      T *m_ptr;
      context m_context;
  };
  
  namespace detail {
  
  /// \internal_
  template<class T>
  struct set_kernel_arg<svm_ptr<T> >
  {
      void operator()(kernel &kernel_, size_t index, const svm_ptr<T> &ptr)
      {
          kernel_.set_arg_svm_ptr(index, ptr.get());
      }
  };
  
  } // end detail namespace
  
  /// \internal_ (is_device_iterator specialization for svm_ptr)
  template<class T>
  struct is_device_iterator<svm_ptr<T> > : boost::true_type {};
  
  } // end compute namespace
  } // end boost namespace
  
  #endif // BOOST_COMPUTE_MEMORY_SVM_PTR_HPP
  