xot 0.1.12 → 0.1.13

data/include/xot/string.h

@@ -38,6 +38,15 @@ namespace Xot
 
 			String (const char* str);
 
+			template <typename ITERATOR>
+			String (ITERATOR begin, ITERATOR end) : Super(begin, end) {}
+
+			String upcase () const;
+
+			String downcase () const;
+
+			String strip () const;
+
 			operator const char* () const;
 
 			friend String operator + (const String& lhs, const String& rhs);

data/include/xot/time.h

@@ -8,7 +8,9 @@ namespace Xot
 {
 
 
-	double time (bool local = true);
+	double time ();
+
+	void sleep (double seconds);
 
 
 }// Xot

data/include/xot/util.h

@@ -6,6 +6,7 @@
 
 #include <stdint.h>
 #include <math.h>
+#include <assert.h>
 #include <xot/defs.h>
 #include <xot/time.h>
 
@@ -26,46 +27,100 @@ namespace Xot
 	double random (double min_, double max_);
 
 
+	template <typename T = uint>
+	inline constexpr T
+	bit (int nth, T base = 0x1)
+	{
+		return (T) (base << nth);
+	}
+
+	template <typename T>
+	inline constexpr T
+	clip (T minval, T maxval, T value)
+	{
+		return value > maxval ? maxval : (value < minval ? minval : value);
+	}
+
+
+	inline constexpr double
+	deg2rad (double degree)
+	{
+		return degree / 180.0 * M_PI;
+	}
+
+	inline constexpr double
+	rad2deg (double radian)
+	{
+		return radian / M_PI * 180.0;
+	}
+
+
 	template <typename T>
-	inline T deg2rad (T degree)
+	inline void
+	add_flag (T* pvalue, uint flag)
 	{
-		return degree / (T) 180 * M_PI;
+		assert(pvalue);
+
+		*pvalue |= flag;
 	}
 
 	template <typename T>
-	inline T rad2deg (T radian)
+	inline void
+	remove_flag (T* pvalue, uint flag)
 	{
-		return radian / M_PI * (T) 180;
+		assert(pvalue);
+
+		*pvalue &= ~flag;
 	}
 
+	template <typename T>
+	inline bool
+	has_flag (T value, uint flag)
+	{
+		if (flag == 0) return false;
+		return (value & flag) == flag;
+	}
 
 	template <typename T>
-	inline T clip (T minval, T maxval, T value)
+	inline bool
+	check_and_remove_flag (T* pvalue, uint flag)
 	{
-		return value > maxval ? maxval : (value < minval ? minval : value);
+		assert(pvalue);
+
+		bool has = has_flag(*pvalue, flag);
+		remove_flag(pvalue, flag);
+		return has;
 	}
 
 
+	static const uintptr_t POINTER_FLAG = 0x1;
+
 	template <typename T>
-	inline T* set_pointer_flag (T* pointer, bool flag = true)
+	inline T*
+	set_pointer_flag (T* pointer, bool flag = true)
 	{
 		uintptr_t intval = *(uintptr_t*) &pointer;
-		if (flag) intval |=  0x1;
-		else      intval &= ~0x1;
+		if (flag)
+			intval |= POINTER_FLAG;
+		else
+			intval &= ~POINTER_FLAG;
+
 		return *(T**) &intval;
 	}
 
 	template <typename T>
-	inline const T* set_pointer_flag (const T* pointer, bool flag = true)
+	inline const T*
+	set_pointer_flag (const T* pointer, bool flag = true)
 	{
 		return set_pointer_flag(const_cast<T*>(pointer), flag);
 	}
 
 	template <typename T>
-	inline bool get_pointer_flag (const T* pointer)
+	inline bool
+	get_pointer_flag (const T* pointer)
 	{
-		uintptr_t intval = *(uintptr_t*) &pointer;
-		return intval & 0x1;
+		const uintptr_t& intval = *(uintptr_t*) &pointer;
+		return intval & POINTER_FLAG;
 	}
 
 

data/lib/xot.rb

@@ -3,7 +3,11 @@
 
 require 'xot/module'
 require 'xot/bit_flag'
+require 'xot/bit_flag_accessor'
+require 'xot/bit_util'
 require 'xot/block_util'
+require 'xot/const_symbol_accessor'
 require 'xot/hookable'
-require 'xot/setter'
 require 'xot/invoker'
+require 'xot/setter'
+require 'xot/universal_accessor'

data/lib/xot/bit_flag.rb

@@ -1,48 +1,61 @@
 # -*- coding: utf-8 -*-
 
 
+require 'xot/bit_util'
+
+
 module Xot
 
 
   class BitFlag
 
-    def initialize (none = 0, &block)
-      @bit2sym, @sym2bit = {}, {none: none, no: none}
+    include BitUtil
+
+    alias make_bit bit
+
+    def initialize (auto: false, none: 0, **flags, &block)
+      @bit2sym, @sym2bit, @auto, @next = {}, {none: none, no: none}, auto, 1
+      flags.each {|sym, value| flag sym, value}
       BlockUtil.instance_eval_or_block_call self, &block if block
     end
 
-    def flag (symbol, bit)
+    def flag (symbol, value = nil, bit: nil)
+      bit = value || make_bit(bit) || (@auto ? @next : nil)
+
+      raise ArgumentError if !bit
+      raise "flag: symbol #{symbol.inspect} or bit #{bit} is already registered." if
+        @sym2bit.key?(symbol) || @bit2sym.key?(bit)
+
+      single_bit = bit.to_s(2).count('1') == 1
+
       @sym2bit[symbol] = bit
-      @bit2sym[bit]    = symbol if bit.to_s(2).count('1') == 1
+      @bit2sym[bit]    = symbol   if single_bit
+      @next            = bit << 1 if single_bit && bit >= @next
+
+      bit
     end
 
     def bits2symbols (bits)
       array = []
       bits.to_s(2).reverse.each_char.with_index do |char, index|
         next unless char == '1'
-        bit = BitFlag.bit index
-        symbol = @bit2sym[bit]
-        raise "unknown bit for flag." unless symbol
+        symbol = @bit2sym[bit index]
+        raise "unknown bit #{index} for flag." unless symbol
         array << symbol
       end
       array
     end
 
     def symbols2bits (*symbols)
-      symbols.map {|sym| sym2bit sym}.reduce(0) {|a, b| a | b}
-    end
-
-    def self.bit (*args)
-      bits = 0
-      args.each {|n| bits |= 0x1 << n}
-      bits
+      symbols.flatten.reduce(0) {|value, symbol| value | sym2bit(symbol)}
     end
 
     private
 
       def sym2bit (symbol)
         bit = @sym2bit[symbol]
-        raise 'unknown symbol for flag.' unless bit
+        bit = flag symbol if !bit && @auto
+        raise "unknown symbol #{symbol.inspect} for flag." unless bit
         bit
       end
 

data/lib/xot/bit_flag_accessor.rb

@@ -0,0 +1,78 @@
+# -*- coding: utf-8 -*-
+
+
+require 'xot/bit_flag'
+require 'xot/block_util'
+
+
+module Xot
+
+
+  module BitFlagAccessor
+
+    def bit_flag_accessor (name, bit_flag = nil, **flags, &block)
+      bf = define_bit_flag name, bit_flag, flags, block
+      define_bit_flag_writer name, bf
+      define_bit_flag_reader name, bf
+    end
+
+    def bit_flag_writer (name, bit_flag = nil, **flags, &block)
+      define_bit_flag_writer name, define_bit_flag(name, bit_flag, flags, block)
+    end
+
+    def bit_flag_reader (name, bit_flag = nil, **flags, &block)
+      define_bit_flag_reader name, define_bit_flag(name, bit_flag, flags, block)
+    end
+
+    private
+
+      def define_bit_flag (name, bit_flag, flags, block)
+        bit_flag ||= Xot::BitFlag.new **flags
+        Xot::BlockUtil.instance_eval_or_block_call bit_flag, &block if block
+
+        define_singleton_method "#{name}_flag".intern do
+          bit_flag
+        end
+
+        bit_flag
+      end
+
+      def define_bit_flag_writer (name, bit_flag)
+        writer = "#{name}=".intern
+        setter = "bf_set_#{name}__".intern
+
+        alias_method setter, writer
+        private setter
+
+        define_method writer do |*symbols|
+          __send__ setter, bit_flag.symbols2bits(symbols)
+        end
+
+        name
+      end
+
+      def define_bit_flag_reader (name, bit_flag)
+        reader = name.intern
+        getter = "bf_get_#{name}__".intern
+
+        alias_method getter, reader
+        private getter
+
+        define_method reader do
+          bit_flag.bits2symbols __send__(getter)
+        end
+
+        name
+      end
+
+  end# BitFlagAccessor
+
+
+end# Xot
+
+
+class Module
+
+  include Xot::BitFlagAccessor
+
+end# Module

data/lib/xot/bit_util.rb

@@ -0,0 +1,19 @@
+# -*- coding: utf-8 -*-
+
+
+module Xot
+
+
+  module BitUtil
+
+    module_function
+
+    def bit (*bits)
+      return nil if bits.compact.empty?
+      bits.reduce(0) {|value, nth| value | (0x1 << nth)}
+    end
+
+  end# BitUtil
+
+
+end# Xot

data/lib/xot/const_symbol_accessor.rb

@@ -0,0 +1,59 @@
+# -*- coding: utf-8 -*-
+
+
+module Xot
+
+
+  module ConstSymbolAccessor
+
+    def const_symbol_accessor (name, **symbol2const)
+      const_symbol_writer name, **symbol2const
+      const_symbol_reader name, **symbol2const
+    end
+
+    def const_symbol_writer (name, **symbol2const)
+      writer = "#{name}=".intern
+      setter = "cs_set_#{name}__".intern
+
+      alias_method setter, writer
+      private setter
+
+      define_method writer do |symbol|
+        const = symbol2const[symbol]
+        raise ArgumentError unless const
+        __send__ setter, const
+      end
+
+      name
+    end
+
+    def const_symbol_reader (name, **symbol2const)
+      reader = name.intern
+      getter = "cs_get_#{name}__".intern
+
+      alias_method getter, reader
+      private getter
+
+      const2symbol = symbol2const.reduce({}) {|h, (k, v)| h[v] = k; h}
+
+      define_method reader do
+        const  = __send__ getter
+        symbol = const2symbol[const]
+        raise "'#{const}' is unknown value." unless symbol
+        symbol
+      end
+
+      name
+    end
+
+  end# ConstSymbolAccessor
+
+
+end# Xot
+
+
+class Module
+
+  include Xot::ConstSymbolAccessor
+
+end# Module

data/lib/xot/extconf.rb

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 
 
-require 'xot/rake'
+require 'xot/rake/util'
 require 'xot/block_util'
 
 
@@ -12,11 +12,11 @@ module Xot
 
     include Xot::Rake
 
-    attr_reader :modules, :defs, :include_dirs, :lib_dirs, :headers, :libs, :local_libs, :frameworks
+    attr_reader :modules, :defs, :inc_dirs, :lib_dirs, :headers, :libs, :local_libs, :frameworks
 
     def initialize (*modules, &block)
       @modules = modules.map {|m| m.const_get :Module}
-      @defs, @include_dirs, @lib_dirs, @headers, @libs, @local_libs, @frameworks =
+      @defs, @inc_dirs, @lib_dirs, @headers, @libs, @local_libs, @frameworks =
         ([[]] * 7).map &:dup
       Xot::BlockUtil.instance_eval_or_block_call self, &block if block
     end
@@ -36,15 +36,16 @@ module Xot
 
       local_libs << (clang? ? 'c++' : 'stdc++')
 
-      $CPPFLAGS = cppflags $CPPFLAGS, defs, include_dirs
-      $CFLAGS   = cflags   $CFLAGS + ' -x c++'
-      $LDFLAGS  = ldflags  $LDFLAGS, lib_dirs, frameworks
+      $CPPFLAGS = make_cppflags $CPPFLAGS, defs, inc_dirs
+      $CFLAGS   = make_cflags   $CFLAGS   + ' -x c++'
+      $CXXFLAGS = make_cflags   $CXXFLAGS + ' -x c++' if $CXXFLAGS
+      $LDFLAGS  = make_ldflags  $LDFLAGS, lib_dirs, frameworks
       $LOCAL_LIBS << local_libs.map {|s| " -l#{s}"}.join
     end
 
     def create_makefile (*args)
       modules.each do |m|
-        dir_config m.name.downcase, m.include_dir, m.lib_dir
+        dir_config m.name.downcase, m.inc_dir, m.lib_dir
       end
 
       exit 1 unless headers.all? {|s| have_header s}

data/lib/xot/module.rb

@@ -6,6 +6,8 @@ module Xot
 
   module Module
 
+    module_function
+
     def name ()
       super.split('::')[-2]
     end
@@ -15,10 +17,10 @@ module Xot
     end
 
     def root_dir (path = '')
-      File.expand_path "../../../#{path}", __FILE__
+      File.expand_path "../../#{path}", __dir__
     end
 
-    def include_dir ()
+    def inc_dir ()
       root_dir 'include'
     end
 
@@ -26,23 +28,6 @@ module Xot
       root_dir 'lib'
     end
 
-    def task_dir ()
-      root_dir 'task'
-    end
-
-    def load_tasks (*names)
-      if names.empty?
-        Dir["#{task_dir}/**/*.rake"].each {|path| load path}
-      else
-        names.each do |name|
-          path = "#{task_dir}/#{name}.rake"
-          load path if File.exist? path
-        end
-      end
-    end
-
-    extend self
-
   end# Module