ast_nodes_gen.go

// Autogenerated code!
// DO NOT EDIT!
//
// Generated by OrderedMap generator from the internal/cmd/generator command.

package jschema

import (
	"bytes"
	"encoding/json"
)

// Set sets a value with specified key.
func (m *ASTNodes) Set(k string, v ASTNode) {
	m.mx.Lock()
	defer m.mx.Unlock()

	if m.data == nil {
		m.data = map[string]ASTNode{}
	}
	if !m.has(k) {
		m.order = append(m.order, k)
	}
	m.data[k] = v
}

// Update updates a value with specified key.
func (m *ASTNodes) Update(k string, fn func(v ASTNode) ASTNode) {
	m.mx.Lock()
	defer m.mx.Unlock()

	if !m.has(k) {
		// Prevent from possible nil pointer dereference if map value type is a
		// pointer.
		return
	}

	m.data[k] = fn(m.data[k])
}

// GetValue gets a value by key.
func (m *ASTNodes) GetValue(k string) ASTNode {
	m.mx.RLock()
	defer m.mx.RUnlock()

	return m.data[k]
}

// Get gets a value by key.
func (m *ASTNodes) Get(k string) (ASTNode, bool) {
	m.mx.RLock()
	defer m.mx.RUnlock()

	v, ok := m.data[k]
	return v, ok
}

// Has checks that specified key is set.
func (m *ASTNodes) Has(k string) bool {
	m.mx.RLock()
	defer m.mx.RUnlock()

	return m.has(k)
}

func (m *ASTNodes) has(k string) bool {
	_, ok := m.data[k]
	return ok
}

// Len returns count of values.
func (m *ASTNodes) Len() int {
	m.mx.RLock()
	defer m.mx.RUnlock()

	return len(m.data)
}

func (m *ASTNodes) Delete(k string) {
	m.mx.Lock()
	defer m.mx.Unlock()

	m.delete(k)
}

func (m *ASTNodes) delete(k string) {
	var kk string
	i := -1

	for i, kk = range m.order {
		if kk == k {
			break
		}
	}

	delete(m.data, k)
	if i != -1 {
		m.order = append(m.order[:i], m.order[i+1:]...)
	}
}

// Filter iterates and changes values in the map.
func (m *ASTNodes) Filter(fn filterASTNodesFunc) {
	m.mx.Lock()
	defer m.mx.Unlock()

	for _, k := range m.order {
		if !fn(k, m.data[k]) {
			m.delete(k)
		}
	}
}

type filterASTNodesFunc = func(k string, v ASTNode) bool

// Find finds first matched item from the map.
func (m *ASTNodes) Find(fn findASTNodesFunc) (ASTNodesItem, bool) {
	m.mx.RLock()
	defer m.mx.RUnlock()

	for _, k := range m.order {
		if fn(k, m.data[k]) {
			return ASTNodesItem{
				Key:   k,
				Value: m.data[k],
			}, true
		}
	}
	return ASTNodesItem{}, false
}

type findASTNodesFunc = func(k string, v ASTNode) bool

func (m *ASTNodes) Each(fn eachASTNodesFunc) error {
	m.mx.RLock()
	defer m.mx.RUnlock()

	for _, k := range m.order {
		if err := fn(k, m.data[k]); err != nil {
			return err
		}
	}
	return nil
}

type eachASTNodesFunc = func(k string, v ASTNode) error

func (m *ASTNodes) EachSafe(fn eachSafeASTNodesFunc) {
	m.mx.RLock()
	defer m.mx.RUnlock()

	for _, k := range m.order {
		fn(k, m.data[k])
	}
}

type eachSafeASTNodesFunc = func(k string, v ASTNode)

// Map iterates and changes values in the map.
func (m *ASTNodes) Map(fn mapASTNodesFunc) error {
	m.mx.Lock()
	defer m.mx.Unlock()

	for _, k := range m.order {
		v, err := fn(k, m.data[k])
		if err != nil {
			return err
		}
		m.data[k] = v
	}
	return nil
}

type mapASTNodesFunc = func(k string, v ASTNode) (ASTNode, error)

// ASTNodesItem represent single data from the ASTNodes.
type ASTNodesItem struct {
	Key   string
	Value ASTNode
}

var _ json.Marshaler = &ASTNodes{}

func (m *ASTNodes) MarshalJSON() ([]byte, error) {
	m.mx.RLock()
	defer m.mx.RUnlock()

	var buf bytes.Buffer
	buf.WriteRune('{')

	for i, k := range m.order {
		if i != 0 {
			buf.WriteRune(',')
		}

		// marshal key
		key, err := json.Marshal(k)
		if err != nil {
			return nil, err
		}
		buf.Write(key)
		buf.WriteRune(':')

		// marshal value
		val, err := json.Marshal(m.data[k])
		if err != nil {
			return nil, err
		}
		buf.Write(val)
	}

	buf.WriteRune('}')
	return buf.Bytes(), nil
}