#882

Committed 31 Aug 2023 07:44PM UTC coverage: 41.798% (-44.7%) from 86.546%

Build # #882

Build Type

push

Committed by

Commit Message

Run Details

19442 of 46514 relevant lines covered (41.8%)

126375.38 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

31.34

/libs/full/components/src/basename_registration.cpp

//  Copyright (c) 2011-2025 Hartmut Kaiser
//
//  SPDX-License-Identifier: BSL-1.0
//  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 <hpx/config.hpp>
#include <hpx/assert.hpp>
#include <hpx/components/basename_registration.hpp>
#include <hpx/components_base/agas_interface.hpp>
#include <hpx/modules/async_combinators.hpp>
#include <hpx/modules/errors.hpp>
#include <hpx/modules/execution.hpp>
#include <hpx/modules/futures.hpp>
#include <hpx/naming_base/id_type.hpp>

#include <cstddef>
#include <string>
#include <utility>
#include <vector>

///////////////////////////////////////////////////////////////////////////
namespace hpx {

    namespace detail {

        std::string name_from_basename(
            std::string const& basename, std::size_t idx)
        {
            HPX_ASSERT(!basename.empty());

            std::string name;
            if (basename[0] != '/')
            {
                name = '/';
            }

            name += basename;
            if (name[name.size() - 1] != '/')
            {
                name += '/';
            }
            name += std::to_string(idx);

            return name;
        }

        std::string name_from_basename(std::string&& basename, std::size_t idx)
        {
            HPX_ASSERT(!basename.empty());

            std::string name;
            if (basename[0] != '/')
            {
                name = '/';
                name += HPX_MOVE(basename);
            }
            else
            {
                name = HPX_MOVE(basename);
            }

            if (name[name.size() - 1] != '/')
            {
                name += '/';
            }
            name += std::to_string(idx);

            return name;
        }
    }    // namespace detail

    ///////////////////////////////////////////////////////////////////////////
    std::vector<hpx::future<hpx::id_type>> find_all_from_basename(
        std::string basename, std::size_t num_ids)
    {
        if (basename.empty())
        {
            HPX_THROW_EXCEPTION(hpx::error::bad_parameter,
                "hpx::find_all_from_basename", "no basename specified");
        }

        std::vector<hpx::future<hpx::id_type>> results;
        for (std::size_t i = 0; i != num_ids; ++i)
        {
            std::string name;
            if (i == num_ids - 1)
            {
                // NOLINTNEXTLINE(bugprone-use-after-move)
                name = detail::name_from_basename(HPX_MOVE(basename), i);
            }
            else
            {
                name = detail::name_from_basename(basename, i);
            }

            results.push_back(
                agas::on_symbol_namespace_event(HPX_MOVE(name), true));
        }
        return results;
    }

    std::vector<hpx::future<hpx::id_type>> find_all_from_basename(
        hpx::launch::sync_policy, std::string base_name, std::size_t num_ids)
    {
        std::vector<hpx::future<hpx::id_type>> results =
            find_all_from_basename(HPX_MOVE(base_name), num_ids);
        hpx::wait_all(results);
        return results;
    }

    std::vector<hpx::future<hpx::id_type>> find_from_basename(
        std::string basename, std::vector<std::size_t> const& ids)
    {
        if (basename.empty())
        {
            HPX_THROW_EXCEPTION(hpx::error::bad_parameter,
                "hpx::find_from_basename", "no basename specified");
        }

        // 26800: Use of a moved from object: ''basename''
#if defined(HPX_MSVC)
#pragma warning(push)
#pragma warning(disable : 26800)
#endif
        std::vector<hpx::future<hpx::id_type>> results;
        for (std::size_t i = 0; i != ids.size(); ++i)
        {
            std::string name;
            if (i == ids.size() - 1)
            {
                // NOLINTNEXTLINE(bugprone-use-after-move)
                name = detail::name_from_basename(HPX_MOVE(basename), i);
            }
            else
            {
                name = detail::name_from_basename(basename, i);
            }

            results.emplace_back(
                agas::on_symbol_namespace_event(HPX_MOVE(name), true));
        }
#if defined(HPX_MSVC)
#pragma warning(pop)
#endif
        return results;
    }

    std::vector<hpx::future<hpx::id_type>> find_from_basename(
        hpx::launch::sync_policy, std::string base_name,
        std::vector<std::size_t> const& ids)
    {
        std::vector<hpx::future<hpx::id_type>> results =
            find_from_basename(HPX_MOVE(base_name), ids);
        hpx::wait_all(results);
        return results;
    }

    hpx::future<hpx::id_type> find_from_basename(
        std::string basename, std::size_t sequence_nr)
    {
        if (basename.empty())
        {
            HPX_THROW_EXCEPTION(hpx::error::bad_parameter,
                "hpx::find_from_basename", "no basename specified");
        }

        if (sequence_nr == ~static_cast<std::size_t>(0))
        {
            sequence_nr = static_cast<std::size_t>(agas::get_locality_id());
        }

        std::string name =
            detail::name_from_basename(HPX_MOVE(basename), sequence_nr);
        return agas::on_symbol_namespace_event(HPX_MOVE(name), true);
    }

    hpx::id_type find_from_basename(
        hpx::launch::sync_policy, std::string basename, std::size_t sequence_nr)
    {
        if (basename.empty())
        {
            HPX_THROW_EXCEPTION(hpx::error::bad_parameter,
                "hpx::find_from_basename", "no basename specified");
        }

        if (sequence_nr == ~static_cast<std::size_t>(0))
        {
            sequence_nr = static_cast<std::size_t>(agas::get_locality_id());
        }

        std::string name =
            detail::name_from_basename(HPX_MOVE(basename), sequence_nr);
        return agas::on_symbol_namespace_event(HPX_MOVE(name), true).get();
    }

    hpx::future<bool> register_with_basename(
        std::string basename, hpx::id_type const& id, std::size_t sequence_nr)
    {
        if (basename.empty())
        {
            HPX_THROW_EXCEPTION(hpx::error::bad_parameter,
                "hpx::register_with_basename", "no basename specified");
        }

        if (sequence_nr == ~static_cast<std::size_t>(0))
        {
            sequence_nr = static_cast<std::size_t>(agas::get_locality_id());
        }

        std::string name =
            detail::name_from_basename(HPX_MOVE(basename), sequence_nr);
        return agas::register_name(HPX_MOVE(name), id);
    }

    bool register_with_basename(hpx::launch::sync_policy, std::string basename,
        hpx::id_type const& id, std::size_t sequence_nr, error_code& ec)
    {
        if (basename.empty())
        {
            HPX_THROW_EXCEPTION(hpx::error::bad_parameter,
                "hpx::register_with_basename", "no basename specified");
        }

        if (sequence_nr == ~static_cast<std::size_t>(0))
        {
            sequence_nr = static_cast<std::size_t>(agas::get_locality_id());
        }

        std::string name =
            detail::name_from_basename(HPX_MOVE(basename), sequence_nr);
        return agas::register_name(hpx::launch::sync, HPX_MOVE(name), id, ec);
    }

    hpx::future<bool> register_with_basename(std::string base_name,
        hpx::future<hpx::id_type> f, std::size_t sequence_nr)
    {
        return f.then(hpx::launch::sync,
            [sequence_nr, base_name = HPX_MOVE(base_name)](
                hpx::future<hpx::id_type>&& f) mutable -> hpx::future<bool> {
                return register_with_basename(
                    HPX_MOVE(base_name), f.get(), sequence_nr);
            });
    }

    hpx::future<hpx::id_type> unregister_with_basename(
        std::string basename, std::size_t sequence_nr)
    {
        if (basename.empty())
        {
            HPX_THROW_EXCEPTION(hpx::error::bad_parameter,
                "hpx::unregister_with_basename", "no basename specified");
        }

        if (sequence_nr == ~static_cast<std::size_t>(0))
        {
            sequence_nr = static_cast<std::size_t>(agas::get_locality_id());
        }

        std::string name =
            detail::name_from_basename(HPX_MOVE(basename), sequence_nr);
        return agas::unregister_name(HPX_MOVE(name));
    }
}    // namespace hpx

1	// Copyright (c) 2011-2025 Hartmut Kaiser
2	//
3	// SPDX-License-Identifier: BSL-1.0
4	// Distributed under the Boost Software License, Version 1.0. (See accompanying
5	// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
6
7	#include <hpx/config.hpp>
8	#include <hpx/assert.hpp>
9	#include <hpx/components/basename_registration.hpp>
10	#include <hpx/components_base/agas_interface.hpp>
11	#include <hpx/modules/async_combinators.hpp>
12	#include <hpx/modules/errors.hpp>
13	#include <hpx/modules/execution.hpp>
14	#include <hpx/modules/futures.hpp>
15	#include <hpx/naming_base/id_type.hpp>
16
17	#include <cstddef>
18	#include <string>
19	#include <utility>
20	#include <vector>
21
22	///////////////////////////////////////////////////////////////////////////
23	namespace hpx {
24
25	namespace detail {
26		×
27	std::string name_from_basename(
28	std::string const& basename, std::size_t idx)
29	{
30	HPX_ASSERT(!basename.empty());
31
32	std::string name;	×
33	if (basename[0] != '/')
34	{
35	name = '/';
36	}
37
38	name += basename;	×
39	if (name[name.size() - 1] != '/')
40	{
41	name += '/';
42	}	×
43	name += std::to_string(idx);
44		×
45	return name;
46	}
47		128✔
48	std::string name_from_basename(std::string&& basename, std::size_t idx)
49	{
50	HPX_ASSERT(!basename.empty());
51
52	std::string name;	128✔
53	if (basename[0] != '/')
54	{
55	name = '/';
56	name += HPX_MOVE(basename);
57	}
58	else
59	{	128✔
60	name = HPX_MOVE(basename);
61	}
62		128✔
63	if (name[name.size() - 1] != '/')
64	{
65	name += '/';
66	}	128✔
67	name += std::to_string(idx);
68		128✔
69	return name;
70	}
71	} // namespace detail
72
73	///////////////////////////////////////////////////////////////////////////	×
74	std::vector<hpx::future<hpx::id_type>> find_all_from_basename(
75	std::string basename, std::size_t num_ids)
76	{	×
77	if (basename.empty())
78	{	×
79	HPX_THROW_EXCEPTION(hpx::error::bad_parameter,
80	"hpx::find_all_from_basename", "no basename specified");
81	}
82		×
83	std::vector<hpx::future<hpx::id_type>> results;	×
84	for (std::size_t i = 0; i != num_ids; ++i)
85	{
86	std::string name;	×
87	if (i == num_ids - 1)	×
88	{
89	// NOLINTNEXTLINE(bugprone-use-after-move)	×
90	name = detail::name_from_basename(HPX_MOVE(basename), i);
91	}
92	else	×
93	{
94	name = detail::name_from_basename(basename, i);	×
95	}	×
96
97	results.push_back(	×
98	agas::on_symbol_namespace_event(HPX_MOVE(name), true));
99	}
100	return results;	×
101	}
102		×
103	std::vector<hpx::future<hpx::id_type>> find_all_from_basename(
104	hpx::launch::sync_policy, std::string base_name, std::size_t num_ids)
105	{
106	std::vector<hpx::future<hpx::id_type>> results =	×
107	find_all_from_basename(HPX_MOVE(base_name), num_ids);	×
108	hpx::wait_all(results);
109	return results;
110	}	×
111		×
112	std::vector<hpx::future<hpx::id_type>> find_from_basename(
113	std::string basename, std::vector<std::size_t> const& ids)	×
114	{
115	if (basename.empty())	×
116	{	×
117	HPX_THROW_EXCEPTION(hpx::error::bad_parameter,
118	"hpx::find_from_basename", "no basename specified");	×
119	}	×
120
121	// 26800: Use of a moved from object: ''basename''	8✔
122	#if defined(HPX_MSVC)
123	#pragma warning(push)
124	#pragma warning(disable : 26800)	8✔
125	#endif
126	std::vector<hpx::future<hpx::id_type>> results;	×
127	for (std::size_t i = 0; i != ids.size(); ++i)
128	{
129	std::string name;
130	if (i == ids.size() - 1)	8✔
131	{
132	// NOLINTNEXTLINE(bugprone-use-after-move)	×
133	name = detail::name_from_basename(HPX_MOVE(basename), i);
134	}
135	else
136	{	8✔
137	name = detail::name_from_basename(basename, i);	16✔
138	}
139
140	results.emplace_back(	60✔
141	agas::on_symbol_namespace_event(HPX_MOVE(name), true));
142	}
143	#if defined(HPX_MSVC)	60✔
144	#pragma warning(pop)
145	#endif	×
146	return results;
147	}
148
149	std::vector<hpx::future<hpx::id_type>> find_from_basename(	60✔
150	hpx::launch::sync_policy, std::string base_name,
151	std::vector<std::size_t> const& ids)	×
152	{
153	std::vector<hpx::future<hpx::id_type>> results =
154	find_from_basename(HPX_MOVE(base_name), ids);
155	hpx::wait_all(results);	60✔
156	return results;	120✔
157	}
158
159	hpx::future<hpx::id_type> find_from_basename(	×
160	std::string basename, std::size_t sequence_nr)
161	{
162	if (basename.empty())	×
163	{
164	HPX_THROW_EXCEPTION(hpx::error::bad_parameter,	×
165	"hpx::find_from_basename", "no basename specified");
166	}
167
168	if (sequence_nr == ~static_cast<std::size_t>(0))	×
169	{
170	sequence_nr = static_cast<std::size_t>(agas::get_locality_id());	×
171	}
172
173	std::string name =
174	detail::name_from_basename(HPX_MOVE(basename), sequence_nr);	×
175	return agas::on_symbol_namespace_event(HPX_MOVE(name), true);	×
176	}
177
178	hpx::id_type find_from_basename(	×
179	hpx::launch::sync_policy, std::string basename, std::size_t sequence_nr)
180	{
181	if (basename.empty())
182	{	×
183	HPX_THROW_EXCEPTION(hpx::error::bad_parameter,	×
184	"hpx::find_from_basename", "no basename specified");
185	}	×
186		×
187	if (sequence_nr == ~static_cast<std::size_t>(0))
188	{
189	sequence_nr = static_cast<std::size_t>(agas::get_locality_id());	60✔
190	}
191
192	std::string name =	60✔
193	detail::name_from_basename(HPX_MOVE(basename), sequence_nr);
194	return agas::on_symbol_namespace_event(HPX_MOVE(name), true).get();	×
195	}
196
197	hpx::future<bool> register_with_basename(
198	std::string basename, hpx::id_type const& id, std::size_t sequence_nr)	60✔
199	{
200	if (basename.empty())	×
201	{
202	HPX_THROW_EXCEPTION(hpx::error::bad_parameter,
203	"hpx::register_with_basename", "no basename specified");
204	}	60✔
205		120✔
206	if (sequence_nr == ~static_cast<std::size_t>(0))
207	{
208	sequence_nr = static_cast<std::size_t>(agas::get_locality_id());
209	}
210
211	std::string name =
212	detail::name_from_basename(HPX_MOVE(basename), sequence_nr);
213	return agas::register_name(HPX_MOVE(name), id);
214	}
215
216	bool register_with_basename(hpx::launch::sync_policy, std::string basename,
217	hpx::id_type const& id, std::size_t sequence_nr, error_code& ec)
218	{
219	if (basename.empty())
220	{
221	HPX_THROW_EXCEPTION(hpx::error::bad_parameter,
222	"hpx::register_with_basename", "no basename specified");
223	}
224
225	if (sequence_nr == ~static_cast<std::size_t>(0))
226	{
227	sequence_nr = static_cast<std::size_t>(agas::get_locality_id());
228	}
229
230	std::string name =
231	detail::name_from_basename(HPX_MOVE(basename), sequence_nr);
232	return agas::register_name(hpx::launch::sync, HPX_MOVE(name), id, ec);
233	}
234
235	hpx::future<bool> register_with_basename(std::string base_name,
236	hpx::future<hpx::id_type> f, std::size_t sequence_nr)
237	{
238	return f.then(hpx::launch::sync,
239	[sequence_nr, base_name = HPX_MOVE(base_name)](
240	hpx::future<hpx::id_type>&& f) mutable -> hpx::future<bool> {
241	return register_with_basename(
242	HPX_MOVE(base_name), f.get(), sequence_nr);
243	});
244	}
245
246	hpx::future<hpx::id_type> unregister_with_basename(
247	std::string basename, std::size_t sequence_nr)
248	{
249	if (basename.empty())
250	{
251	HPX_THROW_EXCEPTION(hpx::error::bad_parameter,
252	"hpx::unregister_with_basename", "no basename specified");
253	}
254
255	if (sequence_nr == ~static_cast<std::size_t>(0))
256	{
257	sequence_nr = static_cast<std::size_t>(agas::get_locality_id());
258	}
259
260	std::string name =
261	detail::name_from_basename(HPX_MOVE(basename), sequence_nr);
262	return agas::unregister_name(HPX_MOVE(name));
263	}
264	} // namespace hpx

STEllAR-GROUP / hpx / #882

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous