namespace all macros with LD_

src/async.cc

@@ -36,7 +36,7 @@ void AsyncWorker::WorkComplete () {
 
 void AsyncWorker::HandleOKCallback () {
   v8::Local<v8::Value> argv[0];
-  RUN_CALLBACK(callback, argv, 0);  
+  LD_RUN_CALLBACK(callback, argv, 0);  
 }
 
 void AsyncWorker::HandleErrorCallback () {
@@ -45,7 +45,7 @@ void AsyncWorker::HandleErrorCallback () {
         v8::Exception::Error(v8::String::New(status.ToString().c_str()))
       )
   };
-  RUN_CALLBACK(callback, argv, 1);
+  LD_RUN_CALLBACK(callback, argv, 1);
 }
 
 void AsyncExecute (uv_work_t* req) {

src/async.h

@@ -3,8 +3,8 @@
  * MIT +no-false-attribs License <https://github.com/rvagg/node-leveldown/blob/master/LICENSE>
  */
 
-#ifndef LU_ASYNC_H
-#define LU_ASYNC_H
+#ifndef LD_ASYNC_H
+#define LD_ASYNC_H
 
 #include <node.h>
 

src/batch.h

@@ -3,8 +3,8 @@
  * MIT +no-false-attribs License <https://github.com/rvagg/node-leveldown/blob/master/LICENSE>
  */
 
-#ifndef LU_BATCH_H
-#define LU_BATCH_H
+#ifndef LD_BATCH_H
+#define LD_BATCH_H
 
 #include "leveldb/write_batch.h"
 

src/database.cc

@@ -143,14 +143,14 @@ v8::Handle<v8::Value> Database::New (const v8::Arguments& args) {
   v8::HandleScope scope;
 
   if (args.Length() == 0) {
-    THROW_RETURN("leveldown() requires at least a location argument")
+    LD_THROW_RETURN("leveldown() requires at least a location argument")
   }
 
   if (!args[0]->IsString()) {
-    THROW_RETURN("leveldown() requires a location string argument")
+    LD_THROW_RETURN("leveldown() requires a location string argument")
   }
 
-  FROM_V8_STRING(location, v8::Handle<v8::String>::Cast(args[0]))
+  LD_FROM_V8_STRING(location, v8::Handle<v8::String>::Cast(args[0]))
 
   Database* obj = new Database(location);
   obj->Wrap(args.This());
@@ -177,12 +177,12 @@ v8::Handle<v8::Value> Database::NewInstance (const v8::Arguments& args) {
 v8::Handle<v8::Value> Database::Open (const v8::Arguments& args) {
   v8::HandleScope scope;
 
-  METHOD_SETUP_COMMON(open, 0, 1)
+  LD_METHOD_SETUP_COMMON(open, 0, 1)
 
-  BOOLEAN_OPTION_VALUE_DEFTRUE(optionsObj, createIfMissing)
-  BOOLEAN_OPTION_VALUE(optionsObj, errorIfExists)
-  BOOLEAN_OPTION_VALUE(optionsObj, compression)
-  UINT32_OPTION_VALUE(optionsObj, cacheSize, 8 << 20)
+  LD_BOOLEAN_OPTION_VALUE_DEFTRUE(optionsObj, createIfMissing)
+  LD_BOOLEAN_OPTION_VALUE(optionsObj, errorIfExists)
+  LD_BOOLEAN_OPTION_VALUE(optionsObj, compression)
+  LD_UINT32_OPTION_VALUE(optionsObj, cacheSize, 8 << 20)
 
   OpenWorker* worker = new OpenWorker(
       database
@@ -201,7 +201,7 @@ v8::Handle<v8::Value> Database::Open (const v8::Arguments& args) {
 v8::Handle<v8::Value> Database::Close (const v8::Arguments& args) {
   v8::HandleScope scope;
 
-  METHOD_SETUP_COMMON_ONEARG(close)
+  LD_METHOD_SETUP_COMMON_ONEARG(close)
 
   CloseWorker* worker = new CloseWorker(database, callback);
   AsyncQueueWorker(worker);
@@ -212,22 +212,22 @@ v8::Handle<v8::Value> Database::Close (const v8::Arguments& args) {
 v8::Handle<v8::Value> Database::Put (const v8::Arguments& args) {
   v8::HandleScope scope;
 
-  METHOD_SETUP_COMMON(put, 2, 3)
+  LD_METHOD_SETUP_COMMON(put, 2, 3)
 
-  CB_ERR_IF_NULL_OR_UNDEFINED(0, Key)
-  CB_ERR_IF_NULL_OR_UNDEFINED(1, Value)
+  LD_CB_ERR_IF_NULL_OR_UNDEFINED(0, Key)
+  LD_CB_ERR_IF_NULL_OR_UNDEFINED(1, Value)
 
   v8::Local<v8::Value> keyBufferV = args[0];
   v8::Local<v8::Value> valueBufferV = args[1];
-  STRING_OR_BUFFER_TO_SLICE(key, keyBufferV, Key)
-  STRING_OR_BUFFER_TO_SLICE(value, valueBufferV, Value)
+  LD_STRING_OR_BUFFER_TO_SLICE(key, keyBufferV, Key)
+  LD_STRING_OR_BUFFER_TO_SLICE(value, valueBufferV, Value)
 
   v8::Persistent<v8::Value> keyBuffer =
       v8::Persistent<v8::Value>::New(keyBufferV);
   v8::Persistent<v8::Value> valueBuffer =
       v8::Persistent<v8::Value>::New(valueBufferV);
 
-  BOOLEAN_OPTION_VALUE(optionsObj, sync)
+  LD_BOOLEAN_OPTION_VALUE(optionsObj, sync)
 
   WriteWorker* worker  = new WriteWorker(
       database
@@ -246,17 +246,17 @@ v8::Handle<v8::Value> Database::Put (const v8::Arguments& args) {
 v8::Handle<v8::Value> Database::Get (const v8::Arguments& args) {
   v8::HandleScope scope;
 
-  METHOD_SETUP_COMMON(put, 1, 2)
+  LD_METHOD_SETUP_COMMON(put, 1, 2)
 
-  CB_ERR_IF_NULL_OR_UNDEFINED(0, Key)
+  LD_CB_ERR_IF_NULL_OR_UNDEFINED(0, Key)
 
   v8::Local<v8::Value> keyBufferV = args[0];
-  STRING_OR_BUFFER_TO_SLICE(key, keyBufferV, Key)
+  LD_STRING_OR_BUFFER_TO_SLICE(key, keyBufferV, Key)
 
   v8::Persistent<v8::Value> keyBuffer = v8::Persistent<v8::Value>::New(keyBufferV);
 
-  BOOLEAN_OPTION_VALUE_DEFTRUE(optionsObj, asBuffer)
-  BOOLEAN_OPTION_VALUE_DEFTRUE(optionsObj, fillCache)
+  LD_BOOLEAN_OPTION_VALUE_DEFTRUE(optionsObj, asBuffer)
+  LD_BOOLEAN_OPTION_VALUE_DEFTRUE(optionsObj, fillCache)
 
   ReadWorker* worker = new ReadWorker(
       database
@@ -274,17 +274,17 @@ v8::Handle<v8::Value> Database::Get (const v8::Arguments& args) {
 v8::Handle<v8::Value> Database::Delete (const v8::Arguments& args) {
   v8::HandleScope scope;
 
-  METHOD_SETUP_COMMON(put, 1, 2)
+  LD_METHOD_SETUP_COMMON(put, 1, 2)
 
-  CB_ERR_IF_NULL_OR_UNDEFINED(0, Key)
+  LD_CB_ERR_IF_NULL_OR_UNDEFINED(0, Key)
 
   v8::Local<v8::Value> keyBufferV = args[0];
-  STRING_OR_BUFFER_TO_SLICE(key, keyBufferV, Key)
+  LD_STRING_OR_BUFFER_TO_SLICE(key, keyBufferV, Key)
 
   v8::Persistent<v8::Value> keyBuffer =
       v8::Persistent<v8::Value>::New(keyBufferV);
 
-  BOOLEAN_OPTION_VALUE(optionsObj, sync)
+  LD_BOOLEAN_OPTION_VALUE(optionsObj, sync)
 
   DeleteWorker* worker = new DeleteWorker(
       database
@@ -299,18 +299,18 @@ v8::Handle<v8::Value> Database::Delete (const v8::Arguments& args) {
 }
 
 /* property key & value strings for elements of the array sent to batch() */
-LU_SYMBOL ( str_key   , key   );
-LU_SYMBOL ( str_value , value );
-LU_SYMBOL ( str_type  , type  );
-LU_SYMBOL ( str_del   , del   );
-LU_SYMBOL ( str_put   , put   );
+LD_SYMBOL ( str_key   , key   );
+LD_SYMBOL ( str_value , value );
+LD_SYMBOL ( str_type  , type  );
+LD_SYMBOL ( str_del   , del   );
+LD_SYMBOL ( str_put   , put   );
 
 v8::Handle<v8::Value> Database::Batch (const v8::Arguments& args) {
   v8::HandleScope scope;
 
-  METHOD_SETUP_COMMON(batch, 1, 2)
+  LD_METHOD_SETUP_COMMON(batch, 1, 2)
 
-  BOOLEAN_OPTION_VALUE(optionsObj, sync)
+  LD_BOOLEAN_OPTION_VALUE(optionsObj, sync)
 
   v8::Local<v8::Array> array = v8::Local<v8::Array>::Cast(args[0]);
 
@@ -326,7 +326,7 @@ v8::Handle<v8::Value> Database::Batch (const v8::Arguments& args) {
     v8::Local<v8::Value> keyBuffer = obj->Get(str_key);
 
     if (obj->Get(str_type)->StrictEquals(str_del)) {
-      STRING_OR_BUFFER_TO_SLICE(key, keyBuffer, Key)
+      LD_STRING_OR_BUFFER_TO_SLICE(key, keyBuffer, Key)
 
       operations->push_back(new BatchDelete(
           key
@@ -335,8 +335,8 @@ v8::Handle<v8::Value> Database::Batch (const v8::Arguments& args) {
     } else if (obj->Get(str_type)->StrictEquals(str_put) && obj->Has(str_value)) {
       v8::Local<v8::Value> valueBuffer = obj->Get(str_value);
 
-      STRING_OR_BUFFER_TO_SLICE(key, keyBuffer, Key)
-      STRING_OR_BUFFER_TO_SLICE(value, valueBuffer, Value)
+      LD_STRING_OR_BUFFER_TO_SLICE(key, keyBuffer, Key)
+      LD_STRING_OR_BUFFER_TO_SLICE(value, valueBuffer, Value)
 
       operations->push_back(new BatchWrite(
           key
@@ -370,18 +370,18 @@ v8::Handle<v8::Value> Database::ApproximateSize (const v8::Arguments& args) {
       || endBufferV->IsUndefined()
       || endBufferV->IsFunction() // callback in pos 1?
       ) {
-    THROW_RETURN( \
+    LD_THROW_RETURN( \
       "approximateSize() requires valid `start`, `end` and `callback` arguments" \
     )
   }
 
-  METHOD_SETUP_COMMON(approximateSize, -1, 2)
+  LD_METHOD_SETUP_COMMON(approximateSize, -1, 2)
 
-  CB_ERR_IF_NULL_OR_UNDEFINED(0, Start)
-  CB_ERR_IF_NULL_OR_UNDEFINED(1, End)
+  LD_CB_ERR_IF_NULL_OR_UNDEFINED(0, Start)
+  LD_CB_ERR_IF_NULL_OR_UNDEFINED(1, End)
 
-  STRING_OR_BUFFER_TO_SLICE(start, startBufferV, Start)
-  STRING_OR_BUFFER_TO_SLICE(end, endBufferV, End)
+  LD_STRING_OR_BUFFER_TO_SLICE(start, startBufferV, Start)
+  LD_STRING_OR_BUFFER_TO_SLICE(end, endBufferV, End)
 
   v8::Persistent<v8::Value> startBuffer =
       v8::Persistent<v8::Value>::New(startBufferV);

src/database.h

@@ -3,8 +3,8 @@
  * MIT +no-false-attribs License <https://github.com/rvagg/node-leveldown/blob/master/LICENSE>
  */
 
-#ifndef LU_DATABASE_H
-#define LU_DATABASE_H
+#ifndef LD_DATABASE_H
+#define LD_DATABASE_H
 
 #include <node.h>
 
@@ -14,13 +14,13 @@
 
 namespace leveldown {
 
-LU_SYMBOL ( option_createIfMissing , createIfMissing ); // for open()
-LU_SYMBOL ( option_errorIfExists   , errorIfExists   ); // for open()
-LU_SYMBOL ( option_compression     , compression     ); // for open()
-LU_SYMBOL ( option_cacheSize       , cacheSize       ); // for open() 
-LU_SYMBOL ( option_sync            , sync            ); // for put() and delete()
-LU_SYMBOL ( option_asBuffer        , asBuffer        ); // for get()
-LU_SYMBOL ( option_fillCache       , fillcache       ); // for get() and readStream()
+LD_SYMBOL ( option_createIfMissing , createIfMissing ); // for open()
+LD_SYMBOL ( option_errorIfExists   , errorIfExists   ); // for open()
+LD_SYMBOL ( option_compression     , compression     ); // for open()
+LD_SYMBOL ( option_cacheSize       , cacheSize       ); // for open() 
+LD_SYMBOL ( option_sync            , sync            ); // for put() and delete()
+LD_SYMBOL ( option_asBuffer        , asBuffer        ); // for get()
+LD_SYMBOL ( option_fillCache       , fillcache       ); // for get() and readStream()
 
 struct AsyncDescriptor;
 
@@ -66,15 +66,15 @@ class Database : public node::ObjectWrap {
 
   static v8::Persistent<v8::Function> constructor;
 
-  LU_V8_METHOD( New      )
-  LU_V8_METHOD( Open     )
-  LU_V8_METHOD( Close    )
-  LU_V8_METHOD( Put      )
-  LU_V8_METHOD( Delete   )
-  LU_V8_METHOD( Get      )
-  LU_V8_METHOD( Batch    )
-  LU_V8_METHOD( Iterator )
-  LU_V8_METHOD( ApproximateSize )
+  LD_V8_METHOD( New      )
+  LD_V8_METHOD( Open     )
+  LD_V8_METHOD( Close    )
+  LD_V8_METHOD( Put      )
+  LD_V8_METHOD( Delete   )
+  LD_V8_METHOD( Get      )
+  LD_V8_METHOD( Batch    )
+  LD_V8_METHOD( Iterator )
+  LD_V8_METHOD( ApproximateSize )
 };
 
 } // namespace leveldown

src/database_async.cc

@@ -117,7 +117,7 @@ void ReadWorker::HandleOKCallback () {
       v8::Local<v8::Value>::New(v8::Null())
     , returnValue
   };
-  RUN_CALLBACK(callback, argv, 2);
+  LD_RUN_CALLBACK(callback, argv, 2);
 }
 
 /** DELETE WORKER **/
@@ -232,7 +232,7 @@ void ApproximateSizeWorker::HandleOKCallback () {
       v8::Local<v8::Value>::New(v8::Null())
     , returnValue
   };
-  RUN_CALLBACK(callback, argv, 2);
+  LD_RUN_CALLBACK(callback, argv, 2);
 }
 
 } // namespace leveldown

src/database_async.h

@@ -3,8 +3,8 @@
  * MIT +no-false-attribs License <https://github.com/rvagg/node-leveldown/blob/master/LICENSE>
  */
 
-#ifndef LU_DATABASE_ASYNC_H
-#define LU_DATABASE_ASYNC_H
+#ifndef LD_DATABASE_ASYNC_H
+#define LD_DATABASE_ASYNC_H
 
 #include <vector>
 #include <node.h>

src/iterator.cc

@@ -118,15 +118,15 @@ v8::Handle<v8::Value> Iterator::Next (const v8::Arguments& args) {
   Iterator* iterator = node::ObjectWrap::Unwrap<Iterator>(args.This());
 
   if (args.Length() == 0 || !args[0]->IsFunction()) {
-    THROW_RETURN("next() requires a callback argument")
+    LD_THROW_RETURN("next() requires a callback argument")
   }
 
   if (iterator->ended) {
-    THROW_RETURN("Cannot call next() after end()")
+    LD_THROW_RETURN("Cannot call next() after end()")
   }
 
   if (iterator->nexting) {
-    THROW_RETURN("Cannot call next() before previous next() has completed")
+    LD_THROW_RETURN("Cannot call next() before previous next() has completed")
   }
 
   v8::Persistent<v8::Function> callback =
@@ -148,11 +148,11 @@ v8::Handle<v8::Value> Iterator::End (const v8::Arguments& args) {
   Iterator* iterator = node::ObjectWrap::Unwrap<Iterator>(args.This());
 
   if (args.Length() == 0 || !args[0]->IsFunction()) {
-    THROW_RETURN("end() requires a callback argument")
+    LD_THROW_RETURN("end() requires a callback argument")
   }
 
   if (iterator->ended) {
-    THROW_RETURN("end() already called on iterator")
+    LD_THROW_RETURN("end() already called on iterator")
   }
 
   v8::Persistent<v8::Function> callback =
@@ -213,7 +213,7 @@ v8::Handle<v8::Value> Iterator::NewInstance (
 v8::Handle<v8::Value> Iterator::New (const v8::Arguments& args) {
   v8::HandleScope scope;
 
-  //TODO: remove this, it's only here to make STRING_OR_BUFFER_TO_SLICE happy
+  //TODO: remove this, it's only here to make LD_STRING_OR_BUFFER_TO_SLICE happy
   v8::Local<v8::Function> callback;
 
   Database* database = node::ObjectWrap::Unwrap<Database>(args[0]->ToObject());
@@ -233,7 +233,7 @@ v8::Handle<v8::Value> Iterator::New (const v8::Arguments& args) {
           || optionsObj->Get(option_start)->IsString())) {
 
       startBuffer = v8::Local<v8::Value>::New(optionsObj->Get(option_start));
-      STRING_OR_BUFFER_TO_SLICE(_start, startBuffer, Start)
+      LD_STRING_OR_BUFFER_TO_SLICE(_start, startBuffer, Start)
       start = new leveldb::Slice(_start.data(), _start.size());
     }
 
@@ -243,7 +243,7 @@ v8::Handle<v8::Value> Iterator::New (const v8::Arguments& args) {
 
       v8::Local<v8::Value> endBuffer =
           v8::Local<v8::Value>::New(optionsObj->Get(option_end));
-      STRING_OR_BUFFER_TO_SLICE(_end, endBuffer, End)
+      LD_STRING_OR_BUFFER_TO_SLICE(_end, endBuffer, End)
       end = new std::string(_end.data(), _end.size());
     }
 
@@ -253,12 +253,12 @@ v8::Handle<v8::Value> Iterator::New (const v8::Arguments& args) {
     }
   }
 
-  BOOLEAN_OPTION_VALUE(optionsObj, reverse)
-  BOOLEAN_OPTION_VALUE_DEFTRUE(optionsObj, keys)
-  BOOLEAN_OPTION_VALUE_DEFTRUE(optionsObj, values)
-  BOOLEAN_OPTION_VALUE_DEFTRUE(optionsObj, keyAsBuffer)
-  BOOLEAN_OPTION_VALUE_DEFTRUE(optionsObj, valueAsBuffer)
-  BOOLEAN_OPTION_VALUE(optionsObj, fillCache)
+  LD_BOOLEAN_OPTION_VALUE(optionsObj, reverse)
+  LD_BOOLEAN_OPTION_VALUE_DEFTRUE(optionsObj, keys)
+  LD_BOOLEAN_OPTION_VALUE_DEFTRUE(optionsObj, values)
+  LD_BOOLEAN_OPTION_VALUE_DEFTRUE(optionsObj, keyAsBuffer)
+  LD_BOOLEAN_OPTION_VALUE_DEFTRUE(optionsObj, valueAsBuffer)
+  LD_BOOLEAN_OPTION_VALUE(optionsObj, fillCache)
 
   Iterator* iterator = new Iterator(
       database