Boost components

[syoliver]

Specify library name and version: boost/1.73.0

I this to get dependencies between boost libraries from boost generated cmakes. Pre 1.70 Boost, it should come from FindBoost.cmake copied in the recipe, but I have not tested yet.
It is far from ready now, but I would just know if it seems too hacky or not to build components for boost and I would like if I continue spending time on it or not.

• I've read the guidelines for contributing.
• I've followed the PEP8 style guides for Python code in the recipes.
• I've used the latest Conan client version.
• I've tried at least one configuration locally with the
  conan-center hook activated.

[conan-center-bot]

Some configurations of 'boost/1.69.0' failed in build 1 (2a2e486c90c4580694a6840262ba545cbf6a4857):

• Linux x86_64, Release, gcc 5, libstdc++ . Options: boost:shared-True
  • Log download
  • Log error Download
  • Profile
• Access to all the logs

[conan-center-bot]

Some configurations of 'boost/1.69.0' failed in build 2 (5586b653380481c3d2d8c07f5f0576e89770f164):

• Linux x86_64, Release, gcc 5, libstdc++ . Options: boost:shared-True
  • Log download
  • Log error Download
  • Profile
• Access to all the logs

[conan-center-bot]

Some configurations of 'boost/1.69.0' failed in build 3 (32e7b01257d280215d014fad332d7485e9326526):

• Linux x86_64, Release, gcc 5, libstdc++ . Options: boost:shared-True
  • Log download
  • Log error Download
  • Profile
• Access to all the logs

[conan-center-bot]

Some configurations of 'boost/1.69.0' failed in build 4 (6ad2c2550041d1cea73b5b5d2964aee302451cae):

• Linux x86_64, Release, gcc 5, libstdc++ . Options: boost:shared-True
  • Log download
  • Log error Download
  • Profile
• Access to all the logs

[conan-center-bot]

Some configurations of 'boost/1.69.0' failed in build 6 (b4e82c1d711e8a94be3cadc30a2e8482d1fe1cfe):

• Linux x86_64, Release, gcc 5, libstdc++ . Options: boost:shared-True
  • Hooks errors detected:
    • [HOOK - conan-center.py] pre_export(): ERROR: [NO FINAL ENDLINE (KB-H041)] File '/tmp/c3ipr/co_pr_1925_6_0_0/recipes/boost/all/test_package/exception.cpp' does not end with an endline (https://github.com/conan-io/conan-center-index/wiki/Error-Knowledge-Base#KB-H041)
  • Log download
  • Log error Download
  • Profile
• Access to all the logs

[conan-center-bot]

Some configurations of 'boost/1.69.0' failed in build 7 (f171e0c8103e1b2f22032f1dab12753d8b42c12a):

• Linux x86_64, Release, gcc 5, libstdc++ . Options: boost:shared-True
  • Log download
  • Log error Download
  • Profile
• Access to all the logs

[SSE4]

hello! I had similar idea, as we need to solve several long-standing issues related to boost components, linking order, etc.
that I wanted to do is to use boostdep tool to generate a dependency graph, and use that information to populate cpp_info (components, libraries, etc).
unfortunately, boostdep doesn't work on boost source tarball, but requires boost git repository in order to operate. we still can generate these reports locally and save data to the file near to the conanfile, and use that information in the recipe.

[conan-center-bot]

Git error in build 8:

Command "git merge 4dbc35f8f5f9932b68d4e14ae84fc28ae1bbfaac" returned status code 1:
stdout: Removing recipes/sqlcipher/all/patches/Makefile.msc.patch
Removing recipes/rocksdb/all/patches/6724.patch
Removing recipes/c-blosc/all/patches/cmake-dependencies.patch
Auto-merging recipes/boost/all/conanfile.py
CONFLICT (content): Merge conflict in recipes/boost/all/conanfile.py
Automatic merge failed; fix conflicts and then commit the result.

stderr: 

[conan-center-bot]

Some configurations of 'boost/1.69.0' failed in build 9 (55af03e52b1258ca0b486f26380f533fc67d565c):

• Linux x86_64, Release, gcc 5, libstdc++ . Options: boost:shared-True
  • Log download
  • Log error Download
  • Profile
• Access to all the logs

[madebr]

hello! I had similar idea, as we need to solve several long-standing issues related to boost components, linking order, etc.
that I wanted to do is to use boostdep tool to generate a dependency graph, and use that information to populate cpp_info (components, libraries, etc).
unfortunately, boostdep doesn't work on boost source tarball, but requires boost git repository in order to operate. we still can generate these reports locally and save data to the file near to the conanfile, and use that information in the recipe.

I created the dependency tree for poco similarly:
see #1570

[madebr]

Would it make sense to build bostdep as part of the boost package (hidden behind an option)?
And add a script that generates the dependency tree.

[madebr]

Using boostdep on boost git 1.73.0, I was able to extract the dependency tree.

@SSE4 What is the difference between --list-modules and --list-buildable?
Does it mean that a buildable builds a library and those that aren't are header only?
Does a buildable named xx_yy create a library created libboost_xx_yy.so?

It seems not, because there exist exceptions: e.g. math and test:

• math creates the libraries multiple libraries: boost_math_c99f, boost_math_c99l, boost_math_c99, boost_math_tr1f, boost_math_tr1l
• test creates the library boost_unit_test_framework

dependency tree of boost 1.73.0 modules

{'accumulators': ['array',
                  'assert',
                  'circular_buffer',
                  'concept_check',
                  'config',
                  'core',
                  'fusion',
                  'iterator',
                  'mpl',
                  'parameter',
                  'preprocessor',
                  'range',
                  'serialization',
                  'static_assert',
                  'throw_exception',
                  'tuple',
                  'type_traits',
                  'typeof'],
 'algorithm': ['array',
               'assert',
               'bind',
               'concept_check',
               'config',
               'core',
               'exception',
               'function',
               'iterator',
               'mpl',
               'range',
               'regex',
               'static_assert',
               'throw_exception',
               'tuple',
               'type_traits',
               'unordered'],
 'align': ['assert', 'config', 'core', 'static_assert'],
 'any': ['config',
         'core',
         'static_assert',
         'throw_exception',
         'type_index',
         'type_traits'],
 'array': ['assert', 'config', 'core', 'static_assert', 'throw_exception'],
 'asio': ['array',
          'assert',
          'bind',
          'chrono',
          'config',
          'core',
          'coroutine',
          'date_time',
          'function',
          'regex',
          'smart_ptr',
          'system',
          'throw_exception',
          'type_traits',
          'utility'],
 'assert': ['config'],
 'assign': ['array',
            'config',
            'core',
            'move',
            'mpl',
            'preprocessor',
            'ptr_container',
            'range',
            'static_assert',
            'throw_exception',
            'tuple',
            'type_traits'],
 'atomic': ['assert', 'config', 'static_assert', 'type_traits'],
 'beast': ['asio',
           'assert',
           'bind',
           'config',
           'container',
           'core',
           'endian',
           'intrusive',
           'logic',
           'optional',
           'smart_ptr',
           'static_assert',
           'system',
           'throw_exception',
           'type_traits',
           'utility',
           'winapi'],
 'bimap': ['concept_check',
           'config',
           'container_hash',
           'core',
           'iterator',
           'lambda',
           'mpl',
           'multi_index',
           'preprocessor',
           'property_map',
           'serialization',
           'static_assert',
           'throw_exception',
           'type_traits',
           'utility'],
 'bind': ['config', 'core'],
 'callable_traits': [],
 'chrono': ['assert',
            'config',
            'core',
            'integer',
            'move',
            'mpl',
            'predef',
            'ratio',
            'static_assert',
            'system',
            'throw_exception',
            'type_traits',
            'typeof',
            'utility',
            'winapi'],
 'circular_buffer': ['assert',
                     'concept_check',
                     'config',
                     'core',
                     'move',
                     'static_assert',
                     'throw_exception',
                     'type_traits'],
 'compatibility': [],
 'compute': ['algorithm',
             'array',
             'assert',
             'chrono',
             'config',
             'core',
             'filesystem',
             'function',
             'function_types',
             'fusion',
             'iterator',
             'lexical_cast',
             'mpl',
             'optional',
             'preprocessor',
             'property_tree',
             'proto',
             'range',
             'smart_ptr',
             'static_assert',
             'thread',
             'throw_exception',
             'tuple',
             'type_traits',
             'typeof',
             'utility',
             'uuid'],
 'concept_check': ['config', 'preprocessor', 'static_assert', 'type_traits'],
 'config': [],
 'container': ['assert',
               'config',
               'container_hash',
               'core',
               'intrusive',
               'move',
               'static_assert',
               'type_traits'],
 'container_hash': ['assert',
                    'config',
                    'core',
                    'detail',
                    'integer',
                    'static_assert',
                    'type_traits'],
 'context': ['assert', 'config', 'pool', 'predef', 'smart_ptr', 'thread'],
 'contract': ['any',
              'assert',
              'config',
              'core',
              'exception',
              'function',
              'function_types',
              'mpl',
              'optional',
              'preprocessor',
              'smart_ptr',
              'static_assert',
              'thread',
              'type_traits',
              'typeof',
              'utility'],
 'conversion': ['assert',
                'config',
                'core',
                'smart_ptr',
                'throw_exception',
                'type_traits',
                'typeof'],
 'convert': ['config',
             'core',
             'function_types',
             'lexical_cast',
             'math',
             'mpl',
             'optional',
             'parameter',
             'range',
             'spirit',
             'type_traits'],
 'core': ['assert', 'config'],
 'coroutine': ['assert',
               'config',
               'context',
               'core',
               'exception',
               'move',
               'range',
               'system',
               'thread',
               'throw_exception',
               'type_traits',
               'utility'],
 'coroutine2': ['assert', 'config', 'context'],
 'crc': ['array', 'config', 'integer', 'type_traits'],
 'date_time': ['algorithm',
               'assert',
               'config',
               'core',
               'io',
               'lexical_cast',
               'range',
               'serialization',
               'smart_ptr',
               'static_assert',
               'throw_exception',
               'tokenizer',
               'type_traits',
               'utility',
               'winapi'],
 'detail': ['config', 'core', 'preprocessor', 'static_assert', 'type_traits'],
 'dll': ['assert',
         'config',
         'core',
         'filesystem',
         'function',
         'move',
         'predef',
         'smart_ptr',
         'spirit',
         'static_assert',
         'system',
         'throw_exception',
         'type_index',
         'type_traits',
         'winapi'],
 'dynamic_bitset': ['assert',
                    'config',
                    'container_hash',
                    'core',
                    'integer',
                    'move',
                    'static_assert',
                    'throw_exception'],
 'endian': ['config', 'core', 'static_assert', 'type_traits'],
 'exception': ['assert',
               'config',
               'core',
               'smart_ptr',
               'throw_exception',
               'tuple',
               'type_traits'],
 'fiber': ['algorithm',
           'assert',
           'config',
           'context',
           'core',
           'filesystem',
           'format',
           'intrusive',
           'predef',
           'smart_ptr'],
 'filesystem': ['assert',
                'config',
                'container_hash',
                'core',
                'detail',
                'io',
                'iterator',
                'predef',
                'smart_ptr',
                'system',
                'type_traits',
                'winapi'],
 'flyweight': ['assert',
               'config',
               'container_hash',
               'core',
               'detail',
               'interprocess',
               'mpl',
               'multi_index',
               'parameter',
               'preprocessor',
               'serialization',
               'smart_ptr',
               'throw_exception',
               'type_traits'],
 'foreach': ['config', 'core', 'iterator', 'mpl', 'range', 'type_traits'],
 'format': ['assert',
            'config',
            'core',
            'optional',
            'smart_ptr',
            'throw_exception',
            'utility'],
 'function': ['assert',
              'bind',
              'config',
              'core',
              'integer',
              'preprocessor',
              'throw_exception',
              'type_index',
              'type_traits',
              'typeof'],
 'function_types': ['config',
                    'core',
                    'detail',
                    'mpl',
                    'preprocessor',
                    'type_traits'],
 'functional': ['config',
                'core',
                'function',
                'function_types',
                'mpl',
                'preprocessor',
                'type_traits',
                'typeof',
                'utility'],
 'fusion': ['config',
            'container_hash',
            'core',
            'function_types',
            'mpl',
            'preprocessor',
            'static_assert',
            'tuple',
            'type_traits',
            'typeof',
            'utility'],
 'geometry': ['algorithm',
              'array',
              'assert',
              'concept_check',
              'config',
              'container',
              'core',
              'function_types',
              'fusion',
              'integer',
              'iterator',
              'lexical_cast',
              'math',
              'move',
              'mpl',
              'multiprecision',
              'polygon',
              'qvm',
              'range',
              'rational',
              'serialization',
              'smart_ptr',
              'static_assert',
              'thread',
              'throw_exception',
              'tokenizer',
              'tuple',
              'type_traits',
              'utility',
              'variant'],
 'gil': ['assert',
         'concept_check',
         'config',
         'core',
         'filesystem',
         'integer',
         'iterator',
         'preprocessor',
         'variant'],
 'graph': ['algorithm',
           'any',
           'array',
           'assert',
           'bimap',
           'bind',
           'concept_check',
           'config',
           'container_hash',
           'conversion',
           'core',
           'detail',
           'foreach',
           'function',
           'integer',
           'iterator',
           'lexical_cast',
           'math',
           'move',
           'mpl',
           'multi_index',
           'optional',
           'parameter',
           'preprocessor',
           'property_map',
           'property_tree',
           'random',
           'range',
           'regex',
           'serialization',
           'smart_ptr',
           'spirit',
           'static_assert',
           'throw_exception',
           'tti',
           'tuple',
           'type_traits',
           'typeof',
           'unordered',
           'utility',
           'xpressive'],
 'graph_parallel': ['assert',
                    'concept_check',
                    'config',
                    'container_hash',
                    'core',
                    'detail',
                    'dynamic_bitset',
                    'filesystem',
                    'foreach',
                    'function',
                    'graph',
                    'iterator',
                    'lexical_cast',
                    'mpi',
                    'mpl',
                    'optional',
                    'property_map',
                    'random',
                    'serialization',
                    'smart_ptr',
                    'static_assert',
                    'tuple',
                    'type_traits',
                    'variant'],
 'hana': ['config', 'core', 'fusion', 'mpl', 'tuple'],
 'heap': ['array',
          'assert',
          'bind',
          'concept_check',
          'config',
          'intrusive',
          'iterator',
          'parameter',
          'static_assert',
          'throw_exception',
          'type_traits'],
 'histogram': ['assert', 'config', 'core', 'serialization', 'throw_exception'],
 'hof': [],
 'icl': ['assert',
         'concept_check',
         'config',
         'container',
         'core',
         'date_time',
         'detail',
         'iterator',
         'move',
         'mpl',
         'range',
         'rational',
         'static_assert',
         'type_traits',
         'utility'],
 'integer': ['assert', 'config', 'core', 'static_assert', 'throw_exception'],
 'interprocess': ['assert',
                  'config',
                  'container',
                  'core',
                  'date_time',
                  'integer',
                  'intrusive',
                  'move',
                  'static_assert',
                  'type_traits',
                  'unordered',
                  'winapi'],
 'intrusive': ['assert',
               'config',
               'container_hash',
               'core',
               'move',
               'static_assert'],
 'io': ['config'],
 'iostreams': ['assert',
               'bind',
               'config',
               'core',
               'detail',
               'function',
               'integer',
               'iterator',
               'mpl',
               'preprocessor',
               'random',
               'range',
               'regex',
               'smart_ptr',
               'static_assert',
               'throw_exception',
               'type_traits',
               'utility'],
 'iterator': ['assert',
              'concept_check',
              'config',
              'conversion',
              'core',
              'detail',
              'function_types',
              'fusion',
              'mpl',
              'optional',
              'smart_ptr',
              'static_assert',
              'type_traits',
              'utility'],
 'lambda': ['bind',
            'config',
            'core',
            'detail',
            'iterator',
            'mpl',
            'preprocessor',
            'tuple',
            'type_traits',
            'utility'],
 'lexical_cast': ['array',
                  'assert',
                  'config',
                  'container',
                  'core',
                  'integer',
                  'math',
                  'range',
                  'static_assert',
                  'throw_exception',
                  'type_traits'],
 'local_function': ['config',
                    'mpl',
                    'preprocessor',
                    'scope_exit',
                    'type_traits',
                    'typeof',
                    'utility'],
 'locale': ['assert',
            'config',
            'function',
            'iterator',
            'smart_ptr',
            'static_assert',
            'thread',
            'type_traits',
            'unordered'],
 'lockfree': ['align',
              'array',
              'assert',
              'atomic',
              'config',
              'core',
              'integer',
              'iterator',
              'mpl',
              'parameter',
              'predef',
              'static_assert',
              'tuple',
              'type_traits',
              'utility'],
 'log': ['align',
         'array',
         'asio',
         'assert',
         'atomic',
         'bind',
         'config',
         'container',
         'core',
         'date_time',
         'exception',
         'filesystem',
         'function_types',
         'fusion',
         'interprocess',
         'intrusive',
         'io',
         'iterator',
         'lexical_cast',
         'locale',
         'move',
         'mpl',
         'optional',
         'parameter',
         'phoenix',
         'predef',
         'preprocessor',
         'property_tree',
         'proto',
         'random',
         'range',
         'regex',
         'smart_ptr',
         'spirit',
         'static_assert',
         'system',
         'thread',
         'throw_exception',
         'type_index',
         'type_traits',
         'utility',
         'winapi',
         'xpressive'],
 'logic': ['config', 'core'],
 'math': ['array',
          'assert',
          'atomic',
          'concept_check',
          'config',
          'core',
          'detail',
          'fusion',
          'integer',
          'lambda',
          'lexical_cast',
          'mpl',
          'predef',
          'range',
          'smart_ptr',
          'static_assert',
          'throw_exception',
          'tuple',
          'type_traits'],
 'metaparse': ['config',
               'mpl',
               'predef',
               'preprocessor',
               'static_assert',
               'type_traits'],
 'move': ['assert', 'config', 'core', 'static_assert'],
 'mp11': [],
 'mpi': ['assert',
         'config',
         'core',
         'foreach',
         'function',
         'graph',
         'integer',
         'iterator',
         'lexical_cast',
         'mpl',
         'optional',
         'python',
         'serialization',
         'smart_ptr',
         'static_assert',
         'throw_exception',
         'type_traits',
         'utility'],
 'mpl': ['config',
         'core',
         'predef',
         'preprocessor',
         'static_assert',
         'type_traits',
         'utility'],
 'msm': ['any',
         'assert',
         'bind',
         'circular_buffer',
         'config',
         'core',
         'function',
         'fusion',
         'mpl',
         'parameter',
         'phoenix',
         'preprocessor',
         'proto',
         'serialization',
         'tuple',
         'type_traits',
         'typeof'],
 'multi_array': ['array',
                 'assert',
                 'concept_check',
                 'config',
                 'core',
                 'functional',
                 'iterator',
                 'mpl',
                 'static_assert',
                 'type_traits'],
 'multi_index': ['assert',
                 'bind',
                 'config',
                 'container_hash',
                 'core',
                 'foreach',
                 'integer',
                 'iterator',
                 'move',
                 'mpl',
                 'preprocessor',
                 'serialization',
                 'smart_ptr',
                 'static_assert',
                 'throw_exception',
                 'tuple',
                 'type_traits',
                 'utility'],
 'multiprecision': ['array',
                    'assert',
                    'atomic',
                    'config',
                    'container_hash',
                    'core',
                    'integer',
                    'lexical_cast',
                    'math',
                    'mpl',
                    'predef',
                    'random',
                    'rational',
                    'smart_ptr',
                    'static_assert',
                    'throw_exception',
                    'type_traits'],
 'nowide': ['config', 'filesystem', 'smart_ptr', 'static_assert'],
 'numeric~conversion': ['config',
                        'conversion',
                        'core',
                        'mpl',
                        'preprocessor',
                        'throw_exception',
                        'type_traits'],
 'numeric~interval': ['config', 'detail', 'logic'],
 'numeric~odeint': ['array',
                    'assert',
                    'bind',
                    'compute',
                    'config',
                    'core',
                    'function',
                    'fusion',
                    'iterator',
                    'math',
                    'mpi',
                    'mpl',
                    'multi_array',
                    'preprocessor',
                    'range',
                    'static_assert',
                    'throw_exception',
                    'type_traits',
                    'units',
                    'utility'],
 'numeric~ublas': ['compute',
                   'concept_check',
                   'config',
                   'core',
                   'iterator',
                   'mpl',
                   'range',
                   'serialization',
                   'smart_ptr',
                   'static_assert',
                   'type_traits',
                   'typeof'],
 'optional': ['assert',
              'config',
              'core',
              'detail',
              'move',
              'predef',
              'static_assert',
              'throw_exception',
              'type_traits',
              'utility'],
 'outcome': ['config', 'exception', 'system', 'throw_exception'],
 'parameter': ['config',
               'core',
               'function',
               'fusion',
               'mpl',
               'optional',
               'preprocessor',
               'type_traits',
               'utility'],
 'parameter_python': ['mpl', 'parameter', 'preprocessor', 'python'],
 'phoenix': ['assert',
             'bind',
             'config',
             'core',
             'function',
             'fusion',
             'mpl',
             'predef',
             'preprocessor',
             'proto',
             'range',
             'smart_ptr',
             'type_traits',
             'utility'],
 'poly_collection': ['assert',
                     'config',
                     'core',
                     'iterator',
                     'mpl',
                     'type_erasure',
                     'type_traits'],
 'polygon': ['config'],
 'pool': ['assert',
          'config',
          'integer',
          'throw_exception',
          'type_traits',
          'winapi'],
 'predef': [],
 'preprocessor': [],
 'process': ['algorithm',
             'asio',
             'config',
             'core',
             'filesystem',
             'fusion',
             'iterator',
             'move',
             'optional',
             'system',
             'tokenizer',
             'type_index',
             'winapi'],
 'program_options': ['any',
                     'bind',
                     'config',
                     'core',
                     'detail',
                     'function',
                     'iterator',
                     'lexical_cast',
                     'smart_ptr',
                     'static_assert',
                     'throw_exception',
                     'tokenizer',
                     'type_traits'],
 'property_map': ['any',
                  'assert',
                  'bind',
                  'concept_check',
                  'config',
                  'core',
                  'function',
                  'iterator',
                  'lexical_cast',
                  'mpi',
                  'mpl',
                  'multi_index',
                  'optional',
                  'serialization',
                  'smart_ptr',
                  'static_assert',
                  'throw_exception',
                  'type_traits',
                  'utility'],
 'property_tree': ['any',
                   'assert',
                   'bind',
                   'config',
                   'core',
                   'format',
                   'iterator',
                   'mpl',
                   'multi_index',
                   'optional',
                   'range',
                   'serialization',
                   'static_assert',
                   'throw_exception',
                   'type_traits'],
 'proto': ['config',
           'core',
           'fusion',
           'mpl',
           'preprocessor',
           'range',
           'static_assert',
           'type_traits',
           'typeof',
           'utility'],
 'ptr_container': ['array',
                   'assert',
                   'circular_buffer',
                   'config',
                   'core',
                   'iterator',
                   'mpl',
                   'range',
                   'serialization',
                   'smart_ptr',
                   'static_assert',
                   'type_traits',
                   'unordered',
                   'utility'],
 'python': ['bind',
            'config',
            'conversion',
            'core',
            'detail',
            'foreach',
            'function',
            'graph',
            'integer',
            'iterator',
            'lexical_cast',
            'mpl',
            'preprocessor',
            'property_map',
            'smart_ptr',
            'static_assert',
            'tuple',
            'type_traits',
            'utility'],
 'qvm': ['assert', 'core', 'exception', 'static_assert', 'throw_exception'],
 'random': ['assert',
            'config',
            'core',
            'dynamic_bitset',
            'integer',
            'io',
            'math',
            'mpl',
            'multiprecision',
            'range',
            'static_assert',
            'system',
            'throw_exception',
            'type_traits',
            'utility'],
 'range': ['array',
           'assert',
           'concept_check',
           'config',
           'container_hash',
           'core',
           'detail',
           'iterator',
           'mpl',
           'optional',
           'preprocessor',
           'regex',
           'static_assert',
           'tuple',
           'type_traits',
           'utility'],
 'ratio': ['config',
           'core',
           'integer',
           'mpl',
           'rational',
           'static_assert',
           'type_traits'],
 'rational': ['assert',
              'config',
              'core',
              'integer',
              'static_assert',
              'throw_exception',
              'type_traits',
              'utility'],
 'regex': ['assert',
           'concept_check',
           'config',
           'container_hash',
           'core',
           'integer',
           'iterator',
           'mpl',
           'predef',
           'smart_ptr',
           'static_assert',
           'throw_exception',
           'type_traits'],
 'safe_numerics': ['concept_check', 'config', 'core', 'integer', 'logic'],
 'scope_exit': ['config', 'function', 'preprocessor', 'type_traits', 'typeof'],
 'serialization': ['array',
                   'assert',
                   'config',
                   'core',
                   'detail',
                   'function',
                   'integer',
                   'io',
                   'iterator',
                   'move',
                   'mpl',
                   'optional',
                   'predef',
                   'preprocessor',
                   'smart_ptr',
                   'spirit',
                   'static_assert',
                   'type_traits',
                   'unordered',
                   'utility',
                   'variant'],
 'signals2': ['assert',
              'bind',
              'config',
              'core',
              'function',
              'iterator',
              'mpl',
              'optional',
              'parameter',
              'predef',
              'preprocessor',
              'smart_ptr',
              'throw_exception',
              'tuple',
              'type_traits',
              'variant'],
 'smart_ptr': ['assert',
               'config',
               'core',
               'move',
               'static_assert',
               'throw_exception',
               'type_traits'],
 'sort': ['config',
          'core',
          'range',
          'serialization',
          'static_assert',
          'type_traits'],
 'spirit': ['array',
            'assert',
            'config',
            'core',
            'endian',
            'filesystem',
            'foreach',
            'function',
            'function_types',
            'fusion',
            'integer',
            'io',
            'iostreams',
            'iterator',
            'locale',
            'math',
            'move',
            'mpl',
            'optional',
            'phoenix',
            'pool',
            'preprocessor',
            'proto',
            'range',
            'regex',
            'smart_ptr',
            'static_assert',
            'thread',
            'throw_exception',
            'type_traits',
            'typeof',
            'unordered',
            'utility',
            'variant'],
 'stacktrace': ['array',
                'config',
                'container_hash',
                'core',
                'predef',
                'static_assert',
                'type_traits',
                'winapi'],
 'statechart': ['assert',
                'bind',
                'config',
                'conversion',
                'core',
                'detail',
                'function',
                'mpl',
                'smart_ptr',
                'static_assert',
                'thread',
                'type_traits'],
 'static_assert': ['config'],
 'static_string': ['assert',
                   'container_hash',
                   'static_assert',
                   'throw_exception',
                   'utility'],
 'system': ['config', 'winapi'],
 'test': ['algorithm',
          'assert',
          'bind',
          'config',
          'core',
          'detail',
          'exception',
          'function',
          'io',
          'iterator',
          'mpl',
          'optional',
          'preprocessor',
          'smart_ptr',
          'static_assert',
          'type_traits',
          'utility'],
 'thread': ['algorithm',
            'assert',
            'atomic',
            'bind',
            'chrono',
            'concept_check',
            'config',
            'container',
            'container_hash',
            'core',
            'date_time',
            'exception',
            'function',
            'intrusive',
            'io',
            'iterator',
            'lexical_cast',
            'move',
            'optional',
            'predef',
            'preprocessor',
            'smart_ptr',
            'static_assert',
            'system',
            'throw_exception',
            'tuple',
            'type_traits',
            'utility',
            'winapi'],
 'throw_exception': ['assert', 'config'],
 'timer': ['chrono',
           'config',
           'core',
           'io',
           'predef',
           'system',
           'throw_exception'],
 'tokenizer': ['assert',
               'config',
               'iterator',
               'mpl',
               'throw_exception',
               'type_traits'],
 'tti': ['config', 'function_types', 'mpl', 'preprocessor', 'type_traits'],
 'tuple': ['config', 'core', 'static_assert', 'type_traits'],
 'type_erasure': ['assert',
                  'config',
                  'core',
                  'fusion',
                  'iterator',
                  'mpl',
                  'preprocessor',
                  'smart_ptr',
                  'thread',
                  'throw_exception',
                  'type_traits',
                  'typeof',
                  'vmd'],
 'type_index': ['config',
                'container_hash',
                'core',
                'preprocessor',
                'smart_ptr',
                'static_assert',
                'throw_exception',
                'type_traits'],
 'type_traits': ['config', 'static_assert'],
 'typeof': ['config', 'preprocessor', 'type_traits'],
 'units': ['assert',
           'config',
           'core',
           'integer',
           'io',
           'lambda',
           'math',
           'mpl',
           'preprocessor',
           'serialization',
           'static_assert',
           'type_traits',
           'typeof'],
 'unordered': ['assert',
               'config',
               'container',
               'container_hash',
               'core',
               'detail',
               'move',
               'predef',
               'preprocessor',
               'smart_ptr',
               'throw_exception',
               'tuple',
               'type_traits'],
 'utility': ['config',
             'container_hash',
             'core',
             'io',
             'preprocessor',
             'static_assert',
             'throw_exception',
             'type_traits'],
 'uuid': ['assert',
          'config',
          'container_hash',
          'core',
          'io',
          'move',
          'predef',
          'random',
          'serialization',
          'static_assert',
          'throw_exception',
          'tti',
          'type_traits',
          'winapi'],
 'variant': ['assert',
             'bind',
             'config',
             'container_hash',
             'core',
             'detail',
             'integer',
             'move',
             'mpl',
             'preprocessor',
             'static_assert',
             'throw_exception',
             'type_index',
             'type_traits',
             'utility'],
 'variant2': ['config'],
 'vmd': ['preprocessor'],
 'wave': ['assert',
          'concept_check',
          'config',
          'core',
          'filesystem',
          'iterator',
          'lexical_cast',
          'mpl',
          'multi_index',
          'pool',
          'preprocessor',
          'serialization',
          'smart_ptr',
          'spirit',
          'static_assert',
          'throw_exception',
          'type_traits'],
 'winapi': ['config', 'predef'],
 'xpressive': ['assert',
               'config',
               'conversion',
               'core',
               'exception',
               'fusion',
               'integer',
               'iterator',
               'lexical_cast',
               'mpl',
               'optional',
               'preprocessor',
               'proto',
               'range',
               'smart_ptr',
               'static_assert',
               'throw_exception',
               'type_traits',
               'typeof',
               'utility'],
 'yap': ['hana', 'preprocessor', 'type_index']}

[SSE4]

boostdep --list-buildable prints a list of the modules that require building. Boostdep considers a module to require building if it contains subdirectories named build and src.

so yes, it looks like it should print only build-able modules (one who produce static / shared libraries)

so the general rule is that build-able module builds (at least) one library (it could build more than one, just like math, serialization or test modules).

right now I don't think we should model components for header-only boost libraries. I think this should be the same as components modeled by find_package(Boost) (CMake), or pkg-config files provided by boost, or sub-packages provided by system package managers (e.g. https://packages.debian.org/en/sid/libboost1.67-dev).

Does a buildable named xx_yy create a library created libboost_xx_yy.so?

I think there are exceptions (e.g. math and test).

[conan-center-bot]

Some configurations of 'boost/1.69.0' failed in build 10 (55af03e52b1258ca0b486f26380f533fc67d565c):

• Linux x86_64, Release, gcc 5, libstdc++ . Options: boost:shared-True
  • Log download
  • Log error Download
  • Profile
• Access to all the logs

[madebr]

That makes the dependency tree a lot smaller 😄

I think only math and test are the exceptions (library naming wise)?

{'atomic': [],
 'chrono': ['system'],
 'container': [],
 'context': ['thread'],
 'contract': ['exception', 'thread'],
 'coroutine': ['context', 'exception', 'system', 'thread'],
 'date_time': ['serialization'],
 'exception': [],
 'fiber': ['context', 'filesystem'],
 'filesystem': ['system'],
 'graph': ['math', 'random', 'regex', 'serialization'],
 'graph_parallel': ['filesystem', 'graph', 'mpi', 'random', 'serialization'],
 'iostreams': ['random', 'regex'],
 'locale': ['thread'],
 'log': ['atomic',
         'container',
         'date_time',
         'exception',
         'filesystem',
         'locale',
         'random',
         'regex',
         'system',
         'thread'],
 'math': ['atomic', 'chrono'],
 'mpi': ['graph', 'python', 'serialization'],
 'nowide': ['filesystem'],
 'program_options': [],
 'python': ['graph'],
 'random': ['math', 'system'],
 'regex': [],
 'serialization': [],
 'stacktrace': [],
 'system': [],
 'test': ['exception'],
 'thread': ['atomic',
            'chrono',
            'container',
            'date_time',
            'exception',
            'system'],
 'timer': ['chrono', 'system'],
 'type_erasure': ['thread'],
 'wave': ['filesystem', 'serialization']}

[SSE4]

@madebr maybe serialization as well? (I've seen libraries with name wserialization)

anyway, I think we have few options:

1. hard code names for math and test
2. use pattern-matching (glob, fnmatch) to try to find these libraries

then, we can use the data in recipe to generate components and properly fill cpp_info.libs (in the right order).

also, we need to gather such data for all currently provided boost versions (I guess 1.69.0 - 1.73.0).
then we probably have to somehow document how to generate this data, so we can add one more for new releases (1.74 and so on). maybe we can provide small script or pip module to do that and put some comment in the code?

finally, we have to decide where and how to store that graph. do we need to hard-code it in recipe? I personally don't like it... should we put json or whatever near to the conanfile? sounds better. should we use one json per boost version? probably... could we try to use conandata.yml for that? I doubt as hooks are too restrictive right now for custom fields.

@uilianries @jgsogo what are you thoughts on how to organize this better?

[madebr]

@SSE4
serialization indeed builds serialization and wserialization.
But from its build file, it's unclear to me why it doesn't build both.

I propose the following:

1. Generates a file (yml) with the dependency tree, along with the library names.
2. Use export to copy this file to the export folder.
3. Use this file to populate the components in package_info. For extra error checking, raise an exception if some library is not represented by a component.

Eventually, this process can also be used to populate/cull the options.

Current content of boost dependency info as a .yml file

dependencies:
  atomic: []
  chrono:
  - system
  container: []
  context:
  - thread
  contract:
  - exception
  - thread
  coroutine:
  - context
  - exception
  - system
  - thread
  date_time:
  - serialization
  exception: []
  fiber:
  - context
  - filesystem
  filesystem:
  - system
  graph:
  - math
  - random
  - regex
  - serialization
  graph_parallel:
  - filesystem
  - graph
  - mpi
  - random
  - serialization
  iostreams:
  - random
  - regex
  locale:
  - thread
  log:
  - atomic
  - container
  - date_time
  - exception
  - filesystem
  - locale
  - random
  - regex
  - system
  - thread
  math:
  - atomic
  mpi:
  - graph
  - python
  - serialization
  nowide:
  - filesystem
  program_options: []
  python:
  - graph
  random:
  - math
  - system
  regex: []
  serialization: []
  stacktrace: []
  system: []
  test:
  - exception
  thread:
  - atomic
  - chrono
  - container
  - date_time
  - exception
  - system
  timer:
  - chrono
  - system
  type_erasure:
  - thread
  wave:
  - filesystem
  - serialization
libs:
  atomic:
  - boost_atomic
  chrono:
  - boost_chrono
  container:
  - boost_container
  context:
  - boost_context
  contract:
  - boost_contract
  coroutine:
  - boost_coroutine
  date_time:
  - boost_date_time
  exception:
  - boost_exception
  fiber:
  - boost_fiber
  filesystem:
  - boost_filesystem
  graph:
  - boost_graph
  graph_parallel:
  - boost_graph_parallel
  iostreams:
  - boost_iostreams
  locale:
  - boost_locale
  log:
  - boost_log
  math:
  - boost_math_c99f
  - boost_math_c99l
  - boost_math_c99
  - boost_math_tr1f
  - boost_math_tr1l
  mpi:
  - boost_mpi
  nowide:
  - boost_nowide
  program_options:
  - boost_program_options
  python:
  - boost_python
  random:
  - boost_random
  regex:
  - boost_regex
  serialization:
  - boost_serialization
  - boost_wserialization
  stacktrace:
  - boost_stacktrace
  system:
  - boost_system
  test:
  - boost_test_unit_framework
  thread:
  - boost_thread
  timer:
  - boost_timer
  type_erasure:
  - boost_type_erasure
  wave:
  - boost_wave

[SSE4]

@madebr yes, we still need to reduce the graph, to handle --without option. also, I think MPI isn't built right now, as it requires special setup, but we don't reflect that right now (maybe we need to add an option).
overall, sounds like a good plan. we only need multiple graphs and multiple yaml files per boost version.

[madebr]

I want to safe the dependency information to the export folder,
because it has to be available even when no sources are.
So I have added

    def export(self):
        self.copy(self._dependency_filename, src="dependencies", dst=self.export_folder)

(where self._dependency_filename is "dependencies-1.73.0.yml")

Now my question is:
How can I access self.export_folder in package_info?

[madebr]

@SSE4
How should the dependency graph be interpreted?
e.g. for mpi:

  mpi:
  - graph
  - python
  - serialization

Are these dependencies hard? Does mpi require boost_python?

You wrote earlier that mpi is not built right now, so does that mean that without_mpi=False is an error right now?

[madebr]

Same with graph_parallel, which depends on mpi.

[SSE4]

boost.mpi may build python module, but it's not hard dependency (optional one).
I am not sure if there are more optional boost dependencies. anyway, it appears like boostdep cannot detect them. so we probably will only assume all dependencies are hard requirements for the first iteration.
we have default option without_mpi=False right now, but our package id lies about this, as mpi is silently turned off and not built (it requires you to provide additional configuration via user-config.jam, so right now it's even impossible to enable it).
we probably need to change default option to without_mpi=True and add code like:

if self.options.without_mpi == False:
    raise ConanException("not implemented (yet)")

enabling MPI requires some another dependency, like OpenMPI or Microsoft MPI, neither one is in CCI yet.

[SSE4]

adding @grafikrobot to this thread just in case he wants to add something on boost dependencies relationship

[SSE4]

for @madebr
boost.stacktrace appears to be having name variations as well, see https://github.com/boostorg/stacktrace/blob/develop/build/Jamfile.v2
I am not sure if it's built in default configuration right now, as we also need to supply sort of back-end library for that (such as libbacktrace or libunwind)

[syoliver]

@SSE4 @madebr I used upstream find_package because, it can be generated without modular boost and can be done automatically (adding version "should" be trivial) and then I am sure to have compatible components with upstream (the most important point for me here is the upstream compatibility...)
Given that boostdep is for modular boost then it is not usable with released boost, it doesn't handle nativelly options of the recipe to compute the dependencies.

The issue is that with pre 1.70.0 boost, cmake package were not released, and we should be using cmake's packages.

[jake-at-work]

Perhaps it makes sense to only attempt to support components and their dependencies in version of Boost older than 1.70. Revert to the current behavior of a single monolithic target for those versions.

[conan-center-bot]

Some configurations of 'boost/1.69.0' failed in build 11 (b6ca19b73916ecfe2c5ae1426f7135fbbeeb5e7d):

• Linux x86_64, Release, gcc 5, libstdc++ . Options: boost:shared-True
  • Log download
  • Log error Download
  • Profile
• Access to all the logs

[jgsogo]

I've added a comment here (conan-io/conan#7283 (comment)) that applies to this PR, it is related to how/where to store dependencies information. Please refer to that one, and we can continue here with what's applicable to this PR.

[conan-center-bot]

Some configurations of 'boost/1.69.0' failed in build 12 (325b84eeb6e96d6331dada7e67c745d35a3f222f):

• Linux x86_64, Release, gcc 5, libstdc++ . Options: boost:shared-True
  • Log download
  • Log error Download
  • Profile
• Access to all the logs

[conan-center-bot]

Some configurations of 'boost/1.70.0' failed in build 13 (bc979d0ac57d104348fc154d2c4791871bf3c8d9):

• Linux x86_64, Release, gcc 5, libstdc++ . Options: boost:shared-True
  • Hooks errors detected:
    • [HOOK - conan-center.py] post_package(): ERROR: [CMAKE-MODULES-CONFIG-FILES (KB-H016)] The conan-center repository doesn't allow the packages to contain CMake find modules or config files. The packages have to be located using generators and the declared cpp_infoinformation (https://github.com/conan-io/conan-center-index/wiki/Error-Knowledge-Base#KB-H016)
    • [HOOK - conan-center.py] post_package(): ERROR: [CMAKE-MODULES-CONFIG-FILES (KB-H016)] Found files:
  • Log download
  • Log error Download
  • Profile
• Access to all the logs

[ghost]

I detected other pull requests that are modifying boost/all recipe:

• [boost] Add 'algorithm' lib #3961 #3963
• Boost/1.72.0/mpi #3959
• boost: patch serialization sources #3918
• Boost: Change assertions to warnings #3900
• [boost] Add nowide lib #3894
• boost: add boost/1.75.0 #3872
• Add --disable-icu flag for iconv backend #3855
• Fix boost syntax warning #3522
• Link boost coroutine_exe against CONAN_LIBS #3205
• boost: Correct --disable-iconv option #2657
• boost: fix i18n_backend=icu support for version 1.7{1,2,3}.0 #1704

This message is automatically generated by https://github.com/ericLemanissier/conan-center-conflicting-prs so don't hesitate to report issues/improvements there.

[stale]

This pull request has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.