pathgen

type CompressionInfo struct {
	// PreRelPath is the list of strings of qualified path elements prior
	// to the compressed-out node in Go list syntax.
	//
	// e.g. "openconfig-withlistval:atomic-lists", "openconfig-withlistval:atomic-lists-again"
	PreRelPathList string
	// PreRelPath is the list of strings of qualified path elements after
	// the compressed-out node in Go list syntax.
	PostRelPathList string
}

type ExtraGenerators struct {
	// StructFields are extra PathStruct fields to be generated.
	StructFields []Generator
	// StructInits are extra PathStruct initializers to be generated when
	// the PathStruct is created.
	StructInits []Generator
	// Extras are other free-form extra generated code to accompany a
	// particular PathStruct.
	Extras []Generator
}

type GenConfig struct {
	// CompressBehaviour determines whether the direct children of some
	// entries are omitted in the generated code for brevity. It also uses
	// a shortened naming convention for type names, including
	// enumeration/identityref names.
	//
	// Compress options are recommended when using OpenConfig-styled YANG,
	// and Uncompress* options otherwise.
	CompressBehaviour genutil.CompressBehaviour
	// PackageName is the name that should be used for the generating package.
	PackageName string
	// GoImports contains package import options.
	GoImports GoImports
	// ParseOptions specifies the options for how the YANG schema is
	// produced.
	ParseOptions ygen.ParseOpts
	// FakeRootName specifies the name of the struct that should be generated
	// representing the root.
	FakeRootName string
	// PathStructSuffix is the suffix to be appended to generated
	// PathStructs to distinguish them from the generated GoStructs, which
	// assume a similar name.
	PathStructSuffix string
	// SkipEnumDeduplication specifies whether leaves of type 'enumeration' that
	// are used in multiple places in the schema should share a common type within
	// the generated code that is output by ygen. By default (false), a common type
	// is used.
	// This is the same flag used by ygen: they must match for pathgen's
	// generated code to be compatible with it.
	SkipEnumDeduplication bool
	// ShortenEnumLeafNames removes the module name from the name of
	// enumeration leaves.
	// This is the same flag used by ygen: they must match for pathgen's
	// generated code to be compatible with it.
	ShortenEnumLeafNames bool
	// EnumOrgPrefixesToTrim trims the organization name from the module
	// part of the name of enumeration leaves if there is a match.
	EnumOrgPrefixesToTrim []string
	// UseDefiningModuleForTypedefEnumNames uses the defining module name
	// to prefix typedef enumerated types instead of the module where the
	// typedef enumerated value is used.
	// This is the same flag used by ygen: they must match for pathgen's
	// generated code to be compatible with it.
	UseDefiningModuleForTypedefEnumNames bool
	// AppendEnumSuffixForSimpleUnionEnums appends an "Enum" suffix to the
	// enumeration name for simple (i.e. non-typedef) leaves which are
	// unions with an enumeration inside. This makes all inlined
	// enumerations within unions, whether typedef or not, have this
	// suffix, achieving consistency.  Since this flag is planned to be a
	// v1 compatibility flag along with
	// UseDefiningModuleForTypedefEnumNames, and will be removed in v1, it
	// only applies when useDefiningModuleForTypedefEnumNames is also set
	// to true.
	AppendEnumSuffixForSimpleUnionEnums bool
	// GeneratingBinary is the name of the binary calling the generator library, it is
	// included in the header of output files for debugging purposes. If a
	// string is not specified, the location of the library is utilised.
	GeneratingBinary string
	// GenerateWildcardPaths means to generate wildcard nodes and paths.
	GenerateWildcardPaths bool
	// SplitByModule controls whether to generate a go package for each yang module.
	SplitByModule bool
	// TrimPackageModulePrefix is the prefix to trim from generated go package names.
	TrimPackageModulePrefix string
	// BasePackagePath is used to create to full import path of the generated go packages.
	BasePackagePath string
	// PackageString is the string to apppend to the generated Go package names.
	PackageSuffix string
	// UnifyPathStructs controls whether to generate both config and states in the same package.
	UnifyPathStructs bool
	// ExtraGenerators are custom funcs that are used to extend the path struct generation.
	ExtraGenerators ExtraGenerators
	// IgnoreAtomicLists disables the following default behaviours:
	//  - All compressed lists will have a new accessor <ListName>Map() that
	//  retrieves the whole list.
	//  - Any child underneath lists whose compressed-out parent container
	//  is marked "telemetry-atomic" are no longer reachable.
	//  - lists marked `ordered-by user` will be represented using built-in Go maps
	//  instead of an ordered map Go structure.
	IgnoreAtomicLists bool
	// IgnoreAtomic avoids generating any descendants where a
	// non-compressed-out list or container is marked "telemetry-atomic".
	IgnoreAtomic bool
	// SplitPackagePaths specifies the prefix paths at or below which symbols will
	// reside in the provided package. The mapped string is the custom name for
	// the package (optional).
	SplitPackagePaths map[string]string
	//UseModuleNameAsPathOrigin uses the YANG module name to the origin for generated gNMI paths.
	UseModuleNameAsPathOrigin bool
	//PathOriginName specifies the origin name for generated gNMI paths.
	PathOriginName string
}

type GeneratedPathCode struct {
	Structs      []GoPathStructCodeSnippet // Structs is the generated set of structs representing containers or lists in the input YANG models.
	CommonHeader string                    // CommonHeader is the header that should be used for all output Go files.
	Deps         map[string]bool           // Deps is the list of packages that this package depends on.
}

type Generator func(string, string, genutil.CompressBehaviour, *ygen.ParsedDirectory, *NodeData, bool) (string, error)

type GoImports struct {
	// SchemaStructPkgPath specifies the path to the ygen-generated structs, which
	// is used to get the enum and union type names used as the list key
	// for calling a list path accessor.
	SchemaStructPkgPath string
	// YgotImportPath specifies the path to the ygot library that should be used
	// in the generated code.
	YgotImportPath string
	// YtypesImportPath specifies the path to the ytypes library that should be used
	// in the generated code.
	YtypesImportPath string
	// YgnmiImportPath is the import path to the ygnmi library that should be used
	// in the generated code.
	YgnmiImportPath string
}

type GoPathStructCodeSnippet struct {
	// PathStructName is the name of the struct that is contained within the snippet.
	// It is stored such that callers can identify the struct to control where it
	// is output.
	PathStructName string
	// StructBase stores the basic code snippet that represents the struct that is
	// the input when code generation is performed, which includes its definition.
	StructBase string
	// ChildConstructors contains the method code snippets with the input struct as a
	// receiver, that is used to get the child path struct.
	ChildConstructors string
	// Package is the name of the package that this snippet belongs to.
	Package string
	// Deps are any packages that this snippet depends on.
	Deps []string
	// ExtraGeneration is the output of any extra generators passed into GenConfig.
	ExtraGeneration string
}

type NodeData struct {
	// GoTypeName is the generated Go type name of a schema node. It is
	// qualified by the SchemaStructPkgAlias if necessary. It could be a
	// GoStruct or a leaf type.
	GoTypeName string
	// LocalGoTypeName is the generated Go type name of a schema node, but
	// always with the SchemaStructPkgAlias stripped. It could be a
	// GoStruct or a leaf type.
	LocalGoTypeName string
	// GoFieldName is the field name of the node under its parent struct.
	GoFieldName string
	// SubsumingGoStructName is the GoStruct type name corresponding to the node. If
	// the node is a leaf, then it is the parent GoStruct's name.
	SubsumingGoStructName string
	// IsLeaf indicates whether this child is a leaf node.
	IsLeaf bool
	// IsScalarField indicates a leaf that is stored as a pointer in its
	// parent struct.
	IsScalarField bool
	// IsListContainer indicates that the node represents the  container
	// surrounding a list.
	IsListContainer bool
	// HasDefault indicates whether this node has a default value
	// associated with it. This is only relevant to leaf or leaf-list
	// nodes.
	HasDefault bool
	// YANGTypeName is the type of the leaf given in the YANG file (without
	// the module prefix, if any, per goyang behaviour). If the node is not
	// a leaf this will be empty. Note that the current purpose for this is
	// to allow callers to handle certain types as special cases, but since
	// the name of the node is a very basic piece of information which
	// excludes the defining module, this is somewhat hacky, so it may be
	// removed or modified in the future.
	YANGTypeName string
	// YANGPath is the schema path of the YANG node.
	YANGPath string
	// GoPathPackageName is the Go package name containing the generated PathStruct for the schema node.
	GoPathPackageName string
	// YANGFieldName is the name of the field entry for this node, only set for leaves.
	YANGFieldName string
	// Directory is the name of the directory used to create this node. For leaves, it's the parent directory.
	DirectoryName string
	// CompressInfo contains information about a compressed path element for a node
	// which points to a path element that's compressed out.
	CompressInfo *CompressionInfo
	// ConfigFalse indicates whether the node is "config false" or "config
	// true" in its YANG schema definition.
	ConfigFalse bool
	// PathOriginName is the name of the origin for this node.
	PathOriginName string
}

type NodeDataMap map[string]*NodeData