1 files changed, 307 insertions, 0 deletions
diff --git a/subversion/bindings/javahl/native/jniwrapper/jni_list.hpp b/subversion/bindings/javahl/native/jniwrapper/jni_list.hpp
new file mode 100644
index 0000000..9a11fc1
--- /dev/null
+++ b/subversion/bindings/javahl/native/jniwrapper/jni_list.hpp
@@ -0,0 +1,307 @@
+/**
+ * @copyright
+ * ====================================================================
+ *    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.
+ * ====================================================================
+ * @endcopyright
+ */
+
+#ifndef SVN_JAVAHL_JNIWRAPPER_LIST_HPP
+#define SVN_JAVAHL_JNIWRAPPER_LIST_HPP
+
+#include "jni_env.hpp"
+#include "jni_object.hpp"
+#include "jni_iterator.hpp"
+
+namespace Java {
+
+/**
+ * Non-template base for an immutable type-safe Java list.
+ *
+ * @since New in 1.9.
+ */
+class BaseImmutableList : public Object
+{
+public:
+  /**
+   * Returns the number of elements in the list.
+   */
+  jint length() const
+    {
+      return m_env.CallIntMethod(m_jthis, impl().m_mid_size);
+    }
+
+  /**
+   * Checks if the list is empty.
+   */
+  bool is_empty() const
+    {
+      return (length() == 0);
+    }
+
+protected:
+  /**
+   * Constructs the list wrapper
+   */
+  explicit BaseImmutableList(Env env, jobject jlist)
+    : Object(env, ClassCache::get_list(env), jlist)
+    {}
+
+  /**
+   * Constructor used by BaseList
+   */
+  explicit BaseImmutableList(Env env, const Object::ClassImpl* pimpl)
+    : Object(env, pimpl)
+    {}
+
+  /**
+   * Clears the contents of the list.
+   */
+  void clear()
+    {
+      m_env.CallVoidMethod(m_jthis, impl().m_mid_clear);
+    }
+
+  /**
+   * Appends @a obj to the end of the list.
+   */
+  void add(jobject obj)
+    {
+      m_env.CallVoidMethod(m_jthis, impl().m_mid_add, obj);
+    }
+
+  /**
+   * Returns the object reference at @a index.
+   * @throw std::out_of_range if the index value is not valid.
+   */
+  jobject operator[](jint index) const;
+
+  /**
+   * Iterator used by subclasses.
+   */
+  class Iterator : public BaseIterator
+  {
+    friend class BaseImmutableList;
+    explicit Iterator(Env env, jobject jiterator)
+      : BaseIterator(env, jiterator)
+      {}
+  };
+
+  /**
+   * Returns an iterator instance.
+   */
+  Iterator get_iterator() const;
+
+  /**
+   * This object's implementation details.
+   */
+  class ClassImpl : public Object::ClassImpl
+  {
+    friend class ClassCacheImpl;
+
+  protected:
+    explicit ClassImpl(Env env, jclass cls);
+
+  public:
+    virtual ~ClassImpl();
+
+    const MethodID m_mid_size;
+    const MethodID m_mid_get;
+    const MethodID m_mid_add;
+    const MethodID m_mid_clear;
+    const MethodID m_mid_iter;
+  };
+
+private:
+  friend class Iterator;
+  friend class ClassCacheImpl;
+  static const char* const m_class_name;
+
+  const ClassImpl& impl() const
+    {
+      return *dynamic_cast<const ClassImpl*>(m_impl);
+    }
+};
+
+/**
+ * Template wrapper for an immutable type-safe Java list.
+ *
+ * @since New in 1.9.
+ */
+template <typename T, typename NativeT=jobject>
+class ImmutableList : public BaseImmutableList
+{
+public:
+  /**
+   * Constructs the list wrapper.
+   */
+  explicit ImmutableList(Env env, jobject jlist)
+    : BaseImmutableList(env, jlist)
+    {}
+
+  /**
+   * Returns a wrapper object for the object reference at @a index.
+   * @throw std::out_of_range if the index value is not valid.
+   */
+  T operator[](jint index) const
+    {
+      return T(m_env, NativeT(BaseImmutableList::operator[](index)));
+    }
+
+  /**
+   * Iterates over the items in the list, calling @a function for
+   * each item.
+   * @see std::for_each
+   */
+  template<typename F>
+  F for_each(F function) const
+    {
+      Iterator iter(get_iterator());
+      while (iter.has_next())
+        function(T(m_env, NativeT(iter.next())));
+      return function;
+    }
+};
+
+/**
+ * Non-template base for a mutable type-safe Java list.
+ *
+ * @since New in 1.9.
+ */
+class BaseList : public BaseImmutableList
+{
+public:
+  /**
+   * Clears the contents of the list.
+   */
+  void clear()
+    {
+      BaseImmutableList::clear();
+    }
+
+protected:
+  /**
+   * Constructs the list wrapper, treating @a jlist as a @c java.util.List.
+   */
+  explicit BaseList(Env env, jobject jlist)
+    : BaseImmutableList(env, jlist)
+    {}
+
+  /**
+   * Constructs and wraps an empty list of type @c java.util.ArrayList
+   * with initial allocation size @a length.
+   */
+  explicit BaseList(Env env, jint length)
+    : BaseImmutableList(env, ClassCache::get_array_list(env))
+    {
+      set_this(env.NewObject(get_class(), impl().m_mid_ctor, length));
+    }
+
+  /**
+   * Appends @a obj to the end of the list.
+   */
+  void add(jobject obj)
+    {
+      BaseImmutableList::add(obj);
+    }
+
+private:
+  /**
+   * This object's implementation details.
+   */
+  class ClassImpl : public BaseImmutableList::ClassImpl
+  {
+    friend class ClassCacheImpl;
+
+  protected:
+    explicit ClassImpl(Env env, jclass cls);
+
+  public:
+    virtual ~ClassImpl();
+
+    const MethodID m_mid_ctor;
+  };
+
+  friend class ClassCacheImpl;
+  static const char* const m_class_name;
+
+  const ClassImpl& impl() const
+    {
+      return *dynamic_cast<const ClassImpl*>(m_impl);
+    }
+};
+
+/**
+ * Template wrapper for a mutable type-safe Java list.
+ *
+ * @since New in 1.9.
+ */
+template <typename T, typename NativeT=jobject>
+class List : public BaseList
+{
+public:
+  /**
+   * Constructs the list wrapper, deriving the class from @a jlist.
+   */
+  explicit List(Env env, jobject jlist)
+    : BaseList(env, jlist)
+    {}
+
+  /**
+   * Constructs and wraps an empty list of type @c java.util.ArrayList
+   * with initial allocation size @a length.
+   */
+  explicit List(Env env, jint length_ = 0)
+    : BaseList(env, length_)
+    {}
+
+  /**
+   * Returns a wrapper object for the object reference at @a index.
+   * @throw std::out_of_range if the index value is not valid.
+   */
+  T operator[](jint index) const
+    {
+      return T(m_env, NativeT(BaseList::operator[](index)));
+    }
+
+  /**
+   * Appends @a obj to the end of the list.
+   */
+  void add(const T& obj)
+    {
+      BaseList::add(obj.get());
+    }
+
+  /**
+   * Iterates over the items in the list, calling @a function for
+   * each item.
+   * @see std::for_each
+   */
+  template<typename F>
+  F for_each(F function) const
+    {
+      Iterator iter(get_iterator());
+      while (iter.has_next())
+        function(T(m_env, NativeT(iter.next())));
+      return function;
+    }
+};
+
+} // namespace Java
+
+#endif // SVN_JAVAHL_JNIWRAPPER_LIST_HPP