include/amino/future.h

Go to the documentation of this file.

/*
 * (c) Copyright 2008, IBM Corporation.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 *  Change History:
 *
 *  yy-mm-dd  Developer  Defect     Description
 *  --------  ---------  ------     -----------
 *  08-08-18  ganzhi     N/A        Initial version
 */
#ifndef AMINO_FUTURE_H
#define AMINO_FUTURE_H

#include <assert.h>

#include <amino/condition.h>
#include <amino/mutex.h>

#ifdef DEBUG
#include <sstream>
#include <iostream>
using namespace std;
#endif 

namespace amino{

    class Future{
        public:
            virtual void * get()=0;

            virtual bool get(int milli, void ** result=NULL)=0;

            virtual ~Future(){}
    };

    class AbstractFuture:public Future{
        private:
            condition_variable cond;

            recursive_mutex f_mutex;
            volatile bool isAvail;
        protected: 
            volatile void * f_result;

            virtual void fireEvent(){
                unique_lock<mutex> llock(f_mutex);
                setAvailable(true);
                cond.notify_all();
            }

            virtual void setAvailable(bool flag){
                unique_lock<mutex> llock(f_mutex);
                isAvail = flag;
            } 

            virtual bool getAvailable(){
                unique_lock<mutex> llock(f_mutex);
                return isAvail;
            }
        public:
            AbstractFuture(){
                isAvail = false;
            }

            virtual ~AbstractFuture(){
            }

            virtual void * get(){
                while(!getAvailable()){
                    unique_lock<mutex> llock(f_mutex);
                    if(!getAvailable()){
                        cond.wait(llock);
                    }
                    else
                        break;
                }
#ifdef DEBUG_FUTURE
                stringstream ss;
                ss <<"IsAvail in get(): "<<isAvail<<this<<endl;
                cout << ss.str(); 
#endif
                assert(isAvail);
                return (void *) f_result;
            }

            virtual bool get(int milli, void ** result=NULL){
                bool res=true;

                if(!isAvail){
                    unique_lock<mutex> llock(f_mutex);
                    res = cond.timed_wait(llock, milli);
                    if(res){
                        if(result!=NULL)
                            *result = (void *)f_result;
                    }
                    return res;
                }

                if(result!=NULL)
                    *result = (void *) f_result;

                return res;
            }
    };
};
#endif

---