11255477262

Committed 09 Oct 2024 12:28PM UTC coverage: 77.697% (+0.08%) from 77.615%

Build # 11255477262

Build Type

Pull #476

github

Committed by

mgeplf

Commit Message

comments

Pull Request Pull Request #476: Efficient swc build

Run Details

286 of 321 new or added lines in 10 files covered. (89.1%)

9 existing lines in 4 files now uncovered.

2125 of 2735 relevant lines covered (77.7%)

901.01 hits per line

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

70.93

/src/warning_handling.cpp

#include <sstream>  // std::ostringstream

#include <morphio/mut/section.h>
#include <morphio/warning_handling.h>
#include <stdexcept>

namespace morphio {
namespace details {
std::string errorLink(const std::string& uri,
                      long unsigned int lineNumber,
                      morphio::readers::ErrorLevel errorLevel) {
    using morphio::readers::ErrorLevel;
    if (uri.empty()) {
        return {};
    }

    const auto SEVERITY = [](ErrorLevel el) {
        switch (el) {
        case ErrorLevel::WARNING:
            return "warning";
        case ErrorLevel::ERROR:
            return "error";
        default:
            throw std::runtime_error("Unknown ErrorLevel");
        }
    };

    auto COLOR = [](ErrorLevel el) {
        switch (el) {
        case ErrorLevel::WARNING:
            return "\033[1;33m";
        case ErrorLevel::ERROR:
            return "\033[1;31m";
        default:
            throw std::runtime_error("Unknown ErrorLevel");
        }
    };

    const std::string COLOR_END("\033[0m");

    return COLOR(errorLevel) + uri + ":" + std::to_string(lineNumber) + ":" + SEVERITY(errorLevel) +
           COLOR_END + "\n";
}
}  // namespace details

std::string WrongDuplicate::msg() const {
    std::string msg("Warning: while appending section: " + std::to_string(current->id()) +
                    " to parent: " + std::to_string(parent->id()));

    if (parent->points().empty()) {
        return "\n" + details::errorLink(uri, 0, readers::ErrorLevel::WARNING) + msg +
               "\nThe parent section is empty.";
    }

    if (current->points().empty()) {
        return "\n" + details::errorLink(uri, 0, readers::ErrorLevel::WARNING) + msg +
               "\nThe current section has no points. It should at "
               "least contains "
               "parent section last point";
    }

    auto p0 = parent->points()[parent->points().size() - 1];
    auto p1 = current->points()[0];
    auto d0 = parent->diameters()[parent->diameters().size() - 1];
    auto d1 = current->diameters()[0];

    std::ostringstream oss;
    oss << msg
        << "\nThe section first point should be parent section last point: "
           "\n        : X Y Z Diameter"
           "\nparent last point :["
        << std::to_string(p0[0]) << ", " << std::to_string(p0[1]) << ", " << std::to_string(p0[2])
        << ", " << std::to_string(d0) << "]\nchild first point :[" << std::to_string(p1[0]) << ", "
        << std::to_string(p1[1]) << ", " << std::to_string(p1[2]) << ", " << std::to_string(d1)
        << "]\n";

    return "\n" + details::errorLink(uri, 0, readers::ErrorLevel::WARNING) + oss.str();
}

bool WarningHandler::isIgnored(enums::Warning warning) {
    return ignoredWarnings_.find(warning) != ignoredWarnings_.end();
}

void WarningHandler::setIgnoredWarning(enums::Warning warning, bool ignore) {
    if (ignore) {
        ignoredWarnings_.insert(warning);
    } else {
        ignoredWarnings_.erase(warning);
    }
}

int32_t WarningHandlerPrinter::getMaxWarningCount() const {
    return maxWarningCount_;
}

void WarningHandlerPrinter::setMaxWarningCount(int32_t warningCount) {
    maxWarningCount_ = warningCount;
}

bool WarningHandlerPrinter::getRaiseWarnings() const {
    return raiseWarnings_;
}
void WarningHandlerPrinter::setRaiseWarnings(bool raise) {
    raiseWarnings_ = raise;
}

void WarningHandlerPrinter::emit(std::shared_ptr<morphio::WarningMessage> wm) {
    const int maxWarningCount = getMaxWarningCount();

    const auto& warning = wm->warning();

    if (isIgnored(warning) || maxWarningCount == 0) {
        return;
    }

    if (getRaiseWarnings()) {
        throw morphio::MorphioError(wm->msg());
    }

    if (maxWarningCount < 0 || errorCount <= static_cast<uint32_t>(maxWarningCount)) {
        std::cerr << wm->msg() << '\n';
        if (maxWarningCount > 0 && errorCount == static_cast<uint32_t>(maxWarningCount)) {
            std::cerr << "Maximum number of warning reached. Next warnings "
                         "won't be displayed.\n"
                         "You can change this number by calling:\n"
                         "\t- C++: set_maximum_warnings(int)\n"
                         "\t- Python: morphio.set_maximum_warnings(int)\n"
                         "0 will print no warning. -1 will print them all\n";
        }
        ++errorCount;
    }
}

int WarningHandlerCollector::getMaxWarningCount() const {
    throw std::runtime_error("WarningHandlerCollector does not implement getMaxWarningCount");
}
void WarningHandlerCollector::setMaxWarningCount(int /*warningCount*/) {
    throw std::runtime_error("WarningHandlerCollector does not implement setMaxWarningCount");
}
bool WarningHandlerCollector::getRaiseWarnings() const {
    throw std::runtime_error("WarningHandlerCollector does not implement getRaiseWarnings");
}
void WarningHandlerCollector::setRaiseWarnings(bool /*raise*/) {
    throw std::runtime_error("WarningHandlerCollector does not implement setRaiseWarnings");
}

void WarningHandlerCollector::emit(std::shared_ptr<WarningMessage> wm) {
    m.emplace_back(isIgnored(wm->warning()), wm);
}

void WarningHandlerCollector::reset() {
    m.erase(m.begin());
}

std::vector<WarningHandlerCollector::Emission> WarningHandlerCollector::getAll() const {
    return m;
}


}  // namespace morphio

1	#include <sstream> // std::ostringstream
2
3	#include <morphio/mut/section.h>
4	#include <morphio/warning_handling.h>
5	#include <stdexcept>
6
7	namespace morphio {
8	namespace details {
9	std::string errorLink(const std::string& uri,	112✔
10	long unsigned int lineNumber,
11	morphio::readers::ErrorLevel errorLevel) {
12	using morphio::readers::ErrorLevel;
13	if (uri.empty()) {	112✔
14	return {};	26✔
15	}
16
17	const auto SEVERITY = [](ErrorLevel el) {	86✔
18	switch (el) {	86✔
19	case ErrorLevel::WARNING:	64✔
20	return "warning";	64✔
21	case ErrorLevel::ERROR:	22✔
22	return "error";	22✔
NEW 23	default:	×
NEW 24	throw std::runtime_error("Unknown ErrorLevel");	×
25	}
26	};
27
28	auto COLOR = [](ErrorLevel el) {	86✔
29	switch (el) {	86✔
30	case ErrorLevel::WARNING:	64✔
31	return "\033[1;33m";	64✔
32	case ErrorLevel::ERROR:	22✔
33	return "\033[1;31m";	22✔
NEW 34	default:	×
NEW 35	throw std::runtime_error("Unknown ErrorLevel");	×
36	}
37	};
38
39	const std::string COLOR_END("\033[0m");	86✔
40
41	return COLOR(errorLevel) + uri + ":" + std::to_string(lineNumber) + ":" + SEVERITY(errorLevel) +	172✔
42	COLOR_END + "\n";	86✔
43	}
44	} // namespace details
45
46	std::string WrongDuplicate::msg() const {	8✔
47	std::string msg("Warning: while appending section: " + std::to_string(current->id()) +	16✔
48	" to parent: " + std::to_string(parent->id()));	24✔
49
50	if (parent->points().empty()) {	8✔
51	return "\n" + details::errorLink(uri, 0, readers::ErrorLevel::WARNING) + msg +	×
52	"\nThe parent section is empty.";	×
53	}
54
55	if (current->points().empty()) {	8✔
56	return "\n" + details::errorLink(uri, 0, readers::ErrorLevel::WARNING) + msg +	×
57	"\nThe current section has no points. It should at "
58	"least contains "
59	"parent section last point";	×
60	}
61
62	auto p0 = parent->points()[parent->points().size() - 1];	8✔
63	auto p1 = current->points()[0];	8✔
64	auto d0 = parent->diameters()[parent->diameters().size() - 1];	8✔
65	auto d1 = current->diameters()[0];	8✔
66
67	std::ostringstream oss;	8✔
68	oss << msg
69	<< "\nThe section first point should be parent section last point: "
70	"\n : X Y Z Diameter"
71	"\nparent last point :["
72	<< std::to_string(p0[0]) << ", " << std::to_string(p0[1]) << ", " << std::to_string(p0[2])	32✔
73	<< ", " << std::to_string(d0) << "]\nchild first point :[" << std::to_string(p1[0]) << ", "	16✔
74	<< std::to_string(p1[1]) << ", " << std::to_string(p1[2]) << ", " << std::to_string(d1)	24✔
75	<< "]\n";	56✔
76
77	return "\n" + details::errorLink(uri, 0, readers::ErrorLevel::WARNING) + oss.str();	16✔
78	}
79
80	bool WarningHandler::isIgnored(enums::Warning warning) {	76✔
81	return ignoredWarnings_.find(warning) != ignoredWarnings_.end();	76✔
82	}
83
UNCOV 84	void WarningHandler::setIgnoredWarning(enums::Warning warning, bool ignore) {	×
UNCOV 85	if (ignore) {	×
UNCOV 86	ignoredWarnings_.insert(warning);	×
87	} else {
UNCOV 88	ignoredWarnings_.erase(warning);	×
89	}
UNCOV 90	}	×
91
92	int32_t WarningHandlerPrinter::getMaxWarningCount() const {	72✔
93	return maxWarningCount_;	72✔
94	}
95
96	void WarningHandlerPrinter::setMaxWarningCount(int32_t warningCount) {	×
97	maxWarningCount_ = warningCount;	×
98	}	×
99
100	bool WarningHandlerPrinter::getRaiseWarnings() const {	72✔
101	return raiseWarnings_;	72✔
102	}
103	void WarningHandlerPrinter::setRaiseWarnings(bool raise) {	×
104	raiseWarnings_ = raise;	×
105	}	×
106
107	void WarningHandlerPrinter::emit(std::shared_ptr<morphio::WarningMessage> wm) {	72✔
108	const int maxWarningCount = getMaxWarningCount();	72✔
109
110	const auto& warning = wm->warning();	72✔
111
112	if (isIgnored(warning) \|\| maxWarningCount == 0) {	72✔
UNCOV 113	return;	×
114	}
115
116	if (getRaiseWarnings()) {	72✔
117	throw morphio::MorphioError(wm->msg());	×
118	}
119
120	if (maxWarningCount < 0 \|\| errorCount <= static_cast<uint32_t>(maxWarningCount)) {	72✔
121	std::cerr << wm->msg() << '\n';	72✔
122	if (maxWarningCount > 0 && errorCount == static_cast<uint32_t>(maxWarningCount)) {	72✔
123	std::cerr << "Maximum number of warning reached. Next warnings "
124	"won't be displayed.\n"
125	"You can change this number by calling:\n"
126	"\t- C++: set_maximum_warnings(int)\n"
127	"\t- Python: morphio.set_maximum_warnings(int)\n"
128	"0 will print no warning. -1 will print them all\n";	×
129	}
130	++errorCount;	72✔
131	}
132	}
133
134	int WarningHandlerCollector::getMaxWarningCount() const {	2✔
135	throw std::runtime_error("WarningHandlerCollector does not implement getMaxWarningCount");	2✔
136	}
137	void WarningHandlerCollector::setMaxWarningCount(int /warningCount/) {	2✔
138	throw std::runtime_error("WarningHandlerCollector does not implement setMaxWarningCount");	2✔
139	}
140	bool WarningHandlerCollector::getRaiseWarnings() const {	2✔
141	throw std::runtime_error("WarningHandlerCollector does not implement getRaiseWarnings");	2✔
142	}
143	void WarningHandlerCollector::setRaiseWarnings(bool /raise/) {	2✔
144	throw std::runtime_error("WarningHandlerCollector does not implement setRaiseWarnings");	2✔
145	}
146
147	void WarningHandlerCollector::emit(std::shared_ptr<WarningMessage> wm) {	4✔
148	m.emplace_back(isIgnored(wm->warning()), wm);	4✔
149	}	4✔
150
151	void WarningHandlerCollector::reset() {	×
152	m.erase(m.begin());	×
153	}	×
154
155	std::vector<WarningHandlerCollector::Emission> WarningHandlerCollector::getAll() const {	4✔
156	return m;	4✔
157	}
158
159
160	} // namespace morphio

BlueBrain / MorphIO / 11255477262

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