liboh/plugins/js/JSObjectStructs/JSTimerStruct.hpp

Go to the documentation of this file.

#ifndef __SIRIKATA_JS_TIMER_STRUCT_HPP__
#define __SIRIKATA_JS_TIMER_STRUCT_HPP__

#include "../JSUtil.hpp"
#include "../EmersonScript.hpp"
#include "JSContextStruct.hpp"
#include <v8.h>
#include <sirikata/core/network/IOTimer.hpp>
#include "JSSuspendable.hpp"
#include <sirikata/core/util/Liveness.hpp>
#include "../JSCtx.hpp"

namespace Sirikata {

class Context;

namespace JS {

struct JSTimerStruct : public JSSuspendable,
                       public Liveness
{
    JSTimerStruct(EmersonScript* eobj, Duration dur, v8::Persistent<v8::Function>& callback,
        JSContextStruct* jscont, uint32 contID,
        double timeRemaining, bool isSuspended, bool isCleared, JSCtx* mCtx);
    ~JSTimerStruct();

    static JSTimerStruct* decodeTimerStruct(v8::Handle<v8::Value> toDecode,String& errorMessage);


    v8::Handle<v8::Value> struct_resetTimer(double timeInSecondsToRefire);
private:
    void evaluateCallback(Liveness::Token isAlive);

public:
    virtual v8::Handle<v8::Value>suspend();
    virtual v8::Handle<v8::Value>resume();
    virtual v8::Handle<v8::Value>clear();

    v8::Handle<v8::Value> struct_getAllData();

    EmersonScript* emerScript;
    v8::Persistent<v8::Function> cb;
    JSContextStruct* jsContStruct;
    // Liveness mLiveness;
    
private:
    JSCtx* mCtx;

    Sirikata::Network::IOTimerPtr mDeadlineTimer;
public:

    Duration timeUntil; //first time create timer will fire after timeUntil seconds
    double mTimeRemaining; //when restoring a timer, will fire in this many more
                           //seconds.


    virtual void fixSuspendableToContext(JSContextStruct* toAttachTo);


    static void timerWeakReferenceCleanup(
        v8::Persistent<v8::Value> containsTimer, void* otherArg);

    void noReference(const Liveness::Token &token);

    void setPersistentObject(v8::Persistent<v8::Object>);

private:

    bool amExecuting;
    
    bool killAfterFire;

    bool noTimerWaiting;


    v8::Persistent<v8::Object> mPersistentHandle;

    void iEvaluateCallback(Liveness::Token token);
    
};

struct JSTimerLivenessHolder
{
    JSTimerLivenessHolder(JSTimerStruct* jst)
     : lt (jst->livenessToken())
    {}

    Liveness::Token lt;
};


#define INLINE_TIMER_CONV_ERROR(toConvert,whereError,whichArg,whereWriteTo)   \
    JSTimerStruct* whereWriteTo;                                                   \
    {                                                                      \
        String _errMsg = "In " #whereError "cannot convert " #whichArg " to timer struct";     \
        whereWriteTo = JSTimerStruct::decodeTimerStruct(toConvert,_errMsg); \
        if (whereWriteTo == NULL) \
            return v8::ThrowException(v8::Exception::Error(v8::String::New(_errMsg.c_str(), _errMsg.length()))); \
    }

typedef std::map<JSTimerStruct*,int>  TimerMap;
typedef TimerMap::iterator TimerIter;

}  //end js namespace
}  //end sirikata namespace

#endif