DockerCLI/vendor/github.com/docker/swarmkit/api/storeobject.go

package api

import (
	"errors"
	"fmt"
	"strings"

	"github.com/docker/go-events"
)

var (
	errUnknownStoreAction = errors.New("unrecognized action type")
	errConflictingFilters = errors.New("conflicting filters specified")
	errNoKindSpecified    = errors.New("no kind of object specified")
	errUnrecognizedAction = errors.New("unrecognized action")
)

// StoreObject is an abstract object that can be handled by the store.
type StoreObject interface {
	GetID() string                           // Get ID
	GetMeta() Meta                           // Retrieve metadata
	SetMeta(Meta)                            // Set metadata
	CopyStoreObject() StoreObject            // Return a copy of this object
	EventCreate() Event                      // Return a creation event
	EventUpdate(oldObject StoreObject) Event // Return an update event
	EventDelete() Event                      // Return a deletion event
}

// Event is the type used for events passed over watcher channels, and also
// the type used to specify filtering in calls to Watch.
type Event interface {
	// TODO(stevvooe): Consider whether it makes sense to squish both the
	// matcher type and the primary type into the same type. It might be better
	// to build a matcher from an event prototype.

	// Matches checks if this item in a watch queue Matches the event
	// description.
	Matches(events.Event) bool
}

// EventCreate is an interface implemented by every creation event type
type EventCreate interface {
	IsEventCreate() bool
}

// EventUpdate is an interface impelemented by every update event type
type EventUpdate interface {
	IsEventUpdate() bool
}

// EventDelete is an interface implemented by every delete event type
type EventDelete interface {
	IsEventDelete()
}

func customIndexer(kind string, annotations *Annotations) (bool, [][]byte, error) {
	var converted [][]byte

	for _, entry := range annotations.Indices {
		index := make([]byte, 0, len(kind)+1+len(entry.Key)+1+len(entry.Val)+1)
		if kind != "" {
			index = append(index, []byte(kind)...)
			index = append(index, '|')
		}
		index = append(index, []byte(entry.Key)...)
		index = append(index, '|')
		index = append(index, []byte(entry.Val)...)
		index = append(index, '\x00')
		converted = append(converted, index)
	}

	// Add the null character as a terminator
	return len(converted) != 0, converted, nil
}

func fromArgs(args ...interface{}) ([]byte, error) {
	if len(args) != 1 {
		return nil, fmt.Errorf("must provide only a single argument")
	}
	arg, ok := args[0].(string)
	if !ok {
		return nil, fmt.Errorf("argument must be a string: %#v", args[0])
	}
	// Add the null character as a terminator
	arg += "\x00"
	return []byte(arg), nil
}

func prefixFromArgs(args ...interface{}) ([]byte, error) {
	val, err := fromArgs(args...)
	if err != nil {
		return nil, err
	}

	// Strip the null terminator, the rest is a prefix
	n := len(val)
	if n > 0 {
		return val[:n-1], nil
	}
	return val, nil
}

func checkCustom(a1, a2 Annotations) bool {
	if len(a1.Indices) == 1 {
		for _, ind := range a2.Indices {
			if ind.Key == a1.Indices[0].Key && ind.Val == a1.Indices[0].Val {
				return true
			}
		}
	}
	return false
}

func checkCustomPrefix(a1, a2 Annotations) bool {
	if len(a1.Indices) == 1 {
		for _, ind := range a2.Indices {
			if ind.Key == a1.Indices[0].Key && strings.HasPrefix(ind.Val, a1.Indices[0].Val) {
				return true
			}
		}
	}
	return false
}