NetState.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using MyCaffe.basecode;
using MyCaffe.common;
using System.ComponentModel;
 
namespace MyCaffe.param
{
    [Serializable]
    [TypeConverter(typeof(ExpandableObjectConverter))]
    public class NetState : BaseParameter, ICloneable, IComparable 
    {
        Phase m_phase = Phase.TEST;
        int m_nLevel = 0;
        List<string> m_rgStage = new List<string>();
 
        public NetState()
        {
        }
 
        public void Save(BinaryWriter bw)
        {
            bw.Write((int)m_phase);
            bw.Write(m_nLevel);
            Utility.Save<string>(bw, m_rgStage);
        }
 
        public static NetState Load(BinaryReader br)
        {
            NetState ns = new NetState();
 
            ns.m_phase = (Phase)br.ReadInt32();
            ns.m_nLevel = br.ReadInt32();
            ns.m_rgStage = Utility.Load<string>(br);
 
            return ns;
        }
 
        [Description("Specifies the Phase of the NetState.")]
        public Phase phase
        {
            get { return m_phase; }
            set { m_phase = value; }
        }
 
        [Description("Specifies the level of the NetState.")]
        public int level
        {
            get { return m_nLevel; }
            set { m_nLevel = value; }
        }
 
        [Description("Specifies the stages of the NetState.")]
        public List<string> stage
        {
            get { return m_rgStage; }
            set
            {
                if (value == null)
                    m_rgStage = new List<string>();
                else
                    m_rgStage = value;
            }
        }
 
        public void MergeFrom(NetState ns)
        {
            if (ns == null)
                return;
 
            if (m_phase == Phase.NONE)
                m_phase = ns.phase;
 
            m_nLevel = ns.level;
 
            foreach (string strStage in ns.m_rgStage)
            {
                if (!m_rgStage.Contains(strStage))
                    m_rgStage.Add(strStage);
            }
        }
 
        public NetState Clone()
        {
            NetState ns = new NetState();
 
            ns.m_phase = m_phase;
            ns.m_nLevel = m_nLevel;
            ns.m_rgStage = Utility.Clone<string>(m_rgStage);
 
            return ns;
        }
 
        object ICloneable.Clone()
        {
            return Clone();
        }
 
        public int CompareTo(object obj)
        {
            NetState ns = obj as NetState;
 
            if (obj == null)
                return 1;
 
            if (!Compare(ns))
                return 1;
 
            return 0;
        }
 
        public override RawProto ToProto(string strName)
        {
            RawProtoCollection rgChildren = new RawProtoCollection();
 
            rgChildren.Add("phase", phase.ToString());
            rgChildren.Add("level", level.ToString());
            rgChildren.Add<string>("stage", stage);
 
            return new RawProto(strName, "", rgChildren);
        }
 
        public static NetState FromProto(RawProto rp)
        {
            string strVal;
            NetState p = new NetState();
 
            if ((strVal = rp.FindValue("phase")) != null)
            {
                switch (strVal)
                {
                    case "TEST":
                        p.phase = Phase.TEST;
                        break;
 
                    case "TRAIN":
                        p.phase = Phase.TRAIN;
                        break;
 
                    case "NONE":
                        p.phase = Phase.NONE;
                        break;
 
                    default:
                        throw new Exception("Unknown 'phase' value: " + strVal);
                }
            }
 
            if ((strVal = rp.FindValue("level")) != null)
                p.level = int.Parse(strVal);
 
            p.stage = rp.FindArray<string>("stage");
 
            return p;
        }
    }
}