xot 0.1.6 → 0.1.7

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b300601324c88ccfa6fc6e1c7c2aee5780dab91a
+  data.tar.gz: 3a1084e6aa373e275acdeda17ddc825151266ed4
+SHA512:
+  metadata.gz: ff596b6f8d92698e58f2aab19c98234251a2bf4ad9489b9f11a04a637d23ac88aee5a7e61c3f2ea90d9c6cefbc9bcf32cdd9d8d512a5da31b156c5c3e45ff7bd
+  data.tar.gz: ea6adff9f5dba95b7403da54c0e6c7f075c82d1e0c2d8dbad987a7c426dac7eaaf9a5626118e9c6490113c855fedd71825521203aaf224c5d173fa95ddc862bb

data/Rakefile

@@ -1,9 +1,9 @@
 # -*- mode: ruby; coding: utf-8 -*-
 
 
-File.expand_path('../lib', __FILE__).tap do |path|
-  $:.unshift path if !$:.include?(path) && File.directory?(path)
-end
+%w[.]
+  .map  {|s| File.expand_path "../#{s}/lib", __FILE__}
+  .each {|s| $:.unshift s if !$:.include?(s) && File.directory?(s)}
 
 require 'xot/rake'
 require 'xot/module'
@@ -11,8 +11,9 @@ require 'xot/module'
 include Xot::Rake
 
 
-MODULE = Xot
-DLNAME = 'tester'
+MODULES = [Xot].map {|m| m.const_get :Module}
+MODULE  = MODULES.last
+DLNAME  = 'tester'
 
 
 task :default => :build
@@ -22,4 +23,4 @@ task :build => :lib
 empty_task :test
 
 
-Xot.load_tasks
+MODULES.each {|m| m.load_tasks :lib, :ext, :test, :gem}

data/VERSION

@@ -1 +1 @@
-0.1.6
+0.1.7

data/ext/xot/extconf.rb

@@ -1,59 +1,20 @@
 # -*- coding: utf-8 -*-
 
 
-File.expand_path('../../../lib', __FILE__).tap do |path|
-  $:.unshift path if !$:.include?(path) && File.directory?(path)
-end
+%w[.]
+  .map  {|s| File.expand_path "../../../#{s}/lib", __FILE__}
+  .each {|s| $:.unshift s if !$:.include?(s) && File.directory?(s)}
 
 require 'mkmf'
-require 'xot/rake'
+require 'xot/extconf'
 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
+Xot::ExtConf.new Xot do
+  setup do
+    headers << 'boost/noncopyable.hpp' << 'ruby.h'
+  end
 
-$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}
+  dir_config 'boost'
+  create_makefile 'xot/tester'
 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

@@ -1,9 +1,102 @@
 #include <ruby.h>
 
 
+#include "xot.h"
+
+
+template <typename EXCEPTION>
+static bool
+test_exception (bool should_catch = true)
+{
+	try
+	{
+		throw EXCEPTION("");
+	}
+	catch (EXCEPTION& e)
+	{
+		if (!should_catch) return false;
+	}
+	catch (...)
+	{
+		if (should_catch) return false;
+	}
+
+	Xot::String s = "Exception Message";
+	EXCEPTION e(s);
+	if (e.what() != s) return false;
+
+	return true;
+}
+
+static bool
+test_exception ()
+{
+	if (!test_exception<Xot::XotError>())            return false;
+	if (!test_exception<Xot::InvalidStateError>())   return false;
+	if (!test_exception<Xot::SystemError>())         return false;
+	if (!test_exception<Xot::NotImplementedError>()) return false;
+	if (!test_exception<std::invalid_argument>())    return false;
+	if (!test_exception<std::out_of_range>())        return false;
+	return true;
+}
+
+struct RefObj : public Xot::RefCountable<> {};
+
+static bool
+test_ref ()
+{
+	if (!(Xot::Ref<RefObj>(NULL) == Xot::Ref<RefObj>(NULL)))       return false;
+	if (!(Xot::Ref<RefObj>(NULL) != Xot::Ref<RefObj>(new RefObj))) return false;
+
+	if (!(Xot::Ref<RefObj>(NULL) == Xot::Ref<const RefObj>(NULL)))       return false;
+	if (!(Xot::Ref<RefObj>(NULL) != Xot::Ref<const RefObj>(new RefObj))) return false;
+
+	if (!(Xot::Ref<const RefObj>(NULL) == Xot::Ref<RefObj>(NULL)))       return false;
+	if (!(Xot::Ref<const RefObj>(NULL) != Xot::Ref<RefObj>(new RefObj))) return false;
+
+	if (!(Xot::Ref<const RefObj>(NULL) == Xot::Ref<const RefObj>(NULL)))       return false;
+	if (!(Xot::Ref<const RefObj>(NULL) != Xot::Ref<const RefObj>(new RefObj))) return false;
+
+	if (!(Xot::Ref<RefObj>(NULL) == (RefObj*) NULL)) return false;
+	if (!(Xot::Ref<RefObj>(NULL) != new RefObj))     return false;
+	return true;
+}
+
+static bool
+test_util ()
+{
+	if (!(Xot::clip(10, 100,  50) ==  50)) return false;
+	if (!(Xot::clip(10, 100,  10) ==  10)) return false;
+	if (!(Xot::clip(10, 100, 100) == 100)) return false;
+	if (!(Xot::clip(10, 100,   0) ==  10)) return false;
+	if (!(Xot::clip(10, 100, 200) == 100)) return false;
+
+	int value;
+	int* p = &value;
+	if (!(Xot::get_pointer_flag(p) == false)) return false;
+
+	p = Xot::set_pointer_flag(p);
+	if (!(Xot::get_pointer_flag(p) == true))  return false;
+
+	p = Xot::set_pointer_flag(p, false);
+	if (!(Xot::get_pointer_flag(p) == false)) return false;
+
+	p = Xot::set_pointer_flag(p, true);
+	if (!(Xot::get_pointer_flag(p) == true))  return false;
+
+	if (!(                      p         != &value))  return false;
+	if (!(Xot::set_pointer_flag(p, false) == &value))  return false;
+
+	return true;
+}
+
+
 static VALUE
 test_native (VALUE self)
 {
+	if (!test_exception()) return false;
+	if (!test_ref()) return false;
+	if (!test_util()) return false;
 	return true;
 }
 

data/include/xot.h

@@ -6,8 +6,11 @@
 
 #include <xot/defs.h>
 #include <xot/string.h>
-#include <xot/pimpl.h>
+#include <xot/exception.h>
 #include <xot/ref.h>
+#include <xot/pimpl.h>
+#include <xot/time.h>
+#include <xot/util.h>
 #include <xot/debug.h>
 
 

data/include/xot/exception.h

@@ -0,0 +1,70 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __XOT_EXCEPTION_H__
+#define __XOT_EXCEPTION_H__
+
+
+#include <stdexcept>
+#include <xot/string.h>
+
+
+namespace Xot
+{
+
+
+	class XotError : public std::runtime_error
+	{
+		typedef std::runtime_error Super;
+		public: XotError (const char* str = NULL);
+	};
+
+
+	class InvalidStateError : public XotError
+	{
+		typedef XotError Super;
+		public: InvalidStateError (const char* str = NULL);
+	};
+
+
+	class SystemError : public XotError
+	{
+		typedef XotError Super;
+		public: SystemError (const char* str = NULL);
+	};
+
+
+	class NotImplementedError : public XotError
+	{
+		typedef XotError Super;
+		public: NotImplementedError (const char* str = NULL);
+	};
+
+
+	String error_text (const char* file, int line, const char* str);
+
+
+	namespace ErrorFunctions
+	{
+
+		void xot_error             (const char* file, int line, const char* format = NULL, ...);
+
+		void argument_error        (const char* file, int line, const char* format = NULL, ...);
+
+		void index_error           (const char* file, int line, const char* format = NULL, ...);
+
+		void invalid_state_error   (const char* file, int line, const char* format = NULL, ...);
+
+		void system_error          (const char* file, int line, const char* format = NULL, ...);
+
+		void not_implemented_error (const char* file, int line, const char* format = NULL, ...);
+
+	}// ErrorFunctions
+
+
+	using namespace ErrorFunctions;
+
+
+}// Xot
+
+
+#endif//EOH

data/include/xot/ref.h

@@ -4,10 +4,18 @@
 #define __XOT_REF_H__
 
 
+#ifdef check // by OSX's AssertMacros.h
+#undef check
+#endif
+
+#include <limits.h>
 #include <assert.h>
 #include <typeinfo>
 #include <boost/noncopyable.hpp>
+#include <boost/type_traits.hpp>
+#include <boost/utility/enable_if.hpp>
 #include <xot/defs.h>
+#include <xot/exception.h>
 #include <xot/debug.h>
 
 
@@ -22,32 +30,32 @@ namespace Xot
 
 
 	template <typename SuperClass = EmptyClass>
-	class RefCountable : public SuperClass
+	class RefCountable : public SuperClass, public boost::noncopyable
 	{
 
 		public:
 
-			virtual void retain ()
+			virtual void retain (void* data = NULL) const
 			{
-				reference(+1);
+				refc_update_count(+1);
 
 				#ifdef XOT_REF_DEBUG
 					doutln(
 						"%s: %d -> %d",
-						typeid(this).name(), count() - 1, count());
+						typeid(this).name(), refc_count() - 1, refc_count());
 				#endif
 			}
 
-			virtual void release ()
+			virtual void release (void* data = NULL) const
 			{
-				assert(count() >= 0);
-				bool del = !retained() || reference(-1) == 0;
+				assert(refc_count() >= 0);
+				bool del = !refc_retained() || refc_update_count(-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");
+						typeid(this).name(), refc_count() + 1, refc_count(),
+						refc_retained() ? "yes" : "no", del ? "yes" : "no");
 				#endif
 
 				if (del) delete this;
@@ -56,7 +64,6 @@ namespace Xot
 		protected:
 
 			RefCountable ()
-			:	refcount(0)
 			{
 			}
 
@@ -64,44 +71,78 @@ namespace Xot
 			{
 			}
 
-		private:
+			virtual int refc_count () const
+			{
+				return refc.count;
+			}
 
-			int refcount;
+			virtual bool refc_retained () const
+			{
+				return refc.aux & 0x1;
+			}
 
-			bool retained () const
+			virtual int refc_update_count (int add) const
 			{
-				return refcount & 0x1;
+				assert(add != 0);
+				if (add >= 0) refc.aux |= 0x1;// bit for retained flag.
+
+				int c = refc.count + add;
+				if (c < 0)
+					invalid_state_error(__FILE__, __LINE__);
+				if (c > USHRT_MAX)
+					xot_error(__FILE__, __LINE__, "refc.count overflow.");
+
+				return refc.count = c;
 			}
 
-			int count () const
+			virtual ushort refc_aux () const
 			{
-				return refcount >> 1;
+				return refc.aux >> 1;
 			}
 
-			int reference (int add)
+			virtual void refc_set_aux (ushort aux) const
 			{
-				assert(add != 0);
-				int c = count() + add;
-				refcount = c << 1 | 0x1;// bit for retained flag.
-				return c;
+				if ((0x1 << 15) & aux)
+					argument_error(__FILE__, __LINE__);
+
+				refc.aux = (refc.aux & 0x1) | (aux << 1);
 			}
 
-			RefCountable (const RefCountable&);
+		private:
 
-			RefCountable& operator = (const RefCountable&);
+			mutable struct Data
+			{
+
+				ushort count, aux;
+
+				Data () : count(0), aux(0) {}
+
+			} refc;
 
 	};// RefCountable
 
 
-	template <typename T>
+	template <typename T, typename = void>
 	class Ref
 	{
 
 		typedef Ref<T> This;
 
+		typedef       T       Value;
+
+		typedef const T  ConstValue;
+
+		typedef       T&      Reference;
+
+		typedef const T& ConstReference;
+
+		typedef       T*      Pointer;
+
+		typedef const T* ConstPointer;
+
 		public:
 
-			Ref (T* ptr = NULL)
+			Ref (Pointer ptr = NULL)
 			:	ptr(ptr)
 			{
 				if (ptr) ptr->retain();
@@ -113,13 +154,13 @@ namespace Xot
 				if (ptr) ptr->retain();
 			}
 
-			Ref& operator = (T* ptr)
+			This& operator = (Pointer ptr)
 			{
 				reset(ptr);
 				return *this;
 			}
 
-			Ref& operator = (const This& obj)
+			This& operator = (const This& obj)
 			{
 				if (&obj == this) return *this;
 				reset(obj.ptr);
@@ -131,7 +172,7 @@ namespace Xot
 				if (ptr) ptr->release();
 			}
 
-			void reset (T* ptr = NULL)
+			void reset (Pointer ptr = NULL)
 			{
 				if (this->ptr == ptr) return;
 				if (this->ptr) this->ptr->release();
@@ -139,41 +180,130 @@ namespace Xot
 				if (this->ptr) this->ptr->retain();
 			}
 
-			      T* get ()       {return ptr;}
+			     Pointer get ()       {return ptr;}
+
+			ConstPointer get () const {return ptr;}
+
+			     Pointer operator -> ()       {return get();}
+
+			ConstPointer operator -> () const {return get();}
+
+			     Reference operator * ()       {return *get();}
+
+			ConstReference operator * () const {return *get();}
+
+			operator      Pointer ()       {return get();}
+
+			operator ConstPointer () const {return get();}
+
+			bool operator == (Pointer ptr) const {return this->ptr == ptr;}
+
+			bool operator != (Pointer ptr) const {return !operator==(ptr);}
+
+			bool operator == (ConstPointer ptr) const {return this->ptr == ptr;}
+
+			bool operator != (ConstPointer ptr) const {return !operator==(ptr);}
+
+			bool operator == (const This& obj) const {return ptr == obj.ptr;}
+
+			bool operator != (const This& obj) const {return !operator==(obj);}
+
+			bool operator <  (const This& obj) const {return ptr < obj.ptr;}
+
+			operator bool () const {return ptr != NULL;}
+
+			bool operator ! () const {return !operator bool();}
+
+		private:
+
+			Pointer ptr;
 
-			const T* get () const {return ptr;}
+	};// Ref
+
+
+	template <typename T>
+	class Ref<T, typename boost::enable_if<boost::is_const<T> >::type>
+	{
+
+		typedef Ref<T> This;
+
+		typedef typename boost::remove_const<T>::type Value;
+
+		typedef                              T   ConstValue;
+
+		typedef       Value&      Reference;
+
+		typedef const Value& ConstReference;
+
+		typedef       Value*      Pointer;
+
+		typedef const Value* ConstPointer;
+
+		public:
+
+			Ref (ConstPointer ptr = NULL)
+			:	ptr(ptr)
+			{
+				if (ptr) ptr->retain();
+			}
+
+			Ref (const This& obj)
+			:	ptr(obj.ptr)
+			{
+				if (ptr) ptr->retain();
+			}
 
-			      T* operator -> ()       {return get();}
+			This& operator = (ConstPointer ptr)
+			{
+				reset(ptr);
+				return *this;
+			}
 
-			const T* operator -> () const {return get();}
+			This& operator = (const This& obj)
+			{
+				if (&obj == this) return *this;
+				reset(obj.ptr);
+				return *this;
+			}
 
-			      T& operator * ()       {return *get();}
+			~Ref ()
+			{
+				if (ptr) ptr->release();
+			}
 
-			const T& operator * () const {return *get();}
+			void reset (ConstPointer ptr = NULL)
+			{
+				if (this->ptr == ptr) return;
+				if (this->ptr) this->ptr->release();
+				this->ptr = ptr;
+				if (this->ptr) this->ptr->retain();
+			}
 
-			operator       T* ()       {return get();}
+			ConstPointer get () const {return ptr;}
 
-			operator const T* () const {return get();}
+			ConstPointer operator -> () const {return get();}
 
-			bool operator == (T* ptr) const {return this->ptr == ptr;}
+			ConstReference operator * () const {return *get();}
 
-			bool operator != (T* ptr) const {return !operator==(ptr);}
+			operator ConstPointer () const {return get();}
 
-			bool operator == (const T* ptr) const {return this->ptr == ptr;}
+			bool operator == (ConstPointer ptr) const {return this->ptr == ptr;}
 
-			bool operator != (const T* ptr) const {return !operator==(ptr);}
+			bool operator != (ConstPointer ptr) const {return !operator==(ptr);}
 
 			bool operator == (const This& obj) const {return ptr == obj.ptr;}
 
 			bool operator != (const This& obj) const {return !operator==(obj);}
 
+			bool operator <  (const This& obj) const {return ptr < obj.ptr;}
+
 			operator bool () const {return ptr != NULL;}
 
 			bool operator ! () const {return !operator bool();}
 
 		private:
 
-			T* ptr;
+			ConstPointer ptr;
 
 	};// Ref