private static final Logger logger = LogManager.getLogger(DataStoreFactory.class);

    /**
     * Map containing registered data store instances indexed by their names and class simple names.
     * All keys are stored in lowercase for case-insensitive lookup.
     */
    protected Map<String, DataStore> dataStoreMap = new LinkedHashMap<>();

    /**

   * the discussion in the {@link #addListener} documentation. All its warnings about heavyweight
   * listeners are also applicable to heavyweight functions passed to this method.
   *
   * <p>This method is similar to {@link java.util.concurrent.CompletableFuture#exceptionally}. It
   * can also serve some of the use cases of {@link java.util.concurrent.CompletableFuture#handle}

     * @param simpleMessage
     *            Simple message with arguments expanded
     * @return Message with message code
     */
    public static String getFormattedMessage(final String messageCode, final String simpleMessage) {
        return "[" + messageCode + "]" + simpleMessage;
    }

    /**
     * Expands arguments and returns a simple message without a message code.
     *
     * @param messageCode

        return args;
    }

    @Override
    public String getMessage() {
        return message;
    }

    /**
     * Returns a simple message without a message code.
     *
     * @return simple message without message code
     */
    public final String getSimpleMessage() {
        return simpleMessage;
    }

  // A consequence of these requirements is that the delegate futures cannot be stored in
  // final fields.
  //
  // For simplicity the rest of this description will discuss Futures.catching since it is the
  // simplest instance, though very similar descriptions apply to many other classes in this file.
  //
  // In the constructor of AbstractCatchingFuture, the delegate future is assigned to a field

   */
  private @Nullable Object generate(TypeToken<?> type) {
    Class<?> rawType = type.getRawType();
    List<Object> samples = sampleInstances.get(rawType);
    Object sample = pickInstance(samples, null);
    if (sample != null) {
      return sample;
    }
    if (rawType.isEnum()) {
      return pickInstance(rawType.getEnumConstants(), null);
    }
    if (type.isArray()) {

    }

    public void test_parse_quoted_values() {
        String value;
        String[] result;

        // Simple quoted value - quotes are removed
        value = "\"simple\"";
        result = KuromojiCSVUtil.parse(value);
        assertEquals(1, result.length);
        assertEquals("\"simple\"", result[0]);

        // Quoted value with comma - quotes are removed
        value = "\"value,with,commas\"";

 * [close()][Response.close] for you.
 *
 * ```java
 * Call call = client.newCall(request);
 * try (Response response = call.execute()) {
 * ... // Use the response.
 * }
 * ```
 *
 * You can use a similar block for asynchronous calls:
 *
 * ```java
 * Call call = client.newCall(request);
 * call.enqueue(new Callback() {
 *   public void onResponse(Call call, Response response) throws IOException {

                  @Override
                  protected Set<String> create(String[] elements) {
                    return intersection(
                        newHashSet(samples().e1(), samples().e3()),
                        newHashSet(samples().e2(), samples().e4()));
                  }
                })
            .named("set & disjoint")
            .withFeatures(CollectionSize.ZERO, CollectionFeature.ALLOWS_NULL_VALUES)

    return generator.create(elements.toArray());
  }

  @Override
  public Collection<E> getSampleElements(int howMany) {
    SampleElements<E> samples = samples();
    List<E> allSampleElements =
        asList(samples.e0(), samples.e1(), samples.e2(), samples.e3(), samples.e4());
    return new ArrayList<>(allSampleElements.subList(0, howMany));
  }

  @Override
  public CollectionSize getCollectionSize() {