Commit: 16 - NeoFT.Workshop (svn)

FreeTrainの進化系を目指す

Commit MetaInfo

• Revision: 16 (tree)
• Time: 2014-02-11 21:36:55
• Author: c477

Log Message

画像オーバーライドの定義と管理（基本実装ほぼ完）

Change Summary

• modified: trunk/NeoFT.suo
• modified: trunk/core/core/view/ISceneCondition.cs
• modified: trunk/core/core/schedule/Time.cs
• modified: trunk/core/core/schedule/PrimitiveConditions.cs
• modified: trunk/core/core/schedule/ConditionValueExtracter.cs
• modified: trunk/core/core/schedule/Calendar.cs
• modified: trunk/core/NFT.Core.csproj
• modified: trunk/core/module_calendar.xml
• modified: trunk/framework/framework/plugin/Plugin.cs
• modified: trunk/TestLauncher/test/SomeTest.cs

Incremental Difference

--- trunk/core/core/view/ISceneCondition.cs	(revision 15)
+++ trunk/core/core/view/ISceneCondition.cs	(revision 16)
@@ -4,7 +4,7 @@
 using nft.framework.drawing;
 using nft.framework;
 using nft.core.schedule;
-using TimeCycle = nft.core.schedule.Calendar.Cycles;
+using TimeCycle = nft.core.schedule.Calendar.TimeUnit;
 
 namespace nft.core.view
 {
@@ -15,10 +15,10 @@
     /// </summary>
     public enum ConditionTypes { 
         Unknown,
-        Daily = (int)TimeCycle.Daily,
-        Weekly = (int)TimeCycle.Weekly,
-        Monthly = (int)TimeCycle.Monthly,
-        Yearly = (int)TimeCycle.Yearly,
+        Daily = (int)TimeCycle.Days,
+        Weekly = (int)TimeCycle.Weeks,
+        Monthly = (int)TimeCycle.Months,
+        Yearly = (int)TimeCycle.Years,
         TimeOfDay, Weather, Scale }
 
     public interface ISceneParams
@@ -39,9 +39,19 @@
 
     public interface ISceneCondition
     {
+        string GroupName { get; }
         string ConditionName { get; }
         ConditionTypes ConditionType { get; }
         bool IsMatch(ISceneParams p);
     }
 
+    public interface IComparablesCondition {
+        IComparable From { get; }
+        
+        /// <summary>
+        /// Until is null when the condition check only if a value match.
+        /// </summary>
+        IComparable Until { get; }
+    }
+
 }

--- trunk/core/core/schedule/Time.cs	(revision 15)
+++ trunk/core/core/schedule/Time.cs	(revision 16)
@@ -1,6 +1,6 @@
 using System;
 using System.Diagnostics;
-using TimeCycle = nft.core.schedule.Calendar.Cycles;
+using TimeCycle = nft.core.schedule.Calendar.TimeUnit;
 
 namespace nft.core.schedule
 {
@@ -47,6 +47,10 @@
 				Hour, Minute, Second  );
 		}
 
+        public string ToString(string format) {
+            throw new NotImplementedException();
+        }
+
 		protected static readonly int[] daysOfMonth = {31,28,31,30,31,30,31, 31,30,31,30,31};
 
 		/// <summary>

--- trunk/core/core/schedule/PrimitiveConditions.cs	(revision 15)
+++ trunk/core/core/schedule/PrimitiveConditions.cs	(revision 16)
@@ -2,16 +2,31 @@
 using System.Collections.Generic;
 using System.Text;
 using nft.core.view;
-using TimeCycle = nft.core.schedule.Calendar.Cycles;
+using TimeUnit = nft.core.schedule.Calendar.TimeUnit;
 using System.Diagnostics;
 
 namespace nft.core.schedule {
     public class PrimitiveConditions {
         protected static Dictionary<string, ISceneCondition> conditions = new Dictionary<string, ISceneCondition>();
+        protected static Dictionary<string, NamedConditionGroup> groups = new Dictionary<string, NamedConditionGroup>();
+        protected static Dictionary<string, TimeUnit> formats = new Dictionary<string, TimeUnit>();
 
+        static PrimitiveConditions() {
+            formats["MM"] = formats["M"] = TimeUnit.Months;
+            formats["dd"] = formats["d"] = TimeUnit.Days;
+            formats["HH"] = formats["H"] = TimeUnit.Hours;
+            formats["E"] = TimeUnit.Days;
+        }
+
         public static void RegisterCondtion(ISceneCondition cond) {
             Debug.WriteLine("Register condition: name="+cond.ConditionName);
-            conditions.Add(cond.ConditionName, cond);
+            conditions[cond.ConditionName] = cond; //重複は後のもので上書き
+            NamedConditionGroup g = null;
+            if (!groups.TryGetValue(cond.GroupName, out g)) {
+                g = new PrimitiveConditions.NamedConditionGroup(cond.GroupName);
+                groups[cond.GroupName] = g;
+            }
+            g.Add(cond);
         }
 
         public static ISceneCondition GetByName(string name) {
@@ -18,36 +33,87 @@
             return conditions[name];
         }
 
-        public static ISceneCondition CreateSceneCondition(string name, ConditionTypes ctype, IComparable match, TimeCycle option_resol) {
-            return CreateSceneConditionImpl(name, ctype, match, null, option_resol);
+        public static ISceneCondition CreateSceneCondition(string groupname, string name, ConditionTypes ctype, IComparable match, TimeUnit option_resol) {
+            return CreateSceneConditionImpl(groupname, name, ctype, match, null, option_resol);
         }
-        
-        public static ISceneCondition CreateSceneCondition(string name, ConditionTypes ctype, object match) {
-            return CreateSceneConditionImpl(name, ctype, match, null, TimeCycle.Unknown);
+
+        public static ISceneCondition CreateSceneCondition(string groupname, string name, ConditionTypes ctype, object match) {
+            return CreateSceneConditionImpl(groupname, name, ctype, match, null, TimeUnit.Unknown);
         }
 
-        public static ISceneCondition CreateSceneCondition(string name, ConditionTypes ctype, IComparable from, IComparable to ) {
-            return CreateSceneConditionImpl(name, ctype, from, to, TimeCycle.Unknown);
+        public static ISceneCondition CreateSceneCondition(string groupname, string name, ConditionTypes ctype, IComparable from, IComparable until) {
+            return CreateSceneConditionImpl(groupname, name, ctype, from, until, TimeUnit.Unknown);
         }
 
-        public static ISceneCondition CreateSceneCondition(string name, ConditionTypes ctype, IComparable from, IComparable to, TimeCycle option_resol) {
-            return CreateSceneConditionImpl(name, ctype, from, to, option_resol);
+        public static ISceneCondition CreateSceneCondition(string groupname, string name, ConditionTypes ctype, IComparable from, IComparable until, TimeUnit unit) {
+            return CreateSceneConditionImpl(groupname, name, ctype, from, until, unit);
         }
 
-        protected static ISceneCondition CreateSceneConditionImpl(string name, ConditionTypes ctype, object from, object to, TimeCycle option_resol) {
+        public static ISceneCondition CreateSceneConditionFromDateFormat(string groupname, string name, ConditionTypes ctype, string format, IComparable match) {
+            return CreateSceneConditionFromDateFormatImpl(groupname, name, ctype, format, match, null);
+        }
+
+        public static ISceneCondition CreateSceneConditionFromDateFormat(string groupname, string name, ConditionTypes ctype, string format, IComparable from, IComparable until) {
+            return CreateSceneConditionFromDateFormatImpl(groupname, name, ctype, format, from, until);
+        }
+
+        public static TimeUnit SelectUnitFromDateFormat(string format) {
+            format = "" + format;
+            TimeUnit tu;
+            if (formats.TryGetValue(format, out tu)) {
+                return tu;
+            }
+            return TimeUnit.Unknown;
+        }
+
+        protected static ISceneCondition CreateSceneConditionFromDateFormatImpl(string groupname, string name, ConditionTypes ctype, string format, IComparable _from, IComparable _until) {
             ISceneCondition cond = null;
+
+            TimeUnit unit = SelectUnitFromDateFormat(format);
+            IConditionValueExtracter ex;
+            if (unit == TimeUnit.Unknown) {
+                // 任意のフォーマット変換による比較
+                ex = new FormattedTimeStrConditionExtracter(ctype, format);
+            } else {
+                ex = CreateCondValueExtracter(ctype, unit);
+            }
+            Type t = ex.ComparableType;
+
+            if (_until == null || _until.CompareTo(_from) == 0) {
+                cond = new EqualityCondition(groupname, name, ex, AdjustType(_from, t));
+            } else {
+                _until = AdjustType(_until, t);
+                _from = AdjustType(_from, t);
+                if (_until.CompareTo(_from) > 0) {
+                    cond = new RangeCondition(groupname, name, ex, _from, _until);
+                } else {
+                    cond = new BoudaryRangeCondition(groupname, name, ex, _from, _until);
+                }
+            }
+            RegisterCondtion(cond);
+            return cond;
+        }
+
+        protected static ISceneCondition CreateSceneConditionImpl(string groupname, string name, ConditionTypes ctype, object from, object until, TimeUnit unit) {
+            ISceneCondition cond = null;
             if (ctype == ConditionTypes.Weather) {
-                cond = new WeatherCondition(from);
+                cond = new WeatherCondition(groupname, from);
             } else {
                 IComparable _from = from as IComparable;
-                IComparable _to = to as IComparable;
-                IConditionValueExtracter ex = CreateCondValueExtracter(ctype);
-                if (_to == null || _to.CompareTo(_from) == 0) {
-                    cond = new EqualityCondition(name, ex, _from);
-                } else if (_to.CompareTo(_from) > 0) {
-                    cond = new RangeCondition(name, ex, _from, _to);
+                IComparable _until = until as IComparable;
+                IConditionValueExtracter ex = CreateCondValueExtracter(ctype, unit);
+                Type t = ex.ComparableType;
+
+                if (_until == null || _until.CompareTo(_from) == 0) {
+                    cond = new EqualityCondition(groupname, name, ex, AdjustType(_from, t));
                 } else {
-                    cond= new BoudaryRangeCondition(name, ex, _from, _to);
+                    _until = AdjustType(_until, t);
+                    _from = AdjustType(_from, t);
+                    if (_until.CompareTo(_from) > 0) {
+                        cond = new RangeCondition(groupname, name, ex, _from, _until);
+                    } else {
+                        cond = new BoudaryRangeCondition(groupname, name, ex, _from, _until);
+                    }
                 }
             }
             RegisterCondtion(cond);
@@ -54,6 +120,10 @@
             return cond;
         }
 
+        protected static IComparable AdjustType(IComparable org, Type t) {
+            return (IComparable) Convert.ChangeType(org, t);
+        }
+
         public static IConditionValueExtracter CreateCondValueExtracter(ConditionTypes ctype) {
             switch (ctype) {
             case ConditionTypes.Daily:
@@ -74,40 +144,100 @@
             return null;
         }
 
-        public static IConditionValueExtracter CreateCondValueExtracter(ConditionTypes ctype, TimeCycle resolution) {
+        public static IConditionValueExtracter CreateCondValueExtracter(ConditionTypes ctype, TimeUnit resolution) {
             try {
-                TimeCycle tc = (TimeCycle)ctype;
+                TimeUnit tc = (TimeUnit)ctype;
             } catch (Exception) {
                 throw new ArgumentException(Enum.GetName(typeof(ConditionTypes), ctype) + " type is not acceptable.");
             }
 
             switch (resolution) {
-            case TimeCycle.Hourly:
+            case TimeUnit.Hours:
                 return new TimeInHoursConditionValueExtracter(ctype);
-            case TimeCycle.Daily:
+            case TimeUnit.Days:
                 return new TimeInDaysConditionValueExtracter(ctype);
-            case TimeCycle.Weekly:
+            case TimeUnit.Weeks:
                 return new TimeInWeeksConditionValueExtracter(ctype);
-            case TimeCycle.Monthly:
+            case TimeUnit.Months:
                 return new MonthConditionValueExtracter();
             }
             return null;
         }
+
+        public static NamedConditionGroup GetGroupByName(string name) {
+            return groups[name];
+        }
+
+        /// <summary>
+        /// Clear cached flag for all CacheableSceneCondition instances.
+        /// Be ware that CacheableSceneCondition will igonre ISceneParams and return cached result whenever once cashed.
+        /// 
+        /// CacheableSceneConditionは一度結果をキャッシュすると、次からは無条件で前回の結果を返す
+        /// ISceneParamsを更新したらこのメソッドを読んでキャッシュをクリアしないといけない。
+        /// </summary>
+        public static void InvalidateCachedConditions() {
+            CacheableSceneCondition.master_cashetick++;
+        }
+
+        public class NamedConditionGroup : IEnumerable<ISceneCondition> {
+            private readonly string name;
+            private List<string> members;
+
+            internal protected NamedConditionGroup(string group_name) {
+                name = group_name;
+                members = new List<string>();
+            }
+
+            public string Name {
+                get{ return name; }
+            }
+
+            public IEnumerator<ISceneCondition> GetEnumerator() {
+                foreach (string s in members) {
+                    yield return PrimitiveConditions.GetByName(s);
+                }
+            }
+
+            System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() {
+                return this.GetEnumerator();
+            }
+
+            internal protected void Add(ISceneCondition cond) {
+                members.Add(cond.ConditionName);
+            }
+
+            public int Count {
+                get{ return members.Count; }
+            }
+        }
+
     }
 
-    public abstract class ComparebleSceneCondition : ISceneCondition{
+    /// <summary>
+    /// CacheableSceneCondition caches result when IsMatch called first.
+    /// After that it will igonre ISceneParams and return cached result, untill PrimitiveConditions.InvalidateCashedConditions is called.
+    /// 
+    /// CacheableSceneConditionは一度結果をキャッシュすると、次からは無条件で前回の結果を返す
+    /// ISceneParamsを更新したらPrimitiveConditions.InvalidateCachedConditionsを呼んでキャッシュをクリアしないといけない。
+    /// </summary>
+    public abstract class CacheableSceneCondition : ISceneCondition {
+        protected internal static uint master_cashetick = 0;
         protected readonly string name;
-        protected IConditionValueExtracter extracter;
+        protected readonly string grp_name;
+        protected uint cachetick;
+        protected bool cached_result;
 
-        protected ComparebleSceneCondition(string name) {
+        protected CacheableSceneCondition(string groupname, string name) {
+            this.grp_name = groupname;
             this.name = name;
+            this.cachetick = --master_cashetick;
         }
 
-        protected ComparebleSceneCondition(string cname, IConditionValueExtracter cvext) {
-            this.name = cname;
-            this.extracter = cvext;
+        public string GroupName {
+            get {
+                return grp_name;
+            }
         }
-
         public string ConditionName {
             get {
                 return name;
@@ -114,39 +244,89 @@
             }
         }
 
-        public virtual ConditionTypes ConditionType {
+        public abstract ConditionTypes ConditionType { get; }
+
+        public virtual bool IsMatch(ISceneParams p) {
+            if (this.cachetick != master_cashetick) {
+                cached_result = IsMatchCore(p);
+                this.cachetick = master_cashetick;
+            }
+            return cached_result;
+        }
+
+        protected abstract bool IsMatchCore(ISceneParams p);
+
+    }
+
+    public abstract class ComparebleSceneCondition : CacheableSceneCondition, IComparablesCondition {
+        protected IConditionValueExtracter extracter;
+
+        protected ComparebleSceneCondition(string groupname, string name):base(groupname, name) {
+        }
+
+        protected ComparebleSceneCondition(string groupname, string cname, IConditionValueExtracter cvext):base(groupname, cname) {
+            this.extracter = cvext;
+        }
+
+        public override ConditionTypes ConditionType {
             get {
                 return extracter.ConditionType;
             }
         }
 
-        public abstract bool IsMatch(ISceneParams p);
+        #region IComparablesCondition implementation
+        public abstract IComparable From { get;  }
 
+        public virtual IComparable Until {
+            get {
+                return null;
+            }
+        }
+        #endregion
     }
 
     public class EqualityCondition : ComparebleSceneCondition {
         protected IComparable match;
-        public EqualityCondition(string name, IConditionValueExtracter ext, IComparable v) : base(name, ext){
+        public EqualityCondition(string groupname, string name, IConditionValueExtracter ext, IComparable v)
+            : base(groupname, name, ext) {
             this.match = v;
         }
 
-        public override bool IsMatch(ISceneParams p) {
+        protected override bool IsMatchCore(ISceneParams p) {
             return extracter.GetTestValue(p).CompareTo(match)==0;
         }
+
+        public override IComparable From {
+            get {
+                return match;
+            }
+        }
     }
 
     public class RangeCondition : ComparebleSceneCondition {
-        protected IComparable from, to;
-        public RangeCondition(string name, IConditionValueExtracter ext, IComparable from, IComparable to)
-            : base(name, ext) {
+        protected IComparable from, until;
+        public RangeCondition(string groupname, string name, IConditionValueExtracter ext, IComparable from, IComparable until)
+            : base(groupname, name, ext) {
             this.from = from;
-            this.to = to;                
+            this.until = until;                
         }
 
-        public override bool IsMatch(ISceneParams p) {
+        protected override bool IsMatchCore(ISceneParams p) {
             IComparable v = extracter.GetTestValue(p);
-            return v.CompareTo(from) >= 0 && v.CompareTo(to) <= 0; //from <= v && v <= to;
+            return v.CompareTo(from) >= 0 && v.CompareTo(until) < 0; //from <= v && v < until;
         }
+
+        public override IComparable From {
+            get {
+                return from;
+            }
+        }
+
+        public override IComparable Until {
+            get {
+                return until;
+            }
+        }
     }
 
     /// <summary>
@@ -155,38 +335,43 @@
     /// This condition is given with arguments from=23, to=1.
     /// </summary>
     public class BoudaryRangeCondition : ComparebleSceneCondition {
-        protected IComparable from, to;
-        public BoudaryRangeCondition(string name, IConditionValueExtracter ext, IComparable from, IComparable to)
-            : base(name, ext) {
+        protected IComparable from, until;
+        public BoudaryRangeCondition(string groupname, string name, IConditionValueExtracter ext, IComparable from, IComparable until)
+            : base(groupname, name, ext) {
             this.from = from;
-            this.to = to;
+            this.until = until;
         }
 
-        public override bool IsMatch(ISceneParams p) {
+        protected override bool IsMatchCore(ISceneParams p) {
             IComparable v = extracter.GetTestValue(p);
-            return v.CompareTo(to) <= 0 || v.CompareTo(from) >= 0; //v <= to || from <= v;
+            return v.CompareTo(until) < 0 || v.CompareTo(from) >= 0; //v < until || from <= v;
         }
-    }
 
-    public class WeatherCondition : ISceneCondition {
-        protected Object weather;
-        internal protected WeatherCondition(Object weather) {
-            this.weather = weather;
+        public override IComparable From {
+            get {
+                return from;
+            }
         }
 
-        public string ConditionName {
+        public override IComparable Until {
             get {
-                return weather.ToString();
+                return until;
             }
         }
+    }
 
-        public ConditionTypes ConditionType {
+    public class WeatherCondition : CacheableSceneCondition {
+        protected Object weather;
+        internal protected WeatherCondition(string groupname, Object weather) : base(groupname, weather.ToString()){
+        }
+
+        public override ConditionTypes ConditionType {
             get {
                 return ConditionTypes.Weather;
             }
         }
 
-        public bool IsMatch(ISceneParams p) {
+        protected override bool IsMatchCore(ISceneParams p) {
             return weather.Equals(p.Weather);
         }
     }

--- trunk/core/core/schedule/ConditionValueExtracter.cs	(revision 15)
+++ trunk/core/core/schedule/ConditionValueExtracter.cs	(revision 16)
@@ -2,7 +2,7 @@
 using System.Collections.Generic;
 using System.Text;
 using nft.core.view;
-using TimeCycle = nft.core.schedule.Calendar.Cycles;
+using TimeCycle = nft.core.schedule.Calendar.TimeUnit;
 
 namespace nft.core.schedule {
     public interface IConditionValueExtracter {
@@ -37,7 +37,7 @@
         }
 
         public override IComparable GetTestValue(ISceneParams p) {
-            long l1 = Calendar.ActiveCalendar.GetCyclicTicks(p.Time, (TimeCycle)condtype);
+            long l1 = Calendar.ActiveCalendar.GetUnitValue(p.Time, (TimeCycle)condtype);
             return l1;
         }
     }
@@ -48,7 +48,7 @@
         }
 
         public override IComparable GetTestValue(ISceneParams p) {
-            decimal l1 = Calendar.ActiveCalendar.GetCyclicTicks(p.Time, (TimeCycle)condtype);
+            double l1 = Calendar.ActiveCalendar.GetUnitValue(p.Time, (TimeCycle)condtype);
             return (long)Math.Floor(l1 / Time.HOUR);
         }
     }
@@ -59,7 +59,7 @@
         }
 
         public override IComparable GetTestValue(ISceneParams p) {
-            decimal l1 = Calendar.ActiveCalendar.GetCyclicTicks(p.Time, (TimeCycle)condtype);
+            double l1 = Calendar.ActiveCalendar.GetUnitValue(p.Time, (TimeCycle)condtype);
             return (long)Math.Floor(l1 / Time.DAY);
         }
     }
@@ -70,7 +70,7 @@
         }
 
         public override IComparable GetTestValue(ISceneParams p) {
-            decimal l1 = Calendar.ActiveCalendar.GetCyclicTicks(p.Time, (TimeCycle)condtype);
+            double l1 = Calendar.ActiveCalendar.GetUnitValue(p.Time, (TimeCycle)condtype);
             return (long)Math.Floor(l1 / Time.DAY);
         }
     }
@@ -85,6 +85,43 @@
         }
     }
 
+    public class FormattedTimeNumsConditionExtracter : LongConditionValueExtracter {
+        string format;
+        public FormattedTimeNumsConditionExtracter(ConditionTypes ctype, string date_format)
+            : base(ctype) {
+            this.format = date_format;
+        }
+
+        public override IComparable GetTestValue(ISceneParams p) {
+            return long.Parse(p.Time.ToString(format));
+        }
+    }
+
+    public class FormattedTimeStrConditionExtracter : IConditionValueExtracter {
+        string format;
+        ConditionTypes condtype;
+        public FormattedTimeStrConditionExtracter(ConditionTypes ctype, string date_format) {
+            this.condtype = ctype;
+            this.format = date_format;
+        }
+
+        public IComparable GetTestValue(ISceneParams p) {
+            return p.Time.ToString(format);
+        }
+
+        public Type ComparableType {
+            get {
+                return typeof(string);
+            }
+        }
+
+        public ConditionTypes ConditionType {
+            get {
+                return condtype;
+            }
+        }
+    }
+
     public class ScaleConditionValueExtracter : LongConditionValueExtracter {
         public ScaleConditionValueExtracter()
             : base(ConditionTypes.Scale) {

--- trunk/core/core/schedule/Calendar.cs	(revision 15)
+++ trunk/core/core/schedule/Calendar.cs	(revision 16)
@@ -25,8 +25,8 @@
             }
         }
 
-        public enum Cycles {
-            Unknown, Hourly, Daily, Weekly, Monthly, Yearly
+        public enum TimeUnit {
+            Unknown, Ticks, Hours, Days, Weeks, Months, Years
         }
 
         private TimeLength[] condToLength;
@@ -38,7 +38,7 @@
             ActiveCalendar = this;
         }
 
-        public long GetCycleTotalTicks(Cycles cycle) {
+        public long GetTicksForUnit(TimeUnit cycle) {
             TimeLength tl = condToLength[(int)cycle];
             return tl.TotalSeconds;
         }
@@ -48,7 +48,7 @@
         /// <param name="t"></param>
         /// <param name="cycle"></param>
         /// <returns></returns>
-        public long GetCyclicTicks(Time t, Cycles cycle) {
+        public long GetUnitValue(Time t, TimeUnit cycle) {
             TimeLength tl = condToLength[(int)cycle];
             return t.Ticks % tl.TotalSeconds;
         }
@@ -55,20 +55,20 @@
 
         public void LoadSettingFile(ParamsReader reader){
             Debug.WriteLine("Load calender settings from:"+reader.SourceURI);
-            ParamsReader cr = reader["calender"];
+            ParamsReader cr = reader["calendar"];
             ReadNamedConditions(cr["named_conditons"]);   
         }
 
         private void InitCondToLength(ParamsReader reader) {
             if (condToLength == null) {
-                condToLength = new TimeLength[Enum.GetValues(typeof(Cycles)).Length];
+                condToLength = new TimeLength[Enum.GetValues(typeof(TimeUnit)).Length];
             }
             condToLength.Initialize();
-            condToLength[(int)Cycles.Unknown] = new TimeLength(long.MaxValue);
-            condToLength[(int)Cycles.Daily] = TimeLength.FromHours(24);
-            condToLength[(int)Cycles.Weekly] = TimeLength.FromDays(7);
-            condToLength[(int)Cycles.Monthly] = TimeLength.FromHours(24);
-            condToLength[(int)Cycles.Yearly] = TimeLength.FromDays(365);
+            condToLength[(int)TimeUnit.Unknown] = new TimeLength(long.MaxValue);
+            condToLength[(int)TimeUnit.Days] = TimeLength.FromHours(24);
+            condToLength[(int)TimeUnit.Weeks] = TimeLength.FromDays(7);
+            condToLength[(int)TimeUnit.Months] = TimeLength.FromHours(24);
+            condToLength[(int)TimeUnit.Years] = TimeLength.FromDays(365);
         }
 
 
@@ -82,18 +82,34 @@
         }
 
         private void ReadGroup(ParamsReader r) {
+            string grp_name = r["name"].InnerText;
+            string tpnam = r["type"].InnerText;
+            ConditionTypes ctype =(ConditionTypes)Enum.Parse(typeof(ConditionTypes), tpnam, true);
+            string format = r["format"].InnerText;
+            foreach (ParamsReader r2 in r.EnumChildren("assign")) {
+                string cname = r2["name"].InnerText;
+                ParamsReader match = r2["match"];
+                if(match.IsNull){
+                    string v_from = r2["from"].InnerText;
+                    string v_to = r2["to"].InnerText;
+                    PrimitiveConditions.CreateSceneConditionFromDateFormat(grp_name, cname, ctype, format, v_from, v_to );
+                } else {
+                    string v_match = match.InnerText;
+                    PrimitiveConditions.CreateSceneConditionFromDateFormat(grp_name, cname, ctype, format, v_match);
+                }
+            }
         }
 
         private void ReadPredefinedGroup(ParamsReader r) {
             string name = r["name"].InnerText;
-            string tpnam = r["type"].InnerText;
+            string tpnam = r["type"].InnerText.ToLower();
             string culnam = r["culture"].InnerText;
             CultureInfo culture = culnam!=null ? CultureInfo.GetCultureInfo(culnam):CultureInfo.CurrentCulture;
             Type t = typeof(DateTimeFormatInfo);
-            string[] arr = t.InvokeMember(name, BindingFlags.Default, null, culture.DateTimeFormat, null) as string[];
-            if (arr.Length == 7) {
+            string[] arr = t.InvokeMember(name, BindingFlags.InvokeMethod|BindingFlags.GetProperty, null, culture.DateTimeFormat, null) as string[];
+            if ("weekly".Equals(tpnam) && arr.Length >= 7) {
                 PrepareDayOfWeekGroup(arr);
-            } else if (arr.Length == 12) {
+            } else if ("monthly".Equals(tpnam) && arr.Length >= 12) { // なぜか13個の要素がある
                 PrepareMonthGroup(arr);
             } else {
                 Debug.WriteLine("Unknown array: "+name);
@@ -102,13 +118,13 @@
 
         private void PrepareDayOfWeekGroup(string[] arr) {
             for(int i=0; i<arr.Length; i++){
-                PrimitiveConditions.CreateSceneCondition(arr[i], ConditionTypes.Weekly, i, Cycles.Daily);
+                PrimitiveConditions.CreateSceneCondition("DayOfWeekName", arr[i], ConditionTypes.Weekly, i, TimeUnit.Days);
             }
         }
 
         private void PrepareMonthGroup(string[] arr) {
-            for (int i = 0; i < arr.Length; i++) {
-                PrimitiveConditions.CreateSceneCondition(arr[i], ConditionTypes.Yearly, i, Cycles.Monthly);
+            for (int i = 0; i < 12; i++) {
+                PrimitiveConditions.CreateSceneCondition("MonthName", arr[i], ConditionTypes.Yearly, i, TimeUnit.Months);
             }
         }
 

--- trunk/core/module_calendar.xml	(revision 15)
+++ trunk/core/module_calendar.xml	(revision 16)
@@ -18,40 +18,40 @@
     <!--m	分　1桁の分で、先行ゼロが付きません-->
     <!--mm	分　1桁の分で、先行ゼロが付きます-->
     <group name="Season" type="yearly" format="M">
-      <assign name="april" from="3" to="5"/>
-      <assign name="summer" from="6" to="8"/>
-      <assign name="fall" from="9" to="11"/>
-      <assign name="winter" from="12" to="2"/>
+      <assign name="april" from="3" until="6"/>
+      <assign name="summer" from="6" until="9"/>
+      <assign name="fall" from="9" until="12"/>
+      <assign name="winter" from="12" until="3"/>
     </group>
     <group name="DayNight" type="daily" format="H">
-      <assign name="day" from="6" to="18"/>
-      <assign name="night" from="19" to="5"/>
+      <assign name="day" from="6" until="19"/>
+      <assign name="night" from="19" until="6"/>
     </group>
     <group name="TimeOfDay" type="daily" format="H">
-      <assign name="before-dawn" from="3" to="5"/>
+      <assign name="before-dawn" from="3" until="6"/>
       <assign name="sunrise" match="5"/>
-      <assign name="daybreak" from="4" to="5"/>
-      <assign name="dawn" from="5" to="7"/>
-      <assign name="morning" from="7" to="11"/>
-      <assign name="early-morning" from="5" to="7"/>
-      <assign name="late-morning" from="8" to="11"/>
-      <assign name="noon" from="11" to="13"/>
-      <assign name="lunchtime" from="11" to="13"/>
+      <assign name="daybreak" from="4" until="6"/>
+      <assign name="dawn" from="5" until="8"/>
+      <assign name="morning" from="7" until="12"/>
+      <assign name="early-morning" from="5" until="8"/>
+      <assign name="late-morning" from="8" until="12"/>
+      <assign name="noon" from="11" until="14"/>
+      <assign name="lunchtime" from="11" until="14"/>
       <assign name="highnoon" match="12"/>
-      <assign name="afternoon" from="12" to="17"/>
-      <assign name="early-afternoon" from="12" to="14"/>
-      <assign name="late-afternoon" from="15" to="17"/>
+      <assign name="afternoon" from="12" until="18"/>
+      <assign name="early-afternoon" from="12" until="15"/>
+      <assign name="late-afternoon" from="15" until="18"/>
       <assign name="sunset" match="18"/>
-      <assign name="dusk" from="17" to="18"/>
-      <assign name="evening" from="18" to="23"/>
-      <assign name="dinner-time" from="18" to="20"/>
-      <assign name="early-evening" from="18" to="20"/>
-      <assign name="late-evening" from="21" to="23"/>
+      <assign name="dusk" from="17" until="19"/>
+      <assign name="evening" from="18" until="0"/>
+      <assign name="dinner-time" from="18" until="21"/>
+      <assign name="early-evening" from="18" until="21"/>
+      <assign name="late-evening" from="21" until="0"/>
       <assign name="midnight" match="24"/>
-      <assign name="around-midnight" from="23" to="2"/>
-      <assign name="after-midnight" from="0" to="3"/>
-      <assign name="dead-of-night" from="2" to="3"/>
-      <assign name="bedtime" from="23" to="6"/>
+      <assign name="around-midnight" from="23" until="3"/>
+      <assign name="after-midnight" from="0" until="4"/>
+      <assign name="dead-of-night" from="2" until="4"/>
+      <assign name="bedtime" from="23" until="7"/>
     </group>
     <group name="DayOfWeek" type="weekly" format="E">
       <!--DateTimeのAbbreviatedDayNames /DayNames はデフォルトで有効 -->      
@@ -64,8 +64,8 @@
       <assign name="土曜" match="6"/>
     </group>
     <group name="WorkDays" type="weekly" format="E">
-      <assign name="weekdays" from="1" to="5"/>
-      <assign name="weekends" from="6" to="0"/>
+      <assign name="weekdays" from="1" until="6"/>
+      <assign name="weekends" from="6" until="1"/>
     </group>
   </named_conditons>
 </calendar>
\ No newline at end of file

--- trunk/framework/framework/plugin/Plugin.cs	(revision 15)
+++ trunk/framework/framework/plugin/Plugin.cs	(revision 16)
@@ -148,7 +148,7 @@
 
 
         /// <summary>
-        /// Can be used for Cashed data storage of this plug-in. 
+        /// Can be used for Cached data storage of this plug-in. 
         /// Each plug-in has it's isolated sub-directory under the DataDir.
         /// </summary>
         public string DataDirectory {

--- trunk/TestLauncher/test/SomeTest.cs	(revision 15)
+++ trunk/TestLauncher/test/SomeTest.cs	(revision 16)
@@ -10,6 +10,20 @@
 {
     class SomeTest
     {
+        [TestEntry]
+        static private bool TestConverter() {
+            object o;
+            o = Convert.ChangeType("123", typeof(long));
+            Debug.WriteLine(o.ToString() + "<<" + o.GetType().Name);
+            o = Convert.ChangeType(456, typeof(string));
+            Debug.WriteLine(o.ToString() + "<<" + o.GetType().Name);
+            o = Convert.ChangeType("10.82", typeof(float));
+            Debug.WriteLine(o.ToString() + "<<" + o.GetType().Name);
+            o = Convert.ChangeType("5/2", typeof(DateTime));
+            Debug.WriteLine(o.ToString() + "<<" + o.GetType().Name);
+            return true;
+        }
+
         [TestEntry(new object[]{@"C:\test\testsub"})]
         [TestEntry(new object[] { "file://c:/test/testsub" })]
         [TestEntry(new object[] { "http://test.com/test/testsub2" })]