tatara 0.2.0 → 0.3.0

data/ext/tatara/map/float/float_float_map.hpp

@@ -0,0 +1,66 @@
+#ifndef FLOAT_FLOAT_MAP_HPP_
+#define FLOAT_FLOAT_MAP_HPP_
+
+#include <ruby.h>
+#include <unordered_map>
+
+class FloatFloatMap {
+    std::unordered_map<double, double> container;
+
+    public:
+        FloatFloatMap();
+        ~FloatFloatMap();
+        double bracket(const double key);
+        double bracket_equal(const double key, const double value);
+};
+
+FloatFloatMap::FloatFloatMap() {}
+
+FloatFloatMap::~FloatFloatMap() {}
+
+double FloatFloatMap::bracket(const double key) {
+    return this->container[key];
+}
+
+double FloatFloatMap::bracket_equal(const double key, const double value) {
+    return this->container[key] = value;
+}
+
+static FloatFloatMap *getFloatFloatMap(VALUE self) {
+    FloatFloatMap *ptr;
+    Data_Get_Struct(self, FloatFloatMap, ptr);
+    return ptr;
+}
+
+static void wrap_float_float_map_free(FloatFloatMap *ptr) {
+    ptr->~FloatFloatMap();
+    ruby_xfree(ptr);
+}
+
+static VALUE wrap_float_float_map_alloc(VALUE klass) {
+    void *p = ruby_xmalloc(sizeof(FloatFloatMap));
+    p = new FloatFloatMap;
+    return Data_Wrap_Struct(klass, NULL, wrap_float_float_map_free, p);
+}
+
+static VALUE wrap_float_float_map_init(VALUE self) {
+    FloatFloatMap *p = getFloatFloatMap(self);
+    p = new FloatFloatMap;
+    return Qnil;
+}
+
+static VALUE wrap_float_float_map_bracket(VALUE self, VALUE key) {
+    const double k = NUM2DBL(key);
+    const double value = getFloatFloatMap(self)->bracket(k);
+    VALUE result = DBL2NUM(value);
+    return result;
+}
+
+static VALUE wrap_float_float_map_bracket_equal(VALUE self, VALUE key, VALUE value) {
+    const double k = NUM2DBL(key);
+    const double v = NUM2DBL(value);
+    getFloatFloatMap(self)->bracket_equal(k, v);
+    return value;
+}
+
+#endif

data/ext/tatara/map/float/float_int_map.hpp

@@ -0,0 +1,66 @@
+#ifndef FLOAT_INT_MAP_HPP_
+#define FLOAT_INT_MAP_HPP_
+
+#include <ruby.h>
+#include <unordered_map>
+
+class FloatIntMap {
+    std::unordered_map<double, int> container;
+
+public:
+    FloatIntMap();
+    ~FloatIntMap();
+    int bracket(const double key);
+    int bracket_equal(const double key, const int value);
+};
+
+FloatIntMap::FloatIntMap() {}
+
+FloatIntMap::~FloatIntMap() {}
+
+int FloatIntMap::bracket(const double key) {
+    return this->container[key];
+}
+
+int FloatIntMap::bracket_equal(const double key, const int value) {
+    return this->container[key] = value;
+}
+
+static FloatIntMap *getFloatIntMap(VALUE self) {
+    FloatIntMap *ptr;
+    Data_Get_Struct(self, FloatIntMap, ptr);
+    return ptr;
+}
+
+static void wrap_float_int_map_free(FloatIntMap *ptr) {
+    ptr->~FloatIntMap();
+    ruby_xfree(ptr);
+}
+
+static VALUE wrap_float_int_map_alloc(VALUE klass) {
+    void *p = ruby_xmalloc(sizeof(FloatIntMap));
+    p = new FloatIntMap;
+    return Data_Wrap_Struct(klass, NULL, wrap_float_int_map_free, p);
+}
+
+static VALUE wrap_float_int_map_init(VALUE self) {
+    FloatIntMap *p = getFloatIntMap(self);
+    p = new FloatIntMap;
+    return Qnil;
+}
+
+static VALUE wrap_float_int_map_bracket(VALUE self, VALUE key) {
+    const double k = NUM2DBL(key);
+    const int value = getFloatIntMap(self)->bracket(k);
+    VALUE result = INT2NUM(value);
+    return result;
+}
+
+static VALUE wrap_float_int_map_bracket_equal(VALUE self, VALUE key, VALUE value) {
+    const double k = NUM2DBL(key);
+    const int v = NUM2INT(value);
+    getFloatIntMap(self)->bracket_equal(k, v);
+    return value;
+}
+
+#endif

data/ext/tatara/map/float/float_string_map.hpp

@@ -0,0 +1,67 @@
+#ifndef FLOAT_STRING_MAP_HPP_
+#define FLOAT_STRING_MAP_HPP_
+
+#include <ruby.h>
+#include <unordered_map>
+#include <string>
+
+class FloatStringMap {
+    std::unordered_map<double, std::string> container;
+
+    public:
+        FloatStringMap();
+        ~FloatStringMap();
+        std::string bracket(const double key);
+        std::string bracket_equal(const double key, const std::string value);
+};
+
+FloatStringMap::FloatStringMap() {}
+
+FloatStringMap::~FloatStringMap() {}
+
+std::string FloatStringMap::bracket(const double key) {
+    return this->container[key];
+}
+
+std::string FloatStringMap::bracket_equal(const double key, const std::string value) {
+    return this->container[key] = value;
+}
+
+static FloatStringMap* getFloatStringMap(VALUE self) {
+    FloatStringMap *ptr;
+    Data_Get_Struct(self, FloatStringMap, ptr);
+    return ptr;
+}
+
+static void wrap_float_string_map_free(FloatStringMap *ptr) {
+    ptr->~FloatStringMap();
+    ruby_xfree(ptr);
+}
+
+static VALUE wrap_float_string_map_alloc(VALUE klass) {
+    void *p = ruby_xmalloc(sizeof(FloatStringMap));
+    p = new FloatStringMap;
+    return Data_Wrap_Struct(klass, NULL, wrap_float_string_map_free, p);
+}
+
+static VALUE wrap_float_string_map_init(VALUE self) {
+    FloatStringMap *p = getFloatStringMap(self);
+    p = new FloatStringMap;
+    return Qnil;
+}
+
+static VALUE wrap_float_string_map_bracket(VALUE self, VALUE key) {
+    const double k = NUM2DBL(key);
+    const std::string value = getFloatStringMap(self)->bracket(k);
+    VALUE result = rb_str_new(value.c_str(), value.size());
+    return result;
+}
+
+static VALUE wrap_float_string_map_bracket_equal(VALUE self, VALUE key, VALUE value) {
+    const double k = NUM2DBL(key);
+    const std::string v = StringValueCStr(value);
+    getFloatStringMap(self)->bracket_equal(k, v);
+    return value;
+}
+
+#endif

data/ext/tatara/map/integer/int_float_map.hpp

@@ -0,0 +1,66 @@
+#ifndef INT_FLOAT_MAP_HPP_
+#define INT_FLOAT_MAP_HPP_
+
+#include <ruby.h>
+#include <unordered_map>
+
+class IntFloatMap {
+    std::unordered_map<int, double> container;
+
+    public:
+        IntFloatMap();
+        ~IntFloatMap();
+        double bracket(const int key);
+        double bracket_equal(const int key, const double value);
+};
+
+IntFloatMap::IntFloatMap() {}
+
+IntFloatMap::~IntFloatMap() {}
+
+double IntFloatMap::bracket(const int key) {
+    return this->container[key];
+}
+
+double IntFloatMap::bracket_equal(const int key, const double value) {
+    return this->container[key] = value;
+}
+
+static IntFloatMap *getIntFloatMap(VALUE self) {
+    IntFloatMap *ptr;
+    Data_Get_Struct(self, IntFloatMap, ptr);
+    return ptr;
+}
+
+static void wrap_int_float_map_free(IntFloatMap *ptr) {
+    ptr->~IntFloatMap();
+    ruby_xfree(ptr);
+}
+
+static VALUE wrap_int_float_map_alloc(VALUE klass) {
+    void *p = ruby_xmalloc(sizeof(IntFloatMap));
+    p = new IntFloatMap;
+    return Data_Wrap_Struct(klass, NULL, wrap_int_float_map_free, p);
+}
+
+static VALUE wrap_int_float_map_init(VALUE self) {
+    IntFloatMap *p = getIntFloatMap(self);
+    p = new IntFloatMap;
+    return Qnil;
+}
+
+static VALUE wrap_int_float_map_bracket(VALUE self, VALUE key) {
+    const int k = NUM2INT(key);
+    const double value = getIntFloatMap(self)->bracket(k);
+    VALUE result = DBL2NUM(value);
+    return result;
+}
+
+static VALUE wrap_int_float_map_bracket_equal(VALUE self, VALUE key, VALUE value) {
+    const int k = NUM2INT(key);
+    const double v = NUM2DBL(value);
+    getIntFloatMap(self)->bracket_equal(k, v);
+    return value;
+}
+
+#endif

data/ext/tatara/map/integer/int_int_map.hpp

@@ -0,0 +1,66 @@
+#ifndef INT_INT_MAP_HPP_
+#define INT_INT_MAP_HPP_
+
+#include <ruby.h>
+#include <unordered_map>
+
+class IntIntMap {
+    std::unordered_map<int, int> container;
+
+    public:
+        IntIntMap();
+        ~IntIntMap();
+        int bracket(const int key);
+        int bracket_equal(const int key, const int value);
+};
+
+IntIntMap::IntIntMap() {}
+
+IntIntMap::~IntIntMap() {}
+
+int IntIntMap::bracket(const int key) {
+    return this->container[key];
+}
+
+int IntIntMap::bracket_equal(const int key, const int value) {
+    return this->container[key] = value;
+}
+
+static IntIntMap *getIntIntMap(VALUE self) {
+    IntIntMap *ptr;
+    Data_Get_Struct(self, IntIntMap, ptr);
+    return ptr;
+}
+
+static void wrap_int_int_map_free(IntIntMap *ptr) {
+    ptr->~IntIntMap();
+    ruby_xfree(ptr);
+}
+
+static VALUE wrap_int_int_map_alloc(VALUE klass) {
+    void *p = ruby_xmalloc(sizeof(IntIntMap));
+    p = new IntIntMap;
+    return Data_Wrap_Struct(klass, NULL, wrap_int_int_map_free, p);
+}
+
+static VALUE wrap_int_int_map_init(VALUE self) {
+    IntIntMap *p = getIntIntMap(self);
+    p = new IntIntMap;
+    return Qnil;
+}
+
+static VALUE wrap_int_int_map_bracket(VALUE self, VALUE key) {
+    const int k = NUM2INT(key);
+    const int value = getIntIntMap(self)->bracket(k);
+    VALUE result = INT2NUM(value);
+    return result;
+}
+
+static VALUE wrap_int_int_map_bracket_equal(VALUE self, VALUE key, VALUE value) {
+    const int k = NUM2INT(key);
+    const int v = NUM2INT(value);
+    getIntIntMap(self)->bracket_equal(k, v);
+    return value;
+}
+
+#endif

data/ext/tatara/map/integer/int_string_map.hpp

@@ -0,0 +1,67 @@
+#ifndef INT_STRING_MAP_HPP_
+#define INT_STRING_MAP_HPP_
+
+#include <ruby.h>
+#include <unordered_map>
+#include <string>
+
+class IntStringMap {
+    std::unordered_map<int, std::string> container;
+
+    public:
+        IntStringMap();
+        ~IntStringMap();
+        std::string bracket(const int key);
+        std::string bracket_equal(const int key, const std::string value);
+};
+
+IntStringMap::IntStringMap() {}
+
+IntStringMap::~IntStringMap() {}
+
+std::string IntStringMap::bracket(const int key) {
+    return this->container[key];
+}
+
+std::string IntStringMap::bracket_equal(const int key, const std::string value) {
+    return this->container[key] = value;
+}
+
+static IntStringMap *getIntStringMap(VALUE self) {
+    IntStringMap *ptr;
+    Data_Get_Struct(self, IntStringMap, ptr);
+    return ptr;
+}
+
+static void wrap_int_string_map_free(IntStringMap *ptr) {
+    ptr->~IntStringMap();
+    ruby_xfree(ptr);
+}
+
+static VALUE wrap_int_string_map_alloc(VALUE klass) {
+    void *p = ruby_xmalloc(sizeof(IntStringMap));
+    p = new IntStringMap;
+    return Data_Wrap_Struct(klass, NULL, wrap_int_string_map_free, p);
+}
+
+static VALUE wrap_int_string_map_init(VALUE self) {
+    IntStringMap *p = getIntStringMap(self);
+    p = new IntStringMap;
+    return Qnil;
+}
+
+static VALUE wrap_int_string_map_bracket(VALUE self, VALUE key) {
+    const int k = NUM2INT(key);
+    const std::string value = getIntStringMap(self)->bracket(k);
+    VALUE result = rb_str_new(value.c_str(), value.size());
+    return result;
+}
+
+static VALUE wrap_int_string_map_bracket_equal(VALUE self, VALUE key, VALUE value) {
+    const int k = NUM2INT(key);
+    const std::string v = {StringValueCStr(value)};
+    getIntStringMap(self)->bracket_equal(k, v);
+    return value;
+}
+
+#endif

data/ext/tatara/map/map.hpp

@@ -1,32 +1,19 @@
-#ifndef MAP_H_
-#define MAP_H_
+#ifndef TATARA_MAP_HPP_
+#define TATARA_MAP_HPP_
 
-#include <unordered_map>
+// include String Key Map
+#include "string/string_int_map.hpp"
+#include "string/string_float_map.hpp"
+#include "string/string_string_map.hpp"
 
-template <class K, class V>
-class Map {
-        std::unordered_map<K, V> container;
-    public:
-        constexpr Map();
-        ~Map();
-        constexpr V bracket(const K key);
-        constexpr V bracket_equal(const K key, const V value);
-};
+// include Int Key Map
+#include "integer/int_int_map.hpp"
+#include "integer/int_float_map.hpp"
+#include "integer/int_string_map.hpp"
 
-template <class K, class V>
-constexpr Map<K, V>::Map() {}
-
-template <class K, class V>
-Map<K, V>::~Map() {}
-
-template <class K, class V>
-constexpr V Map<K, V>::bracket(const K key) {
-    return this->container[key];
-}
-
-template <class K, class V>
-constexpr V Map<K, V>::bracket_equal(const K key, const V value) {
-    return this->container[key] = value;
-}
+// include Float Key Map
+#include "float/float_int_map.hpp"
+#include "float/float_float_map.hpp"
+#include "float/float_string_map.hpp"
 
 #endif