map.h

Go to the documentation of this file.

// The MIT License (MIT)
// Copyright (c) 2018 Maksim Andrianov
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.
#ifndef CDCONTAINERS_INCLUDE_CDCONTAINERS_MAP_H
#define CDCONTAINERS_INCLUDE_CDCONTAINERS_MAP_H

#include <cdcontainers/common.h>
#include <cdcontainers/status.h>
#include <cdcontainers/tables/imap.h>

#include <assert.h>
#include <stdarg.h>
#include <stdbool.h>

struct cdc_map {
  void *container;
  const struct cdc_map_table *table;
};

struct cdc_map_iter {
  void *iter;
  const struct cdc_map_iter_table *table;
};

// Base
enum cdc_stat cdc_map_ctor(const struct cdc_map_table *table,
                           struct cdc_map **m, struct cdc_data_info *info);

enum cdc_stat cdc_map_ctorl(const struct cdc_map_table *table,
                            struct cdc_map **m, struct cdc_data_info *info,
                            ...);

enum cdc_stat cdc_map_ctorv(const struct cdc_map_table *table,
                            struct cdc_map **m, struct cdc_data_info *info,
                            va_list args);
void cdc_map_dtor(struct cdc_map *m);
// Lookup
static inline enum cdc_stat cdc_map_get(struct cdc_map *m, void *key,
                                        void **value)
{
  assert(m != NULL);

  return m->table->get(m->container, key, value);
}

static inline size_t cdc_map_count(struct cdc_map *m, void *key)
{
  assert(m != NULL);

  return m->table->count(m->container, key);
}

static inline void cdc_map_find(struct cdc_map *m, void *key,
                                struct cdc_map_iter *it)
{
  assert(m != NULL);

  m->table->find(m->container, key, it->iter);
}
// Capacity
static inline size_t cdc_map_size(struct cdc_map *m)
{
  assert(m != NULL);

  return m->table->size(m->container);
}

static inline bool cdc_map_empty(struct cdc_map *m)
{
  assert(m != NULL);

  return m->table->empty(m->container);
}
// Modifiers
static inline void cdc_map_clear(struct cdc_map *m)
{
  assert(m != NULL);

  m->table->clear(m->container);
}

static inline enum cdc_stat cdc_map_insert(struct cdc_map *m, void *key,
                                           void *value, struct cdc_map_iter *it,
                                           bool *inserted)
{
  assert(m != NULL);

  void *iter = it ? it->iter : NULL;
  return m->table->insert(m->container, key, value, iter, inserted);
}

static inline enum cdc_stat cdc_map_insert_or_assign(struct cdc_map *m,
                                                     void *key, void *value,
                                                     struct cdc_map_iter *it,
                                                     bool *inserted)
{
  assert(m != NULL);

  void *iter = it ? it->iter : NULL;
  return m->table->insert_or_assign(m->container, key, value, iter, inserted);
}

static inline size_t cdc_map_erase(struct cdc_map *m, void *key)
{
  assert(m != NULL);

  return m->table->erase(m->container, key);
}

static inline void cdc_map_swap(struct cdc_map *a, struct cdc_map *b)
{
  assert(a != NULL);
  assert(b != NULL);
  assert(a->table == b->table);

  CDC_SWAP(void *, a->container, b->container);
}
// Iterators
static inline void cdc_map_begin(struct cdc_map *m, struct cdc_map_iter *it)
{
  assert(m != NULL);
  assert(it != NULL);

  m->table->begin(m->container, it->iter);
}

static inline void cdc_map_end(struct cdc_map *m, struct cdc_map_iter *it)
{
  assert(m != NULL);
  assert(it != NULL);

  m->table->end(m->container, it->iter);
}
// Iterators
enum cdc_stat cdc_map_iter_ctor(struct cdc_map *m, struct cdc_map_iter *it);

static inline void cdc_map_iter_dtor(struct cdc_map_iter *it)
{
  assert(it != NULL);

  it->table->dtor(it->iter);
}

static inline enum cdc_iterator_type cdc_map_iter_type(struct cdc_map_iter *it)
{
  assert(it != NULL);

  return it->table->type();
}

static inline void cdc_map_iter_next(struct cdc_map_iter *it)
{
  assert(it != NULL);

  it->table->next(it->iter);
}

static inline void cdc_map_iter_prev(struct cdc_map_iter *it)
{
  assert(it != NULL);

  it->table->prev(it->iter);
}

static inline bool cdc_map_iter_has_next(struct cdc_map_iter *it)
{
  assert(it != NULL);

  return it->table->has_next(it->iter);
}

static inline bool cdc_map_iter_has_prev(struct cdc_map_iter *it)
{
  assert(it != NULL);

  return it->table->has_prev(it->iter);
}

static inline void *cdc_map_iter_key(struct cdc_map_iter *it)
{
  assert(it != NULL);

  return it->table->key(it->iter);
}

static inline void *cdc_map_iter_value(struct cdc_map_iter *it)
{
  assert(it != NULL);

  return it->table->value(it->iter);
}

static inline struct cdc_pair cdc_map_iter_key_value(struct cdc_map_iter *it)
{
  assert(it != NULL);

  return it->table->key_value(it->iter);
}

static inline bool cdc_map_iter_is_eq(struct cdc_map_iter *it1,
                                      struct cdc_map_iter *it2)
{
  assert(it1 != NULL);
  assert(it2 != NULL);
  assert(it1->table == it2->table);

  return it1->table->eq(it1->iter, it2->iter);
}
// Short names
#ifdef CDC_USE_SHORT_NAMES
typedef struct cdc_map map_t;
typedef struct cdc_map_iter map_iter_t;

// Base
#define map_ctor(...) cdc_map_ctor(__VA_ARGS__)
#define map_ctorv(...) cdc_map_ctorv(__VA_ARGS__)
#define map_ctorl(...) cdc_map_ctorl(__VA_ARGS__)
#define map_dtor(...) cdc_map_dtor(__VA_ARGS__)

// Lookup
#define map_get(...) cdc_map_get(__VA_ARGS__)
#define map_count(...) cdc_map_count(__VA_ARGS__)
#define map_find(...) cdc_map_find(__VA_ARGS__)

// Capacity
#define map_size(...) cdc_map_size(__VA_ARGS__)
#define map_empty(...) cdc_map_empty(__VA_ARGS__)

// Modifiers
#define map_clear(...) cdc_map_clear(__VA_ARGS__)
#define map_insert(...) cdc_map_insert(__VA_ARGS__)
#define map_insert_or_assign(...) cdc_map_insert_or_assign(__VA_ARGS__)
#define map_erase(...) cdc_map_erase(__VA_ARGS__)
#define map_swap(...) cdc_map_swap(__VA_ARGS__)

// Iterators
#define map_begin(...) cdc_map_begin(__VA_ARGS__)
#define map_end(...) cdc_map_end(__VA_ARGS__)

// Iterators
#define map_iter_ctor(...) cdc_map_iter_ctor(__VA_ARGS__)
#define map_iter_dtor(...) cdc_map_iter_dtor(__VA_ARGS__)
#define map_iter_next(...) cdc_map_iter_next(__VA_ARGS__)
#define map_iter_has_next(...) cdc_map_iter_has_next(__VA_ARGS__)
#define map_iter_key(...) cdc_map_iter_key(__VA_ARGS__)
#define map_iter_value(...) cdc_map_iter_value(__VA_ARGS__)
#define map_iter_key_value(...) cdc_map_iter_key_value(__VA_ARGS__)
#define map_iter_is_eq(...) cdc_map_iter_is_eq(__VA_ARGS__)
#endif

#endif  // CDCONTAINERS_INCLUDE_CDCONTAINERS_MAP_H