Methods to combine one project into another - c++

Question

I have a library that depends on jsoncpp, which is a json parser written in C++. At the moment, jsoncpp is stable and not updated very often. It also has been released into the public domain. Now, in order to build the library, there's a dependency on SCons and Python, which works, but is an annoyance to some of my users. Rather than have them download jsoncpp, SCons, Python, and then build the library themselves, I could include the code into my project directly and build everything together. However, this causes some problems.
Primarily, if I include the jsoncpp code into my library, then my library contains the jsoncpp symbols. If a user tries to embed my library into one that already depends on jsoncpp, there's a symbol conflict. What's the correct way to deal with this issue? For example, I could compile my library and jsoncpp separately and distribute both libraries. If the user already has jsoncpp, they could link their own version. Alternatively, I could modify the jsoncpp code and push everything into a new namespace, but this seems cumbersome.
If it helps, I build everything in CMake, so if there's a CMake trick for dealing with this, that's best.
EDIT
Based on Fraser's suggestion, I have the following.
$ find .
.
./build
./build/jsoncpp-src-0.6.0-rc2.tar.gz
./src
./src/cpp
./src/cpp/hello.cpp
./src/cpp/CMakeLists.txt
./src/thirdparty
./src/thirdparty/jsoncpp
./src/thirdparty/jsoncpp/CMakeLists.txt
./src/thirdparty/CMakeLists.txt
./src/CMakeLists.txt
$ cat ./src/cpp/hello.cpp
#include <cstdlib>
#include <iostream>
#include <fstream>
#include <iomanip>
#include "json/json.h"
// Parses a JSON file and returns the root
void parse(const std::string& fname,Json::Value& root) {
// Read in the input file
Json::Reader reader;
std::ifstream file(fname.c_str(),std::ifstream::in);
bool parsingSuccessful = reader.parse( file, root, true );
if (!parsingSuccessful) {
std::cerr << "Failed to parse the optimization parameter "
"file: " << reader.getFormattedErrorMessages() << std::endl;
exit(EXIT_FAILURE);
}
// Close everything out
file.close();
}
int main(int argc,char* argv[]) {
// Make sure we have the correct number of arguments
if(argc!=2) {
std::cout << "hello <json>" << std::endl;
return EXIT_FAILURE;
}
// Parse the JSON files
Json::Value root;
parse(argv[1],root);
// Get the hello string
std::string hello = root["Hello"].get("Message","Hello World!").asString();
// Tell everyone
std::cout << hello << std::endl;
return EXIT_SUCCESS;
}
$ cat ./src/cpp/CMakeLists.txt
project(hello)
cmake_minimum_required(VERSION 2.8.9)
enable_language(CXX)
# Set the location of jsoncpp
find_library(JSONCPP_LIBRARY
NAMES json libjson
PATHS ${CMAKE_BINARY_DIR}/installed/lib)
set(JSONCPP_LIBRARIES ${JSONCPP_LIBRARY} )
set(JSONCPP_INCLUDE_DIRS ${CMAKE_BINARY_DIR}/installed/include)
# Locate the headers
include_directories(${JSONCPP_INCLUDE_DIRS})
# Build the executable
add_executable(hello hello.cpp)
# Link jsoncpp
target_link_libraries(hello ${JSONCPP_LIBRARIES})
$ cat ./src/thirdparty/jsoncpp/CMakeLists.txt
project(jsoncpp)
cmake_minimum_required(VERSION 2.8.9)
enable_language(CXX)
# Set the source file prefix
set(source_prefix ${CMAKE_CURRENT_SOURCE_DIR}/src/lib_json/)
# Save the include directory
set(JSONCPP_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIRI}/include)
# Grab all the sources for the library
set(jsoncpp_srcs
"${source_prefix}/json_reader.cpp"
"${source_prefix}/json_value.cpp"
"${source_prefix}/json_writer.cpp"
)
# Locate the headers
include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include)
# Compile everything
set(CMAKE_POSITION_INDEPENDENT_CODE ON)
add_library(jsoncpp_object OBJECT ${jsoncpp_srcs})
add_library(jsoncpp_static STATIC $<TARGET_OBJECTS:jsoncpp_object> )
add_library(jsoncpp_shared SHARED $<TARGET_OBJECTS:jsoncpp_object> )
set_target_properties(jsoncpp_shared jsoncpp_static
PROPERTIES OUTPUT_NAME json)
# Install the libraries and headers
install(TARGETS jsoncpp_static jsoncpp_shared DESTINATION lib)
install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/include/json DESTINATION include)
$ cat ./src/thirdparty/CMakeLists.txt
project(third_party_libraries)
cmake_minimum_required(VERSION 2.8.9)
# Build jsoncpp
include(ExternalProject)
ExternalProject_Add(
JsonCpp
URL ${CMAKE_BINARY_DIR}/jsoncpp-src-0.6.0-rc2.tar.gz
URL_MD5 363e2f4cbd3aeb63bf4e571f377400fb
PATCH_COMMAND ${CMAKE_COMMAND} -E copy
"${CMAKE_CURRENT_SOURCE_DIR}/jsoncpp/CMakeLists.txt"
CMakeLists.txt
CMAKE_ARGS -DCMAKE_INSTALL_PREFIX:PATH=${CMAKE_BINARY_DIR}/installed
)
$ cat ./src/CMakeLists.txt
project(hello_example)
cmake_minimum_required(VERSION 2.8.9)
# First, build our TPLs
add_subdirectory(thirdparty)
# Then, build our target
add_subdirectory(cpp)
Basically, we use CMake's ExternalProject script in order to compile and install jsoncpp locally to the build directory. Once the library has been installed, we can link our executables to it. Since jsoncpp doesn't contain a CMakeLists.txt, we use the patch procedure to insert an appropriate CMake script into the jsoncpp source structure. In a fancier build script, we could choose whether or not to use this build procedure or have he user specify the library directly.
In any case, perhaps someone else will find this useful. It simplifies the build setup for some users, but doesn't bundle all of the symbols into some mega library.

Answer 1

If you want to try and keep all the users happy (I know - not possible!), you could add an option for each dependency, e.g. option(BuildJsonCpp).
If the option is ON, you build the dependency, otherwise you include it using find_library and find_path or find_package.
For building the dependencies, rather than including the sources, you could consider the ExternalProject CMake module. This module is used to download, configure, build and install external projects, and allows the external project to be contained entirely in your build tree - not your source tree.
This would allow you to keep just your own source files in your project, making it smaller and more relevant - especially for users not wishing to build the dependencies.
It will make your CMake files a bit more complex and harder to maintain, but I guess that's the price you have to pay if you want to make the build system more flexible.