Repository: conan-io/conan-center-index

Issue:
Boost components
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.

- [x] I've read the [guidelines](https://github.com/conan-io/conan-center-index/wiki#how-to-submit-a-pull-request) for contributing.
- [x] I've followed the [PEP8](https://www.python.org/dev/peps/pep-0008/) style guides for Python code in the recipes.
- [x] I've used the [latest](https://github.com/conan-io/conan/releases/latest) Conan client version.
- [ ] I've tried at least one configuration locally with the
      [conan-center hook](https://github.com/conan-io/hooks.git) activated.




Discussion:
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](https://c3i.jfrog.io/c3i/misc/logs/pr/1925/1/boost/1.69.0/94354c5f17a10327336411091b1beca86e92cbe9/create_stdout.txt)
    - [Log error Download](https://c3i.jfrog.io/c3i/misc/logs/pr/1925/1/boost/1.69.0/94354c5f17a10327336411091b1beca86e92cbe9/create_stderr.txt)
    - [Profile](https://c3i.jfrog.io/c3i/misc/logs/pr/1925/1/boost/1.69.0/94354c5f17a10327336411091b1beca86e92cbe9/profile.txt)
- [Access to all the logs](https://c3i.jfrog.io/c3i/misc/logs/pr/1925/1/boost/1.69.0/)
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](https://c3i.jfrog.io/c3i/misc/logs/pr/1925/2/boost/1.69.0/94354c5f17a10327336411091b1beca86e92cbe9/create_stdout.txt)
    - [Log error Download](https://c3i.jfrog.io/c3i/misc/logs/pr/1925/2/boost/1.69.0/94354c5f17a10327336411091b1beca86e92cbe9/create_stderr.txt)
    - [Profile](https://c3i.jfrog.io/c3i/misc/logs/pr/1925/2/boost/1.69.0/94354c5f17a10327336411091b1beca86e92cbe9/profile.txt)
- [Access to all the logs](https://c3i.jfrog.io/c3i/misc/logs/pr/1925/2/boost/1.69.0/)
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](https://c3i.jfrog.io/c3i/misc/logs/pr/1925/3/boost/1.69.0/94354c5f17a10327336411091b1beca86e92cbe9/create_stdout.txt)
    - [Log error Download](https://c3i.jfrog.io/c3i/misc/logs/pr/1925/3/boost/1.69.0/94354c5f17a10327336411091b1beca86e92cbe9/create_stderr.txt)
    - [Profile](https://c3i.jfrog.io/c3i/misc/logs/pr/1925/3/boost/1.69.0/94354c5f17a10327336411091b1beca86e92cbe9/profile.txt)
- [Access to all the logs](https://c3i.jfrog.io/c3i/misc/logs/pr/1925/3/boost/1.69.0/)
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](https://c3i.jfrog.io/c3i/misc/logs/pr/1925/4/boost/1.69.0/94354c5f17a10327336411091b1beca86e92cbe9/create_stdout.txt)
    - [Log error Download](https://c3i.jfrog.io/c3i/misc/logs/pr/1925/4/boost/1.69.0/94354c5f17a10327336411091b1beca86e92cbe9/create_stderr.txt)
    - [Profile](https://c3i.jfrog.io/c3i/misc/logs/pr/1925/4/boost/1.69.0/94354c5f17a10327336411091b1beca86e92cbe9/profile.txt)
- [Access to all the logs](https://c3i.jfrog.io/c3i/misc/logs/pr/1925/4/boost/1.69.0/)
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](https://c3i.jfrog.io/c3i/misc/logs/pr/1925/6/boost/1.69.0/94354c5f17a10327336411091b1beca86e92cbe9/create_stdout.txt)
    - [Log error Download](https://c3i.jfrog.io/c3i/misc/logs/pr/1925/6/boost/1.69.0/94354c5f17a10327336411091b1beca86e92cbe9/create_stderr.txt)
    - [Profile](https://c3i.jfrog.io/c3i/misc/logs/pr/1925/6/boost/1.69.0/94354c5f17a10327336411091b1beca86e92cbe9/profile.txt)
- [Access to all the logs](https://c3i.jfrog.io/c3i/misc/logs/pr/1925/6/boost/1.69.0/)
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](https://c3i.jfrog.io/c3i/misc/logs/pr/1925/7/boost/1.69.0/94354c5f17a10327336411091b1beca86e92cbe9/create_stdout.txt)
    - [Log error Download](https://c3i.jfrog.io/c3i/misc/logs/pr/1925/7/boost/1.69.0/94354c5f17a10327336411091b1beca86e92cbe9/create_stderr.txt)
    - [Profile](https://c3i.jfrog.io/c3i/misc/logs/pr/1925/7/boost/1.69.0/94354c5f17a10327336411091b1beca86e92cbe9/profile.txt)
- [Access to all the logs](https://c3i.jfrog.io/c3i/misc/logs/pr/1925/7/boost/1.69.0/)
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](https://www.boost.org/doc/libs/master/tools/boostdep/doc/html/) 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.
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: 
```
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](https://c3i.jfrog.io/c3i/misc/logs/pr/1925/9/boost/1.69.0/94354c5f17a10327336411091b1beca86e92cbe9/create_stdout.txt)
    - [Log error Download](https://c3i.jfrog.io/c3i/misc/logs/pr/1925/9/boost/1.69.0/94354c5f17a10327336411091b1beca86e92cbe9/create_stderr.txt)
    - [Profile](https://c3i.jfrog.io/c3i/misc/logs/pr/1925/9/boost/1.69.0/94354c5f17a10327336411091b1beca86e92cbe9/profile.txt)
- [Access to all the logs](https://c3i.jfrog.io/c3i/misc/logs/pr/1925/9/boost/1.69.0/)
> 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](https://www.boost.org/doc/libs/master/tools/boostdep/doc/html/) 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 https://github.com/conan-io/conan-center-index/pull/1570


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.
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
 

<details>
<summary>dependency tree of boost 1.73.0 modules</summary>

```
{'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']}

```
</details>
```
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).

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](https://c3i.jfrog.io/c3i/misc/logs/pr/1925/10/boost/1.69.0/94354c5f17a10327336411091b1beca86e92cbe9/create_stdout.txt)
    - [Log error Download](https://c3i.jfrog.io/c3i/misc/logs/pr/1925/10/boost/1.69.0/94354c5f17a10327336411091b1beca86e92cbe9/create_stderr.txt)
    - [Profile](https://c3i.jfrog.io/c3i/misc/logs/pr/1925/10/boost/1.69.0/94354c5f17a10327336411091b1beca86e92cbe9/profile.txt)
- [Access to all the logs](https://c3i.jfrog.io/c3i/misc/logs/pr/1925/10/boost/1.69.0/)
That makes the dependency tree a lot smaller :smile: 

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']}
```
@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?
@SSE4 
serialization indeed builds serialization and wserialization. 
But from [its build file](https://github.com/boostorg/serialization/blob/develop/build/Jamfile.v2), 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](https://docs.conan.io/en/latest/reference/conanfile/methods.html#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.


<details>

<summary>Current content of boost dependency info as a .yml file</summary>

```yml
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


```
</details>
@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.
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
```python
    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?**
@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?
Same with `graph_parallel`, which depends on mpi.
boost.mpi [may](https://github.com/boostorg/mpi/blob/develop/build/Jamfile.v2#L72) 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.
adding @grafikrobot to this thread just in case he wants to add something on boost dependencies relationship
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)
@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.
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.
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](https://c3i.jfrog.io/c3i/misc/logs/pr/1925/11/boost/1.69.0/94354c5f17a10327336411091b1beca86e92cbe9/create_stdout.txt)
    - [Log error Download](https://c3i.jfrog.io/c3i/misc/logs/pr/1925/11/boost/1.69.0/94354c5f17a10327336411091b1beca86e92cbe9/create_stderr.txt)
    - [Profile](https://c3i.jfrog.io/c3i/misc/logs/pr/1925/11/boost/1.69.0/94354c5f17a10327336411091b1beca86e92cbe9/profile.txt)
- [Access to all the logs](https://c3i.jfrog.io/c3i/misc/logs/pr/1925/11/boost/1.69.0/)
I've added a comment here (https://github.com/conan-io/conan/issues/7283#issuecomment-652383952) 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.
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](https://c3i.jfrog.io/c3i/misc/logs/pr/1925/12/boost/1.69.0/94354c5f17a10327336411091b1beca86e92cbe9/create_stdout.txt)
    - [Log error Download](https://c3i.jfrog.io/c3i/misc/logs/pr/1925/12/boost/1.69.0/94354c5f17a10327336411091b1beca86e92cbe9/create_stderr.txt)
    - [Profile](https://c3i.jfrog.io/c3i/misc/logs/pr/1925/12/boost/1.69.0/94354c5f17a10327336411091b1beca86e92cbe9/profile.txt)
- [Access to all the logs](https://c3i.jfrog.io/c3i/misc/logs/pr/1925/12/boost/1.69.0/)
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_info` information (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](https://c3i.jfrog.io/c3i/misc/logs/pr/1925/13/boost/1.70.0/94354c5f17a10327336411091b1beca86e92cbe9/create_stdout.txt)
    - [Log error Download](https://c3i.jfrog.io/c3i/misc/logs/pr/1925/13/boost/1.70.0/94354c5f17a10327336411091b1beca86e92cbe9/create_stderr.txt)
    - [Profile](https://c3i.jfrog.io/c3i/misc/logs/pr/1925/13/boost/1.70.0/94354c5f17a10327336411091b1beca86e92cbe9/profile.txt)
- [Access to all the logs](https://c3i.jfrog.io/c3i/misc/logs/pr/1925/13/boost/1.70.0/)

Resolving patch:
diff --git a/recipes/boost/all/conanfile.py b/recipes/boost/all/conanfile.py
--- a/recipes/boost/all/conanfile.py
+++ b/recipes/boost/all/conanfile.py
@@ -4,6 +4,7 @@
 from conans.errors import ConanException
 
 from conans.errors import ConanInvalidConfiguration
+import glob
 import os
 import sys
 import shlex
@@ -34,10 +35,12 @@
     "graph",
     "graph_parallel",
     "iostreams",
+    "json",
     "locale",
     "log",
     "math",
     "mpi",
+    "nowide",
     "program_options",
     "python",
     "random",
@@ -64,7 +67,6 @@ class BoostConan(ConanFile):
 
     _options = None
 
-
     options = {
         "shared": [True, False],
         "header_only": [True, False],
@@ -129,6 +131,26 @@ class BoostConan(ConanFile):
     def export(self):
         self.copy(self._dependency_filename, src="dependencies", dst="dependencies")
 
+    @property
+    def _min_compiler_version_default_cxx11(self):
+        # Minimum compiler version having c++ standard >= 11
+        return {
+            "gcc": 6,
+            "clang": 6,
+            "apple-clang": 12,  # guess
+            "Visual Studio": 14,  # guess
+        }.get(str(self.settings.compiler))
+
+    @property
+    def _min_compiler_version_nowide(self):
+        # Nowide needs c++11 + swappable std::fstream
+        return {
+            "gcc": 5,
+            "clang": 5,
+            "apple-clang": 12,  # guess
+            "Visual Studio": 14,  # guess
+        }.get(str(self.settings.compiler))
+
     @property
     def _dependency_filename(self):
         return "dependencies-{}.yml".format(self.version)
@@ -140,15 +162,18 @@ def _dependencies(self):
             raise ConanException("Cannot find {}".format(dependencies_filepath))
         return yaml.load(open(dependencies_filepath))
 
-    def _iter_modules(self):
-        tree = {k: v[:] for k, v in self._dependencies["dependencies"].items()}
-        while tree:
-            nodeps = set(k for k, v in tree.items() if not v)
-            if not nodeps:
-                raise ConanException("cyclic dependency tree detected")
-            for nodep in nodeps:
-                yield nodep
-            tree = {k: [d for d in v if d not in nodeps] for k, v in tree.items() if k not in nodeps}
+    def _all_dependent_modules(self, name):
+        dependencies = {name}
+        while True:
+            new_dependencies = set()
+            for dependency in dependencies:
+                new_dependencies.update(set(self._dependencies["dependencies"][dependency]))
+                new_dependencies.update(dependencies)
+            if len(new_dependencies) > len(dependencies):
+                dependencies = new_dependencies
+            else:
+                break
+        return dependencies
 
     @property
     def _source_subfolder(self):
@@ -188,6 +213,21 @@ def config_options(self):
             if "without_{}".format(opt_name) not in self.options:
                 raise ConanException("{} has the configure options {} which is not available in conanfile.py".format(self._dependency_filename, opt_name))
 
+        # nowide requires a c++11-able compiler + movable std::fstream: change default to not build on compiler with too old default c++ standard or too low compiler.cppstd
+        # json requires a c++11-able compiler: change default to not build on compiler with too old default c++ standard or too low compiler.cppstd
+        if self.settings.compiler.cppstd:
+            if not tools.valid_min_cppstd(self, 11):
+                self.options.without_fiber = True
+                self.options.without_nowide = True
+                self.options.without_json = True
+        else:
+            version_cxx11_standard_json = self._min_compiler_version_default_cxx11
+            if version_cxx11_standard_json:
+                if tools.Version(self.settings.compiler.version) < version_cxx11_standard_json:
+                    self.options.without_fiber = True
+                    self.options.without_json = True
+                    self.options.without_nowide = True
+
         # Remove options not supported by this version of boost
         for dep_name in CONFIGURE_OPTIONS:
             if dep_name not in self._configure_options:
@@ -198,8 +238,11 @@ def _configure_options(self):
         return self._dependencies["configure_options"]
 
     def configure(self):
-        if not self.options.i18n_backend and not self.options.without_locale:
-            raise ConanInvalidConfiguration("Boost 'locale' library requires a i18n_backend, either 'icu' or 'iconv'")
+        if self.options.without_locale:
+            self.options.i18n_backend = None
+        else:
+            if not self.options.i18n_backend:
+                raise ConanInvalidConfiguration("Boost.locale library requires a i18n_backend (either 'icu' or 'iconv')")
 
         if not self.options.multithreading:
             # * For the reason 'thread' is deactivate look at https://stackoverflow.com/a/20991533
@@ -225,6 +268,44 @@ def configure(self):
                 self.options.python_version = self._detect_python_version()
                 self.options.python_executable = self._python_executable
 
+        if not self.options.get_safe("without_nowide", True):
+            # nowide require a c++11-able compiler with movable std::fstream
+            mincompiler_version = self._min_compiler_version_nowide
+            if mincompiler_version:
+                if tools.Version(self.settings.compiler.version) < mincompiler_version:
+                    raise ConanInvalidConfiguration("This compiler is too old to build Boost.nowide.")
+
+            if self.settings.compiler.cppstd:
+                tools.check_min_cppstd(self, 11)
+            else:
+                version_cxx11_standard = self._min_compiler_version_default_cxx11
+                if version_cxx11_standard:
+                    if tools.Version(self.settings.compiler.version) < version_cxx11_standard:
+                        raise ConanInvalidConfiguration("Boost.{fiber,json} require a c++11 compiler (please set compiler.cppstd or use a newer compiler)")
+                else:
+                    self.output.warn("I don't know what the default c++ standard of this compiler is. I suppose it supports c++11 by default.\n"
+                                     "This might cause some boost libraries not being built and conan components to fail.")
+
+        # FIXME: check this + shouldn't default be on self._is_msvc?
+        # if self.options.layout == "b2-default":
+        #     self.options.layout = "versioned" if self.settings.os == "Windows" else "system"
+
+        if not all((self.options.without_fiber, self.options.get_safe("without_json", True))):
+            # fiber/json require a c++11-able compiler.
+            if self.settings.compiler.cppstd:
+                tools.check_min_cppstd(self, 11)
+            else:
+                version_cxx11_standard = self._min_compiler_version_default_cxx11
+                if version_cxx11_standard:
+                    if tools.Version(self.settings.compiler.version) < version_cxx11_standard:
+                        raise ConanInvalidConfiguration("Boost.{fiber,json} requires a c++11 compiler (please set compiler.cppstd or use a newer compiler)")
+                else:
+                    self.output.warn("I don't know what the default c++ standard of this compiler is. I suppose it supports c++11 by default.\n"
+                                     "This might cause some boost libraries not being built and conan components to fail.")
+
+        if self.options.layout == "b2-default":
+            self.options.layout = "versioned" if self.settings.os == "Windows" else "system"
+
     def build_requirements(self):
         if not self.options.header_only:
             self.build_requires("b2/4.2.0")
@@ -584,7 +665,7 @@ def _b2_os(self):
 
     @property
     def _b2_address_model(self):
-        if str(self.settings.arch) in ["x86_64", "ppc64", "ppc64le", "mips64", "armv8", "sparcv9"]:
+        if self.settings.arch in ("x86_64", "ppc64", "ppc64le", "mips64", "armv8", "armv8.3", "sparcv9"):
             return "64"
         else:
             return "32"
@@ -651,6 +732,9 @@ def _gnu_cxx11_abi(self):
     def _build_flags(self):
         flags = self._build_cross_flags
 
+        # Stop at the first error. No need to continue building.
+        flags.append("-q")
+
         # https://www.boost.org/doc/libs/1_70_0/libs/context/doc/html/context/architectures.html
         if self._b2_os:
             flags.append("target-os=%s" % self._b2_os)
@@ -663,8 +747,7 @@ def _build_flags(self):
         if self._b2_abi:
             flags.append("abi=%s" % self._b2_abi)
 
-        if self.options.layout is not "b2-default":
-            flags.append("--layout=%s" % self.options.layout)
+        flags.append("--layout=%s" % self.options.layout)
         flags.append("--user-config=%s" % os.path.join(self._boost_build_dir, 'user-config.jam'))
         flags.append("-sNO_ZLIB=%s" % ("0" if self._with_zlib else "1"))
         flags.append("-sNO_BZIP2=%s" % ("0" if self._with_bzip2 else "1"))
@@ -707,14 +790,17 @@ def add_defines(library):
             flags.append("variant=release")
 
         for libname in self._configure_options:
-            if getattr(self.options, "without_%s" % libname):
-                flags.append("--without-%s" % libname)
+            if not getattr(self.options, "without_%s" % libname):
+                flags.append("--with-%s" % libname)
 
         flags.append("toolset=%s" % self._toolset)
 
         if self.settings.get_safe("compiler.cppstd"):
             flags.append("cxxflags=%s" % cppstd_flag(self.settings))
 
+        # LDFLAGS
+        link_flags = []
+
         # CXX FLAGS
         cxx_flags = []
         # fPIC DEFINITION
@@ -727,18 +813,19 @@ def add_defines(library):
             elif self.settings.compiler == "Visual Studio":
                 cxx_flags.append("/Z7")
 
+
         # Standalone toolchain fails when declare the std lib
-        if self.settings.os != "Android" and self.settings.os != "Emscripten":
+        if self.settings.os not in ("Android", "Emscripten"):
             try:
                 if self._gnu_cxx11_abi:
                     flags.append("define=_GLIBCXX_USE_CXX11_ABI=%s" % self._gnu_cxx11_abi)
 
-                if "clang" in str(self.settings.compiler):
-                    if str(self.settings.compiler.libcxx) == "libc++":
-                        cxx_flags.append("-stdlib=libc++")
-                        flags.append('linkflags="-stdlib=libc++"')
-                    else:
-                        cxx_flags.append("-stdlib=libstdc++")
+                if self.settings.compiler in ("clang", "apple-clang"):
+                    libcxx = {
+                        "libstdc++11": "libstdc++",
+                    }.get(str(self.settings.compiler.libcxx), str(self.settings.compiler.libcxx))
+                    cxx_flags.append("-stdlib={}".format(libcxx))
+                    link_flags.append("-stdlib={}".format(libcxx))
             except:
                 pass
 
@@ -770,6 +857,21 @@ def add_defines(library):
             cxx_flags.append("-fvisibility-inlines-hidden")
             cxx_flags.append("-fembed-bitcode")
 
+        if self._with_iconv:
+            flags.append("-sICONV_PATH={}".format(self.deps_cpp_info["libiconv"].rootpath))
+        if self._with_icu:
+            flags.append("-sICU_PATH={}".format(self.deps_cpp_info["icu"].rootpath))
+            if not self.options["icu"].shared:
+                # Using ICU_OPTS to pass ICU system libraries is not possible due to Boost.Regex disallowing it.
+                if self.settings.compiler == "Visual Studio":
+                    icu_ldflags = " ".join("{}.lib".format(l) for l in self.deps_cpp_info["icu"].system_libs)
+                else:
+                    icu_ldflags = " ".join("-l{}".format(l) for l in self.deps_cpp_info["icu"].system_libs)
+                link_flags.append(icu_ldflags)
+
+        link_flags = 'linkflags="%s"' % " ".join(link_flags) if link_flags else ""
+        flags.append(link_flags)
+
         cxx_flags = 'cxxflags="%s"' % " ".join(cxx_flags) if cxx_flags else ""
         flags.append(cxx_flags)
 
@@ -982,6 +1084,15 @@ def package(self):
                 self.output.info("Unlinking static duplicate library: {}".format(os.path.join(self.package_folder, "lib", "lib{}.lib".format(common_lib))))
                 os.unlink(os.path.join(self.package_folder, "lib", "lib{}.lib".format(common_lib)))
 
+        dll_pdbs = glob.glob(os.path.join(self.package_folder, "lib", "*.dll")) + \
+                    glob.glob(os.path.join(self.package_folder, "lib", "*.pdb"))
+        if dll_pdbs:
+            tools.mkdir(os.path.join(self.package_folder, "bin"))
+            for bin_file in dll_pdbs:
+                os.rename(bin_file, os.path.join(self.package_folder, "bin", os.path.basename(bin_file)))
+
+        tools.remove_files_by_mask(os.path.join(self.package_folder, "bin"), "*.pdb")
+
     def _create_emscripten_libs(self):
         # Boost Build doesn't create the libraries, but it gets close,
         # leaving .bc files where the libraries would be.
@@ -998,11 +1109,6 @@ def _create_emscripten_libs(self):
                 self.output.info(cmd)
                 self.run(cmd)
 
-    @property
-    def _is_versioned_layout(self):
-        layout = self.options.get_safe("layout")
-        return layout == "versioned" or (layout == "b2-default" and os.name == 'nt')
-
     @staticmethod
     def _option_to_conan_requirement(name):
         return {
@@ -1042,7 +1148,7 @@ def package_info(self):
             if self.options.error_code_header_only:
                 self.cpp_info.components["headers"].defines.append("BOOST_ERROR_CODE_HEADER_ONLY")
 
-        if self._is_versioned_layout:
+        if self.options.layout == "versioned":
             version = tools.Version(self.version)
             self.cpp_info.components["headers"].includedirs.append(os.path.join("include", "boost-{}_{}".format(version.major, version.minor)))
 
@@ -1053,7 +1159,6 @@ def package_info(self):
 
         if not self.options.header_only:
             self.cpp_info.components["_libboost"].requires = ["headers"]
-            self.cpp_info.components["_libboost"].bindirs.append("lib")
 
             self.cpp_info.components["diagnostic_definitions"].libs = []
             self.cpp_info.components["diagnostic_definitions"].names["cmake_find_package"] = "diagnostic_definitions"
@@ -1086,34 +1191,45 @@ def package_info(self):
                 # A Boost::dynamic_linking cmake target does only make sense for a shared boost package
                 self.cpp_info.components["dynamic_linking"].defines = ["BOOST_ALL_DYN_LINK"]
 
-            libsuffix = ""
-            if self._is_versioned_layout:
-                # https://www.boost.org/doc/libs/1_73_0/more/getting_started/windows.html#library-naming
-                toolset_tag = "-{}".format(self._toolset_tag)
-                threading_tag = "-mt" if self.options.multithreading else ""
-                abi_tag = ""
-                if self._is_msvc:
-                    # FIXME: add 'y' when using cpython cci package and when python is built in debug mode
-                    static_runtime_key = "s" if "MT" in str(self.settings.compiler.runtime) else ""
-                    debug_runtime_key = "g" if "d" in str(self.settings.compiler.runtime) else ""
-                    debug_key = "d" if self.settings.build_type == "Debug" else ""
-                    abi = static_runtime_key + debug_runtime_key + debug_key
-                    if abi:
-                        abi_tag = "-{}".format(abi)
-                else:
-                    debug_tag = "d" if self.settings.build_type == "Debug" else ""
-                    abi = debug_tag
-                    if abi:
-                        abi_tag = "-{}".format(abi)
-
-                arch_tag = "-{}{}".format(self._b2_architecture[0], self._b2_address_model)
-                version = tools.Version(self.version)
-                if not version.patch or version.patch == "0":
-                    version_tag = "-{}_{}".format(version.major, version.minor)
-                else:
-                    version_tag = "-{}_{}_{}".format(version.major, version.minor, version.patch)
-                libsuffix = toolset_tag + threading_tag + abi_tag + arch_tag + version_tag
-                self.output.info("Versioning library suffix: {}".format(libsuffix))
+            # https://www.boost.org/doc/libs/1_73_0/more/getting_started/windows.html#library-naming
+            # libsuffix for MSVC:
+            # - system: ""
+            # - versioned: "-vc142-mt-d-x64-1_74"
+            # - tagged: "-mt-d-x64"
+            libsuffix_lut = {
+                "system": "",
+                "versioned": "{toolset}{threading}{abi}{arch}{version}",
+                "tagged": "{threading}{abi}{arch}",
+            }
+            libsuffix_data = {
+                "toolset": "-{}".format(self._toolset_tag),
+                "threading": "-mt" if self.options.multithreading else "",
+                "abi": "",
+                "ach": "",
+                "version": "",
+            }
+            if self._is_msvc:  # FIXME: mingw?
+                # FIXME: add 'y' when using cpython cci package and when python is built in debug mode
+                static_runtime_key = "s" if "MT" in str(self.settings.compiler.runtime) else ""
+                debug_runtime_key = "g" if "d" in str(self.settings.compiler.runtime) else ""
+                debug_key = "d" if self.settings.build_type == "Debug" else ""
+                abi = static_runtime_key + debug_runtime_key + debug_key
+                if abi:
+                    libsuffix_data["abi"] = "-{}".format(abi)
+            else:
+                debug_tag = "d" if self.settings.build_type == "Debug" else ""
+                abi = debug_tag
+                if abi:
+                    libsuffix_data["abi"] = "-{}".format(abi)
+
+            libsuffix_data["arch"] = "-{}{}".format(self._b2_architecture[0], self._b2_address_model)
+            version = tools.Version(self.version)
+            if not version.patch or version.patch == "0":
+                libsuffix_data["version"] = "-{}_{}".format(version.major, version.minor)
+            else:
+                libsuffix_data["version"] = "-{}_{}_{}".format(version.major, version.minor, version.patch)
+            libsuffix = libsuffix_lut[str(self.options.layout)].format(**libsuffix_data)
+            self.output.info("Library layout suffix: {}".format(repr(libsuffix)))
 
             libformatdata = {}
             if not self.options.without_python:
@@ -1131,14 +1247,16 @@ def add_libprefix(n):
             modules_seen = set()
             detected_libraries = set(tools.collect_libs(self))
             used_libraries = set()
-            for module in self._iter_modules():
-                if self.options.get_safe("without_{}".format(module), False) or not all(d in modules_seen for d in self._dependencies["dependencies"][module]):
+
+            for module in self._dependencies["dependencies"].keys():
+                missing_depmodules = list(depmodule for depmodule in self._all_dependent_modules(module) if self.options.get_safe("without_{}".format(depmodule), False))
+                if missing_depmodules:
                     continue
 
                 module_libraries = [add_libprefix(lib.format(**libformatdata)) + libsuffix for lib in self._dependencies["libs"][module]]
                 if all(l in detected_libraries for l in module_libraries):
                     modules_seen.add(module)
-                    used_libraries = used_libraries.union(module_libraries)
+                    used_libraries.update(module_libraries)
                     self.cpp_info.components[module].libs = module_libraries
 
                     self.cpp_info.components[module].requires = self._dependencies["dependencies"][module] + ["_libboost"]
@@ -1152,10 +1270,10 @@ def add_libprefix(n):
                         if self.options.get_safe(requirement, None) == False:
                             continue
                         conan_requirement = self._option_to_conan_requirement(requirement)
-                        if not conan_requirement:
+                        if conan_requirement not in self.requires:
                             continue
-                        if conan_requirement in ("icu", "iconv"):
-                            if conan_requirement != self.options.get_safe("i18n_backend"):
+                        if module == "locale" and requirement in ("icu", "iconv"):
+                            if requirement != self.options.i18n_backend:
                                 continue
                         self.cpp_info.components[module].requires.append("{0}::{0}".format(conan_requirement))
 
@@ -1194,3 +1312,10 @@ def add_libprefix(n):
                         self.cpp_info.components["_libboost"].cxxflags.append("-pthread")
                         self.cpp_info.components["_libboost"].sharedlinkflags.extend(["-pthread","--shared-memory"])
                         self.cpp_info.components["_libboost"].exelinkflags.extend(["-pthread","--shared-memory"])
+            elif self.settings.os == "iOS":
+                if self.options.multithreading:
+                    # https://github.com/conan-io/conan-center-index/issues/3867
+                    # runtime crashes occur when using the default platform-specific reference counter/atomic
+                    self.cpp_info.components["headers"].defines.extend(["BOOST_AC_USE_PTHREADS", "BOOST_SP_USE_PTHREADS"])
+                else:
+                    self.cpp_info.components["headers"].defines.extend(["BOOST_AC_DISABLE_THREADS", "BOOST_SP_DISABLE_THREADS"])
diff --git a/recipes/boost/all/rebuild-dependencies.py b/recipes/boost/all/rebuild-dependencies.py
--- a/recipes/boost/all/rebuild-dependencies.py
+++ b/recipes/boost/all/rebuild-dependencies.py
@@ -38,10 +38,12 @@
     "graph",
     "graph_parallel",
     "iostreams",
+    "json",
     "locale",
     "log",
     "math",
     "mpi",
+    "nowide",
     "program_options",
     "python",
     "random",
@@ -149,6 +151,9 @@ def do_git_submodule_update(self):
             print("Re-init git submodules")
             subprocess.check_call(["git", "submodule", "update", "--init"])
 
+            print("Removing unknown files/directories")
+            subprocess.check_call(["git", "clean", "-d", "-f"])
+
     def do_install_boostdep(self):
         with tools.chdir(str(self.boost_path)):
             print("Installing boostdep/{}".format(self.boostdep_version))
@@ -224,8 +229,8 @@ def _sort_requirements(self, requirements: List[str]) -> Tuple[List[str], Dict[s
     def do_boostdep_collect(self) -> BoostDependencies:
         with tools.chdir(str(self.boost_path)):
             with tools.environment_append({"PATH": self._bin_paths}):
-                buildables = subprocess.check_output(["boostdep", "--list-buildable"])
-                buildables = buildables.decode().splitlines()
+                buildables = subprocess.check_output(["boostdep", "--list-buildable"], text=True)
+                buildables = buildables.splitlines()
                 log.debug("`boostdep --list--buildable` returned these buildables: %s", buildables)
 
                 # modules = subprocess.check_output(["boostdep", "--list-modules"])
@@ -234,10 +239,18 @@ def do_boostdep_collect(self) -> BoostDependencies:
                 dep_modules = buildables
 
                 dependency_tree = {}
-                for module in dep_modules:
-                    module_ts_output = subprocess.check_output(["boostdep", "--track-sources", module])
-                    mod_deps = re.findall("\n([A-Za-z_-]+):\n", module_ts_output.decode())
-                    dependency_tree[module] = mod_deps
+                buildable_dependencies = subprocess.check_output(["boostdep", "--list-buildable-dependencies"], text=True)
+                log.debug("boosdep --list-buildable-dependencies returnes: %s", buildable_dependencies)
+                for line in buildable_dependencies.splitlines():
+                    if re.match(r"^[\s]*#.*", line):
+                        continue
+                    match = re.match(r"([\S]+)\s*=\s*([^;]+)\s*;\s*", line)
+                    if not match:
+                        continue
+                    master = match.group(1)
+                    dependencies = re.split(r"\s+", match.group(2).strip())
+                    dependency_tree[master] = dependencies
+
                 log.debug("Using `boostdep --track-sources`, the following dependency tree was calculated:")
                 log.debug(pprint.pformat(dependency_tree))
 
@@ -308,6 +321,12 @@ def _fix_dependencies(self, deptree: Dict[str, List[str]]) -> Dict[str, List[str
         if "mpi_python" in deptree and "python" not in deptree["mpi_python"]:
             deptree["mpi_python"].append("python")
 
+        # Break random/math dependency cycle
+        try:
+            deptree["math"].remove("random")
+        except ValueError:
+            pass
+
         remaining_tree = self.detect_cycles(deptree)
         if remaining_tree:
             raise Exception("Dependency cycle detected. Remaining tree: {}".format(remaining_tree))
@@ -389,7 +408,6 @@ def _sort_item(cls, item):
         elif isinstance(item, list):
             return list(cls._sort_item(e) for e in sorted(item))
         else:
-            print("UNKNOWN", type(item), item)
             return item
 
     def do_create_dependency_file(self) -> None:
@@ -413,7 +431,7 @@ def main(args=None) -> int:
     parser = argparse.ArgumentParser()
     parser.add_argument("--verbose", dest="verbose", action="store_true", help="verbose output")
     parser.add_argument("-t", dest="tmppath", help="temporary folder where to clone boost (default is system temporary folder)")
-    parser.add_argument("-d", dest="boostdep_version", default="1.74.0", type=str, help="boostdep version")
+    parser.add_argument("-d", dest="boostdep_version", default="1.75.0", type=str, help="boostdep version")
     parser.add_argument("-u", dest="git_url", default=BOOST_GIT_URL, help="boost git url")
     parser.add_argument("-U", dest="git_update", action="store_true", help="update the git repo")
     parser.add_argument("-o", dest="outputdir", default=None, type=Path, help="output dependency dir")
@@ -438,7 +456,6 @@ def main(args=None) -> int:
     ns.outputdir.mkdir(exist_ok=True)
 
     git_update_done = False
-    boostdep_installed = False
 
     if ns.boost_version is None:
         conan_data = yaml.safe_load(Path("conandata.yml").open())
@@ -467,9 +484,7 @@ def main(args=None) -> int:
 
         boost_collector.do_git_submodule_update()
 
-        if not boostdep_installed:
-            boost_collector.do_install_boostdep()
-            boostdep_installed = True
+        boost_collector.do_install_boostdep()
 
         boost_collector.do_create_dependency_file()
     return 0


Test patch:
diff --git a/recipes/boost/all/test_package/CMakeLists.txt b/recipes/boost/all/test_package/CMakeLists.txt
--- a/recipes/boost/all/test_package/CMakeLists.txt
+++ b/recipes/boost/all/test_package/CMakeLists.txt
@@ -35,6 +35,30 @@ if(NOT HEADER_ONLY)
         target_link_libraries(chrono_exe PRIVATE Boost::chrono)
     endif()
 
+    if(WITH_FIBER)
+        find_package(Boost COMPONENTS fiber REQUIRED)
+        add_executable(fiber_exe fiber.cpp)
+        target_link_libraries(fiber_exe PRIVATE Boost::fiber)
+    endif()
+
+    if(WITH_JSON)
+        find_package(Boost COMPONENTS json REQUIRED)
+        add_executable(json_exe json.cpp)
+        target_link_libraries(json_exe PRIVATE Boost::json)
+    endif()
+
+    if(WITH_NOWIDE)
+        find_package(Boost COMPONENTS nowide REQUIRED)
+        add_executable(nowide_exe nowide.cpp)
+        target_link_libraries(nowide_exe PRIVATE Boost::nowide)
+    endif()
+
+    if(WITH_LOCALE)
+        find_package(Boost COMPONENTS locale REQUIRED)
+        add_executable(locale_exe locale.cpp)
+        target_link_libraries(locale_exe PRIVATE Boost::locale)
+    endif()
+
     if(WITH_PYTHON)
         find_package(Boost COMPONENTS python REQUIRED)
         add_library(hello_ext MODULE python.cpp)
diff --git a/recipes/boost/all/test_package/conanfile.py b/recipes/boost/all/test_package/conanfile.py
--- a/recipes/boost/all/test_package/conanfile.py
+++ b/recipes/boost/all/test_package/conanfile.py
@@ -1,12 +1,18 @@
 from conans import ConanFile, CMake, tools
+from conans.errors import ConanException
 import os
-import sys
 
 
 class TestPackageConan(ConanFile):
     settings = "os", "compiler", "arch", "build_type"
     generators = "cmake", "cmake_find_package"
 
+    def _boost_option(self, name, default):
+        try:
+            return getattr(self.options["boost"], name, default)
+        except (AttributeError, ConanException):
+            return default
+
     def build(self):
         # FIXME: tools.vcvars added for clang-cl. Remove once conan supports clang-cl properly. (https://github.com/conan-io/conan-center-index/pull/1453)
         with tools.vcvars(self.settings) if (self.settings.os == "Windows" and self.settings.compiler == "clang") else tools.no_op():
@@ -24,6 +30,10 @@ def build(self):
             cmake.definitions["WITH_TEST"] = not self.options["boost"].without_test
             cmake.definitions["WITH_COROUTINE"] = not self.options["boost"].without_coroutine
             cmake.definitions["WITH_CHRONO"] = not self.options["boost"].without_chrono
+            cmake.definitions["WITH_FIBER"] = not self.options["boost"].without_fiber
+            cmake.definitions["WITH_LOCALE"] = not self.options["boost"].without_locale
+            cmake.definitions["WITH_NOWIDE"] = not self._boost_option("without_nowide", True)
+            cmake.definitions["WITH_JSON"] = not self._boost_option("without_json", True)
             cmake.configure()
             cmake.build()
 
@@ -43,6 +53,14 @@ def test(self):
             self.run(os.path.join("bin", "coroutine_exe"), run_environment=True)
         if not self.options["boost"].without_chrono:
             self.run(os.path.join("bin", "chrono_exe"), run_environment=True)
+        if not self.options["boost"].without_fiber:
+            self.run(os.path.join("bin", "fiber_exe"), run_environment=True)
+        if not self.options["boost"].without_locale:
+            self.run(os.path.join("bin", "locale_exe"), run_environment=True)
+        if not self._boost_option("without_nowide", True):
+            self.run("{} {}".format(os.path.join("bin", "nowide_exe"), os.path.join(self.source_folder, "conanfile.py")), run_environment=True)
+        if not self._boost_option("without_json", True):
+            self.run(os.path.join("bin", "json_exe"), run_environment=True)
         if not self.options["boost"].without_python:
             with tools.environment_append({"PYTHONPATH": "{}:{}".format("bin", "lib")}):
                 self.run("{} {}".format(self.options["boost"].python_executable, os.path.join(self.source_folder, "python.py")), run_environment=True)
diff --git a/recipes/boost/all/test_package/fiber.cpp b/recipes/boost/all/test_package/fiber.cpp
new file mode 100644
--- /dev/null
+++ b/recipes/boost/all/test_package/fiber.cpp
@@ -0,0 +1,130 @@
+//          Copyright Nat Goodspeed + Oliver Kowalke 2015.
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+
+#include <chrono>
+#include <condition_variable>
+#include <cstddef>
+#include <deque>
+#include <iomanip>
+#include <iostream>
+#include <mutex>
+#include <sstream>
+#include <string>
+#include <thread>
+
+#include <boost/assert.hpp>
+
+#include <boost/fiber/all.hpp>
+
+#include <boost/fiber/detail/thread_barrier.hpp>
+
+static std::size_t fiber_count{ 0 };
+static std::mutex mtx_count{};
+static boost::fibers::condition_variable_any cnd_count{};
+typedef std::unique_lock< std::mutex > lock_type;
+
+/*****************************************************************************
+ *   example fiber function
+ *****************************************************************************/
+//[fiber_fn_ws
+void whatevah( char me) {
+    try {
+        std::thread::id my_thread = std::this_thread::get_id(); /**< get ID of initial thread >*/
+        {
+            std::ostringstream buffer;
+            buffer << "fiber " << me << " started on thread " << my_thread << '\n';
+            std::cout << buffer.str() << std::flush;
+        }
+        for ( unsigned i = 0; i < 10; ++i) { /**< loop ten times >*/
+            boost::this_fiber::yield(); /**< yield to other fibers >*/
+            std::thread::id new_thread = std::this_thread::get_id(); /**< get ID of current thread >*/
+            if ( new_thread != my_thread) { /**< test if fiber was migrated to another thread >*/
+                my_thread = new_thread;
+                std::ostringstream buffer;
+                buffer << "fiber " << me << " switched to thread " << my_thread << '\n';
+                std::cout << buffer.str() << std::flush;
+            }
+        }
+    } catch ( ... ) {
+    }
+    lock_type lk( mtx_count);
+    if ( 0 == --fiber_count) { /**< Decrement fiber counter for each completed fiber. >*/
+        lk.unlock();
+        cnd_count.notify_all(); /**< Notify all fibers waiting on `cnd_count`. >*/
+    }
+}
+//]
+
+/*****************************************************************************
+ *   example thread function
+ *****************************************************************************/
+//[thread_fn_ws
+void thread( boost::fibers::detail::thread_barrier * b) {
+    std::ostringstream buffer;
+    buffer << "thread started " << std::this_thread::get_id() << std::endl;
+    std::cout << buffer.str() << std::flush;
+    boost::fibers::use_scheduling_algorithm< boost::fibers::algo::shared_work >(); /**<
+                                                                                    Install the scheduling algorithm `boost::fibers::algo::shared_work` in order to
+                                                                                    join the work sharing.
+                                                                                    >*/
+    b->wait(); /**< sync with other threads: allow them to start processing >*/
+    lock_type lk( mtx_count);
+    cnd_count.wait( lk, [](){ return 0 == fiber_count; } ); /**<
+                                                             Suspend main fiber and resume worker fibers in the meanwhile.
+                                                             Main fiber gets resumed (e.g returns from `condition_variable_any::wait()`)
+                                                             if all worker fibers are complete.
+                                                             >*/
+    BOOST_ASSERT( 0 == fiber_count);
+}
+//]
+
+/*****************************************************************************
+ *   main()
+ *****************************************************************************/
+int main( int argc, char *argv[]) {
+    std::cout << "main thread started " << std::this_thread::get_id() << std::endl;
+    //[main_ws
+    boost::fibers::use_scheduling_algorithm< boost::fibers::algo::shared_work >(); /*<
+                                                                                    Install the scheduling algorithm `boost::fibers::algo::shared_work` in the main thread
+                                                                                    too, so each new fiber gets launched into the shared pool.
+                                                                                    >*/
+
+    for ( char c : std::string("abcdefghijklmnopqrstuvwxyz")) { /*<
+                                                                 Launch a number of worker fibers; each worker fiber picks up a character
+                                                                 that is passed as parameter to fiber-function `whatevah`.
+                                                                 Each worker fiber gets detached.
+                                                                 >*/
+        boost::fibers::fiber([c](){ whatevah( c); }).detach();
+        ++fiber_count; /*< Increment fiber counter for each new fiber. >*/
+    }
+    boost::fibers::detail::thread_barrier b( 4);
+    std::thread threads[] = { /*<
+                               Launch a couple of threads that join the work sharing.
+                               >*/
+        std::thread( thread, & b),
+        std::thread( thread, & b),
+        std::thread( thread, & b)
+    };
+    b.wait(); /*< sync with other threads: allow them to start processing >*/
+    {
+        lock_type/*< `lock_type` is typedef'ed as __unique_lock__< [@http://en.cppreference.com/w/cpp/thread/mutex `std::mutex`] > >*/ lk( mtx_count);
+        cnd_count.wait( lk, [](){ return 0 == fiber_count; } ); /*<
+                                                                 Suspend main fiber and resume worker fibers in the meanwhile.
+                                                                 Main fiber gets resumed (e.g returns from `condition_variable_any::wait()`)
+                                                                 if all worker fibers are complete.
+                                                                 >*/
+    } /*<
+       Releasing lock of mtx_count is required before joining the threads, otherwise
+       the other threads would be blocked inside condition_variable::wait() and
+       would never return (deadlock).
+       >*/
+    BOOST_ASSERT( 0 == fiber_count);
+    for ( std::thread & t : threads) { /*< wait for threads to terminate >*/
+        t.join();
+    }
+    //]
+    std::cout << "done." << std::endl;
+    return EXIT_SUCCESS;
+}
diff --git a/recipes/boost/all/test_package/json.cpp b/recipes/boost/all/test_package/json.cpp
new file mode 100644
--- /dev/null
+++ b/recipes/boost/all/test_package/json.cpp
@@ -0,0 +1,18 @@
+#include <boost/json.hpp>
+using namespace boost::json;
+
+#include <string>
+#include <iostream>
+
+int main() {
+    object obj;
+    obj[ "pi" ] = 3.141;
+    obj[ "happy" ] = true;
+    obj[ "name" ] = "Boost";
+    obj[ "nothing" ] = nullptr;
+    obj[ "answer" ].emplace_object()["everything"] = 42;
+    obj[ "list" ] = { 1, 0, 2 };
+    obj[ "object" ] = { {"currency", "USD"}, {"value", 42.99} };
+    std::string s = serialize(obj);
+    std::cout << s << '\n';
+}
diff --git a/recipes/boost/all/test_package/locale.cpp b/recipes/boost/all/test_package/locale.cpp
new file mode 100644
--- /dev/null
+++ b/recipes/boost/all/test_package/locale.cpp
@@ -0,0 +1,56 @@
+//
+//  Copyright (c) 2009-2011 Artyom Beilis (Tonkikh)
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+#include <boost/locale.hpp>
+#include <iostream>
+#include <iomanip>
+#include <ctime>
+int main()
+{
+    using namespace boost::locale;
+    generator gen;
+    std::locale::global(gen(""));
+    std::cout.imbue(std::locale());
+    // Setup environment
+    boost::locale::date_time now;
+    date_time start=now;
+    // Set the first day of the first month of this year
+    start.set(period::month(),now.minimum(period::month()));
+    start.set(period::day(),start.minimum(period::day()));
+    int current_year = period::year(now);
+    // Display current year
+    std::cout << format("{1,ftime='%Y'}") % now << std::endl;
+    //
+    // Run forward untill current year is the date
+    //
+    for(now=start; period::year(now) == current_year;) {
+        // Print heading of month
+        if(calendar().is_gregorian())
+            std::cout << format("{1,ftime='%B'}") % now <<std::endl;
+        else
+            std::cout << format("{1,ftime='%B'} ({1,ftime='%Y-%m-%d',locale=en} - {2,locale=en,ftime='%Y-%m-%d'})")
+                % now
+                % date_time(now,now.maximum(period::day())*period::day()) << std::endl;
+        int first = calendar().first_day_of_week();
+        // Print weeks days
+        for(int i=0;i<7;i++) {
+            date_time tmp(now,period::day_of_week() * (first + i));
+            std::cout << format("{1,w=8,ftime='%a'} ") % tmp;
+        }
+        std::cout << std::endl;
+        int current_month = now / period::month();
+        int skip = now / period::day_of_week_local() - 1;
+        for(int i=0;i<skip*9;i++)
+            std::cout << ' ';
+        for(;now / period::month() == current_month ;now += period::day()) {
+            std::cout << format("{1,w=8,ftime='%e'} ") % now;
+            if(now / period::day_of_week_local() == 7)
+                std::cout << std::endl;
+        }
+        std::cout << std::endl;
+    }
+}
diff --git a/recipes/boost/all/test_package/nowide.cpp b/recipes/boost/all/test_package/nowide.cpp
new file mode 100644
--- /dev/null
+++ b/recipes/boost/all/test_package/nowide.cpp
@@ -0,0 +1,30 @@
+// This include fixes the following error on MSVC2019/static/MD with boost/1.73.0:
+// error C2027: use of undefined type 'std::basic_ios<char,std::char_traits<char>>'
+#include <ios>
+
+#include <boost/nowide/args.hpp>
+#include <boost/nowide/fstream.hpp>
+#include <boost/nowide/iostream.hpp>
+int main(int argc,char **argv)
+{
+    boost::nowide::args a(argc,argv); // Fix arguments - make them UTF-8
+    if(argc!=2) {
+        boost::nowide::cerr << "Usage: file_name" << std::endl; // Unicode aware console
+        return 1;
+    }
+    boost::nowide::ifstream f(argv[1]); // argv[1] - is UTF-8
+    if(!f) {
+        // the console can display UTF-8
+        boost::nowide::cerr << "Can't open " << argv[1] << std::endl;
+        return 1;
+    }
+    int total_lines = 0;
+    while(f) {
+        if(f.get() == '\n')
+            total_lines++;
+    }
+    f.close();
+    // the console can display UTF-8
+    boost::nowide::cout << "File " << argv[1] << " has " << total_lines << " lines" << std::endl;
+    return 0;
+}