1cc46d885c9a8c4464d8420dc6a68afe83ac9811

Build # 1cc46d885c9a8c4464d8420dc6a68afe83ac9811

Build Type

push

github

Committed by Bnaya Peretz

Commit Message

wip

Run Details

458 of 552 branches covered (82.97%)

Branch coverage included in aggregate %.

1249 of 1361 relevant lines covered (91.77%)

277.66 hits per line

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

84.72

/src/internal/objectSaverIterative.ts

import { ENTRY_TYPE } from "./entry-types";
import type { ExternalArgs, GlobalCarrier } from "./interfaces";
import {
  createHashMap,
  hashMapInsertUpdateKeyIsPointerReturnNode,
} from "./hashmap/hashmap";
import {
  object_size,
  object_set_all,
  hashmapNode_KEY_POINTER_get,
  hashmapNode_VALUE_POINTER_place,
} from "./generatedStructs";
import { saveStringOrNumber, freeStringOrNumber } from "./store";

export function objectSaverIterative(
  externalArgs: ExternalArgs,
  carrier: GlobalCarrier,
  valuesToSave: any[],
  pointersToSaveTo: number[],
  savedValuesToPointer: Map<unknown, number>,
  referencedExistingPointers: number[],
  objectToSave: any
) {
  const { heap, allocator } = carrier;
  const pointerToStruct = allocator.malloc(object_size);

  const objectEntries = Object.entries(objectToSave);
  const objectEntriesLength = objectEntries.length;

  const hashMapPointer = createHashMap(
    carrier,
    Math.max(
      externalArgs.hashMapMinInitialCapacity,
      Math.ceil(objectEntriesLength * 1.3)
    )
  );

  let newKeyPointer: number | undefined;
  for (let i = 0; i < objectEntriesLength; i += 1) {
    newKeyPointer = savedValuesToPointer.get(objectEntries[i][0]);
    if (newKeyPointer) {
      referencedExistingPointers.push(newKeyPointer);
    } else {
      newKeyPointer = saveStringOrNumber(carrier, objectEntries[i][0]);
    }

    const ptrToNode = hashMapInsertUpdateKeyIsPointerReturnNode(
      externalArgs,
      carrier,
      hashMapPointer,
      newKeyPointer
    );

    // on value saver, that code branch is not expected to happen
    // Because we are creating new objects
    if (hashmapNode_KEY_POINTER_get(heap, ptrToNode) !== newKeyPointer) {
      // The key is already exits, we can dispose the new key memory
      freeStringOrNumber(carrier, newKeyPointer);
    } else {
      if (typeof objectEntries[i][0] === "string") {
        savedValuesToPointer.set(objectEntries[i][0], newKeyPointer);
      }
    }

    const ptrToPtrForObjectPropValue =
      ptrToNode + hashmapNode_VALUE_POINTER_place;

    valuesToSave.push(objectEntries[i][1]);
    pointersToSaveTo.push(ptrToPtrForObjectPropValue);
  }

  object_set_all(heap, pointerToStruct, ENTRY_TYPE.OBJECT, 1, hashMapPointer);

  return pointerToStruct;
}

export function mapSaverIterative(
  externalArgs: ExternalArgs,
  carrier: GlobalCarrier,
  valuesToSave: any[],
  pointersToSaveTo: number[],
  savedValuesToPointer: Map<unknown, number>,
  referencedExistingPointers: number[],
  mapToSave: Map<unknown, unknown>
) {
  const { heap, allocator } = carrier;
  const pointerToStruct = allocator.malloc(object_size);

  const hashMapPointer = createHashMap(
    carrier,
    Math.max(
      externalArgs.hashMapMinInitialCapacity,
      Math.ceil(mapToSave.size * 1.3)
    )
  );

  let newKeyPointer: number | undefined;
  for (const [key, value] of mapToSave) {
    newKeyPointer = savedValuesToPointer.get(key);
    if (newKeyPointer) {
      referencedExistingPointers.push(newKeyPointer);
    } else {
      newKeyPointer = saveStringOrNumber(carrier, key as string | number);
    }

    const ptrToNode = hashMapInsertUpdateKeyIsPointerReturnNode(
      externalArgs,
      carrier,
      hashMapPointer,
      newKeyPointer
    );

    // on value saver, that code branch is not expected to happen
    // Because we are creating new objects
    if (hashmapNode_KEY_POINTER_get(heap, ptrToNode) !== newKeyPointer) {
      // The key is already exits, we can dispose the new key memory
      freeStringOrNumber(carrier, newKeyPointer);
    } else {
      if (typeof key === "string") {
        savedValuesToPointer.set(key, newKeyPointer);
      }
    }

    const ptrToPtrForObjectPropValue =
      ptrToNode + hashmapNode_VALUE_POINTER_place;

    valuesToSave.push(value);
    pointersToSaveTo.push(ptrToPtrForObjectPropValue);
  }

  object_set_all(heap, pointerToStruct, ENTRY_TYPE.MAP, 1, hashMapPointer);

  return pointerToStruct;
}

export function setSaverIterative(
  externalArgs: ExternalArgs,
  carrier: GlobalCarrier,
  savedValuesToPointer: Map<unknown, number>,
  referencedExistingPointers: number[],
  setToSave: Set<unknown>
) {
  const { heap, allocator } = carrier;

  const pointerToStruct = allocator.malloc(object_size);

  const hashMapPointer = createHashMap(
    carrier,
    Math.max(
      externalArgs.hashMapMinInitialCapacity,
      Math.ceil(setToSave.size * 1.3)
    )
  );

  let newKeyPointer: number | undefined;
  for (const key of setToSave) {
    newKeyPointer = savedValuesToPointer.get(key);
    if (newKeyPointer) {
      referencedExistingPointers.push(newKeyPointer);
    } else {
      newKeyPointer = saveStringOrNumber(carrier, key as string | number);
    }

    const ptrToNode = hashMapInsertUpdateKeyIsPointerReturnNode(
      externalArgs,
      carrier,
      hashMapPointer,
      newKeyPointer
    );

    // on value saver, that code branch is not expected to happen
    // Because we are creating new objects
    if (hashmapNode_KEY_POINTER_get(heap, ptrToNode) !== newKeyPointer) {
      // The key is already exits, we can dispose the new key memory
      freeStringOrNumber(carrier, newKeyPointer);
    } else {
      if (typeof key === "string") {
        savedValuesToPointer.set(key, newKeyPointer);
      }
    }
  }

  object_set_all(heap, pointerToStruct, ENTRY_TYPE.SET, 1, hashMapPointer);

  object_set_all(
    carrier.heap,
    pointerToStruct,
    ENTRY_TYPE.SET,
    1,
    hashMapPointer
  );

  return pointerToStruct;
}

1	import { ENTRY_TYPE } from "./entry-types";
2	import type { ExternalArgs, GlobalCarrier } from "./interfaces";
3	import {
4	createHashMap,
5	hashMapInsertUpdateKeyIsPointerReturnNode,
6	} from "./hashmap/hashmap";
7	import {
8	object_size,
9	object_set_all,
10	hashmapNode_KEY_POINTER_get,
11	hashmapNode_VALUE_POINTER_place,
12	} from "./generatedStructs";
13	import { saveStringOrNumber, freeStringOrNumber } from "./store";
14
15	export function objectSaverIterative(
16	externalArgs: ExternalArgs,
17	carrier: GlobalCarrier,
18	valuesToSave: any[],
19	pointersToSaveTo: number[],
20	savedValuesToPointer: Map<unknown, number>,
21	referencedExistingPointers: number[],
22	objectToSave: any
23	) {
24	const { heap, allocator } = carrier;
25	const pointerToStruct = allocator.malloc(object_size);
26
27	const objectEntries = Object.entries(objectToSave);
28	const objectEntriesLength = objectEntries.length;
29
30	const hashMapPointer = createHashMap(
31	carrier,
32	Math.max(
33	externalArgs.hashMapMinInitialCapacity,
34	Math.ceil(objectEntriesLength * 1.3)
35	)
36	);
37
38	let newKeyPointer: number \| undefined;
39	for (let i = 0; i < objectEntriesLength; i += 1) {
40	newKeyPointer = savedValuesToPointer.get(objectEntries[i][0]);
41	if (newKeyPointer) {	204✔
42	referencedExistingPointers.push(newKeyPointer);
43	} else {
44	newKeyPointer = saveStringOrNumber(carrier, objectEntries[i][0]);
45	}
46
47	const ptrToNode = hashMapInsertUpdateKeyIsPointerReturnNode(
48	externalArgs,
49	carrier,
50	hashMapPointer,
51	newKeyPointer
52	);
53
54	// on value saver, that code branch is not expected to happen
55	// Because we are creating new objects
56	if (hashmapNode_KEY_POINTER_get(heap, ptrToNode) !== newKeyPointer) {	204!
57	// The key is already exits, we can dispose the new key memory
58	freeStringOrNumber(carrier, newKeyPointer);
59	} else {
60	if (typeof objectEntries[i][0] === "string") {	204!
61	savedValuesToPointer.set(objectEntries[i][0], newKeyPointer);
62	}
63	}
64
65	const ptrToPtrForObjectPropValue =
66	ptrToNode + hashmapNode_VALUE_POINTER_place;
67
68	valuesToSave.push(objectEntries[i][1]);
69	pointersToSaveTo.push(ptrToPtrForObjectPropValue);
70	}
71
72	object_set_all(heap, pointerToStruct, ENTRY_TYPE.OBJECT, 1, hashMapPointer);
73
74	return pointerToStruct;
75	}
76
77	export function mapSaverIterative(
78	externalArgs: ExternalArgs,
79	carrier: GlobalCarrier,
80	valuesToSave: any[],
81	pointersToSaveTo: number[],
82	savedValuesToPointer: Map<unknown, number>,
83	referencedExistingPointers: number[],
84	mapToSave: Map<unknown, unknown>
85	) {
86	const { heap, allocator } = carrier;
87	const pointerToStruct = allocator.malloc(object_size);
88
89	const hashMapPointer = createHashMap(
90	carrier,
91	Math.max(
92	externalArgs.hashMapMinInitialCapacity,
93	Math.ceil(mapToSave.size * 1.3)
94	)
95	);
96
97	let newKeyPointer: number \| undefined;
98	for (const [key, value] of mapToSave) {
99	newKeyPointer = savedValuesToPointer.get(key);
100	if (newKeyPointer) {	9!
101	referencedExistingPointers.push(newKeyPointer);
102	} else {
103	newKeyPointer = saveStringOrNumber(carrier, key as string \| number);
104	}
105
106	const ptrToNode = hashMapInsertUpdateKeyIsPointerReturnNode(
107	externalArgs,
108	carrier,
109	hashMapPointer,
110	newKeyPointer
111	);
112
113	// on value saver, that code branch is not expected to happen
114	// Because we are creating new objects
115	if (hashmapNode_KEY_POINTER_get(heap, ptrToNode) !== newKeyPointer) {	9!
116	// The key is already exits, we can dispose the new key memory
117	freeStringOrNumber(carrier, newKeyPointer);
118	} else {
119	if (typeof key === "string") {	9✔
120	savedValuesToPointer.set(key, newKeyPointer);
121	}
122	}
123
124	const ptrToPtrForObjectPropValue =
125	ptrToNode + hashmapNode_VALUE_POINTER_place;
126
127	valuesToSave.push(value);
128	pointersToSaveTo.push(ptrToPtrForObjectPropValue);
129	}
130
131	object_set_all(heap, pointerToStruct, ENTRY_TYPE.MAP, 1, hashMapPointer);
132
133	return pointerToStruct;
134	}
135
136	export function setSaverIterative(
137	externalArgs: ExternalArgs,
138	carrier: GlobalCarrier,
139	savedValuesToPointer: Map<unknown, number>,
140	referencedExistingPointers: number[],
141	setToSave: Set<unknown>
142	) {
143	const { heap, allocator } = carrier;
144
145	const pointerToStruct = allocator.malloc(object_size);
146
147	const hashMapPointer = createHashMap(
148	carrier,
149	Math.max(
150	externalArgs.hashMapMinInitialCapacity,
151	Math.ceil(setToSave.size * 1.3)
152	)
153	);
154
155	let newKeyPointer: number \| undefined;
156	for (const key of setToSave) {
157	newKeyPointer = savedValuesToPointer.get(key);
158	if (newKeyPointer) {	14!
159	referencedExistingPointers.push(newKeyPointer);
160	} else {
161	newKeyPointer = saveStringOrNumber(carrier, key as string \| number);
162	}
163
164	const ptrToNode = hashMapInsertUpdateKeyIsPointerReturnNode(
165	externalArgs,
166	carrier,
167	hashMapPointer,
168	newKeyPointer
169	);
170
171	// on value saver, that code branch is not expected to happen
172	// Because we are creating new objects
173	if (hashmapNode_KEY_POINTER_get(heap, ptrToNode) !== newKeyPointer) {	14!
174	// The key is already exits, we can dispose the new key memory
175	freeStringOrNumber(carrier, newKeyPointer);
176	} else {
177	if (typeof key === "string") {	14✔
178	savedValuesToPointer.set(key, newKeyPointer);
179	}
180	}
181	}
182
183	object_set_all(heap, pointerToStruct, ENTRY_TYPE.SET, 1, hashMapPointer);
184
185	object_set_all(
186	carrier.heap,
187	pointerToStruct,
188	ENTRY_TYPE.SET,
189	1,
190	hashMapPointer
191	);
192
193	return pointerToStruct;
194	}

Bnaya / objectbuffer / 1cc46d885c9a8c4464d8420dc6a68afe83ac9811

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