http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/fd280b5c/extensions/usb-camera/CMakeLists.txt
----------------------------------------------------------------------
diff --git a/extensions/usb-camera/CMakeLists.txt 
b/extensions/usb-camera/CMakeLists.txt
index 480bc14..d807e80 100644
--- a/extensions/usb-camera/CMakeLists.txt
+++ b/extensions/usb-camera/CMakeLists.txt
@@ -44,7 +44,7 @@ if (NOT PNG_FOUND)
     message(FATAL_ERROR "A compatible PNG library is required to build 
GetUSBCamera.")
 endif()
 
-include_directories(../../libminifi/include  ../../libminifi/include/core  
../../thirdparty/spdlog-20170710/include ../../thirdparty/concurrentqueue 
../../thirdparty/yaml-cpp-yaml-cpp-0.5.3/include 
${CIVET_THIRDPARTY_ROOT}/include ../../thirdparty/jsoncpp/include  
../../thirdparty/) 
+include_directories(../../libminifi/include  ../../libminifi/include/core  
../../thirdparty/spdlog-20170710/include ../../thirdparty/concurrentqueue 
../../thirdparty/yaml-cpp-yaml-cpp-0.5.3/include 
${CIVET_THIRDPARTY_ROOT}/include ../../thirdparty/) 
 
 include_directories(../../thirdparty/libuvc-0.0.6/include)
 
@@ -60,8 +60,7 @@ if(CMAKE_THREAD_LIBS_INIT)
 endif()
 
 find_package(UUID REQUIRED)
-target_link_libraries(minifi-usb-camera-extensions ${LIBMINIFI} 
${UUID_LIBRARIES} ${JSONCPP_LIB})
-add_dependencies(minifi-usb-camera-extensions jsoncpp_project)
+target_link_libraries(minifi-usb-camera-extensions ${LIBMINIFI} 
${UUID_LIBRARIES})
 find_package(OpenSSL REQUIRED)
 include_directories(${OPENSSL_INCLUDE_DIR})
 target_link_libraries(minifi-usb-camera-extensions ${CMAKE_DL_LIBS} )

http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/fd280b5c/libminifi/CMakeLists.txt
----------------------------------------------------------------------
diff --git a/libminifi/CMakeLists.txt b/libminifi/CMakeLists.txt
index a40f070..ce0a0d9 100644
--- a/libminifi/CMakeLists.txt
+++ b/libminifi/CMakeLists.txt
@@ -55,7 +55,7 @@ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wno-reorder")
 include_directories(../thirdparty/spdlog-20170710/include)
 include_directories(../thirdparty/yaml-cpp-yaml-cpp-20171024/include)
 
-include_directories(../thirdparty/jsoncpp/include)
+include_directories(../thirdparty/rapidjson-1.1.0/include)
 include_directories(../thirdparty/concurrentqueue/)
 include_directories(include)
 
@@ -71,8 +71,7 @@ file(GLOB SPD_SOURCES 
"../thirdparty/spdlog-20170710/include/spdlog/*")
 # header only library
 add_library(spdlog STATIC ${SPD_SOURCES})
 add_library(core-minifi STATIC ${SOURCES})
-add_dependencies(core-minifi jsoncpp_project)
-target_link_libraries(core-minifi ${UUID_LIBRARIES} ${JSONCPP_LIB} yaml-cpp dl)
+target_link_libraries(core-minifi ${UUID_LIBRARIES} yaml-cpp)
 
 find_package(ZLIB REQUIRED)
 include_directories(${ZLIB_INCLUDE_DIRS})
@@ -91,7 +90,6 @@ endif (OPENSSL_FOUND)
 
 add_library(minifi STATIC ${PROCESSOR_SOURCES})
 add_library(capi STATIC ${CAPI_SOURCES})
-target_link_libraries(minifi c-library civetweb-cpp)
 
 target_link_libraries(minifi core-minifi)
 

http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/fd280b5c/libminifi/include/c2/protocols/RESTProtocol.h
----------------------------------------------------------------------
diff --git a/libminifi/include/c2/protocols/RESTProtocol.h 
b/libminifi/include/c2/protocols/RESTProtocol.h
index 823b5a9..ed6d3eb 100644
--- a/libminifi/include/c2/protocols/RESTProtocol.h
+++ b/libminifi/include/c2/protocols/RESTProtocol.h
@@ -18,8 +18,11 @@
 #ifndef LIBMINIFI_INCLUDE_C2_PROTOCOLS_RESTPROTOCOL_H_
 #define LIBMINIFI_INCLUDE_C2_PROTOCOLS_RESTPROTOCOL_H_
 
-#include "json/json.h"
-#include "json/writer.h"
+#include "rapidjson/document.h"
+#include "rapidjson/writer.h"
+#include "rapidjson/stringbuffer.h"
+#include "rapidjson/prettywriter.h"
+
 #include <string>
 #include <mutex>
 
@@ -28,6 +31,7 @@
 #include "c2/HeartBeatReporter.h"
 #include "controllers/SSLContextService.h"
 #include "utils/HTTPClient.h"
+#include "Exception.h"
 
 namespace org {
 namespace apache {
@@ -55,7 +59,11 @@ class RESTProtocol {
 
  protected:
 
-  virtual Json::Value serializeJsonPayload(Json::Value &json_root, const 
C2Payload &payload);
+  virtual rapidjson::Value serializeJsonPayload(const C2Payload &payload, 
rapidjson::Document::AllocatorType &alloc);
+
+  virtual std::string serializeJsonRootPayload(const C2Payload& payload);
+  
+  virtual void mergePayloadContent(rapidjson::Value &target, const C2Payload 
&payload, rapidjson::Document::AllocatorType &alloc);
 
   virtual const C2Payload parseJsonResponse(const C2Payload &payload, const 
std::vector<char> &response);
 

http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/fd280b5c/libminifi/include/utils/ByteArrayCallback.h
----------------------------------------------------------------------
diff --git a/libminifi/include/utils/ByteArrayCallback.h 
b/libminifi/include/utils/ByteArrayCallback.h
index f0a83ee..9ccca48 100644
--- a/libminifi/include/utils/ByteArrayCallback.h
+++ b/libminifi/include/utils/ByteArrayCallback.h
@@ -61,8 +61,6 @@ class ByteInputCallBack : public InputStreamCallback {
   }
 
   virtual void write(std::string content) {
-    //vec.resize(content.length());
-    //std::copy(content.begin(), content.end(), std::back_inserter(vec));
     vec.assign(content.begin(), content.end());
     ptr = &vec[0];
   }

http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/fd280b5c/libminifi/include/utils/HTTPClient.h
----------------------------------------------------------------------
diff --git a/libminifi/include/utils/HTTPClient.h 
b/libminifi/include/utils/HTTPClient.h
index b09b450..3d1383c 100644
--- a/libminifi/include/utils/HTTPClient.h
+++ b/libminifi/include/utils/HTTPClient.h
@@ -147,7 +147,9 @@ class HTTPRequestResponse {
       if (callback->getPos() <= buffer_size) {
         size_t len = buffer_size - callback->pos;
         if (len <= 0)
+        {
           return 0;
+        }
         char *ptr = callback->ptr->getBuffer(callback->getPos());
 
         if (ptr == nullptr) {
@@ -155,6 +157,7 @@ class HTTPRequestResponse {
         }
         if (len > size * nmemb)
           len = size * nmemb;
+        auto strr = std::string(ptr,len);
         memcpy(data, ptr, len);
         callback->pos += len;
         callback->ptr->seek(callback->getPos());
@@ -163,7 +166,6 @@ class HTTPRequestResponse {
     } else {
       return 0x10000000;
     }
-
     return 0;
   }
 

http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/fd280b5c/libminifi/src/RemoteProcessorGroupPort.cpp
----------------------------------------------------------------------
diff --git a/libminifi/src/RemoteProcessorGroupPort.cpp 
b/libminifi/src/RemoteProcessorGroupPort.cpp
index 332de0b..c7cc191 100644
--- a/libminifi/src/RemoteProcessorGroupPort.cpp
+++ b/libminifi/src/RemoteProcessorGroupPort.cpp
@@ -36,8 +36,8 @@
 
 #include "sitetosite/Peer.h"
 #include "sitetosite/SiteToSiteFactory.h"
-#include "json/json.h"
-#include "json/writer.h"
+
+#include "rapidjson/document.h"
 
 #include "Exception.h"
 #include "core/logging/Logger.h"
@@ -311,20 +311,25 @@ void 
RemoteProcessorGroupPort::refreshRemoteSite2SiteInfo() {
     if (!response_body.empty()) {
       std::string controller = std::string(response_body.begin(), 
response_body.end());
       logger_->log_debug("controller config %s", controller);
-      Json::Value value;
-      Json::Reader reader;
-      bool parsingSuccessful = reader.parse(controller, value);
-      if (parsingSuccessful && !value.empty()) {
-        Json::Value controllerValue = value["controller"];
-        if (!controllerValue.empty()) {
-          Json::Value port = controllerValue["remoteSiteListeningPort"];
-          if (client_type_ == sitetosite::CLIENT_TYPE::RAW && !port.empty())
-            this->site2site_port_ = port.asInt();
+      rapidjson::Document doc;
+      rapidjson::ParseResult ok = doc.Parse(controller.c_str());
+
+      if (ok && doc.IsObject() && !doc.ObjectEmpty()) {
+        rapidjson::Value::MemberIterator itr = doc.FindMember("controller");
+
+        if (itr != doc.MemberEnd() && itr->value.IsObject()) {
+          rapidjson::Value controllerValue = itr->value.GetObject();
+          rapidjson::Value::ConstMemberIterator end_itr = 
controllerValue.MemberEnd();
+          rapidjson::Value::ConstMemberIterator port_itr = 
controllerValue.FindMember("remoteSiteListeningPort");
+          rapidjson::Value::ConstMemberIterator secure_itr = 
controllerValue.FindMember("siteToSiteSecure");
+
+          if (client_type_ == sitetosite::CLIENT_TYPE::RAW && port_itr != 
end_itr && port_itr->value.IsNumber())
+            this->site2site_port_ = port_itr->value.GetInt();
           else
             this->site2site_port_ = port_;
-          Json::Value secure = controllerValue["siteToSiteSecure"];
-          if (!secure.empty())
-            this->site2site_secure_ = secure.asBool();
+
+          if (secure_itr != end_itr && secure_itr->value.IsBool())
+            this->site2site_secure_ = secure_itr->value.GetBool();
         }
         logger_->log_debug("process group remote site2site port %d, is secure 
%d", site2site_port_, site2site_secure_);
       }

http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/fd280b5c/libminifi/src/c2/protocols/RESTProtocol.cpp
----------------------------------------------------------------------
diff --git a/libminifi/src/c2/protocols/RESTProtocol.cpp 
b/libminifi/src/c2/protocols/RESTProtocol.cpp
index 946e3c6..b1cebb0 100644
--- a/libminifi/src/c2/protocols/RESTProtocol.cpp
+++ b/libminifi/src/c2/protocols/RESTProtocol.cpp
@@ -24,6 +24,7 @@
 #include <map>
 #include <string>
 #include <vector>
+#include <list>
 
 namespace org {
 namespace apache {
@@ -32,46 +33,57 @@ namespace minifi {
 namespace c2 {
 
 const C2Payload RESTProtocol::parseJsonResponse(const C2Payload &payload, 
const std::vector<char> &response) {
-  Json::Reader reader;
-  Json::Value root;
+  rapidjson::Document root;
+
   try {
-    if (reader.parse(std::string(response.data(), response.size()), root)) {
+    rapidjson::ParseResult ok = root.Parse(response.data(), response.size());
+
+    if (ok) {
       std::string requested_operation = getOperation(payload);
 
       std::string identifier;
-      if (root.isMember("operationid")) {
-        identifier = root["operationid"].asString();
+      if (root.HasMember("operationid")) {
+        identifier = root["operationid"].GetString();
       }
-      if (root["operation"].asString() == requested_operation) {
-        if (root["requested_operations"].size() == 0) {
+
+      if (root.HasMember("operation") && root["operation"].GetString() == 
requested_operation) {
+        if (root["requested_operations"].Size() == 0)
           return std::move(C2Payload(payload.getOperation(), 
state::UpdateState::READ_COMPLETE, true));
-        }
+
         C2Payload new_payload(payload.getOperation(), 
state::UpdateState::NESTED, true);
 
         new_payload.setIdentifier(identifier);
 
-        for (const Json::Value& request : root["requested_operations"]) {
-          Operation newOp = stringToOperation(request["operation"].asString());
+        for (const rapidjson::Value& request : 
root["requested_operations"].GetArray()) {
+          Operation newOp = 
stringToOperation(request["operation"].GetString());
           C2Payload nested_payload(newOp, state::UpdateState::READ_COMPLETE, 
true);
           C2ContentResponse new_command(newOp);
           new_command.delay = 0;
           new_command.required = true;
           new_command.ttl = -1;
+
           // set the identifier if one exists
-          if (request.isMember("operationid")) {
-            new_command.ident = request["operationid"].asString();
+          if (request.HasMember("operationid")) {
+            if (request["operationid"].IsNumber())
+              new_command.ident = 
std::to_string(request["operationid"].GetInt64());
+            else if (request["operationid"].IsString())
+              new_command.ident = request["operationid"].GetString();
+            else
+              throw(Exception(SITE2SITE_EXCEPTION, "Invalid type for 
operationid"));
+
             nested_payload.setIdentifier(new_command.ident);
           }
-          new_command.name = request["name"].asString();
 
-          if (request.isMember("content") && request["content"].size() > 0) {
-            for (const auto &name : request["content"].getMemberNames()) {
-              new_command.operation_arguments[name] = 
request["content"][name].asString();
-            }
-          }
+          new_command.name = request["name"].GetString();
+
+          if (request.HasMember("content") && request["content"].MemberCount() 
> 0)
+            for (const auto &member : request["content"].GetObject())
+              new_command.operation_arguments[member.name.GetString()] = 
member.value.GetString();
+
           nested_payload.addContent(std::move(new_command));
           new_payload.addPayload(std::move(nested_payload));
         }
+
         // we have a response for this request
         return new_payload;
       }
@@ -81,48 +93,116 @@ const C2Payload RESTProtocol::parseJsonResponse(const 
C2Payload &payload, const
   return std::move(C2Payload(payload.getOperation(), 
state::UpdateState::READ_ERROR, true));
 }
 
-Json::Value RESTProtocol::serializeJsonPayload(Json::Value &json_root, const 
C2Payload &payload) {
-  // get the name from the content
-  Json::Value json_payload;
-  std::map<std::string, std::vector<Json::Value>> children;
-  for (const auto &nested_payload : payload.getNestedPayloads()) {
-    Json::Value child_payload = serializeJsonPayload(json_payload, 
nested_payload);
-    children[nested_payload.getLabel()].push_back(child_payload);
-  }
-  for (auto child_vector : children) {
-    if (child_vector.second.size() > 1) {
-      Json::Value children_json(Json::arrayValue);
-      for (auto child : child_vector.second) {
-        json_payload[child_vector.first] = child;
-      }
-    } else {
-      if (child_vector.second.size() == 1) {
-        if (child_vector.second.at(0).isMember(child_vector.first)) {
-          json_payload[child_vector.first] = 
child_vector.second.at(0)[child_vector.first];
-        } else {
-          json_payload[child_vector.first] = child_vector.second.at(0);
-        }
-      }
-    }
-  }
+void setJsonStr(const std::string& key, const std::string& value, 
rapidjson::Value& parent, rapidjson::Document::AllocatorType& alloc) { // NOLINT
+  rapidjson::Value keyVal;
+  rapidjson::Value valueVal;
+  const char* c_key = key.c_str();
+  const char* c_val = value.c_str();
+
+  keyVal.SetString(c_key, key.length(), alloc);
+  valueVal.SetString(c_val, value.length(), alloc);
 
+  parent.AddMember(keyVal, valueVal, alloc);
+}
+
+rapidjson::Value getStringValue(const std::string& value, 
rapidjson::Document::AllocatorType& alloc) { // NOLINT
+  rapidjson::Value Val;
+  Val.SetString(value.c_str(), value.length(), alloc);
+  return Val;
+}
+
+void RESTProtocol::mergePayloadContent(rapidjson::Value &target, const 
C2Payload &payload, rapidjson::Document::AllocatorType &alloc) {
   const std::vector<C2ContentResponse> &content = payload.getContent();
+
   for (const auto &payload_content : content) {
-    Json::Value payload_content_values;
+    rapidjson::Value payload_content_values(rapidjson::kObjectType);
     bool use_sub_option = true;
+
     if (payload_content.op == payload.getOperation()) {
       for (auto content : payload_content.operation_arguments) {
         if (payload_content.operation_arguments.size() == 1 && 
payload_content.name == content.first) {
-          json_payload[payload_content.name] = content.second;
+          setJsonStr(payload_content.name, content.second, target, alloc);
           use_sub_option = false;
         } else {
-          payload_content_values[content.first] = content.second;
+          setJsonStr(content.first, content.second, payload_content_values, 
alloc);
         }
       }
     }
-    if (use_sub_option)
-      json_payload[payload_content.name] = payload_content_values;
+    if (use_sub_option) {
+      rapidjson::Value sub_key = getStringValue(payload_content.name, alloc);
+      target.AddMember(sub_key, payload_content_values, alloc);
+    }
   }
+}
+
+std::string RESTProtocol::serializeJsonRootPayload(const C2Payload& payload) {
+  rapidjson::Document json_payload(rapidjson::kObjectType);
+  rapidjson::Document::AllocatorType &alloc = json_payload.GetAllocator();
+
+  rapidjson::Value opReqStrVal;
+  std::string operation_request_str = getOperation(payload);
+  opReqStrVal.SetString(operation_request_str.c_str(), 
operation_request_str.length(), alloc);
+  json_payload.AddMember("operation", opReqStrVal, alloc);
+
+  std::string operationid = payload.getIdentifier();
+  if (operationid.length() > 0) {
+    rapidjson::Value operationIdVal = getStringValue(operationid, alloc);
+    json_payload.AddMember("operationid", operationIdVal, alloc);
+  }
+
+  mergePayloadContent(json_payload, payload, alloc);
+
+  for (const auto &nested_payload : payload.getNestedPayloads()) {
+    rapidjson::Value np_key = getStringValue(nested_payload.getLabel(), alloc);
+    rapidjson::Value np_value = serializeJsonPayload(nested_payload, alloc);
+    json_payload.AddMember(np_key, np_value, alloc);
+  }
+
+  rapidjson::StringBuffer buffer;
+  rapidjson::PrettyWriter<rapidjson::StringBuffer> writer(buffer);
+  json_payload.Accept(writer);
+
+  // std::string ret = ;
+  return buffer.GetString();
+}
+
+rapidjson::Value RESTProtocol::serializeJsonPayload(const C2Payload &payload, 
rapidjson::Document::AllocatorType &alloc) {
+  // get the name from the content
+  rapidjson::Value json_payload(rapidjson::kObjectType);
+
+  std::map<std::string, std::list<rapidjson::Value*>> children;
+
+  for (const auto &nested_payload : payload.getNestedPayloads()) {
+    rapidjson::Value* child_payload = new 
rapidjson::Value(serializeJsonPayload(nested_payload, alloc));
+    children[nested_payload.getLabel()].push_back(child_payload);
+  }
+
+  // child_vector is Pair<string, vector<Value*>>
+  for (auto child_vector : children) {
+    rapidjson::Value children_json;
+    rapidjson::Value newMemberKey = getStringValue(child_vector.first, alloc);
+
+    if (child_vector.second.size() > 1) {
+      children_json.SetArray();
+      for (auto child : child_vector.second)
+        children_json.PushBack(child->Move(), alloc);
+
+      json_payload.AddMember(newMemberKey, children_json, alloc);
+    } else if (child_vector.second.size() == 1) {
+      rapidjson::Value* first = child_vector.second.front();
+
+      if (first->IsObject() && first->HasMember(newMemberKey))
+        json_payload.AddMember(newMemberKey, (*first)[newMemberKey].Move(), 
alloc);
+      else
+        json_payload.AddMember(newMemberKey, first->Move(), alloc);
+    }
+
+    for (rapidjson::Value* child : child_vector.second)
+      delete child;
+  }
+
+  mergePayloadContent(json_payload, payload, alloc);
+
   return json_payload;
 }
 

http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/fd280b5c/libminifi/src/core/reporting/SiteToSiteProvenanceReportingTask.cpp
----------------------------------------------------------------------
diff --git a/libminifi/src/core/reporting/SiteToSiteProvenanceReportingTask.cpp 
b/libminifi/src/core/reporting/SiteToSiteProvenanceReportingTask.cpp
index 05fa6a8..c25fa64 100644
--- a/libminifi/src/core/reporting/SiteToSiteProvenanceReportingTask.cpp
+++ b/libminifi/src/core/reporting/SiteToSiteProvenanceReportingTask.cpp
@@ -37,8 +37,11 @@
 #include "provenance/Provenance.h"
 #include "FlowController.h"
 
-#include "json/json.h"
-#include "json/writer.h"
+#include "rapidjson/document.h"
+#include "rapidjson/writer.h"
+#include "rapidjson/stringbuffer.h"
+#include "rapidjson/prettywriter.h"
+
 
 namespace org {
 namespace apache {
@@ -53,54 +56,92 @@ void SiteToSiteProvenanceReportingTask::initialize() {
   RemoteProcessorGroupPort::initialize();
 }
 
+void setJsonStr(const std::string& key, const std::string& value, 
rapidjson::Value& parent, rapidjson::Document::AllocatorType& alloc) { // NOLINT
+  rapidjson::Value keyVal;
+  rapidjson::Value valueVal;
+  const char* c_key = key.c_str();
+  const char* c_val = value.c_str();
+
+  keyVal.SetString(c_key, key.length(), alloc);
+  valueVal.SetString(c_val, value.length(), alloc);
+
+  parent.AddMember(keyVal, valueVal, alloc);
+}
+
+rapidjson::Value getStringValue(const std::string& value, 
rapidjson::Document::AllocatorType& alloc) { // NOLINT
+  rapidjson::Value Val;
+  Val.SetString(value.c_str(), value.length(), alloc);
+  return Val;
+}
+
+void appendJsonStr(const std::string& value, rapidjson::Value& parent, 
rapidjson::Document::AllocatorType& alloc) { // NOLINT
+  rapidjson::Value valueVal;
+  const char* c_val = value.c_str();
+  valueVal.SetString(c_val, value.length(), alloc);
+  parent.PushBack(valueVal, alloc);
+}
+
 void SiteToSiteProvenanceReportingTask::getJsonReport(const 
std::shared_ptr<core::ProcessContext> &context, const 
std::shared_ptr<core::ProcessSession> &session,
                                                       
std::vector<std::shared_ptr<core::SerializableComponent>> &records, std::string 
&report) {
-  Json::Value array;
+  rapidjson::Document array(rapidjson::kArrayType);
+  rapidjson::Document::AllocatorType &alloc = array.GetAllocator();
+
   for (auto sercomp : records) {
     std::shared_ptr<provenance::ProvenanceEventRecord> record = 
std::dynamic_pointer_cast<provenance::ProvenanceEventRecord>(sercomp);
     if (nullptr == record) {
       break;
     }
-    Json::Value recordJson;
-    Json::Value updatedAttributesJson;
-    Json::Value parentUuidJson;
-    Json::Value childUuidJson;
-    recordJson["eventId"] = record->getEventId().c_str();
-    recordJson["eventType"] = 
provenance::ProvenanceEventRecord::ProvenanceEventTypeStr[record->getEventType()];
-    recordJson["timestampMillis"] = record->getEventTime();
-    recordJson["durationMillis"] = record->getEventDuration();
-    recordJson["lineageStart"] = record->getlineageStartDate();
-    recordJson["details"] = record->getDetails().c_str();
-    recordJson["componentId"] = record->getComponentId().c_str();
-    recordJson["componentType"] = record->getComponentType().c_str();
-    recordJson["entityId"] = record->getFlowFileUuid().c_str();
-    recordJson["entityType"] = "org.apache.nifi.flowfile.FlowFile";
-    recordJson["entitySize"] = record->getFileSize();
-    recordJson["entityOffset"] = record->getFileOffset();
+
+    rapidjson::Value recordJson(rapidjson::kObjectType);
+    rapidjson::Value updatedAttributesJson(rapidjson::kObjectType);
+    rapidjson::Value parentUuidJson(rapidjson::kArrayType);
+    rapidjson::Value childUuidJson(rapidjson::kArrayType);
+
+    recordJson.AddMember("timestampMillis", record->getEventTime(), alloc);
+    recordJson.AddMember("durationMillis", record->getEventDuration(), alloc);
+    recordJson.AddMember("lineageStart", record->getlineageStartDate(), alloc);
+    recordJson.AddMember("entitySize", record->getFileSize(), alloc);
+    recordJson.AddMember("entityOffset", record->getFileOffset(), alloc);
+
+    recordJson.AddMember("entityType", "org.apache.nifi.flowfile.FlowFile", 
alloc);
+
+    recordJson.AddMember("eventId", getStringValue(record->getEventId(), 
alloc), alloc);
+    recordJson.AddMember("eventType", 
getStringValue(provenance::ProvenanceEventRecord::ProvenanceEventTypeStr[record->getEventType()],
 alloc), alloc);
+    recordJson.AddMember("details", getStringValue(record->getDetails(), 
alloc), alloc);
+    recordJson.AddMember("componentId", 
getStringValue(record->getComponentId(), alloc), alloc);
+    recordJson.AddMember("componentType", 
getStringValue(record->getComponentType(), alloc), alloc);
+    recordJson.AddMember("entityId", getStringValue(record->getFlowFileUuid(), 
alloc), alloc);
+    recordJson.AddMember("transitUri", getStringValue(record->getTransitUri(), 
alloc), alloc);
+    recordJson.AddMember("remoteIdentifier", 
getStringValue(record->getSourceSystemFlowFileIdentifier(), alloc), alloc);
+    recordJson.AddMember("alternateIdentifier", 
getStringValue(record->getAlternateIdentifierUri(), alloc), alloc);
 
     for (auto attr : record->getAttributes()) {
-      updatedAttributesJson[attr.first] = attr.second;
+      setJsonStr(attr.first, attr.second, updatedAttributesJson, alloc);
     }
-    recordJson["updatedAttributes"] = updatedAttributesJson;
+    recordJson.AddMember("updatedAttributes", updatedAttributesJson, alloc);
 
     for (auto parentUUID : record->getParentUuids()) {
-      parentUuidJson.append(parentUUID.c_str());
+      appendJsonStr(parentUUID, parentUuidJson, alloc);
     }
-    recordJson["parentIds"] = parentUuidJson;
+    recordJson.AddMember("parentIds", parentUuidJson, alloc);
 
     for (auto childUUID : record->getChildrenUuids()) {
-      childUuidJson.append(childUUID.c_str());
+      appendJsonStr(childUUID, childUuidJson, alloc);
     }
-    recordJson["childIds"] = childUuidJson;
-    recordJson["transitUri"] = record->getTransitUri().c_str();
-    recordJson["remoteIdentifier"] = 
record->getSourceSystemFlowFileIdentifier().c_str();
-    recordJson["alternateIdentifier"] = 
record->getAlternateIdentifierUri().c_str();
-    recordJson["application"] = ProvenanceAppStr;
-    array.append(recordJson);
+    recordJson.AddMember("childIds", childUuidJson, alloc);
+
+    rapidjson::Value applicationVal;
+    applicationVal.SetString(ProvenanceAppStr, std::strlen(ProvenanceAppStr));
+    recordJson.AddMember("application", applicationVal, alloc);
+
+    array.PushBack(recordJson, alloc);
   }
 
-  Json::StyledWriter writer;
-  report = writer.write(array);
+  rapidjson::StringBuffer buffer;
+  rapidjson::PrettyWriter<rapidjson::StringBuffer> writer(buffer);
+  array.Accept(writer);
+
+  report = buffer.GetString();
 }
 
 void SiteToSiteProvenanceReportingTask::onSchedule(const 
std::shared_ptr<core::ProcessContext> &context, const 
std::shared_ptr<core::ProcessSessionFactory> &sessionFactory) {

http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/fd280b5c/libminifi/test/unit/ProcessorTests.cpp
----------------------------------------------------------------------
diff --git a/libminifi/test/unit/ProcessorTests.cpp 
b/libminifi/test/unit/ProcessorTests.cpp
index 2b91024..6e9ae83 100644
--- a/libminifi/test/unit/ProcessorTests.cpp
+++ b/libminifi/test/unit/ProcessorTests.cpp
@@ -324,7 +324,7 @@ TEST_CASE("Test Find file", "[getfileCreate3]") {
         taskReport->getJsonReport(context, session, recordsReport, jsonStr);
         REQUIRE(recordsReport.size() == 1);
         REQUIRE(taskReport->getName() == 
std::string(org::apache::nifi::minifi::core::reporting::SiteToSiteProvenanceReportingTask::ReportTaskName));
-        REQUIRE(jsonStr.find("\"componentType\" : \"getfileCreate2\"") != 
std::string::npos);
+        REQUIRE(jsonStr.find("\"componentType\": \"getfileCreate2\"") != 
std::string::npos);
       };
 
   testController.runSession(plan, false, verifyReporter);

http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/fd280b5c/main/CMakeLists.txt
----------------------------------------------------------------------
diff --git a/main/CMakeLists.txt b/main/CMakeLists.txt
index 174853e..36d01e8 100644
--- a/main/CMakeLists.txt
+++ b/main/CMakeLists.txt
@@ -23,7 +23,7 @@ IF(POLICY CMP0048)
   CMAKE_POLICY(SET CMP0048 OLD)
 ENDIF(POLICY CMP0048)
 
-include_directories(../libminifi/include  ../libminifi/include/c2  
../libminifi/include/c2/protocols/  ../libminifi/include/core/state 
./libminifi/include/core/statemanagement/metrics  
../libminifi/include/core/yaml  ../libminifi/include/core  
../thirdparty/spdlog-20170710/include ../thirdparty/concurrentqueue 
../thirdparty/yaml-cpp-yaml-cpp-20171024/include 
${CIVET_THIRDPARTY_ROOT}/include ../thirdparty/jsoncpp/include  ../thirdparty/)
+include_directories(../libminifi/include ../thirdparty/spdlog-20170710/include 
../thirdparty/concurrentqueue ../thirdparty/yaml-cpp-yaml-cpp-20171024/include 
../thirdparty/rapidjson-1.1.0/include ../thirdparty/)
 
 include(CheckCXXCompilerFlag)
 CHECK_CXX_COMPILER_FLAG("-std=c++11" COMPILER_SUPPORTS_CXX11)
@@ -51,7 +51,7 @@ find_package(UUID REQUIRED)
 find_package(OpenSSL REQUIRED)
 include_directories(${OPENSSL_INCLUDE_DIR})
 
-# Link against minifi, yaml-cpp, civetweb-cpp, uuid, openssl, jsoncpp and 
rocksdb
+# Link against minifi, yaml-cpp, civetweb-cpp, uuid, openssl, and rocksdb
 #target_link_libraries(minifiexe core-minifi)
 
 if (APPLE)
@@ -66,9 +66,7 @@ else ()
        target_link_libraries (minifiexe -Wl,--whole-archive minifi 
-Wl,--no-whole-archive)
 endif ()
 
-
-target_link_libraries(minifiexe yaml-cpp ${JSON_CPP_LIB} ${UUID_LIBRARIES} 
${OPENSSL_LIBRARIES})
-
+target_link_libraries(minifiexe yaml-cpp ${UUID_LIBRARIES} 
${OPENSSL_LIBRARIES})
 
 if (APPLE)
        get_property(extensions GLOBAL PROPERTY EXTENSION-OPTIONS)

http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/fd280b5c/thirdparty/jsoncpp/AUTHORS
----------------------------------------------------------------------
diff --git a/thirdparty/jsoncpp/AUTHORS b/thirdparty/jsoncpp/AUTHORS
deleted file mode 100644
index c0fbbee..0000000
--- a/thirdparty/jsoncpp/AUTHORS
+++ /dev/null
@@ -1 +0,0 @@
-Baptiste Lepilleur <b...@users.sourceforge.net>

http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/fd280b5c/thirdparty/jsoncpp/CMakeLists.txt
----------------------------------------------------------------------
diff --git a/thirdparty/jsoncpp/CMakeLists.txt 
b/thirdparty/jsoncpp/CMakeLists.txt
deleted file mode 100644
index a6c0884..0000000
--- a/thirdparty/jsoncpp/CMakeLists.txt
+++ /dev/null
@@ -1,156 +0,0 @@
-# vim: et ts=4 sts=4 sw=4 tw=0
-
-CMAKE_MINIMUM_REQUIRED(VERSION 3.1)
-PROJECT(jsoncpp)
-ENABLE_TESTING()
-
-OPTION(JSONCPP_WITH_TESTS "Compile and (for jsoncpp_check) run JsonCpp test 
executables" OFF)
-OPTION(JSONCPP_WITH_POST_BUILD_UNITTEST "Automatically run unit-tests as a 
post build step" OFF)
-OPTION(JSONCPP_WITH_WARNING_AS_ERROR "Force compilation to fail if a warning 
occurs" OFF)
-OPTION(JSONCPP_WITH_STRICT_ISO "Issue all the warnings demanded by strict ISO 
C and ISO C++" ON)
-OPTION(JSONCPP_WITH_PKGCONFIG_SUPPORT "Generate and install .pc files" ON)
-OPTION(JSONCPP_WITH_CMAKE_PACKAGE "Generate and install cmake package files" 
OFF)
-OPTION(BUILD_SHARED_LIBS "Build jsoncpp_lib as a shared library." OFF)
-OPTION(BUILD_STATIC_LIBS "Build jsoncpp_lib static library." ON)
-
-# Ensures that CMAKE_BUILD_TYPE is visible in cmake-gui on Unix
-IF(NOT WIN32)
-    IF(NOT CMAKE_BUILD_TYPE)
-        SET(CMAKE_BUILD_TYPE Release CACHE STRING
-            "Choose the type of build, options are: None Debug Release 
RelWithDebInfo MinSizeRel Coverage."
-            FORCE)
-    ENDIF()
-ENDIF()
-
-# Enable runtime search path support for dynamic libraries on OSX
-IF(APPLE)
-    SET(CMAKE_MACOSX_RPATH 1)
-ENDIF()
-
-# Adhere to GNU filesystem layout conventions
-INCLUDE(GNUInstallDirs)
-
-SET(DEBUG_LIBNAME_SUFFIX "" CACHE STRING "Optional suffix to append to the 
library name for a debug build")
-
-# Set variable named ${VAR_NAME} to value ${VALUE}
-FUNCTION(set_using_dynamic_name VAR_NAME VALUE)
-    SET( "${VAR_NAME}" "${VALUE}" PARENT_SCOPE)
-ENDFUNCTION()
-
-# Extract major, minor, patch from version text
-# Parse a version string "X.Y.Z" and outputs
-# version parts in ${OUPUT_PREFIX}_MAJOR, _MINOR, _PATCH.
-# If parse succeeds then ${OUPUT_PREFIX}_FOUND is TRUE.
-MACRO(jsoncpp_parse_version VERSION_TEXT OUPUT_PREFIX)
-    SET(VERSION_REGEX "[0-9]+\\.[0-9]+\\.[0-9]+(-[a-zA-Z0-9_]+)?")
-    IF( ${VERSION_TEXT} MATCHES ${VERSION_REGEX} )
-        STRING(REGEX MATCHALL "[0-9]+|-([A-Za-z0-9_]+)" VERSION_PARTS 
${VERSION_TEXT})
-        LIST(GET VERSION_PARTS 0 ${OUPUT_PREFIX}_MAJOR)
-        LIST(GET VERSION_PARTS 1 ${OUPUT_PREFIX}_MINOR)
-        LIST(GET VERSION_PARTS 2 ${OUPUT_PREFIX}_PATCH)
-        set_using_dynamic_name( "${OUPUT_PREFIX}_FOUND" TRUE )
-    ELSE( ${VERSION_TEXT} MATCHES ${VERSION_REGEX} )
-        set_using_dynamic_name( "${OUPUT_PREFIX}_FOUND" FALSE )
-    ENDIF()
-ENDMACRO()
-
-# Read out version from "version" file
-#FILE(STRINGS "version" JSONCPP_VERSION)
-#SET( JSONCPP_VERSION_MAJOR X )
-#SET( JSONCPP_VERSION_MINOR Y )
-#SET( JSONCPP_VERSION_PATCH Z )
-SET( JSONCPP_VERSION 1.8.0 )
-jsoncpp_parse_version( ${JSONCPP_VERSION} JSONCPP_VERSION )
-#IF(NOT JSONCPP_VERSION_FOUND)
-#    MESSAGE(FATAL_ERROR "Failed to parse version string properly. Expect 
X.Y.Z")
-#ENDIF(NOT JSONCPP_VERSION_FOUND)
-SET( JSONCPP_SOVERSION 11 )
-SET( JSONCPP_USE_SECURE_MEMORY "0" CACHE STRING "-D...=1 to use memory-wiping 
allocator for STL" )
-
-MESSAGE(STATUS "JsonCpp Version: 
${JSONCPP_VERSION_MAJOR}.${JSONCPP_VERSION_MINOR}.${JSONCPP_VERSION_PATCH}")
-# File version.h is only regenerated on CMake configure step
-CONFIGURE_FILE( "${PROJECT_SOURCE_DIR}/src/lib_json/version.h.in"
-                "${PROJECT_SOURCE_DIR}/include/json/version.h"
-                NEWLINE_STYLE UNIX )
-CONFIGURE_FILE( "${PROJECT_SOURCE_DIR}/version.in"
-                "${PROJECT_SOURCE_DIR}/version"
-                NEWLINE_STYLE UNIX )
-
-MACRO(UseCompilationWarningAsError)
-    IF(MSVC)
-        # Only enabled in debug because some old versions of VS STL generate
-        # warnings when compiled in release configuration.
-        SET(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /WX ")
-    ELSEIF(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-        SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror")
-        IF(JSONCPP_WITH_STRICT_ISO)
-            SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pedantic-errors")
-        ENDIF()
-    ENDIF()
-ENDMACRO()
-
-# Include our configuration header
-INCLUDE_DIRECTORIES( ${jsoncpp_SOURCE_DIR}/include )
-
-IF(MSVC)
-    # Only enabled in debug because some old versions of VS STL generate
-    # unreachable code warning when compiled in release configuration.
-    SET(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /W4 ")
-ENDIF()
-
-# Require C++11 support, prefer ISO C++ over GNU variants,
-# as relying solely on ISO C++ is more portable.
-SET(CMAKE_CXX_STANDARD 11)
-SET(CMAKE_CXX_STANDARD_REQUIRED ON)
-SET(CMAKE_CXX_EXTENSIONS OFF)
-
-IF(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-    # using regular Clang or AppleClang
-    SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wconversion -Wshadow 
-Werror=conversion -Werror=sign-compare")
-ELSEIF(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-    # using GCC
-    SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wconversion -Wshadow 
-Wextra")
-    # not yet ready for -Wsign-conversion
-
-    IF(JSONCPP_WITH_STRICT_ISO AND NOT JSONCPP_WITH_WARNING_AS_ERROR)
-        SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror=conversion -pedantic")
-    ENDIF()
-ELSEIF(CMAKE_CXX_COMPILER_ID STREQUAL "Intel")
-    # using Intel compiler
-    SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wconversion -Wshadow 
-Wextra -Werror=conversion")
-
-    IF(JSONCPP_WITH_STRICT_ISO AND NOT JSONCPP_WITH_WARNING_AS_ERROR)
-        SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pedantic")
-    ENDIF()
-ENDIF()
-
-FIND_PROGRAM(CCACHE_FOUND ccache)
-IF(CCACHE_FOUND)
-    SET_PROPERTY(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ccache)
-    SET_PROPERTY(GLOBAL PROPERTY RULE_LAUNCH_LINK ccache)
-ENDIF(CCACHE_FOUND)
-
-IF(JSONCPP_WITH_WARNING_AS_ERROR)
-    UseCompilationWarningAsError()
-ENDIF()
-
-IF(JSONCPP_WITH_PKGCONFIG_SUPPORT)
-    CONFIGURE_FILE(
-        "pkg-config/jsoncpp.pc.in"
-        "pkg-config/jsoncpp.pc"
-        @ONLY)
-    INSTALL(FILES "${CMAKE_CURRENT_BINARY_DIR}/pkg-config/jsoncpp.pc"
-        DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig")
-ENDIF()
-
-IF(JSONCPP_WITH_CMAKE_PACKAGE)
-        INSTALL(EXPORT jsoncpp
-                DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/jsoncpp
-                FILE        jsoncppConfig.cmake)
-ENDIF()
-
-# Build the different applications
-ADD_SUBDIRECTORY( src )
-
-#install the includes
-ADD_SUBDIRECTORY( include )

http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/fd280b5c/thirdparty/jsoncpp/LICENSE
----------------------------------------------------------------------
diff --git a/thirdparty/jsoncpp/LICENSE b/thirdparty/jsoncpp/LICENSE
deleted file mode 100644
index ca2bfe1..0000000
--- a/thirdparty/jsoncpp/LICENSE
+++ /dev/null
@@ -1,55 +0,0 @@
-The JsonCpp library's source code, including accompanying documentation, 
-tests and demonstration applications, are licensed under the following
-conditions...
-
-The author (Baptiste Lepilleur) explicitly disclaims copyright in all 
-jurisdictions which recognize such a disclaimer. In such jurisdictions, 
-this software is released into the Public Domain.
-
-In jurisdictions which do not recognize Public Domain property (e.g. Germany 
as of
-2010), this software is Copyright (c) 2007-2010 by Baptiste Lepilleur, and is
-released under the terms of the MIT License (see below).
-
-In jurisdictions which recognize Public Domain property, the user of this 
-software may choose to accept it either as 1) Public Domain, 2) under the 
-conditions of the MIT License (see below), or 3) under the terms of dual 
-Public Domain/MIT License conditions described here, as they choose.
-
-The MIT License is about as close to Public Domain as a license can get, and is
-described in clear, concise terms at:
-
-   http://en.wikipedia.org/wiki/MIT_License
-   
-The full text of the MIT License follows:
-
-========================================================================
-Copyright (c) 2007-2010 Baptiste Lepilleur
-
-Permission is hereby granted, free of charge, to any person
-obtaining a copy of this software and associated documentation
-files (the "Software"), to deal in the Software without
-restriction, including without limitation the rights to use, copy,
-modify, merge, publish, distribute, sublicense, and/or sell copies
-of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
-BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
-ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-========================================================================
-(END LICENSE TEXT)
-
-The MIT license is compatible with both the GPL and commercial
-software, affording one all of the rights of Public Domain with the
-minor nuisance of being required to keep the above copyright notice
-and license text in the source code. Note also that by accepting the
-Public Domain "license" you can re-license your copy using whatever
-license you like.

http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/fd280b5c/thirdparty/jsoncpp/NEWS.txt
----------------------------------------------------------------------
diff --git a/thirdparty/jsoncpp/NEWS.txt b/thirdparty/jsoncpp/NEWS.txt
deleted file mode 100644
index 5733fcd..0000000
--- a/thirdparty/jsoncpp/NEWS.txt
+++ /dev/null
@@ -1,175 +0,0 @@
-New in SVN
-----------
-
- *  Updated the type system's behavior, in order to better support backwards
-    compatibility with code that was written before 64-bit integer support was
-    introduced. Here's how it works now:
-
-     *  isInt, isInt64, isUInt, and isUInt64 return true if and only if the
-        value can be exactly represented as that type. In particular, a value
-        constructed with a double like 17.0 will now return true for all of
-        these methods.
-
-     *  isDouble and isFloat now return true for all numeric values, since all
-        numeric values can be converted to a double or float without
-        truncation. Note however that the conversion may not be exact -- for
-        example, doubles cannot exactly represent all integers above 2^53 + 1.
-
-     *  isBool, isNull, isString, isArray, and isObject now return true if and
-        only if the value is of that type.
-
-     *  isConvertibleTo(fooValue) indicates that it is safe to call asFoo.
-        (For each type foo, isFoo always implies isConvertibleTo(fooValue).)
-        asFoo returns an approximate or exact representation as appropriate.
-        For example, a double value may be truncated when asInt is called.
-
-     *  For backwards compatibility with old code, isConvertibleTo(intValue)
-        may return false even if type() == intValue. This is because the value
-        may have been constructed with a 64-bit integer larger than maxInt,
-        and calling asInt() would cause an exception. If you're writing new
-        code, use isInt64 to find out whether the value is exactly
-        representable using an Int64, or asDouble() combined with minInt64 and
-        maxInt64 to figure out whether it is approximately representable.
-
-* Value
-  - Patch #10: BOOST_FOREACH compatibility. Made Json::iterator more 
-    standard compliant, added missing iterator_category and value_type 
-       typedefs (contribued by Robert A. Iannucci).
-               
-* Compilation
-
-  - New CMake based build system. Based in part on contribution from
-    Igor Okulist and Damien Buhl (Patch #14).
-    
-  - New header json/version.h now contains version number macros
-    (JSONCPP_VERSION_MAJOR, JSONCPP_VERSION_MINOR, JSONCPP_VERSION_PATCH
-    and JSONCPP_VERSION_HEXA).
-
-  - Patch #11: added missing JSON_API on some classes causing link issues
-    when building as a dynamic library on Windows 
-       (contributed by Francis Bolduc).
-    
-  - Visual Studio DLL: suppressed warning "C4251: <data member>: <type> 
-    needs to have dll-interface to be used by..." via pragma push/pop
-    in json-cpp headers.
-    
-  - Added Travis CI intregration: https://travis-ci.org/blep/jsoncpp-mirror
-               
-* Bug fixes
-  - Patch #15: Copy constructor does not initialize allocated_ for stringValue
-    (contributed by rmongia).
-
-  - Patch #16: Missing field copy in Json::Value::iterator causing infinite 
-    loop when using experimental internal map (#define 
JSON_VALUE_USE_INTERNAL_MAP)
-       (contributed by Ming-Lin Kao).
-               
-
-  New in JsonCpp 0.6.0:
-  ---------------------
-
-* Compilation
-
-  - LD_LIBRARY_PATH and LIBRARY_PATH environment variables are now 
-    propagated to the build environment as this is required for some 
-    compiler installation.
-
-  - Added support for Microsoft Visual Studio 2008 (bug #2930462): 
-    The platform "msvc90" has been added.
-
-    Notes: you need to setup the environment by running vcvars32.bat 
-    (e.g. MSVC 2008 command prompt in start menu) before running scons.
-    
-  - Added support for amalgamated source and header generation (a la sqlite).
-    Refer to README.md section "Generating amalgamated source and header"
-    for detail.
-    
-* Value
-
-  - Removed experimental ValueAllocator, it caused static 
-    initialization/destruction order issues (bug #2934500). 
-    The DefaultValueAllocator has been inlined in code.
-    
-  - Added support for 64 bits integer:
-  
-    Types Json::Int64 and Json::UInt64 have been added. They are aliased
-       to 64 bits integers on system that support them (based on __int64 on 
-       Microsoft Visual Studio platform, and long long on other platforms).
-       
-       Types Json::LargestInt and Json::LargestUInt have been added. They are
-       aliased to the largest integer type supported: 
-       either Json::Int/Json::UInt or Json::Int64/Json::UInt64 respectively.
-       
-       Json::Value::asInt() and Json::Value::asUInt() still returns plain
-       "int" based types, but asserts if an attempt is made to retrieve
-       a 64 bits value that can not represented as the return type.
-       
-       Json::Value::asInt64() and Json::Value::asUInt64() have been added
-       to obtain the 64 bits integer value.
-       
-       Json::Value::asLargestInt() and Json::Value::asLargestUInt() returns
-       the integer as a LargestInt/LargestUInt respectively. Those functions
-       functions are typically used when implementing writer.
-       
-       The reader attempts to read number as 64 bits integer, and fall back
-       to reading a double if the number is not in the range of 64 bits 
-       integer.
-    
-    Warning: Json::Value::asInt() and Json::Value::asUInt() now returns
-    long long. This changes break code that was passing the return value
-    to *printf() function.
-  
-    Support for 64 bits integer can be disabled by defining the macro 
-       JSON_NO_INT64 (uncomment it in json/config.h for example), though
-       it should have no impact on existing usage.
-    
-  - The type Json::ArrayIndex is used for indexes of a JSON value array. It
-    is an unsigned int (typically 32 bits).
-       
-  - Array index can be passed as int to operator[], allowing use of literal:
-    Json::Value array;
-       array.append( 1234 );
-       int value = array[0].asInt();  // did not compile previously
-
-  - Added float Json::Value::asFloat() to obtain a floating point value as a
-    float (avoid lost of precision warning caused by used of asDouble() 
-    to initialize a float).
-
-* Reader
-
-  - Renamed Reader::getFormatedErrorMessages() to getFormattedErrorMessages.
-    Bug #3023708 (Formatted has 2 't'). The old member function is deprecated
-    but still present for backward compatibility.
-    
-* Tests
-
-  - Added test to ensure that the escape sequence "\/" is corrected handled 
-    by the parser.
-
-* Bug fixes
-
-  - Bug #3139677: JSON [1 2 3] was incorrectly parsed as [1, 3]. Error is now 
-    correctly detected.
-    
-  - Bug #3139678: stack buffer overflow when parsing a double with a
-    length of 32 characters.
-       
-  - Fixed Value::operator <= implementation (had the semantic of operator >=).
-    Found when adding unit tests for comparison operators.
-    
-  - Value::compare() is now const and has an actual implementation with
-    unit tests.
-
-  - Bug #2407932: strpbrk() can fail for NULL pointer.
-
-  - Bug #3306345: Fixed minor typo in Path::resolve().
-
-  - Bug #3314841/#3306896: errors in amalgamate.py
-
-  - Fixed some Coverity warnings and line-endings.
-    
-* License
-  
-  - See file LICENSE for details. Basically JsonCpp is now licensed under 
-    MIT license, or public domain if desired and recognized in your 
jurisdiction.
-    Thanks to Stephan G. Beal [http://wanderinghorse.net/home/stephan/]) who
-       helped figuring out the solution to the public domain issue.

http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/fd280b5c/thirdparty/jsoncpp/README.md
----------------------------------------------------------------------
diff --git a/thirdparty/jsoncpp/README.md b/thirdparty/jsoncpp/README.md
deleted file mode 100644
index 038ccd2..0000000
--- a/thirdparty/jsoncpp/README.md
+++ /dev/null
@@ -1,225 +0,0 @@
-# JsonCpp
-
-[JSON][json-org] is a lightweight data-interchange format. It can represent
-numbers, strings, ordered sequences of values, and collections of name/value
-pairs.
-
-[json-org]: http://json.org/
-
-JsonCpp is a C++ library that allows manipulating JSON values, including
-serialization and deserialization to and from strings. It can also preserve
-existing comment in unserialization/serialization steps, making it a convenient
-format to store user input files.
-
-
-## Documentation
-
-[JsonCpp documentation][JsonCpp-documentation] is generated using [Doxygen][].
-
-[JsonCpp-documentation]: 
http://open-source-parsers.github.io/jsoncpp-docs/doxygen/index.html
-[Doxygen]: http://www.doxygen.org
-
-
-## A note on backward-compatibility
-
-* `1.y.z` is built with C++11.
-* `0.y.z` can be used with older compilers.
-* Major versions maintain binary-compatibility.
-
-
-## Using JsonCpp in your project
-
-The recommended approach to integrating JsonCpp in your project is to include
-the [amalgamated source](#generating-amalgamated-source-and-header) (a single 
-`.cpp` file and two `.h` files) in your project, and compile and build as you 
-would any other source file. This ensures consistency of compilation flags and
-ABI compatibility, issues which arise when building shared or static 
-libraries. See the next section for instructions.
-  
-The `include/` should be added to your compiler include path. JsonCpp headers
-should be included as follow:
-
-    #include <json/json.h>
-
-If JsonCpp was built as a dynamic library on Windows, then your project needs 
to define the macro `JSON_DLL`.
-
-### Generating amalgamated source and header
-
-JsonCpp is provided with a script to generate a single header and a single
-source file to ease inclusion into an existing project. The amalgamated source
-can be generated at any time by running the following command from the
-top-directory (this requires Python 2.6):
-
-    python amalgamate.py
-
-It is possible to specify header name. See the `-h` option for detail.
-
-By default, the following files are generated:
-
-* `dist/jsoncpp.cpp`: source file that needs to be added to your project.
-* `dist/json/json.h`: corresponding header file for use in your project. It is
-  equivalent to including `json/json.h` in non-amalgamated source. This header
-  only depends on standard headers.
-* `dist/json/json-forwards.h`: header that provides forward declaration of all
-  JsonCpp types.
-
-The amalgamated sources are generated by concatenating JsonCpp source in the
-correct order and defining the macro `JSON_IS_AMALGAMATION` to prevent 
inclusion of other headers.
-
-
-## Contributing to JsonCpp
-
-### Building and testing with CMake
-
-[CMake][] is a C++ Makefiles/Solution generator. It is usually available on 
most Linux system as package. On Ubuntu:
-
-    sudo apt-get install cmake
-
-[CMake]: http://www.cmake.org
-
-Note that Python is also required to run the JSON reader/writer tests. If
-missing, the build will skip running those tests.
-
-When running CMake, a few parameters are required:
-
-* A build directory where the makefiles/solution are generated. It is also used
-  to store objects, libraries and executables files.
-* The generator to use: makefiles or Visual Studio solution? What version or
-  Visual Studio, 32 or 64 bits solution? 
-
-Steps for generating solution/makefiles using `cmake-gui`:
-
-* Make "source code" point to the source directory.
-* Make "where to build the binary" point to the directory to use for the build.
-* Click on the "Grouped" check box.
-* Review JsonCpp build options (tick `BUILD_SHARED_LIBS` to build as a
-  dynamic library).
-* Click the configure button at the bottom, then the generate button.
-* The generated solution/makefiles can be found in the binary directory.
-
-Alternatively, from the command-line on Unix in the source directory:
-
-    mkdir -p build/debug
-    cd build/debug
-    cmake -DCMAKE_BUILD_TYPE=debug -DBUILD_STATIC_LIBS=ON 
-DBUILD_SHARED_LIBS=OFF -DARCHIVE_INSTALL_DIR=. -G "Unix Makefiles" ../..
-    make
-
-For a good pkg-config file, add:
-
-    -DCMAKE_INSTALL_INCLUDEDIR=include/jsoncpp
-
-Running `cmake -h` will display the list of available generators (passed using
-the `-G` option).
-
-By default CMake hides compilation commands. This can be modified by specifying
-`-DCMAKE_VERBOSE_MAKEFILE=true` when generating makefiles.
-
-### Building and testing with SCons
-
-**Note:** The SCons-based build system is deprecated. Please use CMake (see the
-section above).
-
-JsonCpp can use [Scons][] as a build system. Note that SCons requires Python to
-be installed.
-
-[SCons]: http://www.scons.org/
-
-Invoke SCons as follows:
-
-    scons platform=$PLATFORM [TARGET]
-
-where `$PLATFORM` may be one of:
-
-* `suncc`: Sun C++ (Solaris)
-* `vacpp`: Visual Age C++ (AIX)
-* `mingw`
-* `msvc6`: Microsoft Visual Studio 6 service pack 5-6
-* `msvc70`: Microsoft Visual Studio 2002
-* `msvc71`: Microsoft Visual Studio 2003
-* `msvc80`: Microsoft Visual Studio 2005
-* `msvc90`: Microsoft Visual Studio 2008
-* `linux-gcc`: Gnu C++ (linux, also reported to work for Mac OS X)
-
-If you are building with Microsoft Visual Studio 2008, you need to set up the
-environment by running `vcvars32.bat` (e.g. MSVC 2008 command prompt) before
-running SCons.
-
-### Running the tests manually
-
-You need to run tests manually only if you are troubleshooting an issue.
-
-In the instructions below, replace `path/to/jsontest` with the path of the
-`jsontest` executable that was compiled on your platform.
-
-    cd test
-    # This will run the Reader/Writer tests
-    python runjsontests.py path/to/jsontest
-    
-    # This will run the Reader/Writer tests, using JSONChecker test suite
-    # (http://www.json.org/JSON_checker/).
-    # Notes: not all tests pass: JsonCpp is too lenient (for example,
-    # it allows an integer to start with '0'). The goal is to improve
-    # strict mode parsing to get all tests to pass.
-    python runjsontests.py --with-json-checker path/to/jsontest
-    
-    # This will run the unit tests (mostly Value)
-    python rununittests.py path/to/test_lib_json
-    
-    # You can run the tests using valgrind:
-    python rununittests.py --valgrind path/to/test_lib_json
-
-### Running the tests using SCons
-
-Note that tests can be run using SCons using the `check` target:
-
-    scons platform=$PLATFORM check
-
-### Building the documentation
-
-Run the Python script `doxybuild.py` from the top directory:
-
-    python doxybuild.py --doxygen=$(which doxygen) --open --with-dot
-
-See `doxybuild.py --help` for options.
-
-### Adding a reader/writer test
-
-To add a test, you need to create two files in test/data:
-
-* a `TESTNAME.json` file, that contains the input document in JSON format.
-* a `TESTNAME.expected` file, that contains a flatened representation of the
-  input document.
-
-The `TESTNAME.expected` file format is as follows:
-
-* Each line represents a JSON element of the element tree represented by the
-  input document.
-* Each line has two parts: the path to access the element separated from the
-  element value by `=`. Array and object values are always empty (i.e.
-  represented by either `[]` or `{}`).
-* Element path `.` represents the root element, and is used to separate object
-  members. `[N]` is used to specify the value of an array element at index `N`.
-
-See the examples `test_complex_01.json` and `test_complex_01.expected` to 
better understand element paths.
-
-### Understanding reader/writer test output
-
-When a test is run, output files are generated beside the input test files. 
Below is a short description of the content of each file:
-
-* `test_complex_01.json`: input JSON document.
-* `test_complex_01.expected`: flattened JSON element tree used to check if
-  parsing was corrected.
-* `test_complex_01.actual`: flattened JSON element tree produced by `jsontest`
-  from reading `test_complex_01.json`.
-* `test_complex_01.rewrite`: JSON document written by `jsontest` using the
-  `Json::Value` parsed from `test_complex_01.json` and serialized using
-  `Json::StyledWritter`.
-* `test_complex_01.actual-rewrite`: flattened JSON element tree produced by
-  `jsontest` from reading `test_complex_01.rewrite`.
-* `test_complex_01.process-output`: `jsontest` output, typically useful for
-  understanding parsing errors.
-
-## License
-
-See the `LICENSE` file for details. In summary, JsonCpp is licensed under the
-MIT license, or public domain if desired and recognized in your jurisdiction.

http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/fd280b5c/thirdparty/jsoncpp/SConstruct
----------------------------------------------------------------------
diff --git a/thirdparty/jsoncpp/SConstruct b/thirdparty/jsoncpp/SConstruct
deleted file mode 100644
index f3a73f7..0000000
--- a/thirdparty/jsoncpp/SConstruct
+++ /dev/null
@@ -1,248 +0,0 @@
-"""
-Notes: 
-- shared library support is buggy: it assumes that a static and dynamic 
library can be build from the same object files. This is not true on many 
platforms. For this reason it is only enabled on linux-gcc at the current time.
-
-To add a platform:
-- add its name in options allowed_values below
-- add tool initialization for this platform. Search for "if platform == 
'suncc'" as an example.
-"""
-
-import os
-import os.path
-import sys
-
-JSONCPP_VERSION = open(File('#version').abspath,'rt').read().strip()
-DIST_DIR = '#dist'
-
-options = Variables()
-options.Add( EnumVariable('platform',
-                        'Platform (compiler/stl) used to build the project',
-                        'msvc71',
-                        allowed_values='suncc vacpp mingw msvc6 msvc7 msvc71 
msvc80 msvc90 linux-gcc'.split(),
-                        ignorecase=2) )
-
-try:
-    platform = ARGUMENTS['platform']
-    if platform == 'linux-gcc':
-        CXX = 'g++' # not quite right, but env is not yet available.
-        import commands
-        version = commands.getoutput('%s -dumpversion' %CXX)
-        platform = 'linux-gcc-%s' %version
-        print "Using platform '%s'" %platform
-        LD_LIBRARY_PATH = os.environ.get('LD_LIBRARY_PATH', '')
-        LD_LIBRARY_PATH = "%s:libs/%s" %(LD_LIBRARY_PATH, platform)
-        os.environ['LD_LIBRARY_PATH'] = LD_LIBRARY_PATH
-        print "LD_LIBRARY_PATH =", LD_LIBRARY_PATH
-except KeyError:
-    print 'You must specify a "platform"'
-    sys.exit(2)
-
-print "Building using PLATFORM =", platform
-
-rootbuild_dir = Dir('#buildscons')
-build_dir = os.path.join( '#buildscons', platform )
-bin_dir = os.path.join( '#bin', platform )
-lib_dir = os.path.join( '#libs', platform )
-sconsign_dir_path = Dir(build_dir).abspath
-sconsign_path = os.path.join( sconsign_dir_path, '.sconsign.dbm' )
-
-# Ensure build directory exist (SConsignFile fail otherwise!)
-if not os.path.exists( sconsign_dir_path ):
-    os.makedirs( sconsign_dir_path )
-
-# Store all dependencies signature in a database
-SConsignFile( sconsign_path )
-
-def make_environ_vars():
-       """Returns a dictionnary with environment variable to use when 
compiling."""
-       # PATH is required to find the compiler
-       # TEMP is required for at least mingw
-    # LD_LIBRARY_PATH & co is required on some system for the compiler
-       vars = {}
-       for name in ('PATH', 'TEMP', 'TMP', 'LD_LIBRARY_PATH', 'LIBRARY_PATH'):
-               if name in os.environ:
-                       vars[name] = os.environ[name]
-       return vars
-       
-
-env = Environment( ENV = make_environ_vars(),
-                   toolpath = ['scons-tools'],
-                   tools=[] ) #, tools=['default'] )
-
-if platform == 'suncc':
-    env.Tool( 'sunc++' )
-    env.Tool( 'sunlink' )
-    env.Tool( 'sunar' )
-    env.Append( CCFLAGS = ['-mt'] )
-elif platform == 'vacpp':
-    env.Tool( 'default' )
-    env.Tool( 'aixcc' )
-    env['CXX'] = 'xlC_r'   #scons does not pick-up the correct one !
-    # using xlC_r ensure multi-threading is enabled:
-    # 
http://publib.boulder.ibm.com/infocenter/pseries/index.jsp?topic=/com.ibm.vacpp7a.doc/compiler/ref/cuselect.htm
-    env.Append( CCFLAGS = '-qrtti=all',
-                LINKFLAGS='-bh:5' )  # -bh:5 remove duplicate symbol warning
-elif platform == 'msvc6':
-    env['MSVS_VERSION']='6.0'
-    for tool in ['msvc', 'msvs', 'mslink', 'masm', 'mslib']:
-        env.Tool( tool )
-    env['CXXFLAGS']='-GR -GX /nologo /MT'
-elif platform == 'msvc70':
-    env['MSVS_VERSION']='7.0'
-    for tool in ['msvc', 'msvs', 'mslink', 'masm', 'mslib']:
-        env.Tool( tool )
-    env['CXXFLAGS']='-GR -GX /nologo /MT'
-elif platform == 'msvc71':
-    env['MSVS_VERSION']='7.1'
-    for tool in ['msvc', 'msvs', 'mslink', 'masm', 'mslib']:
-        env.Tool( tool )
-    env['CXXFLAGS']='-GR -GX /nologo /MT'
-elif platform == 'msvc80':
-    env['MSVS_VERSION']='8.0'
-    for tool in ['msvc', 'msvs', 'mslink', 'masm', 'mslib']:
-        env.Tool( tool )
-    env['CXXFLAGS']='-GR -EHsc /nologo /MT'
-elif platform == 'msvc90':
-    env['MSVS_VERSION']='9.0'
-    # Scons 1.2 fails to detect the correct location of the platform SDK.
-    # So we propagate those from the environment. This requires that the
-    # user run vcvars32.bat before compiling.
-    if 'INCLUDE' in os.environ:
-        env['ENV']['INCLUDE'] = os.environ['INCLUDE']
-    if 'LIB' in os.environ:
-        env['ENV']['LIB'] = os.environ['LIB']
-    for tool in ['msvc', 'msvs', 'mslink', 'masm', 'mslib']:
-        env.Tool( tool )
-    env['CXXFLAGS']='-GR -EHsc /nologo /MT'
-elif platform == 'mingw':
-    env.Tool( 'mingw' )
-    env.Append( CPPDEFINES=[ "WIN32", "NDEBUG", "_MT" ] )
-elif platform.startswith('linux-gcc'):
-    env.Tool( 'default' )
-    env.Append( LIBS = ['pthread'], CCFLAGS = os.environ.get("CXXFLAGS", 
"-Wall"), LINKFLAGS=os.environ.get("LDFLAGS", "") )
-    env['SHARED_LIB_ENABLED'] = True
-else:
-    print "UNSUPPORTED PLATFORM."
-    env.Exit(1)
-
-env.Tool('targz')
-env.Tool('srcdist')
-env.Tool('globtool')
-
-env.Append( CPPPATH = ['#include'],
-            LIBPATH = lib_dir )
-short_platform = platform
-if short_platform.startswith('msvc'):
-    short_platform = short_platform[2:]
-# Notes: on Windows you need to rebuild the source for each variant
-# Build script does not support that yet so we only build static libraries.
-# This also fails on AIX because both dynamic and static library ends with
-# extension .a.
-env['SHARED_LIB_ENABLED'] = env.get('SHARED_LIB_ENABLED', False)
-env['LIB_PLATFORM'] = short_platform
-env['LIB_LINK_TYPE'] = 'lib'    # static
-env['LIB_CRUNTIME'] = 'mt'
-env['LIB_NAME_SUFFIX'] = '${LIB_PLATFORM}_${LIB_LINK_TYPE}${LIB_CRUNTIME}'  # 
must match autolink naming convention
-env['JSONCPP_VERSION'] = JSONCPP_VERSION
-env['BUILD_DIR'] = env.Dir(build_dir)
-env['ROOTBUILD_DIR'] = env.Dir(rootbuild_dir)
-env['DIST_DIR'] = DIST_DIR
-if 'TarGz' in env['BUILDERS']:
-       class SrcDistAdder:
-               def __init__( self, env ):
-                       self.env = env
-               def __call__( self, *args, **kw ):
-                       apply( self.env.SrcDist, (self.env['SRCDIST_TARGET'],) 
+ args, kw )
-       env['SRCDIST_BUILDER'] = env.TarGz
-else: # If tarfile module is missing
-       class SrcDistAdder:
-               def __init__( self, env ):
-                       pass
-               def __call__( self, *args, **kw ):
-                       pass
-env['SRCDIST_ADD'] = SrcDistAdder( env )
-env['SRCDIST_TARGET'] = os.path.join( DIST_DIR, 'jsoncpp-src-%s.tar.gz' % 
env['JSONCPP_VERSION'] )
-                      
-env_testing = env.Clone( )
-env_testing.Append( LIBS = ['json_${LIB_NAME_SUFFIX}'] )
-
-def buildJSONExample( env, target_sources, target_name ):
-    env = env.Clone()
-    env.Append( CPPPATH = ['#'] )
-    exe = env.Program( target=target_name,
-                       source=target_sources )
-    env['SRCDIST_ADD']( source=[target_sources] )
-    global bin_dir
-    return env.Install( bin_dir, exe )
-
-def buildJSONTests( env, target_sources, target_name ):
-    jsontests_node = buildJSONExample( env, target_sources, target_name )
-    check_alias_target = env.Alias( 'check', jsontests_node, RunJSONTests( 
jsontests_node, jsontests_node ) )
-    env.AlwaysBuild( check_alias_target )
-
-def buildUnitTests( env, target_sources, target_name ):
-    jsontests_node = buildJSONExample( env, target_sources, target_name )
-    check_alias_target = env.Alias( 'check', jsontests_node, 
-                                    RunUnitTests( jsontests_node, 
jsontests_node ) )
-    env.AlwaysBuild( check_alias_target )
-
-def buildLibrary( env, target_sources, target_name ):
-    static_lib = env.StaticLibrary( target=target_name + '_${LIB_NAME_SUFFIX}',
-                                    source=target_sources )
-    global lib_dir
-    env.Install( lib_dir, static_lib )
-    if env['SHARED_LIB_ENABLED']:
-        shared_lib = env.SharedLibrary( target=target_name + 
'_${LIB_NAME_SUFFIX}',
-                                        source=target_sources )
-        env.Install( lib_dir, shared_lib )
-    env['SRCDIST_ADD']( source=[target_sources] )
-
-Export( 'env env_testing buildJSONExample buildLibrary buildJSONTests 
buildUnitTests' )
-
-def buildProjectInDirectory( target_directory ):
-    global build_dir
-    target_build_dir = os.path.join( build_dir, target_directory )
-    target = os.path.join( target_directory, 'sconscript' )
-    SConscript( target, build_dir=target_build_dir, duplicate=0 )
-    env['SRCDIST_ADD']( source=[target] )
-
-
-def runJSONTests_action( target, source = None, env = None ):
-    # Add test scripts to python path
-    jsontest_path = Dir( '#test' ).abspath
-    sys.path.insert( 0, jsontest_path )
-    data_path = os.path.join( jsontest_path, 'data' )
-    import runjsontests
-    return runjsontests.runAllTests( os.path.abspath(source[0].path), 
data_path )
-
-def runJSONTests_string( target, source = None, env = None ):
-    return 'RunJSONTests("%s")' % source[0]
-
-import SCons.Action
-ActionFactory = SCons.Action.ActionFactory
-RunJSONTests = ActionFactory(runJSONTests_action, runJSONTests_string )
-
-def runUnitTests_action( target, source = None, env = None ):
-    # Add test scripts to python path
-    jsontest_path = Dir( '#test' ).abspath
-    sys.path.insert( 0, jsontest_path )
-    import rununittests
-    return rununittests.runAllTests( os.path.abspath(source[0].path) )
-
-def runUnitTests_string( target, source = None, env = None ):
-    return 'RunUnitTests("%s")' % source[0]
-
-RunUnitTests = ActionFactory(runUnitTests_action, runUnitTests_string )
-
-env.Alias( 'check' )
-
-srcdist_cmd = env['SRCDIST_ADD']( source = """
-    AUTHORS README.md SConstruct
-    """.split() )
-env.Alias( 'src-dist', srcdist_cmd )
-
-buildProjectInDirectory( 'src/jsontestrunner' )
-buildProjectInDirectory( 'src/lib_json' )
-buildProjectInDirectory( 'src/test_lib_json' )
-#print env.Dump()
-

http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/fd280b5c/thirdparty/jsoncpp/amalgamate.py
----------------------------------------------------------------------
diff --git a/thirdparty/jsoncpp/amalgamate.py b/thirdparty/jsoncpp/amalgamate.py
deleted file mode 100644
index 9cb2d08..0000000
--- a/thirdparty/jsoncpp/amalgamate.py
+++ /dev/null
@@ -1,155 +0,0 @@
-"""Amalgate json-cpp library sources into a single source and header file.
-
-Works with python2.6+ and python3.4+.
-
-Example of invocation (must be invoked from json-cpp top directory):
-python amalgate.py
-"""
-import os
-import os.path
-import sys
-
-class AmalgamationFile:
-    def __init__(self, top_dir):
-        self.top_dir = top_dir
-        self.blocks = []
-
-    def add_text(self, text):
-        if not text.endswith("\n"):
-            text += "\n"
-        self.blocks.append(text)
-
-    def add_file(self, relative_input_path, wrap_in_comment=False):
-        def add_marker(prefix):
-            self.add_text("")
-            self.add_text("// " + "/"*70)
-            self.add_text("// %s of content of file: %s" % (prefix, 
relative_input_path.replace("\\","/")))
-            self.add_text("// " + "/"*70)
-            self.add_text("")
-        add_marker("Beginning")
-        f = open(os.path.join(self.top_dir, relative_input_path), "rt")
-        content = f.read()
-        if wrap_in_comment:
-            content = "/*\n" + content + "\n*/"
-        self.add_text(content)
-        f.close()
-        add_marker("End")
-        self.add_text("\n\n\n\n")
-
-    def get_value(self):
-        return "".join(self.blocks).replace("\r\n","\n")
-
-    def write_to(self, output_path):
-        output_dir = os.path.dirname(output_path)
-        if output_dir and not os.path.isdir(output_dir):
-            os.makedirs(output_dir)
-        f = open(output_path, "wb")
-        f.write(str.encode(self.get_value(), 'UTF-8'))
-        f.close()
-
-def amalgamate_source(source_top_dir=None,
-                       target_source_path=None,
-                       header_include_path=None):
-    """Produces amalgated source.
-       Parameters:
-           source_top_dir: top-directory
-           target_source_path: output .cpp path
-           header_include_path: generated header path relative to 
target_source_path.
-    """
-    print("Amalgating header...")
-    header = AmalgamationFile(source_top_dir)
-    header.add_text("/// Json-cpp amalgated header 
(http://jsoncpp.sourceforge.net/).")
-    header.add_text('/// It is intended to be used with #include "%s"' % 
header_include_path)
-    header.add_file("LICENSE", wrap_in_comment=True)
-    header.add_text("#ifndef JSON_AMALGATED_H_INCLUDED")
-    header.add_text("# define JSON_AMALGATED_H_INCLUDED")
-    header.add_text("/// If defined, indicates that the source file is 
amalgated")
-    header.add_text("/// to prevent private header inclusion.")
-    header.add_text("#define JSON_IS_AMALGAMATION")
-    header.add_file("include/json/version.h")
-    #header.add_file("include/json/allocator.h") # Not available here.
-    header.add_file("include/json/config.h")
-    header.add_file("include/json/forwards.h")
-    header.add_file("include/json/features.h")
-    header.add_file("include/json/value.h")
-    header.add_file("include/json/reader.h")
-    header.add_file("include/json/writer.h")
-    header.add_file("include/json/assertions.h")
-    header.add_text("#endif //ifndef JSON_AMALGATED_H_INCLUDED")
-
-    target_header_path = os.path.join(os.path.dirname(target_source_path), 
header_include_path)
-    print("Writing amalgated header to %r" % target_header_path)
-    header.write_to(target_header_path)
-
-    base, ext = os.path.splitext(header_include_path)
-    forward_header_include_path = base + "-forwards" + ext
-    print("Amalgating forward header...")
-    header = AmalgamationFile(source_top_dir)
-    header.add_text("/// Json-cpp amalgated forward header 
(http://jsoncpp.sourceforge.net/).")
-    header.add_text('/// It is intended to be used with #include "%s"' % 
forward_header_include_path)
-    header.add_text("/// This header provides forward declaration for all 
JsonCpp types.")
-    header.add_file("LICENSE", wrap_in_comment=True)
-    header.add_text("#ifndef JSON_FORWARD_AMALGATED_H_INCLUDED")
-    header.add_text("# define JSON_FORWARD_AMALGATED_H_INCLUDED")
-    header.add_text("/// If defined, indicates that the source file is 
amalgated")
-    header.add_text("/// to prevent private header inclusion.")
-    header.add_text("#define JSON_IS_AMALGAMATION")
-    header.add_file("include/json/config.h")
-    header.add_file("include/json/forwards.h")
-    header.add_text("#endif //ifndef JSON_FORWARD_AMALGATED_H_INCLUDED")
-
-    target_forward_header_path = 
os.path.join(os.path.dirname(target_source_path),
-                                               forward_header_include_path)
-    print("Writing amalgated forward header to %r" % 
target_forward_header_path)
-    header.write_to(target_forward_header_path)
-
-    print("Amalgating source...")
-    source = AmalgamationFile(source_top_dir)
-    source.add_text("/// Json-cpp amalgated source 
(http://jsoncpp.sourceforge.net/).")
-    source.add_text('/// It is intended to be used with #include "%s"' % 
header_include_path)
-    source.add_file("LICENSE", wrap_in_comment=True)
-    source.add_text("")
-    source.add_text('#include "%s"' % header_include_path)
-    source.add_text("""
-#ifndef JSON_IS_AMALGAMATION
-#error "Compile with -I PATH_TO_JSON_DIRECTORY"
-#endif
-""")
-    source.add_text("")
-    lib_json = "src/lib_json"
-    source.add_file(os.path.join(lib_json, "json_tool.h"))
-    source.add_file(os.path.join(lib_json, "json_reader.cpp"))
-    source.add_file(os.path.join(lib_json, "json_valueiterator.inl"))
-    source.add_file(os.path.join(lib_json, "json_value.cpp"))
-    source.add_file(os.path.join(lib_json, "json_writer.cpp"))
-
-    print("Writing amalgated source to %r" % target_source_path)
-    source.write_to(target_source_path)
-
-def main():
-    usage = """%prog [options]
-Generate a single amalgated source and header file from the sources.
-"""
-    from optparse import OptionParser
-    parser = OptionParser(usage=usage)
-    parser.allow_interspersed_args = False
-    parser.add_option("-s", "--source", dest="target_source_path", 
action="store", default="dist/jsoncpp.cpp",
-        help="""Output .cpp source path. [Default: %default]""")
-    parser.add_option("-i", "--include", dest="header_include_path", 
action="store", default="json/json.h",
-        help="""Header include path. Used to include the header from the 
amalgated source file. [Default: %default]""")
-    parser.add_option("-t", "--top-dir", dest="top_dir", action="store", 
default=os.getcwd(),
-        help="""Source top-directory. [Default: %default]""")
-    parser.enable_interspersed_args()
-    options, args = parser.parse_args()
-
-    msg = amalgamate_source(source_top_dir=options.top_dir,
-                             target_source_path=options.target_source_path,
-                             header_include_path=options.header_include_path)
-    if msg:
-        sys.stderr.write(msg + "\n")
-        sys.exit(1)
-    else:
-        print("Source succesfully amalagated")
-
-if __name__ == "__main__":
-    main()

http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/fd280b5c/thirdparty/jsoncpp/appveyor.yml
----------------------------------------------------------------------
diff --git a/thirdparty/jsoncpp/appveyor.yml b/thirdparty/jsoncpp/appveyor.yml
deleted file mode 100644
index f4966a3..0000000
--- a/thirdparty/jsoncpp/appveyor.yml
+++ /dev/null
@@ -1,35 +0,0 @@
-# This is a comment.
-
-version: build.{build}
-
-os: Windows Server 2012 R2
-
-clone_folder: c:\projects\jsoncpp
-
-platform:
-    - Win32
-    - x64
-
-configuration:
-    - Debug
-    - Release
-
-# scripts to run before build
-before_build:
-    - echo "Running cmake..."
-    - cd c:\projects\jsoncpp
-    - cmake --version
-    - set PATH=C:\Program Files (x86)\MSBuild\14.0\Bin;%PATH%
-    - if %PLATFORM% == Win32 cmake .
-    - if %PLATFORM% == x64 cmake -G "Visual Studio 12 2013 Win64" .
-
-build:
-    project: jsoncpp.sln        # path to Visual Studio solution or project
-
-deploy:
-    provider: GitHub
-    auth_token:
-        secure: 
K2Tp1q8pIZ7rs0Ot24ZMWuwr12Ev6Tc6QkhMjGQxoQG3ng1pXtgPasiJ45IDXGdg
-    on:
-        branch: master
-        appveyor_repo_tag: true

http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/fd280b5c/thirdparty/jsoncpp/dev.makefile
----------------------------------------------------------------------
diff --git a/thirdparty/jsoncpp/dev.makefile b/thirdparty/jsoncpp/dev.makefile
deleted file mode 100644
index d288b16..0000000
--- a/thirdparty/jsoncpp/dev.makefile
+++ /dev/null
@@ -1,35 +0,0 @@
-# This is only for jsoncpp developers/contributors.
-# We use this to sign releases, generate documentation, etc.
-VER?=$(shell cat version)
-
-default:
-       @echo "VER=${VER}"
-sign: jsoncpp-${VER}.tar.gz
-       gpg --armor --detach-sign $<
-       gpg --verify $<.asc
-       # Then upload .asc to the release.
-jsoncpp-%.tar.gz:
-       curl https://github.com/open-source-parsers/jsoncpp/archive/$*.tar.gz 
-o $@
-dox:
-       python doxybuild.py --doxygen=$$(which doxygen) --in doc/web_doxyfile.in
-       rsync -va --delete dist/doxygen/jsoncpp-api-html-${VER}/ 
../jsoncpp-docs/doxygen/
-       # Then 'git add -A' and 'git push' in jsoncpp-docs.
-build:
-       mkdir -p build/debug
-       cd build/debug; cmake -DCMAKE_BUILD_TYPE=debug -DBUILD_SHARED_LIBS=ON 
-G "Unix Makefiles" ../..
-       make -C build/debug
-
-# Currently, this depends on include/json/version.h generated
-# by cmake.
-test-amalgamate:
-       python2.7 amalgamate.py
-       python3.4 amalgamate.py
-       cd dist; gcc -I. -c jsoncpp.cpp
-
-valgrind:
-       valgrind --error-exitcode=42 --leak-check=full 
./build/debug/src/test_lib_json/jsoncpp_test
-
-clean:
-       \rm -rf *.gz *.asc dist/
-
-.PHONY: build

Reply via email to