k2hash 1.1.33 → 2.0.0

package/src/k2h_cbs.cc

@@ -22,7 +22,6 @@
 #include <fullock/flckbaselist.tcc>
 #include "k2h_cbs.h"
 
-using namespace v8;
 using namespace std;
 using namespace fullock;
 
@@ -40,68 +39,55 @@ StackEmitCB::~StackEmitCB()
 	flck_unlock_noshared_mutex(&lockval);			// UNLOCK
 }
 
-// [NOTE]
-// This method does not lock, thus must lock before calling this.
-//
-Nan::Callback* StackEmitCB::RawFind(const char* pemitname)
+bool StackEmitCB::Set(const std::string& emitter, const Napi::Function& cb)
 {
-	string			stremit	= pemitname ? pemitname : "";
-	Nan::Callback*	cbfunc	= NULL;
-	if(stremit.empty()){
-		return cbfunc;
-	}
-	if(EmitCbsMap.end() != EmitCbsMap.find(stremit)){
-		cbfunc = EmitCbsMap[stremit];
+	while(!flck_trylock_noshared_mutex(&lockval));	// LOCK
+
+	// clear if existed
+	auto it = EmitCbsMap.find(emitter);
+	if(EmitCbsMap.end() != it){
+		it->second.Reset();
+		EmitCbsMap.erase(it);
 	}
-	return cbfunc;
-}
 
-Nan::Callback* StackEmitCB::Find(const char* pemitname)
-{
-	while(!flck_trylock_noshared_mutex(&lockval));	// LOCK
-	Nan::Callback*	cbfunc = RawFind(pemitname);
+	// Insert new persistent reference
+	Napi::FunctionReference ref = Napi::Persistent(cb);
+	EmitCbsMap.emplace(emitter, std::move(ref));
+
 	flck_unlock_noshared_mutex(&lockval);			// UNLOCK
 
-	return cbfunc;
+	return true;
 }
 
-bool StackEmitCB::Set(const char* pemitname, Nan::Callback* cbfunc)
+bool StackEmitCB::Unset(const std::string& emitter)
 {
-	string	stremit = pemitname ? pemitname : "";
-	if(stremit.empty()){
-		return false;
-	}
-
 	while(!flck_trylock_noshared_mutex(&lockval));	// LOCK
 
-	const Nan::Callback*	oldcbfunc = RawFind(pemitname);
-	if(oldcbfunc){
-		EmitCbsMap.erase(stremit);
-	}
-	if(cbfunc){
-		EmitCbsMap[stremit] = cbfunc;
+	auto it = EmitCbsMap.find(emitter);
+	if(EmitCbsMap.end() == it){
+		flck_unlock_noshared_mutex(&lockval);		// UNLOCK
+		return false;
 	}
+	it->second.Reset();
+	EmitCbsMap.erase(it);
+
 	flck_unlock_noshared_mutex(&lockval);			// UNLOCK
 
 	return true;
 }
 
-bool StackEmitCB::Unset(const char* pemitname)
+Napi::FunctionReference* StackEmitCB::Find(const std::string& emitter)
 {
-	string	stremit = pemitname ? pemitname : "";
-	if(stremit.empty()){
-		return false;
-	}
-
 	while(!flck_trylock_noshared_mutex(&lockval));	// LOCK
 
-	const Nan::Callback*	oldcbfunc = RawFind(pemitname);
-	if(oldcbfunc){
-		EmitCbsMap.erase(stremit);
+	auto it = EmitCbsMap.find(emitter);
+	if(EmitCbsMap.end() == it){
+		flck_unlock_noshared_mutex(&lockval);		// UNLOCK
+		return nullptr;
 	}
 	flck_unlock_noshared_mutex(&lockval);			// UNLOCK
 
-	return true;
+	return &it->second;
 }
 
 /*

package/src/k2h_cbs.h

@@ -21,32 +21,36 @@
 #ifndef K2H_CBS_H
 #define K2H_CBS_H
 
+#include <string>
+#include <unordered_map>
 #include "k2h_common.h"
 
 //---------------------------------------------------------
 // Typedefs
 //---------------------------------------------------------
-typedef std::map<std::string, Nan::Callback*>	cbsmap;
+typedef std::unordered_map<std::string, Napi::FunctionReference>	cbsmap;
 
 //---------------------------------------------------------
 // StackEmitCB Class
 //---------------------------------------------------------
 class StackEmitCB
 {
-	protected:
-		cbsmap			EmitCbsMap;
-		volatile int	lockval;				// lock variable for mapping
-
-	protected:
-		Nan::Callback* RawFind(const char* pemitname);
-
 	public:
 		StackEmitCB();
 		virtual ~StackEmitCB();
 
-		Nan::Callback* Find(const char* pemitname);
-		bool Set(const char* pemitname, Nan::Callback* cbfunc);
-		bool Unset(const char* pemitname);
+		// Set returns true if set succeeded
+		bool Set(const std::string& emitter, const Napi::Function& cb);
+
+		// Unset returns true if removed
+		bool Unset(const std::string& emitter);
+
+		// Find returns pointer to FunctionReference if set, otherwise nullptr
+		Napi::FunctionReference* Find(const std::string& emitter);
+
+	private:
+		cbsmap			EmitCbsMap;
+		volatile int	lockval;				// lock variable for mapping
 };
 
 //---------------------------------------------------------
@@ -55,14 +59,14 @@ class StackEmitCB
 inline const char* GetNormalizationEmitter(const char* emitter, const char*	emitters[])
 {
 	if(!emitter){
-		return NULL;
+		return nullptr;
 	}
 	for(const char** ptmp = &emitters[0]; ptmp && *ptmp; ++ptmp){
 		if(0 == strcasecmp(*ptmp, emitter)){
 			return *ptmp;
 		}
 	}
-	return NULL;
+	return nullptr;
 }
 
 #endif

package/src/k2h_common.h

@@ -31,7 +31,7 @@
 #include <k2hash/k2hqueue.h>
 #include <k2hash/k2hutil.h>
 
-#include <nan.h>
+#include <napi.h>
 #include <string>
 #include <iostream>
 #include <map>