func loadPrefixMap()

in serialize.go [20:82]
47 lines of code
10 McCabe index (conditional complexity)

func loadPrefixMap(data string) (*intStringMap, error) {
	rawBytes, err := decodeUnzipString(data)
	if err != nil {
		return nil, err
	}
	reader := bytes.NewReader(rawBytes)

	// ok, first read in our number of values
	var valueSize uint32
	err = binary.Read(reader, binary.LittleEndian, &valueSize)
	if err != nil {
		return nil, err
	}

	// then our values
	valueBytes := make([]byte, valueSize)
	n, err := reader.Read(valueBytes)
	if uint32(n) < valueSize {
		return nil, fmt.Errorf("unable to read all values: %v", err)
	}

	values := strings.Split(string(valueBytes), "\n")

	// read our # of mappings
	var mappingCount uint32
	err = binary.Read(reader, binary.LittleEndian, &mappingCount)
	if err != nil {
		return nil, err
	}

	maxLength := 0
	mappings := make(map[int]string, mappingCount)
	prefix := 0
	for i := 0; i < int(mappingCount); i++ {
		// first read our diff
		diff, err := binary.ReadUvarint(reader)
		if err != nil {
			return nil, err
		}

		prefix += int(diff)

		// then our map
		var valueIntern uint16
		err = binary.Read(reader, binary.LittleEndian, &valueIntern)
		if err != nil || int(valueIntern) >= len(values) {
			return nil, fmt.Errorf("unable to read interned value: %v", err)
		}

		mappings[prefix] = values[valueIntern]

		strPrefix := fmt.Sprintf("%d", prefix)
		if len(strPrefix) > maxLength {
			maxLength = len(strPrefix)
		}
	}

	// return our values
	return &intStringMap{
		Map:       mappings,
		MaxLength: maxLength,
	}, nil
}