1 package org.apache.turbine.services.pull; 2 3 4 /* 5 * Licensed to the Apache Software Foundation (ASF) under one 6 * or more contributor license agreements. See the NOTICE file 7 * distributed with this work for additional information 8 * regarding copyright ownership. The ASF licenses this file 9 * to you under the Apache License, Version 2.0 (the 10 * "License"); you may not use this file except in compliance 11 * with the License. You may obtain a copy of the License at 12 * 13 * http://www.apache.org/licenses/LICENSE-2.0 14 * 15 * Unless required by applicable law or agreed to in writing, 16 * software distributed under the License is distributed on an 17 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 18 * KIND, either express or implied. See the License for the 19 * specific language governing permissions and limitations 20 * under the License. 21 */ 22 23 24 import org.apache.turbine.pipeline.PipelineData; 25 import org.apache.turbine.services.TurbineServices; 26 import org.apache.turbine.util.RunData; 27 import org.apache.velocity.context.Context; 28 29 /** 30 * This is a Facade class for PullService. 31 * 32 * This class provides static methods that call related methods of the 33 * implementation of the PullService used by the System, according to 34 * the settings in TurbineResources. 35 * 36 * @author <a href="mailto:jvanzyl@periapt.com">Jason van Zyl</a> 37 * @author <a href="mailto:dlr@finemaltcoding.com">Daniel Rall</a> 38 * @author <a href="mailto:hps@intermeta.de">Henning P. Schmiedehausen</a> 39 * @author <a href="mailto:peter@courcoux.biz">Peter Courcoux</a> 40 * @version $Id: TurbinePull.java 1078552 2011-03-06 19:58:46Z tv $ 41 */ 42 public abstract class TurbinePull 43 { 44 /** 45 * Utility method for accessing the service 46 * implementation 47 * 48 * @return a PullService implementation instance 49 */ 50 public static PullService getService() 51 { 52 return (PullService) TurbineServices 53 .getInstance().getService(PullService.SERVICE_NAME); 54 } 55 56 /** 57 * Get the context containing global tools that will be 58 * use as part of the Turbine Pull Model. 59 * 60 * @return A Context object which contains the 61 * Global Tool instances. 62 */ 63 public static final Context getGlobalContext() 64 { 65 return getService().getGlobalContext(); 66 } 67 68 /** 69 * Checks whether this service has been registered. This is 70 * required by the TurbineVelocityService so it can determine 71 * whether to attempt to place the ToolBox in the context. 72 * <p> 73 * So users can use Turbine with templates in the traditional 74 * manner. If the Pull Service is not listed in 75 * <code>TurbineResources.props</code>, or no tools are specified 76 * the TurbineVelocityService will behave in its traditional 77 * manner. 78 */ 79 public static final boolean isRegistered() 80 { 81 return TurbineServices.getInstance() 82 .isRegistered(PullService.SERVICE_NAME); 83 } 84 85 /** 86 * Return the absolute path of the resources directory 87 * used by application tools. 88 * 89 * @return A directory path in the file system or null. 90 */ 91 public static final String getAbsolutePathToResourcesDirectory() 92 { 93 return getService().getAbsolutePathToResourcesDirectory(); 94 } 95 96 /** 97 * Return the resources directory. This is relative 98 * to the webapp context. 99 * 100 * @return A directory path to the resources directory relative to the webapp root or null. 101 */ 102 public static final String getResourcesDirectory() 103 { 104 return getService().getResourcesDirectory(); 105 } 106 107 /** 108 * Populate the given context with all request, session 109 * and persistent scope tools (it is assumed that the context 110 * already wraps the global context, and thus already contains 111 * the global tools). 112 * 113 * @param context a Velocity Context to populate 114 * @param data a RunData object for request specific data 115 */ 116 public static void populateContext(Context context, PipelineData pipelineData) 117 { 118 getService().populateContext(context, pipelineData); 119 } 120 121 /** 122 * Populate the given context with all request, session 123 * and persistent scope tools (it is assumed that the context 124 * already wraps the global context, and thus already contains 125 * the global tools). 126 * 127 * @param context a Velocity Context to populate 128 * @param data a RunData object for request specific data 129 */ 130 public static void populateContext(Context context, RunData data) 131 { 132 getService().populateContext(context, data); 133 } 134 135 /** 136 * Release tool instances from the given context to the 137 * object pool 138 * 139 * @param context a Velocity Context to release tools from 140 */ 141 public static void releaseTools(Context context) 142 { 143 getService().releaseTools(context); 144 } 145 146 /** 147 * Helper method that allows you to easily get a tool 148 * from a Context. Essentially, it just does the cast 149 * to an Application tool for you. 150 * 151 * @param context a Velocity Context to get tools from 152 * @param name the name of the tool to get 153 * @return ApplicationTool null if no tool could be found 154 */ 155 public static ApplicationTool getTool(Context context, 156 String name) 157 { 158 try 159 { 160 return (ApplicationTool) context.get(name); 161 } 162 catch (Exception e) 163 { 164 // ignore 165 } 166 return null; 167 } 168 }