Coverage Report - org.apache.turbine.services.rundata.DefaultTurbineRunData
 
Classes in this File Line Coverage Branch Coverage Complexity
DefaultTurbineRunData
56%
157/276
41%
33/80
1,475
 
 1  
 package org.apache.turbine.services.rundata;
 2  
 
 3  
 /*
 4  
  * Licensed to the Apache Software Foundation (ASF) under one
 5  
  * or more contributor license agreements.  See the NOTICE file
 6  
  * distributed with this work for additional information
 7  
  * regarding copyright ownership.  The ASF licenses this file
 8  
  * to you under the Apache License, Version 2.0 (the
 9  
  * "License"); you may not use this file except in compliance
 10  
  * with the License.  You may obtain a copy of the License at
 11  
  *
 12  
  *   http://www.apache.org/licenses/LICENSE-2.0
 13  
  *
 14  
  * Unless required by applicable law or agreed to in writing,
 15  
  * software distributed under the License is distributed on an
 16  
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 17  
  * KIND, either express or implied.  See the License for the
 18  
  * specific language governing permissions and limitations
 19  
  * under the License.
 20  
  */
 21  
 
 22  
 import java.io.IOException;
 23  
 import java.io.PrintWriter;
 24  
 import java.util.ArrayList;
 25  
 import java.util.HashMap;
 26  
 import java.util.List;
 27  
 import java.util.Locale;
 28  
 import java.util.Map;
 29  
 
 30  
 import javax.naming.Context;
 31  
 import javax.servlet.ServletConfig;
 32  
 import javax.servlet.ServletContext;
 33  
 import javax.servlet.http.HttpServletRequest;
 34  
 import javax.servlet.http.HttpServletResponse;
 35  
 import javax.servlet.http.HttpSession;
 36  
 
 37  
 import org.apache.commons.lang.StringUtils;
 38  
 import org.apache.commons.logging.Log;
 39  
 import org.apache.commons.logging.LogFactory;
 40  
 import org.apache.ecs.Document;
 41  
 import org.apache.ecs.Element;
 42  
 import org.apache.ecs.StringElement;
 43  
 import org.apache.fulcrum.mimetype.MimeTypeService;
 44  
 import org.apache.fulcrum.parser.CookieParser;
 45  
 import org.apache.fulcrum.parser.ParameterParser;
 46  
 import org.apache.fulcrum.pool.Recyclable;
 47  
 import org.apache.turbine.Turbine;
 48  
 import org.apache.turbine.TurbineConstants;
 49  
 import org.apache.turbine.om.security.User;
 50  
 import org.apache.turbine.pipeline.DefaultPipelineData;
 51  
 import org.apache.turbine.services.ServiceManager;
 52  
 import org.apache.turbine.services.TurbineServices;
 53  
 import org.apache.turbine.services.template.TurbineTemplate;
 54  
 import org.apache.turbine.util.FormMessages;
 55  
 import org.apache.turbine.util.ServerData;
 56  
 import org.apache.turbine.util.SystemError;
 57  
 import org.apache.turbine.util.security.AccessControlList;
 58  
 import org.apache.turbine.util.template.TemplateInfo;
 59  
 
 60  
 /**
 61  
  * DefaultTurbineRunData is the default implementation of the
 62  
  * TurbineRunData interface, which is distributed by the Turbine
 63  
  * RunData service, if another implementation is not defined in
 64  
  * the default or specified RunData configuration.
 65  
  * TurbineRunData is an extension to RunData, which
 66  
  * is an interface to run-rime information that is passed
 67  
  * within Turbine. This provides the threading mechanism for the
 68  
  * entire system because multiple requests can potentially come in
 69  
  * at the same time.  Thus, there is only one RunData implementation
 70  
  * for each request that is being serviced.
 71  
  *
 72  
  * <p>DefaultTurbineRunData implements the Recyclable interface making
 73  
  * it possible to pool its instances for recycling.
 74  
  *
 75  
  * @author <a href="mailto:ilkka.priha@simsoft.fi">Ilkka Priha</a>
 76  
  * @author <a href="mailto:jon@latchkey.com">Jon S. Stevens</a>
 77  
  * @author <a href="mailto:bhoeneis@ee.ethz.ch">Bernie Hoeneisen</a>
 78  
  * @author <a href="mailto:dlr@finemaltcoding.com">Daniel Rall</a>
 79  
  * @author <a href="mailto:hps@intermeta.de">Henning P. Schmiedehausen</a>
 80  
  * @author <a href="mailto:quintonm@bellsouth.net">Quinton McCombs</a>
 81  
  * @version $Id: DefaultTurbineRunData.java 1066938 2011-02-03 20:14:53Z ludwig $
 82  
  */
 83  
 public class DefaultTurbineRunData
 84  
         extends DefaultPipelineData
 85  
         implements TurbineRunData, Recyclable
 86  
 {
 87  
     /**
 88  
      * The disposed flag.
 89  
      */
 90  
     private boolean disposed;
 91  
 
 92  
     /** The default locale. */
 93  26
     private static Locale defaultLocale = null;
 94  
 
 95  
     /** The default charset. */
 96  26
     private static String defaultCharSet = null;
 97  
 
 98  
     /** A reference to the GET/POST data parser. */
 99  
     private ParameterParser parameters;
 100  
 
 101  
     /** A reference to a cookie parser. */
 102  
     public CookieParser cookies;
 103  
 
 104  
     /** The servlet request interface. */
 105  
     private HttpServletRequest req;
 106  
 
 107  
     /** The servlet response interface. */
 108  
     private HttpServletResponse res;
 109  
 
 110  
     /** The servlet configuration. */
 111  
     private ServletConfig config;
 112  
 
 113  
     /**
 114  
      * The servlet context information.
 115  
      * Note that this is from the "Turbine" Servlet context.
 116  
      */
 117  
     private ServletContext servletContext;
 118  
 
 119  
     /** The access control list. */
 120  
     private AccessControlList acl;
 121  
 
 122  
     /** Determines if there is information in the document or not. */
 123  
     private boolean pageSet;
 124  
 
 125  
     /** This creates an ECS Document. */
 126  
     private Document page;
 127  
 
 128  
     /** Cached action name to execute for this request. */
 129  
     private String action;
 130  
 
 131  
     /** This is the layout that the page will use to render the screen. */
 132  
     private String layout;
 133  
 
 134  
     /** Cached screen name to execute for this request. */
 135  
     private String screen;
 136  
 
 137  
     /** The character encoding of template files. */
 138  
     private String templateEncoding;
 139  
 
 140  
     /** Information used by a Template system (such as Velocity/JSP). */
 141  
     private TemplateInfo templateInfo;
 142  
 
 143  
     /** This is where output messages from actions should go. */
 144  
     private StringElement message;
 145  
 
 146  
     /**
 147  
      * This is a dedicated message class where output messages from
 148  
      * actions should go.
 149  
      */
 150  
     private FormMessages messages;
 151  
 
 152  
     /** The user object. */
 153  
     private User user;
 154  
 
 155  
     /** This is what will build the <title></title> of the document. */
 156  
     private String title;
 157  
 
 158  
     /** Determines if there is information in the outputstream or not. */
 159  
     private boolean outSet;
 160  
 
 161  
     /**
 162  
      * Cache the output stream because it can be used in many
 163  
      * different places.
 164  
      */
 165  
     private PrintWriter out;
 166  
 
 167  
     /** The locale. */
 168  
     private Locale locale;
 169  
 
 170  
     /** The HTTP charset. */
 171  
     private String charSet;
 172  
 
 173  
     /** The HTTP content type to return. */
 174  54
     private String contentType = "text/html";
 175  
 
 176  
     /** If this is set, also set the status code to 302. */
 177  
     private String redirectURI;
 178  
 
 179  
     /** The HTTP status code to return. */
 180  54
     private int statusCode = HttpServletResponse.SC_OK;
 181  
 
 182  
     /** This is a List to hold critical system errors. */
 183  54
     private List<SystemError> errors = new ArrayList<SystemError>();
 184  
 
 185  
     /** JNDI Contexts. */
 186  
     private Map<String, Context> jndiContexts;
 187  
 
 188  
     /** Holds ServerData (basic properties) about this RunData object. */
 189  
     private ServerData serverData;
 190  
 
 191  
     /** @see #getRemoteAddr() */
 192  
     private String remoteAddr;
 193  
 
 194  
     /** @see #getRemoteHost() */
 195  
     private String remoteHost;
 196  
 
 197  
     /** @see #getUserAgent() */
 198  
     private String userAgent;
 199  
 
 200  
     /** A holder for stack trace. */
 201  
     private String stackTrace;
 202  
 
 203  
     /** A holder ofr stack trace exception. */
 204  
     private Throwable stackTraceException;
 205  
 
 206  
     /**
 207  
      * Put things here and they will be shown on the default Error
 208  
      * screen.  This is great for debugging variable values when an
 209  
      * exception is thrown.
 210  
      */
 211  54
     private Map<String, Object> debugVariables = new HashMap<String, Object>();
 212  
 
 213  
     /** Logging */
 214  26
     private static Log log = LogFactory.getLog(DefaultTurbineRunData.class);
 215  
 
 216  
     /**
 217  
      * Attempts to get the User object from the session.  If it does
 218  
      * not exist, it returns null.
 219  
      *
 220  
      * @param session An HttpSession.
 221  
      * @return A User.
 222  
      */
 223  
     public static User getUserFromSession(HttpSession session)
 224  
     {
 225  
         try
 226  
         {
 227  6
             return (User) session.getAttribute(User.SESSION_KEY);
 228  
         }
 229  0
         catch (ClassCastException e)
 230  
         {
 231  0
             return null;
 232  
         }
 233  
     }
 234  
 
 235  
     /**
 236  
      * Allows one to invalidate the user in a session.
 237  
      *
 238  
      * @param session An HttpSession.
 239  
      * @return True if user was invalidated.
 240  
      */
 241  
     public static boolean removeUserFromSession(HttpSession session)
 242  
     {
 243  
         try
 244  
         {
 245  0
             session.removeAttribute(User.SESSION_KEY);
 246  
         }
 247  0
         catch (Exception e)
 248  
         {
 249  0
             return false;
 250  0
         }
 251  0
         return true;
 252  
     }
 253  
 
 254  
     /**
 255  
      * Gets the default locale defined by properties named
 256  
      * "locale.default.lang" and "locale.default.country".
 257  
      *
 258  
      * This changed from earlier Turbine versions that you can
 259  
      * rely on getDefaultLocale() to never return null.
 260  
      *
 261  
      * @return A Locale object.
 262  
      */
 263  
     protected static Locale getDefaultLocale()
 264  
     {
 265  2
         if (defaultLocale == null)
 266  
         {
 267  
             /* Get the default locale and cache it in a static variable. */
 268  2
             String lang = Turbine.getConfiguration()
 269  
                 .getString(TurbineConstants.LOCALE_DEFAULT_LANGUAGE_KEY,
 270  
                     TurbineConstants.LOCALE_DEFAULT_LANGUAGE_DEFAULT);
 271  
 
 272  2
             String country = Turbine.getConfiguration()
 273  
                 .getString(TurbineConstants.LOCALE_DEFAULT_COUNTRY_KEY,
 274  
                     TurbineConstants.LOCALE_DEFAULT_COUNTRY_DEFAULT);
 275  
 
 276  
 
 277  
             // We ensure that lang and country is never null
 278  2
             defaultLocale =  new Locale(lang, country);
 279  
         }
 280  2
         return defaultLocale;
 281  
     }
 282  
 
 283  
     /**
 284  
      * Gets the default charset defined by a property named
 285  
      * "locale.default.charset" or by the specified locale.
 286  
      * If the specified locale is null, the default locale is applied.
 287  
      *
 288  
      * @return the name of the default charset or null.
 289  
      */
 290  
     protected String getDefaultCharSet()
 291  
     {
 292  8
         log.debug("getDefaultCharSet()");
 293  
 
 294  8
         if (defaultCharSet == null)
 295  
         {
 296  
             /* Get the default charset and cache it in a static variable. */
 297  4
             defaultCharSet = Turbine.getConfiguration()
 298  
                 .getString(TurbineConstants.LOCALE_DEFAULT_CHARSET_KEY,
 299  
                     TurbineConstants.LOCALE_DEFAULT_CHARSET_DEFAULT);
 300  4
             log.debug("defaultCharSet = " + defaultCharSet + " (From Properties)");
 301  
         }
 302  
 
 303  8
         String charset = defaultCharSet;
 304  
 
 305  8
         if (StringUtils.isEmpty(charset))
 306  
         {
 307  2
             log.debug("charset is empty!");
 308  
             /* Default charset isn't specified, get the locale specific one. */
 309  2
             Locale locale = this.locale;
 310  2
             if (locale == null)
 311  
             {
 312  2
                 locale = getDefaultLocale();
 313  2
                 log.debug("Locale was null, is now " + locale + " (from getDefaultLocale())");
 314  
             }
 315  
 
 316  2
             log.debug("Locale is " + locale);
 317  
 
 318  2
             if (!locale.equals(Locale.US))
 319  
             {
 320  2
                 log.debug("We don't have US Locale!");
 321  2
                 ServiceManager serviceManager = TurbineServices.getInstance();
 322  2
                                 MimeTypeService mimeTypeService=null;
 323  
                 try {
 324  2
                                         mimeTypeService= (MimeTypeService)serviceManager.getService(MimeTypeService.ROLE);
 325  
                 }
 326  0
                 catch (Exception e){
 327  0
                     throw new RuntimeException(e);
 328  2
                 }
 329  2
                 charset = mimeTypeService.getCharSet(locale);
 330  
 
 331  2
                 log.debug("Charset now " + charset);
 332  
             }
 333  
         }
 334  
 
 335  8
         log.debug("Returning default Charset of " + charset);
 336  8
         return charset;
 337  
     }
 338  
 
 339  
     /**
 340  
      * Constructs a run data object.
 341  
      */
 342  
     public DefaultTurbineRunData()
 343  
     {
 344  54
         super();
 345  54
         recycle();
 346  54
     }
 347  
 
 348  
     /**
 349  
      * Recycles the object by removing its disposed flag.
 350  
      */
 351  
     public void recycle()
 352  
     {
 353  54
         disposed = false;
 354  54
     }
 355  
 
 356  
     /**
 357  
      * Disposes a run data object.
 358  
      */
 359  
     public void dispose()
 360  
     {
 361  2
         parameters = null;
 362  2
         cookies = null;
 363  2
         req = null;
 364  2
         res = null;
 365  2
         config = null;
 366  2
         servletContext = null;
 367  2
         acl = null;
 368  2
         pageSet = false;
 369  2
         page = null;
 370  2
         action = null;
 371  2
         layout = null;
 372  2
         screen = null;
 373  2
         templateEncoding = null;
 374  2
         templateInfo = null;
 375  2
         message = null;
 376  2
         messages = null;
 377  2
         user = null;
 378  2
         title = null;
 379  2
         outSet = false;
 380  2
         out = null;
 381  2
         locale = null;
 382  2
         charSet = null;
 383  2
         contentType = "text/html";
 384  2
         redirectURI = null;
 385  2
         statusCode = HttpServletResponse.SC_OK;
 386  2
         errors.clear();
 387  2
         jndiContexts = null;
 388  2
         serverData = null;
 389  2
         remoteAddr = null;
 390  2
         remoteHost = null;
 391  2
         userAgent = null;
 392  2
         stackTrace = null;
 393  2
         stackTraceException = null;
 394  2
         debugVariables.clear();
 395  2
     }
 396  
 
 397  
     // ***************************************
 398  
     // Implementation of the RunData interface
 399  
     // ***************************************
 400  
 
 401  
     /**
 402  
      * Gets the parameters.
 403  
      *
 404  
      * @return a parameter parser.
 405  
      */
 406  
     public ParameterParser getParameters()
 407  
     {
 408  
         // Parse the parameters first, if not yet done.
 409  88
         if ((this.parameters != null) &&
 410  
                 (this.parameters.getRequest() != this.req))
 411  
         {
 412  32
             this.parameters.setRequest(this.req);
 413  
         }
 414  88
         return this.parameters;
 415  
     }
 416  
 
 417  
     /**
 418  
      * Gets the cookies.
 419  
      *
 420  
      * @return a cookie parser.
 421  
      */
 422  
     public CookieParser getCookies()
 423  
     {
 424  
         // Parse the cookies first, if not yet done.
 425  0
         if ((this.cookies != null) &&
 426  
                 (this.cookies.getRequest() != getRequest()))
 427  
         {
 428  0
             this.cookies.setData(getRequest(), getResponse());
 429  
         }
 430  0
         return this.cookies;
 431  
     }
 432  
 
 433  
     /**
 434  
      * Gets the servlet request.
 435  
      *
 436  
      * @return the request.
 437  
      */
 438  
     public HttpServletRequest getRequest()
 439  
     {
 440  104
         return this.req;
 441  
     }
 442  
 
 443  
     /**
 444  
      * Gets the servlet response.
 445  
      *
 446  
      * @return the response.
 447  
      */
 448  
     public HttpServletResponse getResponse()
 449  
     {
 450  38
         return this.res;
 451  
     }
 452  
 
 453  
     /**
 454  
      * Gets the servlet session information.
 455  
      *
 456  
      * @return the session.
 457  
      */
 458  
     public HttpSession getSession()
 459  
     {
 460  80
         return getRequest().getSession();
 461  
     }
 462  
 
 463  
     /**
 464  
      * Gets the servlet configuration used during servlet init.
 465  
      *
 466  
      * @return the configuration.
 467  
      */
 468  
     public ServletConfig getServletConfig()
 469  
     {
 470  0
         return this.config;
 471  
     }
 472  
 
 473  
     /**
 474  
      * Gets the servlet context used during servlet init.
 475  
      *
 476  
      * @return the context.
 477  
      */
 478  
     public ServletContext getServletContext()
 479  
     {
 480  0
         return this.servletContext;
 481  
     }
 482  
 
 483  
     /**
 484  
      * Gets the access control list.
 485  
      *
 486  
      * @return the access control list.
 487  
      */
 488  
     public AccessControlList getACL()
 489  
     {
 490  2
         return acl;
 491  
     }
 492  
 
 493  
     /**
 494  
      * Sets the access control list.
 495  
      *
 496  
      * @param acl an access control list.
 497  
      */
 498  
     public void setACL(AccessControlList acl)
 499  
     {
 500  2
         this.acl = acl;
 501  2
     }
 502  
 
 503  
     /**
 504  
      * Checks to see if the page is set.
 505  
      *
 506  
      * @return true if the page is set.
 507  
      * @deprecated no replacement planned, ECS is no longer a requirement
 508  
      */
 509  
     @Deprecated
 510  
     public boolean isPageSet()
 511  
     {
 512  0
         return pageSet;
 513  
     }
 514  
 
 515  
     /**
 516  
      * Gets the page.
 517  
      *
 518  
      * @return a document.
 519  
      * @deprecated no replacement planned, ECS is no longer a requirement
 520  
      */
 521  
     @Deprecated
 522  
     public Document getPage()
 523  
     {
 524  0
         pageSet = true;
 525  0
         if (this.page == null)
 526  
         {
 527  0
             this.page = new Document();
 528  
         }
 529  0
         return this.page;
 530  
     }
 531  
 
 532  
     /**
 533  
      * Whether or not an action has been defined.
 534  
      *
 535  
      * @return true if an action has been defined.
 536  
      */
 537  
     public boolean hasAction()
 538  
     {
 539  48
         return (StringUtils.isNotEmpty(this.action)
 540  
           && !this.action.equalsIgnoreCase("null"));
 541  
     }
 542  
 
 543  
     /**
 544  
      * Gets the action. It returns an empty string if null so
 545  
      * that it is easy to do conditionals on it based on the
 546  
      * equalsIgnoreCase() method.
 547  
      *
 548  
      * @return a string, "" if null.
 549  
      */
 550  
     public String getAction()
 551  
     {
 552  34
         return (hasAction() ? this.action : "");
 553  
     }
 554  
 
 555  
     /**
 556  
      * Sets the action for the request.
 557  
      *
 558  
      * @param action a atring.
 559  
      */
 560  
     public void setAction(String action)
 561  
     {
 562  30
         this.action = action;
 563  30
     }
 564  
 
 565  
     /**
 566  
      * If the Layout has not been defined by the screen then set the
 567  
      * layout to be "DefaultLayout".  The screen object can also
 568  
      * override this method to provide intelligent determination of
 569  
      * the Layout to execute.  You can also define that logic here as
 570  
      * well if you want it to apply on a global scale.  For example,
 571  
      * if you wanted to allow someone to define layout "preferences"
 572  
      * where they could dynamicially change the layout for the entire
 573  
      * site.
 574  
      *
 575  
      * @return a string.
 576  
      */
 577  
 
 578  
     public String getLayout()
 579  
     {
 580  12
         if (this.layout == null)
 581  
         {
 582  
             /*
 583  
              * This will return something if the template
 584  
              * services are running. If we get nothing we
 585  
              * will fall back to the ECS layout.
 586  
              */
 587  4
             layout = TurbineTemplate.getDefaultLayoutName(this);
 588  
 
 589  4
             if (layout == null)
 590  
             {
 591  0
                 layout = "DefaultLayout";
 592  
             }
 593  
         }
 594  
 
 595  12
         return this.layout;
 596  
     }
 597  
 
 598  
     /**
 599  
      * Set the layout for the request.
 600  
      *
 601  
      * @param layout a string.
 602  
      */
 603  
     public void setLayout(String layout)
 604  
     {
 605  4
         this.layout = layout;
 606  4
     }
 607  
 
 608  
     /**
 609  
      * Convenience method for a template info that
 610  
      * returns the layout template being used.
 611  
      *
 612  
      * @return a string.
 613  
      */
 614  
     public String getLayoutTemplate()
 615  
     {
 616  0
         return getTemplateInfo().getLayoutTemplate();
 617  
     }
 618  
 
 619  
     /**
 620  
      * Modifies the layout template for the screen. This convenience
 621  
      * method allows for a layout to be modified from within a
 622  
      * template. For example;
 623  
      *
 624  
      *    $data.setLayoutTemplate("NewLayout.vm")
 625  
      *
 626  
      * @param layout a layout template.
 627  
      */
 628  
     public void setLayoutTemplate(String layout)
 629  
     {
 630  0
         getTemplateInfo().setLayoutTemplate(layout);
 631  0
     }
 632  
 
 633  
     /**
 634  
      * Whether or not a screen has been defined.
 635  
      *
 636  
      * @return true if a screen has been defined.
 637  
      */
 638  
     public boolean hasScreen()
 639  
     {
 640  38
         return StringUtils.isNotEmpty(this.screen);
 641  
     }
 642  
 
 643  
     /**
 644  
      * Gets the screen to execute.
 645  
      *
 646  
      * @return a string.
 647  
      */
 648  
     public String getScreen()
 649  
     {
 650  22
         return (hasScreen() ? this.screen : "");
 651  
     }
 652  
 
 653  
     /**
 654  
      * Sets the screen for the request.
 655  
      *
 656  
      * @param screen a string.
 657  
      */
 658  
     public void setScreen(String screen)
 659  
     {
 660  14
         this.screen = screen;
 661  14
     }
 662  
 
 663  
     /**
 664  
      * Convenience method for a template info that
 665  
      * returns the name of the template being used.
 666  
      *
 667  
      * @return a string.
 668  
      */
 669  
     public String getScreenTemplate()
 670  
     {
 671  0
         return getTemplateInfo().getScreenTemplate();
 672  
     }
 673  
 
 674  
     /**
 675  
      * Sets the screen template for the request. For
 676  
      * example;
 677  
      *
 678  
      *    $data.setScreenTemplate("NewScreen.vm")
 679  
      *
 680  
      * @param screen a screen template.
 681  
      */
 682  
     public void setScreenTemplate(String screen)
 683  
     {
 684  2
         getTemplateInfo().setScreenTemplate(screen);
 685  2
     }
 686  
 
 687  
     /**
 688  
      * Gets the character encoding to use for reading template files.
 689  
      *
 690  
      * @return the template encoding or null if not specified.
 691  
      */
 692  
     public String getTemplateEncoding()
 693  
     {
 694  4
         return templateEncoding;
 695  
     }
 696  
 
 697  
     /**
 698  
      * Sets the character encoding to use for reading template files.
 699  
      *
 700  
      * @param encoding the template encoding.
 701  
      */
 702  
     public void setTemplateEncoding(String encoding)
 703  
     {
 704  0
         templateEncoding = encoding;
 705  0
     }
 706  
 
 707  
     /**
 708  
      * Gets the template info. Creates a new one if needed.
 709  
      *
 710  
      * @return a template info.
 711  
      */
 712  
     public TemplateInfo getTemplateInfo()
 713  
     {
 714  118
         if (templateInfo == null)
 715  
         {
 716  22
             templateInfo = new TemplateInfo(this);
 717  
         }
 718  118
         return templateInfo;
 719  
     }
 720  
 
 721  
     /**
 722  
      * Whether or not a message has been defined.
 723  
      *
 724  
      * @return true if a message has been defined.
 725  
      */
 726  
     public boolean hasMessage()
 727  
     {
 728  0
         return (this.message != null)
 729  
             && StringUtils.isNotEmpty(this.message.toString());
 730  
     }
 731  
 
 732  
     /**
 733  
      * Gets the results of an action or another message
 734  
      * to be displayed as a string.
 735  
      *
 736  
      * @return a string.
 737  
      */
 738  
     public String getMessage()
 739  
     {
 740  0
         return (this.message == null ? null : this.message.toString());
 741  
     }
 742  
 
 743  
     /**
 744  
      * Sets the message for the request as a string.
 745  
      *
 746  
      * @param msg a string.
 747  
      */
 748  
     public void setMessage(String msg)
 749  
     {
 750  0
         this.message = new StringElement(msg);
 751  0
     }
 752  
 
 753  
     /**
 754  
      * Adds the string to message. If message has prior messages from
 755  
      * other actions or screens, this method can be used to chain them.
 756  
      *
 757  
      * @param msg a string.
 758  
      */
 759  
     public void addMessage(String msg)
 760  
     {
 761  0
         addMessage(new StringElement(msg));
 762  0
     }
 763  
 
 764  
     /**
 765  
      * Gets the results of an action or another message
 766  
      * to be displayed as an ECS string element.
 767  
      *
 768  
      * @return a string element.
 769  
      */
 770  
     public StringElement getMessageAsHTML()
 771  
     {
 772  0
         return this.message;
 773  
     }
 774  
 
 775  
     /**
 776  
      * Sets the message for the request as an ECS element.
 777  
      *
 778  
      * @param msg an element.
 779  
      */
 780  
     public void setMessage(Element msg)
 781  
     {
 782  0
         this.message = new StringElement(msg);
 783  0
     }
 784  
 
 785  
     /**
 786  
      * Adds the ECS element to message. If message has prior messages from
 787  
      * other actions or screens, this method can be used to chain them.
 788  
      *
 789  
      * @param msg an element.
 790  
      */
 791  
     public void addMessage(Element msg)
 792  
     {
 793  0
         if (msg != null)
 794  
         {
 795  0
             if (message != null)
 796  
             {
 797  0
                 message.addElement(msg);
 798  
             }
 799  
             else
 800  
             {
 801  0
                 message = new StringElement(msg);
 802  
             }
 803  
         }
 804  0
     }
 805  
 
 806  
     /**
 807  
      * Unsets the message for the request.
 808  
      */
 809  
     public void unsetMessage()
 810  
     {
 811  0
         this.message = null;
 812  0
     }
 813  
 
 814  
     /**
 815  
      * Gets a FormMessages object where all the messages to the
 816  
      * user should be stored.
 817  
      *
 818  
      * @return a FormMessages.
 819  
      */
 820  
     public FormMessages getMessages()
 821  
     {
 822  0
         if (this.messages == null)
 823  
         {
 824  0
             this.messages = new FormMessages();
 825  
         }
 826  0
         return this.messages;
 827  
     }
 828  
 
 829  
     /**
 830  
      * Sets the FormMessages object for the request.
 831  
      *
 832  
      * @param msgs A FormMessages.
 833  
      */
 834  
     public void setMessages(FormMessages msgs)
 835  
     {
 836  0
         this.messages = msgs;
 837  0
     }
 838  
 
 839  
     /**
 840  
      * Gets the title of the page.
 841  
      *
 842  
      * @return a string.
 843  
      */
 844  
     public String getTitle()
 845  
     {
 846  0
         return (this.title == null ? "" : this.title);
 847  
     }
 848  
 
 849  
     /**
 850  
      * Sets the title of the page.
 851  
      *
 852  
      * @param title a string.
 853  
      */
 854  
     public void setTitle(String title)
 855  
     {
 856  0
         this.title = title;
 857  0
     }
 858  
 
 859  
     /**
 860  
      * Checks if a user exists in this session.
 861  
      *
 862  
      * @return true if a user exists in this session.
 863  
      */
 864  
     public boolean userExists()
 865  
     {
 866  0
         user = getUserFromSession();
 867  0
         return (user != null);
 868  
     }
 869  
 
 870  
     /**
 871  
      * Gets the user.
 872  
      *
 873  
      * @return a user.
 874  
      */
 875  
     public User getUser()
 876  
     {
 877  36
         return this.user;
 878  
     }
 879  
 
 880  
     /**
 881  
      * Sets the user.
 882  
      *
 883  
      * @param user a user.
 884  
      */
 885  
     public void setUser(User user)
 886  
     {
 887  10
         log.debug("user set: " + user.getName());
 888  10
         this.user = user;
 889  10
     }
 890  
 
 891  
     /**
 892  
      * Attempts to get the user from the session. If it does
 893  
      * not exist, it returns null.
 894  
      *
 895  
      * @return a user.
 896  
      */
 897  
     public User getUserFromSession()
 898  
     {
 899  6
         return getUserFromSession(getSession());
 900  
     }
 901  
 
 902  
     /**
 903  
      * Allows one to invalidate the user in the default session.
 904  
      *
 905  
      * @return true if user was invalidated.
 906  
      */
 907  
     public boolean removeUserFromSession()
 908  
     {
 909  0
         return removeUserFromSession(getSession());
 910  
     }
 911  
 
 912  
     /**
 913  
      * Checks to see if out is set.
 914  
      *
 915  
      * @return true if out is set.
 916  
      * @deprecated no replacement planned, response writer will not be cached
 917  
      */
 918  
     @Deprecated
 919  
     public boolean isOutSet()
 920  
     {
 921  0
         return outSet;
 922  
     }
 923  
 
 924  
     /**
 925  
      * Gets the print writer. First time calling this
 926  
      * will set the print writer via the response.
 927  
      *
 928  
      * @return a print writer.
 929  
      * @throws IOException
 930  
      * @deprecated no replacement planned, response writer will not be cached
 931  
      */
 932  
     @Deprecated
 933  
     public PrintWriter getOut()
 934  
             throws IOException
 935  
     {
 936  
         // Check to see if null first.
 937  0
         if (this.out == null)
 938  
         {
 939  0
             setOut(res.getWriter());
 940  
         }
 941  0
         pageSet = false;
 942  0
         outSet = true;
 943  0
         return this.out;
 944  
     }
 945  
 
 946  
     /**
 947  
      * Declares that output will be direct to the response stream,
 948  
      * even though getOut() may never be called.  Useful for response
 949  
      * mechanisms that may call res.getWriter() themselves
 950  
      * (such as JSP.)
 951  
      */
 952  
     public void declareDirectResponse()
 953  
     {
 954  0
         outSet = true;
 955  0
         pageSet = false;
 956  0
     }
 957  
 
 958  
     /**
 959  
      * Gets the locale. If it has not already been defined with
 960  
      * setLocale(), then  properties named "locale.default.lang"
 961  
      * and "locale.default.country" are checked from the Resource
 962  
      * Service and the corresponding locale is returned. If these
 963  
      * properties are undefined, JVM's default locale is returned.
 964  
      *
 965  
      * @return the locale.
 966  
      */
 967  
     public Locale getLocale()
 968  
     {
 969  2
         Locale locale = this.locale;
 970  2
         if (locale == null)
 971  
         {
 972  0
             locale = getDefaultLocale();
 973  
         }
 974  2
         return locale;
 975  
     }
 976  
 
 977  
     /**
 978  
      * Sets the locale.
 979  
      *
 980  
      * @param locale the new locale.
 981  
      */
 982  
     public void setLocale(Locale locale)
 983  
     {
 984  52
         this.locale = locale;
 985  
         
 986  
         // propagate the locale to the parsers
 987  52
         if (this.parameters != null)
 988  
         {
 989  52
             parameters.setLocale(locale);
 990  
         }
 991  
 
 992  52
         if (this.cookies != null)
 993  
         {
 994  52
             cookies.setLocale(locale);
 995  
         }
 996  52
     }
 997  
 
 998  
     /**
 999  
      * Gets the charset. If it has not already been defined with
 1000  
      * setCharSet(), then a property named "locale.default.charset"
 1001  
      * is checked from the Resource Service and returned. If this
 1002  
      * property is undefined, the default charset of the locale
 1003  
      * is returned. If the locale is undefined, null is returned.
 1004  
      *
 1005  
      * @return the name of the charset or null.
 1006  
      */
 1007  
     public String getCharSet()
 1008  
     {
 1009  4
         log.debug("getCharSet()");
 1010  
 
 1011  4
         if (StringUtils.isEmpty(charSet))
 1012  
         {
 1013  4
             log.debug("Charset was null!");
 1014  4
             return getDefaultCharSet();
 1015  
         }
 1016  
         else
 1017  
         {
 1018  0
             return charSet;
 1019  
         }
 1020  
     }
 1021  
 
 1022  
     /**
 1023  
      * Sets the charset.
 1024  
      *
 1025  
      * @param charSet the name of the new charset.
 1026  
      */
 1027  
     public void setCharSet(String charSet)
 1028  
     {
 1029  0
         log.debug("setCharSet(" + charSet + ")");
 1030  0
         this.charSet = charSet;
 1031  0
     }
 1032  
 
 1033  
     /**
 1034  
      * Gets the HTTP content type to return. If a charset
 1035  
      * has been specified, it is included in the content type.
 1036  
      * If the charset has not been specified and the main type
 1037  
      * of the content type is "text", the default charset is
 1038  
      * included. If the default charset is undefined, but the
 1039  
      * default locale is defined and it is not the US locale,
 1040  
      * a locale specific charset is included.
 1041  
      *
 1042  
      * @return the content type or an empty string.
 1043  
      */
 1044  
     public String getContentType()
 1045  
     {
 1046  2
         if (StringUtils.isNotEmpty(contentType))
 1047  
         {
 1048  2
             if (StringUtils.isEmpty(charSet))
 1049  
             {
 1050  2
                 if (contentType.startsWith("text/"))
 1051  
                 {
 1052  2
                     return contentType + "; charset=" + getDefaultCharSet();
 1053  
                 }
 1054  
                 
 1055  0
                 return contentType;
 1056  
             }
 1057  
             else
 1058  
             {
 1059  0
                 return contentType + "; charset=" + charSet;
 1060  
             }
 1061  
         }
 1062  
 
 1063  0
         return "";
 1064  
     }
 1065  
 
 1066  
     /**
 1067  
      * Sets the HTTP content type to return.
 1068  
      *
 1069  
      * @param contentType a string.
 1070  
      */
 1071  
     public void setContentType(String contentType)
 1072  
     {
 1073  0
         this.contentType = contentType;
 1074  0
     }
 1075  
 
 1076  
     /**
 1077  
      * Gets the redirect URI. If this is set, also make sure to set
 1078  
      * the status code to 302.
 1079  
      *
 1080  
      * @return a string, "" if null.
 1081  
      */
 1082  
     public String getRedirectURI()
 1083  
     {
 1084  6
         return (this.redirectURI == null ? "" : redirectURI);
 1085  
     }
 1086  
 
 1087  
     /**
 1088  
      * Sets the redirect uri. If this is set, also make sure to set
 1089  
      * the status code to 302.
 1090  
      *
 1091  
      * @param ruri a string.
 1092  
      */
 1093  
     public void setRedirectURI(String ruri)
 1094  
     {
 1095  0
         this.redirectURI = ruri;
 1096  0
     }
 1097  
 
 1098  
     /**
 1099  
      * Gets the HTTP status code to return.
 1100  
      *
 1101  
      * @return the status.
 1102  
      */
 1103  
     public int getStatusCode()
 1104  
     {
 1105  0
         return statusCode;
 1106  
     }
 1107  
 
 1108  
     /**
 1109  
      * Sets the HTTP status code to return.
 1110  
      *
 1111  
      * @param statusCode the status.
 1112  
      */
 1113  
     public void setStatusCode(int statusCode)
 1114  
     {
 1115  0
         this.statusCode = statusCode;
 1116  0
     }
 1117  
 
 1118  
     /**
 1119  
      * Gets an array of system errors.
 1120  
      *
 1121  
      * @return a SystemError[].
 1122  
      */
 1123  
     public SystemError[] getSystemErrors()
 1124  
     {
 1125  0
         SystemError[] result = new SystemError[errors.size()];
 1126  0
         errors.toArray(result);
 1127  0
         return result;
 1128  
     }
 1129  
 
 1130  
     /**
 1131  
      * Adds a critical system error.
 1132  
      *
 1133  
      * @param err a system error.
 1134  
      */
 1135  
     public void setSystemError(SystemError err)
 1136  
     {
 1137  0
         this.errors.add(err);
 1138  0
     }
 1139  
 
 1140  
     /**
 1141  
      * Gets JNDI Contexts.
 1142  
      *
 1143  
      * @return a hashtable.
 1144  
      */
 1145  
     public Map<String, Context> getJNDIContexts()
 1146  
     {
 1147  0
         if (jndiContexts == null)
 1148  0
             jndiContexts = new HashMap<String, Context>();
 1149  0
         return jndiContexts;
 1150  
     }
 1151  
 
 1152  
     /**
 1153  
      * Sets JNDI Contexts.
 1154  
      *
 1155  
      * @param contexts a hashtable.
 1156  
      */
 1157  
     public void setJNDIContexts(Map<String, Context> contexts)
 1158  
     {
 1159  0
         this.jndiContexts = contexts;
 1160  0
     }
 1161  
 
 1162  
     /**
 1163  
      * Gets the cached server scheme.
 1164  
      *
 1165  
      * @return a string.
 1166  
      */
 1167  
     public String getServerScheme()
 1168  
     {
 1169  0
         return getServerData().getServerScheme();
 1170  
     }
 1171  
 
 1172  
     /**
 1173  
      * Gets the cached server name.
 1174  
      *
 1175  
      * @return a string.
 1176  
      */
 1177  
     public String getServerName()
 1178  
     {
 1179  0
         return getServerData().getServerName();
 1180  
     }
 1181  
 
 1182  
     /**
 1183  
      * Gets the cached server port.
 1184  
      *
 1185  
      * @return an int.
 1186  
      */
 1187  
     public int getServerPort()
 1188  
     {
 1189  0
         return getServerData().getServerPort();
 1190  
     }
 1191  
 
 1192  
     /**
 1193  
      * Gets the cached context path.
 1194  
      *
 1195  
      * @return a string.
 1196  
      */
 1197  
     public String getContextPath()
 1198  
     {
 1199  0
         return getServerData().getContextPath();
 1200  
     }
 1201  
 
 1202  
     /**
 1203  
      * Gets the cached script name.
 1204  
      *
 1205  
      * @return a string.
 1206  
      */
 1207  
     public String getScriptName()
 1208  
     {
 1209  0
         return getServerData().getScriptName();
 1210  
     }
 1211  
 
 1212  
     /**
 1213  
      * Gets the server data ofy the request.
 1214  
      *
 1215  
      * @return server data.
 1216  
      */
 1217  
     public ServerData getServerData()
 1218  
     {
 1219  32
         return this.serverData;
 1220  
     }
 1221  
 
 1222  
     /**
 1223  
      * Gets the IP address of the client that sent the request.
 1224  
      *
 1225  
      * @return a string.
 1226  
      */
 1227  
     public String getRemoteAddr()
 1228  
     {
 1229  0
         if (this.remoteAddr == null)
 1230  
         {
 1231  0
             this.remoteAddr = this.getRequest().getRemoteAddr();
 1232  
         }
 1233  
 
 1234  0
         return this.remoteAddr;
 1235  
     }
 1236  
 
 1237  
     /**
 1238  
      * Gets the qualified name of the client that sent the request.
 1239  
      *
 1240  
      * @return a string.
 1241  
      */
 1242  
     public String getRemoteHost()
 1243  
     {
 1244  0
         if (this.remoteHost == null)
 1245  
         {
 1246  0
             this.remoteHost = this.getRequest().getRemoteHost();
 1247  
         }
 1248  
 
 1249  0
         return this.remoteHost;
 1250  
     }
 1251  
 
 1252  
     /**
 1253  
      * Get the user agent for the request. The semantics here
 1254  
      * are muddled because RunData caches the value after the
 1255  
      * first invocation. This is different e.g. from getCharSet().
 1256  
      *
 1257  
      * @return a string.
 1258  
      */
 1259  
     public String getUserAgent()
 1260  
     {
 1261  0
         if (StringUtils.isEmpty(userAgent))
 1262  
         {
 1263  0
             userAgent = this.getRequest().getHeader("User-Agent");
 1264  
         }
 1265  
 
 1266  0
         return userAgent;
 1267  
     }
 1268  
 
 1269  
     /**
 1270  
      * Pulls a user object from the session and increments the access
 1271  
      * counter and sets the last access date for the object.
 1272  
      */
 1273  
     public void populate()
 1274  
     {
 1275  6
         user = getUserFromSession();
 1276  
 
 1277  6
         if (user != null)
 1278  
         {
 1279  2
             user.setLastAccessDate();
 1280  2
             user.incrementAccessCounter();
 1281  2
             user.incrementAccessCounterForSession();
 1282  
         }
 1283  6
     }
 1284  
 
 1285  
     /**
 1286  
      * Saves a user object into the session.
 1287  
      */
 1288  
     public void save()
 1289  
     {
 1290  6
         getSession().setAttribute(User.SESSION_KEY, user);
 1291  6
     }
 1292  
 
 1293  
     /**
 1294  
      * Gets the stack trace if set.
 1295  
      *
 1296  
      * @return the stack trace.
 1297  
      */
 1298  
     public String getStackTrace()
 1299  
     {
 1300  4
         return stackTrace;
 1301  
     }
 1302  
 
 1303  
     /**
 1304  
      * Gets the stack trace exception if set.
 1305  
      *
 1306  
      * @return the stack exception.
 1307  
      */
 1308  
     public Throwable getStackTraceException()
 1309  
     {
 1310  2
         return stackTraceException;
 1311  
     }
 1312  
 
 1313  
     /**
 1314  
      * Sets the stack trace.
 1315  
      *
 1316  
      * @param trace the stack trace.
 1317  
      * @param exp the exception.
 1318  
      */
 1319  
     public void setStackTrace(String trace, Throwable exp)
 1320  
     {
 1321  2
         stackTrace = trace;
 1322  2
         stackTraceException = exp;
 1323  2
     }
 1324  
 
 1325  
     /**
 1326  
      * Gets a Map of debug variables.
 1327  
      *
 1328  
      * @return a Map of debug variables.
 1329  
      * @deprecated use {@link #getDebugVariables} instead
 1330  
      */
 1331  
     @Deprecated
 1332  
     public Map<String, Object> getVarDebug()
 1333  
     {
 1334  0
         return debugVariables;
 1335  
     }
 1336  
 
 1337  
     /**
 1338  
      * Sets a name/value pair in an internal Map that is accessible from the
 1339  
      * Error screen.  This is a good way to get debugging information
 1340  
      * when an exception is thrown.
 1341  
      *
 1342  
      * @param name name of the variable
 1343  
      * @param value value of the variable.
 1344  
      */
 1345  
     public void setDebugVariable(String name, Object value)
 1346  
     {
 1347  0
         this.debugVariables.put(name, value);
 1348  0
     }
 1349  
 
 1350  
     /**
 1351  
      * Gets a Map of debug variables.
 1352  
      *
 1353  
      * @return a Map of debug variables.
 1354  
      */
 1355  
     public Map<String, Object> getDebugVariables()
 1356  
     {
 1357  0
         return this.debugVariables;
 1358  
     }
 1359  
 
 1360  
     // **********************************************
 1361  
     // Implementation of the TurbineRunData interface
 1362  
     // **********************************************
 1363  
 
 1364  
     /**
 1365  
      * Gets the parameter parser without parsing the parameters.
 1366  
      *
 1367  
      * @return the parameter parser.
 1368  
      * @todo Does this method make sense? Pulling the parameter out of
 1369  
      *       the run data object before setting a request (which happens
 1370  
      *       only in getParameters() leads to the Parameter parser having
 1371  
      *       no object and thus the default or even an undefined encoding
 1372  
      *       instead of the actual request character encoding).
 1373  
      */
 1374  
     public ParameterParser getParameterParser()
 1375  
     {
 1376  2
         return parameters;
 1377  
     }
 1378  
 
 1379  
     /**
 1380  
      * Sets the parameter parser.
 1381  
      *
 1382  
      * @param parser a parameter parser.
 1383  
      */
 1384  
     public void setParameterParser(ParameterParser parser)
 1385  
     {
 1386  52
         parameters = parser;
 1387  52
     }
 1388  
 
 1389  
     /**
 1390  
      * Gets the cookie parser without parsing the cookies.
 1391  
      *
 1392  
      * @return the cookie parser.
 1393  
      */
 1394  
     public CookieParser getCookieParser()
 1395  
     {
 1396  2
         return cookies;
 1397  
     }
 1398  
 
 1399  
     /**
 1400  
      * Sets the cookie parser.
 1401  
      *
 1402  
      * @param parser a cookie parser.
 1403  
      */
 1404  
     public void setCookieParser(CookieParser parser)
 1405  
     {
 1406  52
         cookies = parser;
 1407  52
     }
 1408  
 
 1409  
     /**
 1410  
      * Sets the servlet request.
 1411  
      *
 1412  
      * @param req a request.
 1413  
      */
 1414  
     public void setRequest(HttpServletRequest req)
 1415  
     {
 1416  52
         this.req = req;
 1417  52
     }
 1418  
 
 1419  
     /**
 1420  
      * Sets the servlet response.
 1421  
      *
 1422  
      * @param res a response.
 1423  
      */
 1424  
     public void setResponse(HttpServletResponse res)
 1425  
     {
 1426  52
         this.res = res;
 1427  52
     }
 1428  
 
 1429  
     /**
 1430  
      * Sets the servlet configuration used during servlet init.
 1431  
      *
 1432  
      * @param config a configuration.
 1433  
      */
 1434  
     public void setServletConfig(ServletConfig config)
 1435  
     {
 1436  52
         this.config = config;
 1437  52
         if (config == null)
 1438  
         {
 1439  0
             this.servletContext = null;
 1440  
         }
 1441  
         else
 1442  
         {
 1443  52
             this.servletContext = config.getServletContext();
 1444  
         }
 1445  52
     }
 1446  
 
 1447  
     /**
 1448  
      * Sets the server data of the request.
 1449  
      *
 1450  
      * @param serverData server data.
 1451  
      */
 1452  
     public void setServerData(ServerData serverData)
 1453  
     {
 1454  52
         this.serverData = serverData;
 1455  52
     }
 1456  
 
 1457  
     // ********************
 1458  
     // Miscellanous setters
 1459  
     // ********************
 1460  
 
 1461  
     /**
 1462  
      * Sets the print writer.
 1463  
      *
 1464  
      * @param out a print writer.
 1465  
      * @deprecated no replacement planned, response writer will not be cached
 1466  
      */
 1467  
     @Deprecated
 1468  
     protected void setOut(PrintWriter out)
 1469  
     {
 1470  0
         this.out = out;
 1471  0
     }
 1472  
 
 1473  
     /**
 1474  
      * Sets the cached server scheme that is stored in the server data.
 1475  
      *
 1476  
      * @param serverScheme a string.
 1477  
      */
 1478  
     protected void setServerScheme(String serverScheme)
 1479  
     {
 1480  0
         getServerData().setServerScheme(serverScheme);
 1481  0
     }
 1482  
 
 1483  
     /**
 1484  
      * Sets the cached server same that is stored in the server data.
 1485  
      *
 1486  
      * @param serverName a string.
 1487  
      */
 1488  
     protected void setServerName(String serverName)
 1489  
     {
 1490  0
         getServerData().setServerName(serverName);
 1491  0
     }
 1492  
 
 1493  
     /**
 1494  
      * Sets the cached server port that is stored in the server data.
 1495  
      *
 1496  
      * @param port an int.
 1497  
      */
 1498  
     protected void setServerPort(int port)
 1499  
     {
 1500  0
         getServerData().setServerPort(port);
 1501  0
     }
 1502  
 
 1503  
     /**
 1504  
      * Sets the cached context path that is stored in the server data.
 1505  
      *
 1506  
      * @param contextPath a string.
 1507  
      */
 1508  
     protected void setContextPath(String contextPath)
 1509  
     {
 1510  0
         getServerData().setContextPath(contextPath);
 1511  0
     }
 1512  
 
 1513  
     /**
 1514  
      * Sets the cached script name that is stored in the server data.
 1515  
      *
 1516  
      * @param scriptName a string.
 1517  
      */
 1518  
     protected void setScriptName(String scriptName)
 1519  
     {
 1520  0
         getServerData().setScriptName(scriptName);
 1521  0
     }
 1522  
 
 1523  
     /**
 1524  
      * Checks whether the object is disposed.
 1525  
      *
 1526  
      * @return true, if the object is disposed.
 1527  
      */
 1528  
     public boolean isDisposed()
 1529  
     {
 1530  0
         return disposed;
 1531  
     }
 1532  
 
 1533  
 }