go/godoc/redirect/hash.go

// Copyright 2014 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// This file provides a compact encoding of
// a map of Mercurial hashes to Git hashes.

package redirect

import (
	"encoding/binary"
	"fmt"
	"io"
	"os"
	"sort"
	"strconv"
	"strings"
)

// hashMap is a map of Mercurial hashes to Git hashes.
type hashMap struct {
	file    *os.File
	entries int
}

// newHashMap takes a file handle that contains a map of Mercurial to Git
// hashes. The file should be a sequence of pairs of little-endian encoded
// uint32s, representing a hgHash and a gitHash respectively.
// The sequence must be sorted by hgHash.
// The file must remain open for as long as the returned hashMap is used.
func newHashMap(f *os.File) (*hashMap, error) {
	fi, err := f.Stat()
	if err != nil {
		return nil, err
	}
	return &hashMap{file: f, entries: int(fi.Size() / 8)}, nil
}

// Lookup finds an hgHash in the map that matches the given prefix, and returns
// its corresponding gitHash. The prefix must be at least 8 characters long.
func (m *hashMap) Lookup(s string) gitHash {
	if m == nil {
		return 0
	}
	hg, err := hgHashFromString(s)
	if err != nil {
		return 0
	}
	var git gitHash
	b := make([]byte, 8)
	sort.Search(m.entries, func(i int) bool {
		n, err := m.file.ReadAt(b, int64(i*8))
		if err != nil {
			panic(err)
		}
		if n != 8 {
			panic(io.ErrUnexpectedEOF)
		}
		v := hgHash(binary.LittleEndian.Uint32(b[:4]))
		if v == hg {
			git = gitHash(binary.LittleEndian.Uint32(b[4:]))
		}
		return v >= hg
	})
	return git
}

// hgHash represents the lower (leftmost) 32 bits of a Mercurial hash.
type hgHash uint32

func (h hgHash) String() string {
	return intToHash(int64(h))
}

func hgHashFromString(s string) (hgHash, error) {
	if len(s) < 8 {
		return 0, fmt.Errorf("string too small: len(s) = %d", len(s))
	}
	hash := s[:8]
	i, err := strconv.ParseInt(hash, 16, 64)
	if err != nil {
		return 0, err
	}
	return hgHash(i), nil
}

// gitHash represents the leftmost 28 bits of a Git hash in its upper 28 bits,
// and it encodes hash's repository in the lower 4  bits.
type gitHash uint32

func (h gitHash) Hash() string {
	return intToHash(int64(h))[:7]
}

func (h gitHash) Repo() string {
	return repo(h & 0xF).String()
}

func intToHash(i int64) string {
	s := strconv.FormatInt(i, 16)
	if len(s) < 8 {
		s = strings.Repeat("0", 8-len(s)) + s
	}
	return s
}

// repo represents a Go Git repository.
type repo byte

const (
	repoGo repo = iota
	repoBlog
	repoCrypto
	repoExp
	repoImage
	repoMobile
	repoNet
	repoSys
	repoTalks
	repoText
	repoTools
)

func (r repo) String() string {
	return map[repo]string{
		repoGo:     "go",
		repoBlog:   "blog",
		repoCrypto: "crypto",
		repoExp:    "exp",
		repoImage:  "image",
		repoMobile: "mobile",
		repoNet:    "net",
		repoSys:    "sys",
		repoTalks:  "talks",
		repoText:   "text",
		repoTools:  "tools",
	}[r]
}