style(module): clean up some stylistic issues

Author: mbroadst

src/domain.h

@@ -491,7 +491,7 @@ class Domain : public NLVObject<Domain, virDomainPtr, DomainCleanupHandler>
     unsigned long bandwidth_;
     unsigned int flags_;
   };
-  
+
   class BlockCommitWorker : public NLVPrimitiveReturnWorker<virDomainPtr, bool> {
   public:
     BlockCommitWorker(Nan::Callback *callback, virDomainPtr handle, std::function<virErrorPtr(virDomainPtr)> func)

src/nlv_object.h

@@ -46,7 +46,7 @@ class NLVObjectBasePtr
     return NLV_STRINGIFY(class_name); \
   } \
   friend class NLVObject;
-  
+
 
 class NLVObjectBase : public Nan::ObjectWrap
 {
@@ -61,7 +61,7 @@ class NLVObject : public NLVObjectBase
 {
 public:
   typedef HandleType handle_type;
-  
+
   NLVObject(HandleType handle) : handle_(handle), parentReference_(NULL) {}
   ~NLVObject() {
     // calling virtual ClearHandle() will break if overridden by subclasses
@@ -79,7 +79,7 @@ class NLVObject : public NLVObjectBase
     class_instance->Wrap(object);
     return scope.Escape(object);
   }
-  
+
   static bool IsInstanceOf(v8::Local<v8::Object> val) {
     Nan::HandleScope scope;
     return Nan::New(ParentClass::constructor_template)->HasInstance(val);
@@ -112,7 +112,7 @@ class NLVObject : public NLVObjectBase
   NAN_INLINE static HandleType UnwrapHandle(v8::Local<v8::Value> val) {
     return Unwrap(val)->handle();
   }
-  
+
   template<class T>
   NAN_INLINE static HandleType UnwrapHandle(v8::Local<v8::Object> val) {
     return Unwrap(val)->handle();
@@ -171,7 +171,7 @@ NAN_INLINE unsigned int GetFlags(v8::Local<v8::Value> val) {
     Nan::ThrowTypeError("flags must be an array");
     return 0;
   }
-  
+
   Local<Array> flags_ = Local<Array>::Cast(val);
   unsigned int flags = 0;
   for (unsigned int i = 0; i < flags_->Length(); i++)

src/storage_pool.cc

@@ -108,12 +108,13 @@ NAN_METHOD(StoragePool::LookupByVolume)
 {
   Nan::HandleScope scope;
   auto volume = StorageVolume::UnwrapHandle(info[0]);
-  
+
   Worker::RunAsync(info, [=](Worker::SetOnFinishedHandler onFinished) {
     auto storagePool = virStoragePoolLookupByVolume(volume);
-    if(!storagePool) {
+    if (!storagePool) {
       return virSaveLastError();
     }
+
     return onFinished(InstanceReturnHandler<Hypervisor, StoragePool>(storagePool));
   });
 }

src/worker.cc

@@ -4,20 +4,23 @@ using namespace NLV;
 
 void Worker::RunAsync(const Nan::FunctionCallbackInfo<v8::Value>& info, ExecuteHandler handler) {
   Nan::TryCatch tryCatch;
-  if(tryCatch.HasCaught()) {
+  if (tryCatch.HasCaught()) {
     tryCatch.ReThrow();
     return; // don't proceed in case there were any previous errors
   }
+
   auto v8_callback = info[info.Length()-1];
-  if(!v8_callback->IsFunction()) {
+  if (!v8_callback->IsFunction()) {
     Nan::ThrowTypeError("you must specify a function as the callback and it must the last argument");;
     return;
   }
+
   Nan::Callback *callback = new Nan::Callback(v8_callback.As<Function>());
   auto worker = new NLV::Worker(callback, handler);
   auto parent = info.This();
   if (!parent->IsUndefined() && !parent->IsNull()) {
     worker->SaveToPersistent("parent", parent);
   }
+
   Nan::AsyncQueueWorker(worker);
 }

src/worker.h

@@ -3,29 +3,28 @@
 #include "nlv_async_worker.h"
 
 namespace NLV {
-  class Worker : public NLVAsyncWorkerBase {
+  class Worker : public NLVAsyncWorkerBase
+  {
   public:
     typedef std::function<void(Worker*)>  OnFinishedHandler;
-    
     typedef std::function<virErrorPtr(OnFinishedHandler)> SetOnFinishedHandler;
-    
     typedef std::function<virErrorPtr(SetOnFinishedHandler)> ExecuteHandler;
-    
+
     ExecuteHandler execute_handler;
     OnFinishedHandler on_finished_handler;
-    
+
     explicit Worker(Nan::Callback *callback, ExecuteHandler handler)
       : NLVAsyncWorkerBase(callback), execute_handler(handler) { };
-    
+
     void HandleOKCallback() {
       on_finished_handler(this);
     }
-    
+
     template <class... T>
     void Call(T... t) {
       callback->Call(t...);
     }
-    
+
     virtual void Execute() {
       auto error = execute_handler([=] (OnFinishedHandler handler) {
         on_finished_handler = handler;
@@ -35,10 +34,10 @@ namespace NLV {
         SetVirError(error);
       }
     }
-          
+
     static void RunAsync(const Nan::FunctionCallbackInfo<v8::Value>& info, ExecuteHandler handler);
   };
-  
+
   template<class T>
   Worker::OnFinishedHandler PrimitiveReturnHandler(T val) {
     return [=](Worker* worker) {
@@ -47,29 +46,33 @@ namespace NLV {
       worker->Call(2, argv);
     };
   }
+
   template<class ParentClass, class T, class Y>
   Worker::OnFinishedHandler InstanceReturnHandler(Y val) {
     return [=](Worker* worker) {
       Nan::HandleScope scope;
+      Nan::TryCatch try_catch;
+
       Local<Object> childObject = T::NewInstance(val);
       Local<Value> parentObject = worker->GetFromPersistent("parent");
       if (parentObject->IsObject()) {
         childObject->Set(Nan::New("_parent").ToLocalChecked(), parentObject);
       }
+
       T *child = Nan::ObjectWrap::Unwrap<T>(childObject);
       NLVObjectBasePtr *childPtr = new NLVObjectBasePtr(child);
       child->SetParentReference(childPtr);
       auto parent = ParentClass::Unwrap(parentObject);
-      if(parent) {
+      if (parent) {
         parent->children_.push_back(childPtr);
       }
-      Nan::TryCatch try_catch;
-      if(try_catch.HasCaught()) {
+
+      if (try_catch.HasCaught()) {
         v8::Local<v8::Value> argv[] = { try_catch.Exception() };
         worker->Call(1, argv);
         return;
       }
-      
+
       v8::Local<v8::Value> argv[] = { Nan::Null(), childObject };
       worker->Call(2, argv);
     };