import org.gbif.api.model.checklistbank.ParsedName; //导入依赖的package包/类
@Override
// parses the name without authorship and returns the ParsedName.canonicalName() string
public String parseToCanonical(String scientificName, @Nullable Rank rank) {
  if (Strings.isNullOrEmpty(scientificName)) {
    return null;
  }
  try {
    ParsedName pn = parse(scientificName, rank);
    if (pn != null) {
      return pn.canonicalName();
    }
  } catch (UnparsableException e) {
    logUnparsable(e);
  }
  return null;
}
 

import org.gbif.api.model.checklistbank.ParsedName; //导入依赖的package包/类
@Test
public void convertNameType() throws Exception {
  org.gbif.nameparser.api.ParsedName pn = new org.gbif.nameparser.api.ParsedName();
  for (org.gbif.nameparser.api.NameType t : org.gbif.nameparser.api.NameType.values()) {
    pn.setType(t);
    assertNotNull(NameParserGbifV1.gbifNameType(pn));
  }
  pn.setCandidatus(true);
  assertEquals(NameType.CANDIDATUS, NameParserGbifV1.gbifNameType(pn));

  pn.setCandidatus(false);
  pn.setCultivarEpithet("Bella");
  assertEquals(NameType.CULTIVAR, NameParserGbifV1.gbifNameType(pn));

  pn.setDoubtful(true);
  assertEquals(NameType.DOUBTFUL, NameParserGbifV1.gbifNameType(pn));
}
 

import org.gbif.api.model.checklistbank.ParsedName; //导入依赖的package包/类
@Test
public void parseQuietly() throws Exception {
  ParsedName pn = parser.parseQuietly("Navicula var. fasciata", Rank.VARIETY);
  assertNull(pn.getSpecificEpithet());
  assertEquals(NameType.INFORMAL, pn.getType());

  assertEquals("Abies alba", parser.parseQuietly("Abies alba Mill.").canonicalName());
  pn = parser.parseQuietly("Abies alba x Pinus graecus L.");
  assertEquals("Abies alba x Pinus graecus L.", pn.getScientificName());
  assertEquals(NameType.HYBRID, pn.getType());
  assertNull(pn.getGenusOrAbove());

  assertFalse(parser.parseQuietly("Protoscenium simplex  (Cleve, 1899), Jørgensen, 1905 ", Rank.SPECIES).isParsedPartially());
  assertFalse(parser.parseQuietly("Plagiacanthidae", Rank.SPECIES).isParsedPartially());

  pn = parser.parseQuietly("Plagiacanthidae WhatTheHeck @%&/ (please dont parse me[ he?5789])", Rank.SPECIES);
  assertTrue(pn.isParsed());
  assertTrue(pn.isParsedPartially());
  assertEquals("Plagiacanthidae", pn.getGenusOrAbove());
}
 

import org.gbif.api.model.checklistbank.ParsedName; //导入依赖的package包/类
private List<NameUsageMatch> queryHigher(ParsedName pn, String canonicalName, Rank rank, LinneanClassification lc, boolean verbose) {
  // do a lucene matching
  List<NameUsageMatch> matches = nubIndex.matchByName(canonicalName, false, 50);
  for (NameUsageMatch m : matches) {
    // 0 - +100
    final int nameSimilarity = nameSimilarity(canonicalName, m);
    // -50 - +50
    final int classificationSimilarity = classificationSimilarity(lc, m);
    // -10 - +5
    final int rankSimilarity = rankSimilarity(rank, m.getRank()) * 2;
    // -5 - +1
    final int statusScore = STATUS_SCORE.get(m.getStatus());

    // preliminary total score, -5 - 20 distance to next best match coming below!
    m.setConfidence(nameSimilarity + classificationSimilarity + rankSimilarity + statusScore);

    if (verbose) {
      addNote(m, "Similarity: name=" + nameSimilarity);
      addNote(m, "classification=" + classificationSimilarity);
      addNote(m, "rank=" + rankSimilarity);
      addNote(m, "status=" + statusScore);
    }
  }

  return matches;
}
 

import org.gbif.api.model.checklistbank.ParsedName; //导入依赖的package包/类
private int authorSimilarity(@Nullable ParsedName pn, NameUsageMatch m) {
  int similarity = 0;
  if (pn != null) {
    try {
      ParsedName mpn = parser.parse(m.getScientificName(), m.getRank());
      // authorship comparison was requested!
      Equality recomb = authComp.compare(pn.getAuthorship(), pn.getYear(), mpn.getAuthorship(), mpn.getYear());
      Equality bracket = authComp.compare(pn.getBracketAuthorship(), pn.getBracketYear(), mpn.getBracketAuthorship(), mpn.getBracketYear());

      similarity = equality2Similarity(recomb, 3);
      similarity = similarity + equality2Similarity(bracket, 1);

    } catch (UnparsableException e) {
      if (e.type.isParsable()) {
        LOG.warn("Failed to parse name: {}", m.getScientificName());
      }
    }
  }

  return similarity;
}
 

import org.gbif.api.model.checklistbank.ParsedName; //导入依赖的package包/类
private List<ParsedName> parse(Iterator<String> iter) {
  int counter = 0;
  int unparsable = 0;
  List<ParsedName> pnames = Lists.newArrayList();

  while (iter.hasNext()) {
    final String name = iter.next();
    ParsedName pn = parser.parseQuietly(name);
    pnames.add(pn);
    counter++;
    if (!pn.getType().isParsable()) {
      unparsable++;
    }
  }

  LOG.debug("Parsed {} names out of which {} are unparsable", counter, unparsable);
  return pnames;
}
 

import org.gbif.api.model.checklistbank.ParsedName; //导入依赖的package包/类
private boolean matchesNub(ParsedName pn, Rank rank, Kingdom uKingdom, NubUsage match, @Nullable NubUsage currNubParent, boolean ignoreAuthor) {
  if (rank != match.rank) {
    return false;
  }
  // no homonyms above genus level
  if (rank.isSuprageneric()) {
    return true;
  }
  Equality author = ignoreAuthor ? Equality.UNKNOWN : authComp.compare(pn, match.parsedName);
  Equality kingdom = compareKingdom(uKingdom, match.kingdom);
  switch (author) {
    case DIFFERENT:
      return false;
    case EQUAL:
      return true;
    case UNKNOWN:
      return kingdom != Equality.DIFFERENT && (
          rank.isSpeciesOrBelow() || compareClassification(currNubParent, match) != Equality.DIFFERENT
      );
  }
  return false;
}
 

import org.gbif.api.model.checklistbank.ParsedName; //导入依赖的package包/类
private NubUsage createBasionymPlaceholder(NubUsage family, BasionymGroup group) {
  NubUsage basionym = new NubUsage();
  basionym.datasetKey = null;
  basionym.origin = Origin.BASIONYM_PLACEHOLDER;
  basionym.rank = Rank.UNRANKED;
  basionym.status = TaxonomicStatus.DOUBTFUL;
  basionym.parsedName = new ParsedName();
  basionym.parsedName.setGenusOrAbove("?");
  basionym.parsedName.setSpecificEpithet(group.getEpithet());
  basionym.parsedName.setAuthorship(group.getAuthorship());
  basionym.parsedName.setYear(group.getYear());
  basionym.parsedName.setType(NameType.PLACEHOLDER);
  basionym.parsedName.setScientificName(basionym.parsedName.fullName());
  LOG.debug("creating basionym placeholder {} in family {}", basionym.parsedName.canonicalNameComplete(), family.parsedName.canonicalName());
  return db.addUsage(family, basionym);
}
 

import org.gbif.api.model.checklistbank.ParsedName; //导入依赖的package包/类
protected NameUsageNode create(NameUsage u, boolean isRoot) {
  Node n = dao.createTaxon();
  if (u.getTaxonomicStatus() != null && u.getTaxonomicStatus().isSynonym()) {
    n.addLabel(Labels.SYNONYM);
  }
  if (isRoot) {
    n.addLabel(Labels.ROOT);
  }

  // parse name and store it
  ParsedName pn = PARSER.parseQuietly(u.getScientificName(), u.getRank());
  dao.store(n.getId(), pn);

  // update canonical and store usage
  //u.setCanonicalName(pn.canonicalNameWithMarker());
  NameUsageNode nn = new NameUsageNode(n, u, true);
  dao.store(nn, true);

  return nn;
}
 

import org.gbif.api.model.checklistbank.ParsedName; //导入依赖的package包/类
/**
 * @param kvp
 * @param neoDir
 * @param neoFactory
 * @param registry
 */
private UsageDao(DB kvp, File neoDir, @Nullable File kvpStore, GraphDatabaseBuilder neoFactory, @Nullable MetricRegistry registry) {
  try {
    this.neoFactory = neoFactory;
    this.neoDir = neoDir;
    this.kvpStore = kvpStore;
    this.kvp = kvp;
    this.registry = registry;

    names = createKvpMap("names", ParsedName.class, 128);
    facts = createKvpMap("facts", UsageFacts.class, 128);
    verbatim = createKvpMap("verbatim", VerbatimNameUsage.class, 512);
    usages = createKvpMap("usages", NameUsage.class, 256);
    extensions = createKvpMap("extensions", UsageExtensions.class, 512);
    srcUsages = createKvpMap("srcUsages", SrcUsage.class, 256);
    nubUsages = createKvpMap("nubUsages", NubUsage.class, 256);

    openNeo();
  } catch (Exception e) {
    LOG.error("Failed to initialize a new DAO", e);
    close();
    throw e;
  }
}
 

import org.gbif.api.model.checklistbank.ParsedName; //导入依赖的package包/类
@Test
public void testEmptyModels() throws Exception {
    assertSerde(new NameUsage());
    assertSerde(new VerbatimNameUsage());
    assertSerde(new NameUsageMetrics());
    assertSerde(new UsageExtensions());
    assertSerde(new ParsedName());
    assertSerde(new Description());
    assertSerde(new Distribution());
    assertSerde(new Identifier());
    assertSerde(new NameUsageMediaObject());
    assertSerde(new Reference());
    assertSerde(new SpeciesProfile());
    assertSerde(new NameUsage());
    assertSerde(new TypeSpecimen());
    assertSerde(new VernacularName());
    assertSerde(new DatasetMetrics());
}
 

import org.gbif.api.model.checklistbank.ParsedName; //导入依赖的package包/类
@Test
public void testCountTaxa() throws Exception {
  UsageDao dao = UsageDao.temporaryDao(10);
  NubDb nub = NubDb.create(dao, AuthorComparator.createWithoutAuthormap());
  try (Transaction tx = dao.beginTx()) {

    assertEquals(0l, nub.countTaxa());

    NubUsage u = new NubUsage();
    u.parsedName = new ParsedName();
    u.origin = Origin.SOURCE;
    u.rank = Rank.SPECIES;
    nub.addRoot(u);
    assertEquals(1l, nub.countTaxa());

    // we add the same nub usage which already has a neo node, nothing changes
    nub.addRoot(u);
    assertEquals(1l, nub.countTaxa());

    u.node = null;
    nub.addRoot(u);
    assertEquals(2l, nub.countTaxa());
    tx.success();
  }

}
 

import org.gbif.api.model.checklistbank.ParsedName; //导入依赖的package包/类
public static NubUsage nubusage(int key) {
  NubUsage u = new NubUsage();
  u.usageKey = key;
  u.datasetKey = UUID.randomUUID();
  u.kingdom = Kingdom.byNubUsageId(RND.nextInt(8));
  u.origin = Origin.SOURCE;
  u.addRemark(StringUtils.randomSpecies());
  u.parsedName = new ParsedName();
  u.parsedName.setGenusOrAbove(StringUtils.randomGenus());
  u.parsedName.setSpecificEpithet(StringUtils.randomEpithet());
  if (key % 5 == 0) {
    u.rank = Rank.SUBSPECIES;
    u.parsedName.setInfraSpecificEpithet(StringUtils.randomEpithet());
  } else {
    u.rank = Rank.SPECIES;
  }
  u.parsedName.setAuthorship(StringUtils.randomAuthor());
  u.parsedName.setYear(StringUtils.randomSpeciesYear());
  u.parsedName.setScientificName(u.parsedName.fullName());
  u.status = TaxonomicStatus.ACCEPTED;
  return u;
}
 

import org.gbif.api.model.checklistbank.ParsedName; //导入依赖的package包/类
/**
 * @param pn
 * @param code to which rules to adhere to
 * @return
 */
public static String scientificName(ParsedName pn, NomenclaturalCode code) {
  if (!pn.isParsed() || NomenclaturalCode.VIRUS == code) {
    return pn.getScientificName();
  }

  // remove authorship if indet name
  if (pn.isIndetermined()) {
    return pn.buildName(true, true, false, false, true, false, true, false, true, false, false, false, true, true);
  }

  String sciname;
  if (code == NomenclaturalCode.ZOOLOGICAL && pn.getInfraSpecificEpithet() != null && Rank.SUBSPECIES == pn.getRank()) {
    Rank r = pn.getRank();
    pn.setRank(null);
    sciname = pn.buildName(true, false, true, false, true, false, true, false, true, false, false, false, true, true);
    pn.setRank(r);

  } else {
    sciname = pn.canonicalNameComplete();
  }

  return sciname;
}
 

import org.gbif.api.model.checklistbank.ParsedName; //导入依赖的package包/类
/**
 * Assembles the most complete scientific name based on full and individual name parts.
 * @param scientificName the full scientific name
 * @param genericName see GbifTerm.genericName
 * @param genus see DwcTerm.genus
 * @param specificEpithet see DwcTerm.specificEpithet
 * @param infraspecificEpithet see DwcTerm.infraspecificEpithet
 */
public static String buildScientificName(String scientificName, String authorship, String genericName, String genus,
                                         String specificEpithet, String infraspecificEpithet) {
  String sciname = ClassificationUtils.clean(scientificName);
  if (sciname == null) {
    // handle case when the scientific name is null and only given as atomized fields: genus & speciesEpitheton
    ParsedName pn = new ParsedName();
    if (!StringUtils.isBlank(genericName)) {
      pn.setGenusOrAbove(genericName);
    } else {
      pn.setGenusOrAbove(genus);
    }
    pn.setSpecificEpithet(specificEpithet);
    pn.setInfraSpecificEpithet(infraspecificEpithet);
    pn.setAuthorship(authorship);
    sciname = pn.canonicalNameComplete();

  } else if (!Strings.isNullOrEmpty(authorship) && !sciname.toLowerCase().contains(authorship.toLowerCase())) {
    sciname = sciname + " " + authorship;
  }

  return sciname;
}
 

import org.gbif.api.model.checklistbank.ParsedName; //导入依赖的package包/类
/**
 * Ignore the sanctioning author
 */
@Test
public void testCompareSanctioning() throws Exception {
  ParsedName p1 = new ParsedName();
  ParsedName p2 = new ParsedName();

  p1.setAuthorship("Fr. : Fr.");
  p2.setAuthorship("Fr.");

  assertEquals(Equality.EQUAL, comp.compare(p1, p2));

  p2.setAuthorship("Fr. : Pers.");
  assertEquals(Equality.EQUAL, comp.compare(p1, p2));

  p1.setBracketAuthorship("Mill.");
  p2.setBracketAuthorship("Mill. : Pers.");
  assertEquals(Equality.EQUAL, comp.compare(p1, p2));
}
 

import org.gbif.api.model.checklistbank.ParsedName; //导入依赖的package包/类
@Test
public void testCompareUnparsedAuthor() throws Exception {
  ParsedName p1 = new ParsedName();
  p1.setScientificName("Platanus x hispanica Mill. ex Münch., 1770");
  p1.setGenusOrAbove("Platanus");
  p1.setSpecificEpithet("hispanica");
  p1.setNotho(NamePart.SPECIFIC);
  p1.setParsed(false);

  ParsedName p2 = new ParsedName();
  p2.setScientificName("Platanus hispanica Mill. ex Münch.");
  p2.setGenusOrAbove("Platanus");
  p2.setSpecificEpithet("hispanica");
  p2.setNotho(NamePart.SPECIFIC);
  p2.setAuthorship("Mill. ex Münch.");
  p2.setParsed(true);

  assertEquals(Equality.EQUAL, comp.compare(p1, p2));
}
 

import org.gbif.api.model.checklistbank.ParsedName; //导入依赖的package包/类
@Test
public void testUnparsedAuthors() throws Exception {
  ParsedName p3 = new ParsedName();
  p3.setParsed(false);
  p3.setScientificName("Blattaria Voet, ?, 1806");
  p3.setGenusOrAbove("Blattaria");

  ParsedName p4 = new ParsedName();
  p4.setScientificName("Blattaria Weyenbergh, 1874");
  p4.setAuthorship("Weyenbergh");
  p4.setYear("1874");

  assertEquals(Equality.DIFFERENT, comp.compare(p3, p4));

  p4.setYear("1806");
  assertEquals(Equality.EQUAL, comp.compare(p3, p4));
}
 

import org.gbif.api.model.checklistbank.ParsedName; //导入依赖的package包/类
@Test
public void testGroupPlantBasionyms3() throws Exception {
  List<ParsedName> names = names(
      "Negundo aceroides subsp. violaceus (G.Kirchn.) W.A.Weber",
      "Negundo aceroides subsp. violaceus (Kirchner) W.A. Weber",

      "Negundo aceroides subsp. violaceum (Booth ex G.Kirchn.) Holub",
      "Negundo aceroides subsp. violaceum (Booth ex Kirchner) Holub",

      "Negundo aceroides var. violaceum G.Kirchn. in Petzold & G.Kirchn.",
      "Acer violaceum (Kirchner) Simonkai",
      "Acer negundo var. violaceum (G. Kirchn.) H. Jaeger"
  );

  Collection<BasionymGroup<ParsedName>> groups = sorter.groupBasionyms(names);
  assertEquals(1, groups.size());
  BasionymGroup<ParsedName> g = groups.iterator().next();
  assertFalse(g.getRecombinations().isEmpty());
  assertEquals(6, g.getRecombinations().size());
  assertNotNull(g.getBasionym());
  assertEquals("G.Kirchn.", g.getBasionym().authorshipComplete());
}
 

import org.gbif.api.model.checklistbank.ParsedName; //导入依赖的package包/类
private static void applyMatch(Occurrence occ, NameUsageMatch match, Collection<OccurrenceIssue> issues) {
  occ.setTaxonKey(match.getUsageKey());
  occ.setScientificName(match.getScientificName());
  occ.setTaxonRank(match.getRank());

  // copy issues
  occ.getIssues().addAll(issues);

  // parse name into pieces - we dont get them from the nub lookup
  try {
    ParsedName pn = PARSER.parse(match.getScientificName(), match.getRank());
    occ.setGenericName(pn.getGenusOrAbove());
    occ.setSpecificEpithet(pn.getSpecificEpithet());
    occ.setInfraspecificEpithet(pn.getInfraSpecificEpithet());
  } catch (UnparsableException e) {
    if (e.type.isParsable()) {
      LOG.warn("Fail to parse backbone {} name for occurrence {}: {}", e.type, occ.getKey(), e.name);
    }
  }

  for (Rank r : Rank.DWC_RANKS) {
    org.gbif.api.util.ClassificationUtils.setHigherRank(occ, r, match.getHigherRank(r));
    org.gbif.api.util.ClassificationUtils.setHigherRankKey(occ, r, match.getHigherRankKey(r));
  }
  LOG.debug("Occurrence {} matched to nub {} [{}]", occ.getKey(), occ.getScientificName(), occ.getTaxonKey());
}