@@ -73,6 +73,7 @@ type UnionUnsupported struct {
7373type Model struct {
7474 MultiKey map[Model_MultiKey_Key]*Model_MultiKey `path:"b/multi-key" module:"openconfig-withlist/openconfig-withlist"`
7575 SingleKey map[string]*Model_SingleKey `path:"a/single-key" module:"openconfig-withlist/openconfig-withlist"`
76+ SingleKeyOrdered *Model_SingleKeyOrdered_OrderedMap `path:"c/single-key-ordered" module:"openconfig-withlist/openconfig-withlist"`
7677}
7778
7879// IsYANGGoStruct ensures that Model implements the yang.GoStruct
@@ -196,6 +197,165 @@ func (t *Model) RenameSingleKey(oldK, newK string) error {
196197 return nil
197198}
198199
200+ // AppendNewSingleKeyOrdered creates a new entry in the SingleKeyOrdered
201+ // ordered map of the Model struct. The keys of the list are
202+ // populated from the input arguments.
203+ func (s *Model) AppendNewSingleKeyOrdered(Key string) (*Model_SingleKeyOrdered, error) {
204+ if s.SingleKeyOrdered == nil {
205+ s.SingleKeyOrdered = &Model_SingleKeyOrdered_OrderedMap{}
206+ }
207+ return s.SingleKeyOrdered.AppendNew(Key)
208+ }
209+
210+ // AppendSingleKeyOrdered appends the supplied Model_SingleKeyOrdered struct
211+ // to the list SingleKeyOrdered of Model. If the key value(s)
212+ // specified in the supplied Model_SingleKeyOrdered already exist in the list, an
213+ // error is returned.
214+ func (s *Model) AppendSingleKeyOrdered(v *Model_SingleKeyOrdered) error {
215+ if s.SingleKeyOrdered == nil {
216+ s.SingleKeyOrdered = &Model_SingleKeyOrdered_OrderedMap{}
217+ }
218+ return s.SingleKeyOrdered.Append(v)
219+ }
220+
221+ // GetSingleKeyOrdered retrieves the value with the specified key from the
222+ // SingleKeyOrdered map field of Model. If the receiver
223+ // is nil, or the specified key is not present in the list, nil is returned
224+ // such that Get* methods may be safely chained.
225+ func (s *Model) GetSingleKeyOrdered(Key string) *Model_SingleKeyOrdered {
226+ key := Key
227+ return s.SingleKeyOrdered.Get(key)
228+ }
229+
230+ // DeleteSingleKeyOrdered deletes the value with the specified keys from
231+ // the receiver Model. If there is no such element, the
232+ // function is a no-op.
233+ func (s *Model) DeleteSingleKeyOrdered(Key string) bool {
234+ key := Key
235+ return s.SingleKeyOrdered.Delete(key)
236+ }
237+
238+ // Model_SingleKeyOrdered_OrderedMap is an ordered map that represents the "ordered-by user"
239+ // list elements at /openconfig-withlist/model/c/single-key-ordered.
240+ type Model_SingleKeyOrdered_OrderedMap struct {
241+ keys []string
242+ valueMap map[string]*Model_SingleKeyOrdered
243+ }
244+
245+ // IsYANGOrderedList ensures that Model_SingleKeyOrdered_OrderedMap implements the
246+ // ygot.GoOrderedMap interface.
247+ func (*Model_SingleKeyOrdered_OrderedMap) IsYANGOrderedList() {}
248+
249+ // init initializes any uninitialized values.
250+ func (o *Model_SingleKeyOrdered_OrderedMap) init() {
251+ if o == nil {
252+ return
253+ }
254+ if o.valueMap == nil {
255+ o.valueMap = map[string]*Model_SingleKeyOrdered{}
256+ }
257+ }
258+
259+ // Keys returns a copy of the list's keys.
260+ func (o *Model_SingleKeyOrdered_OrderedMap) Keys() []string {
261+ if o == nil {
262+ return nil
263+ }
264+ return append([]string{}, o.keys...)
265+ }
266+
267+ // Values returns the current set of the list's values in order.
268+ func (o *Model_SingleKeyOrdered_OrderedMap) Values() []*Model_SingleKeyOrdered {
269+ if o == nil {
270+ return nil
271+ }
272+ var values []*Model_SingleKeyOrdered
273+ for _, key := range o.keys {
274+ values = append(values, o.valueMap[key])
275+ }
276+ return values
277+ }
278+
279+ // Len returns a size of Model_SingleKeyOrdered_OrderedMap
280+ func (o *Model_SingleKeyOrdered_OrderedMap) Len() int {
281+ if o == nil {
282+ return 0
283+ }
284+ return len(o.keys)
285+ }
286+
287+ // Get returns the value corresponding to the key. If the key is not found, nil
288+ // is returned.
289+ func (o *Model_SingleKeyOrdered_OrderedMap) Get(key string) *Model_SingleKeyOrdered {
290+ if o == nil {
291+ return nil
292+ }
293+ val, _ := o.valueMap[key]
294+ return val
295+ }
296+
297+ // Delete deletes an element.
298+ func (o *Model_SingleKeyOrdered_OrderedMap) Delete(key string) bool {
299+ if o == nil {
300+ return false
301+ }
302+ if _, ok := o.valueMap[key]; !ok {
303+ return false
304+ }
305+ for i, k := range o.keys {
306+ if k == key {
307+ o.keys = append(o.keys[:i], o.keys[i+1:]...)
308+ delete(o.valueMap, key)
309+ return true
310+ }
311+ }
312+ return false
313+ }
314+
315+ // Append appends a Model_SingleKeyOrdered, returning an error if the key
316+ // already exists in the ordered list or if the key is unspecified.
317+ func (o *Model_SingleKeyOrdered_OrderedMap) Append(v *Model_SingleKeyOrdered) error {
318+ if o == nil {
319+ return fmt.Errorf("nil ordered map, cannot append Model_SingleKeyOrdered")
320+ }
321+ if v == nil {
322+ return fmt.Errorf("nil Model_SingleKeyOrdered")
323+ }
324+ if v.Key == nil {
325+ return fmt.Errorf("invalid nil key received for Key")
326+ }
327+
328+ key := *v.Key
329+
330+ if _, ok := o.valueMap[key]; ok {
331+ return fmt.Errorf("duplicate key for list Statement %v", key)
332+ }
333+ o.keys = append(o.keys, key)
334+ o.init()
335+ o.valueMap[key] = v
336+ return nil
337+ }
338+
339+ // AppendNew creates and appends a new Model_SingleKeyOrdered, returning the
340+ // newly-initialized v. It returns an error if the v already exists.
341+ func (o *Model_SingleKeyOrdered_OrderedMap) AppendNew(Key string) (*Model_SingleKeyOrdered, error) {
342+ if o == nil {
343+ return nil, fmt.Errorf("nil ordered map, cannot append Model_SingleKeyOrdered")
344+ }
345+ key := Key
346+
347+ if _, ok := o.valueMap[key]; ok {
348+ return nil, fmt.Errorf("duplicate key for list Statement %v", key)
349+ }
350+ o.keys = append(o.keys, key)
351+ newElement := &Model_SingleKeyOrdered{
352+ Key: &Key,
353+ }
354+ o.init()
355+ o.valueMap[key] = newElement
356+ return newElement, nil
357+ }
358+
199359// ΛBelongingModule returns the name of the module that defines the namespace
200360// of Model.
201361func (*Model) ΛBelongingModule() string {
@@ -261,3 +421,30 @@ func (t *Model_SingleKey) ΛListKeyMap() (map[string]interface{}, error) {
261421func (*Model_SingleKey) ΛBelongingModule() string {
262422 return "openconfig-withlist"
263423}
424+
425+ // Model_SingleKeyOrdered represents the /openconfig-withlist/model/c/single-key-ordered YANG schema element.
426+ type Model_SingleKeyOrdered struct {
427+ Key *string `path:"state/key|key" module:"openconfig-withlist/openconfig-withlist|openconfig-withlist"`
428+ }
429+
430+ // IsYANGGoStruct ensures that Model_SingleKeyOrdered implements the yang.GoStruct
431+ // interface. This allows functions that need to handle this struct to
432+ // identify it as being generated by ygen.
433+ func (*Model_SingleKeyOrdered) IsYANGGoStruct() {}
434+
435+ // ΛListKeyMap returns the keys of the Model_SingleKeyOrdered struct, which is a YANG list entry.
436+ func (t *Model_SingleKeyOrdered) ΛListKeyMap() (map[string]interface{}, error) {
437+ if t.Key == nil {
438+ return nil, fmt.Errorf("nil value for key Key")
439+ }
440+
441+ return map[string]interface{}{
442+ "key": *t.Key,
443+ }, nil
444+ }
445+
446+ // ΛBelongingModule returns the name of the module that defines the namespace
447+ // of Model_SingleKeyOrdered.
448+ func (*Model_SingleKeyOrdered) ΛBelongingModule() string {
449+ return "openconfig-withlist"
450+ }
0 commit comments