001 package org.apache.turbine.services.pull; 002 003 004 /* 005 * Licensed to the Apache Software Foundation (ASF) under one 006 * or more contributor license agreements. See the NOTICE file 007 * distributed with this work for additional information 008 * regarding copyright ownership. The ASF licenses this file 009 * to you under the Apache License, Version 2.0 (the 010 * "License"); you may not use this file except in compliance 011 * with the License. You may obtain a copy of the License at 012 * 013 * http://www.apache.org/licenses/LICENSE-2.0 014 * 015 * Unless required by applicable law or agreed to in writing, 016 * software distributed under the License is distributed on an 017 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 018 * KIND, either express or implied. See the License for the 019 * specific language governing permissions and limitations 020 * under the License. 021 */ 022 023 024 import org.apache.turbine.pipeline.PipelineData; 025 import org.apache.turbine.services.TurbineServices; 026 import org.apache.turbine.util.RunData; 027 import org.apache.velocity.context.Context; 028 029 /** 030 * This is a Facade class for PullService. 031 * 032 * This class provides static methods that call related methods of the 033 * implementation of the PullService used by the System, according to 034 * the settings in TurbineResources. 035 * 036 * @author <a href="mailto:jvanzyl@periapt.com">Jason van Zyl</a> 037 * @author <a href="mailto:dlr@finemaltcoding.com">Daniel Rall</a> 038 * @author <a href="mailto:hps@intermeta.de">Henning P. Schmiedehausen</a> 039 * @author <a href="mailto:peter@courcoux.biz">Peter Courcoux</a> 040 * @version $Id: TurbinePull.java 1078552 2011-03-06 19:58:46Z tv $ 041 */ 042 public abstract class TurbinePull 043 { 044 /** 045 * Utility method for accessing the service 046 * implementation 047 * 048 * @return a PullService implementation instance 049 */ 050 public static PullService getService() 051 { 052 return (PullService) TurbineServices 053 .getInstance().getService(PullService.SERVICE_NAME); 054 } 055 056 /** 057 * Get the context containing global tools that will be 058 * use as part of the Turbine Pull Model. 059 * 060 * @return A Context object which contains the 061 * Global Tool instances. 062 */ 063 public static final Context getGlobalContext() 064 { 065 return getService().getGlobalContext(); 066 } 067 068 /** 069 * Checks whether this service has been registered. This is 070 * required by the TurbineVelocityService so it can determine 071 * whether to attempt to place the ToolBox in the context. 072 * <p> 073 * So users can use Turbine with templates in the traditional 074 * manner. If the Pull Service is not listed in 075 * <code>TurbineResources.props</code>, or no tools are specified 076 * the TurbineVelocityService will behave in its traditional 077 * manner. 078 */ 079 public static final boolean isRegistered() 080 { 081 return TurbineServices.getInstance() 082 .isRegistered(PullService.SERVICE_NAME); 083 } 084 085 /** 086 * Return the absolute path of the resources directory 087 * used by application tools. 088 * 089 * @return A directory path in the file system or null. 090 */ 091 public static final String getAbsolutePathToResourcesDirectory() 092 { 093 return getService().getAbsolutePathToResourcesDirectory(); 094 } 095 096 /** 097 * Return the resources directory. This is relative 098 * to the webapp context. 099 * 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 }