* page context for every page object.

* the PageContext is a jsp page context expanded by CFML functionality.

* for example you have the method getSession to get jsp combatible session object (HTTPSession)

*  and with sessionScope() you get CFML combatible session object (Struct,Scope).

*/

 

  private static final RefBoolean DUMMY_BOOL = new RefBooleanImpl(false);

 

  private static int counter=0;

 

  /**

   * Field <code>pathList</code>

   */

    private LinkedList<UDF> udfs=new LinkedList<UDF>();

    private LinkedList<PageSource> pathList=new LinkedList<PageSource>();

    private LinkedList<PageSource> includePathList=new LinkedList<PageSource>();

    private Set<PageSource> includeOnce=new HashSet<PageSource>();

 

  /**

   * Field <code>executionTime</code>

   */

  protected long executionTime=0;

 

  private HTTPServletRequestWrap req;

  private HttpServletResponse rsp;

  private HttpServlet servlet;

 

  private JspWriter writer;

    private JspWriter forceWriter;

    private BodyContentStack bodyContentStack;

    private DevNullBodyContent devNull;

   

  private ConfigWebImpl config;

  //private DataSourceManager manager;

  //private CFMLCompilerImpl compiler;

 

  // Scopes

  private ScopeContext scopeContext;

    private Variables variablesRoot=new VariablesImpl();//ScopeSupport(false,"variables",Scope.SCOPE_VARIABLES);

    private Variables variables=variablesRoot;//new ScopeSupport("variables",Scope.SCOPE_VARIABLES);

    private Undefined undefined;

 

    private URLImpl _url=new URLImpl();

  private FormImpl _form=new FormImpl();

 

  private URLForm urlForm=new UrlFormImpl(_form,_url);

  private URL url;

  private Form form;

 

 

  private RequestImpl request=new RequestImpl();

  private CGIImpl cgi=new CGIImpl(); 

  private Argument argument=new ArgumentImpl();

    private static LocalNotSupportedScope localUnsupportedScope=LocalNotSupportedScope.getInstance();

  private Local local=localUnsupportedScope;

  private Session session;

  private Server server;

  private Cluster cluster;

  private CookieImpl cookie=new CookieImpl();

  private Client client;

  private Application application;

    private DebuggerPro debugger=new DebuggerImpl();

  private long requestTimeout=-1;

  private short enablecfoutputonly=0;

  private int outputState;

  private String cfid;

  private String cftoken;

  private int id;

  private int requestId;

 

 

  private boolean psq;

  private Locale locale;

  private TimeZone timeZone;

 

    // Pools

    private ErrorPagePool errorPagePool=new ErrorPagePool();

  private TagHandlerPool tagHandlerPool;

  private FTPPool ftpPool=new FTPPoolImpl();

  private final QueryCache queryCache;

  private Component activeComponent;

  private UDF activeUDF;

  private Collection.Key activeUDFCalledName;

    //private ComponentScope componentScope=new ComponentScope(this);

 

  private Credential remoteUser;

   

    protected VariableUtilImpl variableUtil=new VariableUtilImpl();

    private PageException exception;

    private PageSource base;

    ApplicationContext applicationContext;

    ApplicationContext defaultApplicationContext;

    private ScopeFactory scopeFactory=new ScopeFactory();

    private Tag parentTag=null;

    private Tag currentTag=null;

    private Thread thread;

    private long startTime;

  private boolean isCFCRequest;

 

  private DatasourceManagerImpl manager;

  private Struct threads;

  private boolean hasFamily=false;

  //private CFMLFactoryImpl factory;

  private PageContextImpl parent;

  private Map<String,DatasourceConnection> conns=new HashMap<String,DatasourceConnection>();

  private boolean fdEnabled;

  private ExecutionLog execLog;

  private boolean useSpecialMappings;

 

  private ORMSession ormSession;

  private boolean isChild;

  private boolean gatewayContext;

  private String serverPassword;

  private PageException pe;

  public long sizeOf() {

   

    return

    SizeOf.size(pathList)+

    SizeOf.size(includePathList)+

    SizeOf.size(executionTime)+

    SizeOf.size(writer)+

    SizeOf.size(forceWriter)+

    SizeOf.size(bodyContentStack)+

    SizeOf.size(variables)+

    SizeOf.size(url)+

    SizeOf.size(form)+

    SizeOf.size(_url)+

    SizeOf.size(_form)+

    SizeOf.size(request)+

    SizeOf.size(argument)+

    SizeOf.size(local)+

    SizeOf.size(cookie)+

    SizeOf.size(debugger)+

    SizeOf.size(requestTimeout)+

    SizeOf.size(enablecfoutputonly)+

    SizeOf.size(outputState)+

    SizeOf.size(cfid)+

    SizeOf.size(cftoken)+

    SizeOf.size(id)+

    SizeOf.size(psq)+

    SizeOf.size(locale)+

    SizeOf.size(errorPagePool)+

    SizeOf.size(tagHandlerPool)+

    SizeOf.size(ftpPool)+

    SizeOf.size(activeComponent)+

    SizeOf.size(activeUDF)+

    SizeOf.size(remoteUser)+

    SizeOf.size(exception)+

    SizeOf.size(base)+

    SizeOf.size(applicationContext)+

    SizeOf.size(defaultApplicationContext)+

    SizeOf.size(parentTag)+

    SizeOf.size(currentTag)+

    SizeOf.size(startTime)+

    SizeOf.size(isCFCRequest)+

    SizeOf.size(conns)+

    SizeOf.size(serverPassword)+

    SizeOf.size(ormSession);

  }

 

 

  /**

   * default Constructor

   * @param scopeContext

   * @param config Configuration of the CFML Container

   * @param queryCache Query Cache Object

   * @param id identity of the pageContext

   * @param servlet

   */

  public PageContextImpl(ScopeContext scopeContext, ConfigWebImpl config, QueryCache queryCache,int id,HttpServlet servlet) {

    // must be first because is used after

    tagHandlerPool=config.getTagHandlerPool();

        this.servlet=servlet;

    this.id=id;

    //this.factory=factory;

   

        bodyContentStack=new BodyContentStack();

        devNull=bodyContentStack.getDevNullBodyContent();

       

        this.config=config;

        manager=new DatasourceManagerImpl(config);

       

      this.scopeContext=scopeContext;

        undefined=

          new UndefinedImpl(this,config.getScopeCascadingType());

       

       

    //this.compiler=compiler;

        //tagHandlerPool=config.getTagHandlerPool();

    this.queryCache=queryCache;

    server=ScopeContext.getServerScope(this);

   

    defaultApplicationContext=new ClassicApplicationContext(config,"",true,null);

   

  }

  @Override

  public void initialize(

      Servlet servlet,

      ServletRequest req,

      ServletResponse rsp,

      String errorPageURL,

      boolean needsSession,

      int bufferSize,

      boolean autoFlush) throws IOException, IllegalStateException, IllegalArgumentException {

    initialize(

         (HttpServlet)servlet,

         (HttpServletRequest)req,

         (HttpServletResponse)rsp,

         errorPageURL,

         needsSession,

         bufferSize,

         autoFlush,false);

  }

 

  /**

   * initialize a existing page context

   * @param servlet

   * @param req

   * @param rsp

   * @param errorPageURL

   * @param needsSession

   * @param bufferSize

   * @param autoFlush

   */

  public PageContextImpl initialize(

       HttpServlet servlet,

       HttpServletRequest req,

       HttpServletResponse rsp,

       String errorPageURL,

       boolean needsSession,

       int bufferSize,

       boolean autoFlush,

       boolean isChild) {

    requestId=counter++;

    rsp.setContentType("text/html; charset=UTF-8");

    this.isChild=isChild;

   

        //rsp.setHeader("Connection", "close");

        applicationContext=defaultApplicationContext;

       

        startTime=System.currentTimeMillis();

        thread=Thread.currentThread();

       

        isCFCRequest = StringUtil.endsWithIgnoreCase(req.getServletPath(),"."+config.getCFCExtension());

       

        this.req=new HTTPServletRequestWrap(req);

        this.rsp=rsp;

        this.servlet=servlet;

         // Writers

        if(config.debugLogOutput()) {

          CFMLWriter w = config.getCFMLWriter(req,rsp);

          w.setAllowCompression(false);

          DebugCFMLWriter dcw = new DebugCFMLWriter(w);

          bodyContentStack.init(dcw);

          debugger.setOutputLog(dcw);

        }

        else {

          bodyContentStack.init(config.getCFMLWriter(req,rsp));

        }

       

   

        writer=bodyContentStack.getWriter();

        forceWriter=writer;

        

     // Scopes

         server=ScopeContext.getServerScope(this);

         if(hasFamily) {

           variablesRoot=new VariablesImpl();

           variables=variablesRoot;

           request=new RequestImpl();

           _url=new URLImpl();

           _form=new FormImpl();

           urlForm=new UrlFormImpl(_form,_url);

           undefined=

               new UndefinedImpl(this,config.getScopeCascadingType());

          

           hasFamily=false;

         }

         else if(variables==null) {

           variablesRoot=new VariablesImpl();

           variables=variablesRoot;

         }

         request.initialize(this);

        

     if(config.mergeFormAndURL()) {

       url=urlForm;

       form=urlForm;

     }

     else {

       url=_url;

       form=_form;

     }

         //url.initialize(this);

     //form.initialize(this);

     //undefined.initialize(this);

    

        

        psq=config.getPSQL();

   

    fdEnabled=!config.allowRequestTimeout();

   

    if(config.getExecutionLogEnabled())

      this.execLog=config.getExecutionLogFactory().getInstance(this);

    if(debugger!=null)

      debugger.init(config);

   

    undefined.initialize(this);

    return this;

   }

 

  @Override

  public void release() {

        if(config.getExecutionLogEnabled()){

          execLog.release();

      execLog=null;

        }

   

    if(config.debug()) {

        if(!gatewayContext && !isChild)

          config.getDebuggerPool().store(this, debugger);

        debugger.reset();

      }

    else ((DebuggerImpl)debugger).resetTraces(); // traces can alo be used when debugging is off

   

    this.serverPassword=null;

    parent=null;

    // Attention have to be before close

    if(client!=null){

          client.touchAfterRequest(this);

          client=null;

        }

    if(session!=null){

          session.touchAfterRequest(this);

          session=null;

        }

   

    // ORM

        if(ormSession!=null){

          // flush orm session

          try {

        ORMEngine engine=ormSession.getEngine();

            ORMConfiguration config=engine.getConfiguration(this);

            if(config==null || (config.flushAtRequestEnd() && config.autoManageSession())){

          ormSession.flush(this);

          //ormSession.close(this);

          //print.err("2orm flush:"+Thread.currentThread().getId());

        }

        ormSession.close(this);

      }

          catch (Throwable t) {

            //print.printST(t);

          }

          ormSession=null;

        }

       

   

    close();

        thread=null;

        base=null;

        //RequestImpl r = request;

       

        // Scopes

        if(hasFamily) {

          if(!isChild){

            req.disconnect();

          }