public static TemplateIntrospector newInstance(ResourceTemplate template) { TemplateIntrospector introspector = new TemplateIntrospector(template); template.accept(new TemplateIntrospectorInitializer(introspector)); return introspector; }
@Override public <T extends ResourceHandler> T getHandler(Class<? extends T> handlerClass) { ResourceTemplate template=templateLibrary().findByHandler(handlerClass); return this.manager.getHandler(handlerClass, template); }
@Override protected T doProcess(A annotation, Class<? extends ContainerHandler> handler) { T template = super.doProcess(annotation, handler); template.setMemberPath(nullable(memberPath(annotation))); return template; }
/** * {@inheritDoc} */ @Override public ResourceTemplate findById(String templateId) { return ImmutableTemplateFactory.newImmutable(delegate().findById(templateId)); }
protected M doProcess(A annotation, Class<? extends R> handler) { M template = createTemplate(annotation,handler); template.setName(nullable(name(annotation))); template.setDescription(nullable(description(annotation))); return template; }
@Override protected void doPostprocess(A annotation, T template, TemplateResolver resolver) { super.doPostprocess(annotation,template, resolver); Class<? extends ResourceHandler> handler = memberHandler(annotation); ResourceTemplate memberTemplate = resolver.resolve(handler); if(memberTemplate==null) { throw new TemplateCreationException(template.id(), "Could not resolve template for member handler '"+handler.getCanonicalName()+"' "); } template.setMemberTemplate(memberTemplate); }
@Override protected TemplateLibrary getLibrary() { MutableTemplateLibrary library= new MutableTemplateLibrary(); library.registerHandler(PersonContainerHandler.class); return new ImmutableTemplateLibrary(library); }
@Override protected T doProcess(A annotation, Class<? extends ContainerHandler> handler) { T template = super.doProcess(annotation, handler); template.setMembershipRelation(membershipRelation(annotation)); template.setMembershipPredicate(membershipPredicate(annotation, template)); return template; }
@Override public void visitMembershipAwareContainerTemplate(MembershipAwareContainerTemplate template) { visitContainerTemplate(template); this.introspector.membershipAware=true; this.introspector.membershipPredicate=template.membershipPredicate(); this.introspector.membershipRelation=template.membershipRelation(); }
static ResourceTemplate newImmutable(ResourceTemplate template) { if(template==null) { return null; } TemplateCreator creator = new TemplateCreator(); template.accept(creator); return creator.getCreatedTemplate(); }
@Override public void visitIndirectContainerTemplate(IndirectContainerTemplate template) { ImmutableTemplateFactory.newImmutable(template).accept(this.visitor); } }
/** * {@inheritDoc} */ @Override public void accept(final TemplateVisitor visitor) { delegate().accept(new SafeTemplateVisitor(visitor)); } }
/** * {@inheritDoc} */ @Override public ResourceTemplate findByHandler(Class<? extends ResourceHandler> handlerClass) { return ImmutableTemplateFactory.newImmutable(delegate().findByHandler(handlerClass)); }
@Override public ResourceTemplate memberTemplate() { return ImmutableTemplateFactory.newImmutable(template().memberTemplate()); }
@Override public void configure(List<Class<?>> handlerClasses,List<ResourceHandler> handlers) throws TemplateManagementServiceConfigurationException { TemplateManager manager= TemplateManager. builder(). withHandlerClasses(handlerClasses). withHandlers(handlers). build(); TemplateManagementService.this.updateState(manager); }
@Override public void visitIndirectContainerTemplate(IndirectContainerTemplate template) { visitMembershipAwareContainerTemplate(template); this.introspector.indirectContainer=true; this.introspector.insertedContentRelation=template.insertedContentRelation(); } }
@Override protected void processTemplate(ResourceTemplate template) { assertThatHasCustomString(template); for(AttachedTemplate attachedTemplate:template.attachedTemplates()) { assertThatHasCustomString(attachedTemplate); } }
ResourceTemplate toTemplate(Annotation annotation, Class<? extends ResourceHandler> targetClass, TemplateRegistry templateRegistry, TemplateResolver templateResolver) { AbstractMutableTemplate<?> template = this.processor.preProcess(annotation,targetClass); templateRegistry.register(targetClass, template); this.processor.postProcess(annotation, template, templateResolver); return template; }
private ResourceTemplate loadTemplates(Class<? extends ResourceHandler> targetClass, TemplateLoaderContext resolver) { ResourceTemplate template=createTemplate(targetClass,resolver); resolver.register(targetClass,template); return template; }