 // Licensed to the Apache Software Foundation (ASF) under one
 // or more contributor license agreements.  See the NOTICE file
 // distributed with this work for additional information
 // regarding copyright ownership.  The ASF licenses this file
 // to you under the Apache License, Version 2.0 (the
 // "License"); you may not use this file except in compliance
 // with the License.  You may obtain a copy of the License at
 //
 //   http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing,
 // software distributed u
 nder the License is distributed on an
 // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 // KIND, either express or implied.  See the License for the
 // specific language governing permissions and limitations
 // under the License.
 
 #ifndef ARROW_UTIL_LOGGING_H
 #define ARROW_UTIL_LOGGING_H
 
 #include <cstdlib>
 #include <iostream>
 
 #include "arrow/util/macros.h"
 
namespace arrow { 
 // Stubbed versions of macros defined in glog/logging.h, intended for
 // environments where glog headers aren't available.
 //
 // Add more as needed.
 
 // Log levels. LOG ignores them, so their values are abitrary.
   34 
 #define ARROW_DEBUG (-1)
 #define ARROW_INFO 0
 #define ARROW_WARNING 1
 #define ARROW_ERROR 2
 #define ARROW_FATAL 3
 
 #define ARROW_LOG_INTERNAL(level) ::arrow::internal::CerrLog(level)
 #define ARROW_LOG(level) ARROW_LOG_INTERNAL(ARROW_##level)
 #define ARROW_IGNORE_EXPR(expr) ((void)(expr));
 
 #define ARROW_CHECK(condition)                           \
   (condition) ? 0                                        \
               : ::arrow::internal::FatalLog(ARROW_FATAL) \
                     << __FILE__ << __LINE__ << " Check failed: " #condition " "
 
 #ifdef NDEBUG
 #define ARROW_DFATAL ARROW_WARNING
 
 #define DCHECK(condition)      \
   ARROW_IGNORE_EXPR(condition) \
   while (false) ::arrow::internal::NullLog()
 #define DCHECK_EQ(val1, val2) \
   57   ARROW_IGNORE_EXPR(val1)     \
   while (false) ::arrow::internal::NullLog()
 #define DCHECK_NE(val1, val2) \
   ARROW_IGNORE_EXPR(val1)     \
   while (false) ::arrow::internal::NullLog()
 #define DCHECK_LE(val1, val2) \
   ARROW_IGNORE
 _EXPR(val1)     \
   while (false) ::arrow::internal::NullLog()
 #define DCHECK_LT(val1, val2) \
   ARROW_IGNORE_EXPR(val1)     \
   while (false) ::arrow::internal::NullLog()
 #define DCHECK_GE(val1, val2) \
   ARROW_IGNORE_EXPR(val1)     \
   70   while (false) ::arrow::internal::NullLog()
 #define DCHECK_GT(val1, val2) \
   ARROW_IGNORE_EXPR(val1)     \
   while (false) ::arrow::internal::NullLog()
 
 #else
 #define ARROW_DFATAL ARROW_FATAL<
 /span>
 
 #define DCHECK(condition) ARROW_CHECK(condition)
 #define DCHECK_EQ(val1, val2) ARROW_CHECK((val1) == (val2))
 #define DCHECK_NE(val1, val2) ARROW_CHECK((val1) != (val2))
&
 #160;#define DCHECK_LE(val1, val2) ARROW_CHECK((val1) <= (val2))
 #define DCHECK_LT(val1, val2) ARROW_CHECK((val1) < (val2))
 #define DCHECK_GE(val1, val2) ARROW_CHECK((val1) >= (val2))
 #define DCHECK_GT(val1, val2) ARROW_CHECK((val1) > (val2))
 
 #endif  // NDEBUG
 
 namespace internal {
 
 class NullLog {
  public:
   template <class T>
   NullLog& operator<<(const T& t) {
<
 a name="l00094">     return *this;
   }
 };
 
 class CerrLog {
  public:
   CerrLog(int severity)  // NOLINT(runtime/explicit)
       : severity_(severity), has_logged_(false) {}
 
   virtual ~CerrLog() {
     if (has_logged_) {
       std::cerr << std::endl;
     }
     if (severity_ == ARROW_FATAL) {
       std::exit(1);
     }   }
 
   template <class T>
   CerrLog& operator<<(const T& t) {
     if (severity_ != ARROW_DEBUG) {
       has_logged_ = true;
       std::cerr << t;
     }
     return *this;
   }
 
  protected:
   const int severity_;
   bool has_logged_;
 };
&#
 160;
 // Clang-tidy isn't smart enough to determine that DCHECK using CerrLog doesn't
 // return so we create a new class to give it a hint.
 class FatalLog : public CerrLog {
  public:
   explicit FatalLog(int /* severity */)  // NOLINT
       : CerrLog(ARROW_FATAL) {}          // NOLINT
 
   ARROW_NORETURN ~FatalLog() {
     if (has_logged_) {
       std::cerr << std::endl;
     }
     std::exit(1);
   }
<
 a name="l00139"> };
 
 }  // namespace internal
 
 }  // namespace arrow
 
 #endif  // ARROW_UTIL_LOGGING_H

+Go to the documentation of this file. // Licensed to the Apache Software Foundation (ASF) under one
 // or more contributor license agreements.  See the NOTICE file
 // distributed with this work for additional information
 // regarding copyright ownership.  The ASF licenses this file
 // to you under the Apache License, Version 2.0 (the
 // "License"); you may not use this file except in compliance
 // with the License.  You may obtain a copy of the License at
 //
 //   http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing,
 // software distributed u
 nder the License is distributed on an
 // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 // KIND, either express or implied.  See the License for the
 // specific language governing permissions and limitations
 // under the License.
 
 #ifndef ARROW_UTIL_LOGGING_H
 #define ARROW_UTIL_LOGGING_H
 
 #include <cstdlib>
 #include <iostream>
 
 #include "arrow/util/macros.h"
 
namespace arrow { 
 // Stubbed versions of macros defined in glog/logging.h, intended for
 // environments where glog headers aren't available.
 //
 // Add more as needed.
 
 // Log levels. LOG ignores them, so their values are abitrary.
   34 
 #define ARROW_DEBUG (-1)
 #define ARROW_INFO 0
 #define ARROW_WARNING 1
 #define ARROW_ERROR 2
 #define ARROW_FATAL 3
 
 #define ARROW_LOG_INTERNAL(level) ::arrow::internal::CerrLog(level)
 #define ARROW_LOG(level) ARROW_LOG_INTERNAL(ARROW_##level)
 #define ARROW_IGNORE_EXPR(expr) ((void)(expr));
 
 #define ARROW_CHECK(condition)                           \
   (condition) ? 0                                        \
               : ::arrow::internal::FatalLog(ARROW_FATAL) \
                     << __FILE__ << ":" << __LINE__ << " Check failed: " #condition " "
 
 #ifdef NDEBUG
 #define ARROW_DFATAL ARROW_WARNING
 
 #define DCHECK(condition)      \
   ARROW_IGNORE_EXPR(condition) \
   while (false) ::arrow::internal::NullLog()
 #define DCHECK_EQ(val1, val2) \
<
 a name="l00057">   ARROW_IGNORE_EXPR(val1)     \
   while (false) ::arrow::internal::NullLog()
 #define DCHECK_NE(val1, val2) \
   ARROW_IGNORE_EXPR(val1)     \
   while (false) ::arrow::internal::NullLog()
 #define DCHECK_LE(val1, val2) \
   ARROW_IGNORE_EXPR(val1)     \
   while (false) ::arrow::internal::NullLog()
 #define DCHECK_LT(val1, val2) \
   ARROW_IGNORE_EXPR(val1)     \
   while (false) ::arrow::internal::NullLog()
 #define DCHECK_GE(val1, val2) \
   ARROW_IGNORE_EXPR(val1)     \
   while (false) ::arrow::internal::NullLog()
 #define DCHECK_GT(val1, val2) \
   ARROW_IGNORE_EXPR(val1)     \
   while (false) ::arrow::internal::NullLog()
 
 #else
 #define AR
 ROW_DFATAL ARROW_FATAL
 
 #define DCHECK(condition) ARROW_CHECK(condition)
 #define DCHECK_EQ(val1, val2) ARROW_CHECK((val1) == (val2))
 #define DCHECK_NE(val1, val2) ARROW_CHECK((val1) != (val2))
 #define DCHECK_LE(val1, val2) ARROW_CHECK((val1) <= (val2))
 #define DCHECK_LT(val1, val2) ARROW_CHECK((val1) < (val2))
 #define DCHECK_GE(val1, val2) ARROW_CHECK((val1) >= (val2))
 #define DCHECK_GT(val1, val2) ARROW_CHECK((val1) > (val2))
 
 #endif  // NDEBUG
 
 namespace internal {
 
 class NullLog {
  public:
   template <class T>
   NullLog& operator<<(const T& ARROW_ARG_UNUSED(t)) {
     return *this;
   }
 };
 
 class CerrLog {
  public:
   CerrLog(int severity)  // NOLINT(runtime/explicit)
       : severity_(severity), has_logged_(false) {}
 
   virtual ~CerrLog() {
     if (has_logged_) {
       std::cerr << std::endl;
     }
     if (severity_ == ARROW_FATAL) {
       std::exit(1);
     }
   }
 
   template <class T>
   CerrLog& operator<<(const T& t) {
     if (severity_ != ARROW_DEBUG) {
       has_logged_ = true;
       std::cerr << t;
     }
     return *this;
   }
 
  protected:
   const int severity_;
   bool has_logged_;
 
 // Clang-tidy isn't smart enough to determine that DCHECK using CerrLog doesn't
 // return so we create a new class to give it a hint.
 class FatalLog : public CerrLog {
  public:
   explicit FatalLog(int /* severity */)
   // NOLINT
       : CerrLog(ARROW_FATAL) {}          // NOLINT
 
   ARROW_NORETURN ~FatalLog() {
     if (has_logged_) {
       std::cerr << std::endl;
     }
     std::exi
 t(1);
   }
 };
 
 }  // namespace internal
 
 }  // namespace arrow
 
 #endif  // ARROW_UTIL_LOGGING_H

+


http://git-wip-us.apache.org/repos/asf/arrow-site/blob/7a2e5ece/docs/cpp/macros_8h.html
----------------------------------------------------------------------
diff --git a/docs/cpp/macros_8h.html b/docs/cpp/macros_8h.html
index acc9949..4c1033e 100644
--- a/docs/cpp/macros_8h.html
+++ b/docs/cpp/macros_8h.html
@@ -5,7 +5,7 @@
 
-Apache Arrow (C++): /home/wesm/code/arrow/cpp/src/arrow/util/macros.h File Reference
+Apache Arrow (C++): /apache-arrow/arrow/cpp/src/arrow/util/macros.h File Reference
@@ -78,6 +78,8 @@ Macros
  
 #define ARROW_UNUSED(x)   (void)x
  
+#define ARROW_ARG_UNUSED(x)
+ 
 #define ARROW_NORETURN
  
 #define ARROW_PREDICT_FALSE(x)   x
@@ -90,6 +92,24 @@ Macros
  
 
 Macro Definition Documentation
+
+◆ ARROW_ARG_UNUSED
+
+
+
+      
+        
+          
+          
+          
+          
+          
+        
+      #define ARROW_ARG_UNUSED( x)

+

+
+

+
◆ ARROW_DISALLOW_COPY_AND_ASSIGN
 

http://git-wip-us.apache.org/repos/asf/arrow-site/blob/7a2e5ece/docs/cpp/macros_8h_source.html
----------------------------------------------------------------------
diff --git a/docs/cpp/macros_8h_source.html b/docs/cpp/macros_8h_source.html
index 1b0f257..ef12ce7 100644
--- a/docs/cpp/macros_8h_source.html
+++ b/docs/cpp/macros_8h_source.html
@@ -5,7 +5,7 @@
 
-Apache Arrow (C++): /home/wesm/code/arrow/cpp/src/arrow/util/macros.h Source File
+Apache Arrow (C++): /apache-arrow/arrow/cpp/src/arrow/util/macros.h Source File
@@ -67,7 +67,7 @@ $(function() {
 macros.h

-Go to the documentation of this file. // Licensed to the Apache Software Foundation (ASF) under one
 // or more contributor license agreements.  See the NOTICE file
 // distributed with this work for additional information
 // regarding copyright ownership.  The ASF licenses this file
 // to you under the Apache License, Version 2.0 (the
 // "License"); you may not use this file except in compliance
 // with the License.  You may obtain a copy of the License at
 //
 //   http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing,
 // software distributed un
 der the License is distributed on an
 // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 // KIND, either express or implied.  See the License for the
 // specific language governing permissions and limitations
 // under the License.
 
 #ifndef ARROW_UTIL_MACROS_H
 #define ARROW_UTIL_MACROS_H
 
 // From Google gutil
 #ifndef ARROW_DISALLOW_COPY_AND_ASSIGN
 #define ARROW_DISALLOW_COPY_AND_ASSIGN(TypeName) \
   TypeName(const TypeName&) = delete;            \
   void operator=(co
 nst TypeName&) = delete
 #endif
 
 #define ARROW_UNUSED(x) (void)x
 
 //
 // GCC can be told that a certain branch is not likely to be taken (for
 // instance, a CHECK failure), and use th
 at information in static analysis.
 // Giving it this information can help it optimize for the common case in
 // the absence of better information (ie. -fprofile-arcs).
 //
 #if defined(__GNUC__)
 #define ARROW_PREDICT_FALSE(x) (__builtin_expect(x, 0))
 #define ARROW_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
 #define ARROW_NORETURN __attribute__((noreturn))
 #define ARROW_PREFETCH(addr) __builtin_prefetch(addr)
 #elif defined(_MSC_VER)
 #define ARROW_NORETURN __declspec(noreturn)
 #define ARROW_PREDICT_FALSE(x) x
 #define ARROW_PREDICT_TRUE(x) x
   45 #define ARROW_PREFETCH(addr)
 #else
 #define ARROW_NORETURN
 #define ARROW_PREDICT_FALSE(x) x
 #define ARROW_PREDICT_TRUE(x) x
 #define ARROW_PREFETCH(addr)
 #endif
 
 #if (defined(__GNUC__) || defined(__APPLE__))
 #define ARROW_MUST_USE_RESULT __attribute__((warn_unused_result))
 #elif defined(_MSC_VER)
 #define ARROW_MUST_USE_RESULT
   57 #else
 #define ARROW_MUST_USE_RESULT
 #endif
 
 // macros to disable padding
 // these macros are portable across different compilers and platforms
 //[https://github.com/google/flatbuffers/blob/master/include/fl
 atbuffers/flatbuffers.h#L1355]
 #if !defined(MANUALLY_ALIGNED_STRUCT)
 #if defined(_MSC_VER)
 #define MANUALLY_ALIGNED_STRUCT(alignment) \
   __pragma(pack(1));                       \
   struct __declspec(align(alignment))
 #define STRUCT_END(name, size) \
   __pragma(pack());            \
   static_assert(sizeof(name) == size, "compiler breaks packing rules")
 #elif defined(__GNUC__) || defined(__clang__)
 #define MANUALLY_ALIGNED_STRUCT(alignment) \
   _Pragma("pack(1)") struct __attribute__((aligned(alignment)))
 #define STRUCT_END(name, size) \
   _Pragma("pack()") static_assert(sizeof(name) == size, "compiler breaks packing rules")
 #else
 #error Unknown compiler, please define structure alignment macros
 #endif
 #endif  // !defined(MANUALLY_ALIGNED_STRUCT)
 
 #end
 if  // ARROW_UTIL_MACROS_H

+Go to the documentation of this file. // Licensed to the Apache Software Foundation (ASF) under one
 // or more contributor license agreements.  See the NOTICE file
 // distributed with this work for additional information
 // regarding copyright ownership.  The ASF licenses this file
 // to you under the Apache License, Version 2.0 (the
 // "License"); you may not use this file except in compliance
 // with the License.  You may obtain a copy of the License at
 //
 //   http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing,
 // software distributed un
 der the License is distributed on an
 // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 // KIND, either express or implied.  See the License for the
 // specific language governing permissions and limitations
 // under the License.
 
 #ifndef ARROW_UTIL_MACROS_H
 #define ARROW_UTIL_MACROS_H
 
 // From Google gutil
 #ifndef ARROW_DISALLOW_COPY_AND_ASSIGN
 #define ARROW_DISALLOW_COPY_AND_ASSIGN(TypeName) \
   TypeName(const TypeName&) = delete;            \
   void operator=(co
 nst TypeName&) = delete
 #endif
 
 #define ARROW_UNUSED(x) (void)x
 #define ARROW_ARG_UNUSED(x)
 //
 // GCC can be told that a certain branch is not likely to be taken (for
 // instance, a CHECK failure), and use that information in static analysis.
 // Giving it this information can help it optimize for the common case in
 // the absence of better information (ie. -fprofile-arcs).
 //
 #if defined(__GNUC__)
 #define ARROW_PREDICT_FALSE(x) (__builtin_expect(x, 0))
 #define ARROW_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
 #define ARROW_NORETURN __attribute__((noreturn))
 #define ARROW_PREFETCH(addr) __builtin_prefetch(addr)
 #elif defined(_MSC_VER)
 #define ARROW_NORETURN __declspec(noreturn)
 #define ARROW_PREDICT_FALSE(x) x
 #define ARROW_PREDICT_TRUE(x) x
 #define ARROW_PREFETCH(addr)
 #else
 #define ARROW_NORETURN
 #define ARROW_PREDICT_FALSE(x) x
 #define ARROW_PRE
 DICT_TRUE(x) x
 #define ARROW_PREFETCH(addr)
 #endif
 
 #if (defined(__GNUC__) || defined(__APPLE__))
 #define ARROW_MUST_USE_RESULT __attribute__((warn_unused_result))
 #elif defined(_MSC_VER)
   56 #define ARROW_MUST_USE_RESULT
 #else
 #define ARROW_MUST_USE_RESULT
 #endif
 
 // macros to disable padding
 // these macros are portable across different compilers and platforms
 //[https://github.com/google/flatbuffers/blob/master/include/flatbuffers/flatbuffers.h#L1355]
 #if !defined(MANUALLY_ALIGNED_STRUCT)
 #if defined(_MSC_VER)
 #define MANUALLY_ALIGNED_STRUCT(alignment) \
   __pragma(pack(1));                       \
   struct __declspec(align(alignment))
 #define STRUCT_END(name, size) \
   __pragma(pack());            \
   static_assert(sizeof(name) == size, "compiler breaks packing rules")
 #elif defined(__GNUC__) || defined(__clang__)
 #define MANUALLY_ALIGNED_STRUCT(alignment) \
   _Pragma("pack(1)") struct __attribute__((aligned(alignment)))
 #define STRUCT_END(name, size) \
   _Pragma("pack()") static_assert(sizeof(name) == size, "compiler breaks packing rules")
 #else
 #error Unknown compiler, please define structure alignment macros
 #endif
 #endif  // !defined(MANUALLY_ALIGNED_STRUCT)
   81 
 #endif  // ARROW_UTIL_MACROS_H

// Create a Plasma object with metadata.

int64_t data_size = 100;

std::string metadata = "{'author': 'john'}";

uint8_t* data;

client.Create(object_id, data_size, (uint8_t*) metadata.data(), metadata.size(), &data);

Now that we've obtained a pointer to our object's data, we can write our data to it:

// Write some data for the Plasma object.
for (int64_t i = 0; i < data_size; i++) {
    data[i] = static_cast<uint8_t>(i % 4);
}

When the client is done, the client seals the buffer, making the object immutable, and making it available to other Plasma clients:

// Seal the object. This makes it available for all clients.

client.Seal(object_id);

Here is an example that combines all these features:

-

#include <plasma/client.h>
using namespace plasma;
int main(int argc, char** argv) {
  // Start up and connect a Plasma client.
  PlasmaClient client;
  ARROW_CHECK_OK(client.Connect("/tmp/plasma", &q
 uot;", PLASMA_DEFAULT_RELEASE_DELAY));
  // Create an object with a random ObjectID.
  ObjectID object_id = ObjectID::from_binary("00000000000000000000");
  int64_t data_size = 1000;
  uint8_t *data;
  std::string metadata = "{'author': 'john'}";
  ARROW_CHECK_OK(client.Create(object_id, data_size, (uint8_t*) m
 etadata.data(), metadata.size(), &data));
  // Write some data into the object.
  for (int64_t i = 0; i < data_size; i++) {
    data[i] = static_cast<uint8_t>(i % 4);
  }
  // Seal the object.
  ARROW_CHECK_OK(client.Seal(object_id));
  // Disconnect the client.
  ARROW_CHECK_OK(client.Disconnect());
}

This example can be compiled with

+

#include <plasma/client.h>
using namespace plasma;
int main(int argc, char** argv) {
  // Start up and connect a Plasma client.
  PlasmaClient client;
  ARROW_CHECK_OK(client.Connect("/tmp/plasma", &q
 uot;", PLASMA_DEFAULT_RELEASE_DELAY));
  // Create an object with a fixed ObjectID.
  ObjectID object_id = ObjectID::from_binary("00000000000000000000");
  int64_t data_size = 1000;
  uint8_t *data;
  std::string metadata = "{'author': 'john'}";
  ARROW_CHECK_OK(client.Create(object_id, data_size, (uint8_t*) me
 tadata.data(), metadata.size(), &data));
  // Write some data into the object.
  for (int64_t i = 0; i < data_size; i++) {
    data[i] = static_cast<uint8_t>(i % 4);
  }
  // Seal the object.
  ARROW_CHECK_OK(client.Seal(object_id));
  // Disconnect the client.
  ARROW_CHECK_OK(client.Disconnect());
}

This example can be compiled with

g++ create.cc `pkg-config --cflags --libs plasma` --std=c++11 -o create

To verify that an object exists in the Plasma object store, you can call PlasmaClient::Contains() to check if an object has been created and sealed for a given Object ID. Note that this function will still return False if the object has been created, but not yet sealed:

// Check if an object has been created and sealed.
bool has_object;
client.Contains(object_id, &has_object);
if (has_object) {
    // Object has been created and sealed, proceed
}

Getting an Object

After an object has been sealed, any client who knows the Object ID can get the object. To store the retrieved object contents, you should create an ObjectBuffer, then call PlasmaClient::Get() as follows: