node

type ActionPostConstraint interface {
	CheckActionPostConstraints(r ActionRequest) (bool, error)
}

type ActionPreConstraint interface {
	CheckActionPreConstraints(r *ActionRequest) (bool, error)
}

type ActionRequest struct {
	Request
	Meta  *meta.Rpc
	Input *Selection
}

type Browser struct {

	// Information model of browser
	Meta *meta.Module

	// Regsitry of listeners when data model under browser is modified
	Triggers *TriggerTable

	// True if you want no leaf data checks like pattern, length, range, etc
	// you would only want to do this if you had a good reason
	DisableConstraints bool
	// contains filtered or unexported fields
}

type CheckWhen struct {
}

type ChildRequest struct {
	Request
	From   *Selection
	New    bool
	Delete bool
	Meta   meta.HasDataDefinitions
}

type ConstraintHandler struct {
	NoFail      bool
	NewLocation string
	Violations  []error
}

type Constraints struct {
	// contains filtered or unexported fields
}

type ContainerPostConstraint interface {
	CheckContainerPostConstraints(r ChildRequest, child *Selection) (bool, error)
}

type ContainerPreConstraint interface {
	CheckContainerPreConstraints(r *ChildRequest) (bool, error)
}

type ContentConstraint int

type ContextConstraint interface {
	ContextConstraint(*Selection) context.Context
}

type ErrorNode struct {
	Err error
}

type Event struct {
	Type EventType
	Src  Selection
}

type EventType int

type FieldPostConstraint interface {
	CheckFieldPostConstraints(r FieldRequest, hnd *ValueHandle) (bool, error)
}

type FieldPreConstraint interface {
	CheckFieldPreConstraints(r *FieldRequest, hnd *ValueHandle) (bool, error)
}

type FieldRequest struct {
	Request
	Meta  meta.Leafable
	Write bool
	Clear bool
}

type FieldsMatcher struct {
	// contains filtered or unexported fields
}

type Index struct {
	Keys []reflect.Value
	// contains filtered or unexported fields
}

type KeyListBuilder struct {
	// contains filtered or unexported fields
}

type ListItem struct {
	Selection *Selection
	Key       []val.Value
	// contains filtered or unexported fields
}

type ListPostConstraint interface {
	CheckListPostConstraints(r ListRequest, child *Selection, key []val.Value) (bool, bool, error)
}

type ListPreConstraint interface {
	CheckListPreConstraints(r *ListRequest) (bool, error)
}

type ListRange struct {
	Selector   PathMatcher
	CurrentRow int64
	StartRow   int64
	EndRow     int64
}

type ListRequest struct {
	Request
	From   *Selection
	New    bool
	Delete bool

	StartRow int

	// We make row available as a 32bit value for convenience but in theory
	// could be 64bit.  If you know you're list could not exceed 2 billion then
	// it's safe to use this value
	Row int

	StartRow64 int64
	Row64      int64
	First      bool
	Meta       *meta.List
	Key        []val.Value
}

type MaxDepth struct {
	MaxDepth int
}

type MaxNode struct {
	Count int
	Max   int
}

type Node interface {

	// Child is called when navigating, creating or deleting a "container" or "list".
	// The request fields contain the nature of the request.
	//
	// Params:
	//  ChildRequest - contains the nature (e.g. get, delete, new) and details of the
	//                 request (e.g. identity name of the container or list )
	//
	// Return:
	//   Node - Return nil entity does not exist otherwise node implementation of the underlying
	//          node requested
	Child(r ChildRequest) (child Node, err error)

	// Next is called for items in a list when navigating, creating or deleting items in the
	// "list".
	//
	// Params:
	//  ListRequest - contains the nature (e.g. get, delete, new) and details of the
	//                 request (e.g. key, row number)
	//
	// Return:
	//   Node - Return nil entity does not exist otherwise node implementation of the underlying
	//          node requested
	//   []val.Value - If a key was defined in YANG, AND the request is for the next item
	//           in the list, then you must also return the key expressed in val.Value array
	Next(r ListRequest) (next Node, key []val.Value, err error)

	// Field is called to read or write "leaf" or "leaf-list" items on container/list items or
	// even root module.
	//
	// Params:
	//   FieldRequest - identity of the field and the contains the nature (e.g. read or write)
	//             tip: if the YANG defines the field as config:false, you can assume the field is
	//             only called for reading and you can ignore the flag for read v.s. write
	//
	//   *ValueHandle - contains a single the "Val" that with either:
	//                   a.) contain the value to be set or
	//                   b.) be expected to be set to the requested value to be read
	Field(r FieldRequest, hnd *ValueHandle) error

	// Choose is only called when there is a need to know which single case between several "choice/case"
	// sets are currently true.  This is only called when reading.
	//
	// Params:
	//   Selection - current selection that is handling the choice investigation
	//   *Choice - name for the choice (there could be several in a given container)
	//
	// Return:
	//   *ChoiceCase - which case is currently valid (there can be only one)
	//
	Choose(sel *Selection, choice *meta.Choice) (m *meta.ChoiceCase, err error)

	// BeginEdit is called simply to inform a node when it is about to be edited including deleting or creating.
	// While there is nothing required of nodes to do anything on this call, implementations might have
	// very important, internal operations they need to perform like obtaining write locks for example. It is
	// also an opportunity to reject the edit for whatever reason by returning an error.
	//
	// It important to know this is called on **every** parent node for any edit to any of their children.
	// This is known as "event bubbling" and can be helpful when parents are in a better position to handle
	// operations for children.  You can easily distinguish this situation from the NodeRequest parameter.
	// See https://github.com/freeconf/restconf/wiki/Edit-Node-Traversal for details on when this is called
	// in particular in the order
	//
	// Params:
	//  NodeRequest - contains the nature (e.g. get, delete, new)
	BeginEdit(r NodeRequest) error

	// EndEdit is called simply to inform a node after it has been edited including deleting or creating.
	// While there is nothing required of nodes to do anything on this call, implementations might have
	// very important, internal operations they need to perform like release write locks for example. It is
	// also an opportunity to apply changes to live application or persist data to permanent storage.
	//
	// It important to know this is called on **every** parent node for any edit to any of their children.
	// This is known as "event bubbling" and can be helpful when parents are in a better position to handle
	// operations for children.  You can easily distinguish this situation from the NodeRequest parameter.
	// See https://github.com/freeconf/restconf/wiki/Edit-Node-Traversal for details on when this is called
	// in particular in the order
	//
	// Params:
	//  NodeRequest - contains the nature (e.g. get, delete, new)
	EndEdit(r NodeRequest) error

	// Action(rpc/action) is called when caller wished to run a 'action' or 'rpc' definition.  Input can
	// be found in request if an input is defined.  Output only has to be returned for
	// definitions that declare an output.
	//
	// Params:
	//  ActionRequest - In addition to the identity name of the action or rpc, it may contains the "input"
	//        to the action if one was defined in the YANG.
	//
	// Return:
	//  Node - If there is an expected response from action ("output" defined in YANG) then this would be
	//        the Node implementation of that data.
	Action(r ActionRequest) (output Node, err error)

	// Notificationsare unique with respect to resources are allocated that survive the original
	// request so implementation should try not keep references to any more resources than neccessary
	// to ensure they do not reference objects that become stale or that impose large chunks of memory
	// unknowningly and unneccesarily.
	//
	// Params:
	//   NotifyRequest - In addition to the identity name of the notification, this contains the stream
	//        to write events to.
	//
	// Return:
	//   NotifyCloser - Function to called to stop streaming events. This will be called for example when
	//      client closes the event stream socket either naturally or because of a network disconnect.
	//
	Notify(r NotifyRequest) (NotifyCloser, error)

	// Peek give an opportunity for API callers to gain access to the objects behind a node.
	//
	// Params:
	//   Selection - current selection that is handling the peeking
	//   interface{} - Who (or under what context) is attempting to peek. This can be used by
	//         node implementation to decide what is returned or if anything at all is returned.
	//         It may also be ingored.  This is up to
	//
	// Return:
	//   interface{} - Can be anything.
	//
	// This can be considered a violation of abstraction so implementation is not gauranteed and
	// can vary w/o any compiler warnings.  This can be useful in unit testing but uses outside this
	// should be used judicously.
	Peek(sel *Selection, consumer interface{}) interface{}

	// Context provides an opportunity to add/change values in the request context that is passed to
	// operations on this node and operations to children of this node.  FreeCONF does not put or
	// require anything in the context, it is meant as a way to make application or request specific
	// data available to nodes.
	//
	// A popular use of context is to store the user and or user roles making the request so
	// operations can authorize or log user operations.  See RESTCONF request filters for one
	// way to implement that.
	//
	// In addition, if you want to obtain a read-lock on your object that will be released in
	// Release when there are no more references to you object, this would be where to do that
	Context(sel *Selection) context.Context

	// Underlying object is no longer being references. Release read-lock if you obtained one
	// in call to Context
	Release(sel *Selection)
}

type NodeRequest struct {
	Selection *Selection
	New       bool
	Delete    bool
	Source    *Selection
	EditRoot  bool
}

type Notification struct {
	EventTime time.Time
	Event     *Selection
}

type NotifyCloser func() error

type NotifyFilterConstraint interface {
	CheckNotifyFilterConstraints(msg *Selection) (bool, error)
}

type NotifyRequest struct {
	Request
	Meta   *meta.Notification
	Stream NotifyStream
}

type NotifyStream func(n Notification)

type Path struct {
	Meta   meta.Definition
	Key    []val.Value
	Parent *Path
}

type PathMatchExpression struct {
	// contains filtered or unexported fields
}

type PathMatcher interface {
	PathMatches(base *Path, tail *Path) bool
}

type PathSlice struct {
	Head *Path
	Tail *Path
}

type Request struct {
	Selection *Selection

	// Path to meta item requested, including leaf requests
	Path *Path

	Target *Path
	Base   *Path
}

type Selection struct {

	// Browser that this selection ultimately spawned from
	Browser *Browser

	// Underlying node that implements management functions
	Node Node

	// Meta path in YANG module tied to this node
	Path *Path

	// Potentialy stores external data made available to all requests
	Context context.Context

	// Useful when navigating lists, True if this selector is List node, False if
	// this is for an item in List node.
	InsideList bool

	// Constraints hold list of things to check when walking or editing a node.
	Constraints *Constraints
	// contains filtered or unexported fields
}

type Trigger struct {

	// OnBegin will be called on the start of any edit. Return error to stop edit
	OnBegin TriggerFunc

	// OnEnd will be called at the end of any edit. Return error to mark edit as failed
	OnEnd TriggerFunc
	// contains filtered or unexported fields
}

type TriggerFunc func(t *Trigger, r NodeRequest) error

type TriggerTable struct {
	// contains filtered or unexported fields
}

type ValueHandle struct {

	// Readers do not set this, Writers will always have a valid value here
	Val val.Value
}

type Where struct {
	Filter string // XPath filter
	// contains filtered or unexported fields
}

type WithDefaults int