}
    }


    /**
     * Update digest with data
     * 
     * @param input
     * @param offset
     * @param len
     */
    public void update ( byte[] input, int offset, int len ) {
        if ( log.isTraceEnabled() ) {
            log.trace("update: " + this.updates + " " + offset + ":" + len);

                if (!Constants.TRUE.equalsIgnoreCase(contentMap.get("acknowledged").toString())) {
                    throw new DictionaryException("Failed to update " + dictFile.getPath());
                }
            } catch (final IOException e) {
                throw new DictionaryException("Failed to update " + dictFile.getPath(), e);
            }

        }).orElse(() -> {

        kuromojiItem1.setNewToken("TOKEN1");
        kuromojiItem1.setNewSegmentation("SEG1");
        kuromojiItem1.setNewReading("READING1");
        kuromojiItem1.setNewPos("POS1");
        kuromojiFile.update(kuromojiItem1);
        final PagingList<KuromojiItem> itemList2 = kuromojiFile.selectList(0,
                20);
        assertEquals(3, itemList2.size());
        final KuromojiItem kuromojiItem2 = itemList2.get(0);

    }

    @Override
    public ActionFuture<UpdateResponse> update(final UpdateRequest request) {
        return client.update(request);
    }

    @Override
    public void update(final UpdateRequest request, final ActionListener<UpdateResponse> listener) {
        client.update(request, listener);
    }

    @Override
    public UpdateRequestBuilder prepareUpdate() {

        indexingHelper.deleteDocumentsByDocId(client, docList);
        assertEquals("fess.update", resultMap.get("index"));
        assertEquals(0, ((List<String>) resultMap.get("ids")).size());

        docList.add("001");
        indexingHelper.deleteDocumentsByDocId(client, docList);
        assertEquals("fess.update", resultMap.get("index"));
        assertEquals(1, ((List<String>) resultMap.get("ids")).size());

            final int size = accessResultList.size();
            dataService.update(accessResultList);
            accessResultList.clear();
            final long time = systemHelper.getCurrentTimeAsLong() - execTime;
            if (logger.isDebugEnabled()) {
                logger.debug("Updated {} access results. The execution time is {}ms.", size, time);
            }
            return time;
        }

                if (searchEngineClient.copyDocIndex(fromIndex, toIndex, replaceAliases) && replaceAliases
                        && !searchEngineClient.updateAlias(toIndex)) {
                    logger.warn("Failed to update aliases for {} and {}", fromIndex, toIndex);
                }
            }, e -> logger.warn("Failed to reindex from {} to {}", fromIndex, toIndex, e)));
            return true;
        }

import org.opensearch.action.index.IndexResponse;
import org.opensearch.action.search.SearchRequestBuilder;
import org.opensearch.action.search.SearchResponse;
import org.opensearch.action.update.UpdateRequestBuilder;
import org.opensearch.client.Client;
import org.opensearch.core.action.ActionListener;
import org.opensearch.index.seqno.SequenceNumbers;
import org.opensearch.search.SearchHit;

            final PagingList<StopwordsItem> stopwordsList =
                    file.selectList((stopwordsPager.getCurrentPageNumber() - 1) * pageSize, pageSize);

            // update pager
            BeanUtil.copyBeanToBean(stopwordsList, stopwordsPager, option -> option.include(Constants.PAGER_CONVERSION_RULE));
            stopwordsList.setPageRangeSize(fessConfig.getPagingPageRangeSizeAsInteger());

            final int pageSize = synonymPager.getPageSize();
            final PagingList<SynonymItem> synonymList = file.selectList((synonymPager.getCurrentPageNumber() - 1) * pageSize, pageSize);

            // update pager
            BeanUtil.copyBeanToBean(synonymList, synonymPager, option -> option.include(Constants.PAGER_CONVERSION_RULE));
            synonymList.setPageRangeSize(fessConfig.getPagingPageRangeSizeAsInteger());