Java Variant类代码示例

import com.google.api.services.genomics.model.Variant; //导入依赖的package包/类
@Override
public String toString() {
  final Function<Pair<Variant,VariantCall>, String> getStartAndEnd = new Function<Pair<Variant,VariantCall>, String>() {
    @Override
    public String apply(Pair<Variant,VariantCall> pair) {
      return pair.getValue0().getStart().toString() + "-"
          + pair.getValue0().getEnd().toString();
    }
  };

  return Joiner.on(", ").join(FluentIterable.from(Arrays.asList(TrioMember.values()))
      .transform(new Function<TrioMember, String>() {
        @Override
        public String apply(TrioMember person) {
          return person.toString() + ":[" + Joiner.on(",").join(
              FluentIterable.from(getQueue(person)).transform(getStartAndEnd)) + "]";
        }
      }));
}
 

import com.google.api.services.genomics.model.Variant; //导入依赖的package包/类
/** Is variant, call pair a snp
 * @param pair
 * @return success
 */
private boolean isSnp(Pair<Variant, VariantCall> pair) {
  Variant variant = pair.getValue0();
  VariantCall call = pair.getValue1();
  if (variant.getEnd() != variant.getStart() + Long.valueOf(1L)) {
    return false;
  }

  // check for Indels
  if (variant.getReferenceBases().length() != 1) {
    return false;
  }

  for (int gtIdx : call.getGenotype()) {
    if (gtIdx > 0 && variant.getAlternateBases().get(gtIdx - 1).length() != 1) {
      return false;
    }
  }
  return true;
}
 

import com.google.api.services.genomics.model.Variant; //导入依赖的package包/类
@Override Genomics.Variants.Search createSearch(Genomics.Variants api,
    final SearchVariantsRequest request, Optional<String> pageToken) throws IOException {

  if(shardBoundary == ShardBoundary.Requirement.STRICT) {
    // TODO: When this is supported server-side, instead verify that request.getIntersectionType
    // will yield a strict shard.
    shardPredicate = new Predicate<Variant>() {
      @Override
      public boolean apply(Variant variant) {
        return variant.getStart() >= request.getStart();
      }
    };
  }

  return api.search(pageToken
      .transform(
          new Function<String, SearchVariantsRequest>() {
            @Override public SearchVariantsRequest apply(String token) {
              return request.setPageToken(token);
            }
          })
      .or(request));
}
 

import com.google.api.services.genomics.model.Variant; //导入依赖的package包/类
public static Variant makeVariant(String referenceName, long start, long end,
    String referenceBases, List<String> alternateBases, VariantCall... calls) {
  Variant variant =
      new Variant().setReferenceName(referenceName).setStart(start).setEnd(end)
          .setReferenceBases(referenceBases).setAlternateBases(alternateBases);
  if (null != calls) {
    variant.setCalls(Arrays.asList(calls));
  }
  return variant;
}
 

import com.google.api.services.genomics.model.Variant; //导入依赖的package包/类
/**
 * @return get variants
 * @throws IOException API hangups
 */
public List<Variant> getVariants() throws IOException {

  requestCount++;
  request.setPageToken(nextPageToken);

  shared.getLogger().finer(
    String.format("Executing Search Variants Request : " + String.valueOf(requestCount)));

  SearchVariantsResponse response = shared.getGenomics().variants().search(request).execute();

  nextPageToken = response.getNextPageToken();
  return response.getVariants();
}
 

import com.google.api.services.genomics.model.Variant; //导入依赖的package包/类
/** Pop first element from queue
 * @param person
 * @return first element in queue
 */
Pair<Variant,VariantCall> pop(TrioMember person) {
  if (isEmpty(person)) {
    throw new IllegalStateException("Trying to pop from empty queue");
  }
  return getQueue(person).removeFirst();
}
 

import com.google.api.services.genomics.model.Variant; //导入依赖的package包/类
/** Check if a call passes filters for queue and then add it
 * @param person
 * @param pair
 * @return success
 */
boolean checkAndAdd(TrioMember person, Pair<Variant, VariantCall> pair) {

  VariantCall variant = pair.getValue1();
  if (person == CHILD && !isSnp(pair)
      ||callContainsDot(variant)
      || !callIsBiAllelic(variant)
      || !passesFilter(variant)
      || isInsertion(pair)
      || isDeletion(pair)) {
    return false;
  }
  push(person, pair);
  return true;
}
 

import com.google.api.services.genomics.model.Variant; //导入依赖的package包/类
/**
 * Returns the next available PositionCall
 */
PositionCall retrieveNextCall() {
  evictParents();

  Pair<Variant, VariantCall> childSNP = getNextSNP(CHILD);
  Long snpPosition = childSNP.getValue0().getStart();
  String referenceBase = childSNP.getValue0().getReferenceBases();
  Map<TrioMember, Genotype> genotypeMap = new TreeMap<>();

  for (TrioMember person : TrioMember.values()) {

    if (person == CHILD) {
      genotypeMap.put(CHILD, getGenotypeFromSNP(childSNP));
      continue;
    }

    Optional<Pair<Variant, VariantCall>> parentVariant =
        Optional.fromNullable(getMatchingPair(person, snpPosition));
    if (!parentVariant.isPresent()) {
      return null;
    }

    genotypeMap.put(person, isSnp(parentVariant.get())
        ? getGenotypeFromSNP(parentVariant.get())
        : Genotype.valueOf(referenceBase + referenceBase));
  }
  return new PositionCall(snpPosition, genotypeMap);
}
 

import com.google.api.services.genomics.model.Variant; //导入依赖的package包/类
/** Return the genotype corresponding to the SNP
 * @param pair of variant,call corresponding to snp
 * @return genotype corresponding to the SNP
 */
private Genotype getGenotypeFromSNP(Pair<Variant, VariantCall> pair) {
  Variant variant = pair.getValue0();
  VariantCall call = pair.getValue1();
  Allele[] allelePair = new Allele[2];

  for (int idx = 0; idx < 2; idx++) {
    int gtidx = call.getGenotype().get(idx);
    allelePair[idx] = gtidx > 0 ? Allele.valueOf(variant.getAlternateBases().get(gtidx - 1))
        : Allele.valueOf(variant.getReferenceBases());
  }
  return Genotype.valueOfPairAlleles(allelePair[0], allelePair[1]);
}
 

import com.google.api.services.genomics.model.Variant; //导入依赖的package包/类
/** is variant , call an insertion
 * @param pair
 * @return match
 */
private boolean isInsertion(Pair<Variant, VariantCall> pair) {
  Variant variant = pair.getValue0();
  VariantCall call = pair.getValue1();
  for (int gtIdx : call.getGenotype()) {
    if (gtIdx > 0 && variant.getAlternateBases().get(gtIdx - 1).length() != 1) {
      return true;
    }
  }
  return false;
}
 

import com.google.api.services.genomics.model.Variant; //导入依赖的package包/类
/** Get Matching variant from the queue
 * @param person trio member
 * @param snpPosition
 * @return Get matching variant call pairs at matching position
 */
private Pair<Variant, VariantCall> getMatchingPair(TrioMember person, Long snpPosition) {
  for (Pair<Variant, VariantCall> pair : getQueue(person)) {
    Variant variant = pair.getValue0();

    if (Ranges.closedOpen(variant.getStart(), variant.getEnd()).contains(snpPosition)) {
      return pair;
    }
  }
  return null;
}
 

import com.google.api.services.genomics.model.Variant; //导入依赖的package包/类
/** Get next available SNP
 * @param person trio member
 * @return next pair of variant, call corresponding to snp for person
 */
private Pair<Variant, VariantCall> getNextSNP(TrioMember person) {
  Pair<Variant, VariantCall> pair = getFirst(person);

  if (!isSnp(pair)) {
    throw new IllegalStateException("Expected SNP : got " + pair);
  }
  return pair;
}
 

import com.google.api.services.genomics.model.Variant; //导入依赖的package包/类
@Test
public void testPush() {
  Variant v = new Variant().setStart(1L).setEnd(100001L);
  Pair<Variant, VariantCall> pair = Pair.with(v,dummyCall);

  vbuf.push(DAD, pair);

  assertEquals(1, vbuf.getBufferMap().get(DAD).size());
  assertEquals(pair, vbuf.getBufferMap().get(DAD).getFirst());
}
 

import com.google.api.services.genomics.model.Variant; //导入依赖的package包/类
@Test
public void testPop() {
  Variant v = new Variant().setStart(1L).setEnd(100001L);
  Pair<Variant, VariantCall> pair = Pair.with(v,dummyCall);
  vbuf.push(DAD, pair);
  Pair<Variant,VariantCall> popv = vbuf.pop(DAD);

  assertEquals(0, vbuf.getBufferMap().get(DAD).size());
  assertEquals(pair, popv);
}
 

import com.google.api.services.genomics.model.Variant; //导入依赖的package包/类
@Test
public void testGetStartPosition() {
  vbuf.push(DAD, Pair.with(new Variant().setStart(1L).setEnd(10001L), dummyCall));
  vbuf.push(DAD, Pair.with(new Variant().setStart(10002L).setEnd(10003L), dummyCall));

  assertEquals(Long.valueOf(0L), vbuf.getStartPosition(MOM));
  assertEquals(Long.valueOf(1L), vbuf.getStartPosition(DAD));
}