Package org.apache.velocity.runtime

Class VelocimacroFactory

  • public class VelocimacroFactory
extends java.lang.Object
    VelocimacroFactory.java manages the set of VMs in a running Velocity engine.
    Version:
    $Id$

    • Nested Class Summary

      Nested Classes 
      Modifier and Type Class Description
      private static class  VelocimacroFactory.Twonk
      small container class to hold the tuple of a template and modification time.

    • Field Summary

      Fields 
      Modifier and Type Field Description
      private boolean addNewAllowed
      controls if new VMs can be added.
      private boolean autoReloadLibrary
      determines if the libraries are auto-loaded when they change
      private java.util.Map<java.lang.String,​VelocimacroFactory.Twonk> libModMap
      map of the library Template objects used for reload determination
      private org.slf4j.Logger log
      the log for this instance
      private java.util.List<java.lang.String> macroLibVec
      vector of the library names
      private boolean replaceAllowed
      determines if replacement of global VMs are allowed controlled by VM_PERM_ALLOW_INLINE_REPLACE_GLOBAL
      private RuntimeServices rsvc
      runtime services for this instance
      private boolean templateLocal
      sets if template-local namespace in used
      private VelocimacroManager vmManager
      VMManager: deal with namespace management and actually keeps all the VM definitions

    • Method Summary

      All Methods Instance Methods Concrete Methods 
      Modifier and Type Method Description
      boolean addVelocimacro​(java.lang.String name, Node macroBody, java.util.List<Macro.MacroArg> macroArgs, Template definingTemplate)
      Adds a macro to the factory.
      private boolean canAddVelocimacro​(java.lang.String name, Template definingTemplate)
      determines if a given macro/namespace (name, source) combo is allowed to be added
      private boolean getAutoload()
      get the switch for automatic reloading of global library-based VMs
      private boolean getTemplateLocalInline()  
      Directive getVelocimacro​(java.lang.String vmName, Template renderingTemplate, Template sourceTemplate)
      actual factory: creates a Directive that will behave correctly wrt getting the framework to dig out the correct # of args
      void initVelocimacro()
      initialize the factory - setup all permissions load all global libraries.
      boolean isVelocimacro​(java.lang.String vm, Template template)
      Tells the world if a given directive string is a Velocimacro
      private boolean setAddMacroPermission​(boolean addNewAllowed)
      sets the permission to add new macros
      private void setAutoload​(boolean b)
      set the switch for automatic reloading of global library-based VMs
      private boolean setReplacementPermission​(boolean arg)
      sets the permission for allowing addMacro() calls to replace existing VM's
      private void setTemplateLocalInline​(boolean b)
      sets permission to have VMs local in scope to their declaring template note that this is really taken care of in the VMManager class, but we need it here for gating purposes in addVM eventually, I will slide this all into the manager, maybe.

      • Methods inherited from class java.lang.Object

        clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

    • Field Detail

      • rsvc

        private final RuntimeServices rsvc
        runtime services for this instance

      • log

        private org.slf4j.Logger log
        the log for this instance

      • vmManager

        private VelocimacroManager vmManager
        VMManager: deal with namespace management and actually keeps all the VM definitions

      • replaceAllowed

        private boolean replaceAllowed
        determines if replacement of global VMs are allowed controlled by VM_PERM_ALLOW_INLINE_REPLACE_GLOBAL

      • addNewAllowed

        private boolean addNewAllowed
        controls if new VMs can be added. Set by VM_PERM_ALLOW_INLINE Note the assumption that only through inline defs can this happen. additions through autoloaded VMs is allowed

      • templateLocal

        private boolean templateLocal
        sets if template-local namespace in used

      • autoReloadLibrary

        private boolean autoReloadLibrary
        determines if the libraries are auto-loaded when they change

      • macroLibVec

        private java.util.List<java.lang.String> macroLibVec
        vector of the library names

      • libModMap

        private java.util.Map<java.lang.String,​VelocimacroFactory.Twonk> libModMap
        map of the library Template objects used for reload determination

    • Constructor Detail

      • VelocimacroFactory

        public VelocimacroFactory​(RuntimeServices rsvc)
        C'tor for the VelociMacro factory.
        Parameters:
        rsvc - Reference to a runtime services object.

    • Method Detail

      • initVelocimacro

        public void initVelocimacro()
        initialize the factory - setup all permissions load all global libraries.

      • addVelocimacro

        public boolean addVelocimacro​(java.lang.String name,
                              Node macroBody,
                              java.util.List<Macro.MacroArg> macroArgs,
                              Template definingTemplate)
        Adds a macro to the factory.
        Parameters:
        name - Name of the Macro to add.
        macroBody - root node of the parsed macro AST
        macroArgs - Array of macro arguments, containing the #macro() arguments and default values. the 0th is the name.
        definingTemplate - template containing the macro definition
        Returns:
        true if Macro was registered successfully.
        Since:
        1.6

      • canAddVelocimacro

        private boolean canAddVelocimacro​(java.lang.String name,
                                  Template definingTemplate)
        determines if a given macro/namespace (name, source) combo is allowed to be added
        Parameters:
        name - Name of VM to add
        definingTemplate - template containing the source of the macro
        Returns:
        true if it is allowed to be added, false otherwise

      • isVelocimacro

        public boolean isVelocimacro​(java.lang.String vm,
                             Template template)
        Tells the world if a given directive string is a Velocimacro
        Parameters:
        vm - Name of the Macro.
        template - Source template from which the macro should be loaded.
        Returns:
        True if the given name is a macro.

      • getVelocimacro

        public Directive getVelocimacro​(java.lang.String vmName,
                                Template renderingTemplate,
                                Template sourceTemplate)
        actual factory: creates a Directive that will behave correctly wrt getting the framework to dig out the correct # of args
        Parameters:
        vmName - Name of the Macro.
        renderingTemplate - destination template
        sourceTemplate - Source template from which the macro should be loaded.
        Returns:
        A directive representing the Macro.

      • setTemplateLocalInline

        private void setTemplateLocalInline​(boolean b)
        sets permission to have VMs local in scope to their declaring template note that this is really taken care of in the VMManager class, but we need it here for gating purposes in addVM eventually, I will slide this all into the manager, maybe.

      • getTemplateLocalInline

        private boolean getTemplateLocalInline()

      • setAddMacroPermission

        private boolean setAddMacroPermission​(boolean addNewAllowed)
        sets the permission to add new macros

      • setReplacementPermission

        private boolean setReplacementPermission​(boolean arg)
        sets the permission for allowing addMacro() calls to replace existing VM's

      • setAutoload

        private void setAutoload​(boolean b)
        set the switch for automatic reloading of global library-based VMs

      • getAutoload

        private boolean getAutoload()
        get the switch for automatic reloading of global library-based VMs