Refine search
/** * Get the already parsed parts. * @return the parts that were parsed */ public Collection<Part> getParsedParts() { if (_parts == null) return Collections.emptyList(); Collection<List<Part>> values = _parts.values(); List<Part> parts = new ArrayList<>(); for (List<Part> o: values) { List<Part> asList = LazyList.getList(o, false); parts.addAll(asList); } return parts; }
/** * Retrieve a lazy list of map entries associated with specified * internet address by taking into account the wildcard specifications. * * @param addr internet address * @return lazy list of map entries */ public Object getLazyMatches(String addr) { if (addr == null) return LazyList.getList(super.entrySet()); Object entries = null; for(Map.Entry<String, TYPE> entry: super.entrySet()) { if (_patterns.get(entry.getKey()).match(addr)) { entries = LazyList.add(entries,entry); } } return entries; }
/** remove a parent child relationship * @param parent * @param child * @param relationship */ private void remove(Object parent, Object child, String relationship) { if (LOG.isDebugEnabled()) LOG.debug("Container "+parent+" - "+child+" as "+relationship); if (_listeners!=null) { Relationship event=new Relationship(this,parent,child,relationship); for (int i=0; i<LazyList.size(_listeners); i++) ((Listener)LazyList.get(_listeners, i)).remove(event); } }
public void doHandle(String target, Request baseRequest, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException final DispatcherType dispatch = baseRequest.getDispatcherType(); final boolean new_context = baseRequest.takeNewContext(); try final int s = LazyList.size(_requestAttributeListeners); for (int i = 0; i < s; i++) baseRequest.addEventListener(((EventListener)LazyList.get(_requestAttributeListeners,i))); final int s = LazyList.size(_requestListeners); final ServletRequestEvent sre = new ServletRequestEvent(_scontext,request); for (int i = 0; i < s; i++) ((ServletRequestListener)LazyList.get(_requestListeners,i)).requestInitialized(sre); if (DispatcherType.REQUEST.equals(dispatch) && isProtectedTarget(target)) throw new HttpException(HttpServletResponse.SC_NOT_FOUND); LOG.debug(e); baseRequest.setHandled(true); response.sendError(e.getStatus(),e.getReason()); for (int i = LazyList.size(_requestListeners); i-- > 0;) ((ServletRequestListener)LazyList.get(_requestListeners,i)).requestDestroyed(sre); for (int i = LazyList.size(_requestAttributeListeners); i-- > 0;) baseRequest.removeEventListener(((EventListener)LazyList.get(_requestAttributeListeners,i)));
final DispatcherType old_type = baseRequest.getDispatcherType(); final Attributes old_attr=baseRequest.getAttributes(); MultiMap old_params=baseRequest.getParameters(); try baseRequest.getConnection().include(); if (_named!=null) _contextHandler.handle(_named,baseRequest, (HttpServletRequest)request, (HttpServletResponse)response); else MultiMap parameters=new MultiMap(); UrlEncoded.decodeTo(query,parameters,baseRequest.getCharacterEncoding()); if (old_params!=null && old_params.size()>0) Iterator iter = old_params.entrySet().iterator(); while (iter.hasNext()) String name=(String)entry.getKey(); Object values=entry.getValue(); for (int i=0;i<LazyList.size(values);i++) parameters.add(name, LazyList.get(values, i)); attr._contextPath=_contextHandler.getContextPath(); baseRequest.setAttributes(attr); _contextHandler.handle(_path,baseRequest, (HttpServletRequest)request, (HttpServletResponse)response);
public void doFilter(ServletRequest request, ServletResponse response) throws IOException, ServletException if (LOG.isDebugEnabled()) LOG.debug("doFilter " + _filter); if (_filter < LazyList.size(_chain)) FilterHolder holder= (FilterHolder)LazyList.get(_chain, _filter++); if (LOG.isDebugEnabled()) LOG.debug("call filter " + holder); Filter filter= holder.getFilter(); if (holder.isAsyncSupported() || !_baseRequest.isAsyncSupported()) _baseRequest.setAsyncSupported(false); filter.doFilter(request, response, this); _baseRequest.setAsyncSupported(true); _servletHolder.handle(_baseRequest,request, response); else if (getHandler()==null) notFound(srequest, (HttpServletResponse)response); else nextHandle(URIUtil.addPaths(srequest.getServletPath(),srequest.getPathInfo()), baseRequest,srequest,(HttpServletResponse)response);
LOG.warn(_className+" cannot be loaded"); return; LOG.warn(clazz.getName()+" is not assignable from javax.servlet.http.HttpServlet"); return; LOG.warn(clazz.getName()+ " defines both @WebServlet.value and @WebServlet.urlPatterns"); return; ServletHolder[] holders = _context.getServletHandler().getServlets(); holder = _context.getServletHandler().newServletHolder(source); holder.setHeldClass(clazz); metaData.setOrigin(servletName+".servlet.servlet-class",annotation,clazz); _context.getServletHandler().addServlet(holder); mapping.setPathSpecs( LazyList.toStringArray(urlPatternList)); mapping.setPathSpecs(LazyList.toStringArray(urlPatternList));
LOG.warn(_className+" cannot be loaded"); return; LOG.warn(clazz.getName()+" is not assignable from javax.servlet.http.HttpServlet"); return; LOG.warn(clazz.getName()+ " defines both @WebServlet.value and @WebServlet.urlPatterns"); return; ServletHolder[] holders = _context.getServletHandler().getServlets(); boolean isNew = true; ServletHolder holder = null; holder = _context.getServletHandler().newServletHolder(Holder.Source.ANNOTATION); holder.setHeldClass(clazz); metaData.setOrigin(servletName+".servlet.servlet-class"); _context.getServletHandler().addServlet(holder); ServletMapping mapping = new ServletMapping(); mapping.setServletName(holder.getName()); mapping.setPathSpecs( LazyList.toStringArray(urlPatternList)); _context.getServletHandler().addServletMapping(mapping); metaData.setOrigin(servletName+".servlet.mappings"); m.setPathSpecs(LazyList.toStringArray(urlPatternList)); _context.getServletHandler().addServletMapping(m);
/** * @see javax.servlet.ServletRequest#getParameter(java.lang.String) */ @Override public String getParameter(String name) { Object o=_params.get(name); if (!(o instanceof byte[]) && LazyList.size(o)>0) o=LazyList.get(o,0); if (o instanceof byte[]) { try { return getParameterBytesAsString(name, (byte[])o); } catch(Exception e) { LOG.warn(e); } } else if (o!=null) return String.valueOf(o); return null; }
/** * Add a context event listeners. * * @see ServletContextListener * @see ServletContextAttributeListener * @see ServletRequestListener * @see ServletRequestAttributeListener */ public void addEventListener(EventListener listener) { //Only listeners added before the context starts last through a stop/start cycle if (!(isStarted() || isStarting())) _durableListeners = LazyList.add(_durableListeners, listener); setEventListeners((EventListener[])LazyList.addToArray(getEventListeners(),listener,EventListener.class)); }
protected FilterChain getFilterChain(Request baseRequest, String pathInContext, ServletHolder servletHolder) int dispatch = FilterMapping.dispatch(baseRequest.getDispatcherType()); filters= LazyList.add(filters, mapping.getFilterHolder()); if (servletHolder != null && _filterNameMappings!=null && _filterNameMappings.size() > 0) if (_filterNameMappings.size() > 0) Object o= _filterNameMappings.get(servletHolder.getName()); for (int i=0; i<LazyList.size(o);i++) FilterMapping mapping = (FilterMapping)LazyList.get(o,i); if (mapping.appliesTo(dispatch)) filters=LazyList.add(filters,mapping.getFilterHolder()); o= _filterNameMappings.get("*"); for (int i=0; i<LazyList.size(o);i++) FilterMapping mapping = (FilterMapping)LazyList.get(o,i); if (mapping.appliesTo(dispatch)) filters=LazyList.add(filters,mapping.getFilterHolder()); if (LazyList.size(filters) > 0) chain = newCachedChain(filters, servletHolder); else if (LazyList.size(filters) > 0) chain = new Chain(baseRequest,filters, servletHolder);
/** Convenience method to add a pre-constructed ServletMapping. * @param mapping */ public void addServletMapping (ServletMapping mapping) { setServletMappings((ServletMapping[])LazyList.addToArray(getServletMappings(), mapping, ServletMapping.class)); }
/**Convenience method to add a pre-constructed ServletHolder. * @param holder */ public void addServlet(ServletHolder holder) { setServlets((ServletHolder[])LazyList.addToArray(getServlets(), holder, ServletHolder.class)); }
protected CachedChain(Object filters, ServletHolder servletHolder) { if (LazyList.size(filters)>0) { _filterHolder=(FilterHolder)LazyList.get(filters, 0); filters=LazyList.remove(filters,0); _next=newCachedChain(filters,servletHolder); } else _servletHolder=servletHolder; }
@Override public synchronized void removeAttribute(String name) { checkManagedAttribute(name,null); if (_contextAttributes == null) { // Set it on the handler _attributes.removeAttribute(name); return; } Object old_value = _contextAttributes.getAttribute(name); _contextAttributes.removeAttribute(name); if (old_value != null) { if (_contextAttributeListeners != null) { ServletContextAttributeEvent event = new ServletContextAttributeEvent(_scontext,name,old_value); for (int i = 0; i < LazyList.size(_contextAttributeListeners); i++) ((ServletContextAttributeListener)LazyList.get(_contextAttributeListeners,i)).attributeRemoved(event); } } }
/** Convenience method to add a preconstructed FilterHolder * @param filter */ public void addFilter (FilterHolder filter) { if (filter != null) setFilters((FilterHolder[])LazyList.addToArray(getFilters(), filter, FilterHolder.class)); }
/** * @see javax.servlet.ServletRequest#getParameterMap() */ @Override public Map<String, String[]> getParameterMap() { Map<String, String[]> cmap = new HashMap<String,String[]>(); for ( Object key : _params.keySet() ) { String[] a = LazyList.toStringArray(getParameter((String)key)); cmap.put((String)key,a); } return Collections.unmodifiableMap(cmap); }
protected Object expandHandler(Handler handler, Object list, Class<Handler> byClass) { if (handler==null) return list; if (byClass==null || byClass.isAssignableFrom(handler.getClass())) list=LazyList.add(list, handler); if (handler instanceof AbstractHandlerContainer) list=((AbstractHandlerContainer)handler).expandChildren(list, byClass); else if (handler instanceof HandlerContainer) { HandlerContainer container = (HandlerContainer)handler; Handler[] handlers=byClass==null?container.getChildHandlers():container.getChildHandlersByClass(byClass); list=LazyList.addArray(list, handlers); } return list; }