func loadIntStringArrayMap()

in serialize.go [91:161]
55 lines of code
12 McCabe index (conditional complexity)

func loadIntStringArrayMap(data string) (*intStringArrayMap, 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)
	key := 0
	for i := 0; i < int(mappingCount); i++ {
		// first read our diff
		diff, err := binary.ReadUvarint(reader)
		if err != nil {
			return nil, err
		}

		key += int(diff)

		// then our values
		var valueCount uint8
		if err = binary.Read(reader, binary.LittleEndian, &valueCount); err != nil {
			return nil, err
		}

		keyValues := make([]string, valueCount)
		for i := 0; i < int(valueCount); i++ {
			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)
			}
			keyValues[i] = values[valueIntern]
		}
		mappings[key] = keyValues

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

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