LogDog: Implement RegisterPrefix RPC.

common/logdog/types/streamname.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 types
 
 import (
         "encoding/json"
         "errors"
         "fmt"
@@ skipping 146 matching lines @@
 // together.
 func (s StreamName) Concat(o ...StreamName) StreamName {
         parts := make([]string, len(o)+1)
         parts[0] = string(s)
         for i, c := range o {
                 parts[i+1] = string(c)
         }
         return StreamName(Construct(parts...))
 }
 
+// AsPathPrefix uses s as the prefix component of a StreamPath and constructs
+// the remainder of the path with the supplied name.
+//
+// If name is empty, the resulting path will end in the path separator. For
+// example, if s is "foo/bar" and name is "", the path will be "foo/bar/+".
+//
+// If both s and name are valid StreamNames, this will construct a valid
+// StreamPath. If s is a valid StreamName and name is empty, this will construct
+// a valid partial StreamPath.
+func (s StreamName) AsPathPrefix(name StreamName) StreamPath {
+        return StreamPath(Construct(string(s), StreamPathSepStr, string(name)))
+}
+
 // Validate tests whether the stream name is valid.
 func (s StreamName) Validate() error {
         if len(s) == 0 {
                 return errors.New("must contain at least one character")
         }
         if len(s) > MaxStreamNameLength {
                 return fmt.Errorf("stream name is too long (%d > %d)", len(s), MaxStreamNameLength)
         }
 
         var lastRune rune
@@ skipping 54 matching lines @@
 // MarshalJSON implements json.Marshaler.
 func (s StreamName) MarshalJSON() ([]byte, error) {
         v := string(s)
         return json.Marshal(&v)
 }
 
 // A StreamPath consists of two StreamName, joined via a StreamPathSep (+)
 // separator.
 type StreamPath string
 
-// MakeStreamPath creates a StreamPath by joining prefix and name components.
-func MakeStreamPath(prefix, name []StreamName) StreamPath {
-        o := len(prefix)
-        sp := make([]string, o+len(name)+1)
-        for i, v := range prefix {
-                sp[i] = string(v)
-        }
-        sp[o] = StreamPathSepStr
-        for _, v := range name {
-                o++
-                sp[o] = string(v)
-        }
-        return StreamPath(Construct(sp...))
-}
-
 // Split splits a StreamPath into its prefix and name components.
 //
 // If there is no divider present (e.g., foo/bar/baz), the result will parse
 // as the stream prefix with an empty name component.
 func (p StreamPath) Split() (prefix StreamName, name StreamName) {
         prefix, _, name = p.SplitParts()
         return
 }
 
 // SplitParts splits a StreamPath into its prefix and name components.
@@ skipping 168 matching lines @@
 
         return s
 }
 
 func segmentCount(s string) int {
         if len(s) == 0 {
                 return 0
         }
         return strings.Count(s, string(StreamNameSep)) + 1
 }