superstudio 0.8.2102

data/README.md

@@ -0,0 +1,17 @@
+## LICENSE
+
+
+Copyright (C) 2017  David Dawson
+
+Superstudio is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+Superstudio is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Superstudio.  If not, see <http://www.gnu.org/licenses/>.

data/ext/superstudio/extconf.rb

@@ -0,0 +1,6 @@
+require 'mkmf'
+
+$CFLAGS << ' -std=c99'
+CONFIG['warnflags'].gsub!('-Wdeclaration-after-statement', '')
+
+create_makefile('superstudio/superstudio')

data/ext/superstudio/finalize.h

@@ -0,0 +1,11 @@
+#ifndef SS_FINALIZE_
+
+#include "json_builder.h"
+
+unsigned long finalize_key_values(JSONDocumentBuilder* builder, SingleValueJSON* single_values, JSONObject* parent_json, unsigned long counter);
+unsigned long finalize_single_objects(JSONDocumentBuilder* builder, SingleObjectJSON* level_single_objects, unsigned long counter, int comma_finish);
+unsigned long finalize_value_array(JSONDocumentBuilder* builder, ArrayValueJSON* value_arrays, unsigned long counter);
+unsigned long finalize_object_array(JSONDocumentBuilder* builder, ArrayObjectJSON* object_array, unsigned long counter);
+
+
+#endif //SS_FINALIZE_

data/ext/superstudio/fnv_64.c

@@ -0,0 +1,97 @@
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include "fnv_64.h"
+
+/*
+*  0 = char* string
+*  1 = short
+*  2 = int
+*  3 = long
+*  4 = float
+*  6 = double
+*/
+
+uint64_t fnv_hash(uint64_t hash, void *data, char type)
+{
+  unsigned int i;
+
+  union {
+    short source_short;
+    int source_int;
+    long source_long;
+    float source_float;
+    double source_double;
+    char* source_string;
+    char short_bytes[sizeof(short)];
+    char int_bytes[sizeof(int)];
+    char long_bytes[sizeof(long)];
+    char float_bytes[sizeof(float)];
+    char double_bytes[sizeof(double)];
+  } byte_struct;
+
+  switch(type) {
+    case 1:
+      byte_struct.source_short = *(short*)data;
+      for (i=0; i<sizeof(short); i++) {
+        char* byte = &byte_struct.short_bytes[sizeof(short) - 1 - i];
+        hash = fnv_hash_byte(hash, byte);
+      }
+      return hash;
+    break;
+    case 2:
+      byte_struct.source_int = *(int*)data;
+      for (i=0; i<sizeof(int); i++) {
+        char* byte = &byte_struct.int_bytes[sizeof(int) - 1 - i];
+        hash = fnv_hash_byte(hash, byte);
+      }
+      return hash;
+    break;
+    case 3:
+      byte_struct.source_long = *(long*)data;
+      for (i=0; i<sizeof(long); i++) {
+        char* byte = &byte_struct.long_bytes[sizeof(long) - 1 - i];
+        hash = fnv_hash_byte(hash, byte);
+      }
+      return hash;
+    break;
+    case 4:
+      byte_struct.source_float = *(float*)data;
+      for (i=0; i<sizeof(float); i++) {
+        char* byte = &byte_struct.float_bytes[sizeof(float) - 1 - i];
+        hash = fnv_hash_byte(hash, byte);
+      }
+      return hash;
+    break;
+    case 5:
+      byte_struct.source_double = *(double*)data;
+      for (i=0; i<sizeof(double); i++) {
+        char* byte = &byte_struct.double_bytes[sizeof(double) - 1 - i];
+        hash = fnv_hash_byte(hash, byte);
+      }
+      return hash;
+    break;
+    case 0:
+      byte_struct.source_string = (char*)data;
+      while(*byte_struct.source_string != '\0') {
+         hash = fnv_hash_byte(hash, byte_struct.source_string);
+         *byte_struct.source_string = *byte_struct.source_string + 1;
+      }
+      return hash;
+    break;
+  }
+  return 0;
+}
+
+uint64_t fnv_hash_byte(uint64_t hash, char *data)
+{
+  hash ^= (uint64_t)(*data);
+  hash *= (FNV_PRIME % UINT64_MAX);
+  return hash;
+}
+
+void hash_byte(uint64_t *hash, char *data)
+{
+  *hash ^= (uint64_t)(*data);
+  *hash *= (FNV_PRIME % UINT64_MAX);
+}

data/ext/superstudio/fnv_64.h

@@ -0,0 +1,12 @@
+#ifndef FNV_HASH_
+#define FNV_OFFSET 14695981039346656037U
+#define FNV_PRIME 1099511628211U
+#define FNV_HASH_
+
+#include <stdint.h>
+
+uint64_t fnv_hash(uint64_t starting_hash, void *data, char type);
+uint64_t fnv_hash_byte(uint64_t hash, char *data);
+void hash_byte(uint64_t *hash, char *data);
+
+#endif //FNV_HASH_

data/ext/superstudio/hash_linked_list.c

@@ -0,0 +1,222 @@
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <math.h>
+#include "ss_alloc.h"
+#include "hash_linked_list.h"
+#include "json_value.h"
+#include "json_value_array.h"
+#include "json_object_array.h"
+#include "json_single_object.h"
+
+void hl_initialize(HashList *list, SSMemoryStack* memory_stack, unsigned long query_rows)
+{
+  long bucket_count = ((long)((query_rows + 1) / (log10(query_rows + 1)/log10(2))) + 1);
+  list->length = 0;
+  list->bucket_interval = UINT64_MAX / bucket_count;
+  list->next = NULL;
+  list->last = NULL;
+  list->buckets = (HashListNode**)ss_alloc(memory_stack, 1, bucket_count * sizeof(HashListNode*));
+}
+
+void print_list_details(HashList *list)
+{
+  printf("Length: %i\n", list->length);
+  HashListNode *i;
+  i = list->next;
+  while(i) {
+    printf("Hash: %lu\n", i->hash);
+    i = i->next;
+  }
+}
+
+void increment_length(HashList *list)
+{
+  int tmp_length;
+  tmp_length = list->length;
+  list->length = ++tmp_length;
+  return;
+}
+
+uint64_t hl_first(HashList *list)
+{
+  HashListNode first_node;
+  first_node = *(list->next);
+  return first_node.hash;
+}
+
+HashListNode* hl_insert_or_find(HashList *list, 
+  uint64_t passed_hash, 
+  JSONObject* related_object,
+  JSONLevelBuilder* related_parent_level, 
+  JSONLevelBuilder* related_single_json_info,
+  JSONLevelBuilder* related_object_info_list,
+  SSMemoryStack* memory_stack
+  )
+{
+  HashListNode* found_node;
+  int bucket_number = find_target_bucket(passed_hash, list->bucket_interval);
+
+  if (!list->next) {
+    HashListNode *new_node = (HashListNode*)ss_alloc(memory_stack, 1, sizeof(HashListNode));
+
+    new_node->hash = passed_hash;
+    new_node->next = NULL;
+    new_node->bucket_next = NULL;
+    new_node->bucket_previous = NULL;
+    new_node->related_JSON_object = related_object;
+    new_node->related_parent_level = related_parent_level;
+    new_node->single_object_info_list = related_single_json_info;
+    new_node->array_object_info_list = related_object_info_list;
+
+    list->last = list->next = list->buckets[bucket_number] = new_node;
+    increment_length(list);
+    return list->next;
+  }
+  found_node = hl_find_node(list, passed_hash);
+  if (found_node) {
+    if (found_node->bucket_previous != NULL) {
+      found_node->bucket_previous->bucket_next = found_node->bucket_next;
+      found_node->bucket_next = list->buckets[bucket_number];
+
+      found_node->bucket_previous = NULL;
+
+      list->buckets[bucket_number] = found_node;
+    }
+    return found_node;
+  } else {
+    HashListNode *new_node = (HashListNode*)ss_alloc(memory_stack, 1, sizeof(HashListNode));
+    new_node->hash = passed_hash;
+    new_node->next = NULL;
+    new_node->bucket_next = NULL;
+    new_node->bucket_previous = NULL;
+    new_node->related_JSON_object = related_object;
+    new_node->related_parent_level = related_parent_level;
+    new_node->single_object_info_list = related_single_json_info;
+    new_node->array_object_info_list = related_object_info_list;
+
+    if (list->buckets[bucket_number] != NULL) {
+      list->buckets[bucket_number]->bucket_previous = new_node;
+      new_node->bucket_next = list->buckets[bucket_number];
+    }
+    list->buckets[bucket_number] = new_node;
+
+    increment_length(list);
+
+    list->last->next = new_node;
+    list->last = new_node;
+
+    return list->last;
+  }
+}
+
+HashListNode* hl_find_node(HashList *list, uint64_t passed_hash)
+{
+  int bucket_number = find_target_bucket(passed_hash, list->bucket_interval);
+  HashListNode *i = list->buckets[bucket_number];
+
+  if (i == NULL) {
+    return NULL;
+  }
+  while(i) {
+    if (i->hash == passed_hash) {
+      return i;
+    }
+    i = i->bucket_next;
+  }
+  return NULL;
+}
+
+JSONObject* find_or_create_node(
+  JSONDocumentBuilder* builder, 
+  JSONLevelBuilder* level_definitions, 
+  JSONLevelBuilder* child_levels,
+  JSONLevelBuilder* child_array_start,
+  JSONObject* parent_object, 
+  uint64_t hash, 
+  unsigned char parent_type,
+  char** row_strings,
+  unsigned long* string_sizes,
+  unsigned long visible_depth,
+  HashList* parent_search_list
+  )
+{
+  HashListNode* found_node;
+  JSONObject* found_object = NULL;
+  JSONLevelBuilder* found_level_definitions;
+  SingleObjectJSON* related_child_objects;
+  SingleObjectJSON* single_parent_object; // We need to search in two directions - through each child and through each child's single object children
+  int found = 0;
+
+  builder->json_char_count += 3; // Starting, ending brace and comma
+
+  // Dev note:
+  // The create calls will handle duplicates where additional stuff doesn't need to be added
+  if (parent_type == 4) {
+
+    create_array_object(builder, 
+      hash, 
+      parent_search_list, 
+      level_definitions, 
+      child_levels, 
+      child_array_start, 
+      level_definitions->identifier_int);
+    
+    found_node = hl_find_node(parent_search_list, hash);
+    if (found_node) {
+      found_object = found_node->related_JSON_object;
+      found_level_definitions = found_node->related_parent_level;
+    }
+  } else {
+
+    create_single_object(builder, 
+      hash, 
+      level_definitions->identifier_int, 
+      parent_object);  
+
+    // Dev note:
+    // When adding a single object, we're finding the parent hash because the single object is hashed as well
+    // Single objects are a 1-1 relationship
+    related_child_objects = parent_object->single_objects;
+    while (related_child_objects->set_flag && !found) {
+      single_parent_object = related_child_objects;
+      if (single_parent_object->identifier_int == level_definitions->identifier_int) {
+        found = 1;
+      } else {
+        single_parent_object = single_parent_object->value->single_objects;
+        while (single_parent_object->set_flag && !found) {
+          if (single_parent_object->identifier_int == level_definitions->identifier_int) {
+            found = 1;
+          } else {
+            single_parent_object = single_parent_object->next_item;
+          }
+        }
+      }
+      related_child_objects = related_child_objects->next_item;
+    }
+
+    if (found) {
+      found_object = single_parent_object->value;
+    } else {
+      found_object = parent_object;
+    }
+    found_level_definitions = level_definitions;
+  }
+
+  if (found_object) {
+    set_key_values(builder, string_sizes, row_strings, visible_depth, found_level_definitions, found_object);
+    set_value_arrays(builder, found_level_definitions, found_level_definitions->column_count, row_strings, string_sizes, visible_depth, found_object);
+  }
+  
+  return found_object;
+}
+
+void hl_set_json_object(HashListNode* node, JSONObject* related_object)
+{
+  node->related_JSON_object = related_object;
+}
+
+int find_target_bucket(uint64_t passed_hash, unsigned long interval)
+{
+  return passed_hash / interval;
+}

data/ext/superstudio/hash_linked_list.h

@@ -0,0 +1,38 @@
+#ifndef HASH_LIST_
+#define HASH_LIST_
+
+#include <stdint.h>
+#include "json_builder.h"
+
+void hl_initialize(HashList *list, SSMemoryStack* memory_stack, unsigned long query_rows);
+void print_list_details(HashList *list);
+void increment_length(HashList *list);
+uint64_t hl_first(HashList *list);
+int find_target_bucket(uint64_t passed_hash, unsigned long interval);
+void hl_set_json_object(HashListNode* node, JSONObject* related_object);
+
+JSONObject* find_or_create_node(JSONDocumentBuilder* builder, 
+  JSONLevelBuilder* level_definitions, 
+  JSONLevelBuilder* child_levels,
+  JSONLevelBuilder* child_array_start,
+  JSONObject* parent_object, 
+  uint64_t hash, 
+  unsigned char parent_type, 
+  char** row_strings, 
+  unsigned long* string_sizes, 
+  unsigned long visible_depth, 
+  HashList* parent_search_list);
+
+HashListNode* hl_insert_or_find(HashList *list, 
+  uint64_t passed_hash, 
+  JSONObject* related_object,
+  JSONLevelBuilder* related_parent_level, 
+  JSONLevelBuilder* related_single_json_info,
+  JSONLevelBuilder* related_object_info_list,
+  SSMemoryStack* memory_stack
+  );
+
+
+HashListNode* hl_find_node(HashList *list, uint64_t passed_hash);
+
+#endif // HASH_LIST_

data/ext/superstudio/json_builder.c

@@ -0,0 +1,501 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include "json_builder.h"
+#include "json_value.h"
+#include "json_value_array.h"
+#include "json_single_object.h"
+#include "json_object_array.h"
+#include "hash_linked_list.h"
+#include "ss_alloc.h"
+#include "fnv_64.h"
+
+void json_builder_initialize(JSONDocumentBuilder *builder)
+{
+  builder->memory_stack = calloc(1, sizeof(SSMemoryStack));
+  builder->memory_stack->stack_top = calloc(1, sizeof(SSMemoryStackNode));
+
+  builder->root_level = (JSONLevelBuilder*)ss_alloc(builder->memory_stack, 1, sizeof(JSONLevelBuilder)); 
+  builder->root_level->next_child = (JSONLevelBuilder*)ss_alloc(builder->memory_stack, 1, sizeof(JSONLevelBuilder));
+  builder->root_level->next_child_array = (JSONLevelBuilder*)ss_alloc(builder->memory_stack, 1, sizeof(JSONLevelBuilder));
+
+  builder->root = (ArrayObjectJSON*)ss_alloc(builder->memory_stack, 1, sizeof(ArrayObjectJSON));
+
+  builder->root->next = (ArrayObjectJSON*)ss_alloc(builder->memory_stack, 1, sizeof(ArrayObjectJSON));
+
+  builder->resulting_json = NULL;
+  builder->root->identifier_int = 0;
+  builder->root->value_list = NULL;
+  builder->root->set_flag = 0;
+
+  builder->root_level->search_list = (HashList*)ss_alloc(builder->memory_stack, 1, sizeof(HashList));
+
+  builder->row_count = 0;
+  builder->json_char_count = 3; //Starts with "[]\0"
+  builder->max_depth = 0;
+  builder->max_real_depth = 0;
+}
+
+void set_row_count(JSONDocumentBuilder *builder, unsigned long count)
+{
+  builder->row_count = count;
+  initialize_search_list(builder->root_level, builder->memory_stack, count);
+}
+
+void initialize_search_list(JSONLevelBuilder* level, SSMemoryStack* memory_stack, unsigned long count)
+{
+  hl_initialize(level->search_list, memory_stack, count);
+}
+
+unsigned long get_row_count(JSONDocumentBuilder *builder)
+{
+  return builder->row_count;
+}
+
+void set_repeating_array_columns(JSONDocumentBuilder *builder, unsigned long* repeating)
+{
+  builder->root_level->repeating_array_columns = (unsigned long*)ss_alloc(builder->memory_stack, 1, sizeof(unsigned long) * builder->root_level->column_count);
+  memcpy(builder->root_level->repeating_array_columns, repeating, sizeof(unsigned long) * builder->root_level->column_count);
+}
+
+void set_column_count(JSONDocumentBuilder *builder, unsigned long count)
+{
+  builder->root_level->column_count = count;
+}
+
+unsigned long get_column_count(JSONDocumentBuilder *builder)
+{
+  return builder->root_level->column_count;
+}
+
+void set_quote_array(JSONDocumentBuilder *builder, unsigned long* quotes)
+{
+  builder->root_level->quote_array = (unsigned long*)ss_alloc(builder->memory_stack, 1, sizeof(unsigned long) * builder->root_level->column_count);
+  memcpy(builder->root_level->quote_array, quotes, sizeof(unsigned long) * (builder->root_level->column_count));
+}
+
+void set_hashing_array(JSONDocumentBuilder *builder, unsigned long* do_not_hashes)
+{
+  builder->root_level->do_not_hash = (unsigned long*)ss_alloc(builder->memory_stack, 1, sizeof(unsigned long) * builder->root_level->column_count);
+  memcpy(builder->root_level->do_not_hash, do_not_hashes, sizeof(unsigned long) * (builder->root_level->column_count));
+}
+
+void set_depth_array(
+  JSONDocumentBuilder *builder, 
+  unsigned long* depths, 
+  unsigned long max, 
+  unsigned long* real_depths, 
+  unsigned long max_real
+  )
+{
+  builder->root_level->depth_array = (unsigned long*)ss_alloc(builder->memory_stack, 1, sizeof(unsigned long) * builder->root_level->column_count);
+  memcpy(builder->root_level->depth_array, depths, sizeof(unsigned long) * (builder->root_level->column_count));
+
+  builder->max_depth = max;
+  
+  builder->root_level->real_depth_array = (unsigned long*)ss_alloc(builder->memory_stack, 1, sizeof(unsigned long) * builder->root_level->column_count);
+  memcpy(builder->root_level->real_depth_array, real_depths, sizeof(unsigned long) * (builder->root_level->column_count));
+  
+  builder->max_real_depth = max_real;
+}
+
+void set_single_node_key_names(JSONDocumentBuilder *builder, char** key_array, unsigned long* key_sizes)
+{
+  builder->single_object_key_lengths = (unsigned long*)ss_alloc(builder->memory_stack, 1, sizeof(unsigned long) * builder->root_level->column_count);
+  builder->single_object_key_names = (char**)ss_alloc(builder->memory_stack, 1, sizeof(char*) * builder->root_level->column_count);
+
+  memcpy(builder->single_object_key_lengths, key_sizes, sizeof(unsigned long*) * (builder->root_level->column_count));
+  memcpy(builder->single_object_key_names, key_array, sizeof(char*) * (builder->root_level->column_count));
+}
+
+
+void set_array_node_key_names(JSONDocumentBuilder *builder, char** key_array, unsigned long* key_sizes)
+{
+  builder->array_object_key_lengths = (unsigned long*)ss_alloc(builder->memory_stack, 1, sizeof(unsigned long) * builder->root_level->column_count);
+  builder->array_object_key_names = (char**)ss_alloc(builder->memory_stack, 1, sizeof(char*) * builder->root_level->column_count);
+
+  memcpy(builder->array_object_key_lengths, key_sizes, sizeof(unsigned long*) * (builder->root_level->column_count));
+  memcpy(builder->array_object_key_names, key_array, sizeof(char*) * (builder->root_level->column_count));
+}
+
+void set_column_names_sizes(JSONDocumentBuilder *builder, char** column_names, unsigned long* column_string_sizes)
+{
+  builder->root_level->column_name_lengths = (unsigned long*)ss_alloc(builder->memory_stack, 1, sizeof(unsigned long) * builder->root_level->column_count);
+  builder->root_level->column_names = (char**)ss_alloc(builder->memory_stack, 1, sizeof(char*) * builder->root_level->column_count);
+
+  memcpy(builder->root_level->column_name_lengths, column_string_sizes, sizeof(unsigned long*) * (builder->root_level->column_count));
+  memcpy(builder->root_level->column_names, column_names, sizeof(char*) * (builder->root_level->column_count));
+}
+
+void set_mapping_array(JSONDocumentBuilder *builder, char** internal_map, unsigned long* internal_map_sizes)
+{
+  builder->root_level->mapping_array_lengths = (unsigned long*)ss_alloc(builder->memory_stack, 1, sizeof(unsigned long) * builder->root_level->column_count);;
+  builder->root_level->mapping_array = (char**)ss_alloc(builder->memory_stack, 1, sizeof(char*) * builder->root_level->column_count);
+
+  memcpy(builder->root_level->mapping_array_lengths, internal_map_sizes, sizeof(unsigned long) * (builder->root_level->column_count));
+  memcpy(builder->root_level->mapping_array, internal_map, sizeof(char*) * (builder->root_level->column_count));
+}
+
+void consume_row(
+  JSONDocumentBuilder *builder,
+  char** row_strings,
+  unsigned long* string_sizes,
+  unsigned long accessing_depth,
+  unsigned long visible_depth,
+  unsigned long column_count,
+  JSONObject* parent_object,
+  JSONLevelBuilder* level_definitions,
+  unsigned char parent_type,
+  int parent_identifier,
+  HashList* parent_search_list
+  )
+{
+  uint64_t hash;
+  JSONObject* found_object;
+  JSONLevelBuilder* child_levels = (JSONLevelBuilder*)ss_alloc(builder->memory_stack, 1, sizeof(JSONLevelBuilder));
+  JSONLevelBuilder* child_array_start = (JSONLevelBuilder*)ss_alloc(builder->memory_stack, 1, sizeof(JSONLevelBuilder));
+
+  child_levels->next_child = (JSONLevelBuilder*)ss_alloc(builder->memory_stack, 1, sizeof(JSONLevelBuilder));
+  child_levels->next_child_array = (JSONLevelBuilder*)ss_alloc(builder->memory_stack, 1, sizeof(JSONLevelBuilder));
+
+  child_array_start->next_child = (JSONLevelBuilder*)ss_alloc(builder->memory_stack, 1, sizeof(JSONLevelBuilder));
+  child_array_start->next_child_array = (JSONLevelBuilder*)ss_alloc(builder->memory_stack, 1, sizeof(JSONLevelBuilder));
+
+  if (accessing_depth == 0 && visible_depth == 0) {
+    level_definitions = builder->root_level;
+  }
+
+  hash = calculate_run_hash(level_definitions, column_count, string_sizes, row_strings, accessing_depth, (accessing_depth + visible_depth));
+
+  found_object = find_or_create_node(
+    builder, 
+    level_definitions, 
+    child_levels, 
+    child_array_start,
+    parent_object, 
+    hash, 
+    parent_type, 
+    row_strings, 
+    string_sizes, 
+    (visible_depth + accessing_depth),
+    parent_search_list);
+
+  define_child_levels(builder, level_definitions, child_levels, hash, column_count, (accessing_depth + visible_depth));
+
+  initialize_child_levels(child_levels, builder->memory_stack);
+  set_single_object_child_level_definitions(level_definitions, child_levels, hash, column_count, (accessing_depth + visible_depth));
+  assign_single_object_data(level_definitions, child_levels, row_strings, string_sizes, column_count, (accessing_depth + visible_depth));
+
+  define_child_array_levels(builder, level_definitions, child_array_start, hash, column_count, accessing_depth, visible_depth, row_strings, string_sizes);
+  initialize_child_array_levels(child_array_start, builder->memory_stack);
+  set_array_object_child_level_definitions(level_definitions, child_array_start, hash, column_count, (accessing_depth + visible_depth));
+  assign_array_object_data(level_definitions, child_array_start, row_strings, string_sizes, column_count, (accessing_depth + visible_depth));
+
+  if (found_object) {
+    add_or_find_single_object_child_hashes(builder,
+      child_levels,
+      found_object,
+      parent_object,
+      hash,
+      parent_type,
+      parent_identifier);
+
+    add_or_find_array_object_child_hashes(builder, 
+      level_definitions, 
+      child_array_start, 
+      accessing_depth,
+      visible_depth, 
+      column_count, 
+      string_sizes, 
+      row_strings, 
+      found_object
+      );
+
+    consume_single_objects(
+      builder, 
+      child_levels, 
+      found_object,
+      parent_search_list,
+      accessing_depth, 
+      visible_depth
+      );
+
+    consume_array_objects(
+      builder, 
+      child_array_start, 
+      found_object,
+      accessing_depth, 
+      visible_depth 
+      );
+  }
+}
+
+void consume_single_objects (
+  JSONDocumentBuilder* builder, 
+  JSONLevelBuilder* child_levels, 
+  JSONObject* found_object, 
+  HashList* parent_search_list,
+  unsigned long accessing_depth, 
+  unsigned long visible_depth
+  )
+{
+  while(child_levels->set_flag && parent_search_list->length) {
+    if (found_object->single_objects->set_flag) {
+      consume_row(builder,
+        child_levels->active_row_strings->row_strings,
+        child_levels->active_row_strings->string_lengths,
+        accessing_depth,
+        (visible_depth + 1),
+        child_levels->column_count,
+        found_object,
+        child_levels,
+        2,
+        child_levels->identifier_int,
+        parent_search_list
+        );
+    } else {
+      consume_row(builder,
+        child_levels->active_row_strings->row_strings,
+        child_levels->active_row_strings->string_lengths,
+        accessing_depth,
+        (visible_depth + 1),
+        child_levels->column_count,
+        found_object,
+        child_levels,
+        2,
+        child_levels->identifier_int,
+        parent_search_list
+        );      
+    }
+    child_levels = child_levels->next_child;
+  }
+}
+
+void consume_array_objects(JSONDocumentBuilder* builder, 
+  JSONLevelBuilder* child_array_levels, 
+  JSONObject* found_object, 
+  unsigned long accessing_depth, 
+  unsigned long visible_depth)
+{
+  while(child_array_levels->set_flag) {
+    consume_row(builder,
+      child_array_levels->active_row_strings->row_strings,
+      child_array_levels->active_row_strings->string_lengths,
+      (accessing_depth + 1),
+      visible_depth,
+      child_array_levels->column_count,
+      found_object,
+      child_array_levels,
+      4,
+      child_array_levels->identifier_int,
+      child_array_levels->search_list
+      );
+
+    child_array_levels = child_array_levels->next_child_array;
+  }
+}
+
+uint64_t calculate_run_hash(JSONLevelBuilder* level_definitions, unsigned long column_count, unsigned long* string_sizes, char** row_strings, unsigned long accessing_depth, unsigned long hashing_depth)
+{
+  uint64_t hash = FNV_OFFSET;
+  unsigned long counter = 0;
+  unsigned long inner_counter = 0;
+
+  while(counter < column_count) {
+    inner_counter = 0;
+
+    if ((!level_definitions->do_not_hash[counter]) && (level_definitions->real_depth_array[counter] == accessing_depth)
+      && (hashing_depth <= level_definitions->depth_array[counter]))
+    {  
+      while (inner_counter < string_sizes[counter]) {
+        hash_byte(&hash, &row_strings[counter][inner_counter]);
+        inner_counter++;
+      }
+    }
+    counter++;
+  }
+
+  return hash;
+}
+
+uint64_t calculate_identified_hash(
+  JSONLevelBuilder* level_definitions,
+  unsigned long column_count,
+  unsigned long* string_sizes,
+  char** row_strings,
+  unsigned long accessing_depth,
+  unsigned long hashing_depth,
+  int test_identifier_length,
+  char* test_identifier)
+{
+  uint64_t hash = FNV_OFFSET;
+  unsigned long counter = 0;
+  unsigned long inner_counter = 0;
+  int cursor;
+  int inner_identifier_length;
+  char* inner_test_identifier;
+
+  while(counter < column_count) {
+    if (level_definitions->real_depth_array[counter] == accessing_depth) {
+      cursor = 0;
+
+      read_identifier((accessing_depth - 1), level_definitions->mapping_array[counter], &cursor, &inner_identifier_length, level_definitions->mapping_array_lengths[counter]);
+      inner_test_identifier = level_definitions->mapping_array[counter] + cursor;
+
+      // TODO: check to see if we're looking at a 4, only hash on 4s
+      inner_counter = 0;
+      if ((!level_definitions->do_not_hash[counter]) 
+        && (hashing_depth <= level_definitions->depth_array[counter]) 
+        && (inner_identifier_length == test_identifier_length)) {
+        if (!memcmp(test_identifier, inner_test_identifier, test_identifier_length)) {
+          while (inner_counter < string_sizes[counter]) {
+            hash_byte(&hash, &row_strings[counter][inner_counter]);
+            inner_counter++;
+          }
+        }
+      }
+    }
+    counter++;
+  }
+
+  return hash;
+}
+
+char read_type(unsigned long depth_start, 
+  char* mapped_value, 
+  unsigned long mapped_value_length)
+{
+  unsigned long cursor = 0;
+  unsigned long depth_counter = 0;
+
+  if (depth_start > 0) {
+    while (depth_counter < depth_start) {
+      if (cursor >= mapped_value_length) {
+        return 0;
+      }
+      else if (mapped_value[cursor] == '-') {
+        depth_counter++;
+      }
+      cursor++;
+    }
+  }
+  return mapped_value[cursor];
+}
+
+void read_identifier(char depth_start, 
+  char* mapped_value, 
+  int* cursor, 
+  int* identifier_characters, 
+  unsigned long mapped_value_length)
+{
+  *cursor = 0;
+  unsigned char end_cursor = 0;
+  *identifier_characters = 0;
+  char depth_counter = 0;
+  
+  if (depth_start > 0) {
+    while (depth_counter < depth_start) {
+      if (mapped_value[*cursor] == '-') {
+        depth_counter++;
+      }
+      *cursor += 1;
+    }
+  }
+
+  *cursor += 2;
+  end_cursor = *cursor;
+
+  while (mapped_value[end_cursor] != '-' && end_cursor < mapped_value_length) {
+    *identifier_characters += 1;
+    end_cursor++;
+  }
+}
+
+void define_child_levels(
+  JSONDocumentBuilder *builder, 
+  JSONLevelBuilder* level_definitions, 
+  JSONLevelBuilder* child_levels, 
+  uint64_t hash, 
+  unsigned long column_count, 
+  unsigned long visible_depth
+  )
+{
+  unsigned long counter = 0;
+  int test_identifier_length;
+  int identifier_int;
+  int cursor;
+  char* test_identifier;
+  char type;
+
+  while(counter < column_count) {
+    type = read_type(visible_depth, level_definitions->mapping_array[counter], level_definitions->mapping_array_lengths[counter]);
+    read_identifier(visible_depth, level_definitions->mapping_array[counter], &cursor, &test_identifier_length, level_definitions->mapping_array_lengths[counter]);
+    
+    test_identifier = ss_alloc(builder->memory_stack, 1, test_identifier_length + 1);
+    memcpy(test_identifier, level_definitions->mapping_array[counter] + cursor, test_identifier_length);
+    test_identifier[test_identifier_length] = '\0';
+    identifier_int = atoi(test_identifier);
+
+    if (type == '2') {
+      count_increment_or_create_json_level_child(builder, child_levels, test_identifier_length, test_identifier, identifier_int, hash);
+    }
+    if ((level_definitions->real_depth_array[counter] == visible_depth) && (level_definitions->do_not_hash[counter]) && (!level_definitions->defined_flag)) { 
+      level_definitions->contains_array_value_flag = 1;
+    }
+    counter++;
+  }
+}
+
+void define_child_array_levels(
+  JSONDocumentBuilder *builder, 
+  JSONLevelBuilder* level_definitions, 
+  JSONLevelBuilder* child_array_start, 
+  uint64_t hash, 
+  unsigned long column_count, 
+  unsigned long accessing_depth, 
+  unsigned long visible_depth, 
+  char** row_strings, 
+  unsigned long* string_sizes)
+{
+  unsigned long counter = 0;
+  int test_identifier_length;
+  int identifier_int;
+  int cursor;
+  char* test_identifier;
+  char type;
+  uint64_t child_hash;
+
+  while(counter < column_count) {
+      type = read_type(accessing_depth + visible_depth, level_definitions->mapping_array[counter], level_definitions->mapping_array_lengths[counter]);
+      read_identifier(accessing_depth + visible_depth, level_definitions->mapping_array[counter], &cursor, &test_identifier_length, level_definitions->mapping_array_lengths[counter]);
+
+      test_identifier = ss_alloc(builder->memory_stack, 1, test_identifier_length + 1);
+      memcpy(test_identifier, level_definitions->mapping_array[counter] + cursor, test_identifier_length);
+      test_identifier[test_identifier_length] = '\0';
+      identifier_int = atoi(test_identifier);
+
+      if (type == '4') {
+        child_hash = calculate_identified_hash(level_definitions, column_count, string_sizes, row_strings, (accessing_depth + 1), (accessing_depth + visible_depth + 1), test_identifier_length, test_identifier);
+        count_increment_or_create_json_level_child_array(builder, child_array_start, test_identifier_length, test_identifier, identifier_int, hash, child_hash);
+      }
+
+    if ((level_definitions->real_depth_array[counter] == accessing_depth) && (level_definitions->do_not_hash[counter]) && (!level_definitions->defined_flag)) { 
+      level_definitions->contains_array_value_flag = 1;
+    }
+    counter++;
+  }
+}
+
+char* finalize_json(JSONDocumentBuilder *builder)
+{
+  unsigned long counter;
+
+  builder->resulting_json = ss_alloc(builder->memory_stack, 1, builder->json_char_count - 1); // Remove extra character from last comma
+  counter = 0;
+  memcpy(builder->resulting_json + counter, ob, 1);
+  counter++;
+  counter = finalize_object_array(builder, builder->root, counter);
+
+  memcpy(builder->resulting_json + counter, end, 1);
+  return builder->resulting_json;
+}