import no.priv.garshol.duke.RecordImpl; //导入依赖的package包/类
@Override
protected DataSource generateBaseDataSource(Collection<String> baseElements) {
    DataSource ds = mock(DataSource.class);
    Map<String, Collection<String>> map;
    DukeStitcherRecordIterator<String> it = new DukeStitcherRecordIterator<String>();

    for (String s : baseElements) {
        map = new HashMap<String, Collection<String>>(2);
        map.put(idProp, new ArrayList<String>(1));
        map.put(originProp, new ArrayList<String>(1));
        map.get(idProp).add(s);
        map.get(originProp).add(s);
        it.addRecord(new RecordImpl(map));
    }

    it.start();
    when(ds.getRecords()).thenReturn(it);

    return ds;
}
 

import no.priv.garshol.duke.RecordImpl; //导入依赖的package包/类
@Override
protected DataSource generateCandidateDataSource(Collection<Composer> candidateElements) {
    DataSource ds = mock(DataSource.class);
    Map<String, Collection<String>> map;
    DukeStitcherRecordIterator<Composer> it = new DukeStitcherRecordIterator<Composer>();

    for (Composer c : candidateElements) {
        map = new HashMap<String, Collection<String>>(2);
        map.put(idProp, new ArrayList<String>(1));
        map.put(originProp, new ArrayList<String>(1));
        map.get(idProp).add(c.getAttribute(Composer.name));
        map.get(originProp).add(c.getAttribute(Composer.origin));
        it.addRecord(new RecordImpl(map));
    }

    it.start();
    when(ds.getRecords()).thenReturn(it);

    return ds;
}
 

import no.priv.garshol.duke.RecordImpl; //导入依赖的package包/类
@Test
public void testMultiValue() throws IOException {
	// First, index up the record
	HashMap<String, Collection<String>> props = new HashMap<String, Collection<String>>();
	props.put("ID", Collections.singleton("abc"));
	Collection<String> list = new ArrayList<String>();
	list.add("b");
	list.add("c");
	props.put("NAME", list);
	Record r = new RecordImpl(props);
	db.index(r);
	db.commit();

	// Then, retrieve it and verify that it's correct
	r = db.findRecordById("abc");
	assertEquals("abc", r.getValue("ID"));
	list = r.getValues("NAME");
	assertEquals(2, list.size());
	assertTrue(list.contains("b"));
	assertTrue(list.contains("c"));
}
 

import no.priv.garshol.duke.RecordImpl; //导入依赖的package包/类
@Test
public void testMultiValue() throws IOException {
  // First, index up the record
  HashMap props = new HashMap();
  props.put("ID", Collections.singleton("abc"));
  Collection<String> list = new ArrayList();
  list.add("b");
  list.add("c");
  props.put("NAME", list);
  Record r = new RecordImpl(props);
  db.index(r);
  db.commit();

  // Then, retrieve it and verify that it's correct
  r = db.findRecordById("abc");
  assertEquals("abc", r.getValue("ID"));
  list = r.getValues("NAME");
  assertEquals(2, list.size());
  assertTrue(list.contains("b"));
  assertTrue(list.contains("c"));
}
 

import no.priv.garshol.duke.RecordImpl; //导入依赖的package包/类
private void addStatement(RecordImpl record,
                          String subject,
                          String property,
                          String object) {
  Collection<Column> cols = columns.get(property);
  if (cols == null) {
    if (property.equals(RDF_TYPE) && !types.isEmpty())
      addValue(record, subject, property, object);
    return;
  }
  
  for (Column col : cols) {
    String cleaned = object;
    if (col.getCleaner() != null)
      cleaned = col.getCleaner().clean(object);
    if (cleaned != null && !cleaned.equals(""))
      addValue(record, subject, col.getProperty(), cleaned);
  }
}
 

import no.priv.garshol.duke.RecordImpl; //导入依赖的package包/类
public void filterByTypes() {
  // this is fairly ugly. if types has values we add an extra property
  // RDF_TYPE to records during build, then filter out records of the
  // wrong types here. finally, we strip away the RDF_TYPE property here.
  
  if (types.isEmpty())
    return;
  
  for (String uri : new ArrayList<String>(records.keySet())) {
    RecordImpl r = records.get(uri);
    if (!filterbytype(r))
      records.remove(uri);
    else
      r.remove(RDF_TYPE);
  }
}
 

import no.priv.garshol.duke.RecordImpl; //导入依赖的package包/类
private Record parseRecord() {
  RecordImpl record = new RecordImpl();
  String current = subject;

  // we've stored the first statement about the next resource, so we
  // need to process that before we move on to read anything
  
  while (current != null && current.equals(subject)) {
    addStatement(record, subject, property, object);
    parseNextLine();
    // we have now received a callback to statement() with the
    // next statement
  }

  // ok, subject is now either null (we're finished), or different from
  // current, because we've started on the next resource
  if (current == null)
    return null;
  return record;
}
 

import no.priv.garshol.duke.RecordImpl; //导入依赖的package包/类
public void run(String[] argv)
  throws IOException, SAXException {
  Collection<CommandLineParser.Option> options =
    Collections.singleton((CommandLineParser.Option) new CommandLineParser.StringOption("maxhits", 'H'));
  argv = init(argv, 3, 3, options);
  int max_hits = 10000;
  if (parser.getOptionValue("maxhits") != null)
    max_hits = Integer.parseInt(parser.getOptionValue("maxhits"));

  // build record
  RecordImpl prototype = new RecordImpl();
  prototype.addValue(argv[1], argv[2]);

  // search
  Collection<Record> records = database.findCandidateMatches(prototype);
  int hitno = 1;
  for (Record record : records) {
    PrintMatchListener.prettyPrint(record, config.getProperties());
    System.out.println();
    if (hitno++ == max_hits)
      break;
  }
}
 

import no.priv.garshol.duke.RecordImpl; //导入依赖的package包/类
/**
 * . Computes probability that objects are the same
 *
 * @return float the computed score
 */
@Override
public double runAsDouble() {
    HashMap<String, Collection<String>> props =
            new HashMap<>();
    LeafDocLookup doc = doc();
    Collection<String> docKeys = comparedRecord.getProperties();

    for (String key : docKeys) {
        if (doc.containsKey(key)) {
            String value = (doc.get(key) == null ? "" : getFieldValue(doc.get(key)));
            props.put(key, value == null
                    ? Collections.singleton("")
                    : Collections.singleton(value));
        }
    }
    Record r2 = new RecordImpl(props);
    return compare(comparedRecord, r2, entityParams);
}
 

import no.priv.garshol.duke.RecordImpl; //导入依赖的package包/类
/**
 * Helper method which receives an <tt>HpCloudItem</tt> and creates a new <tt>Record</tt> to be
 * used by Duke.
 *
 * @param item The object where the properties' values are going to be read from.
 * @return A <tt>Record</tt> containing all the properties specified in the constructor of this
 *         class.
 */
protected Record convertToRecord(final T item) {
    RecordImpl newRecord = new RecordImpl();

    // This method is called from a parallelised one. Hence, there is no need for this one to be
    // parallelised.
    for (String property : propertiesInfo.keySet()) {
        String value = item.getCore().getAttributeAsString(propertiesInfo.get(property));
        newRecord.addValue(property, value);
    }

    return newRecord;
}
 

import no.priv.garshol.duke.RecordImpl; //导入依赖的package包/类
private void addValue(RecordImpl record, String subject,
                      String property, String object) {
  if (record.isEmpty())
    for (Column idcol : columns.get("?uri"))
      record.addValue(idcol.getProperty(), subject);

  record.addValue(property, object);      
}
 

import no.priv.garshol.duke.RecordImpl; //导入依赖的package包/类
/**
 * . Configures with data from JSON payload only
 *
 * @param fieldsParams fields parameters from JSON
 * @return the record for comparison
 */
private Record configureWithFieldsOnly(
        final List<Map<String, Object>> fieldsParams) {

    Map<String, Collection<String>> props =
            new HashMap<>();
    entityParams = new HashMap<>();

    for (Map<String, Object> value : fieldsParams) {
        HashMap<String, Object> map = new HashMap<>();

        String field = (String) value.get("field");

        List<Cleaner> cleanList =
                getCleaners((ArrayList<Map<String, String>>) value.get(CLEANERS));

        map.put(CLEANERS, cleanList);

        Double maxValue = 0.0;
        if (value.get(HIGH) != null) {
            maxValue = (Double) value.get(HIGH);
        }

        Double minValue = 0.0;
        if (value.get(LOW) != null) {
            minValue = (Double) value.get(LOW);
        }

        Comparator comp = getComparator(value);

        map.put(HIGH, maxValue);
        map.put(LOW, minValue);
        map.put(COMPARATOR, comp);

        entityParams.put(field, map);
    }

    readFields(fieldsParams, props);
    return new RecordImpl(props);
}
 

import no.priv.garshol.duke.RecordImpl; //导入依赖的package包/类
public Map<String, RecordImpl> getRecords() {
  return records;
}
 

import no.priv.garshol.duke.RecordImpl; //导入依赖的package包/类
@Override
public Record next() {
    if (iterator.hasNext()) {
        ItemVO<Integer, Integer> itemVO = iterator.next();

        Map<String, Collection<String>> values = new HashMap<String, Collection<String>>();

        // TODO: fill the record

        String profile = profileService.getProfile(itemVO);





        //Record record = new ProfileDBRecord();
        Record record = new RecordImpl(values);
        return record;
    } else
        return null;
}
 

import no.priv.garshol.duke.RecordImpl; //导入依赖的package包/类
public static Record makeRecord() {
  return new RecordImpl(new HashMap());    
}