maps.c File Reference

#include "serene/rt/maps.h"
#include "serene/rt/context.h"
#include "serene/rt/core.h"
#include "serene/rt/engine.h"
#include "serene/rt/errors.h"
#include "serene/rt/impl/hashmap.h"
#include "serene/rt/protocols.h"
#include "serene/utils.h"

Include dependency graph for maps.c:

Go to the source code of this file.

Functions
static bool	srn_vmap_cmp (const hmap_t *hmap, const hmap_key_t *a, const hmap_key_t *b)
static hmap_hash_t	srn_vmap_hash (const hmap_t *hmap, const hmap_key_t *k)
srn_value_t *	srn_map_empty (srn_context_t *ctx, srn_metadata_t *metadata)
srn_value_t *	srn_map_assoc (srn_context_t *ctx, srn_metadata_t *metadata, srn_value_t *map, srn_value_t *key, srn_value_t *value)

Variables
static const hmap_control_t	value_map

Function Documentation

srn_map_assoc()

srn_value_t * srn_map_assoc	(	srn_context_t *	ctx,
		srn_metadata_t *	metadata,
		srn_value_t *	map,
		srn_value_t *	key,
		srn_value_t *	value )

Definition at line 71 of file maps.c.

  {
  PANIC_IF_NULL(ctx);
  PANIC_IF_NULL(map);
  PANIC_IF_NULL(key);
  PANIC_IF_NULL(value);
 
  if (!IS_A(map, VMap)) {
    return srn_errors_make_error(ctx, metadata, ABSURD, "expected a map");
  }
 
  // Hashing panics on the unhashable tags, and a panic from a data driven
  // value is wrong in an API that reports failures as values.
  if (!srn_value_hashable(key)) {
    return srn_errors_make_error(ctx, metadata, ABSURD, "map key is not hashable");
  }
 
  hmap_key_t k = {.data = key, .len = sizeof(*key)};
 
  srn_map_t *old = AS_MAP(map);
  srn_map_t *neu = ALLOC(ctx, srn_map_t);
 
  neu->inner = value_map.insert(&value_map, &old->inner, &k, value);
  return srn_value_make(ctx, VMap, metadata, (void *)neu);
}

Here is the call graph for this function:

Here is the caller graph for this function:

srn_map_empty()

srn_value_t * srn_map_empty	(	srn_context_t *	ctx,
		srn_metadata_t *	metadata )

Definition at line 64 of file maps.c.

                                                                         {
  PANIC_IF_NULL(ctx);
  srn_map_t *m = ALLOC(ctx, srn_map_t);
  m->inner     = hmap_empty(ctx);
  return srn_value_make(ctx, VMap, metadata, (void *)m);
}

Here is the call graph for this function:

Here is the caller graph for this function:

srn_vmap_cmp()

bool srn_vmap_cmp ( const hmap_t * hmap, const hmap_key_t * a, const hmap_key_t * b )

static

Definition at line 28 of file maps.c.

                                                                                       {
  srn_value_t *va  = (srn_value_t *)a->data;
  srn_value_t *vb  = (srn_value_t *)b->data;
  srn_value_t *res = srn_value_eq(hmap->map_ctx, va, vb);
  switch (TYPE(res)) {
  case VFalse:
    return false;
  case VTrue:
    return true;
  default:
    PANIC("Should never happen");
  }
}

Here is the call graph for this function:

srn_vmap_hash()

hmap_hash_t srn_vmap_hash ( const hmap_t * hmap, const hmap_key_t * k )

static

Definition at line 43 of file maps.c.

                                                                          {
  PANIC_IF_NULL(k);
  PANIC_IF_NULL(k->data);
  srn_value_t *v = (srn_value_t *)k->data;
 
  PANIC_IF_NULL(v);
  return srn_value_hash(hmap->map_ctx, v);
}

Here is the call graph for this function:

Variable Documentation

value_map

const hmap_control_t value_map

static

Initial value:

                                      = {
  .cmp    = &srn_vmap_cmp,
  .hash   = &srn_vmap_hash,
  .insert = hmap_insert_ctl,
  .lookup = hmap_lookup_ctl,
  
  
  
  
  .copy_key = &hmap_copy_key,
}

Definition at line 52 of file maps.c.

                                      {
  .cmp    = &srn_vmap_cmp,
  .hash   = &srn_vmap_hash,
  .insert = hmap_insert_ctl,
  .lookup = hmap_lookup_ctl,
  // The key bytes are a shallow srn_value_t struct; copying them into the
  // map's pinned context keeps the retained key valid independently of the
  // assoc'ing caller's context. Anything the value points at (its payload,
  // metadata) is still the caller's to keep alive.
  .copy_key = &hmap_copy_key,
};