PredatorCZ / PreCore / 536

Committed 22 Sep 2024 12:23PM UTC coverage: 52.238% (-3.0%) from 55.265%

Build # 536

Build Type

push

github

Committed by

PredatorCZ

Commit Message

remove old xml serializers

Run Details

4084 of 7818 relevant lines covered (52.24%)

10609.73 hits per line

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

85.26

/src/reflector_io.cpp

/*  a source for reflector_io

    Copyright 2020-2023 Lukas Cone

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at

        http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
*/

#include "spike/reflect/reflector_io.hpp"
#include "spike/except.hpp"
#include "spike/type/base_128.hpp"
#include <sstream>

struct ReflectedInstanceFriend : ReflectedInstance {
  void *Instance() { return instance; }
  const void *Instance() const { return constInstance; }
  const reflectorStatic *Refl() const { return rfStatic; }
};

class ReflectorFriend : public Reflector {
public:
  using Reflector::GetReflectedInstance;
};

static int SaveClass(const Reflector &ri, ReflectedInstanceFriend inst,
                     BinWritterRef wr);

static int WriteDataItem(const Reflector &ri, BinWritterRef wr,
                         const char *objAddr, ReflType type, size_t index,
                         const reflectorStatic *refl) {
  switch (type.container) {
  case REFContainer::ContainerVector: {
    const VectorMethods methods = refl->vectorMethods[type.index];
    const uint32 numItems = methods.size(objAddr);
    bint128 tvar(numItems);
    wr.Write(numItems);

    for (uint32 i = 0; i < numItems; i++) {
      if (WriteDataItem(ri, wr,
                        static_cast<const char *>(methods.at(objAddr, i)), type,
                        type.index, refl))
        return 2;
    }
    return 0;
  }
  case REFContainer::InlineArray: {
    for (uint32 i = 0; i < type.asArray.numItems; i++) {
      if (WriteDataItem(ri, wr, objAddr + (type.asArray.stride * i),
                        type.asArray, type.index, refl))
        return 2;
    }
    return 0;
  }
  }
  switch (type.type) {
  case REFType::Integer:
  case REFType::Enum:
    if (type.size > 1) {
      bint128 tvar;
      memcpy(&tvar, objAddr, type.size);
      const size_t shValue = 64 - (type.size * 8);
      tvar.value = (tvar.value << shValue) >> shValue;
      wr.Write(tvar);
      return 0;
    }

    [[fallthrough]];
  case REFType::UnsignedInteger:
  case REFType::EnumFlags:
  case REFType::BitFieldClass:
    if (type.size > 1) {
      buint128 tvar;
      memcpy(&tvar, objAddr, type.size);
      wr.Write(tvar);
      return 0;
    }

    [[fallthrough]];
  case REFType::Bool:
  case REFType::FloatingPoint:
    wr.WriteBuffer(objAddr, type.size);
    return 0;

  case REFType::Vector: {
    for (uint32 i = 0; i < type.asArray.numItems; i++) {
      if (WriteDataItem(ri, wr, objAddr + (type.asArray.stride * i),
                        type.asArray, type.index, refl))
        return 2;
    }
    return 0;
  }

  case REFType::String: {
    const std::string *rStr = reinterpret_cast<const std::string *>(objAddr);
    wr.WriteContainerWCount(*rStr);
    return 0;
  }

  case REFType::Class: {
    auto found =
        reflectorStatic::Registry().find(JenHash(type.asClass.typeHash));

    if (found == reflectorStatic::Registry().end()) {
      return 2;
    }

    ReflectedInstance subInst(found->second, objAddr);
    return SaveClass(ri, ReflectedInstanceFriend{subInst}, wr);
  }
  default:
    return 1;
  }
}

static int SaveClass(const Reflector &ri, ReflectedInstanceFriend inst,
                     BinWritterRef wr) {
  auto refData = inst.Refl();
  const buint128 numItems = refData->nTypes;
  const char *thisAddr = static_cast<const char *>(inst.Instance());
  std::stringstream tmpClassBuffer;

  BinWritterRef wrTmpClass(tmpClassBuffer);
  wrTmpClass.Write(numItems);

  for (size_t i = 0; i < numItems; i++) {
    wrTmpClass.Write(refData->types[i].valueNameHash);

    std::stringstream tmpValueBuffer;
    BinWritterRef wrTmp(tmpValueBuffer);

    int rVal =
        WriteDataItem(ri, wrTmp, thisAddr + refData->types[i].offset,
                      refData->types[i], refData->types[i].index, refData);

    if (rVal)
      return rVal;

    const auto sVarBuffer = tmpValueBuffer.str();
    wrTmpClass.WriteContainerWCount<buint128>(sVarBuffer);
  }

  const auto sClassBuffer = tmpClassBuffer.str();
  wr.WriteContainerWCount<buint128>(sClassBuffer);

  return 0;
}

int ReflectorBinUtil::Save(const Reflector &ri, BinWritterRef wr) {
  auto &&rif = static_cast<const ReflectorFriend &>(ri);
  auto inst =
      static_cast<ReflectedInstanceFriend &&>(rif.GetReflectedInstance());
  auto refData = inst.Refl();

  wr.Write(refData->classHash);

  return SaveClass(ri, inst, wr);
}

static int LoadClass(ReflectorPureWrap inst, BinReaderRef rd);

class ReflectorMemberFriend : public ReflectorMember {
public:
  using ReflectorMember::data;
  using ReflectorMember::id;
  ReflectedInstanceFriend Ref() const { return ReflectedInstanceFriend{data}; }
  operator const ReflType &() const { return Ref().Refl()->types[id]; }
};

static int LoadDataItem(BinReaderRef rd, ReflType type, char *objAddr,
                        const reflectorStatic *refl) {
  switch (type.container) {
  case REFContainer::ContainerVector: {
    const VectorMethods methods = refl->vectorMethods[type.index];
    bint128 tvar;
    rd.Read(tvar);
    uint32 numItems = tvar;

    for (uint32 i = 0; i < numItems; i++) {
      if (LoadDataItem(rd, type, static_cast<char *>(methods.at(objAddr, i)),
                       refl))
        return 2;
    }
    return 0;
  }
  case REFContainer::InlineArray: {
    for (uint32 i = 0; i < type.asArray.numItems; i++) {
      if (LoadDataItem(rd, type.asArray, objAddr + (type.asArray.stride * i),
                       refl))
        return 2;
    }
    return 0;
  }
  }

  switch (type.type) {
  case REFType::Integer:
  case REFType::Enum:
    if (type.size > 1) {
      bint128 tvar;
      rd.Read(tvar);
      memcpy(objAddr, &tvar, type.size);
      return 0;
    }

    [[fallthrough]];
  case REFType::UnsignedInteger:
  case REFType::EnumFlags:
  case REFType::BitFieldClass:
    if (type.size > 1) {
      buint128 tvar;
      rd.Read(tvar);
      memcpy(objAddr, &tvar, type.size);
      return 0;
    }

    [[fallthrough]];
  case REFType::Bool:
  case REFType::FloatingPoint:
    rd.ReadBuffer(objAddr, type.size);
    return 0;

  case REFType::Vector: {
    for (uint32 i = 0; i < type.asArray.numItems; i++) {
      if (LoadDataItem(rd, type.asArray, objAddr + (type.asArray.stride * i),
                       refl))
        return 2;
    }
    return 0;
  }

  case REFType::String: {
    std::string *rStr = reinterpret_cast<std::string *>(objAddr);
    rd.ReadContainer(*rStr);
    return 0;
  }

  case REFType::Class: {
    auto found =
        reflectorStatic::Registry().find(JenHash(type.asClass.typeHash));

    if (found == reflectorStatic::Registry().end()) {
      return 2;
    }

    ReflectedInstance subInst(found->second, objAddr);
    return LoadClass(subInst, rd);
  }
  default:
    return 1;
  }
}

static int LoadClass(ReflectorPureWrap rfWrap, BinReaderRef rd) {
  buint128 chunkSize;
  rd.Read(chunkSize);
  rd.Push();
  buint128 numIOItems;
  rd.Read(numIOItems);

  int errType = 0;

  for (uint32 i = 0; i < numIOItems; i++) {
    BinReaderRef rf(rd);
    JenHash valueNameHash;
    buint128 valueChunkSize;
    rd.Read(valueNameHash);
    rd.Read(valueChunkSize);
    rd.Push();

    ReflectorMemberFriend mem{rfWrap[valueNameHash]};

    if (!mem) {
      rd.Pop();
      rd.Skip(valueChunkSize);
      continue;
    }

    ReflType refl = mem;

    char *objAddr = static_cast<char *>(mem.Ref().Instance()) + refl.offset;

    errType = LoadDataItem(rf, refl, objAddr, mem.Ref().Refl());

    if (errType) {
      rd.Pop();
      rd.Skip(valueChunkSize);
    }
  }

  return errType;
}

int ReflectorBinUtil::Load(Reflector &ri, BinReaderRef rd) {
  auto &&rif = static_cast<ReflectorFriend &>(ri);
  auto inst =
      static_cast<ReflectedInstanceFriend &&>(rif.GetReflectedInstance());
  auto refData = inst.Refl();
  JenHash clsHash;

  rd.Push();
  rd.Read(clsHash);

  if (clsHash != refData->classHash) {
    rd.Pop();
    return 1;
  }

  return LoadClass(inst, rd);
}

1	/* a source for reflector_io
2
3	Copyright 2020-2023 Lukas Cone
4
5	Licensed under the Apache License, Version 2.0 (the "License");
6	you may not use this file except in compliance with the License.
7	You may obtain a copy of the License at
8
9	http://www.apache.org/licenses/LICENSE-2.0
10
11	Unless required by applicable law or agreed to in writing, software
12	distributed under the License is distributed on an "AS IS" BASIS,
13	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14	See the License for the specific language governing permissions and
15	limitations under the License.
16	*/
17
18	#include "spike/reflect/reflector_io.hpp"
19	#include "spike/except.hpp"
20	#include "spike/type/base_128.hpp"
21	#include <sstream>
22
23	struct ReflectedInstanceFriend : ReflectedInstance {
24	void *Instance() { return instance; }	4✔
25	const void *Instance() const { return constInstance; }
26	const reflectorStatic *Refl() const { return rfStatic; }	4✔
27	};
28
29	class ReflectorFriend : public Reflector {
30	public:
31	using Reflector::GetReflectedInstance;
32	};
33
34	static int SaveClass(const Reflector &ri, ReflectedInstanceFriend inst,
35	BinWritterRef wr);
36
37	static int WriteDataItem(const Reflector &ri, BinWritterRef wr,	177✔
38	const char *objAddr, ReflType type, size_t index,
39	const reflectorStatic *refl) {
40	switch (type.container) {	177✔
41	case REFContainer::ContainerVector: {	×
42	const VectorMethods methods = refl->vectorMethods[type.index];	×
43	const uint32 numItems = methods.size(objAddr);	×
44	bint128 tvar(numItems);
45	wr.Write(numItems);
46
47	for (uint32 i = 0; i < numItems; i++) {	×
48	if (WriteDataItem(ri, wr,	×
49	static_cast<const char *>(methods.at(objAddr, i)), type,
50	type.index, refl))
51	return 2;
52	}
53	return 0;
54	}
55	case REFContainer::InlineArray: {
56	for (uint32 i = 0; i < type.asArray.numItems; i++) {	94✔
57	if (WriteDataItem(ri, wr, objAddr + (type.asArray.stride * i),	70✔
58	type.asArray, type.index, refl))
59	return 2;
60	}
61	return 0;
62	}
63	}
64	switch (type.type) {	153✔
65	case REFType::Integer:	31✔
66	case REFType::Enum:
67	if (type.size > 1) {	31✔
68	bint128 tvar;
69	memcpy(&tvar, objAddr, type.size);	23✔
70	const size_t shValue = 64 - (type.size * 8);	23✔
71	tvar.value = (tvar.value << shValue) >> shValue;	23✔
72	wr.Write(tvar);
73	return 0;
74	}
75
76	[[fallthrough]];
77	case REFType::UnsignedInteger:
78	case REFType::EnumFlags:
79	case REFType::BitFieldClass:
80	if (type.size > 1) {	40✔
81	buint128 tvar;
82	memcpy(&tvar, objAddr, type.size);	24✔
83	wr.Write(tvar);
84	return 0;
85	}
86
87	[[fallthrough]];
88	case REFType::Bool:
89	case REFType::FloatingPoint:
90	wr.WriteBuffer(objAddr, type.size);
91	return 0;	86✔
92
93	case REFType::Vector: {
94	for (uint32 i = 0; i < type.asArray.numItems; i++) {	67✔
95	if (WriteDataItem(ri, wr, objAddr + (type.asArray.stride * i),	51✔
96	type.asArray, type.index, refl))
97	return 2;
98	}
99	return 0;
100	}
101
102	case REFType::String: {	1✔
103	const std::string rStr = reinterpret_cast<const std::string >(objAddr);
104	wr.WriteContainerWCount(*rStr);	1✔
105	return 0;	1✔
106	}
107
108	case REFType::Class: {	3✔
109	auto found =
110	reflectorStatic::Registry().find(JenHash(type.asClass.typeHash));	3✔
111
112	if (found == reflectorStatic::Registry().end()) {	3✔
113	return 2;
114	}
115
116	ReflectedInstance subInst(found->second, objAddr);	3✔
117	return SaveClass(ri, ReflectedInstanceFriend{subInst}, wr);	3✔
118	}
119	default:
120	return 1;
121	}
122	}
123
124	static int SaveClass(const Reflector &ri, ReflectedInstanceFriend inst,	4✔
125	BinWritterRef wr) {
126	auto refData = inst.Refl();
127	const buint128 numItems = refData->nTypes;	4✔
128	const char thisAddr = static_cast<const char >(inst.Instance());
129	std::stringstream tmpClassBuffer;	4✔
130
131	BinWritterRef wrTmpClass(tmpClassBuffer);
132	wrTmpClass.Write(numItems);
133
134	for (size_t i = 0; i < numItems; i++) {	60✔
135	wrTmpClass.Write(refData->types[i].valueNameHash);	56✔
136
137	std::stringstream tmpValueBuffer;	56✔
138	BinWritterRef wrTmp(tmpValueBuffer);
139
140	int rVal =
141	WriteDataItem(ri, wrTmp, thisAddr + refData->types[i].offset,	56✔
142	refData->types[i], refData->types[i].index, refData);	56✔
143
144	if (rVal)	56✔
145	return rVal;
146
147	const auto sVarBuffer = tmpValueBuffer.str();
148	wrTmpClass.WriteContainerWCount<buint128>(sVarBuffer);	56✔
149	}	56✔
150
151	const auto sClassBuffer = tmpClassBuffer.str();
152	wr.WriteContainerWCount<buint128>(sClassBuffer);	4✔
153
154	return 0;
155	}	4✔
156
157	int ReflectorBinUtil::Save(const Reflector &ri, BinWritterRef wr) {	1✔
158	auto &&rif = static_cast<const ReflectorFriend &>(ri);
159	auto inst =
160	static_cast<ReflectedInstanceFriend &&>(rif.GetReflectedInstance());	1✔
161	auto refData = inst.Refl();
162
163	wr.Write(refData->classHash);	1✔
164
165	return SaveClass(ri, inst, wr);	1✔
166	}
167
168	static int LoadClass(ReflectorPureWrap inst, BinReaderRef rd);
169
170	class ReflectorMemberFriend : public ReflectorMember {
171	public:
172	using ReflectorMember::data;
173	using ReflectorMember::id;
174	ReflectedInstanceFriend Ref() const { return ReflectedInstanceFriend{data}; }	112✔
175	operator const ReflType &() const { return Ref().Refl()->types[id]; }	112✔
176	};
177
178	static int LoadDataItem(BinReaderRef rd, ReflType type, char *objAddr,	354✔
179	const reflectorStatic *refl) {
180	switch (type.container) {	354✔
181	case REFContainer::ContainerVector: {	×
182	const VectorMethods methods = refl->vectorMethods[type.index];	×
183	bint128 tvar;
184	rd.Read(tvar);
185	uint32 numItems = tvar;	×
186
187	for (uint32 i = 0; i < numItems; i++) {	×
188	if (LoadDataItem(rd, type, static_cast<char *>(methods.at(objAddr, i)),	×
189	refl))
190	return 2;
191	}
192	return 0;
193	}
194	case REFContainer::InlineArray: {
195	for (uint32 i = 0; i < type.asArray.numItems; i++) {	188✔
196	if (LoadDataItem(rd, type.asArray, objAddr + (type.asArray.stride * i),	140✔
197	refl))
198	return 2;
199	}
200	return 0;
201	}
202	}
203
204	switch (type.type) {	306✔
205	case REFType::Integer:	62✔
206	case REFType::Enum:
207	if (type.size > 1) {	62✔
208	bint128 tvar;
209	rd.Read(tvar);
210	memcpy(objAddr, &tvar, type.size);	46✔
211	return 0;
212	}
213
214	[[fallthrough]];
215	case REFType::UnsignedInteger:
216	case REFType::EnumFlags:
217	case REFType::BitFieldClass:
218	if (type.size > 1) {	80✔
219	buint128 tvar;
220	rd.Read(tvar);
221	memcpy(objAddr, &tvar, type.size);	48✔
222	return 0;
223	}
224
225	[[fallthrough]];
226	case REFType::Bool:
227	case REFType::FloatingPoint:
228	rd.ReadBuffer(objAddr, type.size);
229	return 0;	172✔
230
231	case REFType::Vector: {
232	for (uint32 i = 0; i < type.asArray.numItems; i++) {	134✔
233	if (LoadDataItem(rd, type.asArray, objAddr + (type.asArray.stride * i),	102✔
234	refl))
235	return 2;
236	}
237	return 0;
238	}
239
240	case REFType::String: {	2✔
241	std::string rStr = reinterpret_cast<std::string >(objAddr);
242	rd.ReadContainer(*rStr);	2✔
243	return 0;	2✔
244	}
245
246	case REFType::Class: {	6✔
247	auto found =
248	reflectorStatic::Registry().find(JenHash(type.asClass.typeHash));	6✔
249
250	if (found == reflectorStatic::Registry().end()) {	6✔
251	return 2;
252	}
253
254	ReflectedInstance subInst(found->second, objAddr);	6✔
255	return LoadClass(subInst, rd);	6✔
256	}
257	default:
258	return 1;
259	}
260	}
261
262	static int LoadClass(ReflectorPureWrap rfWrap, BinReaderRef rd) {	8✔
263	buint128 chunkSize;
264	rd.Read(chunkSize);
265	rd.Push();
266	buint128 numIOItems;
267	rd.Read(numIOItems);
268
269	int errType = 0;
270
271	for (uint32 i = 0; i < numIOItems; i++) {	120✔
272	BinReaderRef rf(rd);	112✔
273	JenHash valueNameHash;	112✔
274	buint128 valueChunkSize;
275	rd.Read(valueNameHash);
276	rd.Read(valueChunkSize);
277	rd.Push();
278
279	ReflectorMemberFriend mem{rfWrap[valueNameHash]};	112✔
280
281	if (!mem) {	112✔
282	rd.Pop();
283	rd.Skip(valueChunkSize);	×
284	continue;	×
285	}
286
287	ReflType refl = mem;	112✔
288
289	char objAddr = static_cast<char >(mem.Ref().Instance()) + refl.offset;	112✔
290
291	errType = LoadDataItem(rf, refl, objAddr, mem.Ref().Refl());	112✔
292
293	if (errType) {	112✔
294	rd.Pop();
295	rd.Skip(valueChunkSize);	×
296	}
297	}
298
299	return errType;	8✔
300	}
301
302	int ReflectorBinUtil::Load(Reflector &ri, BinReaderRef rd) {	2✔
303	auto &&rif = static_cast<ReflectorFriend &>(ri);
304	auto inst =
305	static_cast<ReflectedInstanceFriend &&>(rif.GetReflectedInstance());	2✔
306	auto refData = inst.Refl();
307	JenHash clsHash;	2✔
308
309	rd.Push();
310	rd.Read(clsHash);
311
312	if (clsHash != refData->classHash) {	2✔
313	rd.Pop();
314	return 1;	×
315	}
316
317	return LoadClass(inst, rd);	2✔
318	}

PredatorCZ / PreCore / 536

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