org/objectweb/proactive/core/body/request/NonFunctionalRequestsProcessor.java

/* 
 * ################################################################
 * 
 * ProActive: The Java(TM) library for Parallel, Distributed, 
 *            Concurrent computing with Security and Mobility
 * 
 * Copyright (C) 1997-2007 INRIA/University of Nice-Sophia Antipolis
 * Contact: proactive@objectweb.org
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or any later version.
 *  
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
 * USA
 *  
 *  Initial developer(s):               The ProActive Team
 *                        http://www.inria.fr/oasis/ProActive/contacts.html
 *  Contributor(s): 
 * 
 * ################################################################
 */ 
package org.objectweb.proactive.core.body.request;

import java.io.Serializable;
import java.util.AbstractList;
import java.util.Vector;


public class NonFunctionalRequestsProcessor implements RequestProcessor, Serializable {

        
        private static final long serialVersionUID = 1L;
        private AbstractList<Request> nfRequestsQueue;
        private RequestFilter immediateNFResquestFilter;
    private RequestFilter priorityNFRequestFilter;
    private int immediateNFReqNumber, priorityNFReqNumber;
    
    
        public NonFunctionalRequestsProcessor() {
                nfRequestsQueue = new Vector<Request>();
                this.immediateNFResquestFilter = new ImmediateNFRequestFilter();
        this.priorityNFRequestFilter = new PriorityNFRequestFilter();
        immediateNFReqNumber = 0;
        priorityNFReqNumber = 0;
        }
        


        public synchronized void  addToNFRequestsQueue(Request request) {
                if(immediateNFResquestFilter.acceptRequest(request)) {
                        nfRequestsQueue.add(immediateNFReqNumber,request);
                        immediateNFReqNumber ++;
                } else if (priorityNFRequestFilter.acceptRequest(request)){
                        nfRequestsQueue.add(immediateNFReqNumber + priorityNFReqNumber, request);
                        priorityNFReqNumber ++;
                }
        }
        
        public synchronized Request getOldestPriorityNFRequest(boolean remove) {
                Request request;
                if(nfRequestsQueue.isEmpty()) {
                        return null;
                }else if (remove){                      
                        request = nfRequestsQueue.remove(0);
                        if(immediateNFReqNumber > 0){
                                immediateNFReqNumber --;
                        }else {
                                priorityNFReqNumber --;
                        }
                        return request;
                }else {
                        return nfRequestsQueue.get(0);
                }               
        }
        
        
        public synchronized Request getYoungestPriorityNFRequest(boolean remove) {
                Request request;
                
                if(nfRequestsQueue.isEmpty()) {
                        return null;
                }else if (remove){
                        if(immediateNFReqNumber != 0){
                                request = nfRequestsQueue.remove(immediateNFReqNumber);
                                immediateNFReqNumber --;
                                return request;
                        }else {
                                request = nfRequestsQueue.remove(priorityNFReqNumber);
                                priorityNFReqNumber --;
                                return request;
                        }
                }else {
                        if(immediateNFReqNumber != 0){
                                return nfRequestsQueue.get(immediateNFReqNumber);
                        }else {
                                return nfRequestsQueue.get(priorityNFReqNumber);
                        }
                }                       
        }
        
        
        public synchronized boolean isEmpty() {
                return (immediateNFReqNumber == 0 && priorityNFReqNumber == 0);
        }
        

        public synchronized String toString() {
                StringBuffer sb = new StringBuffer("NFRequests Queue : ");
                sb.append("--- NonFunctionalRequestQueue n=").append(nfRequestsQueue.size()).append("   requests --- ->\n");
                int count = 0;
                java.util.Iterator<Request> iterator = nfRequestsQueue.iterator();
                while (iterator.hasNext()) {
                        Request currentrequest = iterator.next();
                        sb.append(count).append("--> ")
                        .append(currentrequest.getMethodName()).append("\n");
                        count++;
                }
                sb.append("--- End NonFunctionalRequestQueue ---");
                return sb.toString();
        }
        
        public int processRequest(Request request) {
                if((request.getNFRequestPriority() == Request.NFREQUEST_IMMEDIATE_PRIORITY )|| (request.getNFRequestPriority() == Request.NFREQUEST_PRIORITY)){
                        nfRequestsQueue.add(request);
                }
                return RequestProcessor.KEEP;
        }
          
        // --------------- FILTERS -----------------//
        
        
    protected class ImmediateNFRequestFilter implements RequestFilter, Serializable {           
                private static final long serialVersionUID = 1L;

                public boolean acceptRequest(Request request) {
                return (request.isFunctionalRequest() 
                                && (request.getNFRequestPriority() == Request.NFREQUEST_IMMEDIATE_PRIORITY));
        } 
    }
    
    
    protected class PriorityNFRequestFilter implements RequestFilter, Serializable {            
                private static final long serialVersionUID = 1L;

                public boolean acceptRequest(Request request) {
                return (request.isFunctionalRequest() 
                                && (request.getNFRequestPriority() == Request.NFREQUEST_PRIORITY));
        } 
    }
    
    protected class NoPriorityNFRequestFilter implements RequestFilter, Serializable {          
                private static final long serialVersionUID = 1L;

                public boolean acceptRequest(Request request) {
                return (request.isFunctionalRequest() 
                                && (request.getNFRequestPriority() == Request.NFREQUEST_NO_PRIORITY));
        } 
        
    }   
 
//  --------------- END OF FILTERS -----------------//
    
    
  



    
    
}

---