Refactor serialization helpers from impl/memory -> service/datastore/serialize

impl/memory/datastore_query.go

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package memory
 
 import (
         "bytes"
         "encoding/base64"
         "errors"
@@ skipping 150 matching lines @@
                 // index column for it. If that's the case, then we must invert, swap and
                 // increment the inequality endpoints.
                 //
                 // Invert so that the desired numbers are represented correctly in the index.
                 // Swap so that our iterators still go from >= start to < end.
                 // Increment so that >= and < get correctly bounded (since the iterator is
                 // still using natrual bytes ordering)
                 if ret.suffixFormat[0].Descending {
                         hi, lo := []byte(nil), []byte(nil)
                         if len(startD) > 0 {
-                                lo = increment(invert(startD))
+                                lo = increment(serialize.Invert(startD))
                         }
                         if len(endD) > 0 {
-                                hi = increment(invert(endD))
+                                hi = increment(serialize.Invert(endD))
                         }
                         endD, startD = lo, hi
                 }
         }
 
         // Now we check the start and end cursors.
         //
         // Cursors are composed of a list of IndexColumns at the beginning, followed
         // by the raw bytes to use for the suffix. The cursor is only valid if all of
         // its IndexColumns match our proposed suffixFormat, as calculated above.
@@ skipping 53 matching lines @@
         ret.numCols = len(ret.suffixFormat)
         for prop, vals := range ret.eqFilters {
                 if len(ret.suffixFormat) == 1 && prop == "__ancestor__" {
                         continue
                 }
                 ret.numCols += vals.Len()
         }
 
         return ret, nil
 }
+
+func increment(bstr []byte) []byte {
+        ret, overflow := serialize.Increment(bstr)
+        if overflow {
+                // This byte string was ALL 0xFF's. The only safe incrementation to do here
+                // would be to add a new byte to the beginning of bstr with the value 0x01,
+                // and a byte to the beginning OF ALL OTHER []byte's which bstr may be
+                // compared with. This is obviously impossible to do here, so panic. If we
+                // hit this, then we would need to add a spare 0 byte before every index
+                // column.
+                //
+                // Another way to think about this is that we just accumulated a 'carry' bit,
+                // and the new value has overflowed this representation.
+                //
+                // Fortunately, the first byte of a serialized index column entry is a
+                // PropertyType byte, and the only valid values that we'll be incrementing
+                // are never equal to 0xFF, since they have the high bit set (so either they're
+                // 0x8*, or 0x7*, depending on if it's inverted).
+                impossible(fmt.Errorf("incrementing %v would require more sigfigs", bstr))
+        }
+        return ret
+}