#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

0.0

/libs/core/serialization/src/detail/polymorphic_nonintrusive_factory.cpp

//  Copyright (c) 2014 Thomas Heller
//  Copyright (c) 2015 Anton Bikineev
//  Copyright (c) 2015 Andreas Schaefer
//
//  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/modules/errors.hpp>
#include <hpx/serialization/detail/polymorphic_nonintrusive_factory.hpp>
#include <hpx/serialization/serialize.hpp>
#include <hpx/serialization/string.hpp>

#include <string>
#include <typeinfo>

namespace hpx::serialization::detail {

    polymorphic_nonintrusive_factory&
    polymorphic_nonintrusive_factory::instance()
    {
        static polymorphic_nonintrusive_factory factory;
        return factory;
    }

    void polymorphic_nonintrusive_factory::register_class(
        std::type_info const& typeinfo, std::string const& class_name,
        function_bunch_type const& bunch)
    {
        if (!typeinfo.name() && std::string(typeinfo.name()).empty())
        {
            HPX_THROW_EXCEPTION(hpx::error::serialization_error,
                "polymorphic_nonintrusive_factory::register_class",
                "Cannot register a factory with an empty type name");
        }
        if (class_name.empty())
        {
            HPX_THROW_EXCEPTION(hpx::error::serialization_error,
                "polymorphic_nonintrusive_factory::register_class",
                "Cannot register a factory with an empty name");
        }

        if (auto const it = map_.find(class_name); it == map_.end())
        {
            map_[class_name] = bunch;
        }

        if (auto const jt = typeinfo_map_.find(typeinfo.name());
            jt == typeinfo_map_.end())
        {
            typeinfo_map_[typeinfo.name()] = class_name;
        }
    }

    void* polymorphic_nonintrusive_factory::load_create(
        input_archive& ar, std::string const&) const
    {
        std::string class_name;
        ar >> class_name;

        function_bunch_type const& bunch = map_.at(class_name);
        return bunch.create_function(ar);
    }

    void polymorphic_nonintrusive_factory::load_void(input_archive& ar,
        [[maybe_unused]] std::string const& name, void* p) const
    {
        std::string class_name;
        ar >> class_name;

        if (std::string const expected_class_name = typeinfo_map_.at(name);
            class_name != expected_class_name)
        {
            HPX_THROW_EXCEPTION(hpx::error::serialization_error,
                "polymorphic_nonintrusive_factory::register_class",
                "Unexpected (non-matching) type received (received: {}, "
                "expected: {})",
                class_name, expected_class_name);
        }

        map_.at(class_name).load_function(ar, p);
    }

    void polymorphic_nonintrusive_factory::save_void(
        output_archive& ar, std::string const& name, void const* p) const
    {
        std::string const class_name = typeinfo_map_.at(name);
        ar << class_name;

        map_.at(class_name).save_function(ar, p);
    }
}    // namespace hpx::serialization::detail

1	// Copyright (c) 2014 Thomas Heller
2	// Copyright (c) 2015 Anton Bikineev
3	// Copyright (c) 2015 Andreas Schaefer
4	//
5	// SPDX-License-Identifier: BSL-1.0
6	// Distributed under the Boost Software License, Version 1.0.
7	// See accompanying file LICENSE_1_0.txt or copy at
8	// http://www.boost.org/LICENSE_1_0.txt)
9
10	#include <hpx/modules/errors.hpp>
11	#include <hpx/serialization/detail/polymorphic_nonintrusive_factory.hpp>
12	#include <hpx/serialization/serialize.hpp>
13	#include <hpx/serialization/string.hpp>
14
15	#include <string>	×
16	#include <typeinfo>
17
18	namespace hpx::serialization::detail {	×
19
20	polymorphic_nonintrusive_factory&
21	polymorphic_nonintrusive_factory::instance()
22	{
23	static polymorphic_nonintrusive_factory factory;
24	return factory;
25	}
26
27	void polymorphic_nonintrusive_factory::register_class(
28	std::type_info const& typeinfo, std::string const& class_name,
29	function_bunch_type const& bunch)
30	{
31	if (!typeinfo.name() && std::string(typeinfo.name()).empty())
32	{
33	HPX_THROW_EXCEPTION(hpx::error::serialization_error,
34	"polymorphic_nonintrusive_factory::register_class",
35	"Cannot register a factory with an empty type name");
36	}
37	if (class_name.empty())
38	{
39	HPX_THROW_EXCEPTION(hpx::error::serialization_error,
40	"polymorphic_nonintrusive_factory::register_class",
41	"Cannot register a factory with an empty name");
42	}
43
44	if (auto const it = map_.find(class_name); it == map_.end())
45	{
46	map_[class_name] = bunch;
47	}
48
49	if (auto const jt = typeinfo_map_.find(typeinfo.name());
50	jt == typeinfo_map_.end())
51	{
52	typeinfo_map_[typeinfo.name()] = class_name;
53	}
54	}
55
56	void* polymorphic_nonintrusive_factory::load_create(
57	input_archive& ar, std::string const&) const
58	{
59	std::string class_name;
60	ar >> class_name;
61
62	function_bunch_type const& bunch = map_.at(class_name);
63	return bunch.create_function(ar);
64	}
65
66	void polymorphic_nonintrusive_factory::load_void(input_archive& ar,
67	[[maybe_unused]] std::string const& name, void* p) const
68	{
69	std::string class_name;
70	ar >> class_name;
71
72	if (std::string const expected_class_name = typeinfo_map_.at(name);
73	class_name != expected_class_name)
74	{
75	HPX_THROW_EXCEPTION(hpx::error::serialization_error,
76	"polymorphic_nonintrusive_factory::register_class",
77	"Unexpected (non-matching) type received (received: {}, "
78	"expected: {})",
79	class_name, expected_class_name);
80	}
81
82	map_.at(class_name).load_function(ar, p);
83	}
84
85	void polymorphic_nonintrusive_factory::save_void(
86	output_archive& ar, std::string const& name, void const* p) const
87	{
88	std::string const class_name = typeinfo_map_.at(name);
89	ar << class_name;
90
91	map_.at(class_name).save_function(ar, p);
92	}
93	} // namespace hpx::serialization::detail

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