names_gen.go

// Generated by "sketch" utility. DO NOT EDIT
package resource

import (
	"bytes"
	"encoding/json"
	"fmt"
	"sort"
	"sync"

	"github.com/lestrrat-go/blackmagic"
)

func init() {
	Register("Names", "", Names{})
	RegisterBuilder("Names", "", NamesBuilder{})
}

type Names struct {
	mu              sync.RWMutex
	familyName      *string
	formatted       *string
	givenName       *string
	honorificPrefix *string
	honorificSuffix *string
	middleName      *string
	extra           map[string]interface{}
}

// These constants are used when the JSON field name is used.
// Their use is not strictly required, but certain linters
// complain about repeated constants, and therefore internally
// this used throughout
const (
	NamesFamilyNameKey      = "familyName"
	NamesFormattedKey       = "formatted"
	NamesGivenNameKey       = "givenName"
	NamesHonorificPrefixKey = "honorificPrefix"
	NamesHonorificSuffixKey = "honorificSuffix"
	NamesMiddleNameKey      = "middleName"
)

// Get retrieves the value associated with a key
func (v *Names) Get(key string, dst interface{}) error {
	v.mu.RLock()
	defer v.mu.RUnlock()
	return v.getNoLock(key, dst, false)
}

// getNoLock is a utility method that is called from Get, MarshalJSON, etc, but
// it can be used from user-supplied code. Unlike Get, it avoids locking for
// each call, so the user needs to explicitly lock the object before using,
// but otherwise should be faster than sing Get directly
func (v *Names) getNoLock(key string, dst interface{}, raw bool) error {
	switch key {
	case NamesFamilyNameKey:
		if val := v.familyName; val != nil {
			return blackmagic.AssignIfCompatible(dst, *val)
		}
	case NamesFormattedKey:
		if val := v.formatted; val != nil {
			return blackmagic.AssignIfCompatible(dst, *val)
		}
	case NamesGivenNameKey:
		if val := v.givenName; val != nil {
			return blackmagic.AssignIfCompatible(dst, *val)
		}
	case NamesHonorificPrefixKey:
		if val := v.honorificPrefix; val != nil {
			return blackmagic.AssignIfCompatible(dst, *val)
		}
	case NamesHonorificSuffixKey:
		if val := v.honorificSuffix; val != nil {
			return blackmagic.AssignIfCompatible(dst, *val)
		}
	case NamesMiddleNameKey:
		if val := v.middleName; val != nil {
			return blackmagic.AssignIfCompatible(dst, *val)
		}
	default:
		if v.extra != nil {
			val, ok := v.extra[key]
			if ok {
				return blackmagic.AssignIfCompatible(dst, val)
			}
		}
	}
	return fmt.Errorf(`no such key %q`, key)
}

// Set sets the value of the specified field. The name must be a JSON
// field name, not the Go name
func (v *Names) Set(key string, value interface{}) error {
	v.mu.Lock()
	defer v.mu.Unlock()
	switch key {
	case NamesFamilyNameKey:
		converted, ok := value.(string)
		if !ok {
			return fmt.Errorf(`expected value of type string for field familyName, got %T`, value)
		}
		v.familyName = &converted
	case NamesFormattedKey:
		converted, ok := value.(string)
		if !ok {
			return fmt.Errorf(`expected value of type string for field formatted, got %T`, value)
		}
		v.formatted = &converted
	case NamesGivenNameKey:
		converted, ok := value.(string)
		if !ok {
			return fmt.Errorf(`expected value of type string for field givenName, got %T`, value)
		}
		v.givenName = &converted
	case NamesHonorificPrefixKey:
		converted, ok := value.(string)
		if !ok {
			return fmt.Errorf(`expected value of type string for field honorificPrefix, got %T`, value)
		}
		v.honorificPrefix = &converted
	case NamesHonorificSuffixKey:
		converted, ok := value.(string)
		if !ok {
			return fmt.Errorf(`expected value of type string for field honorificSuffix, got %T`, value)
		}
		v.honorificSuffix = &converted
	case NamesMiddleNameKey:
		converted, ok := value.(string)
		if !ok {
			return fmt.Errorf(`expected value of type string for field middleName, got %T`, value)
		}
		v.middleName = &converted
	default:
		if v.extra == nil {
			v.extra = make(map[string]interface{})
		}

		v.extra[key] = value
	}
	return nil
}

// Has returns true if the field specified by the argument has been populated.
// The field name must be the JSON field name, not the Go-structure's field name.
func (v *Names) Has(name string) bool {
	switch name {
	case NamesFamilyNameKey:
		return v.familyName != nil
	case NamesFormattedKey:
		return v.formatted != nil
	case NamesGivenNameKey:
		return v.givenName != nil
	case NamesHonorificPrefixKey:
		return v.honorificPrefix != nil
	case NamesHonorificSuffixKey:
		return v.honorificSuffix != nil
	case NamesMiddleNameKey:
		return v.middleName != nil
	default:
		if v.extra != nil {
			if _, ok := v.extra[name]; ok {
				return true
			}
		}
		return false
	}
}

// Keys returns a slice of string comprising of JSON field names whose values
// are present in the object.
func (v *Names) Keys() []string {
	keys := make([]string, 0, 6)
	if v.familyName != nil {
		keys = append(keys, NamesFamilyNameKey)
	}
	if v.formatted != nil {
		keys = append(keys, NamesFormattedKey)
	}
	if v.givenName != nil {
		keys = append(keys, NamesGivenNameKey)
	}
	if v.honorificPrefix != nil {
		keys = append(keys, NamesHonorificPrefixKey)
	}
	if v.honorificSuffix != nil {
		keys = append(keys, NamesHonorificSuffixKey)
	}
	if v.middleName != nil {
		keys = append(keys, NamesMiddleNameKey)
	}

	if len(v.extra) > 0 {
		for k := range v.extra {
			keys = append(keys, k)
		}
	}
	sort.Strings(keys)
	return keys
}

// HasFamilyName returns true if the field `familyName` has been populated
func (v *Names) HasFamilyName() bool {
	v.mu.RLock()
	defer v.mu.RUnlock()
	return v.familyName != nil
}

// HasFormatted returns true if the field `formatted` has been populated
func (v *Names) HasFormatted() bool {
	v.mu.RLock()
	defer v.mu.RUnlock()
	return v.formatted != nil
}

// HasGivenName returns true if the field `givenName` has been populated
func (v *Names) HasGivenName() bool {
	v.mu.RLock()
	defer v.mu.RUnlock()
	return v.givenName != nil
}

// HasHonorificPrefix returns true if the field `honorificPrefix` has been populated
func (v *Names) HasHonorificPrefix() bool {
	v.mu.RLock()
	defer v.mu.RUnlock()
	return v.honorificPrefix != nil
}

// HasHonorificSuffix returns true if the field `honorificSuffix` has been populated
func (v *Names) HasHonorificSuffix() bool {
	v.mu.RLock()
	defer v.mu.RUnlock()
	return v.honorificSuffix != nil
}

// HasMiddleName returns true if the field `middleName` has been populated
func (v *Names) HasMiddleName() bool {
	v.mu.RLock()
	defer v.mu.RUnlock()
	return v.middleName != nil
}

func (v *Names) FamilyName() string {
	v.mu.RLock()
	defer v.mu.RUnlock()
	if val := v.familyName; val != nil {
		return *val
	}
	return ""
}

func (v *Names) Formatted() string {
	v.mu.RLock()
	defer v.mu.RUnlock()
	if val := v.formatted; val != nil {
		return *val
	}
	return ""
}

func (v *Names) GivenName() string {
	v.mu.RLock()
	defer v.mu.RUnlock()
	if val := v.givenName; val != nil {
		return *val
	}
	return ""
}

func (v *Names) HonorificPrefix() string {
	v.mu.RLock()
	defer v.mu.RUnlock()
	if val := v.honorificPrefix; val != nil {
		return *val
	}
	return ""
}

func (v *Names) HonorificSuffix() string {
	v.mu.RLock()
	defer v.mu.RUnlock()
	if val := v.honorificSuffix; val != nil {
		return *val
	}
	return ""
}

func (v *Names) MiddleName() string {
	v.mu.RLock()
	defer v.mu.RUnlock()
	if val := v.middleName; val != nil {
		return *val
	}
	return ""
}

// Remove removes the value associated with a key
func (v *Names) Remove(key string) error {
	v.mu.Lock()
	defer v.mu.Unlock()

	switch key {
	case NamesFamilyNameKey:
		v.familyName = nil
	case NamesFormattedKey:
		v.formatted = nil
	case NamesGivenNameKey:
		v.givenName = nil
	case NamesHonorificPrefixKey:
		v.honorificPrefix = nil
	case NamesHonorificSuffixKey:
		v.honorificSuffix = nil
	case NamesMiddleNameKey:
		v.middleName = nil
	default:
		delete(v.extra, key)
	}

	return nil
}

func (v *Names) Clone(dst interface{}) error {
	v.mu.RLock()
	defer v.mu.RUnlock()

	var extra map[string]interface{}
	if len(v.extra) > 0 {
		extra = make(map[string]interface{})
		for key, val := range v.extra {
			extra[key] = val
		}
	}
	return blackmagic.AssignIfCompatible(dst, &Names{
		familyName:      v.familyName,
		formatted:       v.formatted,
		givenName:       v.givenName,
		honorificPrefix: v.honorificPrefix,
		honorificSuffix: v.honorificSuffix,
		middleName:      v.middleName,
		extra:           extra,
	})
}

// MarshalJSON serializes Names into JSON.
// All pre-declared fields are included as long as a value is
// assigned to them, as well as all extra fields. All of these
// fields are sorted in alphabetical order.
func (v *Names) MarshalJSON() ([]byte, error) {
	v.mu.RLock()
	defer v.mu.RUnlock()

	var buf bytes.Buffer
	enc := json.NewEncoder(&buf)
	buf.WriteByte('{')
	for i, k := range v.Keys() {
		var val interface{}
		if err := v.getNoLock(k, &val, true); err != nil {
			return nil, fmt.Errorf(`failed to retrieve value for field %q: %w`, k, err)
		}

		if i > 0 {
			buf.WriteByte(',')
		}
		if err := enc.Encode(k); err != nil {
			return nil, fmt.Errorf(`failed to encode map key name: %w`, err)
		}
		buf.WriteByte(':')
		if err := enc.Encode(val); err != nil {
			return nil, fmt.Errorf(`failed to encode map value for %q: %w`, k, err)
		}
	}
	buf.WriteByte('}')
	return buf.Bytes(), nil
}

// UnmarshalJSON deserializes a piece of JSON data into Names.
//
// Pre-defined fields must be deserializable via "encoding/json" to their
// respective Go types, otherwise an error is returned.
//
// Extra fields are stored in a special "extra" storage, which can only
// be accessed via `Get()` and `Set()` methods.
func (v *Names) UnmarshalJSON(data []byte) error {
	v.mu.Lock()
	defer v.mu.Unlock()
	v.familyName = nil
	v.formatted = nil
	v.givenName = nil
	v.honorificPrefix = nil
	v.honorificSuffix = nil
	v.middleName = nil

	dec := json.NewDecoder(bytes.NewReader(data))
	var extra map[string]interface{}

LOOP:
	for {
		tok, err := dec.Token()
		if err != nil {
			return fmt.Errorf(`error reading JSON token: %w`, err)
		}
		switch tok := tok.(type) {
		case json.Delim:
			if tok == '}' { // end of object
				break LOOP
			}
			// we should only get into this clause at the very beginning, and just once
			if tok != '{' {
				return fmt.Errorf(`expected '{', but got '%c'`, tok)
			}
		case string:
			switch tok {
			case NamesFamilyNameKey:
				var val string
				if err := dec.Decode(&val); err != nil {
					return fmt.Errorf(`failed to decode value for %q: %w`, NamesFamilyNameKey, err)
				}
				v.familyName = &val
			case NamesFormattedKey:
				var val string
				if err := dec.Decode(&val); err != nil {
					return fmt.Errorf(`failed to decode value for %q: %w`, NamesFormattedKey, err)
				}
				v.formatted = &val
			case NamesGivenNameKey:
				var val string
				if err := dec.Decode(&val); err != nil {
					return fmt.Errorf(`failed to decode value for %q: %w`, NamesGivenNameKey, err)
				}
				v.givenName = &val
			case NamesHonorificPrefixKey:
				var val string
				if err := dec.Decode(&val); err != nil {
					return fmt.Errorf(`failed to decode value for %q: %w`, NamesHonorificPrefixKey, err)
				}
				v.honorificPrefix = &val
			case NamesHonorificSuffixKey:
				var val string
				if err := dec.Decode(&val); err != nil {
					return fmt.Errorf(`failed to decode value for %q: %w`, NamesHonorificSuffixKey, err)
				}
				v.honorificSuffix = &val
			case NamesMiddleNameKey:
				var val string
				if err := dec.Decode(&val); err != nil {
					return fmt.Errorf(`failed to decode value for %q: %w`, NamesMiddleNameKey, err)
				}
				v.middleName = &val
			default:
				var val interface{}
				if err := v.decodeExtraField(tok, dec, &val); err != nil {
					return fmt.Errorf(`failed to decode value for %q: %w`, tok, err)
				}
				if extra == nil {
					extra = make(map[string]interface{})
				}
				extra[tok] = val
			}
		}
	}

	if extra != nil {
		v.extra = extra
	}
	return nil
}

type NamesBuilder struct {
	mu     sync.Mutex
	err    error
	once   sync.Once
	object *Names
}

// NewNamesBuilder creates a new NamesBuilder instance.
// NamesBuilder is safe to be used uninitialized as well.
func NewNamesBuilder() *NamesBuilder {
	return &NamesBuilder{}
}
func (b *NamesBuilder) initialize() {
	b.err = nil
	b.object = &Names{}
}
func (b *NamesBuilder) FamilyName(in string) *NamesBuilder {
	return b.SetField(NamesFamilyNameKey, in)
}
func (b *NamesBuilder) Formatted(in string) *NamesBuilder {
	return b.SetField(NamesFormattedKey, in)
}
func (b *NamesBuilder) GivenName(in string) *NamesBuilder {
	return b.SetField(NamesGivenNameKey, in)
}
func (b *NamesBuilder) HonorificPrefix(in string) *NamesBuilder {
	return b.SetField(NamesHonorificPrefixKey, in)
}
func (b *NamesBuilder) HonorificSuffix(in string) *NamesBuilder {
	return b.SetField(NamesHonorificSuffixKey, in)
}
func (b *NamesBuilder) MiddleName(in string) *NamesBuilder {
	return b.SetField(NamesMiddleNameKey, in)
}

// SetField sets the value of any field. The name should be the JSON field name.
// Type check will only be performed for pre-defined types
func (b *NamesBuilder) SetField(name string, value interface{}) *NamesBuilder {
	b.mu.Lock()
	defer b.mu.Unlock()

	b.once.Do(b.initialize)
	if b.err != nil {
		return b
	}

	if err := b.object.Set(name, value); err != nil {
		b.err = err
	}
	return b
}
func (b *NamesBuilder) Build() (*Names, error) {
	b.mu.Lock()
	defer b.mu.Unlock()

	b.once.Do(b.initialize)
	if b.err != nil {
		return nil, b.err
	}
	obj := b.object
	b.once = sync.Once{}
	b.once.Do(b.initialize)
	return obj, nil
}
func (b *NamesBuilder) MustBuild() *Names {
	object, err := b.Build()
	if err != nil {
		panic(err)
	}
	return object
}

func (b *NamesBuilder) From(in *Names) *NamesBuilder {
	b.mu.Lock()
	defer b.mu.Unlock()
	b.once.Do(b.initialize)
	if b.err != nil {
		return b
	}

	var cloned Names
	if err := in.Clone(&cloned); err != nil {
		b.err = err
		return b
	}

	b.object = &cloned
	return b
}

// AsMap returns the resource as a Go map
func (v *Names) AsMap(m map[string]interface{}) error {
	v.mu.RLock()
	defer v.mu.RUnlock()

	for _, key := range v.Keys() {
		var val interface{}
		if err := v.getNoLock(key, &val, false); err != nil {
			return fmt.Errorf(`failed to retrieve value for key %q: %w`, key, err)
		}
		m[key] = val
	}
	return nil
}

// GetExtension takes into account extension uri, and fetches
// the specified attribute from the extension object
func (v *Names) GetExtension(name, uri string, dst interface{}) error {
	if uri == "" {
		return v.Get(name, dst)
	}
	var ext interface{}
	if err := v.Get(uri, &ext); err != nil {
		return fmt.Errorf(`failed to fetch extension %q: %w`, uri, err)
	}

	getter, ok := ext.(interface {
		Get(string, interface{}) error
	})
	if !ok {
		return fmt.Errorf(`extension does not implement Get(string, interface{}) error`)
	}
	return getter.Get(name, dst)
}

func (*Names) decodeExtraField(name string, dec *json.Decoder, dst interface{}) error {
	// we can get an instance of the resource object
	if rx, ok := registry.LookupByURI(name); ok {
		if err := dec.Decode(&rx); err != nil {
			return fmt.Errorf(`failed to decode value for key %q: %w`, name, err)
		}
		if err := blackmagic.AssignIfCompatible(dst, rx); err != nil {
			return err
		}
	} else {
		if err := dec.Decode(dst); err != nil {
			return fmt.Errorf(`failed to decode value for key %q: %w`, name, err)
		}
	}
	return nil
}

func (b *Builder) Names() *NamesBuilder {
	return &NamesBuilder{}
}