31952604910

Committed 16 Aug 2026 02:24PM UTC coverage: 19.438% (+3.2%) from 16.231%

Build # 31952604910

Build Type

push

github

Committed by

jcelerier

Commit Message

execution: fix a crash that has been lurking since 2018 in execution cleanup

Coverage Stats

0 of 1 new or added line in 1 file covered. (0.0%)

2699 existing lines in 72 files now uncovered.

41088 of 211385 relevant lines covered (19.44%)

4325.7 hits per line

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

14.75

/src/plugins/score-lib-device/Device/ItemModels/NodeDisplayMethods.cpp

// This is an open source non-commercial project. Dear PVS-Studio, please check
// it. PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
#include "NodeDisplayMethods.hpp"

#include <State/Domain.hpp>
#include <State/Value.hpp>
#include <State/ValueConversion.hpp>

#include <Device/Address/AddressSettings.hpp>
#include <Device/Address/IOType.hpp>
#include <Device/Node/DeviceNode.hpp>
#include <Device/Protocol/DeviceInterface.hpp>
#include <Device/Protocol/DeviceSettings.hpp>

#include <ossia/network/domain/domain.hpp>
#include <ossia/network/value/value_conversion.hpp>

#include <QBrush>
#include <QFont>
#include <qnamespace.h>

namespace ossia
{

// TODO MOVEME
template <>
QVariant convert(const ossia::value& val)
{
  struct vis
  {
  public:
    using return_type = QVariant;
    return_type operator()(const ossia::impulse& v) const
    {
      return QVariant::fromValue(v);
    }
    return_type operator()(int i) const { return QVariant::fromValue(i); }
    return_type operator()(float f) const { return QVariant::fromValue(f); }
    return_type operator()(bool b) const { return QVariant::fromValue(b); }
    return_type operator()(const std::string& s) const
    {
      return QString::fromStdString(s);
    }
    return_type operator()(char c) const { return QVariant::fromValue(QChar(c)); }

    return_type operator()(ossia::vec2f t) const { return QVector2D{t[0], t[1]}; }
    return_type operator()(ossia::vec3f t) const { return QVector3D{t[0], t[1], t[2]}; }
    return_type operator()(ossia::vec4f t) const
    {
      return QVector4D{t[0], t[1], t[2], t[3]};
    }
    return_type operator()(const std::vector<ossia::value>& t) const
    {
      QVariantList arr;
      arr.reserve(t.size());

      for(const auto& elt : t)
      {
        arr.push_back(ossia::apply_nonnull(*this, elt.v));
      }

      return arr;
    }
    return_type operator()(const ossia::value_map_type& t) const
    {
      QVariantMap arr;

      for(const auto& [k, v] : t)
      {
        arr.insert(QString::fromStdString(k), ossia::apply_nonnull(*this, v));
      }

      return arr;
    }
    return_type operator()() const { return {}; }
  };

  return val.apply(vis{});
}
}
namespace Device
{
QVariant nameColumnData(const Device::Node& node, int role)
{
  static const QFont& italicFont{[]() {
    static QFont f;
    f.setItalic(true);
    return f;
  }()};

  using namespace score;

  const auto ioType = node.get<Device::AddressSettings>().ioType;
  switch(role)
  {
    case Qt::DisplayRole:
    case Qt::EditRole:
      return node.displayName();
    case Qt::FontRole: {
      if(ioType == ossia::access_mode::GET || ioType == ossia::access_mode::SET)
      {
        return italicFont;
      }
      return {};
    }
    case Qt::ForegroundRole: {
      if(ioType == ossia::access_mode::GET || ioType == ossia::access_mode::SET)
      {
        return QBrush(Qt::lightGray);
      }
      return {};
    }
    default:
      return {};
  }
}

QVariant deviceNameColumnData(const Device::Node& node, bool connected, int role)
{
  static const QFont& italicFont{[]() {
    static QFont f;
    f.setItalic(true);
    return f;
  }()};

  using namespace score;

  switch(role)
  {
    case Qt::DisplayRole: {
      const auto& name = node.get<DeviceSettings>().name;
      return connected ? name : name + " (disconnected)";
    }
    case Qt::EditRole:
      return node.get<DeviceSettings>().name;
    case Qt::FontRole: {
      if(!connected)
        return italicFont;
      return {};
    }
    default:
      return {};
  }
}

QVariant valueColumnData(const Device::Node& node, int role)
{
  using namespace score;
  if(node.is<DeviceSettings>())
    return {};

  if(role == Qt::DisplayRole || role == Qt::EditRole)
  {
    const ossia::value& val = node.get<AddressSettings>().value;
    if(ossia::is_array(val))
    {
      return State::convert::toPrettyString(val);
    }
    else if(role == Qt::DisplayRole && val.get_type() == ossia::val_type::FLOAT)
    {
      // Done here explicitely to avoid Qt's default scientific notation QLocale conversion
      return State::convert::toPrettyString(*val.target<float>());
    }
    else
    {
      return State::convert::value<QVariant>(val);
    }
  }
  else if(role == Qt::ForegroundRole)
  {
    const auto ioType = node.get<AddressSettings>().ioType;

    if(ioType)
    {
      switch(*ioType)
      {
        case ossia::access_mode::GET:
          return QBrush(Qt::darkGray);
        case ossia::access_mode::SET:
          return QBrush(Qt::lightGray);
        default:
          return {};
      }
    }
  }

  return {};
}

QVariant GetColumnData(const Device::Node& node, int role)
{
  using namespace score;
  if(node.is<DeviceSettings>())
    return {};

  /*
  if(role == Qt::DisplayRole || role == Qt::EditRole)
  {
      switch(node.get<AddressSettings>().ioType)
      {
          case ossia::access_mode::GET:    return true;
          case ossia::access_mode::SET:   return false;
          case ossia::access_mode::BI: return true;
          case IOType::Invalid: return QVariant{};
          default:            return QVariant{};
      }
  }
  */

  if(role == Qt::CheckStateRole)
  {
    const auto ioType = node.get<AddressSettings>().ioType;
    if(ioType)
    {
      switch(*ioType)
      {
        case ossia::access_mode::GET:
          return Qt::Checked;
        case ossia::access_mode::SET:
          return Qt::Unchecked;
        case ossia::access_mode::BI:
          return Qt::Checked;
      }
    }
    return Qt::Unchecked;
  }

  return {};
}
QVariant SetColumnData(const Device::Node& node, int role)
{
  using namespace score;
  if(node.is<DeviceSettings>())
    return {};

  /*
  if(role == Qt::DisplayRole || role == Qt::EditRole)
  {
      switch(node.get<AddressSettings>().ioType)
      {
          case ossia::access_mode::GET:    return false;
          case ossia::access_mode::SET:   return true;
          case ossia::access_mode::BI: return true;
          case IOType::Invalid: return true;
          default:            return QVariant{};
      }
  }
  */

  if(role == Qt::CheckStateRole)
  {
    const auto ioType = node.get<AddressSettings>().ioType;
    if(ioType)
    {
      switch(*ioType)
      {
        case ossia::access_mode::GET:
          return Qt::Unchecked;
        case ossia::access_mode::SET:
          return Qt::Checked;
        case ossia::access_mode::BI:
          return Qt::Checked;
      }
    }
    return Qt::Unchecked;
  }
  return {};
}

QVariant minColumnData(const Device::Node& node, int role)
{
  using namespace score;
  if(node.is<DeviceSettings>())
    return {};

  if(role == Qt::DisplayRole || role == Qt::EditRole)
  {
    return node.get<AddressSettings>().domain.get().convert_min<QVariant>();
  }

  return {};
}

QVariant maxColumnData(const Device::Node& node, int role)
{
  using namespace score;
  if(node.is<DeviceSettings>())
    return {};

  if(role == Qt::DisplayRole || role == Qt::EditRole)
  {
    return node.get<AddressSettings>().domain.get().convert_max<QVariant>();
  }

  return {};
}
}

1	// This is an open source non-commercial project. Dear PVS-Studio, please check
2	// it. PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
3	#include "NodeDisplayMethods.hpp"
4
5	#include <State/Domain.hpp>
6	#include <State/Value.hpp>
7	#include <State/ValueConversion.hpp>
8
9	#include <Device/Address/AddressSettings.hpp>
10	#include <Device/Address/IOType.hpp>
11	#include <Device/Node/DeviceNode.hpp>
12	#include <Device/Protocol/DeviceInterface.hpp>
13	#include <Device/Protocol/DeviceSettings.hpp>
14
15	#include <ossia/network/domain/domain.hpp>
16	#include <ossia/network/value/value_conversion.hpp>
17
18	#include <QBrush>
19	#include <QFont>
20	#include <qnamespace.h>
21
22	namespace ossia
23	{
24
25	// TODO MOVEME
26	template <>
27	QVariant convert(const ossia::value& val)	×
28	{
29	struct vis
30	{
31	public:
32	using return_type = QVariant;
33	return_type operator()(const ossia::impulse& v) const	×
34	{
35	return QVariant::fromValue(v);	×
36	}
37	return_type operator()(int i) const { return QVariant::fromValue(i); }	×
38	return_type operator()(float f) const { return QVariant::fromValue(f); }	×
39	return_type operator()(bool b) const { return QVariant::fromValue(b); }	×
40	return_type operator()(const std::string& s) const	×
41	{
42	return QString::fromStdString(s);	×
43	}	×
44	return_type operator()(char c) const { return QVariant::fromValue(QChar(c)); }
45
46	return_type operator()(ossia::vec2f t) const { return QVector2D{t[0], t[1]}; }	×
47	return_type operator()(ossia::vec3f t) const { return QVector3D{t[0], t[1], t[2]}; }	×
48	return_type operator()(ossia::vec4f t) const	×
49	{
50	return QVector4D{t[0], t[1], t[2], t[3]};	×
51	}
52	return_type operator()(const std::vector<ossia::value>& t) const	×
53	{
54	QVariantList arr;	×
55	arr.reserve(t.size());	×
56
57	for(const auto& elt : t)	×
58	{
59	arr.push_back(ossia::apply_nonnull(*this, elt.v));	×
60	}
61
62	return arr;	×
63	}	×
64	return_type operator()(const ossia::value_map_type& t) const	×
65	{
66	QVariantMap arr;	×
67
68	for(const auto& [k, v] : t)	×
69	{
70	arr.insert(QString::fromStdString(k), ossia::apply_nonnull(*this, v));	×
71	}
72
73	return arr;	×
74	}	×
75	return_type operator()() const { return {}; }	×
76	};
77
78	return val.apply(vis{});	×
79	}
80	}
81	namespace Device
82	{
83	QVariant nameColumnData(const Device::Node& node, int role)	41✔
84	{
85	static const QFont& italicFont{[]() {	42✔
86	static QFont f;	1✔
87	f.setItalic(true);	1✔
88	return f;	1✔
89	}()};	×
90
91	using namespace score;
92
93	const auto ioType = node.get<Device::AddressSettings>().ioType;	41✔
94	switch(role)	41✔
95	{
96	case Qt::DisplayRole:
97	case Qt::EditRole:
98	return node.displayName();	41✔
99	case Qt::FontRole: {
100	if(ioType == ossia::access_mode::GET \|\| ioType == ossia::access_mode::SET)	×
101	{
102	return italicFont;	×
103	}
104	return {};	×
105	}
106	case Qt::ForegroundRole: {
107	if(ioType == ossia::access_mode::GET \|\| ioType == ossia::access_mode::SET)	×
108	{
109	return QBrush(Qt::lightGray);	×
110	}
111	return {};	×
112	}
113	default:
114	return {};	×
115	}
116	}	41✔
117
118	QVariant deviceNameColumnData(const Device::Node& node, bool connected, int role)	19✔
119	{
120	static const QFont& italicFont{[]() {	20✔
121	static QFont f;	1✔
122	f.setItalic(true);	1✔
123	return f;	1✔
124	}()};	×
125
126	using namespace score;
127
128	switch(role)	19✔
129	{
130	case Qt::DisplayRole: {
131	const auto& name = node.get<DeviceSettings>().name;	19✔
132	return connected ? name : name + " (disconnected)";	19✔
133	}
134	case Qt::EditRole:
135	return node.get<DeviceSettings>().name;	×
136	case Qt::FontRole: {
137	if(!connected)	×
138	return italicFont;	×
139	return {};	×
140	}
141	default:
142	return {};	×
143	}
144	}	19✔
145
146	QVariant valueColumnData(const Device::Node& node, int role)	×
147	{
148	using namespace score;
149	if(node.is<DeviceSettings>())	×
150	return {};	×
151
152	if(role == Qt::DisplayRole \|\| role == Qt::EditRole)	×
153	{
154	const ossia::value& val = node.get<AddressSettings>().value;	×
155	if(ossia::is_array(val))	×
156	{
UNCOV 157	return State::convert::toPrettyString(val);	×
158	}
UNCOV 159	else if(role == Qt::DisplayRole && val.get_type() == ossia::val_type::FLOAT)	×
160	{
161	// Done here explicitely to avoid Qt's default scientific notation QLocale conversion
UNCOV 162	return State::convert::toPrettyString(*val.target<float>());	×
163	}
164	else
165	{
UNCOV 166	return State::convert::value<QVariant>(val);	×
167	}
168	}
UNCOV 169	else if(role == Qt::ForegroundRole)	×
170	{
UNCOV 171	const auto ioType = node.get<AddressSettings>().ioType;	×
172
UNCOV 173	if(ioType)	×
174	{
UNCOV 175	switch(*ioType)	×
176	{
177	case ossia::access_mode::GET:
UNCOV 178	return QBrush(Qt::darkGray);	×
179	case ossia::access_mode::SET:
UNCOV 180	return QBrush(Qt::lightGray);	×
181	default:
UNCOV 182	return {};	×
183	}
184	}
UNCOV 185	}	×
186
UNCOV 187	return {};	×
188	}	×
189
UNCOV 190	QVariant GetColumnData(const Device::Node& node, int role)	×
191	{
192	using namespace score;
UNCOV 193	if(node.is<DeviceSettings>())	×
194	return {};	×
195
196	/*
197	if(role == Qt::DisplayRole \|\| role == Qt::EditRole)
198	{
199	switch(node.get<AddressSettings>().ioType)
200	{
201	case ossia::access_mode::GET: return true;
202	case ossia::access_mode::SET: return false;
203	case ossia::access_mode::BI: return true;
204	case IOType::Invalid: return QVariant{};
205	default: return QVariant{};
206	}
207	}
208	*/
209
UNCOV 210	if(role == Qt::CheckStateRole)	×
211	{
UNCOV 212	const auto ioType = node.get<AddressSettings>().ioType;	×
213	if(ioType)	×
214	{
UNCOV 215	switch(*ioType)	×
216	{
217	case ossia::access_mode::GET:
UNCOV 218	return Qt::Checked;	×
219	case ossia::access_mode::SET:
UNCOV 220	return Qt::Unchecked;	×
221	case ossia::access_mode::BI:
UNCOV 222	return Qt::Checked;	×
223	}
UNCOV 224	}	×
225	return Qt::Unchecked;	×
226	}
227
UNCOV 228	return {};	×
229	}	×
230	QVariant SetColumnData(const Device::Node& node, int role)	×
231	{
232	using namespace score;
UNCOV 233	if(node.is<DeviceSettings>())	×
234	return {};	×
235
236	/*
237	if(role == Qt::DisplayRole \|\| role == Qt::EditRole)
238	{
239	switch(node.get<AddressSettings>().ioType)
240	{
241	case ossia::access_mode::GET: return false;
242	case ossia::access_mode::SET: return true;
243	case ossia::access_mode::BI: return true;
244	case IOType::Invalid: return true;
245	default: return QVariant{};
246	}
247	}
248	*/
249
UNCOV 250	if(role == Qt::CheckStateRole)	×
251	{
UNCOV 252	const auto ioType = node.get<AddressSettings>().ioType;	×
253	if(ioType)	×
254	{
UNCOV 255	switch(*ioType)	×
256	{
257	case ossia::access_mode::GET:
UNCOV 258	return Qt::Unchecked;	×
259	case ossia::access_mode::SET:
UNCOV 260	return Qt::Checked;	×
261	case ossia::access_mode::BI:
UNCOV 262	return Qt::Checked;	×
263	}
UNCOV 264	}	×
265	return Qt::Unchecked;	×
266	}
UNCOV 267	return {};	×
268	}	×
269
UNCOV 270	QVariant minColumnData(const Device::Node& node, int role)	×
271	{
272	using namespace score;
UNCOV 273	if(node.is<DeviceSettings>())	×
274	return {};	×
275
UNCOV 276	if(role == Qt::DisplayRole \|\| role == Qt::EditRole)	×
277	{
UNCOV 278	return node.get<AddressSettings>().domain.get().convert_min<QVariant>();	×
279	}
280
UNCOV 281	return {};	×
282	}	×
283
UNCOV 284	QVariant maxColumnData(const Device::Node& node, int role)	×
285	{
286	using namespace score;
UNCOV 287	if(node.is<DeviceSettings>())	×
288	return {};	×
289
UNCOV 290	if(role == Qt::DisplayRole \|\| role == Qt::EditRole)	×
291	{
UNCOV 292	return node.get<AddressSettings>().domain.get().convert_max<QVariant>();	×
293	}
294
UNCOV 295	return {};	×
296	}	×
297	}

ossia / score / 31952604910

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