regenerate docs

Author: kevmoo

testing/test_package_docs/ex/Animal-class.html

@@ -210,7 +210,7 @@ <h2>Properties</h2>
           <span class="signature">&#8594; int</span>
         </dt>
         <dd class="inherited">
-          <p>Get a hash code for this object.</p>
+          <p>The hash code for this object.</p>
           <div class="features">read-only, inherited</div>
 </dd>
         <dt id="runtimeType" class="property inherited">

testing/test_package_docs/ex/Apple-class.html

@@ -246,7 +246,7 @@ <h2>Properties</h2>
           <span class="signature">&#8594; int</span>
         </dt>
         <dd class="inherited">
-          <p>Get a hash code for this object.</p>
+          <p>The hash code for this object.</p>
           <div class="features">read-only, inherited</div>
 </dd>
         <dt id="runtimeType" class="property inherited">

testing/test_package_docs/ex/Apple/hashCode.html

@@ -120,14 +120,28 @@ <h5><a href="ex/Apple-class.html">Apple</a></h5>
         <span class="name ">hashCode</span></section>
 
       <section class="desc markdown">
-  <p>Get a hash code for this object.</p>
-<p>All objects have hash codes. Hash codes are guaranteed to be the
-same for objects that are equal when compared using the equality
-operator <code>==</code>. Other than that there are no guarantees about
-the hash codes. They will not be consistent between runs and
-there are no distribution guarantees.</p>
-<p>If a subclass overrides <code>hashCode</code> it should override the
-equality operator as well to maintain consistency.</p>
+  <p>The hash code for this object.</p>
+<p>A hash code is a single integer which represents the state of the object
+that affects <code>==</code> comparisons.</p>
+<p>All objects have hash codes. 
+The default hash code represents only the identity of the object, 
+the same way as the default <code>==</code> implementation only considers objects
+equal if they are identical (see <code>identityHashCode</code>).</p>
+<p>If <code>==</code> is overridden to use the object state instead, 
+the hash code must also be changed to represent that state. </p>
+<p>Hash codes must be the same for objects that are equal to each other
+according to <code>==</code>.
+The hash code of an object should only change if the object changes
+in a way that affects equality.
+There are no further requirements for the hash codes.
+They need not be consistent between executions of the same program
+and there are no distribution guarantees.</p>
+<p>Objects that are not equal are allowed to have the same hash code,
+it is even technically allowed that all instances have the same hash code,
+but if clashes happen too often, it may reduce the efficiency of hash-based
+data structures like <code>HashSet</code> or <code>HashMap</code>.</p>
+<p>If a subclass overrides <code>hashCode</code>, it should override the
+<code>==</code> operator as well to maintain consistency.</p>
 </section>
 </section>
 

testing/test_package_docs/ex/Apple/operator_equals.html

@@ -129,9 +129,9 @@ <h5><a href="ex/Apple-class.html">Apple</a></h5>
 either both be true, or both be false.</p></li><li>
 <p>Transitive: For all objects <code>o1</code>, <code>o2</code>, and <code>o3</code>, if <code>o1 == o2</code> and
 <code>o2 == o3</code> are true, then <code>o1 == o3</code> must be true.</p></li></ul>
-<p>The method should also be consistent over time, so equality of two objects
-should not change over time, or at least only change if one of the objects
-was modified.</p>
+<p>The method should also be consistent over time, 
+so whether two objects are equal should only change
+if at least one of the objects was modified.</p>
 <p>If a subclass overrides the equality operator it should override
 the <code>hashCode</code> method as well to maintain consistency.</p>
     </section>

testing/test_package_docs/ex/B-class.html

@@ -229,7 +229,7 @@ <h2>Properties</h2>
           <span class="signature">&#8594; int</span>
         </dt>
         <dd class="inherited">
-          <p>Get a hash code for this object.</p>
+          <p>The hash code for this object.</p>
           <div class="features">read-only, inherited</div>
 </dd>
         <dt id="m" class="property inherited">

testing/test_package_docs/ex/B/hashCode.html

@@ -122,14 +122,28 @@ <h5><a href="ex/B-class.html">B</a></h5>
         <span class="name ">hashCode</span></section>
 
       <section class="desc markdown">
-  <p>Get a hash code for this object.</p>
-<p>All objects have hash codes. Hash codes are guaranteed to be the
-same for objects that are equal when compared using the equality
-operator <code>==</code>. Other than that there are no guarantees about
-the hash codes. They will not be consistent between runs and
-there are no distribution guarantees.</p>
-<p>If a subclass overrides <code>hashCode</code> it should override the
-equality operator as well to maintain consistency.</p>
+  <p>The hash code for this object.</p>
+<p>A hash code is a single integer which represents the state of the object
+that affects <code>==</code> comparisons.</p>
+<p>All objects have hash codes. 
+The default hash code represents only the identity of the object, 
+the same way as the default <code>==</code> implementation only considers objects
+equal if they are identical (see <code>identityHashCode</code>).</p>
+<p>If <code>==</code> is overridden to use the object state instead, 
+the hash code must also be changed to represent that state. </p>
+<p>Hash codes must be the same for objects that are equal to each other
+according to <code>==</code>.
+The hash code of an object should only change if the object changes
+in a way that affects equality.
+There are no further requirements for the hash codes.
+They need not be consistent between executions of the same program
+and there are no distribution guarantees.</p>
+<p>Objects that are not equal are allowed to have the same hash code,
+it is even technically allowed that all instances have the same hash code,
+but if clashes happen too often, it may reduce the efficiency of hash-based
+data structures like <code>HashSet</code> or <code>HashMap</code>.</p>
+<p>If a subclass overrides <code>hashCode</code>, it should override the
+<code>==</code> operator as well to maintain consistency.</p>
 </section>
 </section>
 

testing/test_package_docs/ex/B/operator_equals.html

@@ -131,9 +131,9 @@ <h5><a href="ex/B-class.html">B</a></h5>
 either both be true, or both be false.</p></li><li>
 <p>Transitive: For all objects <code>o1</code>, <code>o2</code>, and <code>o3</code>, if <code>o1 == o2</code> and
 <code>o2 == o3</code> are true, then <code>o1 == o3</code> must be true.</p></li></ul>
-<p>The method should also be consistent over time, so equality of two objects
-should not change over time, or at least only change if one of the objects
-was modified.</p>
+<p>The method should also be consistent over time, 
+so whether two objects are equal should only change
+if at least one of the objects was modified.</p>
 <p>If a subclass overrides the equality operator it should override
 the <code>hashCode</code> method as well to maintain consistency.</p>
     </section>

testing/test_package_docs/ex/Cat-class.html

@@ -187,7 +187,7 @@ <h2>Properties</h2>
           <span class="signature">&#8594; int</span>
         </dt>
         <dd class="inherited">
-          <p>Get a hash code for this object.</p>
+          <p>The hash code for this object.</p>
           <div class="features">read-only, inherited</div>
 </dd>
         <dt id="runtimeType" class="property inherited">

testing/test_package_docs/ex/Cat/hashCode.html

@@ -107,14 +107,28 @@ <h5><a href="ex/Cat-class.html">Cat</a></h5>
         <span class="name ">hashCode</span></section>
 
       <section class="desc markdown">
-  <p>Get a hash code for this object.</p>
-<p>All objects have hash codes. Hash codes are guaranteed to be the
-same for objects that are equal when compared using the equality
-operator <code>==</code>. Other than that there are no guarantees about
-the hash codes. They will not be consistent between runs and
-there are no distribution guarantees.</p>
-<p>If a subclass overrides <code>hashCode</code> it should override the
-equality operator as well to maintain consistency.</p>
+  <p>The hash code for this object.</p>
+<p>A hash code is a single integer which represents the state of the object
+that affects <code>==</code> comparisons.</p>
+<p>All objects have hash codes. 
+The default hash code represents only the identity of the object, 
+the same way as the default <code>==</code> implementation only considers objects
+equal if they are identical (see <code>identityHashCode</code>).</p>
+<p>If <code>==</code> is overridden to use the object state instead, 
+the hash code must also be changed to represent that state. </p>
+<p>Hash codes must be the same for objects that are equal to each other
+according to <code>==</code>.
+The hash code of an object should only change if the object changes
+in a way that affects equality.
+There are no further requirements for the hash codes.
+They need not be consistent between executions of the same program
+and there are no distribution guarantees.</p>
+<p>Objects that are not equal are allowed to have the same hash code,
+it is even technically allowed that all instances have the same hash code,
+but if clashes happen too often, it may reduce the efficiency of hash-based
+data structures like <code>HashSet</code> or <code>HashMap</code>.</p>
+<p>If a subclass overrides <code>hashCode</code>, it should override the
+<code>==</code> operator as well to maintain consistency.</p>
 </section>
 </section>
 

testing/test_package_docs/ex/Cat/operator_equals.html

@@ -116,9 +116,9 @@ <h5><a href="ex/Cat-class.html">Cat</a></h5>
 either both be true, or both be false.</p></li><li>
 <p>Transitive: For all objects <code>o1</code>, <code>o2</code>, and <code>o3</code>, if <code>o1 == o2</code> and
 <code>o2 == o3</code> are true, then <code>o1 == o3</code> must be true.</p></li></ul>
-<p>The method should also be consistent over time, so equality of two objects
-should not change over time, or at least only change if one of the objects
-was modified.</p>
+<p>The method should also be consistent over time, 
+so whether two objects are equal should only change
+if at least one of the objects was modified.</p>
 <p>If a subclass overrides the equality operator it should override
 the <code>hashCode</code> method as well to maintain consistency.</p>
     </section>