return nil, err
	}
	if ret.Mode != "" && !ret.Mode.Valid() {
		return &ret, ErrUnknownWORMModeDirective
	}

	if ret.Mode.Valid() && ret.RetainUntilDate.IsZero() {
		return &ret, ErrMalformedXML
	}

	if !ret.Mode.Valid() && !ret.RetainUntilDate.IsZero() {
		return &ret, ErrMalformedXML
	}

	t, err := UTCNowNTP()
	if err != nil {

    }
    public int getErrorCode() {
        return error;
    }
    public Throwable getRootCause() {
        return rootCause;
    }
    public String toString() {
        if (rootCause != null) {
            StringWriter sw = new StringWriter();
            PrintWriter pw = new PrintWriter(sw);
            rootCause.printStackTrace(pw);
            return super.toString() + "\n" + sw;
        }

        if (!external) {
            disableExternalResources(schemaFactory);
        }
        return schemaFactory;
    }

    /**
     * RELAX NGのための{@link SchemaFactory}を生成します。
     *
     * @return RELAX NGのための{@link SchemaFactory}
     */
    public static SchemaFactory newRelaxNgSchemaFactory() {
        return newRelaxNgSchemaFactory(false);
    }

    return ordering.compare(function.apply(left), function.apply(right));
  }

  @Override
  public boolean equals(@CheckForNull Object object) {
    if (object == this) {
      return true;
    }
    if (object instanceof ByFunctionOrdering) {
      ByFunctionOrdering<?, ?> that = (ByFunctionOrdering<?, ?>) object;

    if (cmp < 0) {
      return aggregateBelowRange(aggr, node.left);
    } else if (cmp == 0) {
      switch (range.getLowerBoundType()) {
        case OPEN:
          return aggr.nodeAggregate(node) + aggr.treeAggregate(node.left);
        case CLOSED:
          return aggr.treeAggregate(node.left);
      }
      throw new AssertionError();
    } else {
      return aggr.treeAggregate(node.left)

func (n NSQArgs) Validate() error {
	if !n.Enable {
		return nil
	}

	if n.NSQDAddress.IsEmpty() {
		return errors.New("empty nsqdAddress")
	}

	if n.Topic == "" {
		return errors.New("empty topic")
	}
	if n.QueueDir != "" {
		if !filepath.IsAbs(n.QueueDir) {
			return errors.New("queueDir path should be absolute")
		}
	}

	return nil
}

// NSQTarget - NSQ target.
type NSQTarget struct {

		fmt.Fprintf(w, "%s\t%s\t%v\n", flag, viper.GetString(flag), configSource(flag, v))
	}
	return w.Flush()
}

func configSource(flag string, v env.VariableInfo) string {
	// Environment variables have high precedence in Viper
	if v.IsSet() {
		return "$" + v.GetName()
	}

	if viper.InConfig(flag) {
		return root.IstioConfig
	}

	return "default"

     *  @param expression A valid XPath string.
     *  @return A XPathNodes, should never be null.
     *
     * @throws XPathExpressionException
     */
    public XPathNodes selectNodeList(final Node contextNode, final String expression) throws XPathExpressionException {
        return xPath.evaluateExpression(expression, contextNode, XPathNodes.class);
    }

    /**

            return false;
        } else if (!a.getArtifactId().equals(getArtifactId())) {
            return false;
        } else if (!a.getVersion().equals(getVersion())) {
            return false;
        } else if (!a.getType().equals(getType())) {
            return false;
        } else {
            return a.getClassifier() == null
                    ? getClassifier() == null

     */
    @Override
    public final long getLastAccessTime () {
        return this.lastAccessTime;
    }


    /**
     * @return the lastWriteTime
     */
    @Override
    public final long getLastWriteTime () {
        return this.lastWriteTime;
    }


    /**
     * @return the changeTime
     */
    public final long getChangeTime () {