@Override public void accept(TemplateVisitor visitor) { checkNotNull(visitor,"Template visitor cannot be null"); for(ResourceTemplate template:this.context.registeredTemplates()) { template.accept(visitor); } }
@Override public Set<AttachedTemplate> attachedTemplates() { return this.template.attachedTemplates(); }
@Override public String id() { return this.template.id(); }
public InvalidTemplateClassException(Class<? extends ResourceTemplate> templateClass, ResourceTemplate template) { super("The template {"+template.id()+","+template.handlerClass().getCanonicalName()+"} cannot be casted to '"+templateClass.getCanonicalName()+"' ("+template.getClass().getCanonicalName()+")"); }
@Override public Class<? extends ResourceHandler> handlerClass() { return this.template.handlerClass(); }
@Override <T extends DelegatedResourceSnapshot> T createAttachedResource( Class<? extends T> snapshotClass, String attachmentId, Name<?> name, Class<? extends ResourceHandler> handlerClass, DelegatedResourceSnapshot ctx) { AttachedTemplate attachedTemplate = template().attachedTemplate(attachmentId); checkState(attachedTemplate!=null,"No attachment '%s' is defined for template '%s'",attachmentId,template()); checkState(attachedTemplate.template().handlerClass().isAssignableFrom(handlerClass),"Attachment '%s' of template '%s' is not compatible with '%s' (%s)",attachmentId,template().id(),handlerClass.getCanonicalName(),attachedTemplate.template().handlerClass().getCanonicalName()); checkState(nameFilterForAttachment(attachmentId).isValid(name),"Resource name '%s' is already in use",name); T newSnapshot= ctx.newChildResource(ResourceId.createId(name,attachedTemplate.template()),snapshotClass); DelegatedAttachmentSnapshot newAttachment = AttachmentSnapshotCollection.newAttachment(attachmentId, newSnapshot); this.attachments.add(newAttachment); UnitOfWork.getCurrent().registerDirty(ctx); newSnapshot.markNew(); if(LOGGER.isTraceEnabled()) { LOGGER.trace("Attached '{}' as '{}' to '{}'",newSnapshot.resourceId(),attachmentId,ctx.resourceId()); } return snapshotClass.cast(newSnapshot); }
@Override public AttachedTemplate attachedTemplate(String attachmentId) { return this.template.attachedTemplate(attachmentId); }
@Override public Optional<String> description() { return this.template.description(); }
@Override public Set<String> attachmentIds() { return this.template.attachmentIds(); }
private <T extends ResourceHandler> Class<? extends T> handlerClass(ResourceTemplate template, Class<? extends T> clazz) { Class<?> handlerClass = template.handlerClass(); if(!clazz.isAssignableFrom(handlerClass)) { throw new IllegalStateException("Cannot cast '"+handlerClass.getCanonicalName()+"' to a subclass of '"+clazz.getCanonicalName()+"'"); } return handlerClass.asSubclass(clazz); }
@Override public void visitResourceTemplate(ResourceTemplate template) { Class<? extends ResourceHandler> handlerClass = template.handlerClass(); ResourceHandler handler=this.handlers.getInstance(handlerClass); if(handler==null) { try { handler=handlerClass.newInstance(); } catch (Exception e) { String message=String.format("Could not instantiate resource handler from template '%s' (%s)",template.id(),handlerClass.getCanonicalName()); LOGGER.warn(message); throw new ResourceHandlerInstantiationException(message,handlerClass,e); } } this.builder.put(HandlerId.createId(handlerClass), handler); }
@Override protected void fillInMetadata(ContentPreferences contentPreferences, final Individual<?, ?> individual, final Context ctx) { individual. addValue( ctx.property(RDF.TYPE), ctx.reference(LDP.RESOURCE)); for(Entry<String, PublicResource> entry:attachments().entrySet()) { AttachedTemplate attachedTemplate = template().attachedTemplate(entry.getKey()); individual.addValue( attachedTemplate.predicate().or(HAS_ATTACHMENT), ctx.newIndividual(entry.getValue())); populateAdditionalMetadata(contentPreferences,individual,ctx,entry.getValue()); } }
public static boolean areCompatible(Class<? extends Resource> clazz, ResourceTemplate template) { Checker checker = new Checker(clazz); template.accept(checker); return checker.getResult(); }
@Override public String toString() { return MoreObjects. toStringHelper(getClass()). omitNullValues(). add("id", this.id). add("path", this.path). add("template.id()", this.template.id()). add("predicate", predicate). toString(); }
protected void toString(ToStringHelper helper) { helper. omitNullValues(). add("resourceId", resourceId). add("template().handlerClass()",template().handlerClass().getCanonicalName()); }
@Override protected void init() { ResourceTemplate template = super.getTemplate(this.id); Set<AttachedTemplate> attachedTemplates = template.attachedTemplates(); if(!attachedTemplates.isEmpty() && this.attachments.isEmpty()) { for(AttachedTemplate attachedTemplate:attachedTemplates) { JPAAttachment newAttachment = new JPAAttachment(attachedTemplate.id()); this.attachments.add(newAttachment); } } this.attachmentCollection.init(this.attachments); }
private String generatePathForAttachment(Resource child, Resource parent) throws EndpointNotFoundException { Attachment attachment=parent.findAttachment(child.id()); if(attachment==null) { return null; } Endpoint endpoint=getResourceEndpoint(parent.id()); ResourceTemplate parentTemplate=this.templateManagementService.templateOfId(parent.id().templateId()); AttachedTemplate attachedTemplate = parentTemplate.attachedTemplate(attachment.id()); return PathBuilder. create(). addSegment(endpoint.path()). addSegment(attachedTemplate.path()). addSegment(attachment.version()>0?attachment.version():null). build(); }
public static boolean areCompatible(Class<?> clazz, ResourceTemplate template) { Checker checker = new Checker(clazz); template.accept(checker); return checker.getResult(); }
/** * {@inheritDoc} */ @Override protected ToStringHelper stringHelper() { return super. stringHelper(). add("memberTemplate",this.memberTemplate.id()). add("memberPath",this.memberPath); }
<T extends ResourceHandler> T getHandler(Class<? extends T> handlerClass, ResourceTemplate template) { checkNotNull(handlerClass,"Handler class cannot be null"); checkNotNull(template,"Template cannot be null"); checkArgument(this.library.contains(template),"Unknown template '"+template+"'"); checkArgument(handlerClass.isAssignableFrom(template.handlerClass())); return handlerClass.cast(this.handlers.get(HandlerId.createId(template.handlerClass()))); }