github.com/whtcorpsinc/milevadb-prod@v0.0.0-20211104133533-f57f4be3b597/causetstore/petri/acyclic/structure/list.go

// Copyright 2020 WHTCORPS INC, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// See the License for the specific language governing permissions and
// limitations under the License.

package structure

import (
	"context"
	"encoding/binary"

	"github.com/whtcorpsinc/errors"
	"github.com/whtcorpsinc/milevadb/ekv"
)

type listMeta struct {
	LIndex int64
	RIndex int64
}

func (spacetime listMeta) Value() []byte {
	buf := make([]byte, 16)
	binary.BigEndian.PutUint64(buf[0:8], uint64(spacetime.LIndex))
	binary.BigEndian.PutUint64(buf[8:16], uint64(spacetime.RIndex))
	return buf
}

func (spacetime listMeta) IsEmpty() bool {
	return spacetime.LIndex >= spacetime.RIndex
}

// LPush prepends one or multiple values to a list.
func (t *TxStructure) LPush(key []byte, values ...[]byte) error {
	return t.listPush(key, true, values...)
}

// RPush appends one or multiple values to a list.
func (t *TxStructure) RPush(key []byte, values ...[]byte) error {
	return t.listPush(key, false, values...)
}

func (t *TxStructure) listPush(key []byte, left bool, values ...[]byte) error {
	if t.readWriter == nil {
		return ErrWriteOnSnapshot
	}
	if len(values) == 0 {
		return nil
	}

	spacetimeKey := t.encodeListMetaKey(key)
	spacetime, err := t.loadListMeta(spacetimeKey)
	if err != nil {
		return errors.Trace(err)
	}

	var index int64
	for _, v := range values {
		if left {
			spacetime.LIndex--
			index = spacetime.LIndex
		} else {
			index = spacetime.RIndex
			spacetime.RIndex++
		}

		dataKey := t.encodeListDataKey(key, index)
		if err = t.readWriter.Set(dataKey, v); err != nil {
			return errors.Trace(err)
		}
	}

	return t.readWriter.Set(spacetimeKey, spacetime.Value())
}

// LPop removes and gets the first element in a list.
func (t *TxStructure) LPop(key []byte) ([]byte, error) {
	return t.listPop(key, true)
}

// RPop removes and gets the last element in a list.
func (t *TxStructure) RPop(key []byte) ([]byte, error) {
	return t.listPop(key, false)
}

func (t *TxStructure) listPop(key []byte, left bool) ([]byte, error) {
	if t.readWriter == nil {
		return nil, ErrWriteOnSnapshot
	}
	spacetimeKey := t.encodeListMetaKey(key)
	spacetime, err := t.loadListMeta(spacetimeKey)
	if err != nil || spacetime.IsEmpty() {
		return nil, errors.Trace(err)
	}

	var index int64
	if left {
		index = spacetime.LIndex
		spacetime.LIndex++
	} else {
		spacetime.RIndex--
		index = spacetime.RIndex
	}

	dataKey := t.encodeListDataKey(key, index)

	var data []byte
	data, err = t.reader.Get(context.TODO(), dataKey)
	if err != nil {
		return nil, errors.Trace(err)
	}

	if err = t.readWriter.Delete(dataKey); err != nil {
		return nil, errors.Trace(err)
	}

	if !spacetime.IsEmpty() {
		err = t.readWriter.Set(spacetimeKey, spacetime.Value())
	} else {
		err = t.readWriter.Delete(spacetimeKey)
	}

	return data, errors.Trace(err)
}

// LLen gets the length of a list.
func (t *TxStructure) LLen(key []byte) (int64, error) {
	spacetimeKey := t.encodeListMetaKey(key)
	spacetime, err := t.loadListMeta(spacetimeKey)
	return spacetime.RIndex - spacetime.LIndex, errors.Trace(err)
}

// LGetAll gets all elements of this list in order from right to left.
func (t *TxStructure) LGetAll(key []byte) ([][]byte, error) {
	spacetimeKey := t.encodeListMetaKey(key)
	spacetime, err := t.loadListMeta(spacetimeKey)
	if err != nil || spacetime.IsEmpty() {
		return nil, errors.Trace(err)
	}

	length := int(spacetime.RIndex - spacetime.LIndex)
	elements := make([][]byte, 0, length)
	for index := spacetime.RIndex - 1; index >= spacetime.LIndex; index-- {
		e, err := t.reader.Get(context.TODO(), t.encodeListDataKey(key, index))
		if err != nil {
			return nil, errors.Trace(err)
		}
		elements = append(elements, e)
	}
	return elements, nil
}

// LIndex gets an element from a list by its index.
func (t *TxStructure) LIndex(key []byte, index int64) ([]byte, error) {
	spacetimeKey := t.encodeListMetaKey(key)
	spacetime, err := t.loadListMeta(spacetimeKey)
	if err != nil || spacetime.IsEmpty() {
		return nil, errors.Trace(err)
	}

	index = adjustIndex(index, spacetime.LIndex, spacetime.RIndex)

	if index >= spacetime.LIndex && index < spacetime.RIndex {
		return t.reader.Get(context.TODO(), t.encodeListDataKey(key, index))
	}
	return nil, nil
}

// LSet uFIDelates an element in the list by its index.
func (t *TxStructure) LSet(key []byte, index int64, value []byte) error {
	if t.readWriter == nil {
		return ErrWriteOnSnapshot
	}
	spacetimeKey := t.encodeListMetaKey(key)
	spacetime, err := t.loadListMeta(spacetimeKey)
	if err != nil || spacetime.IsEmpty() {
		return errors.Trace(err)
	}

	index = adjustIndex(index, spacetime.LIndex, spacetime.RIndex)

	if index >= spacetime.LIndex && index < spacetime.RIndex {
		return t.readWriter.Set(t.encodeListDataKey(key, index), value)
	}
	return ErrInvalidListIndex.GenWithStack("invalid list index %d", index)
}

// LClear removes the list of the key.
func (t *TxStructure) LClear(key []byte) error {
	if t.readWriter == nil {
		return ErrWriteOnSnapshot
	}
	spacetimeKey := t.encodeListMetaKey(key)
	spacetime, err := t.loadListMeta(spacetimeKey)
	if err != nil || spacetime.IsEmpty() {
		return errors.Trace(err)
	}

	for index := spacetime.LIndex; index < spacetime.RIndex; index++ {
		dataKey := t.encodeListDataKey(key, index)
		if err = t.readWriter.Delete(dataKey); err != nil {
			return errors.Trace(err)
		}
	}

	return t.readWriter.Delete(spacetimeKey)
}

func (t *TxStructure) loadListMeta(spacetimeKey []byte) (listMeta, error) {
	v, err := t.reader.Get(context.TODO(), spacetimeKey)
	if ekv.ErrNotExist.Equal(err) {
		err = nil
	}
	if err != nil {
		return listMeta{}, errors.Trace(err)
	}

	spacetime := listMeta{0, 0}
	if v == nil {
		return spacetime, nil
	}

	if len(v) != 16 {
		return spacetime, ErrInvalidListMetaData
	}

	spacetime.LIndex = int64(binary.BigEndian.Uint64(v[0:8]))
	spacetime.RIndex = int64(binary.BigEndian.Uint64(v[8:16]))
	return spacetime, nil
}

func adjustIndex(index int64, min, max int64) int64 {
	if index >= 0 {
		return index + min
	}

	return index + max
}