NetStateRule.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.ComponentModel;
using MyCaffe.basecode;
using MyCaffe.common;
using System.Drawing.Design;
using MyCaffe.param.ui;
 
namespace MyCaffe.param
{
    [Serializable]
    [TypeConverter(typeof(ExpandableObjectConverter))]
    public class NetStateRule : BaseParameter, ICloneable, IComparable, IBinaryPersist
    {
        Phase m_phase = Phase.NONE;
        int? m_nMinLevel = null;
        int? m_nMaxLevel = null;
        List<string> m_rgStage = new List<string>();
        List<string> m_rgNotStage = new List<string>();
 
        public NetStateRule()
        {
        }
 
        public NetStateRule(Phase p)
        {
            m_phase = p;
        }
 
        public void Save(BinaryWriter bw)
        {
            bw.Write((int)m_phase);
 
            bw.Write(m_nMinLevel.HasValue);
            if (m_nMinLevel.HasValue)
                bw.Write(m_nMinLevel.Value);
 
            bw.Write(m_nMaxLevel.HasValue);
            if (m_nMaxLevel.HasValue)
                bw.Write(m_nMaxLevel.Value);
 
            Utility.Save<string>(bw, m_rgStage);
            Utility.Save<string>(bw, m_rgNotStage);
        }
 
        public object Load(BinaryReader br, bool bNewInstance)
        {
            NetStateRule p = this;
 
            if (bNewInstance)
                p = new NetStateRule();
 
            p.m_phase = (Phase)br.ReadInt32();
 
            if (br.ReadBoolean())
                p.m_nMinLevel = br.ReadInt32();
 
            if (br.ReadBoolean())
                p.m_nMaxLevel = br.ReadInt32();
 
            p.m_rgStage = Utility.Load<string>(br);
            p.m_rgNotStage = Utility.Load<string>(br);
 
            return p;
        }
 
        [Description("Specifies the phase required to meet this rule.")]
        public Phase phase
        {
            get { return m_phase; }
            set { m_phase = value; }
        }
 
        [Description("Specifies the minimum level in which the layer should be used.")]
        public int? min_level
        {
            get { return m_nMinLevel; }
            set { m_nMinLevel = value; }
        }
 
        [Description("Specifies the maximum level in which the layer should be used.")]
        public int? max_level
        {
            get { return m_nMaxLevel; }
            set { m_nMaxLevel = value; }
        }
 
        [Description("Specifies the stage required to meet this rule.")]
        [Editor(@"System.Windows.Forms.Design.StringCollectionEditor, System.Design, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", typeof(System.Drawing.Design.UITypeEditor))]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        [TypeConverter(typeof(CsvConverter))]
        public List<string> stage
        {
            get { return m_rgStage; }
            set { m_rgStage = value; }
        }
 
        [Description("Specifies the 'not_stage' that cannot be specified to meet this rule.")]
        [Editor(@"System.Windows.Forms.Design.StringCollectionEditor, System.Design, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", typeof(System.Drawing.Design.UITypeEditor))]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        [TypeConverter(typeof(CsvConverter))]
        public List<string> not_stage
        {
            get { return m_rgNotStage; }
            set { m_rgNotStage = value; }
        }
 
        public object Clone()
        {
            NetStateRule ns = new NetStateRule();
 
            ns.m_nMaxLevel = m_nMaxLevel;
            ns.m_nMinLevel = m_nMinLevel;
            ns.m_phase = m_phase;
            ns.m_rgNotStage = Utility.Clone<string>(m_rgNotStage);
            ns.m_rgStage = Utility.Clone<string>(m_rgStage);
 
            return ns;
        }
 
        public override RawProto ToProto(string strName)
        {
            RawProtoCollection rgChildren = new RawProtoCollection();
 
            rgChildren.Add("phase", phase.ToString());
 
            if (min_level.HasValue)
                rgChildren.Add("min_level", min_level);
 
            if (max_level.HasValue)
                rgChildren.Add("max_level", max_level);
 
            if (stage.Count > 0)
                rgChildren.Add<string>("stage", stage);
 
            if (not_stage.Count > 0)
                rgChildren.Add<string>("not_stage", not_stage);
 
            return new RawProto(strName, "", rgChildren);
        }
 
        public static NetStateRule FromProto(RawProto rp)
        {
            string strVal;
            NetStateRule p = new NetStateRule();
 
            if ((strVal = rp.FindValue("phase")) != null)
            {
                switch (strVal)
                {
                    case "TEST":
                        p.phase = Phase.TEST;
                        break;
 
                    case "TRAIN":
                        p.phase = Phase.TRAIN;
                        break;
 
                    case "RUN":
                        p.phase = Phase.RUN;
                        break;
 
                    case "NONE":
                        p.phase = Phase.NONE;
                        break;
 
                    case "ALL":
                        p.phase = Phase.ALL;
                        break;
 
                    default:
                        throw new Exception("Unknown 'phase' value: " + strVal);
                }
            }
 
            p.min_level = (int?)rp.FindValue("min_level", typeof(int));
            p.max_level = (int?)rp.FindValue("max_level", typeof(int));
            p.stage = rp.FindArray<string>("stage");
            p.not_stage = rp.FindArray<string>("not_stage");
 
            return p;
        }
 
        public int CompareTo(object obj)
        {
            NetStateRule nsr = obj as NetStateRule;
 
            if (nsr == null)
                return 1;
 
            if (!Compare(nsr))
                return 1;
 
            return 0;
        }
    }
}