this.nodeType = nodeType;
    }


    NbtAddress ( Name hostName, int address, boolean groupName, int nodeType, boolean isBeingDeleted, boolean isInConflict, boolean isActive,
            boolean isPermanent, byte[] macAddress ) {

        /*
         * The NodeStatusResponse.readNodeNameArray method may also set this
         * information. These two places where node status data is populated should

    private List<String> header;
    private List<String> footer;
    private Path location;
    private Function<String, String> callback;
    boolean substitute = true;
    boolean typed;

    public MavenProperties() {}

    public MavenProperties(Path location) throws IOException {
        this(location, null);
    }

    private Model fileModel;

    private Path pomPath;

    private ModelSource modelSource;

    private int validationLevel = VALIDATION_LEVEL_STRICT;

    private boolean processPlugins;

    private boolean twoPhaseBuilding;

    private boolean locationTracking;

    private List<Profile> profiles;

    private List<String> activeProfileIds;

    private List<String> inactiveProfileIds;

  @Override
  public Set<E> elementSet() {
    return delegate().elementSet();
  }

  @Override
  public Set<Entry<E>> entrySet() {
    return delegate().entrySet();
  }

  @Override
  public boolean equals(@CheckForNull Object object) {
    return object == this || delegate().equals(object);
  }

  @Override
  public int hashCode() {
    return delegate().hashCode();
  }

  @CanIgnoreReturnValue

        return getNegotiatedMpxCount();
    }


    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.SmbNegotiationResponse#canReuse(jcifs.CIFSContext, boolean)
     */
    @Override
    public boolean canReuse ( CIFSContext tc, boolean forceSigning ) {
        return this.getConfig().equals(tc.getConfig());
    }


    /**
     * @return the dialectIndex
     */

      E fromElement, boolean fromInclusive, E toElement, boolean toInclusive) {
    return tailSetImpl(fromElement, fromInclusive).headSetImpl(toElement, toInclusive);
  }

  @Override
  ImmutableSortedSet<E> tailSetImpl(E fromElement, boolean inclusive) {
    return getSubSet(tailIndex(fromElement, inclusive), size());
  }

  int tailIndex(E fromElement, boolean inclusive) {

      "scriptType": {
        "type": "keyword"
      },
      "scriptData": {
        "type": "keyword"
      },
      "crawler": {
        "type": "boolean"
      },
      "jobLogging": {
        "type": "boolean"
      },
      "available": {
        "type": "boolean"
      },
      "sortOrder": {
        "type": "integer"
      },
      "createdBy": {
        "type": "keyword"
      },
      "createdTime": {

 * @param <E>
 *            要素の型
 */
public class SingleValueIterator<E> implements Iterator<E> {

    /** 反復子が返す唯一の値 */
    protected final E value;

    /** 反復子がさらに要素を持つ場合は{@literal true} */
    protected boolean hasNext = true;

    /**
     * for each構文で使用するために{@link SingleValueIterator}をラップした{@link Iterable}を返します。
     *
     * @param <E>
     *            要素の型
     * @param value
     *            反復子が返す唯一の値

    /**
     * Not exactly sure what that is all about, certainly legacy stuff
     * 
     * @return resolveHashes
     */
    boolean isResolveHashes ();


    /**
     * @return whether this refrral needs to be resolved further
     */
    boolean isIntermediate ();


    /**
     * @param next
     * @return new referral, combining a chain of referrals
     */

        }
        return elements;
    }

    public void appendChild(String text) {
        appendChild(document.createTextNode(text));
    }

    public void appendChild(Node node) {
        boolean inPara = false;
        if (node instanceof Element) {
            Element element = (Element) node;
            if (element.getTagName().equals("para") && stack.getFirst().getTagName().equals("para")) {
                pop();