tatara 0.2.0 → 0.3.0

data/ext/tatara/vector/float/float_vector.hpp

@@ -0,0 +1,132 @@
+#ifndef FLOAT_VECTOR_HPP_
+#define FLOAT_VECTOR_HPP_
+
+#include <ruby.h>
+#include <vector>
+
+class FloatVector {
+    std::vector<double> container;
+
+    public:
+        FloatVector();
+        ~FloatVector();
+        double first();
+        double last();
+        double bracket(const int index);
+        double bracket_equal(const int index, const double var);
+        void emplace_back(const double var);
+        int size();
+        void clear();
+        FloatVector& push_back_object(const double var);
+ };
+
+FloatVector::FloatVector() {}
+
+FloatVector::~FloatVector() {}
+
+double FloatVector::first() {
+    return this->container.front();
+}
+
+double FloatVector::last() {
+    return this->container.back();
+}
+
+double FloatVector::bracket(const int index) {
+    return this->container[index];
+}
+
+double FloatVector::bracket_equal(const int index, const double var) {
+    return this->container[index] = var;
+}
+
+void FloatVector::emplace_back(const double var) {
+    this->container.emplace_back(var);
+}
+
+int FloatVector::size() {
+    return this->container.size();
+}
+
+void FloatVector::clear() {
+    this->container.clear();
+}
+
+FloatVector &FloatVector::push_back_object(const double var) {
+    this->container.emplace_back(std::move(var));
+    return *this;
+}
+
+static FloatVector *getFloatVector(VALUE self) {
+    FloatVector *ptr;
+    Data_Get_Struct(self, FloatVector, ptr);
+    return ptr;
+}
+
+static void wrap_float_vector_free(FloatVector *ptr) {
+    ptr->~FloatVector();
+    ruby_xfree(ptr);
+}
+
+static VALUE wrap_float_vector_alloc(VALUE klass) {
+    void *p = ruby_xmalloc(sizeof(FloatVector));
+    p = new FloatVector;
+    return Data_Wrap_Struct(klass, NULL, wrap_float_vector_free, p);
+}
+
+static VALUE wrap_float_vector_init(VALUE self) {
+    FloatVector *p = getFloatVector(self);
+    p = new FloatVector;
+    return Qnil;
+}
+
+static VALUE wrap_float_vector_first(VALUE self) {
+    const double value = getFloatVector(self)->first();
+    VALUE result = DBL2NUM(value);
+    return result;
+}
+
+static VALUE wrap_float_vector_last(VALUE self) {
+    const double value = getFloatVector(self)->last();
+    VALUE result = DBL2NUM(value);
+    return result;
+}
+
+static VALUE wrap_float_vector_bracket(VALUE self, VALUE index) {
+    const int i = NUM2INT(index);
+    const double value = getFloatVector(self)->bracket(i);
+    VALUE result = DBL2NUM(value);
+    return result;
+}
+
+static VALUE wrap_float_vector_bracket_equal(VALUE self, VALUE index, VALUE value) {
+    const int i = NUM2INT(index);
+    const double v = NUM2DBL(value);
+    getFloatVector(self)->bracket_equal(i, v);
+    return value;
+}
+
+static VALUE wrap_float_vector_emplace_back(VALUE self, VALUE value) {
+    const double v = NUM2DBL(value);
+    getFloatVector(self)->emplace_back(v);
+    return Qnil;
+}
+
+static VALUE wrap_float_vector_size(VALUE self) {
+    const int size = getFloatVector(self)->size();
+    VALUE result = INT2NUM(size);
+    return result;
+}
+
+static VALUE wrap_float_vector_clear(VALUE self) {
+    getFloatVector(self)->clear();
+    return Qnil;
+}
+
+static VALUE wrap_float_vector_push_back_object(VALUE self, VALUE value) {
+    const double v = NUM2DBL(value);
+    getFloatVector(self)->push_back_object(v);
+    return self;
+}
+
+#endif

data/ext/tatara/vector/integer/int_vector.hpp

@@ -0,0 +1,132 @@
+#ifndef INT_VECTOR_HPP_
+#define INT_VECTOR_HPP_
+
+#include <ruby.h>
+#include <vector>
+
+class IntVector {
+    std::vector<int> container;
+
+    public:
+        IntVector();
+        ~IntVector();
+        int first();
+        int last();
+        int bracket(const int index);
+        int bracket_equal(const int index, const int var);
+        void emplace_back(const int var);
+        int size();
+        void clear();
+        IntVector& push_back_object(const int var);
+ };
+
+IntVector::IntVector() {}
+
+IntVector::~IntVector() {}
+
+int IntVector::first() {
+    return this->container.front();
+}
+
+int IntVector::last() {
+    return this->container.back();
+}
+
+int IntVector::bracket(const int index) {
+    return this->container[index];
+}
+
+int IntVector::bracket_equal(const int index, const int var) {
+    return this->container[index] = var;
+}
+
+void IntVector::emplace_back(const int var) {
+    this->container.emplace_back(var);
+}
+
+int IntVector::size() {
+    return this->container.size();
+}
+
+void IntVector::clear() {
+    this->container.clear();
+}
+
+IntVector &IntVector::push_back_object(const int var) {
+    this->container.emplace_back(std::move(var));
+    return *this;
+}
+
+static IntVector *getIntVector(VALUE self) {
+    IntVector *ptr;
+    Data_Get_Struct(self, IntVector, ptr);
+    return ptr;
+}
+
+static void wrap_int_vector_free(IntVector *ptr) {
+    ptr->~IntVector();
+    ruby_xfree(ptr);
+}
+
+static VALUE wrap_int_vector_alloc(VALUE klass) {
+    void *p = ruby_xmalloc(sizeof(IntVector));
+    p = new IntVector;
+    return Data_Wrap_Struct(klass, NULL, wrap_int_vector_free, p);
+}
+
+static VALUE wrap_int_vector_init(VALUE self) {
+    IntVector *p = getIntVector(self);
+    p = new IntVector;
+    return Qnil;
+}
+
+static VALUE wrap_int_vector_first(VALUE self) {
+    const int value = getIntVector(self)->first();
+    VALUE result = INT2NUM(value);
+    return result;
+}
+
+static VALUE wrap_int_vector_last(VALUE self) {
+    const int value = getIntVector(self)->last();
+    VALUE result = INT2NUM(value);
+    return result;
+}
+
+static VALUE wrap_int_vector_bracket(VALUE self, VALUE index) {
+    const int i = NUM2INT(index);
+    const int value = getIntVector(self)->bracket(i);
+    VALUE result = INT2NUM(value);
+    return result;
+}
+
+static VALUE wrap_int_vector_bracket_equal(VALUE self, VALUE index, VALUE value) {
+    const int i = NUM2INT(index);
+    const int v = NUM2INT(value);
+    getIntVector(self)->bracket_equal(i, v);
+    return value;
+}
+
+static VALUE wrap_int_vector_emplace_back(VALUE self, VALUE value) {
+    const int v = NUM2INT(value);
+    getIntVector(self)->emplace_back(v);
+    return Qnil;
+}
+
+static VALUE wrap_int_vector_size(VALUE self) {
+    const int size = getIntVector(self)->size();
+    VALUE result = INT2NUM(size);
+    return result;
+}
+
+static VALUE wrap_int_vector_clear(VALUE self) {
+    getIntVector(self)->clear();
+    return Qnil;
+}
+
+static VALUE wrap_int_vector_push_back_object(VALUE self, VALUE value) {
+    const int v = NUM2INT(value);
+    getIntVector(self)->push_back_object(v);
+    return self;
+}
+
+#endif

data/ext/tatara/vector/string/string_vector.hpp

@@ -0,0 +1,133 @@
+#ifndef STRING_VECTOR_HPP_
+#define STRING_VECTOR_HPP_
+
+#include <ruby.h>
+#include <vector>
+#include <string>
+
+class StringVector {
+    std::vector<std::string> container;
+
+    public:
+        StringVector();
+        ~StringVector();
+        std::string first();
+        std::string last();
+        std::string bracket(const int index);
+        std::string bracket_equal(const int index, const std::string var);
+        void emplace_back(const std::string var);
+        int size();
+        void clear();
+        StringVector& push_back_object(const std::string var);
+ };
+
+StringVector::StringVector() {}
+
+StringVector::~StringVector() {}
+
+std::string StringVector::first() {
+    return this->container.front();
+}
+
+std::string StringVector::last() {
+    return this->container.back();
+}
+
+std::string StringVector::bracket(const int index) {
+    return this->container[index];
+}
+
+std::string StringVector::bracket_equal(const int index, const std::string var) {
+    return this->container[index] = var;
+}
+
+void StringVector::emplace_back(const std::string var) {
+    this->container.emplace_back(var);
+}
+
+int StringVector::size() {
+    return this->container.size();
+}
+
+void StringVector::clear() {
+    this->container.clear();
+}
+
+StringVector &StringVector::push_back_object(const std::string var) {
+    this->container.emplace_back(std::move(var));
+    return *this;
+}
+
+static StringVector *getStringVector(VALUE self) {
+    StringVector *ptr;
+    Data_Get_Struct(self, StringVector, ptr);
+    return ptr;
+}
+
+static void wrap_string_vector_free(StringVector *ptr) {
+    ptr->~StringVector();
+    ruby_xfree(ptr);
+}
+
+static VALUE wrap_string_vector_alloc(VALUE klass) {
+    void *p = ruby_xmalloc(sizeof(StringVector));
+    p = new StringVector;
+    return Data_Wrap_Struct(klass, NULL, wrap_string_vector_free, p);
+}
+
+static VALUE wrap_string_vector_init(VALUE self) {
+    StringVector *p = getStringVector(self);
+    p = new StringVector;
+    return Qnil;
+}
+
+static VALUE wrap_string_vector_first(VALUE self) {
+    const std::string value = getStringVector(self)->first();
+    VALUE result = rb_str_new(value.data(), value.size());
+    return result;
+}
+
+static VALUE wrap_string_vector_last(VALUE self) {
+    const std::string value = getStringVector(self)->last();
+    VALUE result = rb_str_new(value.data(), value.size());
+    return result;
+}
+
+static VALUE wrap_string_vector_bracket(VALUE self, VALUE index) {
+    const int i = NUM2INT(index);
+    const std::string value = getStringVector(self)->bracket(i);
+    VALUE result = rb_str_new(value.data(), value.size());
+    return result;
+}
+
+static VALUE wrap_string_vector_bracket_equal(VALUE self, VALUE index, VALUE value) {
+    const int i = NUM2INT(index);
+    const std::string v = {StringValueCStr(value)};
+    getStringVector(self)->bracket_equal(i, v);
+    return value;
+}
+
+static VALUE wrap_string_vector_emplace_back(VALUE self, VALUE value) {
+    const std::string v = {StringValueCStr(value)};
+    getStringVector(self)->emplace_back(v);
+    return Qnil;
+}
+
+static VALUE wrap_string_vector_size(VALUE self) {
+    const int size = getStringVector(self)->size();
+    VALUE result = INT2NUM(size);
+    return result;
+}
+
+static VALUE wrap_string_vector_clear(VALUE self) {
+    getStringVector(self)->clear();
+    return Qnil;
+}
+
+static VALUE wrap_string_vector_push_back_object(VALUE self, VALUE value) {
+    const std::string v = {StringValueCStr(value)};
+    getStringVector(self)->push_back_object(v);
+    return self;
+}
+
+#endif

data/ext/tatara/vector/vector.hpp

@@ -1,6 +1,10 @@
 #ifndef VEC_TEMPLATE_H_
 #define VEC_TEMPLATE_H_
 
+#include "integer/int_vector.hpp"
+#include "float/float_vector.hpp"
+#include "string/string_vector.hpp"
+
 #include <algorithm>
 #include <iterator>
 #include <vector>

data/lib/tatara/array/array.rb

@@ -18,9 +18,82 @@ module Tatara
             (0...(self.size)).each{|i| block.call(self[i], i)}
         end
 
+        def intersection(other)
+            copy = self.dup
+            result = self.to_array & other.to_array
+            copy.clear
+            result.map(&copy.method(:<<))
+            return copy
+        end
+
         def &(other)
             self.intersection other
         end
+
+        def sort
+            copy = self.dup
+            result = self.to_array.sort
+            copy.clear
+            result.each{|v| copy << v}
+            return copy
+        end
+
+        def sort!
+            result = self.to_array.sort
+            self.clear
+            result.each{|v| self << v}
+            return self
+        end
+
+        def uniq
+            copy = self.dup
+            result = self.to_array.uniq
+            copy.clear
+            result.map(&copy.method(:<<))
+            return copy
+        end
+
+        def uniq!
+            result = self.to_array.uniq
+            self.clear
+            result.each{|v| self << v}
+            return self
+        end
+
+        def reverse
+            copy = self.dup
+            result = self.to_array.reverse
+            result.each{|v| copy << v }
+            return copy
+        end
+
+        def reverse!
+            result = self.to_array.reverse
+            self.clear
+            result.each{|v| self << v }
+            return self
+        end
+
+        def slice(start, length)
+            copy = self.dup
+            result = self.to_array.slice(start, length)
+            copy.clear
+            result.each{|v| copy << v }
+            return copy
+        end
+
+        def slice!(start, length)
+            result = self.to_array.slice(start, length)
+            self.clear
+            result.each{|v| self << v }
+            return self
+        end
+
+        def to_array
+            result = []
+            self.map{|v| result << v}
+            result
+        end
     end
 
     class IntArray