Merge pull request #135 from SynBioDex/develop

Merge for release 2.1.1

Author: bbartley

CMakeLists.txt

@@ -5,27 +5,27 @@ PROJECT( SBOL )
 # set up folder structure
 SET( SBOL_ROOT_DIR          ${CMAKE_CURRENT_SOURCE_DIR} )
 SET( SBOL_SOURCE_DIR        ${SBOL_ROOT_DIR}/source     )
-SET( SBOL_EXAMPLE_DIR       ${SBOL_ROOT_DIR}/examples   )
-SET( SBOL_TEST_DIR          ${SBOL_ROOT_DIR}/tests      )
+SET( SBOL_EXAMPLE_DIR       ${SBOL_ROOT_DIR}/example   )
+SET( SBOL_TEST_DIR          ${SBOL_ROOT_DIR}/test      )
 SET( SBOL_MANUAL_DIR        ${SBOL_ROOT_DIR}/manual     )
 SET( SBOL_WRAPPER_DIR       ${SBOL_ROOT_DIR}/wrapper    )
 SET( SBOL_BUILD_DIR         ${SBOL_ROOT_DIR}/build      )
 SET( SBOL_RELEASE_DIR       ${SBOL_ROOT_DIR}/release    )
-SET( EXECUTABLE_OUTPUT_PATH ${SBOL_RELEASE_DIR}         )
-SET( LIBRARY_OUTPUT_PATH    ${SBOL_RELEASE_DIR}/library )
+SET( SBOL_EXECUTABLE_OUTPUT_PATH ${SBOL_RELEASE_DIR}         )
+SET( SBOL_LIBRARY_OUTPUT_PATH    ${SBOL_RELEASE_DIR}/library )
+
 IF (${CMAKE_SYSTEM_NAME} MATCHES "Windows")
-    SET( HEADER_OUTPUT_PATH		${LIBRARY_OUTPUT_PATH}/include )
+    SET( HEADER_OUTPUT_PATH		${SBOL_LIBRARY_OUTPUT_PATH}/include )
 ELSE()
-    SET( HEADER_OUTPUT_PATH		${LIBRARY_OUTPUT_PATH}/sbol )
+    SET( HEADER_OUTPUT_PATH		${SBOL_LIBRARY_OUTPUT_PATH}/sbol )
 ENDIF()
 
 # set build options
-OPTION( SBOL_BUILD_STATIC     "Build statically linked library"           TRUE )
+#OPTION( SBOL_BUILD_STATIC     "Build statically linked library"           TRUE )
 OPTION( SBOL_BUILD_SHARED     "Build dynamically linked library"           FALSE )
 #OPTION( SBOL_BUILD_COMBINED  "Build libSBOL and Raptor RDF archives combined" FALSE )
 #OPTION( SBOL_DEBUG_STATEMENTS "Add some print statements for debugging"   FALSE )
 #OPTION( SBOL_BUILD_EXAMPLES   "Build the example programs"                FALSE )
-#OPTION( SBOL_BUILD_TESTS      "Build the unit tests and example tests"    FALSE )
 if(CMAKE_SIZEOF_VOID_P EQUAL 8)
 	OPTION( SBOL_BUILD_32      "Build on x86 architecture" FALSE )
 	OPTION( SBOL_BUILD_64      "Build on x64 architecture" TRUE)
@@ -38,6 +38,7 @@ OPTION( SBOL_BUILD_PYTHON3  "Generate Python version 3 wrapper using SWIG" FALSE
 OPTION( SBOL_BUILD_MANUAL  "Generate SBOL documentation using Doxygen" FALSE )
 OPTION( SBOL_BUILD_JSON  "Build JsonCpp library (for Linux users primarily)" FALSE)
 OPTION( SBOL_BUILD_OSX_DIST  "For pySBOL distributions on Mac, target frameworks back to OSX 10.9" FALSE)
+OPTION( SBOL_BUILD_TESTS      "Build the unit tests and example tests"    FALSE )
 
 # -fPIC from boost Python
 set (CMAKE_POSITION_INDEPENDENT_CODE TRUE)
@@ -62,9 +63,9 @@ ADD_SUBDIRECTORY( source )
 #ENDIF()
 
 # build tests
-#IF( SBOL_BUILD_TESTS )
-#    ADD_SUBDIRECTORY( tests )
-#ENDIF()
+IF( SBOL_BUILD_TESTS )
+    ADD_SUBDIRECTORY( test )
+ENDIF()
 
 # generate documentation
 IF( SBOL_BUILD_MANUAL )

Repression_Circuit.pdf

@@ -2224,7 +2224,7 @@ CLASS_GRAPH            = YES
 # The default value is: YES.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
-COLLABORATION_GRAPH    = YES
+COLLABORATION_GRAPH    = NO
 
 # If the GROUP_GRAPHS tag is set to YES then doxygen will generate a graph for
 # groups, showing the direct groups dependencies.

manual/Doxyfile

@@ -146,6 +146,7 @@
 /// $ g++ -std=c++11 -I../source -I/usr/local/include/raptor2 -L/usr/local/lib -lraptor2 -ljsoncpp -lcurl -lsbol client_app.cpp -o client_app 
 /// $ ./client_app
 /// ```
+/// Here, -I flags specify paths to include folders with necessary header files. -L flag specifies path to the libSBOL library. -o flag specifies the file name of the output. Change the values according to your setup.
 ///
 /// @section visual_studio Creating a Visual Studio project on Windows
 /// 

manual/getting_started.dox

@@ -1,19 +1,17 @@
 //////////////////////////////////////////////////////////////////////
 /// @page installation Installation
 ///
-/// We provide two ways to install libSBOL: Using the binary installers or building from the source.
+/// On Windows, installation through binary installers is the simplest way to obtain libSBOL. The installer contains pre-compiled libSBOL library. Simply install it to whichever path you want and use it.
 ///
-/// For help configuring a client project, see @ref visual_studio or @ref xcode.
-///
-/// @section binary_installers Download Binary Installers
-/// 
 /// [Get the latest binary installers](https://github.com/SynBioDex/libSBOL/releases/latest)
 ///
-/// Installation through binary installers is the simplest way to obtain libSBOL.
-/// 
-/// Installer contains pre-compiled libSBOL library. Simply install it to whichever path you want and use it.
-/// Currently, we only distribute binary installers for Windows and Mac OSX.
+/// On MacOSX, installation via the [Homebrew](http://brew.sh) package manager is easiest. Install libSBOL by running the following command in terminal:
+/// ```
+/// brew install homebrew/science/libsbol
+/// ```
+/// For help configuring a client project, see @ref visual_studio or @ref xcode.
 ///
+/// Instructions for building from source are also provided below.
 ///
 /// @section build_from_source Build from Source
 ///
@@ -25,37 +23,27 @@
 /// * OPTIONAL: [Doxygen](http://www.stack.nl/~dimitri/doxygen/) for creating documentation
 /// * OPTIONAL: [SWIG](http://www.swig.org/) for generating Python wrappers
 /// 
-/// All the development has been done using "default native compilers" and MinGW on Windows or Unix makefiles on Mac/Linux. CMake can be used to generate projects for Eclipse, Visual Studio, XCode, etc. 
+/// All the development has been done using "default native compilers" and Visual Studio on Windows or Unix makefiles on Mac/Linux. CMake can be used to generate projects for Eclipse, MinGW, XCode, etc. 
+///
+/// For more details on running libSBOL on Mac, check @ref xcode. For more details on running libSBOL on Windows using Visual Studio, check @ref visual_studio.
 ///
-/// If you don't want to use CMake to generate make files, following is an example command line for building the library on Mac:
-/// ```
-/// $ mkdir release
-/// $ cd release
-/// $ g++ -c ../source/*.cpp -I../source -I/usr/local/include/raptor2 -std=c++11
-/// $ ar rcs libsbol.a *.o
-/// ```
-/// For more details on running libSBOL on Mac, check @ref xcode.
 /// ![Screenshot of Cmake-gui in Windows](cmakescreen.png)
 ///
 /// Windows
 /// -------
-/// 1. [Install git for Windows](https://git-scm.com/)
-/// 
-/// 2. [Install CMake for Windows](https://cmake.org/download/)
+/// 1. [Install git for Windows](https://git-scm.com/) and [CMake for Windows](https://cmake.org/download/).
 ///
-/// 3. Clone the repository by running the following command in git application or command console or get the stable source [here](https://github.com/SynBioDex/libSBOL/releases/latest):
+/// 2. Clone the repository by running the following command in git application or command console or get the stable source [here](https://github.com/SynBioDex/libSBOL/releases/latest):
 /// ```
 /// git clone https://github.com/SynBioDex/libSBOL.git
 /// ```
 /// This will create a libSBOL directory with the source.
 ///
-/// 4. Run CMake-gui. For "Where is the source code" enter the path to your libSBOL folder (not libSBOL/source folder). Choose build path by setting "Where to build the binaries". After setting the paths, click Configure, and choose what type of compiler you want to generate instructions for (e.g. Visual Studio 14 2015 for 32 bit and Visual Studio 14 2015 Win64 for 64 bit). See the screenshot above.
+/// 3. Run CMake-gui. For "Where is the source code" enter the path to your libSBOL folder (not libSBOL/source folder). Choose build path by setting "Where to build the binaries". After setting the paths, click Configure, and choose what type of compiler you want to generate instructions for (e.g. Visual Studio 14 2015 for 32 bit and Visual Studio 14 2015 Win64 for 64 bit). See the screenshot above.
 ///
-/// 5. (optional) Set optional targets, e.g. examples, tests, manual, or Python wrapper. To add them check the appropriate boxes and then press Configure again. CMAKE_INSTALL_PREFIX is of particular interest, since it determines the path the output will be located. Building Python wrapper requires SWIG.
-///
-///   SBOL_BUILD_STATIC: Builds static archive. Enabled by default on Windows
+/// 4. (optional) Set optional targets, e.g. examples, tests, manual, or Python wrapper. To add them check the appropriate boxes and then press Configure again. CMAKE_INSTALL_PREFIX is of particular interest, since it determines the path the output will be located. Building Python wrapper requires SWIG.
 ///
-///   SBOL_BUILD_SHARED: Currently unavailable on Windows
+///   SBOL_BUILD_SHARED: Builds a dynamically linked library. The default is static.
 ///
 ///   SBOL_BUILD_32: Build for 32-bit architectures
 ///
@@ -68,9 +56,10 @@
 ///   If you want to try either 32 bit or 64 bit version of libSBOL, make sure you are using the right type of compiler. (Visual Studio 14 2015 vs Visual Studio 14 2015 Win64).
 ///   For Python bindings, you need SWIG and Python libraries. CMake will try to look it up for you, but if it cannot, specify the path manually.
 ///
-/// 6. Once it's all set, click Generate to create the compiler instructions.
+/// 5. Once it's all set, click Generate to create the compiler instructions.
 /// 
-/// 7. The last step is to build the libraries. We recommend minGW or Visual Studio 2015 for this purpose. When building, make sure that you are building for 'release' target.
+/// 6. The last step is to build the libraries. We recommend Visual Studio 2015 or minGW for this purpose. When building, make sure that you are building for 'release' target.
+/// When using Visual Studio, open 'SBOL.sln' under 'build' folder. On the Solution Explorer to the right, right click INSTALL and press Build. The library will be located under the folder you specified in CMAKE_INSTALL_PREFIX.
 /// When using minGW, first go to 'build' folder and run the compiler by using
 /// ```
 /// mingw32-make
@@ -80,9 +69,8 @@
 /// mingw32-make install
 /// ```
 /// You will need administrator privileges for a make install.
-/// When using Visual Studio, open 'SBOL.sln' under 'build' folder. On the Solution Explorer to the right, right click INSTALL and press Build. The library will be located under the folder you specified in CMAKE_INSTALL_PREFIX.
 ///
-/// 8. (optional) For Python bindings, copy and paste the sbol folder with Python bindings to your local Python site-packages folder.
+/// 7. (optional) For Python bindings, copy and paste the sbol folder with Python bindings to your local Python site-packages folder.
 ///
 ///
 /// Mac
@@ -95,24 +83,17 @@
 /// ```
 /// This will create a libSBOL directory with the source.
 ///
-/// 3. LibSBOL depends on the RaptorRDF library which can be obtained using the [Homebrew](brew.sh) package manager. Install Raptor by running the following command in terminal:
+/// 3. LibSBOL depends on the RaptorRDF library which can be obtained using the [Homebrew](http://brew.sh) package manager. Install Raptor by running the following command in terminal:
 /// ```
 /// brew install raptor jsoncpp libxslt curl
 /// ```
 /// Homebrew isn’t the only option. Other package installers are MacPorts and Fink.
 ///
-/// 4. You can use the cmake utility on Mac as well. One important difference about CMake on Mac versus Windows is that there is no GUI application.  However, there is an interactive utility that runs in a terminal window.
-/// ```
-/// ccmake .
-/// ```
-///
-/// 5. For "Where is the source code" enter the path to your libSBOL folder (not libSBOL/source folder). Choose build path by setting "Where to build the binaries". After setting the paths, click Configure, and choose what type of compiler you want to generate instructions for. 
+/// 4. Run CMake-gui (type cmake in terminal or run cmake app). For "Where is the source code" enter the path to your libSBOL folder (not libSBOL/source folder). Choose build path by setting "Where to build the binaries". After setting the paths, click Configure, and choose what type of compiler you want to generate instructions for. 
 /// 
-/// 6. (optional) Set optional targets, e.g. examples, tests, manual, or Python wrapper. To add them check the appropriate boxes and then press Configure again. CMAKE_INSTALL_PREFIX is of particular interest, since it determines the path the output will be located. By default on Mac OSX, the library will be installed to /usr/local/lib. Building Python wrapper requires SWIG.
-///
-///   SBOL_BUILD_STATIC: Builds static archive.
+/// 5. (optional) Set optional targets, e.g. examples, tests, manual, or Python wrapper. To add them check the appropriate boxes and then press Configure again. CMAKE_INSTALL_PREFIX is of particular interest, since it determines the path the output will be located. By default on Mac OSX, the library will be installed to /usr/local/lib. Building Python wrapper requires SWIG.
 ///
-///   SBOL_BUILD_SHARED: Builds a dynamically linked library
+///   SBOL_BUILD_SHARED: Builds a dynamically linked library. The default is static.
 ///
 ///   SBOL_BUILD_32: Build for 32-bit architectures.
 ///
@@ -124,9 +105,9 @@
 ///
 ///   For Python bindings, you need SWIG and Python libraries. CMake will try to look it up for you, but if it cannot, specify the path manually.
 ///
-/// 7. Once it's all set, click Generate to create the compiler instructions.
+/// 6. Once it's all set, click Generate to create the compiler instructions.
 ///
-/// 8. In terminal, go to the build directory and run:
+/// 7. In terminal, go to the build directory and run:
 /// ```
 /// make 
 /// ```
@@ -154,24 +135,17 @@
 /// sudo apt-get install swig python-dev
 /// ```
 ///
-/// 3. (optional) To update the documentation you will need Doxygen. To install run: 
-/// ```
-/// sudo apt-get install doxygen-gui
-/// ```
-///
-/// 4. Clone the repository by running the following command in terminal or get the stable source [here](https://github.com/SynBioDex/libSBOL/releases/latest).
+/// 3. Clone the repository by running the following command in terminal or get the stable source [here](https://github.com/SynBioDex/libSBOL/releases/latest).
 /// ```
 /// git clone https://github.com/SynBioDex/libSBOL.git
 /// ```
 /// This will create a libSBOL directory with the source. 
 ///
-/// 5. Run CMake-gui (type cmake-gui or cmake-qt-gui in terminal). For "Where is the source code" enter the path to your libSBOL folder (not libSBOL/source folder). Choose build path by setting "Where to build the binaries". After setting the paths, click Configure, and choose what type of compiler you want to generate instructions for. See the screenshot above.
+/// 4. Run CMake-gui (type cmake-gui or cmake-qt-gui in terminal). For "Where is the source code" enter the path to your libSBOL folder (not libSBOL/source folder). Choose build path by setting "Where to build the binaries". After setting the paths, click Configure, and choose what type of compiler you want to generate instructions for. See the screenshot above.
 /// 
-/// 6. (optional) Set optional targets, e.g. examples, tests, manual, or Python wrapper. To add them check the appropriate boxes and then press Configure again. CMAKE_INSTALL_PREFIX is of particular interest, since it determines the path the output will be located. Building Python wrapper requires SWIG.
-///
-///   SBOL_BUILD_STATIC: Builds static archive.
+/// 5. (optional) Set optional targets, e.g. examples, tests, manual, or Python wrapper. To add them check the appropriate boxes and then press Configure again. CMAKE_INSTALL_PREFIX is of particular interest, since it determines the path the output will be located. Building Python wrapper requires SWIG.
 ///
-///   SBOL_BUILD_SHARED: Builds a dynamically linked library
+///   SBOL_BUILD_SHARED: Builds a dynamically linked library. The default is static.
 ///
 ///   SBOL_BUILD_32: Build for 32-bit architectures.
 ///
@@ -187,9 +161,9 @@
 ///   sudo apt-get python3.5-dev
 ///   ```
 ///
-/// 7. Once it's all set, click Generate to create the compiler instructions.
+/// 6. Once it's all set, click Generate to create the compiler instructions.
 /// 
-/// 8. The last step is to build the libraries. In terminal, first go to 'build' folder and run the compiler by using:
+/// 7. The last step is to build the libraries. In terminal, first go to 'build' folder and run the compiler by using:
 /// ```
 /// make install
 /// ```
@@ -199,7 +173,7 @@
 /// ```
 /// to compile. The library will be located under the folder you specified in CMAKE_INSTALL_PREFIX.
 ///
-/// 9. (optional) For Python bindings, you might want to add the path of Python bindings as part of PYTHONPATH environment. To do so, run:
+/// 8. (optional) For Python bindings, you might want to add the path of Python bindings as part of PYTHONPATH environment. To do so, run:
 /// ```
 /// export PYTHONPATH=$PYTHONPATH:/path-to-your-Python-bindings
 /// ```