Refactor for readability, consistency

Author: hannahhoward

hamt/hamt.go

@@ -28,11 +28,12 @@ import (
 
 	dag "github.com/ipfs/go-merkledag"
 
-	format "github.com/ipfs/go-unixfs"
 	bitfield "github.com/Stebalien/go-bitfield"
 	cid "github.com/ipfs/go-cid"
 	ipld "github.com/ipfs/go-ipld-format"
 	"github.com/spaolacci/murmur3"
+
+	format "github.com/ipfs/go-unixfs"
 )
 
 const (
@@ -106,7 +107,6 @@ func NewHamtFromDag(dserv ipld.DAGService, nd ipld.Node) (*Shard, error) {
 		return nil, err
 	}
 
-
 	if fsn.Type() != format.THAMTShard {
 		return nil, fmt.Errorf("node was not a dir shard")
 	}
@@ -204,6 +204,14 @@ func (sv *shardValue) Label() string {
 	return sv.key
 }
 
+func (ds *Shard) makeShardValue(lnk *ipld.Link) *shardValue {
+	lnk2 := *lnk
+	return &shardValue{
+		key: lnk.Name[ds.maxpadlen:],
+		val: &lnk2,
+	}
+}
+
 func hash(val []byte) []byte {
 	h := murmur3.New64()
 	h.Write(val)
@@ -255,6 +263,24 @@ func (ds *Shard) Find(ctx context.Context, name string) (*ipld.Link, error) {
 	return out, nil
 }
 
+type linkType int
+
+const (
+	invalidLink linkType = iota
+	shardLink
+	shardValueLink
+)
+
+func (ds *Shard) childLinkType(lnk *ipld.Link) (linkType, error) {
+	if len(lnk.Name) < ds.maxpadlen {
+		return invalidLink, fmt.Errorf("invalid link name '%s'", lnk.Name)
+	}
+	if len(lnk.Name) == ds.maxpadlen {
+		return shardLink, nil
+	}
+	return shardValueLink, nil
+}
+
 // getChild returns the i'th child of this shard. If it is cached in the
 // children array, it will return it from there. Otherwise, it loads the child
 // node from disk.
@@ -279,12 +305,13 @@ func (ds *Shard) getChild(ctx context.Context, i int) (child, error) {
 // as a 'child' interface
 func (ds *Shard) loadChild(ctx context.Context, i int) (child, error) {
 	lnk := ds.nd.Links()[i]
-	if len(lnk.Name) < ds.maxpadlen {
-		return nil, fmt.Errorf("invalid link name '%s'", lnk.Name)
+	lnkLinkType, err := ds.childLinkType(lnk)
+	if err != nil {
+		return nil, err
 	}
 
 	var c child
-	if len(lnk.Name) == ds.maxpadlen {
+	if lnkLinkType == shardLink {
 		nd, err := lnk.GetNode(ctx, ds.dserv)
 		if err != nil {
 			return nil, err
@@ -296,11 +323,7 @@ func (ds *Shard) loadChild(ctx context.Context, i int) (child, error) {
 
 		c = cds
 	} else {
-		lnk2 := *lnk
-		c = &shardValue{
-			key: lnk.Name[ds.maxpadlen:],
-			val: &lnk2,
-		}
+		c = ds.makeShardValue(lnk)
 	}
 
 	ds.children[i] = c
@@ -387,9 +410,11 @@ func (ds *Shard) EnumLinks(ctx context.Context) ([]*ipld.Link, error) {
 	var links []*ipld.Link
 	var setlk sync.Mutex
 
-	getLinks := ds.makeAsyncTrieGetLinks(func(l *ipld.Link) error {
+	getLinks := makeAsyncTrieGetLinks(ds.dserv, func(sv *shardValue) error {
+		lnk := sv.val
+		lnk.Name = sv.key
 		setlk.Lock()
-		links = append(links, l)
+		links = append(links, lnk)
 		setlk.Unlock()
 		return nil
 	})
@@ -410,29 +435,34 @@ func (ds *Shard) ForEachLink(ctx context.Context, f func(*ipld.Link) error) erro
 	})
 }
 
-func (ds *Shard) makeAsyncTrieGetLinks(cb func(*ipld.Link) error) dag.GetLinks {
+// makeAsyncTrieGetLinks builds a getLinks function that can be used with EnumerateChildrenAsync
+// to iterate a HAMT shard. It takes an IPLD Dag Service to fetch nodes, and a call back that will get called
+// on all links to leaf nodes in a HAMT tree, so they can be collected for an EnumLinks operation
+func makeAsyncTrieGetLinks(dagService ipld.DAGService, onShardValue func(*shardValue) error) dag.GetLinks {
 
-	return func(ctx context.Context, c cid.Cid) ([]*ipld.Link, error) {
-		node, err := ds.dserv.Get(ctx, c)
+	return func(ctx context.Context, currentCid cid.Cid) ([]*ipld.Link, error) {
+		node, err := dagService.Get(ctx, currentCid)
 		if err != nil {
 			return nil, err
 		}
-		cds, err := NewHamtFromDag(ds.dserv, node)
+		directoryShard, err := NewHamtFromDag(dagService, node)
 		if err != nil {
 			return nil, err
 		}
 
-		childShards := make([]*ipld.Link, 0, len(cds.children))
-		for idx := range cds.children {
-			lnk := cds.nd.Links()[idx]
+		childShards := make([]*ipld.Link, 0, len(directoryShard.children))
+		for idx := range directoryShard.children {
+			lnk := directoryShard.nd.Links()[idx]
+			lnkLinkType, err := directoryShard.childLinkType(lnk)
 
-			if len(lnk.Name) < cds.maxpadlen {
-				return nil, fmt.Errorf("invalid link name '%s'", lnk.Name)
+			if err != nil {
+				return nil, err
 			}
-			if len(lnk.Name) == cds.maxpadlen {
+			if lnkLinkType == shardLink {
 				childShards = append(childShards, lnk)
 			} else {
-				cb(lnk)
+				sv := directoryShard.makeShardValue(lnk)
+				onShardValue(sv)
 			}
 		}
 		return childShards, nil