@Override public Class<? extends ResourceHandler> handlerClass() { return this.template.handlerClass(); }
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); }
protected void toString(ToStringHelper helper) { helper. omitNullValues(). add("resourceId", resourceId). add("template().handlerClass()",template().handlerClass().getCanonicalName()); }
<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()))); }
@Override public boolean contains(ResourceTemplate template) { checkNotNull(template,"Template cannot be null"); return findByHandler(template.handlerClass())!=null; }
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()+")"); }
private Class<? extends ResourceHandler> resolveHandler(ResourceId resourceId) { ResourceTemplate template = this.templateManagementService.templateOfId(resourceId.templateId()); return template!=null?template.handlerClass():null; }
@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 processTemplate(ResourceTemplate template) { ResourceTemplate other = library.findByHandler(template.handlerClass()); assertThat(other,equalTo(template)); } }
@Override protected void processTemplate(ResourceTemplate template) { ResourceTemplate other = library.findByHandler(template.handlerClass()); assertThat(other,not(nullValue())); } }
@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); }
Capabilities endpointCapabilities(Endpoint endpoint) { MutableCapabilities result=new MutableCapabilities(); Resource resource = resolveResource(endpoint); ResourceTemplate template=resourceTemplate(resource); Class<? extends ResourceHandler> handlerClass = template.handlerClass(); result.setQueryable(Queryable.class.isAssignableFrom(handlerClass)); result.setModifiable(Modifiable.class.isAssignableFrom(handlerClass)); result.setDeletable(Deletable.class.isAssignableFrom(handlerClass) && !resource.isRoot()); // TODO: Analyze how to provide patch support result.setPatchable(false); TemplateIntrospector introspector = TemplateIntrospector.newInstance(template); result.setFactory(introspector.isContainer()); return result; }
private <T extends Resource> Adapter adapter(T resource, WriteSessionConfiguration configuration) { ResourceTemplate template=this.templateManagementService.templateOfId(resource.id().templateId()); Class<? extends ResourceHandler> handlerClass = template.handlerClass(); ResourceHandler delegate=this.templateManagementService.getHandler(handlerClass); return AdapterFactory.newAdapter(resource,delegate,this.writeSessionService,configuration); }
@Override public void visitResource(Resource resource) { DelegatedResourceSnapshot snapshot=new DelegatedResourceSnapshot(resource.id(),template.handlerClass()); snapshot.setParentState(ParentState.parentOf(resource)); snapshot.setPersistencyState(PersistencyState.newPersistentReferenceState(resource.id(),template)); result.set(snapshot); } @Override
private DelegatedResourceSnapshot instantiateTemplate(ResourceId resourceId, ResourceTemplate template) { DelegatedResourceSnapshot snapshot=null; TemplateIntrospector introspector=TemplateIntrospector.newInstance(template); if(!introspector.isContainer()) { snapshot=new DelegatedResourceSnapshot(resourceId,template.handlerClass()); } else { snapshot=new DelegatedContainerSnapshot(resourceId,handlerClass(template,ContainerHandler.class)); } return snapshot; }
@Override public void visitContainer(Container resource) { DelegatedContainerSnapshot snapshot=new DelegatedContainerSnapshot(resource.id(),handlerClass(template,ContainerHandler.class)); snapshot.setParentState(ParentState.parentOf(resource)); snapshot.setPersistencyState(PersistencyState.newPersistentReferenceState(resource.id(),template)); result.set(snapshot); } }
private ResourceSnapshot resolveManagedResource(URI path) { try { Endpoint endpoint= applicationEngine(). endpointManagementService(). resolveEndpoint(path.toString()); ResourceSnapshot result=null; if(endpoint!=null && endpoint.deleted()==null) { org.ldp4j.application.kernel.resource.Resource resource = context(). resolveResource(endpoint); if(resource!=null) { ResourceId resourceId = resource.id(); result= this.session. find( ResourceSnapshot.class, resourceId.name(), context().resourceTemplate(resource).handlerClass()); } } return result; } catch (Exception e) { throw new SnapshotResolutionException("Could not resolve resource for endpoint '"+this.canonicalBase.resolve(path)+"'",e); } } }
@Test public void testResolverSnapshotResolver$resolveEndpoint$happyPath() throws Exception { final URI base = URI.create("http://www.examples.org/base/"); final String path="resource/path/"; final ResourceId resourceId = ResourceId.createId(NamingScheme.getDefault().name("name"),"template"); new Expectations() {{ engine.unwrap(DefaultApplicationEngine.class);result=engine; engine.endpointManagementService();result=endpointManagementService; endpointManagementService.resolveEndpoint(path);result=endpoint; endpoint.deleted();result=null; engine.unwrap(DefaultApplicationEngine.class);result=engine; engine.activeContext();result=context; context.resolveResource(endpoint);result=resource; resource.id();result=resourceId; engine.unwrap(DefaultApplicationEngine.class);result=engine; engine.activeContext();result=context; context.resourceTemplate(resource);result=template; template.handlerClass();result=ResourceHandler.class; session.find(ResourceSnapshot.class,resourceId.name(),ResourceHandler.class);result=snapshot; }}; new MockUp<ApplicationEngine>() { @Mock public ApplicationEngine engine() throws ApplicationEngineException { return engine; } }; CoreRuntimeDelegate sut=new CoreRuntimeDelegate(); ResourceSnapshotResolver resolver = sut.createResourceResolver(base, session); assertThat(resolver.resolve(base.resolve(path)),sameInstance(snapshot)); }