Java QuotedPrintableCodec.decode方法代码示例

import org.apache.commons.codec.net.QuotedPrintableCodec; //导入方法依赖的package包/类
/**
 * <p>Parses the FN type.</p>
 *
 * @param group
 * @param value
 * @param paramTypeList
 * @param vcard
 * @throws VCardBuildException
 */
private void parseFnType(String group, String value, List<ParameterType> paramTypeList, VCardImpl vcard) throws VCardBuildException {
	try {
		FormattedNameType formattedNameFeature = new FormattedNameType();

		for (ParameterType pt : paramTypeList) {					
			if(pt.getName().equals("CHARSET")) {
				formattedNameFeature.setCharset(pt.getValue());
				value = new String(value.getBytes(), formattedNameFeature.getCharset().name());
			}
			else if(pt.getName().equals("ENCODING")) {
				if(pt.getValue().equals(EncodingType.QUOTED_PRINTABLE.getType())) {
					formattedNameFeature.setEncodingType(EncodingType.QUOTED_PRINTABLE);
				}
			}
			else if(pt.getName().equals("LANGUAGE")) {
				formattedNameFeature.setLanguage(pt.getValue());
			}
			else {
				ExtendedParameterType parameter = new ExtendedParameterType(pt.getName(), pt.getValue());                                               
				formattedNameFeature.addExtendedParameter(parameter);
			}
		}
		
		if(formattedNameFeature.getEncodingType() == EncodingType.QUOTED_PRINTABLE) {
			QuotedPrintableCodec q = new QuotedPrintableCodec();
			
			if(isCharsetForced()) {
				value = q.decode(value, forceCharset.name());
			}
			else { 
				if(formattedNameFeature.hasCharset()) {
					value = q.decode(value, formattedNameFeature.getCharset().name());
				}
				else {
					value = q.decode(value);
				}
			}
		}

		formattedNameFeature.setFormattedName(VCardUtils.unescapeString(value));
		
		if(group != null) {
			formattedNameFeature.setGroup(group);
		}
		
		vcard.setFormattedName(formattedNameFeature);
	}
	catch(Exception ex) {
		throw new VCardBuildException("FormattedNameType ("+VCardType.FN.getType()+") ["+ex.getClass().getName()+"] "+ex.getMessage(), ex);
	}
}
 

import org.apache.commons.codec.net.QuotedPrintableCodec; //导入方法依赖的package包/类
/**
 * <p>Parses the N type.</p>
 *
 * @param group
 * @param value
 * @param paramTypeList
 * @param vcard
 * @throws VCardBuildException
 */
private void parseNType(String group, String value, List<ParameterType> paramTypeList, VCardImpl vcard) throws VCardBuildException {
	try {
		NameType nameFeature = new NameType();

		for (ParameterType pt : paramTypeList) {					
			if(pt.getName().equals("CHARSET")) {
				nameFeature.setCharset(pt.getValue());
			}
			else if(pt.getName().equals("ENCODING")) {
				if(pt.getValue().equals(EncodingType.QUOTED_PRINTABLE.getType())) {
					nameFeature.setEncodingType(EncodingType.QUOTED_PRINTABLE);
				}
			}
			else if(pt.getName().equals("LANGUAGE")) {
				nameFeature.setLanguage(pt.getValue());
			}
			else {
				throw new VCardBuildException("Invalid parameter type: "+pt);
			}
		}
		
		if(nameFeature.getEncodingType() == EncodingType.QUOTED_PRINTABLE) {
			QuotedPrintableCodec q = new QuotedPrintableCodec();
			
			if(isCharsetForced()) {
				value = q.decode(value, forceCharset.name());
			}
			else { 
				if(nameFeature.hasCharset()) {
					value = q.decode(value, nameFeature.getCharset().name());
				}
				else {
					value = q.decode(value);
				}
			}
		}
		
		switch(compatMode)
		{
			case MS_OUTLOOK:
			{
				parseNTypeOutlook(nameFeature, value);
				break;
			}

			default:
			{
				parseNTypeRFC(nameFeature, value);
				break;
			}
		}
		
		if(group != null) {
			nameFeature.setGroup(group);
		}

		vcard.setName(nameFeature);
	}
	catch(Exception ex) {
		throw new VCardBuildException("NameType ("+VCardType.N.getType()+") ["+ex.getClass().getName()+"] "+ex.getMessage(), ex);
	}
}
 

import org.apache.commons.codec.net.QuotedPrintableCodec; //导入方法依赖的package包/类
/**
 * <p>Parses the Nickname type.</p>
 *
 * @param group
 * @param value
 * @param paramTypeList
 * @param vcard
 * @throws VCardBuildException
 */
private void parseNicknameType(String group, String value, List<ParameterType> paramTypeList, VCardImpl vcard) throws VCardBuildException {
	try {
		NicknameType nicknameFeature = new NicknameType();

		for (ParameterType pt : paramTypeList) {					
			if(pt.getName().equals("CHARSET")) {
				nicknameFeature.setCharset(pt.getValue());
			}
			else if(pt.getName().equals("ENCODING")) {
				if(pt.getValue().equals(EncodingType.QUOTED_PRINTABLE.getType())) {
					nicknameFeature.setEncodingType(EncodingType.QUOTED_PRINTABLE);
				}
			}
			else if(pt.getName().equals("LANGUAGE")) {
				nicknameFeature.setLanguage(pt.getValue());
			}
			else {
				ExtendedParameterType parameter = new ExtendedParameterType(pt.getName(), pt.getValue());                                               
				nicknameFeature.addExtendedParameter(parameter);
			}
		}
		
		if(nicknameFeature.getEncodingType() == EncodingType.QUOTED_PRINTABLE) {
			QuotedPrintableCodec q = new QuotedPrintableCodec();
			
			if(isCharsetForced()) {
				value = q.decode(value, forceCharset.name());
			}
			else { 
				if(nicknameFeature.hasCharset()) {
					value = q.decode(value, nicknameFeature.getCharset().name());
				}
				else {
					value = q.decode(value);
				}
			}
		}
		
		String[] nicknames = VCardUtils.parseStringWithEscappedDelimiter(value, ',');
		for(int i = 0; i < nicknames.length; i++) {
			if(VCardUtils.needsUnEscaping(nicknames[i])) {
				nicknameFeature.addNickname(VCardUtils.unescapeString(nicknames[i]));
			}
			else {
				nicknameFeature.addNickname(nicknames[i]);
			}
		}
		
		if(group != null) {
			nicknameFeature.setGroup(group);
		}
		
		vcard.setNicknames(nicknameFeature);
	}
	catch(Exception ex) {
		throw new VCardBuildException("NicknameType ("+VCardType.NICKNAME.getType()+") ["+ex.getClass().getName()+"] "+ex.getMessage(), ex);
	}
}
 

import org.apache.commons.codec.net.QuotedPrintableCodec; //导入方法依赖的package包/类
/**
 * <p>Parses the TEL type.</p>
 *
 * @param group
 * @param value
 * @param paramTypeList
 * @param vcard
 * @throws VCardBuildException
 */
private void parseTelType(String group, String value, List<ParameterType> paramTypeList, VCardImpl vcard) throws VCardBuildException {
	try {
		TelephoneType telephoneFeature = new TelephoneType();

		for (ParameterType pt : paramTypeList) {					
			if(pt.getName().equals("CHARSET")) {
				telephoneFeature.setCharset(pt.getValue());
			}
			else if(pt.getName().equals("ENCODING")) {
				if(pt.getValue().equals(EncodingType.QUOTED_PRINTABLE.getType())) {
					telephoneFeature.setEncodingType(EncodingType.QUOTED_PRINTABLE);
				}
			}
			else if(pt.getName().equals("TYPE")) {
				if(pt.getValue().indexOf(',') != -1) {
					String[] typeValueList = pt.getValue().split(",");
					for(String typeValue : typeValueList) {
						setTelParameterType(telephoneFeature, typeValue);
					}
				}
				else {
					setTelParameterType(telephoneFeature, pt.getValue());
				}
			}
			else if(pt.getName().equals("LANGUAGE")) {
				telephoneFeature.setLanguage(pt.getValue());
			}
			else {
				ExtendedParameterType parameter = new ExtendedParameterType(pt.getName(), pt.getValue());                                               
				telephoneFeature.addExtendedParameter(parameter);
			}
		}
		
		if(telephoneFeature.getEncodingType() == EncodingType.QUOTED_PRINTABLE) {
			QuotedPrintableCodec q = new QuotedPrintableCodec();

			if(isCharsetForced()) {
				value = q.decode(value, forceCharset.name());
			}
			else { 
				if(telephoneFeature.hasCharset()) {
					value = q.decode(value, telephoneFeature.getCharset().name());
				}
				else {
					value = q.decode(value);
				}
			}
		}
		
		telephoneFeature.setTelephone(VCardUtils.unescapeString(value));
		if(group != null) {
			telephoneFeature.setGroup(group);
		}
		
		vcard.addTelephoneNumber(telephoneFeature);
	}
	catch(Exception ex) {
		throw new VCardBuildException("TelephoneType ("+VCardType.TEL.getType()+") ["+ex.getClass().getName()+"] "+ex.getMessage(), ex);
	}
}
 

import org.apache.commons.codec.net.QuotedPrintableCodec; //导入方法依赖的package包/类
/**
 * <p>Parses the MAILER type.</p>
 *
 * @param group
 * @param value
 * @param paramTypeList
 * @param vcard
 * @throws VCardBuildException
 */
private void parseMailerType(String group, String value, List<ParameterType> paramTypeList, VCardImpl vcard) throws VCardBuildException {
	try {
		MailerType mailerFeature = new MailerType();
		
		for (ParameterType pt : paramTypeList) {					
			if(pt.getName().equals("CHARSET")) {
				mailerFeature.setCharset(pt.getValue());
			}
			else if(pt.getName().equals("ENCODING")) {
				if(pt.getValue().equals(EncodingType.QUOTED_PRINTABLE.getType())) {
					mailerFeature.setEncodingType(EncodingType.QUOTED_PRINTABLE);
				}
			}
			else if(pt.getName().equals("LANGUAGE")) {
				mailerFeature.setLanguage(pt.getValue());
			}
			else {
				ExtendedParameterType parameter = new ExtendedParameterType(pt.getName(), pt.getValue());                                               
				mailerFeature.addExtendedParameter(parameter);
			}
		}
		
		if(mailerFeature.getEncodingType() == EncodingType.QUOTED_PRINTABLE) {
			QuotedPrintableCodec q = new QuotedPrintableCodec();

			if(isCharsetForced()) {
				value = q.decode(value, forceCharset.name());
			}
			else { 
				if(mailerFeature.hasCharset()) {
					value = q.decode(value, mailerFeature.getCharset().name());
				}
				else {
					value = q.decode(value);
				}
			}
		}
		
		mailerFeature.setMailer(VCardUtils.unescapeString(value));
		if(group != null) {
			mailerFeature.setGroup(group);
		}
		
		vcard.setMailer(mailerFeature);
	}
	catch(Exception ex) {
		throw new VCardBuildException("MailerType ("+VCardType.MAILER.getType()+") ["+ex.getClass().getName()+"] "+ex.getMessage(), ex);
	}
}
 

import org.apache.commons.codec.net.QuotedPrintableCodec; //导入方法依赖的package包/类
/**
 * <p>Parses the TITLE type.</p>
 *
 * @param group
 * @param value
 * @param paramTypeList
 * @param vcard
 * @throws VCardBuildException
 */
private void parseTitleType(String group, String value, List<ParameterType> paramTypeList, VCardImpl vcard) throws VCardBuildException {
	try {
		TitleType titleFeature = new TitleType();

		for (ParameterType pt : paramTypeList) {					
			if(pt.getName().equals("CHARSET")) {
				titleFeature.setCharset(pt.getValue());
			}
			else if(pt.getName().equals("ENCODING")) {
				if(pt.getValue().equals(EncodingType.QUOTED_PRINTABLE.getType())) {
					titleFeature.setEncodingType(EncodingType.QUOTED_PRINTABLE);
				}
			}
			else if(pt.getName().equals("LANGUAGE")) {
				titleFeature.setLanguage(pt.getValue());
			}
			else {
				ExtendedParameterType parameter = new ExtendedParameterType(pt.getName(), pt.getValue());                                               
				titleFeature.addExtendedParameter(parameter);
			}
		}
		
		if(titleFeature.getEncodingType() == EncodingType.QUOTED_PRINTABLE) {
			QuotedPrintableCodec q = new QuotedPrintableCodec();

			if(isCharsetForced()) {
				value = q.decode(value, forceCharset.name());
			}
			else { 
				if(titleFeature.hasCharset()) {
					value = q.decode(value, titleFeature.getCharset().name());
				}
				else {
					value = q.decode(value);
				}
			}
		}
		
		titleFeature.setTitle(VCardUtils.unescapeString(value));
		if(group != null) {
			titleFeature.setGroup(group);
		}
		
		vcard.setTitle(titleFeature);
	}
	catch(Exception ex) {
		throw new VCardBuildException("TitleType ("+VCardType.TITLE.getType()+") ["+ex.getClass().getName()+"] "+ex.getMessage(), ex);
	}
}
 

import org.apache.commons.codec.net.QuotedPrintableCodec; //导入方法依赖的package包/类
/**
 * <p>Parses the ROLE type.</p>
 *
 * @param group
 * @param value
 * @param paramTypeList
 * @param vcard
 * @throws VCardBuildException
 */
private void parseRoleType(String group, String value, List<ParameterType> paramTypeList, VCardImpl vcard) throws VCardBuildException {
	try {
		RoleType roleFeature = new RoleType();

		for (ParameterType pt : paramTypeList) {					
			if(pt.getName().equals("CHARSET")) {
				roleFeature.setCharset(pt.getValue());
			}
			else if(pt.getName().equals("ENCODING")) {
				if(pt.getValue().equals(EncodingType.QUOTED_PRINTABLE.getType())) {
					roleFeature.setEncodingType(EncodingType.QUOTED_PRINTABLE);
				}
			}
			else if(pt.getName().equals("LANGUAGE")) {
				roleFeature.setLanguage(pt.getValue());
			}
			else {
				ExtendedParameterType parameter = new ExtendedParameterType(pt.getName(), pt.getValue());                                               
				roleFeature.addExtendedParameter(parameter);
			}
		}
		
		if(roleFeature.getEncodingType() == EncodingType.QUOTED_PRINTABLE) {
			QuotedPrintableCodec q = new QuotedPrintableCodec();

			if(isCharsetForced()) {
				value = q.decode(value, forceCharset.name());
			}
			else { 
				if(roleFeature.hasCharset()) {
					value = q.decode(value, roleFeature.getCharset().name());
				}
				else {
					value = q.decode(value);
				}
			}
		}
		
		roleFeature.setRole(VCardUtils.unescapeString(value));
		if(group != null) {
			roleFeature.setGroup(group);
		}
		
		vcard.setRole(roleFeature);
	}
	catch(Exception ex) {
		throw new VCardBuildException("RoleType ("+VCardType.ROLE.getType()+") ["+ex.getClass().getName()+"] "+ex.getMessage(), ex);
	}
}
 

import org.apache.commons.codec.net.QuotedPrintableCodec; //导入方法依赖的package包/类
/**
 * <p>Parses the ORG type.</p>
 *
 * @param group
 * @param value
 * @param paramTypeList
 * @param vcard
 * @throws VCardBuildException
 */
private void parseOrgType(String group, String value, List<ParameterType> paramTypeList, VCardImpl vcard) throws VCardBuildException {
	try {
		OrganizationType organizationFeature = new OrganizationType();

		for (ParameterType pt : paramTypeList) {					
			if(pt.getName().equals("CHARSET")) {
				organizationFeature.setCharset(pt.getValue());
			}
			else if(pt.getName().equals("ENCODING")) {
				if(pt.getValue().equals(EncodingType.QUOTED_PRINTABLE.getType())) {
					organizationFeature.setEncodingType(EncodingType.QUOTED_PRINTABLE);
				}
			}
			else if(pt.getName().equals("LANGUAGE")) {
				organizationFeature.setLanguage(pt.getValue());
			}
			else {
				ExtendedParameterType parameter = new ExtendedParameterType(pt.getName(), pt.getValue());                                               
				organizationFeature.addExtendedParameter(parameter);
			}
		}
		
		if(organizationFeature.getEncodingType() == EncodingType.QUOTED_PRINTABLE) {
			QuotedPrintableCodec q = new QuotedPrintableCodec();

			if(isCharsetForced()) {
				value = q.decode(value, forceCharset.name());
			}
			else { 
				if(organizationFeature.hasCharset()) {
					value = q.decode(value, organizationFeature.getCharset().name());
				}
				else {
					value = q.decode(value);
				}
			}
		}
		
		String[] orgs = VCardUtils.parseStringWithEscappedDelimiter(value, ';');
		for(int i = 0; i < orgs.length; i++) {
			if(VCardUtils.needsUnEscaping(orgs[i])) {
				String unesc = VCardUtils.unescapeString(orgs[i]);
				organizationFeature.addOrganization(unesc);
			}
			else {
				organizationFeature.addOrganization(orgs[i]);
			}
		}
		
		if(group != null) {
			organizationFeature.setGroup(group);
		}
		
		vcard.setOrganizations(organizationFeature);
	}
	catch(Exception ex) {
		throw new VCardBuildException("OrganizationType ("+VCardType.ORG.getType()+") ["+ex.getClass().getName()+"] "+ex.getMessage(), ex);
	}
}
 

import org.apache.commons.codec.net.QuotedPrintableCodec; //导入方法依赖的package包/类
/**
 * <p>Parses the CATEGORIES type.</p>
 *
 * @param group
 * @param value
 * @param paramTypeList
 * @param vcard
 * @throws VCardBuildException
 */
private void parseCategoriesType(String group, String value, List<ParameterType> paramTypeList, VCardImpl vcard) throws VCardBuildException {
	try {
		CategoriesType categoriesFeature = new CategoriesType();

		for (ParameterType pt : paramTypeList) {					
			if(pt.getName().equals("CHARSET")) {
				categoriesFeature.setCharset(pt.getValue());
			}
			else if(pt.getName().equals("ENCODING")) {
				if(pt.getValue().equals(EncodingType.QUOTED_PRINTABLE.getType())) {
					categoriesFeature.setEncodingType(EncodingType.QUOTED_PRINTABLE);
				}
			}
			else if(pt.getName().equals("LANGUAGE")) {
				categoriesFeature.setLanguage(pt.getValue());
			}
			else {
				ExtendedParameterType parameter = new ExtendedParameterType(pt.getName(), pt.getValue());                                               
				categoriesFeature.addExtendedParameter(parameter);
			}
		}
		
		if(categoriesFeature.getEncodingType() == EncodingType.QUOTED_PRINTABLE) {
			QuotedPrintableCodec q = new QuotedPrintableCodec();

			if(isCharsetForced()) {
				value = q.decode(value, forceCharset.name());
			}
			else { 
				if(categoriesFeature.hasCharset()) {
					value = q.decode(value, categoriesFeature.getCharset().name());
				}
				else {
					value = q.decode(value);
				}
			}
		}
		
		String[] categories = null;
		switch(compatMode)
		{
			case KDE_ADDRESS_BOOK:
			{
				categories = VCardUtils.unescapeString(value).split(",");
				break;
			}
			
			default:
			{
				categories = VCardUtils.parseStringWithEscappedDelimiter(value, ',');
				break;
			}
		}
		
		for(int i = 0; i < categories.length; i++) {
			categoriesFeature.addCategory(VCardUtils.unescapeString(categories[i]));
		}
		
		if(group != null) {
			categoriesFeature.setGroup(group);
		}
		
		vcard.setCategories(categoriesFeature);
	}
	catch(Exception ex) {
		throw new VCardBuildException("CategoriesType ("+VCardType.CATEGORIES.getType()+") ["+ex.getClass().getName()+"] "+ex.getMessage(), ex);
	}
}
 

import org.apache.commons.codec.net.QuotedPrintableCodec; //导入方法依赖的package包/类
/**
 * <p>Parses the NOTE type.</p>
 *
 * @param group
 * @param value
 * @param paramTypeList
 * @param vcard
 * @throws VCardBuildException
 */
private void parseNoteType(String group, String value, List<ParameterType> paramTypeList, VCardImpl vcard) throws VCardBuildException {
	try {
		NoteType noteFeature = new NoteType();

		for (ParameterType pt : paramTypeList) {					
			if(pt.getName().equals("CHARSET")) {
				noteFeature.setCharset(pt.getValue());
			}
			else if(pt.getName().equals("ENCODING")) {
				if(pt.getValue().equals(EncodingType.QUOTED_PRINTABLE.getType())) {
					noteFeature.setEncodingType(EncodingType.QUOTED_PRINTABLE);
				}
			}
			else if(pt.getName().equals("LANGUAGE")) {
				noteFeature.setLanguage(pt.getValue());
			}
			else {
				ExtendedParameterType parameter = new ExtendedParameterType(pt.getName(), pt.getValue());                                               
				noteFeature.addExtendedParameter(parameter);
			}
		}
		
		if(noteFeature.getEncodingType() == EncodingType.QUOTED_PRINTABLE) {
			QuotedPrintableCodec q = new QuotedPrintableCodec();

			if(isCharsetForced()) {
				value = q.decode(value, forceCharset.name());
			}
			else { 
				if(noteFeature.hasCharset()) {
					value = q.decode(value, noteFeature.getCharset().name());
				}
				else {
					value = q.decode(value);
				}
			}
		}
		
		noteFeature.setNote(VCardUtils.unescapeString(value));
		
		if(group != null) {
			noteFeature.setGroup(group);
		}
		
		vcard.addNote(noteFeature);
	}
	catch(Exception ex) {
		throw new VCardBuildException("NoteType ("+VCardType.NOTE.getType()+") ["+ex.getClass().getName()+"] "+ex.getMessage(), ex);
	}
}
 

import org.apache.commons.codec.net.QuotedPrintableCodec; //导入方法依赖的package包/类
/**
 * <p>Parses the PRODID type.</p>
 *
 * @param group
 * @param value
 * @param paramTypeList
 * @param vcard
 * @throws VCardBuildException
 */
private void parseProdidType(String group, String value, List<ParameterType> paramTypeList, VCardImpl vcard) throws VCardBuildException {
	try {
		ProductIdType productIdFeature = new ProductIdType();

		for (ParameterType pt : paramTypeList) {					
			if(pt.getName().equals("CHARSET")) {
				productIdFeature.setCharset(pt.getValue());
			}
			else if(pt.getName().equals("ENCODING")) {
				if(pt.getValue().equals(EncodingType.QUOTED_PRINTABLE.getType())) {
					productIdFeature.setEncodingType(EncodingType.QUOTED_PRINTABLE);
				}
			}
			else if(pt.getName().equals("LANGUAGE")) {
				productIdFeature.setLanguage(pt.getValue());
			}
			else {
				ExtendedParameterType parameter = new ExtendedParameterType(pt.getName(), pt.getValue());                                               
				productIdFeature.addExtendedParameter(parameter);
			}
		}
		
		if(productIdFeature.getEncodingType() == EncodingType.QUOTED_PRINTABLE) {
			QuotedPrintableCodec q = new QuotedPrintableCodec();

			if(isCharsetForced()) {
				value = q.decode(value, forceCharset.name());
			}
			else { 
				if(productIdFeature.hasCharset()) {
					value = q.decode(value, productIdFeature.getCharset().name());
				}
				else {
					value = q.decode(value);
				}
			}
		}
		
		productIdFeature.setProductId(VCardUtils.unescapeString(value));
		
		if(group != null) {
			productIdFeature.setGroup(group);
		}
		
		vcard.setProductId(productIdFeature);
	}
	catch(Exception ex) {
		throw new VCardBuildException("ProductIdType ("+VCardType.PRODID.getType()+") ["+ex.getClass().getName()+"] "+ex.getMessage(), ex);
	}
}
 

import org.apache.commons.codec.net.QuotedPrintableCodec; //导入方法依赖的package包/类
/**
 * <p>Parses the SORT-STRING type.</p>
 *
 * @param group
 * @param value
 * @param paramTypeList
 * @param vcard
 * @throws VCardBuildException
 */
private void parseSortStringType(String group, String value, List<ParameterType> paramTypeList, VCardImpl vcard) throws VCardBuildException {
	try {
		SortStringType sortStringFeature = new SortStringType();

		for (ParameterType pt : paramTypeList) {					
			if(pt.getName().equals("CHARSET")) {
				sortStringFeature.setCharset(pt.getValue());
			}
			else if(pt.getName().equals("ENCODING")) {
				if(pt.getValue().equals(EncodingType.QUOTED_PRINTABLE.getType())) {
					sortStringFeature.setEncodingType(EncodingType.QUOTED_PRINTABLE);
				}
			}
			else if(pt.getName().equals("LANGUAGE")) {
				sortStringFeature.setLanguage(pt.getValue());
			}
			else {
				ExtendedParameterType parameter = new ExtendedParameterType(pt.getName(), pt.getValue());                                               
				sortStringFeature.addExtendedParameter(parameter);
			}
		}
		
		if(sortStringFeature.getEncodingType() == EncodingType.QUOTED_PRINTABLE) {
			QuotedPrintableCodec q = new QuotedPrintableCodec();

			if(isCharsetForced()) {
				value = q.decode(value, forceCharset.name());
			}
			else { 
				if(sortStringFeature.hasCharset()) {
					value = q.decode(value, sortStringFeature.getCharset().name());
				}
				else {
					value = q.decode(value);
				}
			}
		}
		
		sortStringFeature.setSortString(VCardUtils.unescapeString(value));
		
		if(group != null) {
			sortStringFeature.setGroup(group);
		}
		
		vcard.setSortString(sortStringFeature);
	}
	catch(Exception ex) {
		throw new VCardBuildException("SortStringType ("+VCardType.SORT_STRING.getType()+") ["+ex.getClass().getName()+"] "+ex.getMessage(), ex);
	}
}
 

import org.apache.commons.codec.net.QuotedPrintableCodec; //导入方法依赖的package包/类
/**
 * <p>Parses the UID type.</p>
 *
 * @param group
 * @param value
 * @param paramTypeList
 * @param vcard
 * @throws VCardBuildException
 */
private void parseUidType(String group, String value, List<ParameterType> paramTypeList, VCardImpl vcard) throws VCardBuildException {
	try {
		UIDType uidFeature = new UIDType();

		for (ParameterType pt : paramTypeList) {					
			if(pt.getName().equals("CHARSET")) {
				uidFeature.setCharset(pt.getValue());
			}
			else if(pt.getName().equals("ENCODING")) {
				if(pt.getValue().equals(EncodingType.QUOTED_PRINTABLE.getType())) {
					uidFeature.setEncodingType(EncodingType.QUOTED_PRINTABLE);
				}
			}
			else if(pt.getName().equals("LANGUAGE")) {
				uidFeature.setLanguage(pt.getValue());
			}
			else {
				ExtendedParameterType parameter = new ExtendedParameterType(pt.getName(), pt.getValue());                                               
				uidFeature.addExtendedParameter(parameter);
			}
		}
		
		if(uidFeature.getEncodingType() == EncodingType.QUOTED_PRINTABLE) {
			QuotedPrintableCodec q = new QuotedPrintableCodec();

			if(isCharsetForced()) {
				value = q.decode(value, forceCharset.name());
			}
			else { 
				if(uidFeature.hasCharset()) {
					value = q.decode(value, uidFeature.getCharset().name());
				}
				else {
					value = q.decode(value);
				}
			}
		}
		
		uidFeature.setUID(VCardUtils.unescapeString(value));
		
		if(group != null) {
			uidFeature.setGroup(group);
		}
		
		vcard.setUID(uidFeature);
	}
	catch(Exception ex) {
		throw new VCardBuildException("UIDType ("+VCardType.UID.getType()+") ["+ex.getClass().getName()+"] "+ex.getMessage(), ex);
	}
}
 

import org.apache.commons.codec.net.QuotedPrintableCodec; //导入方法依赖的package包/类
/**
 * <p>Parses the CLASS type.</p>
 *
 * @param group
 * @param value
 * @param paramTypeList
 * @param vcard
 * @throws VCardBuildException
 */
private void parseClassType(String group, String value, List<ParameterType> paramTypeList, VCardImpl vcard) throws VCardBuildException {
	try {
		ClassType classFeature = new ClassType();
		
		for (ParameterType pt : paramTypeList) {					
			if(pt.getName().equals("CHARSET")) {
				classFeature.setCharset(pt.getValue());
			}
			else if(pt.getName().equals("ENCODING")) {
				if(pt.getValue().equals(EncodingType.QUOTED_PRINTABLE.getType())) {
					classFeature.setEncodingType(EncodingType.QUOTED_PRINTABLE);
				}
			}
			else if(pt.getName().equals("LANGUAGE")) {
				classFeature.setLanguage(pt.getValue());
			}
			else {
				ExtendedParameterType parameter = new ExtendedParameterType(pt.getName(), pt.getValue());                                               
				classFeature.addExtendedParameter(parameter);
			}
		}
		
		if(classFeature.getEncodingType() == EncodingType.QUOTED_PRINTABLE) {
			QuotedPrintableCodec q = new QuotedPrintableCodec();

			if(isCharsetForced()) {
				value = q.decode(value, forceCharset.name());
			}
			else { 
				if(classFeature.hasCharset()) {
					value = q.decode(value, classFeature.getCharset().name());
				}
				else {
					value = q.decode(value);
				}
			}
		}
		
		classFeature.setSecurityClass(VCardUtils.unescapeString(value));
		
		if(group != null) {
			classFeature.setGroup(group);
		}
		
		vcard.setSecurityClass(classFeature);
	}
	catch(Exception ex) {
		throw new VCardBuildException("ClassType ("+VCardType.CLASS.getType()+") ["+ex.getClass().getName()+"] "+ex.getMessage(), ex);
	}
}
 

import org.apache.commons.codec.net.QuotedPrintableCodec; //导入方法依赖的package包/类
/**
 * <p>Parses the EXTENDED type.</p>
 *
 * @param group
 * @param value
 * @param paramTypeList
 * @param typeName
 * @param vcard
 * @throws VCardBuildException
 */
private void parseXtendedType(String group, String value, String typeName, List<ParameterType> paramTypeList, VCardImpl vcard) throws VCardBuildException {
	try {
		ExtendedType extendedFeature = new ExtendedType();

		for (ParameterType pt : paramTypeList) {					
			if(pt.getName().equals("CHARSET")) {
				extendedFeature.setCharset(pt.getValue());
			}
			else if(pt.getName().equals("ENCODING")) {
				if(pt.getValue().equals(EncodingType.QUOTED_PRINTABLE.getType())) {
					extendedFeature.setEncodingType(EncodingType.QUOTED_PRINTABLE);
				}
			}
			else if(pt.getName().equals("LANGUAGE")) {
				extendedFeature.setLanguage(pt.getValue());
			}
			else {
				ExtendedParameterType parameter = new ExtendedParameterType(pt.getName(), pt.getValue());					    					    
				extendedFeature.addExtendedParameter(parameter);
			}
		}
		
		if(extendedFeature.getEncodingType() == EncodingType.QUOTED_PRINTABLE) {
			QuotedPrintableCodec q = new QuotedPrintableCodec();

			if(isCharsetForced()) {
				value = q.decode(value, forceCharset.name());
			}
			else { 
				if(extendedFeature.hasCharset()) {
					value = q.decode(value, extendedFeature.getCharset().name());
				}
				else {
					value = q.decode(value);
				}
			}
		}
		
		extendedFeature.setExtensionName(typeName);
		extendedFeature.setExtensionData(VCardUtils.unescapeString(value));
		
		if(group != null) {
			extendedFeature.setGroup(group);
		}
		
		vcard.addExtendedType(extendedFeature);
	}
	catch(Exception ex) {
		throw new VCardBuildException("ExtendedType ("+VCardType.XTENDED.getType()+") ["+ex.getClass().getName()+"] "+ex.getMessage(), ex);
	}
}