} else {
                file.update(stopwordsItem);
            }
        });
    }

    public void delete(final String dictId, final StopwordsItem stopwordsItem) {
        getStopwordsFile(dictId).ifPresent(file -> {
            file.delete(stopwordsItem);
        });
    }

            } else {
                file.update(synonymItem);
            }
        });
    }

    public void delete(final String dictId, final SynonymItem synonymItem) {
        getSynonymFile(dictId).ifPresent(file -> {
            file.delete(synonymItem);
        });
    }

    }

    // DELETE /api/admin/dict/mapping/setting/{dictId}/{id}
    @Execute
    public JsonResponse<ApiResult> delete$setting(final String dictId, final long id) {
        charMappingService.getCharMappingItem(dictId, id).ifPresent(entity -> {
            charMappingService.delete(dictId, entity);
            saveInfo(messages -> messages.addSuccessCrudDeleteCrudTable(GLOBAL));

    }

    // DELETE /api/admin/dict/stemmerOverride/setting/{dictId}/{id}
    @Execute
    public JsonResponse<ApiResult> delete$setting(final String dictId, final long id) {
        stemmerOverrideService.getStemmerOverrideItem(dictId, id).ifPresent(entity -> {
            stemmerOverrideService.delete(dictId, entity);

        final KuromojiItem kuromojiItem1 = itemList1.get(0);
        kuromojiFile.delete(kuromojiItem1);
        final PagingList<KuromojiItem> itemList2 = kuromojiFile.selectList(0,
                20);
        assertEquals(2, itemList2.size());

        final KuromojiItem kuromojiItem2 = itemList2.get(1);
        kuromojiFile.delete(kuromojiItem2);
        final PagingList<KuromojiItem> itemList3 = kuromojiFile.selectList(0,

            asyncImport(fileName, tempFile);
        } catch (final IOException e) {
            logger.warn("Failed to create a temp file.", e);
            if (tempFile.exists() && !tempFile.delete()) {
                logger.warn("Failed to delete {}.", tempFile.getAbsolutePath());
            }
            throwValidationError(messages -> messages.addErrorsFileIsNotSupported(GLOBAL, fileName), this::asListHtml);
        }

	if err != nil {
		err = msgp.WrapError(err, "Values")
		return
	}
	dst := *m
	if dst == nil {
		dst = make(map[string]string, zb0002)
	} else if len(dst) > 0 {
		for key := range dst {
			delete(dst, key)
		}
	}
	for zb0002 > 0 {
		var za0001 string
		var za0002 string
		zb0002--
		za0001, bts, err = msgp.ReadStringBytes(bts)
		if err != nil {
			err = msgp.WrapError(err, "Values")
			return

    void store(RESULT accessResult);

    void update(RESULT accessResult);

    void update(List<RESULT> accessResult);

    int getCount(String sessionId);

    void delete(String sessionId);

    void deleteAll();

    RESULT getAccessResult(String sessionId, String url);

    List<RESULT> getAccessResultList(String url, boolean hasData);

  // If true, only explicit op placements are accepted. If false, uses
  // type-based dispatch.
  bool strict_scope_placement;
};

struct LoggedTensor {
  TFE_TensorHandle* tensor;
  LoggedTensor() = delete;
  explicit LoggedTensor(TFE_TensorHandle* tensor) : tensor(tensor) {}
  ~LoggedTensor() { TFE_DeleteTensorHandle(tensor); }
};

int64_t LoggedTensorDim(void* data, int dim_index, TF_Status* status) {

            try {
                unregister(scheduledJob);
            } catch (final Exception e) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Failed to delete Job {}", scheduledJob, e);
                }
            }
            return;
        }

        final FessConfig fessConfig = ComponentUtil.getFessConfig();
        final CronParamsSupplier paramsOp = () -> {