}
        return getLastEntry().element;
    }

    /**
     * 最初のエントリを返します。
     *
     * @return 最初のエントリ
     */
    public Entry getFirstEntry() {
        if (isEmpty()) {
            return null;
        }
        return header.next;
    }

    /**
     * 最後のエントリを返します。
     *
     * @return 最後のエントリ
     */
    public Entry getLastEntry() {
        if (isEmpty()) {

        if (StringUtil.isBlank(size)) {
            return SearchLogPager.DEFAULT_PAGE_SIZE;
        }
        try {
            final int value = Integer.parseInt(size);
            if (value <= 0 || value > ComponentUtil.getFessConfig().getPageSearchlogMaxFetchSizeAsInteger()) {
                return SearchLogPager.DEFAULT_PAGE_SIZE;
            }
            return value;
        } catch (final NumberFormatException e) {

    map.put("three", 3);
    return SerializableTester.reserialize(map);
  }

  @Override
  protected SortedMap<String, Integer> makeEmptyMap() throws UnsupportedOperationException {
    NavigableMap<String, Integer> map = new SafeTreeMap<>();
    return SerializableTester.reserialize(map);
  }

  @Override
  protected String getKeyNotInPopulatedMap() {
    return "minus one";
  }

  @Override

    private static final long serialVersionUID = 1L;

    public String getId() {
        return asDocMeta().id();
    }

    public void setId(final String id) {
        asDocMeta().id(id);
    }

    public Long getVersionNo() {
        return asDocMeta().version();
    }

    public void setVersionNo(final Long version) {
        asDocMeta().version(version);
    }

    public String normalize(final String enc) {
        if (StringUtil.isBlank(enc)) {
            return defaultEncoding;
        }

        final String newEnc = encodingMap.get(toLowerCase(enc));
        if (StringUtil.isBlank(newEnc)) {
            return enc;
        }
        return newEnc;
    }

    public void setDefaultEncoding(final String defaultEncoding) {

            return convertPrefixQuery(fessConfig, context, termQuery, boost, field, text);
        }
        if (DEFAULT_FIELD.equals(field)) {
            return convertDefaultTermQuery(fessConfig, context, termQuery, boost, field, text);
        }
        if (SORT_FIELD.equals(field)) {
            return convertSortQuery(fessConfig, context, termQuery, boost, field, text);
        }

      return standardCeiling(e);
    }

    @Override
    public @Nullable T higher(T e) {
      return standardHigher(e);
    }

    @Override
    public @Nullable T pollFirst() {
      return standardPollFirst();
    }

    @Override
    public @Nullable T pollLast() {
      return standardPollLast();
    }

    @Override
    public SortedSet<T> headSet(T toElement) {

        return new TreeSet<E>(contents);
      }
    },
    UnmodifiableSetImpl {
      @Override
      public <E extends Comparable<E>> Set<E> create(Collection<E> contents) {
        return unmodifiableSet(new HashSet<E>(contents));
      }
    },
    SynchronizedSetImpl {
      @Override
      public <E extends Comparable<E>> Set<E> create(Collection<E> contents) {

                    log.debug("Have: " + Hexdump.toHexString(data, offset + SmbConstants.SIGNATURE_OFFSET, 8));
                }
                return true;
            }
        }

        return false;
    }


    @Override
    public String toString () {
        return "MacSigningKey=" + Hexdump.toHexString(this.macSigningKey, 0, this.macSigningKey.length);
    }


    /**
     * 

        if (session.isIgnoreArtifactDescriptorRepositories()) {
            return;
        }

        if (!repositoryIds.add(repository.getId())) {
            if (!replace) {
                return;
            }

            removeMatchingRepository(repositories, repository.getId());
        }