How to use

SimpleDictionary

in

org.datacleaner.reference

private Element toElement(final SimpleDictionary dictionary) {
  final Element elem = getDocument().createElement("value-list-dictionary");
  elem.setAttribute("name", dictionary.getName());
  if (!Strings.isNullOrEmpty(dictionary.getDescription())) {
    elem.setAttribute("description", dictionary.getDescription());
  }
  final Set<String> values = dictionary.getValueSet();
  for (final String value : values) {
    appendElement(elem, "value", value);
  }
  appendElement(elem, "case-sensitive", dictionary.isCaseSensitive());
  return elem;
}

public SimpleDictionary(final String name, final boolean caseSensitive, final String... values) {
  this(name, createValueSet(values, caseSensitive), caseSensitive);
}

@Inject
protected SimpleDictionaryDialog(@Nullable final SimpleDictionary dictionary,
    final MutableReferenceDataCatalog catalog, final WindowContext windowContext) {
  super(windowContext, ImageManager.get().getImage(IconUtils.DICTIONARY_SIMPLE_IMAGEPATH));
  _originalDictionary = dictionary;
  _catalog = catalog;
  _nameTextField = WidgetFactory.createTextField("Dictionary name");
  _valuesTextArea = WidgetFactory.createTextArea("Values");
  _valuesTextArea.setRows(14);
  _caseSensitiveCheckBox = new DCCheckBox<>("Case-sensitive?", false);
  _caseSensitiveCheckBox.setForeground(WidgetUtils.BG_COLOR_BRIGHTEST);
  _caseSensitiveCheckBox.setOpaque(false);
  _caseSensitiveCheckBox.setToolTipText("Only match on dictionary terms when text-case is the same.");
  if (dictionary != null) {
    _nameTextField.setText(dictionary.getName());
    final Collection<String> values = dictionary.getValueSet();
    final StringBuilder sb = new StringBuilder();
    boolean first = true;
    for (final String value : values) {
      if (first) {
        first = false;
      } else {
        sb.append('\n');
      }
      sb.append(value);
    }
    _valuesTextArea.setText(sb.toString());
    _caseSensitiveCheckBox.setSelected(dictionary.isCaseSensitive());
  }
}

@Override
public DictionaryConnection openConnection(final DataCleanerConfiguration configuration) {
  final ResourceConverter rc = new ResourceConverter(configuration);
  final Resource resource = rc.fromString(Resource.class, _filename);
  final Set<String> values = resource.read(in -> {
    final Set<String> values1 = new HashSet<>();
    final BufferedReader reader = FileHelper.getBufferedReader(in, getEncoding());
    try {
      String line = reader.readLine();
      while (line != null) {
        if (!_caseSensitive) {
          line = line.toLowerCase();
        }
        values1.add(line);
        line = reader.readLine();
      }
    } catch (final IOException e) {
      logger.error("Failed to read line from resource: {}", resource, e);
    } finally {
      FileHelper.safeClose(reader);
    }
    return values1;
  });
  final SimpleDictionary simpleDictionary = new SimpleDictionary(getName(), values, _caseSensitive);
  return simpleDictionary.openConnection(configuration);
}

public SimpleDictionary loadIntoMemory(final DatastoreConnection datastoreConnection) {
  final DataContext dataContext = datastoreConnection.getDataContext();
  final Column column = getColumn(datastoreConnection);
  final Query query = dataContext.query().from(column.getTable()).select(column).toQuery();
  if (datastoreConnection.getDatastore().getPerformanceCharacteristics().isQueryOptimizationPreferred()) {
    query.getSelectClause().setDistinct(true);
  }
  final Set<String> values = new HashSet<>();
  try (DataSet dataSet = dataContext.executeQuery(query)) {
    while (dataSet.next()) {
      final Object value = dataSet.getRow().getValue(0);
      if (value != null) {
        values.add(value.toString());
      }
    }
  }
  return new SimpleDictionary(getName(), values);
}

  final SimpleDictionary dict = new SimpleDictionary(name, values, caseSensitive);
  dict.setDescription(vldt.getDescription());
  dictionaryList.add(dict);
} else if (dictionaryType instanceof CustomElementType) {

private static String getDescription(final Dictionary dictionary) {
  if (dictionary.getDescription() != null) {
    return dictionary.getDescription();
  }
  if (dictionary instanceof TextFileDictionary) {
    return ((TextFileDictionary) dictionary).getFilename();
  } else if (dictionary instanceof DatastoreDictionary) {
    final DatastoreDictionary datastoreDictionary = (DatastoreDictionary) dictionary;
    return datastoreDictionary.getDatastoreName() + ": " + datastoreDictionary.getQualifiedColumnName();
  } else if (dictionary instanceof SimpleDictionary) {
    final SimpleDictionary simpleDictionary = (SimpleDictionary) dictionary;
    final Collection<String> values = simpleDictionary.getValueSet();
    final StringBuilder sb = new StringBuilder();
    for (final String value : values) {
      if (sb.length() > 0) {
        sb.append(",");
      }
      sb.append(value);
      if (sb.length() > 20) {
        break;
      }
    }
    return sb.toString();
  }
  return "";
}

@Override
public Iterator<String> getAllValues() {
  return _dictionary.loadIntoMemory(_datastoreConnection).openConnection(null).getAllValues();
}

final SimpleDictionary dict = new SimpleDictionary(name1, caseSensitive, values.split("\n"));

@Override
public Iterator<String> getLengthSortedValues() {
  return _dictionary.loadIntoMemory(_datastoreConnection).openConnection(null).getLengthSortedValues();
}

public SimpleDictionary(final String name, final Collection<String> values, final boolean caseSensitive) {
  super(name);
  if (caseSensitive) {
    _valueSet = Sets.newHashSet(values);
  } else {
    _valueSet = createValueSet(values.iterator(), caseSensitive);
  }
  _caseSensitive = caseSensitive;
}

@Override
public DictionaryConnection openConnection(final DataCleanerConfiguration configuration) {
  final Datastore datastore = configuration.getDatastoreCatalog().getDatastore(_datastoreName);
  if (datastore == null) {
    throw new NoSuchDatastoreException(_datastoreName);
  }
  final DatastoreConnection datastoreConnection = datastore.openConnection();
  if (_loadIntoMemory) {
    final SimpleDictionary simpleDictionary = loadIntoMemory(datastoreConnection);
    // no need for the connection anymore
    datastoreConnection.close();
    return simpleDictionary.openConnection(configuration);
  }
  return new DatastoreDictionaryConnection(this, datastoreConnection);
}

private static Set<String> createValueSet(final Object[] array, final boolean caseSensitive) {
  return createValueSet(Iterators.forArray(array), caseSensitive);
}

private void readObject(final ObjectInputStream stream) throws IOException, ClassNotFoundException {
  final Adaptor adaptor = (getField, serializable) -> {
    final boolean caseSensitive = getField.get("_caseSensitive", true);
    // handle potentially missing caseSensitive flag
    {
      final Field caseSensitiveField = SimpleDictionary.class.getDeclaredField("_caseSensitive");
      caseSensitiveField.setAccessible(true);
      caseSensitiveField.set(serializable, caseSensitive);
    }
    // handle legacy SimpleReferenceValues based data
    try {
      final Object oldValues = getField.get("_values", null);
      if (oldValues != null) {
        @SuppressWarnings("deprecation") final SimpleReferenceValues srv =
            (SimpleReferenceValues) oldValues;
        @SuppressWarnings("deprecation") final Object[] values = srv.getValues();
        final Set<String> valueSet = createValueSet(values, caseSensitive);
        final Field valuesField = SimpleDictionary.class.getDeclaredField("_valueSet");
        valuesField.setAccessible(true);
        valuesField.set(serializable, valueSet);
      }
    } catch (final IllegalArgumentException e) {
      // happens for newer versions of the object type.
    }
  };
  ReadObjectBuilder.create(this, SimpleDictionary.class).readObject(stream, adaptor);
}