Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package edu.mit.simile.butterfly.velocity;
  
  import java.io.Writer;
  
  import org.slf4j.Logger;
This class implements a Butterfly-special Velocity command "#super()" that allows template to invoke the parent that they have overloaded. This works only with modules extending one another and it's useful for template delegation.
 
 public class Super extends InputBase {
 
     final static private Logger _logger = LoggerFactory.getLogger("Velocity.super");
     
     @Override
     public String getName() {
         return "super";
     }
 
     @Override
     public int getType() {
         return ;
     }
 
     @Override
     public boolean render(InternalContextAdapter contextWriter writerNode node
         
         // avoid rendering if no longer allowed (after a stop)
         if (!context.getAllowRendering()) {
             return true;
         }
         
         String template = context.getCurrentTemplateName();
         .debug("Injecting parent of {}"template);
 
         // decorate the template so that the ButterflyModule understands it has
         // to look for an overloaded resource first. This is hacky, I know, but
         // unfortunately I see no other way of signaling such behavior to the 
         // resource loader via Velocity's own conduits.
         template = "@@" + template + "@@";
         
         // see if we have exceeded the configured depth.
         // If it isn't configured, put a stop at 20 just in case.
 
         Object[] templateStack = context.getTemplateNameStack();
 
         if (templateStack.length >= .getInt(., 20)) {
             StringBuffer path = new StringBuffer();
 
             for (int i = 0; i < templateStack.length; ++i) {
                 path.append(" > ");
                 path.append(templateStack[i]);
             }
 
             .error("Max recursion depth reached (" + templateStack.length + ")" + " File stack:" + path);
             return false;
         }
 
         // now use the Runtime resource loader to get the template
 
         Template t = null;
 
         try {
             t = .getTemplate(templategetInputEncoding(context));
         } catch (ResourceNotFoundException rnfe) {
             // the arg wasn't found. Note it and throw
             .error("#inject(): cannot find template '" + template + "', called from template "
                     + context.getCurrentTemplateName() + " at (" + getLine() + ", " + getColumn() + ")");
             throw rnfe;
         } catch (ParseErrorException pee) {
             // the arg was found, but didn't parse - syntax error
             .error("#inject(): syntax error in #inject()-ed template '" + template + "', called from template "
                     + context.getCurrentTemplateName() + " at (" + getLine() + ", " + getColumn() + ")");
             throw pee;
         } catch (Exception e) {
             .error("#inject(): arg = " + template + ".  Exception: " + e);
             return false;
         }
 
         // and render it
         try {
             context.pushCurrentTemplateName(template);
             ((SimpleNodet.getData()).render(contextwriter);
         } catch (Exception e) {
             // if it's a MIE, it came from the render.... throw it...
             if (e instanceof MethodInvocationException) {
                throw (MethodInvocationExceptione;
            }
            .error("Exception rendering #inject(" + template + ")"e);
            return false;
        } finally {
            context.popCurrentTemplateName();
        }
        return true;
    }
New to GrepCode? Check out our FAQ X