ella.h

Jump To … +

ella.h ella_jni_value.h ella_jvm.h ella_objects.cpp ella_objects.h ella_types.h ella_utils.h

ella.h

js_vm.h nanProject

#ifndef js_vm_h
#define js_vm_h



#include "nan.h"

#include "jvm_handler.h"
#include "jvm_object.h"
#include "classpath.h"


#include "ella_utils.h"
#include "ella_jvm.h"
#include "ella_objects.h"
#include "ella_types.h"


#include <map>
#include <regex>


namespace ella {
    JVMLoader vm;
    std::map< int, std::shared_ptr<Object> > objectsMap;
    
    
    using V8Args = const Nan::FunctionCallbackInfo<v8::Value>;

here we extract the functions body, arguments and callback and proceed to call the JVM.

    void MakeCallToJNI(V8Args& args) {
        
        try {
            FunctionHandler fnHandler( args );

functions dedicated to transform from v8 -> LibJNI::BaseJavaValue in ella_functions.

            fnHandler.SetArguments(args, {GetString, GetNumber});
            fnHandler.DetectAndGetCallback(args, GetFunctionCallback);

supported class are declared in ella_functions.

            InvocationList<BaseCall> supportedInvocations;
            
            supportedInvocations.Create<StringCall>();
            supportedInvocations.Create<IntCall>();
            supportedInvocations.Create<DoubleCall>();
            supportedInvocations.Create<VoidCall>();
            supportedInvocations.Create<ByteArrayCall>();
            
            
            
            auto jniWorker =  new JNIWorker<InvocationList<BaseCall>>(supportedInvocations,
                                                                      fnHandler,
                                                                      objectsMap[fnHandler.HashCode()]);
            
            if(!jniWorker->isAsync())
                args.GetReturnValue().Set( jniWorker->call().Get() );
            else
                Nan::AsyncQueueWorker(jniWorker);
            
            
        }catch(VMError& error) {
            Nan::ThrowTypeError( error.errorMessage.c_str() );
        }
    }

Class loader, instanciation and cache in dictionary using the hashcode as key.

    void ClassLoader(V8Args& args) {
        
        try{
            
            auto classname = Utils::GetClassName(args[0]);
            
            std::shared_ptr<Object> clazz(new Object(vm, classname));
            
            auto methods  = clazz->GetMembers();
            auto hashcode = clazz->Call<IntValue>("hashCode").Get();
            
            auto jsObject = Utils::CreateJSObject<decltype(methods), decltype(MakeCallToJNI)>(methods,hashcode, MakeCallToJNI);
            
            objectsMap[hashcode] = clazz;
            
            args.GetReturnValue().Set(jsObject);
            
        }catch(VMError& error){
            Nan::ThrowTypeError( error.errorMessage.c_str() );
        }
    }

¶

Start (callback)
¶
¶

Start a new JVM instance.

callback: a function where to callback when instance has finish startup.

    
    void Start(V8Args& args ){
        
        if (!args[0]->IsFunction())
            Nan::ThrowTypeError("Callback required.");
        
        auto *jscallBack = new Nan::Callback(args[0].As<v8::Function>());
        
        auto vmInitWorker = new ella::JVM<decltype(ClassLoader)> (jscallBack, vm, ClassLoader);
        
        Nan::AsyncQueueWorker(vmInitWorker);
    }

¶

SetClassPath (Array, isRecursive)
¶

Array -> a list of paths where to find your [ .jars .class ]. isRecursive -> true look recursively, false it wont.

    
    
    void SetClassPath(V8Args& args ){
        
        try{
            std::vector<std::string> dirs;
            bool recursive = false;
            
            if( args[0]->IsArray() ){
                auto list = Nan::New<v8::Array>()->Cast(*args[0]);
                dirs = ella::Utils::IterCollection< decltype(list), std::string>(list, ella::Utils::ObjectToString);
            }
            
            if( args[1]->IsBoolean() )
                recursive = args[1]->ToBoolean()->Value();
            
            vm.SetClassPath( ClassPath::LocateLibraries(dirs, recursive) );
            
        }catch(VMError& error){
            Nan::ThrowTypeError( error.errorMessage.c_str() );
        }
        
    }
    
   
    void GetClassPath(V8Args& args ){
        args.GetReturnValue().Set( Nan::New(vm.GetClassPath()).ToLocalChecked() );
    }
    
}




#endif /* js_vm_h */

ella.h

Start (callback)

SetClassPath (Array, isRecursive)