xot 0.1.3 → 0.1.4

data/.gitignore

@@ -0,0 +1,14 @@
+*.o
+*.so
+*.bundle
+*.dll.a
+*.gem
+*.log
+*.rdoc.cpp
+*~
+lib/*.a
+.doc
+.yardoc
+.DS_Store
+Makefile
+depend.mf

data/Rakefile

@@ -1,37 +1,22 @@
 # -*- mode: ruby; coding: utf-8 -*-
 
 
-%w[.].map {|s| "#{s}/lib"}.each do |path|
-  $: << File.expand_path(File.join File.dirname(__FILE__), *path.split('/'))
-end
-
-require 'rubygems'
-require 'xot/rake/helpers'
+require 'bundler/setup'
+require 'xot/rake'
 require 'xot/module'
 
 include Xot::Rake
 
 
 MODULE = Xot
+DLNAME = 'tester'
 
 
 task :default => :build
 
 task :build => :lib
 
-task :rebuild => [:clean, :build]
-
-task :lib => 'lib:build'
-
-task :doc => 'ext:doc'
-
-task :gem => 'gem:build'
-
-task :install => 'gem:install'
-
-task :uninstall => 'gem:uninstall'
-
-task :clean => ['lib:clean', 'gem:clean']
+empty_task :test
 
 
 Xot.load_tasks

data/VERSION

@@ -1 +1 @@
-0.1.3
+0.1.4

data/ext/xot/extconf.rb

@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*-
+
+
+require 'bundler/setup'
+require 'mkmf'
+require 'xot/rake/helpers'
+require 'xot/module'
+
+include Xot::Rake
+
+
+debug = env :DEBUG, false
+
+
+DEFS    = []
+INCDIRS = %w[
+  /opt/local/include
+  /opt/include
+]
+LIBDIRS = []
+
+HEADERS = %w[
+  boost/noncopyable.hpp
+  ruby.h
+  xot.h
+]
+LIBS = %w[
+  stdc++
+  xot
+]
+
+
+DEFS << '_DEBUG' if debug
+DEFS << 'NDEBUG' unless debug
+DEFS << 'WINDOWS' << 'WIN32' if win32?
+DEFS << 'COCOA' if cocoa?
+DEFS << $~[0].upcase if RUBY_PLATFORM =~ /mswin|ming|cygwin|darwin/i
+
+$CPPFLAGS << DEFS.map    {|s| " -D#{s}"}.join
+$CPPFLAGS << INCDIRS.map {|s| " -I#{s}"}.join
+$LDFLAGS  << LIBDIRS.map {|s| " -L#{s}"}.join
+$CFLAGS   << ' --stdlib=libc++' if clang?
+
+RbConfig::CONFIG.each do |key, val|
+  {'gcc' => 'g++', 'clang' => 'clang++'}.each {|from, to| val.gsub! from, to}
+end
+
+
+dir_config 'boost'
+dir_config 'xot', Xot.root_dir
+
+exit 1 unless HEADERS.all? {|s| have_header(s)}
+exit 1 unless LIBS.all?    {|s| have_library(s)}
+
+
+create_makefile 'xot/tester'

data/ext/xot/tester.cpp

@@ -0,0 +1,19 @@
+#include <ruby.h>
+
+
+static VALUE
+test_native (VALUE self)
+{
+	return true;
+}
+
+
+extern "C" void
+Init_tester ()
+{
+	VALUE mXot    = rb_define_module(            "Xot");
+	VALUE mTester = rb_define_module_under(mXot, "Tester");
+
+	rb_define_singleton_method(
+		mTester, "test_native", RUBY_METHOD_FUNC(test_native), 0);
+}

data/include/xot.h

@@ -6,6 +6,9 @@
 
 #include <xot/defs.h>
 #include <xot/string.h>
+#include <xot/pimpl.h>
+#include <xot/ref.h>
+#include <xot/debug.h>
 
 
 #endif//EOH

data/include/xot/debug.h

@@ -0,0 +1,29 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __XOT_DEBUG_H__
+#define __XOT_DEBUG_H__
+
+
+namespace Xot
+{
+
+
+#ifdef _DEBUG
+
+	void dout (const char* format, ...);
+
+	void doutln (const char* format, ...);
+
+#else
+
+	inline void dout(...) {}
+
+	inline void doutln(...) {}
+
+#endif
+
+
+}// Xot
+
+
+#endif//EOH

data/include/xot/defs.h

@@ -4,6 +4,20 @@
 #define __XOT_DEFS_H__
 
 
+#include <stddef.h>
+
+
+#ifdef CYGWIN
+
+	typedef unsigned short ushort;
+
+	typedef unsigned int   uint;
+
+	typedef unsigned long  ulong;
+
+#endif
+
+
 namespace Xot
 {
 
@@ -12,13 +26,23 @@ namespace Xot
 	{
 
 
-		typedef unsigned char      uchar;
+		typedef unsigned char uchar;
+
+		#ifdef CYGWIN
+
+			using ::ushort;
+			using ::uint;
+			using ::ulong;
+
+		#else
+
+			typedef unsigned short ushort;
 
-		typedef unsigned short     ushort;
+			typedef unsigned int   uint;
 
-		typedef unsigned int       uint;
+			typedef unsigned long  ulong;
 
-		typedef unsigned long      ulong;
+		#endif
 
 		typedef          long long  longlong;
 

data/include/xot/pimpl.h

@@ -0,0 +1,67 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __XOT_PIMPL_H__
+#define __XOT_PIMPL_H__
+
+
+#include <boost/scoped_ptr.hpp>
+#include <boost/shared_ptr.hpp>
+
+
+namespace Xot
+{
+
+
+	template <typename T, bool SHARED = false> class PImpl;
+
+
+	template <typename T>
+	class PImpl<T, false> : public boost::scoped_ptr<T>
+	{
+
+		typedef boost::scoped_ptr<T> Super;
+
+		typedef PImpl<T, false> This;
+
+		public:
+
+			PImpl () : Super(new T) {}
+
+			PImpl (T* p) : Super(p) {}
+
+			PImpl (const This& obj) : Super(new T(*obj)) {}
+
+			This& operator = (const This& obj)
+			{
+				if (&obj != this) reset(new T(*obj));
+				return *this;
+			}
+
+			bool shared () const {return false;}
+
+	};// PImpl
+
+
+	template <typename T>
+	class PImpl<T, true> : public boost::shared_ptr<T>
+	{
+
+		typedef boost::shared_ptr<T> Super;
+
+		typedef PImpl<T, true> This;
+
+		public:
+
+			PImpl () : Super(new T) {}
+
+			PImpl (T* p) : Super(p) {}
+
+			bool shared () const {return true;}
+
+	};// PImpl
+
+
+}// Xot
+
+
+#endif//EOH

data/include/xot/ref.h

@@ -0,0 +1,184 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __XOT_REF_H__
+#define __XOT_REF_H__
+
+
+#include <assert.h>
+#include <typeinfo>
+#include <boost/noncopyable.hpp>
+#include <xot/defs.h>
+#include <xot/debug.h>
+
+
+//#define XOT_REF_DEBUG 1
+
+
+namespace Xot
+{
+
+
+	class EmptyClass {};
+
+
+	template <typename SuperClass = EmptyClass>
+	class RefCountable : public SuperClass
+	{
+
+		public:
+
+			virtual void retain ()
+			{
+				reference(+1);
+
+				#ifdef XOT_REF_DEBUG
+					doutln(
+						"%s: %d -> %d",
+						typeid(this).name(), count() - 1, count());
+				#endif
+			}
+
+			virtual void release ()
+			{
+				assert(count() >= 0);
+				bool del = !retained() || reference(-1) == 0;
+
+				#ifdef XOT_REF_DEBUG
+					doutln(
+						"%s: %d -> %d, refcount:%s, delete:%s",
+						typeid(this).name(), count() + 1, count(),
+						retained() ? "yes" : "no", del ? "yes" : "no");
+				#endif
+
+				if (del) delete this;
+			}
+
+		protected:
+
+			RefCountable ()
+			:	refcount(0)
+			{
+			}
+
+			virtual ~RefCountable ()
+			{
+			}
+
+		private:
+
+			int refcount;
+
+			bool retained () const
+			{
+				return refcount & 0x1;
+			}
+
+			int count () const
+			{
+				return refcount >> 1;
+			}
+
+			int reference (int add)
+			{
+				assert(add != 0);
+				int c = count() + add;
+				refcount = c << 1 | 0x1;// bit for retained flag.
+				return c;
+			}
+
+			RefCountable (const RefCountable&);
+
+			RefCountable& operator = (const RefCountable&);
+
+	};// RefCountable
+
+
+	template <typename T>
+	class Ref
+	{
+
+		typedef Ref<T> This;
+
+		public:
+
+			Ref (T* ptr = NULL)
+			:	ptr(ptr)
+			{
+				if (ptr) ptr->retain();
+			}
+
+			Ref (const This& obj)
+			:	ptr(obj.ptr)
+			{
+				if (ptr) ptr->retain();
+			}
+
+			Ref& operator = (T* ptr)
+			{
+				reset(ptr);
+				return *this;
+			}
+
+			Ref& operator = (const This& obj)
+			{
+				if (&obj == this) return *this;
+				reset(obj.ptr);
+				return *this;
+			}
+
+			~Ref ()
+			{
+				if (ptr) ptr->release();
+			}
+
+			void reset (T* ptr = NULL)
+			{
+				if (this->ptr == ptr) return;
+				if (this->ptr) this->ptr->release();
+				this->ptr = ptr;
+				if (this->ptr) this->ptr->retain();
+			}
+
+			      T* get ()       {return ptr;}
+
+			const T* get () const {return ptr;}
+
+			      T* operator -> ()       {return get();}
+
+			const T* operator -> () const {return get();}
+
+			      T& operator * ()       {return *get();}
+
+			const T& operator * () const {return *get();}
+
+			operator       T* ()       {return get();}
+
+			operator const T* () const {return get();}
+
+			bool operator == (T* ptr) const {return this->ptr == ptr;}
+
+			bool operator != (T* ptr) const {return !operator==(ptr);}
+
+			bool operator == (const T* ptr) const {return this->ptr == ptr;}
+
+			bool operator != (const T* ptr) const {return !operator==(ptr);}
+
+			bool operator == (const This& obj) const {return ptr == obj.ptr;}
+
+			bool operator != (const This& obj) const {return !operator==(obj);}
+
+			operator bool () const {return ptr != NULL;}
+
+			bool operator ! () const {return !operator bool();}
+
+		private:
+
+			T* ptr;
+
+	};// Ref
+
+
+}// Xot
+
+
+#endif//EOH