CountedCompleter.xml

<Type Name="CountedCompleter" FullName="Java.Util.Concurrent.CountedCompleter">
  <TypeSignature Language="C#" Value="public abstract class CountedCompleter : Java.Util.Concurrent.ForkJoinTask" />
  <TypeSignature Language="ILAsm" Value=".class public auto ansi abstract beforefieldinit CountedCompleter extends Java.Util.Concurrent.ForkJoinTask" />
  <TypeSignature Language="DocId" Value="T:Java.Util.Concurrent.CountedCompleter" />
  <TypeSignature Language="F#" Value="type CountedCompleter = class&#xA;    inherit ForkJoinTask" />
  <AssemblyInfo>
    <AssemblyName>Mono.Android</AssemblyName>
    <AssemblyVersion>0.0.0.0</AssemblyVersion>
  </AssemblyInfo>
  <Base>
    <BaseTypeName>Java.Util.Concurrent.ForkJoinTask</BaseTypeName>
  </Base>
  <Interfaces />
  <Attributes>
    <Attribute>
      <AttributeName Language="C#">[Android.Runtime.Register("java/util/concurrent/CountedCompleter", ApiSince=24, DoNotGenerateAcw=true)]</AttributeName>
      <AttributeName Language="F#">[&lt;Android.Runtime.Register("java/util/concurrent/CountedCompleter", ApiSince=24, DoNotGenerateAcw=true)&gt;]</AttributeName>
    </Attribute>
    <Attribute>
      <AttributeName Language="C#">[Java.Interop.JavaTypeParameters(new System.String[] { "T" })]</AttributeName>
      <AttributeName Language="F#">[&lt;Java.Interop.JavaTypeParameters(new System.String[] { "T" })&gt;]</AttributeName>
    </Attribute>
    <Attribute>
      <AttributeName Language="C#">[System.Runtime.Versioning.SupportedOSPlatform("android24.0")]</AttributeName>
      <AttributeName Language="F#">[&lt;System.Runtime.Versioning.SupportedOSPlatform("android24.0")&gt;]</AttributeName>
    </Attribute>
  </Attributes>
  <Docs>
    <summary>A <c>ForkJoinTask</c> with a completion action performed when
            triggered and there are no remaining pending actions.</summary>
    <remarks>
      <para>A <c>ForkJoinTask</c> with a completion action performed when
            triggered and there are no remaining pending actions.
            CountedCompleters are in general more robust in the
            presence of subtask stalls and blockage than are other forms of
            ForkJoinTasks, but are less intuitive to program.  Uses of
            CountedCompleter are similar to those of other completion based
            components (such as <c>java.nio.channels.CompletionHandler</c>)
            except that multiple &lt;em&gt;pending&lt;/em&gt; completions may be necessary
            to trigger the completion action <c>#onCompletion(CountedCompleter)</c>,
            not just one.
            Unless initialized otherwise, the #getPendingCount pending
            count starts at zero, but may be (atomically) changed using
            methods <c>#setPendingCount</c>, <c>#addToPendingCount</c>, and
            <c>#compareAndSetPendingCount</c>. Upon invocation of <c>#tryComplete</c>, if the pending action count is nonzero, it is
            decremented; otherwise, the completion action is performed, and if
            this completer itself has a completer, the process is continued
            with its completer.  As is the case with related synchronization
            components such as <c>Phaser</c> and <c>Semaphore</c>, these methods
            affect only internal counts; they do not establish any further
            internal bookkeeping. In particular, the identities of pending
            tasks are not maintained. As illustrated below, you can create
            subclasses that do record some or all pending tasks or their
            results when needed.  As illustrated below, utility methods
            supporting customization of completion traversals are also
            provided. However, because CountedCompleters provide only basic
            synchronization mechanisms, it may be useful to create further
            abstract subclasses that maintain linkages, fields, and additional
            support methods appropriate for a set of related usages.</para>
      <para>A concrete CountedCompleter class must define method <c>#compute</c>, that should in most cases (as illustrated below), invoke
            <c>tryComplete()</c> once before returning. The class may also
            optionally override method <c>#onCompletion(CountedCompleter)</c>
            to perform an action upon normal completion, and method
            <c>#onExceptionalCompletion(Throwable, CountedCompleter)</c> to
            perform an action upon any exception.</para>
      <para>CountedCompleters most often do not bear results, in which case
            they are normally declared as <c>CountedCompleter&lt;Void&gt;</c>, and
            will always return <c>null</c> as a result value.  In other cases,
            you should override method <c>#getRawResult</c> to provide a
            result from <c>join(), invoke()</c>, and related methods.  In
            general, this method should return the value of a field (or a
            function of one or more fields) of the CountedCompleter object that
            holds the result upon completion. Method <c>#setRawResult</c> by
            default plays no role in CountedCompleters.  It is possible, but
            rarely applicable, to override this method to maintain other
            objects or fields holding result data.</para>
      <para>A CountedCompleter that does not itself have a completer (i.e.,
            one for which <c>#getCompleter</c> returns <c>null</c>) can be
            used as a regular ForkJoinTask with this added functionality.
            However, any completer that in turn has another completer serves
            only as an internal helper for other computations, so its own task
            status (as reported in methods such as <c>ForkJoinTask#isDone</c>)
            is arbitrary; this status changes only upon explicit invocations of
            <c>#complete</c>, <c>ForkJoinTask#cancel</c>,
            <c>ForkJoinTask#completeExceptionally(Throwable)</c> or upon
            exceptional completion of method <c>compute</c>. Upon any
            exceptional completion, the exception may be relayed to a task's
            completer (and its completer, and so on), if one exists and it has
            not otherwise already completed. Similarly, cancelling an internal
            CountedCompleter has only a local effect on that completer, so is
            not often useful.</para>
      <para>&lt;b&gt;Sample Usages.&lt;/b&gt;</para>
      <para>&lt;b&gt;Parallel recursive decomposition.&lt;/b&gt; CountedCompleters may
            be arranged in trees similar to those often used with <c>RecursiveAction</c>s, although the constructions involved in setting
            them up typically vary. Here, the completer of each task is its
            parent in the computation tree. Even though they entail a bit more
            bookkeeping, CountedCompleters may be better choices when applying
            a possibly time-consuming operation (that cannot be further
            subdivided) to each element of an array or collection; especially
            when the operation takes a significantly different amount of time
            to complete for some elements than others, either because of
            intrinsic variation (for example I/O) or auxiliary effects such as
            garbage collection.  Because CountedCompleters provide their own
            continuations, other tasks need not block waiting to perform them.</para>
      <para>For example, here is an initial version of a utility method that
            uses divide-by-two recursive decomposition to divide work into
            single pieces (leaf tasks). Even when work is split into individual
            calls, tree-based techniques are usually preferable to directly
            forking leaf tasks, because they reduce inter-thread communication
            and improve load balancing. In the recursive case, the second of
            each pair of subtasks to finish triggers completion of their parent
            (because no result combination is performed, the default no-op
            implementation of method <c>onCompletion</c> is not overridden).
            The utility method sets up the root task and invokes it (here,
            implicitly using the <c>ForkJoinPool#commonPool()</c>).  It is
            straightforward and reliable (but not optimal) to always set the
            pending count to the number of child tasks and call <c>tryComplete()</c> immediately before returning.</para>
      <code lang="text/java">{@code
            public static &lt;E&gt; void forEach(E[] array, Consumer&lt;E&gt; action) {
              class Task extends CountedCompleter&lt;Void&gt; {
                final int lo, hi;
                Task(Task parent, int lo, int hi) {
                  super(parent); this.lo = lo; this.hi = hi;
                }
            
                public void compute() {
                  if (hi - lo &gt;= 2) {
                    int mid = (lo + hi) &gt;&gt;&gt; 1;
                    // must set pending count before fork
                    setPendingCount(2);
                    new Task(this, mid, hi).fork(); // right child
                    new Task(this, lo, mid).fork(); // left child
                  }
                  else if (hi &gt; lo)
                    action.accept(array[lo]);
                  tryComplete();
                }
              }
              new Task(null, 0, array.length).invoke();
            }}</code>
      <para>This design can be improved by noticing that in the recursive case,
            the task has nothing to do after forking its right task, so can
            directly invoke its left task before returning. (This is an analog
            of tail recursion removal.)  Also, when the last action in a task
            is to fork or invoke a subtask (a "tail call"), the call to <c>tryComplete()</c> can be optimized away, at the cost of making the
            pending count look "off by one".</para>
      <code lang="text/java">{@code
                public void compute() {
                  if (hi - lo &gt;= 2) {
                    int mid = (lo + hi) &gt;&gt;&gt; 1;
                    setPendingCount(1); // looks off by one, but correct!
                    new Task(this, mid, hi).fork(); // right child
                    new Task(this, lo, mid).compute(); // direct invoke
                  } else {
                    if (hi &gt; lo)
                      action.accept(array[lo]);
                    tryComplete();
                  }
                }}</code>
      <para>As a further optimization, notice that the left task need not even exist.
            Instead of creating a new one, we can continue using the original task,
            and add a pending count for each fork.  Additionally, because no task
            in this tree implements an <c>#onCompletion(CountedCompleter)</c> method,
            <c>tryComplete</c> can be replaced with <c>#propagateCompletion</c>.</para>
      <code lang="text/java">{@code
                public void compute() {
                  int n = hi - lo;
                  for (; n &gt;= 2; n /= 2) {
                    addToPendingCount(1);
                    new Task(this, lo + n/2, lo + n).fork();
                  }
                  if (n &gt; 0)
                    action.accept(array[lo]);
                  propagateCompletion();
                }}</code>
      <para>When pending counts can be precomputed, they can be established in
            the constructor:</para>
      <code lang="text/java">{@code
            public static &lt;E&gt; void forEach(E[] array, Consumer&lt;E&gt; action) {
              class Task extends CountedCompleter&lt;Void&gt; {
                final int lo, hi;
                Task(Task parent, int lo, int hi) {
                  super(parent, 31 - Integer.numberOfLeadingZeros(hi - lo));
                  this.lo = lo; this.hi = hi;
                }
            
                public void compute() {
                  for (int n = hi - lo; n &gt;= 2; n /= 2)
                    new Task(this, lo + n/2, lo + n).fork();
                  action.accept(array[lo]);
                  propagateCompletion();
                }
              }
              if (array.length &gt; 0)
                new Task(null, 0, array.length).invoke();
            }}</code>
      <para>Additional optimizations of such classes might entail specializing
            classes for leaf steps, subdividing by say, four, instead of two
            per iteration, and using an adaptive threshold instead of always
            subdividing down to single elements.</para>
      <para>&lt;b&gt;Searching.&lt;/b&gt; A tree of CountedCompleters can search for a
            value or property in different parts of a data structure, and
            report a result in an <c>java.util.concurrent.atomic.AtomicReference AtomicReference</c> as
            soon as one is found. The others can poll the result to avoid
            unnecessary work. (You could additionally #cancel
            cancel other tasks, but it is usually simpler and more efficient
            to just let them notice that the result is set and if so skip
            further processing.)  Illustrating again with an array using full
            partitioning (again, in practice, leaf tasks will almost always
            process more than one element):</para>
      <code lang="text/java">{@code
            class Searcher&lt;E&gt; extends CountedCompleter&lt;E&gt; {
              final E[] array; final AtomicReference&lt;E&gt; result; final int lo, hi;
              Searcher(CountedCompleter&lt;?&gt; p, E[] array, AtomicReference&lt;E&gt; result, int lo, int hi) {
                super(p);
                this.array = array; this.result = result; this.lo = lo; this.hi = hi;
              }
              public E getRawResult() { return result.get(); }
              public void compute() { // similar to ForEach version 3
                int l = lo, h = hi;
                while (result.get() == null &amp;&amp; h &gt;= l) {
                  if (h - l &gt;= 2) {
                    int mid = (l + h) &gt;&gt;&gt; 1;
                    addToPendingCount(1);
                    new Searcher(this, array, result, mid, h).fork();
                    h = mid;
                  }
                  else {
                    E x = array[l];
                    if (matches(x) &amp;&amp; result.compareAndSet(null, x))
                      quietlyCompleteRoot(); // root task is now joinable
                    break;
                  }
                }
                tryComplete(); // normally complete whether or not found
              }
              boolean matches(E e) { ... } // return true if found
            
              public static &lt;E&gt; E search(E[] array) {
                  return new Searcher&lt;E&gt;(null, array, new AtomicReference&lt;E&gt;(), 0, array.length).invoke();
              }
            }}</code>
      <para>In this example, as well as others in which tasks have no other
            effects except to <c>compareAndSet</c> a common result, the
            trailing unconditional invocation of <c>tryComplete</c> could be
            made conditional (<c>if (result.get() == null) tryComplete();</c>)
            because no further bookkeeping is required to manage completions
            once the root task completes.</para>
      <para>&lt;b&gt;Recording subtasks.&lt;/b&gt; CountedCompleter tasks that combine
            results of multiple subtasks usually need to access these results
            in method <c>#onCompletion(CountedCompleter)</c>. As illustrated in the following
            class (that performs a simplified form of map-reduce where mappings
            and reductions are all of type <c>E</c>), one way to do this in
            divide and conquer designs is to have each subtask record its
            sibling, so that it can be accessed in method <c>onCompletion</c>.
            This technique applies to reductions in which the order of
            combining left and right results does not matter; ordered
            reductions require explicit left/right designations.  Variants of
            other streamlinings seen in the above examples may also apply.</para>
      <code lang="text/java">{@code
            class MyMapper&lt;E&gt; { E apply(E v) {  ...  } }
            class MyReducer&lt;E&gt; { E apply(E x, E y) {  ...  } }
            class MapReducer&lt;E&gt; extends CountedCompleter&lt;E&gt; {
              final E[] array; final MyMapper&lt;E&gt; mapper;
              final MyReducer&lt;E&gt; reducer; final int lo, hi;
              MapReducer&lt;E&gt; sibling;
              E result;
              MapReducer(CountedCompleter&lt;?&gt; p, E[] array, MyMapper&lt;E&gt; mapper,
                         MyReducer&lt;E&gt; reducer, int lo, int hi) {
                super(p);
                this.array = array; this.mapper = mapper;
                this.reducer = reducer; this.lo = lo; this.hi = hi;
              }
              public void compute() {
                if (hi - lo &gt;= 2) {
                  int mid = (lo + hi) &gt;&gt;&gt; 1;
                  MapReducer&lt;E&gt; left = new MapReducer(this, array, mapper, reducer, lo, mid);
                  MapReducer&lt;E&gt; right = new MapReducer(this, array, mapper, reducer, mid, hi);
                  left.sibling = right;
                  right.sibling = left;
                  setPendingCount(1); // only right is pending
                  right.fork();
                  left.compute();     // directly execute left
                }
                else {
                  if (hi &gt; lo)
                      result = mapper.apply(array[lo]);
                  tryComplete();
                }
              }
              public void onCompletion(CountedCompleter&lt;?&gt; caller) {
                if (caller != this) {
                  MapReducer&lt;E&gt; child = (MapReducer&lt;E&gt;)caller;
                  MapReducer&lt;E&gt; sib = child.sibling;
                  if (sib == null || sib.result == null)
                    result = child.result;
                  else
                    result = reducer.apply(child.result, sib.result);
                }
              }
              public E getRawResult() { return result; }
            
              public static &lt;E&gt; E mapReduce(E[] array, MyMapper&lt;E&gt; mapper, MyReducer&lt;E&gt; reducer) {
                return new MapReducer&lt;E&gt;(null, array, mapper, reducer,
                                         0, array.length).invoke();
              }
            }}</code>
      <para>Here, method <c>onCompletion</c> takes a form common to many
            completion designs that combine results. This callback-style method
            is triggered once per task, in either of the two different contexts
            in which the pending count is, or becomes, zero: (1) by a task
            itself, if its pending count is zero upon invocation of <c>tryComplete</c>, or (2) by any of its subtasks when they complete and
            decrement the pending count to zero. The <c>caller</c> argument
            distinguishes cases.  Most often, when the caller is <c>this</c>,
            no action is necessary. Otherwise the caller argument can be used
            (usually via a cast) to supply a value (and/or links to other
            values) to be combined.  Assuming proper use of pending counts, the
            actions inside <c>onCompletion</c> occur (once) upon completion of
            a task and its subtasks. No additional synchronization is required
            within this method to ensure thread safety of accesses to fields of
            this task or other completed tasks.</para>
      <para>&lt;b&gt;Completion Traversals.&lt;/b&gt; If using <c>onCompletion</c> to
            process completions is inapplicable or inconvenient, you can use
            methods <c>#firstComplete</c> and <c>#nextComplete</c> to create
            custom traversals.  For example, to define a MapReducer that only
            splits out right-hand tasks in the form of the third ForEach
            example, the completions must cooperatively reduce along
            unexhausted subtask links, which can be done as follows:</para>
      <code lang="text/java">{@code
            class MapReducer&lt;E&gt; extends CountedCompleter&lt;E&gt; { // version 2
              final E[] array; final MyMapper&lt;E&gt; mapper;
              final MyReducer&lt;E&gt; reducer; final int lo, hi;
              MapReducer&lt;E&gt; forks, next; // record subtask forks in list
              E result;
              MapReducer(CountedCompleter&lt;?&gt; p, E[] array, MyMapper&lt;E&gt; mapper,
                         MyReducer&lt;E&gt; reducer, int lo, int hi, MapReducer&lt;E&gt; next) {
                super(p);
                this.array = array; this.mapper = mapper;
                this.reducer = reducer; this.lo = lo; this.hi = hi;
                this.next = next;
              }
              public void compute() {
                int l = lo, h = hi;
                while (h - l &gt;= 2) {
                  int mid = (l + h) &gt;&gt;&gt; 1;
                  addToPendingCount(1);
                  (forks = new MapReducer(this, array, mapper, reducer, mid, h, forks)).fork();
                  h = mid;
                }
                if (h &gt; l)
                  result = mapper.apply(array[l]);
                // process completions by reducing along and advancing subtask links
                for (CountedCompleter&lt;?&gt; c = firstComplete(); c != null; c = c.nextComplete()) {
                  for (MapReducer t = (MapReducer)c, s = t.forks; s != null; s = t.forks = s.next)
                    t.result = reducer.apply(t.result, s.result);
                }
              }
              public E getRawResult() { return result; }
            
              public static &lt;E&gt; E mapReduce(E[] array, MyMapper&lt;E&gt; mapper, MyReducer&lt;E&gt; reducer) {
                return new MapReducer&lt;E&gt;(null, array, mapper, reducer,
                                         0, array.length, null).invoke();
              }
            }}</code>
      <para>&lt;b&gt;Triggers.&lt;/b&gt; Some CountedCompleters are themselves never
            forked, but instead serve as bits of plumbing in other designs;
            including those in which the completion of one or more async tasks
            triggers another async task. For example:</para>
      <code lang="text/java">{@code
            class HeaderBuilder extends CountedCompleter&lt;...&gt; { ... }
            class BodyBuilder extends CountedCompleter&lt;...&gt; { ... }
            class PacketSender extends CountedCompleter&lt;...&gt; {
              PacketSender(...) { super(null, 1); ... } // trigger on second completion
              public void compute() { } // never called
              public void onCompletion(CountedCompleter&lt;?&gt; caller) { sendPacket(); }
            }
            // sample use:
            PacketSender p = new PacketSender();
            new HeaderBuilder(p, ...).fork();
            new BodyBuilder(p, ...).fork();}</code>
      <para>Added in 1.8.</para>
      <para>
        <format type="text/html">
          <a href="https://developer.android.com/reference/java/util/concurrent/CountedCompleter" title="Reference documentation">Java documentation for <code>java.util.concurrent.CountedCompleter</code>.</a>
        </format>
      </para>
      <para>
                    Portions of this page are modifications based on work created and shared by the 
                    <format type="text/html"><a href="https://developers.google.com/terms/site-policies" title="Android Open Source Project">Android Open Source Project</a></format>
                     and used according to terms described in the 
                    <format type="text/html"><a href="https://creativecommons.org/licenses/by/2.5/" title="Creative Commons 2.5 Attribution License">Creative Commons 2.5 Attribution License.</a></format></para>
    </remarks>
  </Docs>
  <Members>
    <Member MemberName=".ctor">
      <MemberSignature Language="C#" Value="protected CountedCompleter ();" />
      <MemberSignature Language="ILAsm" Value=".method familyhidebysig specialname rtspecialname instance void .ctor() cil managed" />
      <MemberSignature Language="DocId" Value="M:Java.Util.Concurrent.CountedCompleter.#ctor" />
      <MemberType>Constructor</MemberType>
      <AssemblyInfo>
        <AssemblyName>Mono.Android</AssemblyName>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName Language="C#">[Android.Runtime.Register(".ctor", "()V", "", ApiSince=24)]</AttributeName>
          <AttributeName Language="F#">[&lt;Android.Runtime.Register(".ctor", "()V", "", ApiSince=24)&gt;]</AttributeName>
        </Attribute>
        <Attribute>
          <AttributeName Language="C#">[System.Runtime.Versioning.SupportedOSPlatform("android24.0")]</AttributeName>
          <AttributeName Language="F#">[&lt;System.Runtime.Versioning.SupportedOSPlatform("android24.0")&gt;]</AttributeName>
        </Attribute>
      </Attributes>
      <Parameters />
      <Docs>
        <summary>Creates a new CountedCompleter with no completer
            and an initial pending count of zero.</summary>
        <remarks>
          <para>Creates a new CountedCompleter with no completer
            and an initial pending count of zero.</para>
          <para>
            <format type="text/html">
              <a href="https://developer.android.com/reference/java/util/concurrent/CountedCompleter#CountedCompleter()" title="Reference documentation">Java documentation for <code>java.util.concurrent.CountedCompleter.CountedCompleter()</code>.</a>
            </format>
          </para>
          <para>
                    Portions of this page are modifications based on work created and shared by the 
                    <format type="text/html"><a href="https://developers.google.com/terms/site-policies" title="Android Open Source Project">Android Open Source Project</a></format>
                     and used according to terms described in the 
                    <format type="text/html"><a href="https://creativecommons.org/licenses/by/2.5/" title="Creative Commons 2.5 Attribution License">Creative Commons 2.5 Attribution License.</a></format></para>
        </remarks>
      </Docs>
    </Member>
    <Member MemberName=".ctor">
      <MemberSignature Language="C#" Value="protected CountedCompleter (Java.Util.Concurrent.CountedCompleter? completer);" />
      <MemberSignature Language="ILAsm" Value=".method familyhidebysig specialname rtspecialname instance void .ctor(class Java.Util.Concurrent.CountedCompleter completer) cil managed" />
      <MemberSignature Language="DocId" Value="M:Java.Util.Concurrent.CountedCompleter.#ctor(Java.Util.Concurrent.CountedCompleter)" />
      <MemberSignature Language="F#" Value="new Java.Util.Concurrent.CountedCompleter : Java.Util.Concurrent.CountedCompleter -&gt; Java.Util.Concurrent.CountedCompleter" Usage="new Java.Util.Concurrent.CountedCompleter completer" />
      <MemberType>Constructor</MemberType>
      <AssemblyInfo>
        <AssemblyName>Mono.Android</AssemblyName>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName Language="C#">[Android.Runtime.Register(".ctor", "(Ljava/util/concurrent/CountedCompleter;)V", "", ApiSince=24)]</AttributeName>
          <AttributeName Language="F#">[&lt;Android.Runtime.Register(".ctor", "(Ljava/util/concurrent/CountedCompleter;)V", "", ApiSince=24)&gt;]</AttributeName>
        </Attribute>
        <Attribute>
          <AttributeName Language="C#">[System.Runtime.Versioning.SupportedOSPlatform("android24.0")]</AttributeName>
          <AttributeName Language="F#">[&lt;System.Runtime.Versioning.SupportedOSPlatform("android24.0")&gt;]</AttributeName>
        </Attribute>
      </Attributes>
      <Parameters>
        <Parameter Name="completer" Type="Java.Util.Concurrent.CountedCompleter" />
      </Parameters>
      <Docs>
        <param name="completer">this task's completer, or <c>null</c> if none</param>
        <summary>Creates a new CountedCompleter with the given completer
            and an initial pending count of zero.</summary>
        <remarks>
          <para>Creates a new CountedCompleter with the given completer
            and an initial pending count of zero.</para>
          <para>
            <format type="text/html">
              <a href="https://developer.android.com/reference/java/util/concurrent/CountedCompleter#CountedCompleter(java.util.concurrent.CountedCompleter%3C?%3E)" title="Reference documentation">Java documentation for <code>java.util.concurrent.CountedCompleter.CountedCompleter(java.util.concurrent.CountedCompleter&lt;?&gt;)</code>.</a>
            </format>
          </para>
          <para>
                    Portions of this page are modifications based on work created and shared by the 
                    <format type="text/html"><a href="https://developers.google.com/terms/site-policies" title="Android Open Source Project">Android Open Source Project</a></format>
                     and used according to terms described in the 
                    <format type="text/html"><a href="https://creativecommons.org/licenses/by/2.5/" title="Creative Commons 2.5 Attribution License">Creative Commons 2.5 Attribution License.</a></format></para>
        </remarks>
      </Docs>
    </Member>
    <Member MemberName=".ctor">
      <MemberSignature Language="C#" Value="protected CountedCompleter (Java.Util.Concurrent.CountedCompleter? completer, int initialPendingCount);" />
      <MemberSignature Language="ILAsm" Value=".method familyhidebysig specialname rtspecialname instance void .ctor(class Java.Util.Concurrent.CountedCompleter completer, int32 initialPendingCount) cil managed" />
      <MemberSignature Language="DocId" Value="M:Java.Util.Concurrent.CountedCompleter.#ctor(Java.Util.Concurrent.CountedCompleter,System.Int32)" />
      <MemberSignature Language="F#" Value="new Java.Util.Concurrent.CountedCompleter : Java.Util.Concurrent.CountedCompleter * int -&gt; Java.Util.Concurrent.CountedCompleter" Usage="new Java.Util.Concurrent.CountedCompleter (completer, initialPendingCount)" />
      <MemberType>Constructor</MemberType>
      <AssemblyInfo>
        <AssemblyName>Mono.Android</AssemblyName>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName Language="C#">[Android.Runtime.Register(".ctor", "(Ljava/util/concurrent/CountedCompleter;I)V", "", ApiSince=24)]</AttributeName>
          <AttributeName Language="F#">[&lt;Android.Runtime.Register(".ctor", "(Ljava/util/concurrent/CountedCompleter;I)V", "", ApiSince=24)&gt;]</AttributeName>
        </Attribute>
        <Attribute>
          <AttributeName Language="C#">[System.Runtime.Versioning.SupportedOSPlatform("android24.0")]</AttributeName>
          <AttributeName Language="F#">[&lt;System.Runtime.Versioning.SupportedOSPlatform("android24.0")&gt;]</AttributeName>
        </Attribute>
      </Attributes>
      <Parameters>
        <Parameter Name="completer" Type="Java.Util.Concurrent.CountedCompleter" />
        <Parameter Name="initialPendingCount" Type="System.Int32" />
      </Parameters>
      <Docs>
        <param name="completer">this task's completer, or <c>null</c> if none</param>
        <param name="initialPendingCount">the initial pending count</param>
        <summary>Creates a new CountedCompleter with the given completer
            and initial pending count.</summary>
        <remarks>
          <para>Creates a new CountedCompleter with the given completer
            and initial pending count.</para>
          <para>
            <format type="text/html">
              <a href="https://developer.android.com/reference/java/util/concurrent/CountedCompleter#CountedCompleter(java.util.concurrent.CountedCompleter%3C?%3E,%20int)" title="Reference documentation">Java documentation for <code>java.util.concurrent.CountedCompleter.CountedCompleter(java.util.concurrent.CountedCompleter&lt;?&gt;, int)</code>.</a>
            </format>
          </para>
          <para>
                    Portions of this page are modifications based on work created and shared by the 
                    <format type="text/html"><a href="https://developers.google.com/terms/site-policies" title="Android Open Source Project">Android Open Source Project</a></format>
                     and used according to terms described in the 
                    <format type="text/html"><a href="https://creativecommons.org/licenses/by/2.5/" title="Creative Commons 2.5 Attribution License">Creative Commons 2.5 Attribution License.</a></format></para>
        </remarks>
      </Docs>
    </Member>
    <Member MemberName=".ctor">
      <MemberSignature Language="C#" Value="protected CountedCompleter (IntPtr javaReference, Android.Runtime.JniHandleOwnership transfer);" />
      <MemberSignature Language="ILAsm" Value=".method familyhidebysig specialname rtspecialname instance void .ctor(native int javaReference, valuetype Android.Runtime.JniHandleOwnership transfer) cil managed" />
      <MemberSignature Language="DocId" Value="M:Java.Util.Concurrent.CountedCompleter.#ctor(System.IntPtr,Android.Runtime.JniHandleOwnership)" />
      <MemberSignature Language="F#" Value="new Java.Util.Concurrent.CountedCompleter : nativeint * Android.Runtime.JniHandleOwnership -&gt; Java.Util.Concurrent.CountedCompleter" Usage="new Java.Util.Concurrent.CountedCompleter (javaReference, transfer)" />
      <MemberType>Constructor</MemberType>
      <AssemblyInfo>
        <AssemblyName>Mono.Android</AssemblyName>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Parameters>
        <Parameter Name="javaReference" Type="System.IntPtr" />
        <Parameter Name="transfer" Type="Android.Runtime.JniHandleOwnership" />
      </Parameters>
      <Docs>
        <param name="javaReference">To be added.</param>
        <param name="transfer">To be added.</param>
        <summary>To be added.</summary>
        <remarks>
          <para>Portions of this page are modifications based on work created and shared by the <format type="text/html"><a href="https://developers.google.com/terms/site-policies" title="Android Open Source Project">Android Open Source Project</a></format> and used according to terms described in the <format type="text/html"><a href="https://creativecommons.org/licenses/by/2.5/" title="Creative Commons 2.5 Attribution License">Creative Commons 2.5 Attribution License.</a></format></para>
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="AddToPendingCount">
      <MemberSignature Language="C#" Value="public void AddToPendingCount (int delta);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance void AddToPendingCount(int32 delta) cil managed" />
      <MemberSignature Language="DocId" Value="M:Java.Util.Concurrent.CountedCompleter.AddToPendingCount(System.Int32)" />
      <MemberSignature Language="F#" Value="member this.AddToPendingCount : int -&gt; unit" Usage="countedCompleter.AddToPendingCount delta" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Mono.Android</AssemblyName>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName Language="C#">[Android.Runtime.Register("addToPendingCount", "(I)V", "", ApiSince=24)]</AttributeName>
          <AttributeName Language="F#">[&lt;Android.Runtime.Register("addToPendingCount", "(I)V", "", ApiSince=24)&gt;]</AttributeName>
        </Attribute>
        <Attribute>
          <AttributeName Language="C#">[System.Runtime.Versioning.SupportedOSPlatform("android24.0")]</AttributeName>
          <AttributeName Language="F#">[&lt;System.Runtime.Versioning.SupportedOSPlatform("android24.0")&gt;]</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="delta" Type="System.Int32" />
      </Parameters>
      <Docs>
        <param name="delta">the value to add</param>
        <summary>Adds (atomically) the given value to the pending count.</summary>
        <remarks>
          <para>Adds (atomically) the given value to the pending count.</para>
          <para>
            <format type="text/html">
              <a href="https://developer.android.com/reference/java/util/concurrent/CountedCompleter#addToPendingCount(int)" title="Reference documentation">Java documentation for <code>java.util.concurrent.CountedCompleter.addToPendingCount(int)</code>.</a>
            </format>
          </para>
          <para>
                    Portions of this page are modifications based on work created and shared by the 
                    <format type="text/html"><a href="https://developers.google.com/terms/site-policies" title="Android Open Source Project">Android Open Source Project</a></format>
                     and used according to terms described in the 
                    <format type="text/html"><a href="https://creativecommons.org/licenses/by/2.5/" title="Creative Commons 2.5 Attribution License">Creative Commons 2.5 Attribution License.</a></format></para>
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="CompareAndSetPendingCount">
      <MemberSignature Language="C#" Value="public bool CompareAndSetPendingCount (int expected, int count);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance bool CompareAndSetPendingCount(int32 expected, int32 count) cil managed" />
      <MemberSignature Language="DocId" Value="M:Java.Util.Concurrent.CountedCompleter.CompareAndSetPendingCount(System.Int32,System.Int32)" />
      <MemberSignature Language="F#" Value="member this.CompareAndSetPendingCount : int * int -&gt; bool" Usage="countedCompleter.CompareAndSetPendingCount (expected, count)" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Mono.Android</AssemblyName>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName Language="C#">[Android.Runtime.Register("compareAndSetPendingCount", "(II)Z", "", ApiSince=24)]</AttributeName>
          <AttributeName Language="F#">[&lt;Android.Runtime.Register("compareAndSetPendingCount", "(II)Z", "", ApiSince=24)&gt;]</AttributeName>
        </Attribute>
        <Attribute>
          <AttributeName Language="C#">[System.Runtime.Versioning.SupportedOSPlatform("android24.0")]</AttributeName>
          <AttributeName Language="F#">[&lt;System.Runtime.Versioning.SupportedOSPlatform("android24.0")&gt;]</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="expected" Type="System.Int32" />
        <Parameter Name="count" Type="System.Int32" />
      </Parameters>
      <Docs>
        <param name="expected">the expected value</param>
        <param name="count">the new value</param>
        <summary>Sets (atomically) the pending count to the given count only if
            it currently holds the given expected value.</summary>
        <returns>
          <c>true</c> if successful</returns>
        <remarks>
          <para>Sets (atomically) the pending count to the given count only if
            it currently holds the given expected value.</para>
          <para>
            <format type="text/html">
              <a href="https://developer.android.com/reference/java/util/concurrent/CountedCompleter#compareAndSetPendingCount(int,%20int)" title="Reference documentation">Java documentation for <code>java.util.concurrent.CountedCompleter.compareAndSetPendingCount(int, int)</code>.</a>
            </format>
          </para>
          <para>
                    Portions of this page are modifications based on work created and shared by the 
                    <format type="text/html"><a href="https://developers.google.com/terms/site-policies" title="Android Open Source Project">Android Open Source Project</a></format>
                     and used according to terms described in the 
                    <format type="text/html"><a href="https://creativecommons.org/licenses/by/2.5/" title="Creative Commons 2.5 Attribution License">Creative Commons 2.5 Attribution License.</a></format></para>
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="Complete">
      <MemberSignature Language="C#" Value="public override void Complete (Java.Lang.Object? rawResult);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance void Complete(class Java.Lang.Object rawResult) cil managed" />
      <MemberSignature Language="DocId" Value="M:Java.Util.Concurrent.CountedCompleter.Complete(Java.Lang.Object)" />
      <MemberSignature Language="F#" Value="override this.Complete : Java.Lang.Object -&gt; unit" Usage="countedCompleter.Complete rawResult" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Mono.Android</AssemblyName>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName Language="C#">[Android.Runtime.Register("complete", "(Ljava/lang/Object;)V", "GetComplete_Ljava_lang_Object_Handler", ApiSince=24)]</AttributeName>
          <AttributeName Language="F#">[&lt;Android.Runtime.Register("complete", "(Ljava/lang/Object;)V", "GetComplete_Ljava_lang_Object_Handler", ApiSince=24)&gt;]</AttributeName>
        </Attribute>
        <Attribute>
          <AttributeName Language="C#">[System.Runtime.Versioning.SupportedOSPlatform("android24.0")]</AttributeName>
          <AttributeName Language="F#">[&lt;System.Runtime.Versioning.SupportedOSPlatform("android24.0")&gt;]</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="rawResult" Type="Java.Lang.Object" />
      </Parameters>
      <Docs>
        <param name="rawResult">the raw result</param>
        <summary>Regardless of pending count, invokes
            <c>#onCompletion(CountedCompleter)</c>, marks this task as
            complete and further triggers <c>#tryComplete</c> on this
            task's completer, if one exists.</summary>
        <remarks>
          <para>Regardless of pending count, invokes
            <c>#onCompletion(CountedCompleter)</c>, marks this task as
            complete and further triggers <c>#tryComplete</c> on this
            task's completer, if one exists.  The given rawResult is
            used as an argument to <c>#setRawResult</c> before invoking
            <c>#onCompletion(CountedCompleter)</c> or marking this task
            as complete; its value is meaningful only for classes
            overriding <c>setRawResult</c>.  This method does not modify
            the pending count.</para>
          <para>This method may be useful when forcing completion as soon as
            any one (versus all) of several subtask results are obtained.
            However, in the common (and recommended) case in which <c>setRawResult</c> is not overridden, this effect can be obtained
            more simply using <c>#quietlyCompleteRoot()</c>.</para>
          <para>
            <format type="text/html">
              <a href="https://developer.android.com/reference/java/util/concurrent/CountedCompleter#complete(T)" title="Reference documentation">Java documentation for <code>java.util.concurrent.CountedCompleter.complete(T)</code>.</a>
            </format>
          </para>
          <para>
                    Portions of this page are modifications based on work created and shared by the 
                    <format type="text/html"><a href="https://developers.google.com/terms/site-policies" title="Android Open Source Project">Android Open Source Project</a></format>
                     and used according to terms described in the 
                    <format type="text/html"><a href="https://creativecommons.org/licenses/by/2.5/" title="Creative Commons 2.5 Attribution License">Creative Commons 2.5 Attribution License.</a></format></para>
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="Completer">
      <MemberSignature Language="C#" Value="public Java.Util.Concurrent.CountedCompleter? Completer { get; }" />
      <MemberSignature Language="ILAsm" Value=".property instance class Java.Util.Concurrent.CountedCompleter Completer" />
      <MemberSignature Language="DocId" Value="P:Java.Util.Concurrent.CountedCompleter.Completer" />
      <MemberSignature Language="F#" Value="member this.Completer : Java.Util.Concurrent.CountedCompleter" Usage="Java.Util.Concurrent.CountedCompleter.Completer" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyName>Mono.Android</AssemblyName>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName Language="C#">[System.Runtime.Versioning.SupportedOSPlatform("android24.0")]</AttributeName>
          <AttributeName Language="F#">[&lt;System.Runtime.Versioning.SupportedOSPlatform("android24.0")&gt;]</AttributeName>
        </Attribute>
        <Attribute>
          <AttributeName Language="C#">[get: Android.Runtime.Register("getCompleter", "()Ljava/util/concurrent/CountedCompleter;", "", ApiSince=24)]</AttributeName>
          <AttributeName Language="F#">[&lt;get: Android.Runtime.Register("getCompleter", "()Ljava/util/concurrent/CountedCompleter;", "", ApiSince=24)&gt;]</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>Java.Util.Concurrent.CountedCompleter</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>Returns the completer established in this task's constructor,
            or <c>null</c> if none.</summary>
        <value>the completer</value>
        <remarks>
          <para>Returns the completer established in this task's constructor,
            or <c>null</c> if none.</para>
          <para>
            <format type="text/html">
              <a href="https://developer.android.com/reference/java/util/concurrent/CountedCompleter#getCompleter()" title="Reference documentation">Java documentation for <code>java.util.concurrent.CountedCompleter.getCompleter()</code>.</a>
            </format>
          </para>
          <para>
                    Portions of this page are modifications based on work created and shared by the 
                    <format type="text/html"><a href="https://developers.google.com/terms/site-policies" title="Android Open Source Project">Android Open Source Project</a></format>
                     and used according to terms described in the 
                    <format type="text/html"><a href="https://creativecommons.org/licenses/by/2.5/" title="Creative Commons 2.5 Attribution License">Creative Commons 2.5 Attribution License.</a></format></para>
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="Compute">
      <MemberSignature Language="C#" Value="public abstract void Compute ();" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance void Compute() cil managed" />
      <MemberSignature Language="DocId" Value="M:Java.Util.Concurrent.CountedCompleter.Compute" />
      <MemberSignature Language="F#" Value="abstract member Compute : unit -&gt; unit" Usage="countedCompleter.Compute " />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Mono.Android</AssemblyName>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName Language="C#">[Android.Runtime.Register("compute", "()V", "GetComputeHandler", ApiSince=24)]</AttributeName>
          <AttributeName Language="F#">[&lt;Android.Runtime.Register("compute", "()V", "GetComputeHandler", ApiSince=24)&gt;]</AttributeName>
        </Attribute>
        <Attribute>
          <AttributeName Language="C#">[System.Runtime.Versioning.SupportedOSPlatform("android24.0")]</AttributeName>
          <AttributeName Language="F#">[&lt;System.Runtime.Versioning.SupportedOSPlatform("android24.0")&gt;]</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <summary>The main computation performed by this task.</summary>
        <remarks>
          <para>The main computation performed by this task.</para>
          <para>
            <format type="text/html">
              <a href="https://developer.android.com/reference/java/util/concurrent/CountedCompleter#compute()" title="Reference documentation">Java documentation for <code>java.util.concurrent.CountedCompleter.compute()</code>.</a>
            </format>
          </para>
          <para>
                    Portions of this page are modifications based on work created and shared by the 
                    <format type="text/html"><a href="https://developers.google.com/terms/site-policies" title="Android Open Source Project">Android Open Source Project</a></format>
                     and used according to terms described in the 
                    <format type="text/html"><a href="https://creativecommons.org/licenses/by/2.5/" title="Creative Commons 2.5 Attribution License">Creative Commons 2.5 Attribution License.</a></format></para>
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="DecrementPendingCountUnlessZero">
      <MemberSignature Language="C#" Value="public int DecrementPendingCountUnlessZero ();" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance int32 DecrementPendingCountUnlessZero() cil managed" />
      <MemberSignature Language="DocId" Value="M:Java.Util.Concurrent.CountedCompleter.DecrementPendingCountUnlessZero" />
      <MemberSignature Language="F#" Value="member this.DecrementPendingCountUnlessZero : unit -&gt; int" Usage="countedCompleter.DecrementPendingCountUnlessZero " />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Mono.Android</AssemblyName>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName Language="C#">[Android.Runtime.Register("decrementPendingCountUnlessZero", "()I", "", ApiSince=24)]</AttributeName>
          <AttributeName Language="F#">[&lt;Android.Runtime.Register("decrementPendingCountUnlessZero", "()I", "", ApiSince=24)&gt;]</AttributeName>
        </Attribute>
        <Attribute>
          <AttributeName Language="C#">[System.Runtime.Versioning.SupportedOSPlatform("android24.0")]</AttributeName>
          <AttributeName Language="F#">[&lt;System.Runtime.Versioning.SupportedOSPlatform("android24.0")&gt;]</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <summary>If the pending count is nonzero, (atomically) decrements it.</summary>
        <returns>the initial (undecremented) pending count holding on entry
            to this method</returns>
        <remarks>
          <para>If the pending count is nonzero, (atomically) decrements it.</para>
          <para>
            <format type="text/html">
              <a href="https://developer.android.com/reference/java/util/concurrent/CountedCompleter#decrementPendingCountUnlessZero()" title="Reference documentation">Java documentation for <code>java.util.concurrent.CountedCompleter.decrementPendingCountUnlessZero()</code>.</a>
            </format>
          </para>
          <para>
                    Portions of this page are modifications based on work created and shared by the 
                    <format type="text/html"><a href="https://developers.google.com/terms/site-policies" title="Android Open Source Project">Android Open Source Project</a></format>
                     and used according to terms described in the 
                    <format type="text/html"><a href="https://creativecommons.org/licenses/by/2.5/" title="Creative Commons 2.5 Attribution License">Creative Commons 2.5 Attribution License.</a></format></para>
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="Exec">
      <MemberSignature Language="C#" Value="protected override sealed bool Exec ();" />
      <MemberSignature Language="ILAsm" Value=".method familyhidebysig virtual instance bool Exec() cil managed" />
      <MemberSignature Language="DocId" Value="M:Java.Util.Concurrent.CountedCompleter.Exec" />
      <MemberSignature Language="F#" Value="override this.Exec : unit -&gt; bool" Usage="countedCompleter.Exec " />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Mono.Android</AssemblyName>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName Language="C#">[Android.Runtime.Register("exec", "()Z", "", ApiSince=24)]</AttributeName>
          <AttributeName Language="F#">[&lt;Android.Runtime.Register("exec", "()Z", "", ApiSince=24)&gt;]</AttributeName>
        </Attribute>
        <Attribute>
          <AttributeName Language="C#">[System.Runtime.Versioning.SupportedOSPlatform("android24.0")]</AttributeName>
          <AttributeName Language="F#">[&lt;System.Runtime.Versioning.SupportedOSPlatform("android24.0")&gt;]</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <summary>Implements execution conventions for CountedCompleters.</summary>
        <returns>To be added.</returns>
        <remarks>
          <para>Implements execution conventions for CountedCompleters.</para>
          <para>
            <format type="text/html">
              <a href="https://developer.android.com/reference/java/util/concurrent/CountedCompleter#exec()" title="Reference documentation">Java documentation for <code>java.util.concurrent.CountedCompleter.exec()</code>.</a>
            </format>
          </para>
          <para>
                    Portions of this page are modifications based on work created and shared by the 
                    <format type="text/html"><a href="https://developers.google.com/terms/site-policies" title="Android Open Source Project">Android Open Source Project</a></format>
                     and used according to terms described in the 
                    <format type="text/html"><a href="https://creativecommons.org/licenses/by/2.5/" title="Creative Commons 2.5 Attribution License">Creative Commons 2.5 Attribution License.</a></format></para>
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="FirstComplete">
      <MemberSignature Language="C#" Value="public Java.Util.Concurrent.CountedCompleter? FirstComplete ();" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance class Java.Util.Concurrent.CountedCompleter FirstComplete() cil managed" />
      <MemberSignature Language="DocId" Value="M:Java.Util.Concurrent.CountedCompleter.FirstComplete" />
      <MemberSignature Language="F#" Value="member this.FirstComplete : unit -&gt; Java.Util.Concurrent.CountedCompleter" Usage="countedCompleter.FirstComplete " />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Mono.Android</AssemblyName>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName Language="C#">[Android.Runtime.Register("firstComplete", "()Ljava/util/concurrent/CountedCompleter;", "", ApiSince=24)]</AttributeName>
          <AttributeName Language="F#">[&lt;Android.Runtime.Register("firstComplete", "()Ljava/util/concurrent/CountedCompleter;", "", ApiSince=24)&gt;]</AttributeName>
        </Attribute>
        <Attribute>
          <AttributeName Language="C#">[System.Runtime.Versioning.SupportedOSPlatform("android24.0")]</AttributeName>
          <AttributeName Language="F#">[&lt;System.Runtime.Versioning.SupportedOSPlatform("android24.0")&gt;]</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>Java.Util.Concurrent.CountedCompleter</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <summary>If this task's pending count is zero, returns this task;
            otherwise decrements its pending count and returns <c>null</c>.</summary>
        <returns>this task, if pending count was zero, else <c>null</c></returns>
        <remarks>
          <para>If this task's pending count is zero, returns this task;
            otherwise decrements its pending count and returns <c>null</c>.
            This method is designed to be used with <c>#nextComplete</c> in
            completion traversal loops.</para>
          <para>
            <format type="text/html">
              <a href="https://developer.android.com/reference/java/util/concurrent/CountedCompleter#firstComplete()" title="Reference documentation">Java documentation for <code>java.util.concurrent.CountedCompleter.firstComplete()</code>.</a>
            </format>
          </para>
          <para>
                    Portions of this page are modifications based on work created and shared by the 
                    <format type="text/html"><a href="https://developers.google.com/terms/site-policies" title="Android Open Source Project">Android Open Source Project</a></format>
                     and used according to terms described in the 
                    <format type="text/html"><a href="https://creativecommons.org/licenses/by/2.5/" title="Creative Commons 2.5 Attribution License">Creative Commons 2.5 Attribution License.</a></format></para>
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="HelpComplete">
      <MemberSignature Language="C#" Value="public void HelpComplete (int maxTasks);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance void HelpComplete(int32 maxTasks) cil managed" />
      <MemberSignature Language="DocId" Value="M:Java.Util.Concurrent.CountedCompleter.HelpComplete(System.Int32)" />
      <MemberSignature Language="F#" Value="member this.HelpComplete : int -&gt; unit" Usage="countedCompleter.HelpComplete maxTasks" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Mono.Android</AssemblyName>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName Language="C#">[Android.Runtime.Register("helpComplete", "(I)V", "", ApiSince=24)]</AttributeName>
          <AttributeName Language="F#">[&lt;Android.Runtime.Register("helpComplete", "(I)V", "", ApiSince=24)&gt;]</AttributeName>
        </Attribute>
        <Attribute>
          <AttributeName Language="C#">[System.Runtime.Versioning.SupportedOSPlatform("android24.0")]</AttributeName>
          <AttributeName Language="F#">[&lt;System.Runtime.Versioning.SupportedOSPlatform("android24.0")&gt;]</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="maxTasks" Type="System.Int32" />
      </Parameters>
      <Docs>
        <param name="maxTasks">the maximum number of tasks to process.  If
                            less than or equal to zero, then no tasks are
                            processed.</param>
        <summary>If this task has not completed, attempts to process at most the
            given number of other unprocessed tasks for which this task is
            on the completion path, if any are known to exist.</summary>
        <remarks>
          <para>If this task has not completed, attempts to process at most the
            given number of other unprocessed tasks for which this task is
            on the completion path, if any are known to exist.</para>
          <para>
            <format type="text/html">
              <a href="https://developer.android.com/reference/java/util/concurrent/CountedCompleter#helpComplete(int)" title="Reference documentation">Java documentation for <code>java.util.concurrent.CountedCompleter.helpComplete(int)</code>.</a>
            </format>
          </para>
          <para>
                    Portions of this page are modifications based on work created and shared by the 
                    <format type="text/html"><a href="https://developers.google.com/terms/site-policies" title="Android Open Source Project">Android Open Source Project</a></format>
                     and used according to terms described in the 
                    <format type="text/html"><a href="https://creativecommons.org/licenses/by/2.5/" title="Creative Commons 2.5 Attribution License">Creative Commons 2.5 Attribution License.</a></format></para>
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="JniPeerMembers">
      <MemberSignature Language="C#" Value="public override Java.Interop.JniPeerMembers JniPeerMembers { get; }" />
      <MemberSignature Language="ILAsm" Value=".property instance class Java.Interop.JniPeerMembers JniPeerMembers" />
      <MemberSignature Language="DocId" Value="P:Java.Util.Concurrent.CountedCompleter.JniPeerMembers" />
      <MemberSignature Language="F#" Value="member this.JniPeerMembers : Java.Interop.JniPeerMembers" Usage="Java.Util.Concurrent.CountedCompleter.JniPeerMembers" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyName>Mono.Android</AssemblyName>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName Language="C#">[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]</AttributeName>
          <AttributeName Language="F#">[&lt;System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)&gt;]</AttributeName>
        </Attribute>
        <Attribute>
          <AttributeName Language="C#">[System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]</AttributeName>
          <AttributeName Language="F#">[&lt;System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)&gt;]</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>Java.Interop.JniPeerMembers</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>To be added.</summary>
        <value>To be added.</value>
        <remarks>
          <para>Portions of this page are modifications based on work created and shared by the <format type="text/html"><a href="https://developers.google.com/terms/site-policies" title="Android Open Source Project">Android Open Source Project</a></format> and used according to terms described in the <format type="text/html"><a href="https://creativecommons.org/licenses/by/2.5/" title="Creative Commons 2.5 Attribution License">Creative Commons 2.5 Attribution License.</a></format></para>
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="NextComplete">
      <MemberSignature Language="C#" Value="public Java.Util.Concurrent.CountedCompleter? NextComplete ();" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance class Java.Util.Concurrent.CountedCompleter NextComplete() cil managed" />
      <MemberSignature Language="DocId" Value="M:Java.Util.Concurrent.CountedCompleter.NextComplete" />
      <MemberSignature Language="F#" Value="member this.NextComplete : unit -&gt; Java.Util.Concurrent.CountedCompleter" Usage="countedCompleter.NextComplete " />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Mono.Android</AssemblyName>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName Language="C#">[Android.Runtime.Register("nextComplete", "()Ljava/util/concurrent/CountedCompleter;", "", ApiSince=24)]</AttributeName>
          <AttributeName Language="F#">[&lt;Android.Runtime.Register("nextComplete", "()Ljava/util/concurrent/CountedCompleter;", "", ApiSince=24)&gt;]</AttributeName>
        </Attribute>
        <Attribute>
          <AttributeName Language="C#">[System.Runtime.Versioning.SupportedOSPlatform("android24.0")]</AttributeName>
          <AttributeName Language="F#">[&lt;System.Runtime.Versioning.SupportedOSPlatform("android24.0")&gt;]</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>Java.Util.Concurrent.CountedCompleter</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <summary>If this task does not have a completer, invokes <c>ForkJoinTask#quietlyComplete</c> and returns <c>null</c>.</summary>
        <returns>the completer, or <c>null</c> if none</returns>
        <remarks>
          <para>If this task does not have a completer, invokes <c>ForkJoinTask#quietlyComplete</c> and returns <c>null</c>.  Or, if
            the completer's pending count is non-zero, decrements that
            pending count and returns <c>null</c>.  Otherwise, returns the
            completer.  This method can be used as part of a completion
            traversal loop for homogeneous task hierarchies:</para>
          <code lang="text/java">{@code
            for (CountedCompleter&lt;?&gt; c = firstComplete();
                 c != null;
                 c = c.nextComplete()) {
              // ... process c ...
            }}</code>
          <para>
            <format type="text/html">
              <a href="https://developer.android.com/reference/java/util/concurrent/CountedCompleter#nextComplete()" title="Reference documentation">Java documentation for <code>java.util.concurrent.CountedCompleter.nextComplete()</code>.</a>
            </format>
          </para>
          <para>
                    Portions of this page are modifications based on work created and shared by the 
                    <format type="text/html"><a href="https://developers.google.com/terms/site-policies" title="Android Open Source Project">Android Open Source Project</a></format>
                     and used according to terms described in the 
                    <format type="text/html"><a href="https://creativecommons.org/licenses/by/2.5/" title="Creative Commons 2.5 Attribution License">Creative Commons 2.5 Attribution License.</a></format></para>
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="OnCompletion">
      <MemberSignature Language="C#" Value="public virtual void OnCompletion (Java.Util.Concurrent.CountedCompleter? caller);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance void OnCompletion(class Java.Util.Concurrent.CountedCompleter caller) cil managed" />
      <MemberSignature Language="DocId" Value="M:Java.Util.Concurrent.CountedCompleter.OnCompletion(Java.Util.Concurrent.CountedCompleter)" />
      <MemberSignature Language="F#" Value="abstract member OnCompletion : Java.Util.Concurrent.CountedCompleter -&gt; unit&#xA;override this.OnCompletion : Java.Util.Concurrent.CountedCompleter -&gt; unit" Usage="countedCompleter.OnCompletion caller" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Mono.Android</AssemblyName>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName Language="C#">[Android.Runtime.Register("onCompletion", "(Ljava/util/concurrent/CountedCompleter;)V", "GetOnCompletion_Ljava_util_concurrent_CountedCompleter_Handler", ApiSince=24)]</AttributeName>
          <AttributeName Language="F#">[&lt;Android.Runtime.Register("onCompletion", "(Ljava/util/concurrent/CountedCompleter;)V", "GetOnCompletion_Ljava_util_concurrent_CountedCompleter_Handler", ApiSince=24)&gt;]</AttributeName>
        </Attribute>
        <Attribute>
          <AttributeName Language="C#">[System.Runtime.Versioning.SupportedOSPlatform("android24.0")]</AttributeName>
          <AttributeName Language="F#">[&lt;System.Runtime.Versioning.SupportedOSPlatform("android24.0")&gt;]</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="caller" Type="Java.Util.Concurrent.CountedCompleter" />
      </Parameters>
      <Docs>
        <param name="caller">the task invoking this method (which may
            be this task itself)</param>
        <summary>Performs an action when method <c>#tryComplete</c> is invoked
            and the pending count is zero, or when the unconditional
            method <c>#complete</c> is invoked.</summary>
        <remarks>
          <para>Performs an action when method <c>#tryComplete</c> is invoked
            and the pending count is zero, or when the unconditional
            method <c>#complete</c> is invoked.  By default, this method
            does nothing. You can distinguish cases by checking the
            identity of the given caller argument. If not equal to <c>this</c>, then it is typically a subtask that may contain results
            (and/or links to other results) to combine.</para>
          <para>
            <format type="text/html">
              <a href="https://developer.android.com/reference/java/util/concurrent/CountedCompleter#onCompletion(java.util.concurrent.CountedCompleter%3C?%3E)" title="Reference documentation">Java documentation for <code>java.util.concurrent.CountedCompleter.onCompletion(java.util.concurrent.CountedCompleter&lt;?&gt;)</code>.</a>
            </format>
          </para>
          <para>
                    Portions of this page are modifications based on work created and shared by the 
                    <format type="text/html"><a href="https://developers.google.com/terms/site-policies" title="Android Open Source Project">Android Open Source Project</a></format>
                     and used according to terms described in the 
                    <format type="text/html"><a href="https://creativecommons.org/licenses/by/2.5/" title="Creative Commons 2.5 Attribution License">Creative Commons 2.5 Attribution License.</a></format></para>
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="OnExceptionalCompletion">
      <MemberSignature Language="C#" Value="public virtual bool OnExceptionalCompletion (Java.Lang.Throwable? ex, Java.Util.Concurrent.CountedCompleter? caller);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance bool OnExceptionalCompletion(class Java.Lang.Throwable ex, class Java.Util.Concurrent.CountedCompleter caller) cil managed" />
      <MemberSignature Language="DocId" Value="M:Java.Util.Concurrent.CountedCompleter.OnExceptionalCompletion(Java.Lang.Throwable,Java.Util.Concurrent.CountedCompleter)" />
      <MemberSignature Language="F#" Value="abstract member OnExceptionalCompletion : Java.Lang.Throwable * Java.Util.Concurrent.CountedCompleter -&gt; bool&#xA;override this.OnExceptionalCompletion : Java.Lang.Throwable * Java.Util.Concurrent.CountedCompleter -&gt; bool" Usage="countedCompleter.OnExceptionalCompletion (ex, caller)" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Mono.Android</AssemblyName>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName Language="C#">[Android.Runtime.Register("onExceptionalCompletion", "(Ljava/lang/Throwable;Ljava/util/concurrent/CountedCompleter;)Z", "GetOnExceptionalCompletion_Ljava_lang_Throwable_Ljava_util_concurrent_CountedCompleter_Handler", ApiSince=24)]</AttributeName>
          <AttributeName Language="F#">[&lt;Android.Runtime.Register("onExceptionalCompletion", "(Ljava/lang/Throwable;Ljava/util/concurrent/CountedCompleter;)Z", "GetOnExceptionalCompletion_Ljava_lang_Throwable_Ljava_util_concurrent_CountedCompleter_Handler", ApiSince=24)&gt;]</AttributeName>
        </Attribute>
        <Attribute>
          <AttributeName Language="C#">[System.Runtime.Versioning.SupportedOSPlatform("android24.0")]</AttributeName>
          <AttributeName Language="F#">[&lt;System.Runtime.Versioning.SupportedOSPlatform("android24.0")&gt;]</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="ex" Type="Java.Lang.Throwable" />
        <Parameter Name="caller" Type="Java.Util.Concurrent.CountedCompleter" />
      </Parameters>
      <Docs>
        <param name="ex">the exception</param>
        <param name="caller">the task invoking this method (which may
            be this task itself)</param>
        <summary>Performs an action when method <c>#completeExceptionally(Throwable)</c> is invoked or method <c>#compute</c> throws an exception, and this task has not already
            otherwise completed normally.</summary>
        <returns>
          <c>true</c> if this exception should be propagated to this
            task's completer, if one exists</returns>
        <remarks>
          <para>Performs an action when method <c>#completeExceptionally(Throwable)</c> is invoked or method <c>#compute</c> throws an exception, and this task has not already
            otherwise completed normally. On entry to this method, this task
            <c>ForkJoinTask#isCompletedAbnormally</c>.  The return value
            of this method controls further propagation: If <c>true</c>
            and this task has a completer that has not completed, then that
            completer is also completed exceptionally, with the same
            exception as this completer.  The default implementation of
            this method does nothing except return <c>true</c>.</para>
          <para>
            <format type="text/html">
              <a href="https://developer.android.com/reference/java/util/concurrent/CountedCompleter#onExceptionalCompletion(java.lang.Throwable,%20java.util.concurrent.CountedCompleter%3C?%3E)" title="Reference documentation">Java documentation for <code>java.util.concurrent.CountedCompleter.onExceptionalCompletion(java.lang.Throwable, java.util.concurrent.CountedCompleter&lt;?&gt;)</code>.</a>
            </format>
          </para>
          <para>
                    Portions of this page are modifications based on work created and shared by the 
                    <format type="text/html"><a href="https://developers.google.com/terms/site-policies" title="Android Open Source Project">Android Open Source Project</a></format>
                     and used according to terms described in the 
                    <format type="text/html"><a href="https://creativecommons.org/licenses/by/2.5/" title="Creative Commons 2.5 Attribution License">Creative Commons 2.5 Attribution License.</a></format></para>
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="PendingCount">
      <MemberSignature Language="C#" Value="public int PendingCount { get; set; }" />
      <MemberSignature Language="ILAsm" Value=".property instance int32 PendingCount" />
      <MemberSignature Language="DocId" Value="P:Java.Util.Concurrent.CountedCompleter.PendingCount" />
      <MemberSignature Language="F#" Value="member this.PendingCount : int with get, set" Usage="Java.Util.Concurrent.CountedCompleter.PendingCount" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyName>Mono.Android</AssemblyName>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName Language="C#">[System.Runtime.Versioning.SupportedOSPlatform("android24.0")]</AttributeName>
          <AttributeName Language="F#">[&lt;System.Runtime.Versioning.SupportedOSPlatform("android24.0")&gt;]</AttributeName>
        </Attribute>
        <Attribute>
          <AttributeName Language="C#">[get: Android.Runtime.Register("getPendingCount", "()I", "", ApiSince=24)]</AttributeName>
          <AttributeName Language="F#">[&lt;get: Android.Runtime.Register("getPendingCount", "()I", "", ApiSince=24)&gt;]</AttributeName>
        </Attribute>
        <Attribute>
          <AttributeName Language="C#">[set: Android.Runtime.Register("setPendingCount", "(I)V", "", ApiSince=24)]</AttributeName>
          <AttributeName Language="F#">[&lt;set: Android.Runtime.Register("setPendingCount", "(I)V", "", ApiSince=24)&gt;]</AttributeName>
        </Attribute>
        <Attribute>
          <AttributeName Language="C#">[set: System.Runtime.Versioning.SupportedOSPlatform("android24.0")]</AttributeName>
          <AttributeName Language="F#">[&lt;set: System.Runtime.Versioning.SupportedOSPlatform("android24.0")&gt;]</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Docs>
        <param name="count">the count</param>
        <summary>Returns the current pending count. -or- Sets the pending count to the given value.</summary>
        <value>the current pending count</value>
        <remarks>
          <para>Property getter documentation:</para>
          <para>Returns the current pending count.</para>
          <para>
            <format type="text/html">
              <a href="https://developer.android.com/reference/java/util/concurrent/CountedCompleter#getPendingCount()" title="Reference documentation">Java documentation for <code>java.util.concurrent.CountedCompleter.getPendingCount()</code>.</a>
            </format>
          </para>
          <para>Property setter documentation:</para>
          <para>Sets the pending count to the given value.</para>
          <para>
            <format type="text/html">
              <a href="https://developer.android.com/reference/java/util/concurrent/CountedCompleter#setPendingCount(int)" title="Reference documentation">Java documentation for <code>java.util.concurrent.CountedCompleter.setPendingCount(int)</code>.</a>
            </format>
          </para>
          <para>
                    Portions of this page are modifications based on work created and shared by the 
                    <format type="text/html"><a href="https://developers.google.com/terms/site-policies" title="Android Open Source Project">Android Open Source Project</a></format>
                     and used according to terms described in the 
                    <format type="text/html"><a href="https://creativecommons.org/licenses/by/2.5/" title="Creative Commons 2.5 Attribution License">Creative Commons 2.5 Attribution License.</a></format></para>
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="PropagateCompletion">
      <MemberSignature Language="C#" Value="public void PropagateCompletion ();" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance void PropagateCompletion() cil managed" />
      <MemberSignature Language="DocId" Value="M:Java.Util.Concurrent.CountedCompleter.PropagateCompletion" />
      <MemberSignature Language="F#" Value="member this.PropagateCompletion : unit -&gt; unit" Usage="countedCompleter.PropagateCompletion " />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Mono.Android</AssemblyName>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName Language="C#">[Android.Runtime.Register("propagateCompletion", "()V", "", ApiSince=24)]</AttributeName>
          <AttributeName Language="F#">[&lt;Android.Runtime.Register("propagateCompletion", "()V", "", ApiSince=24)&gt;]</AttributeName>
        </Attribute>
        <Attribute>
          <AttributeName Language="C#">[System.Runtime.Versioning.SupportedOSPlatform("android24.0")]</AttributeName>
          <AttributeName Language="F#">[&lt;System.Runtime.Versioning.SupportedOSPlatform("android24.0")&gt;]</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <summary>Equivalent to <c>#tryComplete</c> but does not invoke <c>#onCompletion(CountedCompleter)</c> along the completion path:
            If the pending count is nonzero, decrements the count;
            otherwise, similarly tries to complete this task's completer, if
            one exists, else marks this task as complete.</summary>
        <remarks>
          <para>Equivalent to <c>#tryComplete</c> but does not invoke <c>#onCompletion(CountedCompleter)</c> along the completion path:
            If the pending count is nonzero, decrements the count;
            otherwise, similarly tries to complete this task's completer, if
            one exists, else marks this task as complete. This method may be
            useful in cases where <c>onCompletion</c> should not, or need
            not, be invoked for each completer in a computation.</para>
          <para>
            <format type="text/html">
              <a href="https://developer.android.com/reference/java/util/concurrent/CountedCompleter#propagateCompletion()" title="Reference documentation">Java documentation for <code>java.util.concurrent.CountedCompleter.propagateCompletion()</code>.</a>
            </format>
          </para>
          <para>
                    Portions of this page are modifications based on work created and shared by the 
                    <format type="text/html"><a href="https://developers.google.com/terms/site-policies" title="Android Open Source Project">Android Open Source Project</a></format>
                     and used according to terms described in the 
                    <format type="text/html"><a href="https://creativecommons.org/licenses/by/2.5/" title="Creative Commons 2.5 Attribution License">Creative Commons 2.5 Attribution License.</a></format></para>
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="QuietlyCompleteRoot">
      <MemberSignature Language="C#" Value="public void QuietlyCompleteRoot ();" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance void QuietlyCompleteRoot() cil managed" />
      <MemberSignature Language="DocId" Value="M:Java.Util.Concurrent.CountedCompleter.QuietlyCompleteRoot" />
      <MemberSignature Language="F#" Value="member this.QuietlyCompleteRoot : unit -&gt; unit" Usage="countedCompleter.QuietlyCompleteRoot " />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Mono.Android</AssemblyName>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName Language="C#">[Android.Runtime.Register("quietlyCompleteRoot", "()V", "", ApiSince=24)]</AttributeName>
          <AttributeName Language="F#">[&lt;Android.Runtime.Register("quietlyCompleteRoot", "()V", "", ApiSince=24)&gt;]</AttributeName>
        </Attribute>
        <Attribute>
          <AttributeName Language="C#">[System.Runtime.Versioning.SupportedOSPlatform("android24.0")]</AttributeName>
          <AttributeName Language="F#">[&lt;System.Runtime.Versioning.SupportedOSPlatform("android24.0")&gt;]</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <summary>Equivalent to <c>getRoot().quietlyComplete()</c>.</summary>
        <remarks>
          <para>Equivalent to <c>getRoot().quietlyComplete()</c>.</para>
          <para>
            <format type="text/html">
              <a href="https://developer.android.com/reference/java/util/concurrent/CountedCompleter#quietlyCompleteRoot()" title="Reference documentation">Java documentation for <code>java.util.concurrent.CountedCompleter.quietlyCompleteRoot()</code>.</a>
            </format>
          </para>
          <para>
                    Portions of this page are modifications based on work created and shared by the 
                    <format type="text/html"><a href="https://developers.google.com/terms/site-policies" title="Android Open Source Project">Android Open Source Project</a></format>
                     and used according to terms described in the 
                    <format type="text/html"><a href="https://creativecommons.org/licenses/by/2.5/" title="Creative Commons 2.5 Attribution License">Creative Commons 2.5 Attribution License.</a></format></para>
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="RawResult">
      <MemberSignature Language="C#" Value="public virtual Java.Lang.Object? RawResult { get; }" />
      <MemberSignature Language="ILAsm" Value=".property instance class Java.Lang.Object RawResult" />
      <MemberSignature Language="DocId" Value="P:Java.Util.Concurrent.CountedCompleter.RawResult" />
      <MemberSignature Language="F#" Value="member this.RawResult : Java.Lang.Object" Usage="Java.Util.Concurrent.CountedCompleter.RawResult" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyName>Mono.Android</AssemblyName>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName Language="C#">[System.Runtime.Versioning.SupportedOSPlatform("android24.0")]</AttributeName>
          <AttributeName Language="F#">[&lt;System.Runtime.Versioning.SupportedOSPlatform("android24.0")&gt;]</AttributeName>
        </Attribute>
        <Attribute>
          <AttributeName Language="C#">[get: Android.Runtime.Register("getRawResult", "()Ljava/lang/Object;", "GetGetRawResultHandler", ApiSince=24)]</AttributeName>
          <AttributeName Language="F#">[&lt;get: Android.Runtime.Register("getRawResult", "()Ljava/lang/Object;", "GetGetRawResultHandler", ApiSince=24)&gt;]</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>Java.Lang.Object</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>Returns the result of the computation.</summary>
        <value>the result of the computation</value>
        <remarks>
          <para>Returns the result of the computation.  By default,
            returns <c>null</c>, which is appropriate for <c>Void</c>
            actions, but in other cases should be overridden, almost
            always to return a field or function of a field that
            holds the result upon completion.</para>
          <para>
            <format type="text/html">
              <a href="https://developer.android.com/reference/java/util/concurrent/CountedCompleter#getRawResult()" title="Reference documentation">Java documentation for <code>java.util.concurrent.CountedCompleter.getRawResult()</code>.</a>
            </format>
          </para>
          <para>
                    Portions of this page are modifications based on work created and shared by the 
                    <format type="text/html"><a href="https://developers.google.com/terms/site-policies" title="Android Open Source Project">Android Open Source Project</a></format>
                     and used according to terms described in the 
                    <format type="text/html"><a href="https://creativecommons.org/licenses/by/2.5/" title="Creative Commons 2.5 Attribution License">Creative Commons 2.5 Attribution License.</a></format></para>
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="Root">
      <MemberSignature Language="C#" Value="public Java.Util.Concurrent.CountedCompleter? Root { get; }" />
      <MemberSignature Language="ILAsm" Value=".property instance class Java.Util.Concurrent.CountedCompleter Root" />
      <MemberSignature Language="DocId" Value="P:Java.Util.Concurrent.CountedCompleter.Root" />
      <MemberSignature Language="F#" Value="member this.Root : Java.Util.Concurrent.CountedCompleter" Usage="Java.Util.Concurrent.CountedCompleter.Root" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyName>Mono.Android</AssemblyName>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName Language="C#">[System.Runtime.Versioning.SupportedOSPlatform("android24.0")]</AttributeName>
          <AttributeName Language="F#">[&lt;System.Runtime.Versioning.SupportedOSPlatform("android24.0")&gt;]</AttributeName>
        </Attribute>
        <Attribute>
          <AttributeName Language="C#">[get: Android.Runtime.Register("getRoot", "()Ljava/util/concurrent/CountedCompleter;", "", ApiSince=24)]</AttributeName>
          <AttributeName Language="F#">[&lt;get: Android.Runtime.Register("getRoot", "()Ljava/util/concurrent/CountedCompleter;", "", ApiSince=24)&gt;]</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>Java.Util.Concurrent.CountedCompleter</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>Returns the root of the current computation; i.</summary>
        <value>the root of the current computation</value>
        <remarks>
          <para>Returns the root of the current computation; i.e., this
            task if it has no completer, else its completer's root.</para>
          <para>
            <format type="text/html">
              <a href="https://developer.android.com/reference/java/util/concurrent/CountedCompleter#getRoot()" title="Reference documentation">Java documentation for <code>java.util.concurrent.CountedCompleter.getRoot()</code>.</a>
            </format>
          </para>
          <para>
                    Portions of this page are modifications based on work created and shared by the 
                    <format type="text/html"><a href="https://developers.google.com/terms/site-policies" title="Android Open Source Project">Android Open Source Project</a></format>
                     and used according to terms described in the 
                    <format type="text/html"><a href="https://creativecommons.org/licenses/by/2.5/" title="Creative Commons 2.5 Attribution License">Creative Commons 2.5 Attribution License.</a></format></para>
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="SetRawResult">
      <MemberSignature Language="C#" Value="protected override void SetRawResult (Java.Lang.Object? t);" />
      <MemberSignature Language="ILAsm" Value=".method familyhidebysig virtual instance void SetRawResult(class Java.Lang.Object t) cil managed" />
      <MemberSignature Language="DocId" Value="M:Java.Util.Concurrent.CountedCompleter.SetRawResult(Java.Lang.Object)" />
      <MemberSignature Language="F#" Value="override this.SetRawResult : Java.Lang.Object -&gt; unit" Usage="countedCompleter.SetRawResult t" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Mono.Android</AssemblyName>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName Language="C#">[Android.Runtime.Register("setRawResult", "(Ljava/lang/Object;)V", "GetSetRawResult_Ljava_lang_Object_Handler", ApiSince=24)]</AttributeName>
          <AttributeName Language="F#">[&lt;Android.Runtime.Register("setRawResult", "(Ljava/lang/Object;)V", "GetSetRawResult_Ljava_lang_Object_Handler", ApiSince=24)&gt;]</AttributeName>
        </Attribute>
        <Attribute>
          <AttributeName Language="C#">[System.Runtime.Versioning.SupportedOSPlatform("android24.0")]</AttributeName>
          <AttributeName Language="F#">[&lt;System.Runtime.Versioning.SupportedOSPlatform("android24.0")&gt;]</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="t" Type="Java.Lang.Object" />
      </Parameters>
      <Docs>
        <param name="t">To be added.</param>
        <summary>A method that result-bearing CountedCompleters may optionally
            use to help maintain result data.</summary>
        <remarks>
          <para>A method that result-bearing CountedCompleters may optionally
            use to help maintain result data.  By default, does nothing.
            Overrides are not recommended. However, if this method is
            overridden to update existing objects or fields, then it must
            in general be defined to be thread-safe.</para>
          <para>
            <format type="text/html">
              <a href="https://developer.android.com/reference/java/util/concurrent/CountedCompleter#setRawResult(T)" title="Reference documentation">Java documentation for <code>java.util.concurrent.CountedCompleter.setRawResult(T)</code>.</a>
            </format>
          </para>
          <para>
                    Portions of this page are modifications based on work created and shared by the 
                    <format type="text/html"><a href="https://developers.google.com/terms/site-policies" title="Android Open Source Project">Android Open Source Project</a></format>
                     and used according to terms described in the 
                    <format type="text/html"><a href="https://creativecommons.org/licenses/by/2.5/" title="Creative Commons 2.5 Attribution License">Creative Commons 2.5 Attribution License.</a></format></para>
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="ThresholdClass">
      <MemberSignature Language="C#" Value="protected override IntPtr ThresholdClass { get; }" />
      <MemberSignature Language="ILAsm" Value=".property instance native int ThresholdClass" />
      <MemberSignature Language="DocId" Value="P:Java.Util.Concurrent.CountedCompleter.ThresholdClass" />
      <MemberSignature Language="F#" Value="member this.ThresholdClass : nativeint" Usage="Java.Util.Concurrent.CountedCompleter.ThresholdClass" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyName>Mono.Android</AssemblyName>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName Language="C#">[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]</AttributeName>
          <AttributeName Language="F#">[&lt;System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)&gt;]</AttributeName>
        </Attribute>
        <Attribute>
          <AttributeName Language="C#">[System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]</AttributeName>
          <AttributeName Language="F#">[&lt;System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)&gt;]</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.IntPtr</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>To be added.</summary>
        <value>To be added.</value>
        <remarks>
          <para>Portions of this page are modifications based on work created and shared by the <format type="text/html"><a href="https://developers.google.com/terms/site-policies" title="Android Open Source Project">Android Open Source Project</a></format> and used according to terms described in the <format type="text/html"><a href="https://creativecommons.org/licenses/by/2.5/" title="Creative Commons 2.5 Attribution License">Creative Commons 2.5 Attribution License.</a></format></para>
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="ThresholdType">
      <MemberSignature Language="C#" Value="protected override Type ThresholdType { get; }" />
      <MemberSignature Language="ILAsm" Value=".property instance class System.Type ThresholdType" />
      <MemberSignature Language="DocId" Value="P:Java.Util.Concurrent.CountedCompleter.ThresholdType" />
      <MemberSignature Language="F#" Value="member this.ThresholdType : Type" Usage="Java.Util.Concurrent.CountedCompleter.ThresholdType" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyName>Mono.Android</AssemblyName>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName Language="C#">[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]</AttributeName>
          <AttributeName Language="F#">[&lt;System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)&gt;]</AttributeName>
        </Attribute>
        <Attribute>
          <AttributeName Language="C#">[System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]</AttributeName>
          <AttributeName Language="F#">[&lt;System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)&gt;]</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.Type</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>To be added.</summary>
        <value>To be added.</value>
        <remarks>
          <para>Portions of this page are modifications based on work created and shared by the <format type="text/html"><a href="https://developers.google.com/terms/site-policies" title="Android Open Source Project">Android Open Source Project</a></format> and used according to terms described in the <format type="text/html"><a href="https://creativecommons.org/licenses/by/2.5/" title="Creative Commons 2.5 Attribution License">Creative Commons 2.5 Attribution License.</a></format></para>
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="TryComplete">
      <MemberSignature Language="C#" Value="public void TryComplete ();" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance void TryComplete() cil managed" />
      <MemberSignature Language="DocId" Value="M:Java.Util.Concurrent.CountedCompleter.TryComplete" />
      <MemberSignature Language="F#" Value="member this.TryComplete : unit -&gt; unit" Usage="countedCompleter.TryComplete " />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyName>Mono.Android</AssemblyName>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName Language="C#">[Android.Runtime.Register("tryComplete", "()V", "", ApiSince=24)]</AttributeName>
          <AttributeName Language="F#">[&lt;Android.Runtime.Register("tryComplete", "()V", "", ApiSince=24)&gt;]</AttributeName>
        </Attribute>
        <Attribute>
          <AttributeName Language="C#">[System.Runtime.Versioning.SupportedOSPlatform("android24.0")]</AttributeName>
          <AttributeName Language="F#">[&lt;System.Runtime.Versioning.SupportedOSPlatform("android24.0")&gt;]</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <summary>If the pending count is nonzero, decrements the count;
            otherwise invokes <c>#onCompletion(CountedCompleter)</c>
            and then similarly tries to complete this task's completer,
            if one exists, else marks this task as complete.</summary>
        <remarks>
          <para>If the pending count is nonzero, decrements the count;
            otherwise invokes <c>#onCompletion(CountedCompleter)</c>
            and then similarly tries to complete this task's completer,
            if one exists, else marks this task as complete.</para>
          <para>
            <format type="text/html">
              <a href="https://developer.android.com/reference/java/util/concurrent/CountedCompleter#tryComplete()" title="Reference documentation">Java documentation for <code>java.util.concurrent.CountedCompleter.tryComplete()</code>.</a>
            </format>
          </para>
          <para>
                    Portions of this page are modifications based on work created and shared by the 
                    <format type="text/html"><a href="https://developers.google.com/terms/site-policies" title="Android Open Source Project">Android Open Source Project</a></format>
                     and used according to terms described in the 
                    <format type="text/html"><a href="https://creativecommons.org/licenses/by/2.5/" title="Creative Commons 2.5 Attribution License">Creative Commons 2.5 Attribution License.</a></format></para>
        </remarks>
      </Docs>
    </Member>
  </Members>
</Type>