ease_engine 0.0.19

data/lib/ease_engine/time.rb

@@ -0,0 +1,22 @@
+module EaseEngine
+  class Time < Time
+    def to_s
+      sprintf( "%04d/%02d/%02d %02d:%02d:%02d.%06d", year, month, day, hour, min, sec, usec )
+    end
+    
+    def to_unix_epoch_time_usec
+      to_i * 1000000 + usec
+    end
+    
+    def -( time )
+      ( to_i - time.to_i ) * 1000000 + ( usec - time.usec )
+    end
+    
+    def is_same_day( time )
+      return false if day != time.day
+      return false if month != time.month
+      return false if year != time.year
+      return true
+    end
+  end
+end

data/lib/ease_engine/timer.rb

@@ -0,0 +1,72 @@
+require "ease_engine/data"
+
+module EaseEngine
+  class Timer
+    class Info
+      attr_accessor :end_time_usec, :arg, :callback
+      
+      def initialize( end_time_usec, arg, callback )
+        @end_time_usec = end_time_usec
+        @arg = arg
+        @callback = callback
+      end
+    end
+    
+    class Record < EaseEngine::Data::Record
+      def sort!
+        @ary.sort_by!{|info| info.data.end_time_usec}
+        
+        super
+      end
+    end
+    
+    attr_accessor   :update_time_usec
+    
+    def initialize( options = {} )
+      options[ :update_time_usec ] = 100000 if ! options.key?( :update_time_usec )
+      
+      @update_time_usec = options[ :update_time_usec ]
+      @check_time_usec = 0
+      
+      @timer = Record.new( 1, 0xFFFFFFFF )
+      @group = EaseEngine::Data::Group.new
+    end
+    
+    def add( group_id, timeout_usec, arg, callback )
+      timer_id = @timer.add( Info.new( EaseEngine::Time.new.to_unix_epoch_time_usec + timeout_usec, arg, callback ) )
+      return 0 if 0 == timer_id
+      
+      @group.add( group_id, timer_id ) if 0 < group_id
+      
+      timer_id
+    end
+    
+    def remove( group_id, timer_id = 0 )
+      @group.group( group_id ).each{|timer_id, group_id|
+        @timer.remove( timer_id )
+      }
+      @group.remove( group_id, timer_id )
+      @timer.remove( timer_id )
+    end
+    
+    def update
+      return if 0 == @timer.size
+      
+      usec = EaseEngine::Time.new.to_unix_epoch_time_usec
+      return if usec < @check_time_usec
+      
+      @timer.each{|id, index, info|
+        if info.end_time_usec < usec
+          remove( 0, id )
+          
+          info.callback.call( info.arg )
+        else
+          # 終了時間の早い順に昇順ソートしているので、後のデータをチェックする必要なし
+          break
+        end
+      }
+      
+      @check_time_usec = usec + @update_time_usec
+    end
+  end
+end

data/lib/ease_engine/version.rb

@@ -0,0 +1,3 @@
+module EaseEngine
+  VERSION = "0.0.19"
+end

data/lib/ease_engine/watcher.rb

@@ -0,0 +1,95 @@
+require "cool.io"
+require "ease_engine/platform"
+
+module EaseEngine
+  class Watcher
+    class Info < Cool.io::IOWatcher
+      attr_accessor     :io, :callbacks
+      
+      def initialize( io, flags, callbacks )
+        @io = io
+        @callbacks = callbacks
+        
+        super( io.kind_of?( EaseEngine::Socket ) ? io.socket : io, flags )
+      end
+      
+      def on_readable
+        @callbacks[ :on_read ].call( @io ) if @callbacks.key?( :on_read )
+      end
+      
+      def on_writable
+        @callbacks[ :on_write ].call( @io ) if @callbacks.key?( :on_write )
+      end
+      
+      def on_remove
+        @callbacks[ :on_remove ].call( @io ) if @callbacks.key?( :on_remove )
+      end
+    end
+    
+    def initialize( options = {} )
+      # 環境に合わせて適切なものを選択
+      if ! options.key?( :backend )
+        backend = :select
+        if EaseEngine::Platform.mac?
+          backend = :kqueue
+        elsif EaseEngine::Platform.linux?
+          backend = :epoll
+        end
+        
+        options[ :backend ] = backend
+      end
+      
+      EaseEngine::Log.inf( "Watcher #{options}" )
+      @loop = Cool.io::Loop.new( options )
+      @watches = {}
+    end
+    
+    def watch( timeout = 0 )
+      if ! @watches.empty?
+        @loop.run_once( timeout )
+      elsif 0 < timeout
+        sleep timeout
+      end
+    end
+    
+    def add( io, callbacks )
+      id = io.to_i
+      if @watches.key?( id )
+        info = @watches[ id ]
+        @watches.delete( id )
+        info.detach
+      end
+      
+      flags = ""
+      flags = "r" if callbacks.key?( :on_read )
+      flags = "#{flags}w" if callbacks.key?( :on_write )
+      
+      @watches[ id ] = Info.new( io, flags, callbacks )
+      @watches[ id ].attach @loop
+    end
+    
+    def remove( io )
+      id = io.to_i
+      return if ! @watches.key?( id )
+      
+      info = @watches[ id ]
+      @watches.delete( id )
+      info.detach
+      info.on_remove
+    end
+    
+    def size
+      @watches.size
+    end
+    
+    def each
+      @watches.each{|id, info|
+        yield info
+      }
+    end
+    
+    def []( id )
+      @watches.key?( id ) ? @watches[ id ].io : nil
+    end
+  end
+end

data/types/Rakefile

@@ -0,0 +1,83 @@
+require "fileutils"
+
+class String
+  def camelize
+    list = []
+    self.split( "_" ).each{|name|
+      list.push name.capitalize
+    }
+    list.join
+  end
+end
+
+type = nil
+build_cmds = []
+clean_cmds = []
+
+desc "Setup"
+task :setup do
+  puts "setup #{type}"
+  
+  case type
+  when :csharp
+    create_file_path = Proc.new{|names|
+       names.each_with_index{|name, index|
+         names[ index ] = name.camelize
+       }
+       "./csharp/#{names.join( '/' )}.cs"
+     }
+  else
+    STDERR.puts "Unknown type=#{type}"
+    return
+  end
+  
+  Dir::glob( "../lib/**/*.rb" ).each{|src_path|
+    dst_path = src_path.sub( /^\.\.\/lib\/(.+)\.rb$/, "\\1" )
+    dst_path = create_file_path.call( dst_path.split( "/" ) )
+#    p [ src_path, dst_path ]
+    
+    dir = File.dirname( dst_path )
+    FileUtils.mkdir_p( dir ) if ! Dir.exist?( dir )
+    FileUtils.cp( src_path, dst_path ) if ! File.exist?( dst_path )
+  }
+end
+
+desc "Build"
+task :build do
+  build_cmds.each{|cmd|
+    sh cmd
+  }
+end
+
+desc "Clean"
+task :clean do
+  clean_cmds.each{|cmd|
+    sh cmd
+  }
+end
+
+desc "CSharp"
+task :csharp do
+  type = :csharp
+  srcs = [
+    "./csharp/EaseEngine.cs",
+    "./csharp/EaseEngine/Version.cs",
+    "./csharp/EaseEngine/Time.cs",
+    "./csharp/EaseEngine/Buffer.cs",
+    "./csharp/EaseEngine/Measure.cs",
+  ]
+  build_cmds = [
+    "mcs -target:library -out:./csharp/EaseEngine.dll #{srcs.join( ' ' )}",
+    "cp ./csharp/EaseEngine.dll ./csharp/Unity/Assets/."
+  ]
+  clean_cmds = [
+    "rm -f ./csharp/EaseEngine.dll"
+  ]
+end
+
+desc "Show"
+task :show do
+  puts "type=#{type}"
+  puts "build_cmds=#{build_cmds}"
+  puts "clean_cmds=#{clean_cmds}"
+end

data/types/csharp/EaseEngine.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Diagnostics;
+
+namespace EaseEngine {
+  public class Common {
+    static public UInt32 Rotate( UInt32 min, UInt32 max, UInt32 value, UInt32 add ){
+      if ( value < min || max < value ) return min;
+      
+      value += add;
+      return ( value < min || max < value ) ? min : value;
+    }
+    
+    static public string TraceInfo( StackFrame trace, ref string file, ref int line, ref string method ){
+      file = trace.GetFileName();
+      line = trace.GetFileLineNumber();
+      method = trace.GetMethod().Name;
+      return string.Format( "{0}:{1} {2}", file, line, method );
+    }
+    
+    static public string TraceInfo( StackFrame trace ){
+      string file = "";
+      int line = 0;
+      string method = "";
+      return TraceInfo( trace, ref file, ref line, ref method );
+    }
+    
+    static public string TraceInfo( int index, ref string file, ref int line, ref string method ){
+      return TraceInfo( new StackFrame( index + 1, true ), ref file, ref line, ref method );
+    }
+    
+    static public string TraceInfo( int index ){
+      return TraceInfo( new StackFrame( index + 1, true ) );
+    }
+    
+    static public string TraceInfo(){
+      return TraceInfo( 1 );
+    }
+  }
+}

data/types/csharp/EaseEngine/Buffer.cs

@@ -0,0 +1,49 @@
+using System;
+using System.Text;
+
+namespace EaseEngine {
+  public class Buffer {
+    protected string    m_value;
+    public string Value {
+      get { return m_value; }
+      set { m_value = value; }
+    }
+    
+    protected int       m_size;
+    public int Size {
+      get { return m_size; }
+      set { m_size = value; }
+    }
+    
+    public Buffer( string value ){
+      m_value = value;
+      m_size = value.Length;
+    }
+    
+    public Buffer() : this( "" ){
+    }
+    
+    public override string ToString(){
+      return m_value;
+    }
+    
+    public string Add( string value ){
+      if ( 0 < value.Length ){
+        StringBuilder sb = new StringBuilder( m_size + value.Length );
+        sb.Append( value );
+        m_value = sb.ToString();
+        m_size = m_value.Length;
+      }
+      return m_value;
+    }
+    
+    public string Remove( int size ){
+      if ( size <= 0 ) return "";
+      
+      m_size -= size;
+      string removed_str = m_value.Substring( 0, size );
+      m_value = m_value.Substring( size );
+      return removed_str;
+    }
+  }
+}

data/types/csharp/EaseEngine/Measure.cs

@@ -0,0 +1,47 @@
+using System;
+
+namespace EaseEngine {
+  public class Measure {
+    protected Time   m_start_time;
+    public Time StartTime {
+      get { return m_start_time; }
+      set { m_start_time = value; }
+    }
+    
+    protected Time   m_end_time;
+    public Time EndTime {
+      get { return m_end_time; }
+      set { m_end_time = value; }
+    }
+    
+    protected UInt64 m_update_usec;
+    public UInt64 UpdateUSec {
+      get { return m_update_usec; }
+      set { m_update_usec = value; }
+    }
+    
+    protected UInt64 m_count;
+    public UInt64 Count {
+      get { return m_count; }
+      set { m_count = value; }
+    }
+    
+    public Measure(){
+      Start();
+    }
+    
+    public void Start(){
+      m_start_time = m_end_time = new Time();
+      m_update_usec = 0;
+      m_count = 0;
+    }
+    
+    public UInt64 Check(){
+      m_end_time = new Time();
+      m_update_usec += ( m_end_time - m_start_time );
+      m_count += 1;
+      m_start_time = m_end_time;
+      return m_update_usec;
+    }
+  }
+}

data/types/csharp/EaseEngine/Time.cs

@@ -0,0 +1,41 @@
+using System;
+
+namespace EaseEngine {
+  public class Time {
+    protected static DateTime   m_unix_epoch_base_time = new DateTime( 1970, 1, 1 );
+    
+    protected DateTime          m_value;
+    protected DateTime          m_value_unix_epoch_time;
+    public DateTime Value {
+      get { return m_value; }
+      set {
+        m_value = value;
+        m_value_unix_epoch_time = value.ToUniversalTime();
+      }
+    }
+    
+    public Time(){
+      Value = DateTime.Now;
+    }
+    
+    public UInt64 ToUnixEpochTimeUSec(){
+      return (UInt64)( ( m_value_unix_epoch_time - m_unix_epoch_base_time ).TotalSeconds * 1000000 );
+    }
+    
+    public override string ToString(){
+      return string.Format( "{0:0000}/{1:00}/{2:00} {3:00}:{4:00}:{5:00}.{6:000000}",
+        m_value.Year, m_value.Month, m_value.Day, m_value.Hour, m_value.Minute, m_value.Second, m_value.Millisecond * 1000 );
+    }
+    
+    public static UInt64 operator-( Time a, Time b ){
+      return a.ToUnixEpochTimeUSec() - b.ToUnixEpochTimeUSec();
+    }
+    
+    public bool IsSameDay( Time time ){
+      if ( m_value.Day != time.Value.Day ) return false;
+      if ( m_value.Month != time.Value.Month ) return false;
+      if ( m_value.Year != time.Value.Year ) return false;
+      return true;
+    }
+  }
+}