Java Rank.SPECIES属性代码示例

private static void setNumByRank(NameUsageMetrics u, Rank rank, int count) {
    if (rank == Rank.PHYLUM) {
        u.setNumPhylum(count);
    }
    if (rank == Rank.CLASS) {
        u.setNumClass(count);
    }
    if (rank == Rank.ORDER) {
        u.setNumOrder(count);
    }
    if (rank == Rank.FAMILY) {
        u.setNumFamily(count);
    }
    if (rank == Rank.GENUS) {
        u.setNumGenus(count);
    }
    if (rank == Rank.SUBGENUS) {
        u.setNumSubgenus(count);
    }
    if (rank == Rank.SPECIES) {
        u.setNumSpecies(count);
    }
}
 

@Test
public void testUsages() throws Exception {
  // use default prod API
  Properties props = dbSetup.getProperties();
  ClbConfiguration clb = new ClbConfiguration();
  clb.databaseName = props.getProperty("checklistbank.db.dataSource.databaseName");
  clb.serverName = props.getProperty("checklistbank.db.dataSource.serverName");
  clb.user = props.getProperty("checklistbank.db.dataSource.user");
  clb.password = props.getProperty("checklistbank.db.dataSource.password");

  ClbSource src = new ClbSource(clb, UUID.fromString("109aea14-c252-4a85-96e2-f5f4d5d088f4"), "squirrels");
  src.ignoreRanksAbove = Rank.SPECIES;
  src.init(false, false);
  int counter = 0;
  for (SrcUsage u : src) {
    counter++;
    System.out.print(u.key + "  ");
    System.out.println(u.scientificName);
  }
  assertEquals(44, counter);

}
 

@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();
  }

}
 

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;
}
 

/**
 * Gets the count of usages by a rank.
 * Only Linnean ranks are supported.
 *
 * @param rank the linnean rank to retrieve counts for
 *
 * @return the count or null if rank doesnt exist
 */
@Nullable
public Integer getNumByRank(Rank rank) {
  if (rank == Rank.PHYLUM) {
    return numPhylum;
  }
  if (rank == Rank.CLASS) {
    return numClass;
  }
  if (rank == Rank.ORDER) {
    return numOrder;
  }
  if (rank == Rank.FAMILY) {
    return numFamily;
  }
  if (rank == Rank.GENUS) {
    return numGenus;
  }
  if (rank == Rank.SUBGENUS) {
    return numSubgenus;
  }
  if (rank == Rank.SPECIES) {
    return numSpecies;
  }
  return null;
}
 

private static Rank interpretRank(Map<Term, String> terms){
  Rank rank = null;
  if (hasTerm(terms, DwcTerm.taxonRank)) {
    rank = RANK_PARSER.parse(value(terms, DwcTerm.taxonRank)).getPayload();
  }
  // try again with verbatim if it exists
  if (rank == null && hasTerm(terms, DwcTerm.verbatimTaxonRank)) {
    rank = RANK_PARSER.parse(value(terms, DwcTerm.verbatimTaxonRank)).getPayload();
  }
  // derive from atomized fields
  if (rank == null && hasTerm(terms, DwcTerm.genus)) {
    if (hasTerm(terms, DwcTerm.specificEpithet)) {
      if (hasTerm(terms, DwcTerm.infraspecificEpithet)) {
        rank = Rank.INFRASPECIFIC_NAME;
      } else {
        rank = Rank.SPECIES;
      }
    } else {
      rank = Rank.GENUS;
    }
  }
  return rank;
}
 

private int rankSimilarity(Rank query, Rank ref) {
  int similarity = 0;
  if (ref != null) {
    // rate ranks lower that are not represented in the canonical, e.g. cultivars
    if (ref.isRestrictedToCode() == NomenclaturalCode.CULTIVARS) {
      similarity -= 7;
    } else if (Rank.STRAIN == ref) {
      similarity -= 7;
    }

    if (ref.isUncomparable()) {
      // this also includes informal again
      similarity -= 3;
    }

    if (query != null) {
      // both ranks exist. Compare directly
      if (query.equals(ref)) {
        similarity += 10;

      } else if (Rank.INFRASPECIFIC_NAME == query && ref.isInfraspecific()
          || Rank.INFRASPECIFIC_NAME == ref && query.isInfraspecific()) {
        // unspecific infraspecific rank
        similarity += 5;

      } else if (Rank.INFRASUBSPECIFIC_NAME == query && ref.isInfraspecific() && ref != Rank.SUBSPECIES
          || Rank.INFRASUBSPECIFIC_NAME == ref && query.isInfraspecific() && query != Rank.SUBSPECIES) {
        // unspecific infrasubspecific rank
        similarity += 5;

      } else if (query.isUncomparable()) {
        // uncomparable query ranks
        similarity -= 5;

      } else if (ref == Rank.SPECIES && query.isInfraspecific() || ref.isSupraspecific() && query.isSpeciesOrBelow()
          || query == Rank.SPECIES && ref.isInfraspecific() || query.isSupraspecific() && ref.isSpeciesOrBelow()) {
        // not good, different number of epithets means rather unalike
        similarity -= 25;

      } else {
        // rate lower the further away the ranks are
        similarity -= Math.abs(ref.ordinal() - query.ordinal());
      }
    }

  } else if (query != null) {
    // reference has no rank, rate it lower
    similarity -= 1;
  }
  return minMax(-25, 5, similarity);
}
 

static void assertMatchConsistency(NameUsageMatch match) {
  assertNotNull(match.getConfidence());
  assertNotNull(match.getMatchType());
  if (NameUsageMatch.MatchType.NONE == match.getMatchType()) {
    assertNull(match.getUsageKey());
    assertNull(match.getScientificName());

    assertNull(match.getSpeciesKey());
    assertNull(match.getGenusKey());
    assertNull(match.getFamilyKey());
    assertNull(match.getOrderKey());
    assertNull(match.getClassKey());
    assertNull(match.getPhylumKey());
    assertNull(match.getKingdomKey());

    assertNull(match.getSpecies());
    assertNull(match.getGenus());
    assertNull(match.getFamily());
    assertNull(match.getOrder());
    assertNull(match.getClazz());
    assertNull(match.getPhylum());
    assertNull(match.getKingdom());

  } else {
    assertNotNull(match.getUsageKey());
    assertNotNull(match.getScientificName());

    if (match.getRank() != null) {
      Rank rank = match.getRank();
      if (rank.isSuprageneric()) {
        assertNull(match.getSpecies());
        assertNull(match.getSpeciesKey());
        assertNull(match.getGenus());
        assertNull(match.getGenusKey());

      } else if (rank == Rank.GENUS) {
        assertNotNull(match.getGenus());
        assertNull(match.getSpecies());
        assertNull(match.getSpeciesKey());

      } else if (rank == Rank.SPECIES) {
        assertNotNull(match.getGenus());
        assertNotNull(match.getSpecies());
        assertNotNull(match.getSpeciesKey());
        if (!match.isSynonym()) {
          assertEquals(match.getUsageKey(), match.getSpeciesKey());
          assertTrue(match.getScientificName().startsWith(match.getSpecies()));
        }

      } else if (rank.isInfraspecific()) {
        assertNotNull(match.getGenus());
        assertNotNull(match.getSpecies());
        assertNotNull(match.getSpeciesKey());
        if (!match.isSynonym()) {
          assertFalse(match.getUsageKey().equals(match.getSpeciesKey()));
          assertTrue(match.getScientificName().startsWith(match.getSpecies()));
        }

      }
    }
  }
}