import org.springframework.hateoas.Identifiable; //导入依赖的package包/类
/**
 * Creates a new ToAttributedValueConverter instance.
 * 
 * @param mapper the mapper in use
 * @param reflectionProvider the reflection provider in use
 * @param lookup the converter lookup in use
 * @param valueFieldName the field defining the tag's value (may be null)
 * @param valueDefinedIn the type defining the field
 */
public IdentifiableToIdConverter(
    final Class<Identifiable<?>> type, final Mapper mapper, final ReflectionProvider reflectionProvider,
    final ConverterLookup lookup, final String valueFieldName, Class<?> valueDefinedIn) {
    this.type = type;

       Field field = null;
       try {
           field = (valueDefinedIn != null ? valueDefinedIn : type.getSuperclass())
               .getDeclaredField("id");
          
           if (!field.isAccessible()) {
               field.setAccessible(true);
           }
       } catch (NoSuchFieldException e) {
           throw new IllegalArgumentException(e.getMessage() + ": " + valueFieldName);
       }
}
 

import org.springframework.hateoas.Identifiable; //导入依赖的package包/类
public T slash(Object object) {

		if (object == null) {
			return getThis();
		}

		if (object instanceof Identifiable) {
			return slash((Identifiable<?>) object);
		}

		String path = object.toString();

		if (path.endsWith("#")) {
			path = path.substring(0, path.length() - 1);
		}

		if (!StringUtils.hasText(path)) {
			return getThis();
		}

		String uriString = uriComponents.toUriString();
		UriComponentsBuilder builder = uriString.isEmpty() ? fromUri(uriComponents.toUri())
				: fromUriString(uriString);

		UriComponents components = UriComponentsBuilder.fromUriString(path).build();

		for (String pathSegment : components.getPathSegments()) {
			builder.pathSegment(pathSegment);
		}

		String fragment = components.getFragment();
		if (StringUtils.hasText(fragment)) {
			builder.fragment(fragment);
		}

		return createNewInstance(builder.query(components.getQuery()));
	}
 

import org.springframework.hateoas.Identifiable; //导入依赖的package包/类
@Override
public AffordanceBuilder slash(Identifiable<?> identifiable) {
    if (identifiable == null) {
        return this;
    }

    return slash(identifiable.getId());
}
 

import org.springframework.hateoas.Identifiable; //导入依赖的package包/类
public static String toFriendlyId(Identifiable<UUID> entity) {
	return Url62.encode(entity.getId());
}
 

import org.springframework.hateoas.Identifiable; //导入依赖的package包/类
@Override
public Link linkToSingleResource(Identifiable<?> entity) {
	Assert.notNull(entity);
	return linkToSingleResource(entity.getClass(), entity.getId());
}
 

import org.springframework.hateoas.Identifiable; //导入依赖的package包/类
@Override
public LinkBuilder linkForSingleResource(Identifiable<?> entity) {
	Assert.notNull(entity);
	return linkForSingleResource(entity.getClass(), entity.getId());
}
 

import org.springframework.hateoas.Identifiable; //导入依赖的package包/类
/**
 * Converts a DiscourseDB annotation into Brat annotations.
 * A single DiscourseDB annotation might result in multiple Brat annotations 
 * 
 * @param dbAnno the DiscourseDB annotation to convert
 * @param spanOffset the current offset of the Contribution or Content within the aggregate document
 * @param text the contribution text
 * @param entity the annotated entity (Contribution or Content)
 * @param annotationVersionInfo a list in which version information about the exported annotations will be stored 
 * @return a list of BratAnnotations 
 */
@Transactional(propagation= Propagation.REQUIRED, readOnly=true)
private <T extends BaseEntity & Identifiable<Long>> List<BratAnnotation> convertAnnotationToBrat(AnnotationInstance dbAnno, int spanOffset, String sep, String text, T entity, BratIdGenerator bratIdGenerator) {
	Assert.notNull(dbAnno, "The annotation instance to be converted cannot be null.");
	Assert.notNull(text, "The text may be empty, but not null.");
	Assert.notNull(entity, "The entity associated with the annotation cannot be null.");
	Assert.notNull(bratIdGenerator, "The Brat IDGenerator cannot be null.");
	
	//one DiscourseDB annotation could result in multiple BRAT annotations 
	List<BratAnnotation> newAnnotations = new ArrayList<>();
	
	//PRODUCE Text-Bound Annotation for ALL other annotations		
	BratAnnotation textBoundAnnotation = new BratAnnotation();
	textBoundAnnotation.setType(BratAnnotationType.BRAT_TEXT);			
	textBoundAnnotation.setId(bratIdGenerator.getNextAvailableBratId(BratAnnotationType.BRAT_TEXT, dbAnno.getId()));
	textBoundAnnotation.setAnnotationLabel(dbAnno.getType());

	//CALC OFFSET			
	if (entity instanceof Contribution) {
		//annotations on contributions are always annotated on the contribution separator as an entity label 
		textBoundAnnotation.setBeginIndex(spanOffset);
		textBoundAnnotation.setEndIndex(spanOffset+ sep.length());
		textBoundAnnotation.setCoveredText(sep);															
	}else if (entity instanceof Content) {
		//content labels are always annotated as text spans on the currentRevision content entity
		if(dbAnno.getEndOffset()==0){
			log.warn("Labels on Content entites should define a span and should not be entity labels."); 
		}
		textBoundAnnotation.setBeginIndex(spanOffset+dbAnno.getBeginOffset()+sep.length()+1);
		textBoundAnnotation.setEndIndex(spanOffset+dbAnno.getEndOffset()+sep.length()+1);
		textBoundAnnotation.setCoveredText(text.substring(dbAnno.getBeginOffset(),dbAnno.getEndOffset()));											
	}		
	textBoundAnnotation.setVersionInfo(new VersionInfo(AnnotationSourceType.DDB_ANNOTATION, textBoundAnnotation.getId(), dbAnno.getId(), dbAnno.getEntityVersion()));
	newAnnotations.add(textBoundAnnotation);
	
	//FEATURE VALUES ARE USED TO CREATE BRAT ANNOTATION ATTRIBUTES. Feature types are ignored.
	for(Feature f:dbAnno.getFeatures()){			
		BratAnnotation newAttribute = new BratAnnotation();
		newAttribute.setType(BratAnnotationType.BRAT_NOTE);			
		newAttribute.setId(bratIdGenerator.getNextAvailableBratId(BratAnnotationType.BRAT_NOTE, f.getId()));
		newAttribute.setAnnotationLabel("AnnotatorNotes");
		newAttribute.setNoteText(f.getValue());
		newAttribute.setSourceAnnotationId(textBoundAnnotation.getId());
		newAttribute.setVersionInfo(new VersionInfo(AnnotationSourceType.DDB_FEATURE, newAttribute.getId(), f.getId(), f.getEntityVersion()));
		newAnnotations.add(newAttribute);				
	}
   	
	return newAnnotations;
}
 

import org.springframework.hateoas.Identifiable; //导入依赖的package包/类
public void marshal(final Object source, final HierarchicalStreamWriter writer,
    final MarshallingContext context) {
    if(source instanceof Identifiable){
    	writer.setValue(((Identifiable<?>)source).getId().toString());
    }
}
 

import org.springframework.hateoas.Identifiable; //导入依赖的package包/类
@Override
public void serialize(Identifiable<?> value, JsonGenerator jgen, SerializerProvider provider) 
  throws IOException, JsonProcessingException {
	provider.defaultSerializeValue(value.getId(), jgen);
}
 

import org.springframework.hateoas.Identifiable; //导入依赖的package包/类
public void addSelfUpdateLink(Collection<Link> links, Identifiable<?> identifiable){
    Link singleResourceLink = repositoryEntityLinks.linkToSingleResource(identifiable).expand();

    Assert.notNull(singleResourceLink);

    Link updateLink = singleResourceLink.withRel( "self" + UPDATE_REL_SUFFIX );

    links.add(updateLink);

    Link deleteLink = singleResourceLink.withRel( "self" + DELETE_REL_SUFFIX );

    links.add(deleteLink);
}