#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

79.17

/libs/full/parcelset_base/src/locality.cpp

//  Copyright (c)      2014 Thomas Heller
//  Copyright (c) 2007-2024 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/modules/errors.hpp>
#include <hpx/modules/serialization.hpp>
#include <hpx/modules/type_support.hpp>
#include <hpx/modules/util.hpp>

#include <hpx/parcelset_base/locality.hpp>
#include <hpx/parcelset_base/locality_interface.hpp>

#include <string>
#include <utility>

///////////////////////////////////////////////////////////////////////////////
namespace hpx::parcelset {

    locality::locality(locality const& other)
      : impl_(other.impl_ ? other.impl_->clone() : nullptr)
    {
    }

    locality::locality(locality&& other) noexcept
      : impl_(other.impl_ ? other.impl_->move() : nullptr)
    {
    }

    locality& locality::operator=(locality const& other)
    {
        if (this != &other)
        {
            if (other.impl_)
            {
                impl_.reset(other.impl_->clone());
            }
            else
            {
                impl_.reset();
            }
        }
        return *this;
    }

    locality& locality::operator=(locality&& other) noexcept
    {
        if (this != &other)
        {
            if (other.impl_)
            {
                impl_.reset(other.impl_->move());
            }
            else
            {
                impl_.reset();
            }
        }
        return *this;
    }

    ///////////////////////////////////////////////////////////////////////////
    bool operator==(locality const& lhs, locality const& rhs)
    {
        if (lhs.impl_ == rhs.impl_)
            return true;
        if (!lhs.impl_ || !rhs.impl_)
            return false;
        return lhs.impl_->equal(*rhs.impl_);
    }

    bool operator!=(locality const& lhs, locality const& rhs)
    {
        return !(lhs == rhs);
    }

    bool operator<(locality const& lhs, locality const& rhs)
    {
        if (lhs.impl_ == rhs.impl_)
            return false;
        if (!lhs.impl_ || !rhs.impl_)
            return false;
        return lhs.impl_->less_than(*rhs.impl_);
    }

    bool operator>(locality const& lhs, locality const& rhs)
    {
        if (lhs.impl_ == rhs.impl_)
            return false;
        if (!lhs.impl_ || !rhs.impl_)
            return false;
        return !(lhs < rhs) && lhs != rhs;
    }

    ///////////////////////////////////////////////////////////////////////////
    std::ostream& operator<<(std::ostream& os, locality const& l)
    {
        if (!l.impl_)
            return os;
        return l.impl_->print(os);
    }

    ///////////////////////////////////////////////////////////////////////////
    void locality::save(
        [[maybe_unused]] serialization::output_archive& ar, unsigned int) const
    {
#if defined(HPX_HAVE_NETWORKING)
        std::string const t = type();
        ar << t;
        if (t.empty())
        {
            return;
        }

        impl_->save(ar);
#else
        HPX_THROW_EXCEPTION(hpx::error::invalid_status, "locality::save",
            "this shouldn't be called if networking is disabled");
#endif
    }

    void locality::load(
        [[maybe_unused]] serialization::input_archive& ar, unsigned int)
    {
#if defined(HPX_HAVE_NETWORKING)
        std::string t;
        ar >> t;
        if (t.empty())
        {
            return;
        }

        impl_ = HPX_MOVE(create_locality(t).impl_);
        impl_->load(ar);
        HPX_ASSERT(impl_->valid());
#else
        HPX_THROW_EXCEPTION(hpx::error::invalid_status, "locality::load",
            "this shouldn't be called if networking is disabled");
#endif
    }

    std::ostream& operator<<(std::ostream& os, endpoints_type const& endpoints)
    {
        hpx::util::ios_flags_saver ifs(os);
        os << "[ ";
        for (endpoints_type::value_type const& loc : endpoints)
        {
            os << "(" << loc.first << ":" << loc.second << ") ";
        }
        os << "]";

        return os;
    }
}    // namespace hpx::parcelset

1	// Copyright (c) 2014 Thomas Heller
2	// Copyright (c) 2007-2024 Hartmut Kaiser
3	//
4	// SPDX-License-Identifier: BSL-1.0
5	// Distributed under the Boost Software License, Version 1.0. (See accompanying
6	// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
7
8	#include <hpx/config.hpp>
9	#include <hpx/assert.hpp>
10	#include <hpx/modules/errors.hpp>
11	#include <hpx/modules/serialization.hpp>
12	#include <hpx/modules/type_support.hpp>
13	#include <hpx/modules/util.hpp>
14
15	#include <hpx/parcelset_base/locality.hpp>
16	#include <hpx/parcelset_base/locality_interface.hpp>
17
18	#include <string>
19	#include <utility>
20
21	///////////////////////////////////////////////////////////////////////////////
22	namespace hpx::parcelset {
23
24	locality::locality(locality const& other)	2,239✔
25	: impl_(other.impl_ ? other.impl_->clone() : nullptr)	2,239✔
26	{
27	}	2,239✔
28
29	locality::locality(locality&& other) noexcept	68✔
30	: impl_(other.impl_ ? other.impl_->move() : nullptr)	68✔
31	{
32	}	68✔
33
34	locality& locality::operator=(locality const& other)	19✔
35	{
36	if (this != &other)	19✔
37	{
38	if (other.impl_)	19✔
39	{
40	impl_.reset(other.impl_->clone());	19✔
41	}
42	else
43	{
44	impl_.reset();
45	}
46	}
47	return *this;	19✔
48	}
49
50	locality& locality::operator=(locality&& other) noexcept	12✔
51	{
52	if (this != &other)	12✔
53	{
54	if (other.impl_)	12✔
55	{
56	impl_.reset(other.impl_->move());	6✔
57	}
58	else
59	{
60	impl_.reset();
61	}
62	}
63	return *this;	12✔
64	}
65
66	///////////////////////////////////////////////////////////////////////////
67	bool operator==(locality const& lhs, locality const& rhs)	×
68	{
69	if (lhs.impl_ == rhs.impl_)	×
70	return true;
71	if (!lhs.impl_ \|\| !rhs.impl_)	×
72	return false;
73	return lhs.impl_->equal(*rhs.impl_);	×
74	}
75
76	bool operator!=(locality const& lhs, locality const& rhs)	×
77	{
78	return !(lhs == rhs);	×
79	}
80
81	bool operator<(locality const& lhs, locality const& rhs)	4,056✔
82	{
83	if (lhs.impl_ == rhs.impl_)	4,056✔
84	return false;
85	if (!lhs.impl_ \|\| !rhs.impl_)	4,056✔
86	return false;
87	return lhs.impl_->less_than(*rhs.impl_);	4,056✔
88	}
89
90	bool operator>(locality const& lhs, locality const& rhs)	×
91	{
92	if (lhs.impl_ == rhs.impl_)	×
93	return false;
94	if (!lhs.impl_ \|\| !rhs.impl_)	×
95	return false;
96	return !(lhs < rhs) && lhs != rhs;	×
97	}
98
99	///////////////////////////////////////////////////////////////////////////
100	std::ostream& operator<<(std::ostream& os, locality const& l)	10✔
101	{
102	if (!l.impl_)	10✔
103	return os;
104	return l.impl_->print(os);	10✔
105	}
106
107	///////////////////////////////////////////////////////////////////////////
108	void locality::save(	69✔
109	[[maybe_unused]] serialization::output_archive& ar, unsigned int) const
110	{
111	#if defined(HPX_HAVE_NETWORKING)
112	std::string const t = type();	69✔
113	ar << t;
114	if (t.empty())	69✔
115	{
116	return;
117	}
118
119	impl_->save(ar);	69✔
120	#else
121	HPX_THROW_EXCEPTION(hpx::error::invalid_status, "locality::save",
122	"this shouldn't be called if networking is disabled");
123	#endif
124	}
125
126	void locality::load(	23✔
127	[[maybe_unused]] serialization::input_archive& ar, unsigned int)
128	{
129	#if defined(HPX_HAVE_NETWORKING)
130	std::string t;
131	ar >> t;
132	if (t.empty())	23✔
133	{
134	return;
135	}
136
137	impl_ = HPX_MOVE(create_locality(t).impl_);	46✔
138	impl_->load(ar);	23✔
139	HPX_ASSERT(impl_->valid());
140	#else
141	HPX_THROW_EXCEPTION(hpx::error::invalid_status, "locality::load",
142	"this shouldn't be called if networking is disabled");
143	#endif
144	}
145
146	std::ostream& operator<<(std::ostream& os, endpoints_type const& endpoints)	34✔
147	{
148	hpx::util::ios_flags_saver ifs(os);	34✔
149	os << "[ ";	34✔
150	for (endpoints_type::value_type const& loc : endpoints)	44✔
151	{
152	os << "(" << loc.first << ":" << loc.second << ") ";	10✔
153	}
154	os << "]";	34✔
155
156	return os;	34✔
157	}
158	} // namespace hpx::parcelset

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