read_files.go

package store_util

import (
	"github.com/friedenberg/zit/src/alfa/errors"
	"github.com/friedenberg/zit/src/alfa/schnittstellen"
	"github.com/friedenberg/zit/src/bravo/iter"
	"github.com/friedenberg/zit/src/delta/checked_out_state"
	"github.com/friedenberg/zit/src/hotel/sku"
	"github.com/friedenberg/zit/src/india/matcher"
)

func (s *common) ReadOneExternalFS(
	sk2 *sku.Transacted,
) (co *sku.CheckedOut, err error) {
	// TODO-P3 pool
	co = &sku.CheckedOut{
		Internal: *sk2,
	}

	ok := false

	var e *sku.ExternalMaybe

	if e, ok = s.cwdFiles.Get(sk2.Kennung); !ok {
		err = iter.MakeErrStopIteration()
		return
	}

	var e2 *sku.External

	if e2, err = s.ReadOneExternal(e, sk2); err != nil {
		if errors.IsNotExist(err) {
			err = iter.MakeErrStopIteration()
		} else if errors.Is(err, sku.ErrExternalHasConflictMarker) {
			co.State = checked_out_state.StateConflicted
			co.External.FDs = e.FDs

			if err = co.External.Kennung.SetWithKennung(sk2.Kennung); err != nil {
				err = errors.Wrap(err)
				return
			}

			return
		} else {
			err = errors.Wrapf(err, "Cwd: %#v", e)
		}

		return
	}

	co.External = *e2
	co.DetermineState(false)

	return
}

func (s *common) ReadFiles(
	fq matcher.FuncReaderTransactedLikePtr,
	f schnittstellen.FuncIter[*sku.CheckedOut],
) (err error) {
	if err = fq(
		iter.MakeChain(
			func(et *sku.Transacted) (err error) {
				var col *sku.CheckedOut

				et1 := sku.GetTransactedPool().Get()

				if err = et1.SetFromSkuLike(et); err != nil {
					err = errors.Wrap(err)
					return
				}

				if col, err = s.ReadOneExternalFS(et1); err != nil {
					err = errors.Wrap(err)
					return
				}

				if err = col.Internal.SetFromSkuLike(et); err != nil {
					err = errors.Wrap(err)
					return
				}

				if col.State == checked_out_state.StateUnknown {
					col.DetermineState(false)
				}

				if err = f(col); err != nil {
					err = errors.Wrap(err)
					return
				}

				return
			},
		),
	); err != nil {
		err = errors.Wrap(err)
		return
	}

	if err = s.cwdFiles.EachCreatableMatchable(
		iter.MakeChain(
			func(il *sku.ExternalMaybe) (err error) {
				if err = s.GetAbbrStore().Exists(&il.Kennung); err == nil {
					err = iter.MakeErrStopIteration()
					return
				}

				err = nil

				tco := &sku.CheckedOut{}
				var tcoe *sku.External

				if tcoe, err = s.ReadOneExternal(
					il,
					nil,
				); err != nil {
					if errors.IsNotExist(err) {
						err = iter.MakeErrStopIteration()
					} else {
						err = errors.Wrapf(err, "%#v", il)
					}

					return
				}

				tco.Internal.Kennung = tcoe.Kennung
				tco.External = *tcoe
				tco.State = checked_out_state.StateUntracked

				if err = f(tco); err != nil {
					err = errors.Wrap(err)
					return
				}

				return
			},
		),
	); err != nil {
		err = errors.Wrap(err)
		return
	}

	return
}