import htsjdk.variant.vcf.VCFHeaderLineType; //导入依赖的package包/类
public static VCFHeaderLineType checkType(String type) {
	type = type.trim().toLowerCase();
	if(type.equals("integer")) {
		return VCFHeaderLineType.Integer;
	} else if(type.equals("float")) {
		return VCFHeaderLineType.Float;
	} else if(type.equals("string")) {
		return VCFHeaderLineType.String;
	} else if(type.equals("character")) {
		return VCFHeaderLineType.Character;
	} else if(type.equals("flag")) {
		return VCFHeaderLineType.Flag;
	} else {
		throw new IllegalArgumentException(ErrorMsg.VU_LINE_TYPE_ERR);
	}
}
 

import htsjdk.variant.vcf.VCFHeaderLineType; //导入依赖的package包/类
public void getFieldsValBED(NodeWithRefAlt query, NodeWithRefAlt db, boolean forceOverlap) {
	String val, name;
	AnnoFieldBean_bak field;

	for (String key : keys) {
		field = fields.get(key);
		val = db.colToValMap.get(bedFieldsMap.get(key) - 1);
		if(val == null) throw new IllegalArgumentException("Can't find val for column " + bedFieldsMap.get(key));
		
		name = field.getOutName() != null ? field.getOutName() : field.getName();
		if(field.getVcfInfo().getType() == VCFHeaderLineType.Flag) {
			results.add(new AnnNode(name, name));
		} else {
			if(forceOverlap) results.add(new AnnNode(name, field.getValForForceOverlap(val, query, db)));
			else results.add(new AnnNode(name, field.getVal(val, query, db)));
		}
	}
}
 

import htsjdk.variant.vcf.VCFHeaderLineType; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Override
public boolean filterLine(final T obj, String line) {
	
	if(line.startsWith(BEGIN)) {
		if(currentField != null) {
			Map<String, VCFInfoHeaderLine> infoMap = (Map<String, VCFInfoHeaderLine>)obj;
			infoMap.put(currentField, new VCFInfoHeaderLine(currentField, count, type, desc));
		}
		currentField = line.substring(1);
		if(currentField.trim().equals("")) throw new IllegalArgumentException("Field name is empty, please check filed name starts with @");
		desc = "";
		count = VCFHeaderLineCount.UNBOUNDED;
		type = VCFHeaderLineType.String;
		
		return false;
	} else if(line.equals("") || line.startsWith(COMMENT_LINE)) {
		return false;
	} else {
		return true;
	}
}
 

import htsjdk.variant.vcf.VCFHeaderLineType; //导入依赖的package包/类
private Map<String, Object> filterInfoByWhiteList(VariantContext context,
                                                  VcfFilterInfo vcfFilterInfo, VCFHeader vcfHeader) {
    Map<String, Object> permittedInfo = new HashMap<>();
    Map<String, Object> info = context.getAttributes();

    vcfFilterInfo.getInfoItems().forEach(key -> {
        if (info.containsKey(key.getName()) && vcfHeader.getInfoHeaderLine(key.getName()) != null) {
            int count = vcfHeader.getInfoHeaderLine(key.getName()).getCount(context);
            switch (key.getType()) {
                case Integer:
                    addNumberInfo(permittedInfo, info, count, VCFHeaderLineType.Integer, key);
                    break;
                case Float:
                    addNumberInfo(permittedInfo, info, count, VCFHeaderLineType.Float, key);
                    break;
                case Flag:
                    permittedInfo.put(key.getName(), parseFlagInfo(permittedInfo, info, count, key));
                    break;
                default:
                    permittedInfo.put(key.getName(), info.get(key.getName()));
            }
        }
    });

    return permittedInfo;
}
 

import htsjdk.variant.vcf.VCFHeaderLineType; //导入依赖的package包/类
private String getGroupByField(List<VcfFile> files, String groupBy) throws IOException {
    IndexSortField sortField = IndexSortField.getByName(groupBy);
    if (sortField == null) {
        VcfFilterInfo info = vcfManager.getFiltersInfo(
            files.stream().map(BaseEntity::getId).collect(Collectors.toList()));

        InfoItem infoItem = info.getInfoItemMap().get(groupBy);
        Assert.notNull(infoItem, "Unknown sort field: " + groupBy);

        if (infoItem.getType() == VCFHeaderLineType.Integer || infoItem.getType() == VCFHeaderLineType.Float) {
            return FeatureIndexFields.getGroupName(infoItem.getName().toLowerCase());
        } else {
            return infoItem.getName().toLowerCase();
        }
    } else {
        if (sortField.getType() == SortField.Type.INT || sortField.getType() == SortField.Type.FLOAT) {
            return sortField.getField().getGroupName();
        } else {
            return sortField.getField().fieldName;
        }
    }
}
 

import htsjdk.variant.vcf.VCFHeaderLineType; //导入依赖的package包/类
private static Value createTypedValue(VCFHeaderLineType type, Object value) {
  if (type == VCFHeaderLineType.Flag) {
    return Value.newBuilder().setBoolValue((Boolean) value).build();
  }

  // Booleans are given as Boolean objects. Strangely, Floats and Integers
  // are given as String objects by HTSJDK.
  if (!(value instanceof String)) {
    throw new IllegalStateException("Received non-Boolean, non-List type in non-String format. "
        + "This is most likely due to a change in htsjdk's library.");
  }

  String stringValue = (String) value;
  boolean isNumeric = stringValue.matches("[-+]?\\d+(\\.\\d+)?");

  if (type == VCFHeaderLineType.Integer && isNumeric) {
    return Value.newBuilder().setNumberValue(Integer.parseInt(stringValue)).build();
  }

  if (type == VCFHeaderLineType.Float && isNumeric) {
    return Value.newBuilder().setNumberValue(Double.parseDouble(stringValue)).build();
  }


  return Value.newBuilder().setStringValue(stringValue).build();
}
 

import htsjdk.variant.vcf.VCFHeaderLineType; //导入依赖的package包/类
private String getGroupByField(List<VcfFile> files, String groupBy) throws IOException {
    IndexSortField sortField = IndexSortField.getByName(groupBy);
    if (sortField == null) {
        VcfFilterInfo info = vcfManager.getFiltersInfo(
                files.stream().map(BaseEntity::getId).collect(Collectors.toList()));

        InfoItem infoItem = info.getInfoItemMap().get(groupBy);
        Assert.notNull(infoItem, "Unknown sort field: " + groupBy);

        if (infoItem.getType() == VCFHeaderLineType.Integer || infoItem.getType() == VCFHeaderLineType.Float) {
            return FeatureIndexFields.getGroupName(infoItem.getName().toLowerCase());
        } else {
            return infoItem.getName().toLowerCase();
        }
    } else {
        if (sortField.getType() == SortField.Type.INT || sortField.getType() == SortField.Type.FLOAT) {
            return sortField.getField().getGroupName();
        } else {
            return sortField.getField().fieldName;
        }
    }
}
 

import htsjdk.variant.vcf.VCFHeaderLineType; //导入依赖的package包/类
@Override
public void onTraversalStart() {
    final VCFHeader inputHeader = getHeaderForVariants();
    final Set<VCFHeaderLine> headerLines = new HashSet<>(inputHeader.getMetaDataInSortedOrder());
    headerLines.add(new VCFInfoHeaderLine(EXPECTED_ALLELE_FRACTION_NAME, 1, VCFHeaderLineType.Float, "expected allele fraction in pooled bam"));
    final VCFHeader vcfHeader = new VCFHeader(headerLines, inputHeader.getGenotypeSamples());
    headerLines.addAll(getDefaultToolVCFHeaderLines());
    vcfWriter = createVCFWriter(outputVcf);
    vcfWriter.writeHeader(vcfHeader);

    final List<MixingFraction> mixingFractionsList = MixingFraction.readMixingFractions(inputMixingFractions);
    final Map<String, Double> mixingfractionsMap = mixingFractionsList.stream()
            .collect(Collectors.toMap(MixingFraction::getSample, MixingFraction::getMixingFraction));
    mixingFractionsInSampleOrder = inputHeader.getSampleNamesInOrder().stream()
            .mapToDouble(mixingfractionsMap::get).toArray();
}
 

import htsjdk.variant.vcf.VCFHeaderLineType; //导入依赖的package包/类
private void addHeaders(VCFHeader header, String prefix, String infix, String note) {
    VCFInfoHeaderLine infoClinVarBasicInfo = new VCFInfoHeaderLine(prefix + infix + "BASIC_INFO",
            VCFHeaderLineCount.UNBOUNDED, VCFHeaderLineType.String,
            "Annotation of basic info with the form 'allele | hgvs string | origin'" + note);
    header.addMetaDataLine(infoClinVarBasicInfo);

    VCFInfoHeaderLine infoClinVarVarInfo = new VCFInfoHeaderLine(prefix + infix + "VAR_INFO",
            VCFHeaderLineCount.UNBOUNDED, VCFHeaderLineType.String,
            "Annotation of variant source information of the form 'allele | db name | id in db | origins'" + note);
    header.addMetaDataLine(infoClinVarVarInfo);
    
    VCFInfoHeaderLine infoClinVarDiseaseInfo = new VCFInfoHeaderLine(prefix + infix + "DISEASE_INFO",
            VCFHeaderLineCount.UNBOUNDED, VCFHeaderLineType.String,
            "Annotation of disease information of the form 'allele | significance | disease db | id in disease db "
                    + "| name in disease db | revision status | clinical accession'" + note);
    header.addMetaDataLine(infoClinVarDiseaseInfo);
}
 

import htsjdk.variant.vcf.VCFHeaderLineType; //导入依赖的package包/类
/**
 * Add header entries.
 * 
 * @param header The {@link VCFHeader} to extend.
 */
public void addHeaders(VCFHeader header) {
	header.addMetaDataLine(new VCFFilterHeaderLine(FILTER_GT_DE_NOVO_PARENT_AD2,
			"Supporting read count for alternative allele in tentative de novo call > "
					+ options.getDeNovoMaxParentAd2()));
	header.addMetaDataLine(new VCFFilterHeaderLine(FILTER_GT_DE_NOVO_IN_SIBLING,
			"Non-ref genotype also seen in sibling"));

	header.addMetaDataLine(
			new VCFFormatHeaderLine(FORMAT_GT_DE_NOVO, 1, VCFHeaderLineType.Character,
					"Whether the variant looks de novo by genotype, one of {'Y', 'N'}."));
	header.addMetaDataLine(
			new VCFFormatHeaderLine(FORMAT_PARENTS_REF, 1, VCFHeaderLineType.Character,
					"Whether both parent's genotype is reference, one of {'Y', 'N'}."));

	header.addMetaDataLine(new VCFFilterHeaderLine(FILTER_GT_ONE_PARENT_FILTERED,
			"One parent was filtered or no-call, filter child as well, important for inheritance "
					+ "filtration as filtered variants count as no-call which counts as "
					+ "wild-card by default; \"one/both parents filtered\" don't count. (enabled: "
					+ options.isApplyParentGtFilteredFilters() + ")"));
	header.addMetaDataLine(new VCFFilterHeaderLine(FILTER_GT_BOTH_PARENTS_FILTERED,
			"Both parents are filtered or no-call, filter child as well, important for inheritance "
					+ "filtration as filtered variants count as no-call which counts as "
					+ "wild-card by default; \"one/both parents filtered\" don't count. (enabled: "
					+ options.isApplyParentGtFilteredFilters() + ")"));
}
 

import htsjdk.variant.vcf.VCFHeaderLineType; //导入依赖的package包/类
@Override
public void writeHeader(final VCFHeader header) {
	final VCFHeader header2=new VCFHeader(header);
	header2.addMetaDataLine(
			new VCFInfoHeaderLine(this.ATT,
					VCFHeaderLineCount.UNBOUNDED,
					VCFHeaderLineType.String,
					"TRAP Score:((ALT|GENE|SCORE) in Trap Database  http://trap-score.org/"
				));
	header2.addMetaDataLine(
			new VCFInfoHeaderLine(this.ATT_MIN,
					1,
					VCFHeaderLineType.Float,
					"Min Score in Trap Database  http://trap-score.org/"
				));
	header2.addMetaDataLine(
			new VCFInfoHeaderLine(this.ATT_MAX,
					1,
					VCFHeaderLineType.Float,
					"Max Score in Trap Database  http://trap-score.org/"
				));
	super.writeHeader(header2);
	}
 

import htsjdk.variant.vcf.VCFHeaderLineType; //导入依赖的package包/类
@Override
public void writeHeader(final VCFHeader header) {
	this.limitToThoseFilters = 
			CtxWriterFactory.this.onlyThoseFiltersTagStr.stream().flatMap(
					S->Arrays.asList(S.split("[, ]")).stream()).
					filter(S->!StringUtil.isBlank(S)).
					collect(Collectors.toSet())
					;
	this.infoHeaderLine = new VCFInfoHeaderLine(
			CtxWriterFactory.this.infoName.trim(),
			VCFHeaderLineCount.UNBOUNDED,
			VCFHeaderLineType.String,
			"Variant was previously FILTERed with the given values."
			);
	if(header.getInfoHeaderLine(infoHeaderLine.getID())!=null)
		{
		throw new JvarkitException.UserError("INFO["+this.infoHeaderLine.getID()+"] already exists in input VCF.");
		}
	
	
	final VCFHeader h2= new VCFHeader(header);	
	h2.addMetaDataLine(this.infoHeaderLine);
	super.writeHeader(h2);
	}
 

import htsjdk.variant.vcf.VCFHeaderLineType; //导入依赖的package包/类
CtxWriter(final VariantContextWriter delegate) {
super(delegate);
Objects.requireNonNull(delegate);
Arrays.fill(this.ome2manifest,null);
for(final OmeType ome:OmeType.values()) {
	for(final String pop: POPS)
		{
		if(!CtxWriterFactory.this.doNotInsertAlleleCount) this.infoFields.add(new InfoField("AC_"+pop,ome,true,VCFHeaderLineType.Integer));
		if(!CtxWriterFactory.this.doNotInsertAlleleFreq) this.infoFields.add(new InfoField("AF_"+pop,ome,true,VCFHeaderLineType.Float));
		if(!CtxWriterFactory.this.doNotInsertAlleleNumber) this.infoFields.add(new InfoField("AN_"+pop,ome,pop.equals("POPMAX"),VCFHeaderLineType.Integer));
		}
	if(!CtxWriterFactory.this.doNotInsertAlleleCount) this.infoFields.add(new InfoField("AC",ome,true,VCFHeaderLineType.Integer));
	if(!CtxWriterFactory.this.doNotInsertAlleleFreq) infoFields.add(new InfoField("AF",ome,true,VCFHeaderLineType.Float));
	if(!CtxWriterFactory.this.doNotInsertAlleleNumber) infoFields.add(new InfoField("AN",ome,false,VCFHeaderLineType.Integer));
	}
}
 

import htsjdk.variant.vcf.VCFHeaderLineType; //导入依赖的package包/类
public void setBedHeaderInfo(String dbLabel) {
		if(count == null) {
			System.err.println("You should set number for field " + name + " of bed file " + dbLabel + ", or we will use 'number=.' instead. ");
			count = VCFHeaderLineCount.UNBOUNDED;
		}
		if(type == null) {
			System.err.println("You should set type for field " + name + " of bed file " + dbLabel + ", or we will use 'type=string' instead. ");
			type = VCFHeaderLineType.String;
		}
//		if(count == null || type == null) throw new IllegalArgumentException("DB format is bed, please set number and type for field name " + name);
		this.vcfInfo = new VCFInfoHeaderLine((outName != null) ? outName:getName() , count, type, description);
	}
 

import htsjdk.variant.vcf.VCFHeaderLineType; //导入依赖的package包/类
public void getFieldsValVCF(NodeWithRefAlt query, NodeWithRefAlt db, boolean forceOverlap) {
	int beg, end;
	String val, info = db.info, name;
	AnnoFieldBean_bak field;
	for (String key : keys) {
		field = fields.get(key);
		name = field.getOutName() != null ? field.getOutName() : field.getName();
		beg = info.indexOf(field.getName());
		if(beg != -1) {
			if(field.getVcfInfo().getType() == VCFHeaderLineType.Flag) {
				results.add(new AnnNode(name, name));
			} else {
				beg = info.indexOf("=", beg);
				end = info.indexOf(VCFConstants.INFO_FIELD_SEPARATOR, beg);
				if(end == -1) {
					val = info.substring(beg + 1);
				} else {
					val = info.substring(beg + 1, end);
				}
				
				if(forceOverlap) results.add(new AnnNode(name, field.getValForForceOverlap(val, query, db)));
				else results.add(new AnnNode(name, field.getVal(val, query, db)));
			}
		} else {
			if(field.getVcfInfo().getType() == VCFHeaderLineType.Flag) {
				results.add(new AnnNode(name, null));
			} else {
				throw new IllegalArgumentException("Can't find field " + name + " in " + db.origStr);
			}
		}
	}
}
 

import htsjdk.variant.vcf.VCFHeaderLineType; //导入依赖的package包/类
@Override
public List<VCFInfoHeaderLine> getDescriptions() {
    return Arrays.asList(
            new VCFInfoHeaderLine(CCC, 1, VCFHeaderLineType.Integer, "Number of called chromosomes"),
            new VCFInfoHeaderLine(NCC, 1, VCFHeaderLineType.Integer, "Number of no-called samples"),
            new VCFInfoHeaderLine(HWP, 1, VCFHeaderLineType.Float, "P value from test of Hardy Weinberg Equilibrium"),
            new VCFInfoHeaderLine(GQ_MEAN, 1, VCFHeaderLineType.Float, "Mean of all GQ values"),
            new VCFInfoHeaderLine(GQ_STDDEV, 1, VCFHeaderLineType.Float, "Standard deviation of all GQ values")
    );
}
 

import htsjdk.variant.vcf.VCFHeaderLineType; //导入依赖的package包/类
public static Set<VCFHeaderLine> getVCFHeaderInfo() {
    Set<VCFHeaderLine> headerInfo = new HashSet<VCFHeaderLine>();


    headerInfo.add(new VCFFilterHeaderLine("REJECT", "Rejected as a confident somatic mutation"));
    headerInfo.add(new VCFFilterHeaderLine("PASS", "Accept as a confident somatic mutation"));

    // TODO: what fields do we need here
    VCFStandardHeaderLines.addStandardInfoLines(headerInfo, true,
            VCFConstants.MAPPING_QUALITY_ZERO_KEY,
            VCFConstants.DBSNP_KEY,
            VCFConstants.SOMATIC_KEY);

    // TODO copy from TCGA spec..
    headerInfo.add(new VCFInfoHeaderLine("VT", 1, VCFHeaderLineType.String, "Variant type, can be SNP, INS or DEL"));


    VCFStandardHeaderLines.addStandardFormatLines(headerInfo, true,
            VCFConstants.GENOTYPE_KEY,
            VCFConstants.GENOTYPE_QUALITY_KEY,
            VCFConstants.DEPTH_KEY,
            VCFConstants.GENOTYPE_ALLELE_DEPTHS,
            VCFConstants.GENOTYPE_PL_KEY);

    // cancer-specific
    // TODO: push to VCFConstants in GATK
    headerInfo.add(new VCFFormatHeaderLine("FA", VCFHeaderLineCount.A, VCFHeaderLineType.Float, "Allele fraction of the alternate allele with regard to reference"));
    headerInfo.add(new VCFFormatHeaderLine("SS", 1, VCFHeaderLineType.Integer, "Variant status relative to non-adjacent Normal,0=wildtype,1=germline,2=somatic,3=LOH,4=post-transcriptional modification,5=unknown"));
    headerInfo.add(new VCFFormatHeaderLine(VCFConstants.RMS_BASE_QUALITY_KEY, VCFHeaderLineCount.A, VCFHeaderLineType.Float, "Average base quality for reads supporting alleles"));

    return headerInfo;
}
 

import htsjdk.variant.vcf.VCFHeaderLineType; //导入依赖的package包/类
private void addNumberInfo(Map<String, Object> permittedInfo, Map<String, Object> info, int count,
                           VCFHeaderLineType type, InfoItem key) {
    Object value;
    if (count > 1) {
        value = parseNumberArray(type, info.get(key.getName()));

        if (value == null) {
            LOGGER.error(MessageHelper.getMessage(
                MessagesConstants.ERROR_FEATURE_INDEX_WRITING_WRONG_PARAMETER_TYPE,
                key.getName(), key.getType(), info.get(key.getName()).toString()));
            return;
        }

        permittedInfo.put("_" + key.getName() + "_v", info.get(key.getName()).toString());
    } else {
        String numberString = info.get(key.getName()).toString();

        if (NumberUtils.isNumber(numberString)) {
            value = parseNumber(type, info.get(key.getName()));
        } else {
            LOGGER.error(MessageHelper.getMessage(
                MessagesConstants.ERROR_FEATURE_INDEX_WRITING_WRONG_PARAMETER_TYPE, key.getName(), key.getType(),
                numberString));
            return;
        }
    }

    permittedInfo.put(key.getName(), value);
}
 

import htsjdk.variant.vcf.VCFHeaderLineType; //导入依赖的package包/类
private Object parseNumberArray(VCFHeaderLineType type, Object infoObject) {
    switch (type) {
        case Integer:
            return Utils.parseIntArray(infoObject.toString());
        case Float:
            return Utils.parseFloatArray(infoObject.toString());
        default:
            throw new IllegalArgumentException(MessageHelper.getMessage(
                MessagesConstants.ERROR_FEATURE_INDEX_INVALID_NUMBER_FORMAT, type));
    }
}
 

import htsjdk.variant.vcf.VCFHeaderLineType; //导入依赖的package包/类
private Object parseNumber(VCFHeaderLineType type, Object infoObject) {
    switch (type) {
        case Integer:
            return Integer.parseInt(infoObject.toString());
        case Float:
            return Float.parseFloat(infoObject.toString());
        default:
            throw new IllegalArgumentException(MessageHelper.getMessage(
                MessagesConstants.ERROR_FEATURE_INDEX_INVALID_NUMBER_FORMAT, type));
    }
}