void configureTemplates() throws ApplicationConfigurationException { try { this.templateManagementService.configure(this.handlerClasses, this.handlers); } catch (TemplateManagementServiceConfigurationException e) { throw new ApplicationConfigurationException("Invalid application resource handler configuration",e); } }
public <T extends ResourceTemplate> T templateOfId(String templateId, Class<? extends T> templateClass) { checkNotNull(templateClass,"Template class cannot be null"); ResourceTemplate found = templateOfId(templateId); if(found==null) { return null; } else if(!templateClass.isInstance(found)) { throw new IllegalArgumentException("Cannot cast template '"+templateId+"' to '"+templateClass.getCanonicalName()+"' ("+found.getClass().getCanonicalName()+")"); } return templateClass.cast(found); }
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); }
/** * {@inheritDoc} */ @Override public <S extends ResourceSnapshot> S find( Class<? extends S> snapshotClass, Name<?> name, Class<? extends ResourceHandler> handlerClass) { checkNotNull(snapshotClass,"Resource snapshot class cannot be null"); checkNotNull(name,RESOURCE_NAME_CANNOT_BE_NULL); checkNotNull(handlerClass,"Resource handler class cannot be null"); checkArgument(!ContainerSnapshot.class.isAssignableFrom(snapshotClass) || ContainerHandler.class.isAssignableFrom(handlerClass),"Incompatible snapshot and handler classes ('%s' instances are not handled by '%s')",snapshotClass.getCanonicalName(),handlerClass.getCanonicalName()); ResourceTemplate template=this.writeSessionService.templateManagementService().templateOfHandler(handlerClass); checkArgument(template!=null,"Handler class '%s' is not associated to any existing template",handlerClass.getCanonicalName()); checkArgument(Snapshots.areCompatible(snapshotClass,template),"Cannot wrap an object managed by '%s' with an snapshot of type '%s'",handlerClass.getCanonicalName(),snapshotClass.getCanonicalName()); checkState(this.status.equals(Status.ACTIVE),WRITE_SESSION_NOT_ACTIVE,this.status); ResourceId id=ResourceId.createId(name,template); DelegatedResourceSnapshot resource = resolveResource(id, template); return snapshotClass.cast(resource); }
private <T extends ResourceHandler> T getHandler(Class<? extends T> handlerClass) { return tms.getHandler(handlerClass); }
public <T extends ResourceHandler> T getHandler(Class<? extends T> handlerClass) { return getState().getHandler(handlerClass); }
public static TemplateManagementService defaultService() { return serviceBuilder().build(); }
@Override public TemplateManagementService build() { return new TemplateManagementService(super.modelFactory()); }
private Resource createResource(Class<? extends ResourceHandler> handlerClass, Name<?> name) { return this.modelFactory. createResource( this.templateManagementService.templateOfHandler(handlerClass), name); }
public void configure(List<Class<?>> handlerClasses, List<ResourceHandler> handlers) throws TemplateManagementServiceConfigurationException { getState().configure(handlerClasses, handlers); }
private static void initialize(ServiceRegistry registry) { registry. registerServiceBuilder( TemplateManagementService.serviceBuilder()). registerServiceBuilder( EndpointManagementService.serviceBuilder()). registerServiceBuilder( WriteSessionService.serviceBuilder()). registerServiceBuilder( ResourceControllerService.serviceBuilder()). registerServiceBuilder( ApplicationLifecycleService.serviceBuilder()); }
ResourceTemplate loadTemplate(String templateId) { return this.writeSessionService.templateManagementService().templateOfId(templateId); }
@BeforeClass public static void setUpBefore() throws Exception { ServiceRegistry.setInstance(null); RuntimeDelegate.setInstance(new JPARuntimeDelegate()); PersonHandler personHandler = new PersonHandler(); ServiceRegistry. getInstance(). getService(TemplateManagementService.class). configure( Lists.<Class<?>>newArrayList(), Arrays.<ResourceHandler>asList(personHandler)); }
void validate() throws ApplicationConfigurationException { assertNameNotNull(); assertHandlerClassNotNull(); this.template = EnvironmentImpl.this.templateManagementService.templateOfHandler(this.handlerClass); assertTemplateExists(); assertValidPath(); }
public ResourceTemplate templateOfHandler(Class<? extends ResourceHandler> handlerClass) { checkNotNull(handlerClass,"Resource handler cannot be null"); return ImmutableTemplateFactory.newImmutable(getState().templateLibrary().findByHandler(handlerClass)); }
private Class<? extends ResourceHandler> resolveHandler(ResourceId resourceId) { ResourceTemplate template = this.templateManagementService.templateOfId(resourceId.templateId()); return template!=null?template.handlerClass():null; }
@BeforeClass public static void setUpBefore() throws Exception { ServiceRegistry.setInstance(null); RuntimeDelegate.setInstance(new InMemoryRuntimeDelegate()); PersonHandler personHandler = new PersonHandler(); QueryableResourceHandler queryHandler=new QueryableResourceHandler(); ServiceRegistry. getInstance(). getService(TemplateManagementService.class). configure( Lists.<Class<?>>newArrayList(), Arrays.<ResourceHandler>asList(personHandler,queryHandler)); }
private Resource findResource(Name<?> name, Class<? extends ResourceHandler> handlerClass) { ResourceTemplate template = this.templateManagementService.templateOfHandler(handlerClass); ResourceId id = ResourceId.createId(name,template); return this.resourceRepository.resourceOfId(id); }
public ResourceTemplate templateOfId(String templateId) { checkNotNull(templateId,"Template identifier cannot be null"); return ImmutableTemplateFactory.newImmutable(getState().templateLibrary().findById(templateId)); }
ResourceTemplate resourceTemplate(Resource resource) { return this.engine().templateManagementService().templateOfId(resource.id().templateId()); }