}
        return getLastEntry().element;
    }

    /**
     * Returns the first entry.
     *
     * @return the first entry
     */
    public Entry getFirstEntry() {
        if (isEmpty()) {
            return null;
        }
        return header.next;
    }

    /**
     * Returns the last entry.
     *
     * @return the last entry
     */

	err := val.Decode(&tmp)
	if err != nil {
		return err
	}
	*kv = BatchJobKV(tmp)
	kv.line, kv.col = val.Line, val.Column
	return nil
}

// Validate returns an error if key is empty
func (kv BatchJobKV) Validate() error {
	if kv.Key == "" {
		return BatchJobYamlErr{
			line: kv.line,
			col:  kv.col,
			msg:  "key can't be empty",
		}
	}
	return nil
}

// Empty indicates if kv is not set

    @Override
    public int size() {
      return parent.length();
    }

    @Override
    public Long get(int index) {
      return parent.get(index);
    }

    @Override
    public boolean contains(@Nullable Object target) {
      return indexOf(target) >= 0;
    }

    @Override
    public int indexOf(@Nullable Object target) {

    if (object == this) {
      return true;
    }
    if (!(object instanceof ImmutableIntArray)) {
      return false;
    }
    ImmutableIntArray that = (ImmutableIntArray) object;
    if (this.length() != that.length()) {
      return false;
    }
    for (int i = 0; i < length(); i++) {
      if (this.get(i) != that.get(i)) {
        return false;
      }
    }
    return true;
  }

                return post();
            }
            return get();
        }

        /**
         * Sets the HTTP method for the request.
         * @param method The HTTP method.
         * @return The current RequestDataContext instance.
         */
        public RequestDataContext method(final Method method) {
            data.setMethod(method);
            return this;
        }

        /**

        return Arrays.copyOf(fileId, 16);
    }

    /**
     * Get the handle type
     * @return the handle type
     */
    public HandleType getType() {
        return type;
    }

    /**
     * Get the timeout
     * @return the timeout in milliseconds
     */
    public long getTimeout() {
        return timeout;
    }

    /**
     * Get the create time

                return false;
            }
        } else if (!value3.equals(other.value3)) {
            return false;
        }
        if (value4 == null) {
            if (other.value4 != null) {
                return false;
            }
        } else if (!value4.equals(other.value4)) {
            return false;
        }
        return true;
    }

  }

  /**
   * Used by tests that require a map, but don't care whether it's populated or not.
   *
   * @return a new map instance.
   */
  protected Map<K, V> makeEitherMap() {
    try {
      return makePopulatedMap();
    } catch (UnsupportedOperationException e) {
      return makeEmptyMap();
    }
  }

  @SuppressWarnings("CatchingUnchecked") // sneaky checked exception

	if objectAPI == nil {
		return
	}

	if GlobalKMS == nil {
		writeErrorResponseJSON(ctx, w, errorCodes.ToAPIErr(ErrKMSNotConfigured), r.URL)
		return
	}

	stat, err := GlobalKMS.Status(ctx)
	if err != nil {
		writeCustomErrorResponseJSON(ctx, w, errorCodes.ToAPIErr(ErrInternalError), err.Error(), r.URL)
		return
	}
	resp, err := json.Marshal(stat)
	if err != nil {

        public long getTotalValidations() {
            return totalValidations;
        }

        public long getFailedValidations() {
            return failedValidations;
        }

        public long getBufferOverflowsPrevented() {
            return bufferOverflowsPrevented;
        }

        public long getIntegerOverflowsPrevented() {
            return integerOverflowsPrevented;
        }