keyvalue.go

/*
 * Copyright 2026 Mandelsoft. All rights reserved.
 *  This file is licensed under the Apache Software License, v. 2 except as noted
 *  otherwise in the LICENSE file
 *
 *  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,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */

package logging

import (
	"fmt"

	"github.com/mandelsoft/logging/utils"
)

////////////////////////////////////////////////////////////////////////////////

// KeyValueProvider is an interface, which can be implemented by an object
// to be directly usable in a key/value list as key-pair provider.
// The NormalizeTo method is used to normalize its values by appending
// the key pairs to a normalized list.
//
// Those values can be used as single argument representing a set of key/value pairs
// together with a sequence of key and value
// arguments in the argument list of the logging methods.
//
// Besides a single KeyValue this interface can be implemented by any
// application object, which should be usable to provide standard key/value
// pairs for a log message.
type KeyValueProvider interface {
	NormalizeTo(*[]interface{})
}

type keyValue struct {
	name  string
	value interface{}
}

var _ keyvalue = (*keyValue)(nil)

type keyvalue interface {
	Name() string
	Value() interface{}
}

var _ KeyValueProvider = (*keyValue)(nil)

func (kv *keyValue) Name() string {
	return kv.name
}

func (kv *keyValue) Value() interface{} {
	return kv.value
}

func (kv *keyValue) String() string {
	return fmt.Sprint(kv.name, "=", kv.value)
}

func (kv *keyValue) NormalizeTo(values *[]interface{}) {
	if kv.value != utils.Ignore {
		*values = append(*values, kv.name, kv.value)
	}
}

// KeyValue is a KeyValueProvider providing a single key/value pair for the
// argument list of logging methods.
//
// Those values can be used as single argument representing a key/value pair
// together with a sequence of key and value
// arguments in the argument list of the logging methods.
//
// This function can be used to define standardized keys for various
// use cases(see package [github.com/mandelsoft/logging/keyvalue]).
func KeyValue(key string, value interface{}) *keyValue {
	return &keyValue{
		name:  key,
		value: value,
	}
}

// NormalizeValues evaluates a sequence of key and value specifications and
// provided a list of pure key/value pairs applicable for logr.
// It normalizes Attribute and KeyValueProvider entries.
func NormalizeValues(keypairs []interface{}) []interface{} {
	for i, e := range keypairs {
		if i%2 == 0 {
			if _, ok := e.(KeyValueProvider); ok {
				return _prepare(keypairs)
			}
		} else {
			if e == utils.Ignore {
				return _prepare(keypairs)
			}
		}
	}
	return keypairs
}

func _prepare(keypairs []interface{}) []interface{} {
	var r []interface{}
	for i := 0; i < len(keypairs); i += 2 {
		if v, ok := keypairs[i].(KeyValueProvider); ok {
			v.NormalizeTo(&r)
			i--
		} else {
			if i+1 < len(keypairs) {
				if keypairs[i+1] != utils.Ignore {
					r = append(r, keypairs[i], keypairs[i+1])
				}
			} else {
				r = append(r, keypairs[i]) // preserve the erroneous value
			}
		}
	}
	return r
}