internal VelocimacroProxy CreateVelocimacro(String ns) { VelocimacroProxy velocimacroProxy = new VelocimacroProxy(); velocimacroProxy.Name = macroName; velocimacroProxy.ArgArray = argumentArray; velocimacroProxy.MacroBody = macroBody; velocimacroProxy.NodeTree = nodeTree; velocimacroProxy.Namespace = ns; return(velocimacroProxy); }
internal VelocimacroProxy createVelocimacro(String namespace_Renamed) { VelocimacroProxy vp = new VelocimacroProxy(); vp.Name = this.macroname; vp.ArgArray = this.argarray; vp.Macrobody = this.macrobody; vp.NodeTree = this.nodeTree; vp.Namespace = namespace_Renamed; return(vp); }
internal MacroEntry(string vmName, INode macro, string[] argArray, string sourceTemplate) { this.vmName = vmName; this.argArray = argArray; this.nodeTree = (SimpleNode)macro; this.sourceTemplate = sourceTemplate; vp = new VelocimacroProxy(); vp.SetName(this.vmName); vp.ArgArray = this.argArray; vp.NodeTree = this.nodeTree; }
public Directive.Directive GetVelocimacro(string vmName, string sourceTemplate) { VelocimacroProxy velocimacroProxy = null; lock (this) { velocimacroProxy = this.vmManager.get(vmName, sourceTemplate); if (velocimacroProxy != null && this.Autoload) { string libraryName = this.vmManager.GetLibraryName(vmName, sourceTemplate); if (libraryName != null) { try { VelocimacroFactory.Twonk twonk = (VelocimacroFactory.Twonk) this.libModMap[libraryName]; if (twonk != null) { Template template = twonk.template; long modificationTime = twonk.modificationTime; long lastModified = template.ResourceLoader.GetLastModified(template); if (lastModified > modificationTime) { this.LogVMMessageInfo("Velocimacro : autoload reload for VMs from VM library template : " + libraryName); twonk.modificationTime = lastModified; template = this.rsvc.GetTemplate(libraryName); twonk.template = template; twonk.modificationTime = template.LastModified; } } } catch (System.Exception ex) { this.LogVMMessageInfo(string.Concat(new object[] { "Velocimacro : error using VM library template ", libraryName, " : ", ex })); } velocimacroProxy = this.vmManager.get(vmName, sourceTemplate); } } } return(velocimacroProxy); }
/// <summary> actual factory : creates a Directive that will /// behave correctly wrt getting the framework to /// dig out the correct # of args /// </summary> public Directive.Directive GetVelocimacro(String vmName, String sourceTemplate) { VelocimacroProxy velocimacroProxy = null; lock (this) { /* * don't ask - do */ velocimacroProxy = velocimacroManager.get(vmName, sourceTemplate); /* * if this exists, and autoload is on, we need to check * where this VM came from */ if (velocimacroProxy != null && Autoload) { /* * see if this VM came from a library. Need to pass sourceTemplate * in the event namespaces are set, as it could be masked by local */ String lib = velocimacroManager.GetLibraryName(vmName, sourceTemplate); if (lib != null) { try { /* * get the template from our map */ Twonk twonk = (Twonk)libModMap[lib]; if (twonk != null) { Template template = twonk.template; /* * now, compare the last modified time of the resource * with the last modified time of the template * if the file has changed, then reload. Otherwise, we should * be ok. */ long tt = twonk.modificationTime; long ft = template.ResourceLoader.GetLastModified(template) ; if (ft > tt) { LogVMMessageInfo(string.Format("Velocimacro : autoload reload for VMs from VM library template : {0}", lib)); /* * when there are VMs in a library that invoke each other, * there are calls into getVelocimacro() from the init() * process of the VM directive. To stop the infinite loop * we save the current time reported by the resource loader * and then be honest when the reload is complete */ twonk.modificationTime = ft; template = runtimeServices.GetTemplate(lib) ; /* * and now we be honest */ twonk.template = template; twonk.modificationTime = template.LastModified; /* * note that we don't need to put this twonk back * into the map, as we can just use the same reference * and this block is synchronized */ } } } catch (System.Exception e) { LogVMMessageInfo(string.Format("Velocimacro : error using VM library template {0} : {1}", lib, e)); } /* * and get again */ velocimacroProxy = velocimacroManager.get(vmName, sourceTemplate); } } } return(velocimacroProxy); }
/// <since> 1.6 /// </since> public virtual Directive.Directive GetVelocimacro(string vmName, string sourceTemplate, string renderingTemplate) { VelocimacroProxy vp = null; vp = vmManager.Get(vmName, sourceTemplate, renderingTemplate); /* * if this exists, and autoload is on, we need to check where this VM came from */ if (vp != null && autoReloadLibrary) { lock (this) { /* * see if this VM came from a library. Need to pass sourceTemplate in the event * namespaces are set, as it could be masked by local */ string lib = vmManager.GetLibraryName(vmName, sourceTemplate); if (lib != null) { try { /* * Get the template from our map */ if (libModMap.ContainsKey(lib)) { Twonk tw = libModMap[lib]; Template template = tw.template; /* * now, Compare the last modified time of the resource with the last * modified time of the template if the file has changed, then reload. * Otherwise, we should be ok. */ long tt = tw.modificationTime; long ft = template.ResourceLoader.GetLastModified(template); if (ft > tt) { log.Debug("auto-reloading VMs from VM library : " + lib); /* * when there are VMs in a library that invoke each other, there are * calls into getVelocimacro() from the Init() process of the VM * directive. To stop the infinite loop we save the current time * reported by the resource loader and then be honest when the * reload is complete */ tw.modificationTime = ft; template = rsvc.GetTemplate(lib); /* * and now we be honest */ tw.template = template; tw.modificationTime = template.LastModified; /* * note that we don't need to Put this twonk * back into the map, as we can just use the * same reference and this block is synchronized */ } } } catch (System.Exception e) { string msg = "Velocimacro : Error using VM library : " + lib; //Log.Error(true, msg, e); throw new VelocityException(msg, e); } vp = vmManager.Get(vmName, sourceTemplate, renderingTemplate); } } } return(vp); }
internal VelocimacroProxy CreateVelocimacro(String ns) { VelocimacroProxy vp = new VelocimacroProxy(); vp.Name = macroname; vp.ArgArray = argarray; vp.Macrobody = macrobody; vp.NodeTree = nodeTree; vp.Namespace = ns; return vp; }
internal VelocimacroProxy CreateVelocimacro(String ns) { VelocimacroProxy velocimacroProxy = new VelocimacroProxy(); velocimacroProxy.Name = macroName; velocimacroProxy.ArgArray = argumentArray; velocimacroProxy.MacroBody = macroBody; velocimacroProxy.NodeTree = nodeTree; velocimacroProxy.Namespace = ns; return velocimacroProxy; }