Method LoadParityData

par2/decoder.go:496–559

LoadParityData searches for parity volumes and loads them into memory.

()

// LoadParityData searches for parity volumes and loads them into
// memory.
func (d *Decoder) LoadParityData() error {
	ext := path.Ext(d.indexPath)
	base := d.indexPath[:len(d.indexPath)-len(ext)]
	matches, err := d.fileIO.FindWithPrefixAndSuffix(base+".", ext)
	if err != nil {
		return err
	}

	var parityFiles []file
	for i, match := range matches {
		parityFile, err := func() (*file, error) {
			volumeBytes, err := d.fileIO.ReadFile(match)
			if err != nil {
				return nil, err
			}

			// Ignore all the other packet types other
			// than recovery packets.
			_, parityFile, err := readFile(recoveryDelegate{d.delegate}, &d.setID, volumeBytes)
			if _, ok := err.(noPacketsFoundError); ok {
				return nil, nil
			} else if err != nil {
				// TODO: Relax this check.
				return nil, err
			}

			if d.sliceByteCount != parityFile.mainPacket.sliceByteCount {
				return nil, errors.New("slice byte count mismatch")
			}

			if !reflect.DeepEqual(decoderInputFileInfoIDs(d.recoverySet), parityFile.mainPacket.recoverySet) {
				return nil, errors.New("recovery set mismatch")
			}

			if !reflect.DeepEqual(decoderInputFileInfoIDs(d.nonRecoverySet), parityFile.mainPacket.nonRecoverySet) {
				return nil, errors.New("non-recovery set mismatch")
			}

			return &parityFile, nil
		}()
		d.delegate.OnParityFileLoad(i+1, match, err)
		if err != nil {
			return err
		}
		if parityFile == nil {
			continue
		}

		parityFiles = append(parityFiles, *parityFile)
	}

	var parityShards [][]byte
	for _, file := range parityFiles {
		for exponent, packet := range file.recoveryPackets {
			if int(exponent) >= len(parityShards) {
				parityShards = append(parityShards, make([][]byte, int(exponent+1)-len(parityShards))...)
			}
			parityShards[exponent] = packet.data