{
                RepositoryBase other =  (RepositoryBase) obj;

                boolean retValue = false;

                if ( id != null )
                {
                    retValue = id.equals( other.id );
                }

                return retValue;
            }
          ]]></code>
        </codeSegment>
      </codeSegments>
    </class>
    <class>

                if ((arg.equals("--module-path") || arg.equals("-p")) && (i + 1) < compileOptions.getCompilerArgs().size()) {
                    Object argValue = compileOptions.getCompilerArgs().get(++i);
                    String[] modules = argValue.toString().split(File.pathSeparator);
                    modulePaths.addAll(Arrays.asList(modules));
                } else if (arg.startsWith("--module-path=")) {

        - enumValue
        example: exampleValue
        exclusiveMaximum: true
        exclusiveMinimum: true
        externalDocs:
          description: descriptionValue
          url: urlValue
        format: formatValue
        id: idValue
        items:
        - {}
        maxItems: 16
        maxLength: 13
        maxProperties: 21
        maximum: 9.5
        minItems: 17
        minLength: 14

			window = time.Duration(*m.WindowSeconds) * time.Second
		}
		res[m.DescribedObject.Name] = PodMetric{
			Timestamp: m.Timestamp.Time,
			Window:    window,
			Value:     int64(m.Value.MilliValue()),
		}

		m.Value.MilliValue()
	}

	timestamp := metrics.Items[0].Timestamp.Time

	return res, timestamp, nil
}

	regKey, err := registry.OpenKey(registry.LOCAL_MACHINE, reg, registry.QUERY_VALUE)
	if err != nil {
		return "", err
	}
	defer regKey.Close()

	regValue, _, err := regKey.GetStringValue(key)
	return regValue, err
}

// getDNSSuffixList reads DNS config file and returns the list of configured DNS suffixes
func getDNSSuffixList() ([]string, error) {

      enum:
      - enumValue
      example: exampleValue
      exclusiveMaximum: true
      exclusiveMinimum: true
      externalDocs:
        description: descriptionValue
        url: urlValue
      format: formatValue
      id: idValue
      items:
      - {}
      maxItems: 16
      maxLength: 13
      maxProperties: 21
      maximum: 9.5
      minItems: 17
      minLength: 14
      minProperties: 22

			opt := cmdOption{
				flag.Name,
				flag.Shorthand,
				flag.DefValue,
				forceMultiLine(flag.Usage),
			}
			result = append(result, opt)
		} else {
			opt := cmdOption{
				Name:         flag.Name,
				DefaultValue: forceMultiLine(flag.DefValue),
				Usage:        forceMultiLine(flag.Usage),
			}
			result = append(result, opt)
		}
	})

	regKey, err := registry.OpenKey(registry.LOCAL_MACHINE, bootIdRegistry, registry.READ)
	if err != nil {
		return "", err
	}
	defer regKey.Close()
	regValue, _, err := regKey.GetIntegerValue(bootIdKey)
	if err != nil {
		return "", err
	}
	return strconv.FormatUint(regValue, 10), nil

	}
}

// TypedToObject transforms the typed value into a runtime.Object. That
// is not specific to deduced type.
func (deducedTypeConverter) TypedToObject(value *typed.TypedValue) (runtime.Object, error) {
	return valueToObject(value.AsValue())
}

func valueToObject(val value.Value) (runtime.Object, error) {
	vu := val.Unstructured()
	switch o := vu.(type) {

		if !(len(flag.ShorthandDeprecated) > 0) && len(flag.Shorthand) > 0 {
			format = "**-%s**, " + format
			fmt.Fprintf(out, format, flag.Shorthand, flag.Name, flag.DefValue, flag.Usage)
		} else {
			fmt.Fprintf(out, format, flag.Name, flag.DefValue, flag.Usage)
		}
	})
}

func printOptions(out *bytes.Buffer, command *cobra.Command) {
	flags := command.NonInheritedFlags()
	if flags.HasFlags() {