How to use

StringPattern

in

org.datacleaner.reference

@Override
protected String getName(final StringPattern item) {
  return item.getName();
}

@Initialize
public void init() {
  stringPatternConnections = new StringPatternConnection[_stringPatterns.length];
  for (int i = 0; i < _stringPatterns.length; i++) {
    stringPatternConnections[i] = _stringPatterns[i].openConnection(_configuration);
  }
}

private static String getDescription(final StringPattern stringPattern) {
  if (stringPattern.getDescription() != null) {
    return stringPattern.getDescription();
  }
  final String description;
  if (stringPattern instanceof RegexSwapStringPattern) {
    description = ((RegexSwapStringPattern) stringPattern).getRegex().getExpression();
  } else if (stringPattern instanceof RegexStringPattern) {
    description = ((RegexStringPattern) stringPattern).getExpression();
  } else if (stringPattern instanceof SimpleStringPattern) {
    description = ((SimpleStringPattern) stringPattern).getExpression();
  } else {
    description = "";
  }
  if (description == null) {
    return "";
  }
  if (description.length() > 30) {
    return description.substring(0, 27) + "...";
  }
  return description;
}

@Override
public StringPattern getStringPattern(final String name) {
  if (name != null) {
    for (final StringPattern sp : _stringPatterns) {
      if (name.equals(sp.getName())) {
        return sp;
      }
    }
  }
  return null;
}

@Initialize
public void init() {
  stringPatternConnections = new StringPatternConnection[stringPatterns.length];
  for (int i = 0; i < stringPatterns.length; i++) {
    stringPatternConnections[i] = stringPatterns[i].openConnection(configuration);
  }
}

@Override
public StringPattern getStringPattern(final String name) {
  if (name != null) {
    for (final StringPattern sp : _userPreferences.getUserStringPatterns()) {
      if (name.equals(sp.getName())) {
        return sp;
      }
    }
  }
  return null;
}

private void addStringPatternInternal(final StringPattern sp, final boolean externalize) {
  final String name = sp.getName();
  if (Strings.isNullOrEmpty(name)) {
    throw new IllegalArgumentException("StringPattern has no name!");
  }
  final List<StringPattern> stringPatterns = _userPreferences.getUserStringPatterns();
  for (final StringPattern stringPattern : stringPatterns) {
    if (name.equals(stringPattern.getName())) {
      throw new IllegalArgumentException("StringPattern name '" + name + "' is not unique!");
    }
  }
  assignProvidedProperties(sp);
  stringPatterns.add(sp);
  if (externalize) {
    if (_configurationWriter.isExternalizable(sp)) {
      _configurationWriter.externalize(sp);
    }
    _userPreferences.save();
  }
}

final String name = stringPattern.getName();
if (uniqueNames.contains(name)) {
  throw new IllegalStateException("Duplicate string pattern names: " + name);

@Override
public OutputColumns getOutputColumns() {
  final String columnName = _column.getName();
  final String[] names = new String[_stringPatterns.length];
  for (int i = 0; i < names.length; i++) {
    names[i] = columnName + " '" + _stringPatterns[i].getName() + "'";
  }
  final Class<?>[] types = new Class[_stringPatterns.length];
  for (int i = 0; i < types.length; i++) {
    types[i] = _outputType.getOutputClass();
  }
  return new OutputColumns(names, types);
}

@Override
public String toString(final Object o) {
  final String result;
  if (o instanceof Schema) {
    result = ((Schema) o).getName();
  } else if (o instanceof Table) {
    result = ((Table) o).getQualifiedLabel();
  } else if (o instanceof Column) {
    result = ((Column) o).getQualifiedLabel();
  } else if (o instanceof Dictionary) {
    result = ((Dictionary) o).getName();
  } else if (o instanceof SynonymCatalog) {
    result = ((SynonymCatalog) o).getName();
  } else if (o instanceof StringPattern) {
    result = ((StringPattern) o).getName();
  } else if (o instanceof Datastore) {
    result = ((Datastore) o).getName();
  } else {
    logger.warn("Could not convert type: {}", o.getClass().getName());
    result = o.toString();
  }
  return result;
}

public void removeStringPattern(final StringPattern sp, final boolean externalize) {
  final List<StringPattern> stringPatterns = _userPreferences.getUserStringPatterns();
  if (stringPatterns.remove(sp)) {
    for (final StringPatternChangeListener listener : _stringPatternListeners) {
      listener.onRemove(sp);
    }
    for (final ReferenceDataChangeListener<StringPattern> listener : _stringPatternChangeListeners) {
      listener.onRemove(sp);
    }
  }
  if (externalize) {
    _configurationWriter.removeStringPattern(sp.getName());
    _userPreferences.save();
  }
}

public void changeStringPattern(final StringPattern oldPattern, final StringPattern newPattern,
    final boolean externalize) {
  // The old reference is removed from user preferences and we add a new
  //pattern with the same name but with a different expression value
  final List<StringPattern> stringPatterns = _userPreferences.getUserStringPatterns();
  stringPatterns.remove(oldPattern);
  if (externalize) {
    _configurationWriter.removeStringPattern(oldPattern.getName());
    _userPreferences.save();
  }
  addStringPatternInternal(newPattern, externalize);
  for (final ReferenceDataChangeListener<StringPattern> listener : _stringPatternChangeListeners) {
    listener.onChange(oldPattern, newPattern);
  }
  for (final StringPatternChangeListener listener : _stringPatternListeners) {
    listener.onRemove(oldPattern);
    listener.onAdd(newPattern);
  }
}

if (_regexStringPattern != null && _catalog.containsStringPattern(_regexStringPattern.getName())) {
  _catalog.changeStringPattern(_regexStringPattern, regexStringPattern);
} else {