tatara 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1268bb136f3184f85b96809e40e4ab571f563bf3fd4642d9addfb80c00ea9302
+  data.tar.gz: 3ad328e25cefdefbd10cd38cc9b93d98a5da91e402317a77dccb56f9c50d3fb9
+SHA512:
+  metadata.gz: 9f01b88a1ba64c2863f3b927de8ee056c3f33bcdbf2d6a74e77e5ffd7ce16dce7592c109bd7a1b71636f76d62f973ba391b044bc3f8add79ee8984626d181986
+  data.tar.gz: 8f289f3ac4b1d940e71020683f596470e71a07568de3611033caa017a75ffa54c6f744c83f97aab391cedc3940791a55f9a474df908239943567120ec7d1eeb1

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/lib/tatara/tatara.so

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.6.3
+before_install: gem install bundler -v 2.0.1

data/Gemfile

@@ -0,0 +1,10 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in tatara.gemspec
+gemspec
+
+gem "rice"
+gem "rake-compiler"
+
+# Using Benchmark Driver
+gem "benchmark_driver"

data/Gemfile.lock

@@ -0,0 +1,29 @@
+PATH
+  remote: .
+  specs:
+    tatara (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    benchmark_driver (0.15.5)
+    minitest (5.11.3)
+    rake (10.5.0)
+    rake-compiler (1.0.7)
+      rake
+    rice (2.1.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  benchmark_driver
+  bundler (~> 2.0)
+  minitest (~> 5.0)
+  rake (~> 10.0)
+  rake-compiler
+  rice
+  tatara!
+
+BUNDLED WITH
+   2.0.1

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 S.H.
+
+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.

data/Makefile

@@ -0,0 +1,328 @@
+
+SHELL = /bin/sh
+
+# V=0 quiet, V=1 verbose.  other values don't work.
+V = 0
+Q1 = $(V:1=)
+Q = $(Q1:0=@)
+ECHO1 = $(V:1=@ :)
+ECHO = $(ECHO1:0=@ echo)
+NULLCMD = :
+
+#### Start of system configuration section. ####
+
+srcdir = ext/tatara
+topdir = /home/sh/.rbenv/versions/2.6.3/include/ruby-2.6.0
+hdrdir = $(topdir)
+arch_hdrdir = /home/sh/.rbenv/versions/2.6.3/include/ruby-2.6.0/x86_64-linux
+PATH_SEPARATOR = :
+VPATH = $(srcdir):$(arch_hdrdir)/ruby:$(hdrdir)/ruby
+
+prefix = $(DESTDIR)/home/sh/.rbenv/versions/2.6.3
+
+rubysitearchprefix = $(rubylibprefix)/$(sitearch)
+
+rubyarchprefix = $(rubylibprefix)/$(arch)
+
+rubylibprefix = $(libdir)/$(RUBY_BASE_NAME)
+
+exec_prefix = $(prefix)
+
+vendorarchhdrdir = $(vendorhdrdir)/$(sitearch)
+
+sitearchhdrdir = $(sitehdrdir)/$(sitearch)
+
+rubyarchhdrdir = $(rubyhdrdir)/$(arch)
+
+vendorhdrdir = $(rubyhdrdir)/vendor_ruby
+
+sitehdrdir = $(rubyhdrdir)/site_ruby
+
+rubyhdrdir = $(includedir)/$(RUBY_VERSION_NAME)
+
+vendorarchdir = $(vendorlibdir)/$(sitearch)
+
+vendorlibdir = $(vendordir)/$(ruby_version)
+
+vendordir = $(rubylibprefix)/vendor_ruby
+
+sitearchdir = $(sitelibdir)/$(sitearch)
+
+sitelibdir = $(sitedir)/$(ruby_version)
+
+sitedir = $(rubylibprefix)/site_ruby
+
+rubyarchdir = $(rubylibdir)/$(arch)
+
+rubylibdir = $(rubylibprefix)/$(ruby_version)
+
+sitearchincludedir = $(includedir)/$(sitearch)
+
+archincludedir = $(includedir)/$(arch)
+
+sitearchlibdir = $(libdir)/$(sitearch)
+
+archlibdir = $(libdir)/$(arch)
+
+ridir = $(datarootdir)/$(RI_BASE_NAME)
+
+mandir = $(datarootdir)/man
+
+localedir = $(datarootdir)/locale
+
+libdir = $(exec_prefix)/lib
+
+psdir = $(docdir)
+
+pdfdir = $(docdir)
+
+dvidir = $(docdir)
+
+htmldir = $(docdir)
+
+infodir = $(datarootdir)/info
+
+docdir = $(datarootdir)/doc/$(PACKAGE)
+
+oldincludedir = $(DESTDIR)/usr/include
+
+includedir = $(prefix)/include
+
+localstatedir = $(prefix)/var
+
+sharedstatedir = $(prefix)/com
+
+sysconfdir = $(prefix)/etc
+
+datadir = $(datarootdir)
+
+datarootdir = $(prefix)/share
+
+libexecdir = $(exec_prefix)/libexec
+
+sbindir = $(exec_prefix)/sbin
+
+bindir = $(exec_prefix)/bin
+
+archdir = $(rubyarchdir)
+
+
+
+CC_WRAPPER = 
+CC = gcc
+CXX = g++
+LIBRUBY = $(LIBRUBY_SO)
+LIBRUBY_A = lib$(RUBY_SO_NAME)-static.a
+LIBRUBYARG_SHARED = -Wl,-rpath,$(libdir) -L$(libdir) -l$(RUBY_SO_NAME)
+LIBRUBYARG_STATIC = -Wl,-rpath,/home/sh/.rbenv/versions/2.6.3/lib -L/home/sh/.rbenv/versions/2.6.3/lib -lruby-static -lz -lpthread -lrt -lrt -ldl -lcrypt -lm 
+empty =
+OUTFLAG = -o $(empty)
+COUTFLAG = -o $(empty)
+CSRCFLAG = $(empty)
+
+RUBY_EXTCONF_H = 
+cflags   = $(optflags) $(debugflags) $(warnflags)
+cxxflags = $(optflags) $(debugflags) $(warnflags)
+optflags = -O3
+debugflags = -ggdb3
+warnflags = -Wall -Wextra -Wdeclaration-after-statement -Wdeprecated-declarations -Wduplicated-cond -Wimplicit-function-declaration -Wimplicit-int -Wmisleading-indentation -Wpointer-arith -Wrestrict -Wwrite-strings -Wimplicit-fallthrough=0 -Wmissing-noreturn -Wno-cast-function-type -Wno-constant-logical-operand -Wno-long-long -Wno-missing-field-initializers -Wno-overlength-strings -Wno-packed-bitfield-compat -Wno-parentheses-equality -Wno-self-assign -Wno-tautological-compare -Wno-unused-parameter -Wno-unused-value -Wsuggest-attribute=format -Wsuggest-attribute=noreturn -Wunused-variable
+cppflags = 
+CCDLFLAGS = -fPIC
+CFLAGS   = $(CCDLFLAGS) $(cflags)  -fPIC $(ARCH_FLAG)
+INCFLAGS = -I. -I$(arch_hdrdir) -I$(hdrdir)/ruby/backward -I$(hdrdir) -I$(srcdir)
+DEFS     = 
+CPPFLAGS =  -I/home/sh/.rbenv/versions/2.6.3/include  $(DEFS) $(cppflags)  -I/home/sh/.rbenv/versions/2.6.3/lib/ruby/gems/2.6.0/gems/rice-2.1.3/ruby/lib/include
+CXXFLAGS = $(CFLAGS)  -Wall -g
+ldflags  = -L. -L/home/sh/.rbenv/versions/2.6.3/lib  -fstack-protector-strong -rdynamic -Wl,-export-dynamic  -L/home/sh/.rbenv/versions/2.6.3/lib/ruby/gems/2.6.0/gems/rice-2.1.3/ruby/lib/lib -lrice
+dldflags = -L/home/sh/.rbenv/versions/2.6.3/lib  -Wl,--compress-debug-sections=zlib 
+ARCH_FLAG = 
+DLDFLAGS = $(ldflags) $(dldflags) $(ARCH_FLAG)
+LDSHARED = g++ -shared
+LDSHAREDXX = $(CXX) -shared
+AR = ar
+EXEEXT = 
+
+
+RUBY_INSTALL_NAME = $(RUBY_BASE_NAME)
+
+RUBY_SO_NAME = ruby
+
+RUBYW_INSTALL_NAME = 
+
+RUBY_VERSION_NAME = $(RUBY_BASE_NAME)-$(ruby_version)
+
+RUBYW_BASE_NAME = rubyw
+
+RUBY_BASE_NAME = ruby
+
+
+arch = x86_64-linux
+sitearch = $(arch)
+ruby_version = 2.6.0
+ruby = $(bindir)/$(RUBY_BASE_NAME)
+RUBY = $(ruby)
+ruby_headers = $(hdrdir)/ruby.h $(hdrdir)/ruby/backward.h $(hdrdir)/ruby/ruby.h $(hdrdir)/ruby/defines.h $(hdrdir)/ruby/missing.h $(hdrdir)/ruby/intern.h $(hdrdir)/ruby/st.h $(hdrdir)/ruby/subst.h $(arch_hdrdir)/ruby/config.h
+
+RM = rm -f
+RM_RF = $(RUBY) -run -e rm -- -rf
+RMDIRS = rmdir --ignore-fail-on-non-empty -p
+MAKEDIRS = /bin/mkdir -p
+INSTALL = /usr/bin/install -c
+INSTALL_PROG = $(INSTALL) -m 0755
+INSTALL_DATA = $(INSTALL) -m 644
+COPY = cp
+TOUCH = exit >
+
+#### End of system configuration section. ####
+
+preload = 
+
+
+CXX = g++
+libpath = . $(libdir)
+LIBPATH =  -L. -L$(libdir) -Wl,-rpath,$(libdir)
+DEFFILE = 
+
+CLEANFILES = mkmf.log
+DISTCLEANFILES = 
+DISTCLEANDIRS = 
+
+extout = 
+extout_prefix = 
+target_prefix = /tatara
+LOCAL_LIBS = 
+LIBS = -Wl,-rpath,/home/sh/.rbenv/versions/2.6.3/lib -L/home/sh/.rbenv/versions/2.6.3/lib -lruby -lm   -lc
+ORIG_SRCS = tatara.cpp
+SRCS = $(ORIG_SRCS) 
+OBJS = tatara.o
+HDRS = 
+LOCAL_HDRS = 
+TARGET = tatara
+TARGET_NAME = tatara
+TARGET_ENTRY = Init_$(TARGET_NAME)
+DLLIB = $(TARGET).so
+EXTSTATIC = 
+STATIC_LIB = 
+
+TIMESTAMP_DIR = .
+
+BINDIR        = $(bindir)
+
+RUBYCOMMONDIR = $(sitedir)$(target_prefix)
+
+RUBYLIBDIR    = $(sitelibdir)$(target_prefix)
+
+RUBYARCHDIR   = $(sitearchdir)$(target_prefix)
+
+HDRDIR        = $(rubyhdrdir)/ruby$(target_prefix)
+
+ARCHHDRDIR    = $(rubyhdrdir)/$(arch)/ruby$(target_prefix)
+
+TARGET_SO_DIR =
+TARGET_SO     = $(TARGET_SO_DIR)$(DLLIB)
+CLEANLIBS     = $(TARGET_SO) 
+CLEANOBJS     = *.o  *.bak
+
+
+all:    $(DLLIB)
+static: $(STATIC_LIB)
+.PHONY: all install static install-so install-rb
+.PHONY: clean clean-so clean-static clean-rb
+
+clean-static::
+clean-rb-default::
+clean-rb::
+clean-so::
+clean: clean-so clean-static clean-rb-default clean-rb
+		-$(Q)$(RM) $(CLEANLIBS) $(CLEANOBJS) $(CLEANFILES) .*.time
+
+distclean-rb-default::
+distclean-rb::
+distclean-so::
+distclean-static::
+distclean: clean distclean-so distclean-static distclean-rb-default distclean-rb
+		-$(Q)$(RM) Makefile $(RUBY_EXTCONF_H) conftest.* mkmf.log
+		-$(Q)$(RM) core ruby$(EXEEXT) *~ $(DISTCLEANFILES)
+		-$(Q)$(RMDIRS) $(DISTCLEANDIRS) 2> /dev/null || true
+
+realclean: distclean
+install: install-so install-rb
+
+install-so: $(DLLIB) $(TIMESTAMP_DIR)/.sitearchdir.-.tatara.time
+	$(INSTALL_PROG) $(DLLIB) $(RUBYARCHDIR)
+clean-static::
+	-$(Q)$(RM) $(STATIC_LIB)
+install-rb: pre-install-rb do-install-rb install-rb-default
+install-rb-default: pre-install-rb-default do-install-rb-default
+pre-install-rb: Makefile
+pre-install-rb-default: Makefile
+do-install-rb:
+do-install-rb-default:
+pre-install-rb-default:
+	@$(NULLCMD)
+$(TIMESTAMP_DIR)/.sitearchdir.-.tatara.time:
+	$(Q) $(MAKEDIRS) $(@D) $(RUBYARCHDIR)
+	$(Q) $(TOUCH) $@
+
+site-install: site-install-so site-install-rb
+site-install-so: install-so
+site-install-rb: install-rb
+
+.SUFFIXES: .c .m .cc .mm .cxx .cpp .o .S
+
+.cc.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $(CSRCFLAG)$<
+
+.cc.S:
+	$(ECHO) translating $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -S $(CSRCFLAG)$<
+
+.mm.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $(CSRCFLAG)$<
+
+.mm.S:
+	$(ECHO) translating $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -S $(CSRCFLAG)$<
+
+.cxx.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $(CSRCFLAG)$<
+
+.cxx.S:
+	$(ECHO) translating $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -S $(CSRCFLAG)$<
+
+.cpp.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $(CSRCFLAG)$<
+
+.cpp.S:
+	$(ECHO) translating $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -S $(CSRCFLAG)$<
+
+.c.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -c $(CSRCFLAG)$<
+
+.c.S:
+	$(ECHO) translating $(<)
+	$(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -S $(CSRCFLAG)$<
+
+.m.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -c $(CSRCFLAG)$<
+
+.m.S:
+	$(ECHO) translating $(<)
+	$(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -S $(CSRCFLAG)$<
+
+$(TARGET_SO): $(OBJS) Makefile
+	$(ECHO) linking shared-object tatara/$(DLLIB)
+	-$(Q)$(RM) $(@)
+	$(Q) $(LDSHAREDXX) -o $@ $(OBJS) $(LIBPATH) $(DLDFLAGS) $(LOCAL_LIBS) $(LIBS)
+
+
+
+$(OBJS): $(HDRS) $(ruby_headers)

data/README.md

@@ -0,0 +1,41 @@
+# Tatara
+
+Add Type to Ruby!
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'tatara'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install tatara
+
+## Usage
+
+```ruby
+@integer = Tatara::Integer.new # => This type is Integer!
+@integer.value = 42
+puts @integer.value # => 42 and type is Integer!
+@integer.value = "42" #=> Error!
+```
+
+`Tatara` supported `Integer`, `Float`, `String`.  
+And, Container for `Vector`, `Array`, `Map`!
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/tatara.

data/Rakefile

@@ -0,0 +1,20 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+require "rake/extensiontask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test
+
+Rake::ExtensionTask.new "tatara" do |ext|
+  ext.lib_dir = "lib/tatara"
+end
+
+desc 'Benchmark Task'
+task :benchmark do
+  system("ruby benchmark/benchmark.rb")
+end

data/benchmark/benchmark.rb

@@ -0,0 +1,14 @@
+require 'benchmark_driver'
+
+Benchmark.driver do |x|
+  x.prelude <<~RUBY
+    require 'tatara/tatara'
+  RUBY
+
+  x.report %{ Tatara::String.new }
+  x.report %{ Tatara::Integer.new }
+  x.report %{ Tatara::Float.new }
+  x.report %{ Tatara::StringVector.new }
+  x.report %{ Tatara::IntVector.new }
+  x.report %{ Tatara::FloatVector.new }
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "tatara"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/ext/tatara/array/array.hpp

@@ -0,0 +1,62 @@
+#ifndef ARRAY__TEMPLATE_H_
+#define ARRAY__TEMPLATE_H_
+
+#include <vector>
+
+template <class T>
+class CppArray {
+        std::vector<T> container;
+    public:
+        constexpr CppArray();
+        ~CppArray();
+        constexpr T first();
+        constexpr T last();
+        constexpr T bracket(const int index);
+        constexpr T bracket_equal(const int index, const T var);
+        constexpr void emplace_back(const T var);
+        constexpr int size();
+        constexpr void clear();
+};
+
+template <class T>
+constexpr CppArray<T>::CppArray() {}
+
+template <class T>
+CppArray<T>::~CppArray() {}
+
+template <class T>
+constexpr T CppArray<T>::first() {
+    return this->container.front();
+}
+
+template <class T>
+constexpr T CppArray<T>::last(){
+    return this->container.back();
+}
+
+template <class T>
+constexpr T CppArray<T>::bracket(const int index) {
+    return this->container[index];
+}
+
+template <class T>
+constexpr T CppArray<T>::bracket_equal(const int index, const T var) {
+    return this->container[index] = var;
+}
+
+template <class T>
+constexpr void CppArray<T>::emplace_back(const T var) {
+    this->container.emplace_back(var);
+}
+
+template <class T>
+constexpr int CppArray<T>::size() {
+    return this->container.size();
+}
+
+template <class T>
+constexpr void CppArray<T>::clear() {
+    this->container.clear();
+}
+
+#endif

data/ext/tatara/extconf.rb

@@ -0,0 +1,6 @@
+
+require "mkmf-rice"
+
+$CXXFLAGS = '-Ofast -mtune=native -march=native -mfpmath=both -std=c++17'
+
+create_makefile("tatara/tatara") 

data/ext/tatara/float/float.hpp

@@ -0,0 +1,68 @@
+#ifndef FLOAT_H_
+#define FLOAT_H_
+
+#include <string>
+#include <regex>
+
+class Float {
+        double value = 0.0;
+    public:
+        constexpr Float();
+        ~Float();
+        constexpr double assignment(const double var);
+        constexpr double return_value();
+        constexpr double increment_value();
+        constexpr double decrement_value();
+        std::string to_string();
+        constexpr int to_integer();
+        constexpr double plus_equal(const double var);
+        constexpr double clear();
+        constexpr bool equal(const double var);
+};
+
+constexpr Float::Float() {}
+
+Float::~Float() {}
+
+constexpr double Float::assignment(const double var) {
+    return this->value = var;
+}
+
+constexpr double Float::return_value() {
+    return this->value;
+}
+
+constexpr double Float::increment_value() {
+    return this->value++;
+}
+
+constexpr double Float::decrement_value() {
+    return this->value--;
+}
+
+std::string Float::to_string() {
+
+    std::string null = "";
+
+    std::regex re("0+");
+
+    return std::regex_replace(std::to_string(this->value), re, null);
+}
+
+constexpr int Float::to_integer() {
+    return static_cast<int>(this->value);
+}
+
+constexpr double Float::plus_equal(const double var) {
+    return this->value += var;
+}
+
+constexpr double Float::clear() {
+    return this->value = 0.0;
+}
+
+constexpr bool Float::equal(const double var) {
+    return this->value == var;
+}
+
+#endif

data/ext/tatara/integer/integer.hpp

@@ -0,0 +1,58 @@
+#ifndef INTEGER_H_
+#define INTEGER_H_
+
+#include <string>
+
+class Integer {
+    int value = 0;
+
+    public:
+        constexpr Integer();
+        ~Integer();
+        constexpr int assignment(const int var);
+        constexpr int return_value();
+        constexpr int increment_value();
+        constexpr int decrement_value();
+        std::string to_string();
+        constexpr int plus_equal(int var);
+        constexpr int clear();
+        constexpr bool equal(const int var);
+};
+
+constexpr Integer::Integer() {}
+
+Integer::~Integer(){}
+
+constexpr int Integer::assignment(const int var) {
+    return this->value = var;
+}
+
+constexpr int Integer::return_value() {
+    return this->value;
+}
+
+constexpr int Integer::increment_value() {
+    return this->value++;
+}
+
+constexpr int Integer::decrement_value() {
+    return this->value--;
+}
+
+std::string Integer::to_string() {
+    return std::to_string(this->value);
+}
+
+constexpr int Integer::plus_equal(int var) {
+    return this->value += var;
+}
+
+constexpr int Integer::clear() {
+    return this->value = 0;
+}
+
+constexpr bool Integer::equal(const int var) {
+    return this->value == var;
+}
+
+#endif

data/ext/tatara/map/map.hpp

@@ -0,0 +1,32 @@
+#ifndef MAP_H_
+#define MAP_H_
+
+#include <unordered_map>
+
+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);
+};
+
+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;
+}
+
+#endif

data/ext/tatara/string/string.hpp

@@ -0,0 +1,47 @@
+#ifndef STRING_H_
+#define STRING_H_
+
+#include <string>
+
+class CppString {
+        std::string value = "";
+    public:
+        CppString();
+        ~CppString();
+        std::string assignment(const std::string var);
+        std::string return_value();
+        int to_integer();
+        std::string plus_equal(const std::string var);
+        std::string clear();
+        bool equal(const std::string var);
+};
+
+CppString::CppString() {}
+
+CppString::~CppString() {}
+
+std::string CppString::assignment(const std::string var) {
+    return this->value = var;
+}
+
+std::string CppString::return_value() {
+    return this->value;
+}
+
+int CppString::to_integer() {
+    return std::stoi(this->value);
+}
+
+std::string CppString::plus_equal(const std::string var) {
+    return this->value += var;
+}
+
+std::string CppString::clear() {
+    return this->value = "";
+}
+
+bool CppString::equal(const std::string var) {
+    return this->value == var;
+}
+
+#endif

data/ext/tatara/tatara.cpp

@@ -0,0 +1,127 @@
+#include <string>
+#include <rice/Data_Type.hpp>
+#include <rice/Constructor.hpp>
+#include "vector/vector.hpp"
+#include "array/array.hpp"
+#include "map/map.hpp"
+#include "integer/integer.hpp"
+#include "float/float.hpp"
+#include "string/string.hpp"
+
+using namespace Rice;
+
+extern "C" {
+    void Init_tatara() {
+        Rice::Module rb_mTatara = define_module("Tatara");
+
+        Data_Type<Integer> rbcInteger = define_class_under<Integer>(rb_mTatara, "Integer")
+            .define_constructor(Constructor<Integer>())
+            .define_method("value", &Integer::return_value)
+            .define_method("value=", &Integer::assignment)
+            .define_method("value+=", &Integer::plus_equal)
+            .define_method("inc", &Integer::increment_value)
+            .define_method("dec", &Integer::decrement_value)
+            .define_method("to_s", &Integer::to_string)
+            .define_method("clear", &Integer::clear)
+            .define_method("value==", &Integer::equal);
+
+        Data_Type<Float> rbcFloat = define_class_under<Float>(rb_mTatara, "Float")
+            .define_constructor(Constructor<Float>())
+            .define_method("value", &Float::return_value)
+            .define_method("value=", &Float::assignment)
+            .define_method("value+=", &Float::plus_equal)
+            .define_method("inc", &Float::increment_value)
+            .define_method("dec", &Float::decrement_value)
+            .define_method("to_s", &Float::to_string)
+            .define_method("to_i", &Float::to_integer)
+            .define_method("clear", &Float::clear)
+            .define_method("value==", &Float::equal);
+
+        Data_Type<CppString> rbcString = define_class_under<CppString>(rb_mTatara, "String")
+            .define_constructor(Constructor<CppString>())
+            .define_method("value", &CppString::return_value)
+            .define_method("value=", &CppString::assignment)
+            .define_method("value+=", &CppString::plus_equal)
+            .define_method("to_i", &CppString::to_integer)
+            .define_method("clear", &CppString::clear)
+            .define_method("value==", &CppString::equal);
+
+        Data_Type<Vector<int>> rb_cIntVector = define_class_under<Vector<int>>(rb_mTatara, "IntVector")
+            .define_constructor(Constructor<Vector<int>>())
+            .define_method("first", &Vector<int>::first)
+            .define_method("last", &Vector<int>::last)
+            .define_method("[]", &Vector<int>::bracket)
+            .define_method("[]=", &Vector<int>::bracket_equal)
+            .define_method("emplace_back", &Vector<int>::emplace_back)
+            .define_method("size", &Vector<int>::size)
+            .define_method("clear", &Vector<int>::clear)
+            .define_method("sum", &Vector<int>::sum);
+
+        Data_Type<Vector<double>> rb_cFloatVector = define_class_under<Vector<double>>(rb_mTatara, "FloatVector")
+            .define_constructor(Constructor<Vector<double>>())
+            .define_method("first", &Vector<double>::first)
+            .define_method("last", &Vector<double>::last)
+            .define_method("[]", &Vector<double>::bracket)
+            .define_method("[]=", &Vector<double>::bracket_equal)
+            .define_method("emplace_back", &Vector<double>::emplace_back)
+            .define_method("size", &Vector<double>::size)
+            .define_method("clear", &Vector<double>::clear)
+            .define_method("sum", &Vector<double>::sum);
+
+        Data_Type<Vector<std::string>> rb_cStringVector = define_class_under<Vector<std::string>>(rb_mTatara, "StringVector")
+            .define_constructor(Constructor<Vector<std::string>>())
+            .define_method("first", &Vector<std::string>::first)
+            .define_method("last", &Vector<std::string>::last)
+            .define_method("[]", &Vector<std::string>::bracket)
+            .define_method("[]=", &Vector<std::string>::bracket_equal)
+            .define_method("emplace_back", &    Vector<std::string>::emplace_back)
+            .define_method("size", &Vector<std::string>::size)
+            .define_method("clear", &Vector<std::string>::clear)
+            .define_method("sum", &Vector<std::string>::sum);
+
+        Data_Type<CppArray<int>> rb_cIntArray = define_class_under<CppArray<int>>(rb_mTatara, "IntArray")
+            .define_constructor(Constructor<CppArray<int>>())
+            .define_method("first", &CppArray<int>::first)
+            .define_method("last", &CppArray<int>::last)
+            .define_method("[]", &CppArray<int>::bracket)
+            .define_method("[]=", &CppArray<int>::bracket_equal)
+            .define_method("push", &CppArray<int>::emplace_back)
+            .define_method("size", &CppArray<int>::size)
+            .define_method("clear", &CppArray<int>::clear);
+
+        Data_Type<CppArray<double>> rb_cFloatArray = define_class_under<CppArray<double>>(rb_mTatara, "FloatArray")
+            .define_constructor(Constructor<CppArray<double>>())
+            .define_method("first", &CppArray<double>::first)
+            .define_method("last", &CppArray<double>::last)
+            .define_method("[]", &CppArray<double>::bracket)
+            .define_method("[]=", &CppArray<double>::bracket_equal)
+            .define_method("push", &CppArray<double>::emplace_back)
+            .define_method("size", &CppArray<double>::size)
+            .define_method("clear", &CppArray<double>::clear);
+
+        Data_Type<CppArray<std::string>> rb_cStringArray = define_class_under<CppArray<std::string>>(rb_mTatara, "StringArray")
+            .define_constructor(Constructor<CppArray<std::string>>())
+            .define_method("first", &CppArray<std::string>::first)
+            .define_method("last", &CppArray<std::string>::last)
+            .define_method("[]", &CppArray<std::string>::bracket)
+            .define_method("[]=", &CppArray<std::string>::bracket_equal)            
+            .define_method("push", &CppArray<std::string>::emplace_back)
+            .define_method("size", &CppArray<std::string>::size)
+            .define_method("clear", &CppArray<std::string>::clear);
+
+        Data_Type<Map<std::string, int>> rb_cStringIntMap = define_class_under<Map<std::string, int>>(rb_mTatara, "StringIntMap")
+            .define_constructor(Constructor<Map<std::string, int>>())
+            .define_method("[]", &Map<std::string, int>::bracket)
+            .define_method("[]=", &Map<std::string, int>::bracket_equal);
+
+        Data_Type<Map<std::string, double>> rb_cStringFloatMap = define_class_under<Map<std::string, double>>(rb_mTatara, "StringFloatMap")
+            .define_constructor(Constructor<Map<std::string, double>>())
+            .define_method("[]", &Map<std::string, double>::bracket)
+            .define_method("[]=", &Map<std::string, double>::bracket_equal);
+
+        Data_Type<Map<std::string, std::string>> rb_cStringStringMap = define_class_under<Map<std::string, std::string>>(rb_mTatara, "StringStringMap")
+            .define_constructor(Constructor<Map<std::string, std::string>>())
+            .define_method("[]", &Map<std::string, std::string>::bracket)
+            .define_method("[]=", &Map<std::string, std::string>::bracket_equal);
+    }
+}

data/ext/tatara/vector/vector.hpp

@@ -0,0 +1,74 @@
+#ifndef VEC_TEMPLATE_H_
+#define VEC_TEMPLATE_H_
+
+#include <vector>
+
+template <class T>
+class Vector {
+    std::vector<T> container;
+
+    public:
+        constexpr Vector();
+        ~Vector();
+        constexpr T first();
+        constexpr T last();
+        constexpr T bracket(const int index);
+        constexpr T bracket_equal(const int index, const T var);
+        constexpr void emplace_back(const T var);
+        constexpr int size();
+        constexpr void clear();
+        T sum();
+};
+
+template <class T>
+constexpr Vector<T>::Vector() {}
+
+template <class T>
+Vector<T>::~Vector() {}
+
+template <class T>
+constexpr T Vector<T>::first() {
+    return this->container.front();
+}
+
+template <class T>
+constexpr T Vector<T>::last() {
+    return this->container.back();
+}
+
+template <class T>
+constexpr T Vector<T>::bracket(const int index) {
+    return this->container[index];
+}
+
+template <class T>
+constexpr T Vector<T>::bracket_equal(const int index, const T var) {
+    return this->container[index] = var;
+}
+
+template <class T>
+constexpr void Vector<T>::emplace_back(const T var) {
+    this->container.emplace_back(std::move(var));
+}
+
+template <class T>
+constexpr int Vector<T>::size() {
+    return this->container.size();
+}
+
+template <class T>
+constexpr void Vector<T>::clear() {
+    this->container.clear();
+}
+
+template <class T>
+T Vector<T>::sum() {
+    T sum;
+
+    for (auto&& c : this->container)
+        sum += c;
+
+    return sum;
+}
+
+#endif

data/lib/tatara.rb

@@ -0,0 +1,6 @@
+require "tatara/version"
+
+module Tatara
+  class Error < StandardError; end
+  # Your code goes here...
+end

data/lib/tatara/version.rb

@@ -0,0 +1,3 @@
+module Tatara
+  VERSION = "0.1.0"
+end

data/tatara.gemspec

@@ -0,0 +1,42 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "tatara/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "tatara"
+  spec.version       = Tatara::VERSION
+  spec.authors       = ["S-H-GAMELINKS"]
+  spec.email         = ["gamelinks007@gmail.com"]
+
+  spec.summary       = %q{Simple type declaration lib}
+  spec.description   = %q{Simple type declaration lib}
+  spec.homepage      = "https://github.com/S-H-GAMELINKS/tatara"
+  spec.extensions    = %w[ext/tatara/extconf.rb]
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  #if spec.respond_to?(:metadata)
+  #  spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
+  #
+  #  spec.metadata["homepage_uri"] = spec.homepage
+  #  spec.metadata["source_code_uri"] = "https://github.com/S-H-GAMELINKS/tatara"
+  #  spec.metadata["changelog_uri"] = "https://github.com/S-H-GAMELINKS/tatara"
+  #else
+  #  raise "RubyGems 2.0 or newer is required to protect against " \
+  #    "public gem pushes."
+  #end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+end

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification
+name: tatara
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- S-H-GAMELINKS
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-09-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: Simple type declaration lib
+email:
+- gamelinks007@gmail.com
+executables: []
+extensions:
+- ext/tatara/extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- Makefile
+- README.md
+- Rakefile
+- benchmark/benchmark.rb
+- bin/console
+- bin/setup
+- ext/tatara/array/array.hpp
+- ext/tatara/extconf.rb
+- ext/tatara/float/float.hpp
+- ext/tatara/integer/integer.hpp
+- ext/tatara/map/map.hpp
+- ext/tatara/string/string.hpp
+- ext/tatara/tatara.cpp
+- ext/tatara/vector/vector.hpp
+- lib/tatara.rb
+- lib/tatara/version.rb
+- tatara.gemspec
+homepage: https://github.com/S-H-GAMELINKS/tatara
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.4
+signing_key: 
+specification_version: 4
+summary: Simple type declaration lib
+test_files: []