# 环境
ubuntu:bionic的docker image
```shell
docker run -it ubuntu:bionic
```
预装工具
```shell
apt-get install cmake
```
# 安装conan
```shell
# pip3 install conan
Collecting conan
# conan -v
Conan version 1.33.0
```
# 使用conan
>官方文档：https://docs.conan.io/en/latest/getting_started.html

## 搜索包
```shell
# conan search poco --remote=conan-center
WARN: Remotes registry file missing, creating default one in /root/.conan/remotes.json
Existing package recipes:
poco/1.8.1          <<< 已有的版本
poco/1.9.3
poco/1.9.4
poco/1.10.0
poco/1.10.1
```
## 导入包
```shell
# conan inspect poco/1.9.4
poco/1.9.4: Not found in local cache, looking in remotes...
poco/1.9.4: Trying with 'conan-center'...
Downloading conanmanifest.txt completed [0.59k]                         
Downloading conanfile.py completed [12.59k]                            
Downloading conan_export.tgz completed [0.30k]              
Decompressing conan_export.tgz completed [0.00k]       
poco/1.9.4: Downloaded recipe revision 0
name: poco
version: 1.9.4
url: https://github.com/conan-io/conan-center-index
homepage: https://pocoproject.org
license: BSL-1.0
```

## 编译
```shell
# conan profile new default --detect
Found gcc 7
Found clang 6.0
gcc>=5, using the major as version

************************* WARNING: GCC OLD ABI COMPATIBILITY ***********************
 
Conan detected a GCC version > 5 but has adjusted the 'compiler.libcxx' setting to
'libstdc++' for backwards compatibility.
Your compiler is likely using the new CXX11 ABI by default (libstdc++11).

If you want Conan to use the new ABI for the default profile, run:

    $ conan profile update settings.compiler.libcxx=libstdc++11 default

Or edit '/root/.conan/profiles/default' and set compiler.libcxx=libstdc++11

************************************************************************************

# conan profile update settings.compiler.libcxx=libstdc++11 default
```
准备三个文件放在同一个目录如：`conan`中
```
conan$ ls
CMakeLists.txt  conanfile.txt md5.cpp

文件内容：

conan$ cat conanfile.txt 
[requires]
 poco/1.9.4

 [generators]
 cmake
 
conan$ cat md5.cpp 
#include "Poco/MD5Engine.h"
#include "Poco/DigestStream.h"

#include <iostream>

int main(int argc, char** argv){
    Poco::MD5Engine md5;
    Poco::DigestOutputStream ds(md5);
    ds << "abcdefghijklmnopqrstuvwxyz";
    ds.close();
    std::cout << Poco::DigestEngine::digestToHex(md5.digest()) << std::endl;
    return 0;
}

conan$ cat CMakeLists.txt 
cmake_minimum_required(VERSION 2.8.12)
 project(MD5Encrypter)

 add_definitions("-std=c++11")

 include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake)
 conan_basic_setup()

 add_executable(md5 md5.cpp)
 target_link_libraries(md5 ${CONAN_LIBS})
 ```
 ## conan编译
```shell
conan# mkdir build && cd build
build# conan install ..
Configuration:
[settings]
arch=x86_64
arch_build=x86_64
build_type=Release
compiler=gcc
compiler.libcxx=libstdc++11
compiler.version=7
os=Linux
os_build=Linux
conanfile.txt: Generated conaninfo.txt
conanfile.txt: Generated graphinfo

build# cmake .. -G "Unix Makefiles" -DCMAKE_BUILD_TYPE=Release
-- The C compiler identification is GNU 7.5.0
-- The CXX compiler identification is GNU 7.5.0
-- Configuring done
-- Generating done
-- Build files have been written to: /root/build

build# cmake --build .
Scanning dependencies of target md5
[ 50%] Building CXX object CMakeFiles/md5.dir/md5.cpp.o
[100%] Linking CXX executable bin/md5
[100%] Built target md5

build# ls
CMakeCache.txt  Makefile  cmake_install.cmake  conanbuildinfo.cmake  conaninfo.txt
CMakeFiles      bin       conan.lock           conanbuildinfo.txt    graph_info.json

build# ./bin/md5
c3fcd3d76192e4007dfb496cca67e13b
```
环境完成！

## 打包项目
>官网打包教程：https://docs.conan.io/en/latest/creating_packages/getting_started.html

下面要解决的问题是conanfile.txt中的conan包是怎么生成的。按照官网的打包步骤走了一遍，把源码打包成一个conan包。假设我们要将一个hello的源码打包成一个conan包

### 准备源码
```shell
# mkdir mypkg && cd mypkg
//这里会从github上下载hello的程序
/mypkg# conan new hello/0.1 -t  
```
### 编译成conan包
+ 方法1：
```shell
/mypkg# conan create . demo/testing
[100%] Built target example
hello/0.1@demo/testing (test package): Running test()
Hello World Release!         <<< 执行hello程序
```
+ 方法2：

上面的编译步骤等价于
```shell
/mypkg# conan export . demo/testing
/mypkg# conan install hello/0.1@demo/testing --build=hello
# package is created now, use test to test it
/mypkg# conan test test_package hello/0.1@demo/testing
hello/0.1@demo/testing (test package): Running test()
Hello World Release!         <<< 执行hello程序
```
### 查看生成的包
```shell
# conan search hello 
Existing package recipes:

hello/0.1@demo/testing
```
说明已经将hello的程序源码打包成了conan包。

conan 将自己的项目生成conan包

Conan 是 C 和 C++ 语言的依赖项和包管理器。它是免费和开源的，适用于所有平台（Windows、Linux、OSX、FreeBSD、Solaris 等），可用于开发所有目标，包括嵌入式、移动（iOS、Android）和裸机。它还与 CMake、Visual Studio (MSBuild)、Makefiles、SCons 等所有构建系统集成，包括专有系统。
它专为加速 C 和 C++ 项目的开发和持续集成而设计和优化。通过完整的二进制包管理，它可以为任意数量的不同版本的包创建和重用任意数量的不同二进制文件（用于不同的配置，如架构、编译器版本等），在所有平台上使用完全相同的过程。由于它是去中心化的，因此很容易运行自己的服务器来私下托管自己的包和二进制文件，而无需共享它们。@《Conan官方文档》

在之前的博客《conan入门(四):conan 引用第三方库示例》中我们以cJSON为例说明了如何在项目中引用一个conan 包。

如何将自己设计的模块以conan包形式打包提供给第三方(客户/同事)使用?

本文将以一个基于 cJSON 库实现字符串解析的模块 jsonlib,说明如何将自己的模块封装成conan提供给第三方使用。

jsonlib示例程序

示例的所有源码都保存在GIT仓库 conan_example的jsonlib分支,请直接克隆代码到本地：

git clone https://gitee.com/l0km/conan_example.git -b jsonlib
# -b jsonlib 切换到 jsonlib 分支,等价于 'git checkout jsonlib' 命令 

jsonlib是个很简单的库，只有两个文件：jsonlib.h,jsonlib.c，只实现了一个功能从JSON字符串中解析name指定的字段内容,结果保存到输出缓冲区,JSON解析的工作实际上是调用cJSON来实现的。以下是实现源码。

src/jsonlib.h

/*
 * jsonlib.h
 *  conan example for library
 *  Created on: 2022/02/18
 *      Author: guyadong
 */

#ifndef SRC_JSONLIB_H_
#define SRC_JSONLIB_H_
#ifndef JSONLIB_DLL_DECL
#  if defined(_WIN32) && !defined(__CYGWIN__) && defined(JSONLIB_IS_DLL)
#    if defined(JSONLIB_EXPORTS)
#      define JSONLIB_DLL_DECL  __declspec(dllexport)
#    else
#      define JSONLIB_DLL_DECL  __declspec(dllimport)
#    endif
#  else
#    define JSONLIB_DLL_DECL
#  endif
#endif
#include <stddef.h>
#ifdef __cplusplus
extern "C"
{
#endif

//************************************
// 从JSON字符串中解析name指定的字段内容,结果保存到输出缓冲区
// @param    const char * cjs JSON 字符串
// @param    const char * name 字段名
// @param    char * buffer [out] 输出缓冲区
// @param    size_t bufsz 输出缓冲区长度
// @return   int 成功返回0,否则返回-1
//************************************
JSONLIB_DLL_DECL int jlib_parse_field(const char* cjs,const char*name, char*buffer,size_t bufsz);
#ifdef __cplusplus
}
#endif
#endif /* SRC_JSONLIB_H_ */

src/jsonlib.c

#include "jsonlib.h"
#include <cjson/cJSON.h>
#include <string.h>
#include <stdlib.h>

JSONLIB_DLL_DECL int jlib_parse_field(const char* cjs,const char*name, char*buffer,size_t bufsz)
{
    int c = -1;
    if(cjs && name && buffer && bufsz)
    {
        cJSON* j = cJSON_Parse(cjs);
        if(j)
        {
            cJSON* item = cJSON_GetObjectItem(j,name);
            if(item)
            {
                char* s = cJSON_PrintUnformatted(item);
                if(s && strlen(s) < bufsz)
                {
					strncpy(buffer, s, bufsz);
					c = 0;
                }
                free(s);
            }
        }
        cJSON_Delete(j);
    }
    return c;
}

CMakeLists.txt

cmake_minimum_required(VERSION 3.10.3)
# 3.0以上版本才允许使用VERSION option
project(JsonTest VERSION 1.0.0 LANGUAGES C)
find_package(cJSON REQUIRED)
add_library(jsonlib src/jsonlib.c)
set_target_properties(jsonlib PROPERTIES PUBLIC_HEADER "src/jsonlib.h")
target_link_libraries(jsonlib PUBLIC cjson)
target_compile_definitions(jsonlib 
    PRIVATE $<$<STREQUAL:$<TARGET_PROPERTY:TYPE>,SHARED_LIBRARY>:JSONLIB_EXPORTS>
    PUBLIC $<$<STREQUAL:$<TARGET_PROPERTY:TYPE>,SHARED_LIBRARY>:JSONLIB_IS_DLL>
)

conan new

现在 jsonlib.h,jsonlib.c,CMakeLists.txt三个文件构成了一个简单但完整的标准CMake项目。

conan_example
│  CMakeLists.txt
│      
└─src
       jsonlib.c
       jsonlib.h

怎么把这个小项目封装为conan包呢？如果你看过我的上一篇博客《conan入门(六):conanfile.txt conanfile.py的区别》以及《conan入门(一):conan 及 JFrog Artifactory 安装》就差不多可以知道，一个conan包最关键的就是需要有一个conanfile.py脚本来定义包的各种配置。

但是要手写一个conanfile.py好像还挺麻烦的，我对python也是只知皮毛。

显然手写是不可能的，conan new 命令就是用于创建一个新的conan配置文件模板。有了模板，在之上修改就可以了：

$ conan new jsonlib/1.0.0 --template cmake_lib
File saved: CMakeLists.txt
File saved: conanfile.py
File saved: src/jsonlib.cpp
File saved: src/jsonlib.h
File saved: test_package/CMakeLists.txt
File saved: test_package/conanfile.py
File saved: test_package/src/example.cpp

conan new jsonlib/1.0.0 --template cmake_lib执行后生成的目录结构如下，可以看到conan很贴心的生成了conanfile.py，jsonlib的源码文件及CMakeLists.txt以及对应的测试代码(test_package)—这是一个完整的conan包项目框架，虽然它不是想我们需要的内容,但有了这个框架总比从头开始写要方便得多：

conan_example
│  CMakeLists.txt
│  conanfile.py
│  
├─src
│      jsonlib.cpp
│      jsonlib.h
│      
└─test_package
    │  CMakeLists.txt
    │  conanfile.py
    │  
    └─src
            example.cpp

上面执行 conan new 命令使用的 --template cmake_lib 参数是Conan的一项目还在实验中的功能,根据指定模板生成Conan项目框架，详细说明参见Conan官方文档:《Package scaffolding for conan new command》

conan new命令的详细说明参见Conan官方文档《conan new》

update jsonlib

现在我们在Conan生成的项目框架上，把jsonlib装进去。

conanfile.py

首先如下图修改conanfile.py

CMakeLists.txt

如下图将conan new 生成的CMakeLists.txt的内容合并到jsonlib的CMakeLists.txt中

jsonlib.h jsonlib.c

src/jsonlib.c替换conan new 生成的src/jsonlib.cpp,

src/jsonlib.h 替换conan new生成的src/jsonlib.h

example.cpp

将conan new生成的test_package/src/example.cpp替换为如下代码,实现简单的jsonlib接口测试

test_package/src/example.cpp

#include <stdio.h>
#include <jsonlib.h>

int main(int argc, char** argv)
{
    char jstr[] = "{\"hello\":\"world\"}";
    printf("JSON:%s\n",jstr);

    char fieldbuf[32];
    int c = jlib_parse_field(jstr,"hello",fieldbuf,sizeof(fieldbuf));
    if(0 == c){
        printf("parsed 'hello' field:  %s\n",fieldbuf);
    }

    return 0;
}

conan create (编译jsonlib)

创建了conanfile.py后，编译conan包非常简单

# 注意是 conan_example jsonlib分支
$ cd conan_example
$ conan create .
Exporting package recipe
jsonlib/1.0.0 exports_sources: Copied 1 '.txt' file: CMakeLists.txt
jsonlib/1.0.0 exports_sources: Copied 1 '.c' file: jsonlib.c
jsonlib/1.0.0 exports_sources: Copied 1 '.h' file: jsonlib.h
jsonlib/1.0.0: A new conanfile.py version was exported
jsonlib/1.0.0: Folder: C:\Users\guyadong\.conan\data\jsonlib\1.0.0\_\_\export
jsonlib/1.0.0: Exported revision: 5f5439068d01c7592ebbcb724712ce89
.....
.....
Capturing current environment in deactivate_conanrunenv-release-x86_64.bat
Configuring environment variables
JSON:{"hello":"world"}
parsed 'hello' field:  "world"

conan create .根据配置文件 (同级文件夹下的conanfile.py) 构建二进制包
conan create 命令行用法参见Conan官方文档《conan create》

conan create执行成功后,就会将生成的二进制包保存在本地仓库$HOME/.conan/data/jsonlib/1.0.0/_/_package

执行conan search jsonlib/1.0.0@会显示二进制包的信息

conan upload(上传到私有制品库)

项目编译成功就可以上执行conan upload传到私有制品库了：

conan upload jsonlib/1.0.0  -r ${repo} --all
# ${repo}为私有制品库的名字

–all 指定上传所有内容(配置文件conanfile.py,源码和二进制包),如果不指定些选项，只上传除二进制包之外的所有文件

关于 conan upload命令的详细说明参见Conan官方文档:《conan upload》

上传成功进入JFrog Artifactory后台就可以看到已经上传的package

总结

上面一套流程做完，可以总结一下，将一个已经有项目封装为conan包的过程：

开始麻烦些，需要用conan new 创建一个模板，然后修改模板，将自己的代码装进去。如果你对python很熟，可以不需要conan new创建模板项目，自己手工改就好了。

后面就很简单 :

conan create 完成conan 二进制包编译

conan upload 负责 conan包的上传发布

参考资料

《conan new》

《conan upload》

《conan create》

《Package scaffolding for conan new command》

conan系列文章

《conan入门(一):conan 及 JFrog Artifactory 安装》
《conan入门(二)：conan 服务配置-密码管理及策略》
《conan入门(三):上传预编译的库(artifact)》
《conan入门(四):conan 引用第三方库示例》
《conan入门(五):conan 交叉编译引用第三方库示例》
《conan入门(六):conanfile.txt conanfile.py的区别》
《conan入门(七):将自己的项目生成conan包》
《conan入门(八):交叉编译自己的conan包项目》
《conan入门(九):NDK交叉编译自己的conan包项目塈profile的定义》
《conan入门(十):Windows下Android NDK交叉编译Boost》
《conan入门(十一):Linux下Android NDK交叉编译Boost》
《conan入门(十二):Windows NDK 编译 boost报错:CMake was unable to find a build program … MinGW Makefile》
《conan入门(十三):conan info 命令的基本用法》
《conan入门(十四):conan new 命令的新特性–模板功能(–template)》
《conan入门(十五):AttributeError: ‘CMake‘ object has no attribute ‘definitions‘》
《conan入门(十六):profile template功能实现不同平台下profile的统一》
《conan入门(十七):支持android NDK (armv7,armv8,x86,x86_64)交叉编译的统一profile jinja2模板》
《conan入门(十八):Cannot recognize the Windows subsystem, install MSYS2/cygwin or specify a build_require》
《conan入门(十九):封装第三方开源库cpp_redis示例》
《conan入门(二十):封装只包含头文件(header_only)的库示例》
《conan入门(二十一):解决MinGW编译Openssl的编译错误:crypto/dso/dso_win32.c》
《conan入门(二十二):编译 openssl要求python 3.7以上版本》
《conan入门(二十三):Windows下MinGW编译libcurl》
《conan入门(二十四):通过CONAN_DISABLE_CHECK_COMPILER禁用编译器检查》
《conan入门(二十五):imports将包安装到本地项目或其他指定位置》

conan 交叉编译引用第三方库示例

Conan 是 C 和 C++ 语言的依赖项和包管理器。它是免费和开源的，适用于所有平台（Windows、Linux、OSX、FreeBSD、Solaris 等），可用于开发所有目标，包括嵌入式、移动（iOS、Android）和裸机。它还与 CMake、Visual Studio (MSBuild)、Makefiles、SCons 等所有构建系统集成，包括专有系统。
它专为加速 C 和 C++ 项目的开发和持续集成而设计和优化。通过完整的二进制包管理，它可以为任意数量的不同版本的包创建和重用任意数量的不同二进制文件（用于不同的配置，如架构、编译器版本等），在所有平台上使用完全相同的过程。由于它是去中心化的，因此很容易运行自己的服务器来私下托管自己的包和二进制文件，而无需共享它们。@《Conan官方文档》

在上一篇博客《conan入门(四):conan 引用第三方库示例》中我们以cJSON为例说明了如何在项目中引用一个conan 包。那是比较简单的一种编译本机目标代码的应用场景(编译环境是Windows,目标代码也是Windows平台)。在物联应用的大背景下，C/C++开发中跨平台交叉编译的应用是非常广泛的。在使用conan来管理C/C++包(制品库)的环境下，如何实现对交叉编译的支持呢？因为我的工作涉及不少嵌入式平台的开发，conan对交叉编译的支持是我最关心的部分。

本文还是以cJSON 为例 ，说明如何在交叉编译环境下使用Conan引入依赖库。

总得来说，很简单，只需要有工具链文件，就可以完成。

cJSON示例程序

示例的所有源码都保存在GIT仓库 conan_example,请接克隆代码到本地：

git clone https://gitee.com/l0km/conan_example.git

示例程序conan_example,以JSON格式输出使用的cJSON库的版本号。

本文中将介绍如何交叉编译arm平台的conan_exmample示例程序。

TOOLCHAIN_FILE

要实现交叉首先要定义好工具链，我有一个DS-5 ARM的交叉编译器(arm-linux-gnueabihf)。已经写好了交叉编译工具链文件

conan_example/cmake/ds5-arm-linux-gnueabihf.toolchain.cmake

# This one is important
SET(CMAKE_SYSTEM_NAME Generic)
SET(CMAKE_SYSTEM_PROCESSOR arm)

set(_compiler_prefix "${_compiler_prefix}")
if(NOT EXISTS ${_compiler_prefix})
	if(NOT $ENV{CROSS_COMPILER_PREFIX} STREQUAL "")
	    set(_compiler_prefix $ENV{CROSS_COMPILER_PREFIX})
	elseif(CROSS_COMPILER_PREFIX)
	    set(_compiler_prefix ${CROSS_COMPILER_PREFIX})
	else()
		find_program(_armcc_path armcc)
		if(NOT _armcc_path)
			message(FATAL_ERROR "NOT FOUND compiler armcc in system path")
		endif()
		get_filename_component(_bin ${_armcc_path} DIRECTORY )
		get_filename_component(_compiler_prefix ${_bin} DIRECTORY )
	endif()	
endif()
set(_suffix)
if(WIN32)
	set(_suffix .exe)
endif()

#INCLUDE(CMakeForceCompiler)

# Specify the cross compiler
#SET(CMAKE_C_COMPILER "${_compiler_prefix}/bin/armcc${_suffix}")
#SET(CMAKE_CXX_COMPILER "${_compiler_prefix}/bin/armcc${_suffix}")
#SET(CMAKE_AR "${_compiler_prefix}/bin/armar${_suffix}" CACHE FILEPATH "Archiver")

SET(CMAKE_C_COMPILER "${_compiler_prefix}/../gcc/bin/arm-linux-gnueabihf-gcc${_suffix}")
SET(CMAKE_CXX_COMPILER "${_compiler_prefix}/../gcc/bin/arm-linux-gnueabihf-g++${_suffix}")
#CMAKE_C_COMPILER("${_compiler_prefix}/sw/gcc/bin/arm-linux-gnueabihf-gcc${_suffix}" GNU)
#CMAKE_CXX_COMPILER ("${_compiler_prefix}/sw/gcc/bin/arm-linux-gnueabihf-g++${_suffix}" GNU)

UNSET(CMAKE_C_FLAGS CACHE)
#SET(CMAKE_C_FLAGS "--cpu=Cortex-A9 --thumb -Ospace" CACHE STRING "" FORCE)
UNSET(CMAKE_CXX_FLAGS CACHE)
#SET(CMAKE_CXX_FLAGS ${CMAKE_C_FLAGS} CACHE STRING "" FORCE)
UNSET(CMAKE_EXE_LINKER_FLAGS CACHE)
#SET(CMAKE_EXE_LINKER_FLAGS "" CACHE STRING "" FORCE)
UNSET(CMAKE_AR_FLAGS CACHE)
#SET(CMAKE_AR_FLAGS "-p -armcc,-Ospace" CACHE STRING "" FORCE)

# set(CMAKE_C_ARCHIVE_CREATE "<CMAKE_AR> cr <TARGET> <LINK_FLAGS> <OBJECTS>")
#SET(CMAKE_C_ARCHIVE_CREATE "<CMAKE_AR> ${CMAKE_AR_FLAGS} -o <TARGET> <OBJECTS>" CACHE STRING "C Archive Create")
# set(CMAKE_CXX_ARCHIVE_CREATE "<CMAKE_AR> cr <TARGET> <LINK_FLAGS> <OBJECTS>")
#SET(CMAKE_CXX_ARCHIVE_CREATE "<CMAKE_AR> ${CMAKE_AR_FLAGS} -o <TARGET> <OBJECTS>" CACHE STRING "CXX Archive Create")

#include_directories("${_compiler_prefix}/include")
include_directories("${_compiler_prefix}/../gcc/arm-linux-gnueabihf/libc/usr/include/arm-linux-gnueabi")

# Where is the target environment
SET(CMAKE_FIND_ROOT_PATH "${_compiler_prefix}/../gcc/arm-linux-gnueabihf/libc")

# Search for programs in the build host directories
SET(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)

# For libraries and headers in the target directories
SET(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
SET(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)

unset(_compiler_prefix)

交叉编译

install cjson(arm)

先要安装arm平台的cjson库，显然，conan中央仓库没有预编译好的arm版本的cJSON库，我们需要通过定义环境变量CONAN_CMAKE_TOOLCHAIN_FILE指定工具链文件，执行conan install 时conan找不到arm平台的库就会自动根据CONAN_CMAKE_TOOLCHAIN_FILE定义的工具链接文件完成arm平台库的编译

$ export CONAN_CMAKE_TOOLCHAIN_FILE=/j/conan_example/cmake/ds5-arm-linux-gnueabihf.toolchain.cmake

关于CONAN_CMAKE_TOOLCHAIN_FILE及其他conan环境变量定义更详细说明参见Conan官方文档《Environment variables》

如上篇博客差不多，执行conan install安装arm平台的cJSON库

$ cd conan_example
$ mkdir build && cd build
$ conan install .. -s os=Linux -s arch=armv7 -s compiler=gcc -s compiler.version=4.8  --build cjson
Configuration:
[settings]
arch=armv7
arch_build=x86_64
build_type=Release
compiler=gcc
compiler.version=4.8
os=Linux
os_build=Windows
[options]
[build_requires]
[env]

cjson/1.7.13: Not found in local cache, looking in remotes...
cjson/1.7.13: Trying with 'conancenter'...
Downloading conanmanifest.txt completed [0.17k]

Downloading conanfile.py completed [6.55k]

Downloading conan_export.tgz completed [0.25k]

Decompressing conan_export.tgz completed [0.00k]

cjson/1.7.13: Downloaded recipe revision 0
cjson/1.7.13: Forced build from source
conanfile.txt: Installing package
Requirements
    cjson/1.7.13 from 'conancenter' - Downloaded
Packages
    cjson/1.7.13:5c3af8d1e83ce3e5b674d9e36b307da418be8145 - Build

Cross-build from 'Windows:x86_64' to 'Linux:armv7'
Installing (downloading, building) binaries...
Downloading conan_sources.tgz completed [0.25k]

Decompressing conan_sources.tgz completed [0.00k]

cjson/1.7.13: Configuring sources in C:\Users\guyadong\.conan\data\cjson\1.7.13\_\_\source
Downloading v1.7.13.tar.gz completed [346.14k]


cjson/1.7.13: Copying sources to build folder
cjson/1.7.13: Building your package in C:\Users\guyadong\.conan\data\cjson\1.7.13\_\_\build\5c3af8d1e83ce3e5b674d9e36b307da418be8145
cjson/1.7.13: Generator cmake created conanbuildinfo.cmake
cjson/1.7.13: Aggregating env generators
cjson/1.7.13: Calling build()
-- The C compiler identification is GNU 4.8.3
-- The CXX compiler identification is GNU 4.8.3
-- Check for working C compiler: E:/DS-5-v5.26.0/sw/ARMCompiler5.06u4/../gcc/bin/arm-linux-gnueabihf-gcc.exe
-- Check for working C compiler: E:/DS-5-v5.26.0/sw/ARMCompiler5.06u4/../gcc/bin/arm-linux-gnueabihf-gcc.exe - works
-- Detecting C compiler ABI info
-- Detecting C compiler ABI info - done
-- Detecting C compile features
-- Detecting C compile features - done
-- Check for working CXX compiler: E:/DS-5-v5.26.0/sw/ARMCompiler5.06u4/../gcc/bin/arm-linux-gnueabihf-g++.exe
-- Check for working CXX compiler: E:/DS-5-v5.26.0/sw/ARMCompiler5.06u4/../gcc/bin/arm-linux-gnueabihf-g++.exe - works
-- Detecting CXX compiler ABI info
-- Detecting CXX compiler ABI info - done
-- Detecting CXX compile features
-- Detecting CXX compile features - done
-- Conan: called by CMake conan helper
-- Conan: called inside local cache
-- Conan: Adjusting output directories
-- Conan: Using cmake global configuration
-- Conan: Adjusting default RPATHs Conan policies
-- Conan: Adjusting language standard
-- Conan: Adjusting fPIC flag (ON)
-- Conan: Checking correct version: 4.8
-- Performing Test FLAG_SUPPORTED_fvisibilityhidden
-- Performing Test FLAG_SUPPORTED_fvisibilityhidden - Success
-- Configuring done
-- Generating done
CMake Warning:
  Manually-specified variables were not used by the project:

    CMAKE_EXPORT_NO_PACKAGE_REGISTRY


-- Build files have been written to: C:/Users/guyadong/.conan/data/cjson/1.7.13/_/_/build/5c3af8d1e83ce3e5b674d9e36b307da418be8145/build_subfolder
Scanning dependencies of target cjson
[ 50%] Building C object source_subfolder/CMakeFiles/cjson.dir/cJSON.c.obj
[100%] Linking C static library ..\lib\libcjson.a
[100%] Built target cjson
cjson/1.7.13: Package '5c3af8d1e83ce3e5b674d9e36b307da418be8145' built
cjson/1.7.13: Build folder C:\Users\guyadong\.conan\data\cjson\1.7.13\_\_\build\5c3af8d1e83ce3e5b674d9e36b307da418be8145
cjson/1.7.13: Generated conaninfo.txt
cjson/1.7.13: Generated conanbuildinfo.txt
cjson/1.7.13: Generating the package
cjson/1.7.13: Package folder C:\Users\guyadong\.conan\data\cjson\1.7.13\_\_\package\5c3af8d1e83ce3e5b674d9e36b307da418be8145
cjson/1.7.13: Calling package()
[100%] Built target cjson
Install the project...
-- Install configuration: "Release"
-- Installing: C:/Users/guyadong/.conan/data/cjson/1.7.13/_/_/package/5c3af8d1e83ce3e5b674d9e36b307da418be8145/include/cjson/cJSON.h
-- Installing: C:/Users/guyadong/.conan/data/cjson/1.7.13/_/_/package/5c3af8d1e83ce3e5b674d9e36b307da418be8145/lib/pkgconfig/libcjson.pc
-- Installing: C:/Users/guyadong/.conan/data/cjson/1.7.13/_/_/package/5c3af8d1e83ce3e5b674d9e36b307da418be8145/lib/libcjson.a
-- Installing: C:/Users/guyadong/.conan/data/cjson/1.7.13/_/_/package/5c3af8d1e83ce3e5b674d9e36b307da418be8145/lib/cmake/cJSON/cJSONConfig.cmake
-- Installing: C:/Users/guyadong/.conan/data/cjson/1.7.13/_/_/package/5c3af8d1e83ce3e5b674d9e36b307da418be8145/lib/cmake/cJSON/cJSONConfigVersion.cmake
cjson/1.7.13 package(): Packaged 1 '.h' file: cJSON.h
cjson/1.7.13 package(): Packaged 1 '.a' file: libcjson.a
cjson/1.7.13 package(): Packaged 1 '.cmake' file: conan-official-cjson-targets.c
make
cjson/1.7.13 package(): Packaged 1 file: LICENSE
cjson/1.7.13: Package '5c3af8d1e83ce3e5b674d9e36b307da418be8145' created
cjson/1.7.13: Created package revision a991a9101873de809042280c2b48122c
conanfile.txt: Generator cmake created conanbuildinfo.cmake
conanfile.txt: Generator txt created conanbuildinfo.txt
conanfile.txt: Aggregating env generators
conanfile.txt: Generated conaninfo.txt
conanfile.txt: Generated graphinfo

-s os=Linux -s arch=armv7 -s compiler=gcc -s compiler.version=4.8 指定交叉编译的目标平台编译器及版本

–build cjson 指定编译cjson库

–build 的可选值(可多个组合):

​ --build never 禁止编译依赖包,只下载预编译的二进制包,如果没找到预编译包则报错[不可与其他可选值组合]

​ --build missing 如果依赖包中没有找到预编译的二进制包则从源码编译

​ --build outdated 如果依赖包中没有找到预编译的二进制包或过期(日期旧于源码)则从源码编译

​ --build cascade

​ --build [pattern] 编译包名匹配[pattern]的所有包

​ --build ![pattern] 编译包名匹配[pattern]的之外所有包

本示例中--build json 是[pattern] 用法,所以--build json 也是一样的效果

--build=json也是有效的写法

关于conan install命令更详细的说明参见Conan官方文档《conan install》

build conan_example

生成Makeifile 工程文件

$ cd conan_example/build
$ cmake .. -G "Unix Makefiles" -DCMAKE_TOOLCHAIN_FILE=J:\conan_example\cmake\ds5-arm-linux-gnueabihf.toolchain.cmake
-- The C compiler identification is GNU 4.8.3
-- The CXX compiler identification is GNU 4.8.3
-- Check for working C compiler: E:/DS-5-v5.26.0/sw/ARMCompiler5.06u4/../gcc/bin
/arm-linux-gnueabihf-gcc.exe
-- Check for working C compiler: E:/DS-5-v5.26.0/sw/ARMCompiler5.06u4/../gcc/bin
/arm-linux-gnueabihf-gcc.exe - works
-- Detecting C compiler ABI info
-- Detecting C compiler ABI info - done
-- Detecting C compile features
-- Detecting C compile features - done
-- Check for working CXX compiler: E:/DS-5-v5.26.0/sw/ARMCompiler5.06u4/../gcc/b
in/arm-linux-gnueabihf-g++.exe
-- Check for working CXX compiler: E:/DS-5-v5.26.0/sw/ARMCompiler5.06u4/../gcc/b
in/arm-linux-gnueabihf-g++.exe - works
-- Detecting CXX compiler ABI info
-- Detecting CXX compiler ABI info - done
-- Detecting CXX compile features
-- Detecting CXX compile features - done
-- Conan: Adjusting output directories
-- Conan: Using cmake global configuration
-- Conan: Adjusting default RPATHs Conan policies
-- Conan: Adjusting language standard
-- Current conanbuildinfo.cmake directory: J:/conan_example/build
-- Conan: Checking correct version: 4.8
-- Configuring done
-- Generating done
-- Build files have been written to: J:/conan_example/build

编译conan_example

$ cmake --build .
Scanning dependencies of target json_test
[ 50%] Building C object CMakeFiles/json_test.dir/json_test.c.obj
[100%] Linking C executable bin/json_test
[100%] Built target json_test

上传到私有制品库

对于第三方库我们不需要每次都编译，可以上传到私有制品库

conan upload cjson/1.7.13  -r ${repo} --all
# ${repo}为私有制品库的名字,下同

下次再执行conan install …时就可以指定不编译

$ conan install .. -s os=Linux -s arch=armv7 -s compiler=gcc -s compiler.version=4.8 --build never -r ${repo}
# --build never 强制不编译
# -r ${repo} 指定从私有制品库获取

conan系列文章

《conan入门(一):conan 及 JFrog Artifactory 安装》
《conan入门(二)：conan 服务配置-密码管理及策略》
《conan入门(三):上传预编译的库(artifact)》
《conan入门(四):conan 引用第三方库示例》
《conan入门(五):conan 交叉编译引用第三方库示例》
《conan入门(六):conanfile.txt conanfile.py的区别》
《conan入门(七):将自己的项目生成conan包》
《conan入门(八):交叉编译自己的conan包项目》
《conan入门(九):NDK交叉编译自己的conan包项目塈profile的定义》
《conan入门(十):Windows下Android NDK交叉编译Boost》
《conan入门(十一):Linux下Android NDK交叉编译Boost》
《conan入门(十二):Windows NDK 编译 boost报错:CMake was unable to find a build program … MinGW Makefile》
《conan入门(十三):conan info 命令的基本用法》
《conan入门(十四):conan new 命令的新特性–模板功能(–template)》
《conan入门(十五):AttributeError: ‘CMake‘ object has no attribute ‘definitions‘》
《conan入门(十六):profile template功能实现不同平台下profile的统一》
《conan入门(十七):支持android NDK (armv7,armv8,x86,x86_64)交叉编译的统一profile jinja2模板》
《conan入门(十八):Cannot recognize the Windows subsystem, install MSYS2/cygwin or specify a build_require》
《conan入门(十九):封装第三方开源库cpp_redis示例》
《conan入门(二十):封装只包含头文件(header_only)的库示例》
《conan入门(二十一):解决MinGW编译Openssl的编译错误:crypto/dso/dso_win32.c》
《conan入门(二十二):编译 openssl要求python 3.7以上版本》
《conan入门(二十三):Windows下MinGW编译libcurl》
《conan入门(二十四):通过CONAN_DISABLE_CHECK_COMPILER禁用编译器检查》
《conan入门(二十五):imports将包安装到本地项目或其他指定位置》