codifier/store_ops.go

// Copyright 2021 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

package codifier

import "log"

// StoreKeyValue stores the given value under the given given. The key must not
// exists already. The value is a string. If it's a list, use StoreKeyValueList.
func (p *Proc) StoreKeyValue(key, value string) *Proc {
	if p == nil {
		log.Println("  StoreKeyValue() error: nil receiver")
		return nil
	}
	_, ok := p.Store[key].(string)
	if ok {
		log.Printf("  StoreKeyValue() error: key %q already present in store", key)
		return nil
	}
	p.Store[key] = value
	return p
}

// Value returns the value stored under the given key else empty string if not
// present.
func (p *Proc) Value(key string) string {
	if p == nil {
		log.Println("  Value() error: nil receiver")
		return ""
	}
	value, ok := p.Store[key].(string)
	if !ok {
		log.Printf("  Value(): key %q not present in store", key)
		return ""
	}
	return value
}

// ExtractValue is an operator that extracts a value by key from the current
// replacement, if present. The expected k/v format is `k="v"` with single or
// double quotes and optional spaces. The key and the extracted value are
// stored.
func (p *Proc) ExtractValue(key string) *Proc {
	if p == nil {
		log.Println("  ExtractValue() error: nil receiver")
		return nil
	}
	value, err := getValue(p.replacement, key)
	if err != nil {
		log.Printf("  ExtractValue() error: %v", err)
		return nil
	}
	p.Store[key] = value
	return p
}

// ExtractList is an operator that extracts a list by name from the Proc's
// replacement. The argument is the list name. The extracted list is stored
// under the name.
func (p *Proc) ExtractList(listName string) *Proc {
	if p == nil {
		log.Println("  ExtractList() error: nil receiver")
		return nil
	}
	list, err := extractNamedList(p.replacement, listName)
	if err != nil {
		log.Printf("  ExtractList() error: %v", err)
		return nil
	}
	if list == nil {
		log.Printf("  ExtractList() error: found no list named %q", listName)
		return nil
	}
	log.Printf("ExtractList(): list %q has %d items", listName, len(list))
	p.Store[listName] = list
	return p
}

// ListValue returns the list stored under the given key else nil if not
// present.
func (p *Proc) ListValue(key string) []string {
	if p == nil {
		log.Println("  ListValue() error: nil receiver")
		return nil
	}
	v := p.Store[key]
	if v == nil {
		return nil
	}
	return v.([]string)
}

// lastItemInList returns the last item stored under the given listKey, else a
// blank string.
func (p *Proc) lastItemInList(listKey string) string {
	if p == nil {
		log.Println("  lastItemInList() error: nil receiver")
		return ""
	}
	storedList, ok := p.Store[listKey].([]string)
	if !ok {
		log.Printf("  lastItemInList(): list %q not present in store", listKey)
		return ""
	}
	if len(storedList) == 0 {
		return ""
	}
	return storedList[len(storedList)-1]
}

// copyStore copies the given Proc's store into it's store. If a key already
// exists in p's store, return nil.
func (p *Proc) copyStore(q *Proc) *Proc {
	if p == nil {
		log.Println("  copyStore() error: nil receiver")
		return nil
	}
	for k, v := range q.Store {
		_, ok := p.Store[k]
		if ok {
			log.Printf("  copyStore() error: key %q exists in destination store", k)
			return nil
		}
		p.Store[k] = v
	}
	return p
}

// ClearStore copies the given Proc's store into it's store. If a key already
// exists in p's store, return nil.
func (p *Proc) ClearStore() *Proc {
	if p == nil {
		log.Println("  ClearStore() error: nil receiver")
		return nil
	}
	p.Store = make(map[string]interface{})
	return p
}