GETSAMPLE_OBJ_INTERFACE.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using FObjBase;
using FLY.Thick.Base.Common;

namespace FLY.Thick.Base.OBJ_INTERFACE
{
    public class GETSAMPLE_OBJ_INTERFACE
    {
        #region Pack
        public class Pack_Params_SampleCell
        {
            public bool enable;
            public bool justForCheck;
            public int orgad;
            public int position;

            #region IPack 成员


            public byte[] ToBytes()
            {
                List<byte> buf = new List<byte>();
                
                buf.AddRange(BitConverter.GetBytes(enable));
                buf.AddRange(BitConverter.GetBytes(justForCheck));
                buf.AddRange(BitConverter.GetBytes(orgad));
                buf.AddRange(BitConverter.GetBytes(position));
                return buf.ToArray();
            }
            /// <summary>
            /// 返回由字节数组中指定位置的10个字节转换来的数据。
            /// </summary>
            /// <param name="value"></param>
            /// <returns></returns>
            public bool TryParse(byte[] value, int startIndex) 
            {
                if ((value.Length-startIndex) < (1*2+4*2))
                    return false;
                int idx = startIndex;
                enable = BitConverter.ToBoolean(value, idx);
                idx += 1;
                justForCheck = BitConverter.ToBoolean(value, idx);
                idx += 1;

                orgad = BitConverter.ToInt32(value, idx);
                idx += 4;
                position = BitConverter.ToInt32(value, idx);
                idx += 4;
                return true;
            }

            #endregion
        }
        public class Pack_Params_SampleFeature
        {
            public bool enable;
            public int startpos;
            public int endpos;

            #region IPack 成员

            public byte[] ToBytes()
            {
                List<byte> buf = new List<byte>();

                buf.AddRange(BitConverter.GetBytes(enable));
                buf.AddRange(BitConverter.GetBytes(startpos));
                buf.AddRange(BitConverter.GetBytes(endpos));

                return buf.ToArray();
            }

            /// <summary>
            /// 返回由字节数组中指定位置的9个字节转换来的数据。
            /// </summary>
            /// <param name="value"></param>
            /// <returns></returns>
            public bool TryParse(byte[] value, int startIndex)
            {
                if ((value.Length - startIndex) < 9)
                    return false;
                int idx = startIndex;
                enable = BitConverter.ToBoolean(value, idx);
                idx += 1;
                startpos = BitConverter.ToInt32(value, idx);
                idx += 4;
                endpos = BitConverter.ToInt32(value, idx);
                idx += 4;

                return true;
            }
            #endregion
        }
        public class Pack_Params : IPack
        {
            public bool enable;
            public int interval;
            public UInt32 velocity;
            public int range;
            public int window;
            public Pack_Params_SampleCell[] samples;
            public int search;
            public Pack_Params_SampleFeature[] features;

            #region IPack 成员

            public byte[] ToBytes()
            {
                List<byte> buf = new List<byte>();
                buf.AddRange(BitConverter.GetBytes(enable));
                buf.AddRange(BitConverter.GetBytes(interval));
                buf.AddRange(BitConverter.GetBytes(velocity));
                buf.AddRange(BitConverter.GetBytes(range));
                buf.AddRange(BitConverter.GetBytes(window));
                buf.AddRange(BitConverter.GetBytes(search));

                buf.AddRange(BitConverter.GetBytes(samples.Length));

                foreach (Pack_Params_SampleCell p in samples)
                {
                    buf.AddRange(p.ToBytes());
                }

                buf.AddRange(BitConverter.GetBytes(features.Length));

                foreach (Pack_Params_SampleFeature p in features)
                {
                    buf.AddRange(p.ToBytes());
                }
                return buf.ToArray();
            }

            public bool TryParse(byte[] value)
            {
                int cnt = 1 + 4 * 4 +4 + 4 + 4;
                if (value.Length < cnt)
                    return false;
                int idx = 0;
                enable = BitConverter.ToBoolean(value, idx);
                idx++;
                interval = BitConverter.ToInt32(value, idx);
                idx += 4;
                velocity = BitConverter.ToUInt32(value, idx);
                idx += 4;
                range = BitConverter.ToInt32(value, idx);
                idx += 4;
                window = BitConverter.ToInt32(value, idx);
                idx += 4;


                search = BitConverter.ToInt32(value, idx);
                idx += 4;

                int len = BitConverter.ToInt32(value, idx);
                idx += 4;
                cnt += len * 10;
                if (value.Length < cnt)
                    return false;

                samples = new Pack_Params_SampleCell[len];

                for (int i = 0; i < len; i++)
                {
                    samples[i] = new Pack_Params_SampleCell();
                    samples[i].TryParse(value, idx);
                    idx += 10;
                }

                len = BitConverter.ToInt32(value, idx);
                idx += 4;
                cnt += len * 9;
                if (value.Length < cnt)
                    return false;

                features = new Pack_Params_SampleFeature[len];
                for (int i = 0; i < len; i++)
                {
                    features[i] = new Pack_Params_SampleFeature();
                    features[i].TryParse(value, idx);
                    idx += 9;
                }

                return true;
            }

            #endregion
        }
        public class Pack_State_SampleCell
        {
            public int ad;
            public int value;

            #region IPack 成员


            public byte[] ToBytes()
            {
                List<byte> buf = new List<byte>();

                buf.AddRange(BitConverter.GetBytes(ad));
                buf.AddRange(BitConverter.GetBytes(value));
                return buf.ToArray();
            }
            /// <summary>
            /// 返回由字节数组中指定位置的8个字节转换来的数据。
            /// </summary>
            /// <param name="value"></param>
            /// <returns></returns>
            public bool TryParse(byte[] value, int startIndex, out int cnt)
            {
                cnt = 8;
                if ((value.Length - startIndex) < cnt)
                    return false;
                int idx = startIndex;
                ad = BitConverter.ToInt32(value, idx);
                idx += 4;
                this.value = BitConverter.ToInt32(value, idx);
                idx += 4;
                return true;
            }
            #endregion
        }
        public class Pack_State_SampleFeature
        {
            public double maxRelevancy;
            public int maxOffset;
            public int[] scanData;

            #region IPack 成员

            public byte[] ToBytes()
            {
                List<byte> buf = new List<byte>();

                buf.AddRange(BitConverter.GetBytes(maxRelevancy));
                buf.AddRange(BitConverter.GetBytes(maxOffset));
                if (scanData == null)
                {
                    buf.AddRange(BitConverter.GetBytes(0));
                }
                else
                {
                    buf.AddRange(BitConverter.GetBytes(scanData.Length));
                    for (int i = 0; i < scanData.Length; i++)
                    {
                        buf.AddRange(BitConverter.GetBytes(scanData[i]));
                    }
                }
                return buf.ToArray();
            }


            /// <summary>
            /// 返回由字节数组中指定位置的16个字节以上转换来的数据。
            /// </summary>
            /// <param name="value"></param>
            /// <returns></returns>
            public bool TryParse(byte[] value, int startIndex, out int cnt)
            {
                cnt = 8 + 4 + 4;
                if ((value.Length-startIndex) < cnt)
                    return false;
                int idx = startIndex;
                maxRelevancy = BitConverter.ToDouble(value, idx);
                idx += 8;
                maxOffset = BitConverter.ToInt32(value, idx);
                idx += 4;
                int len = BitConverter.ToInt32(value, idx);
                idx += 4;
                cnt += len * 4;
                if ((value.Length - startIndex) < cnt)
                    return false;
                if (len > 0)
                {
                    scanData = new int[len];
                    for (int i = 0; i < len; i++)
                    {
                        scanData[i] = BitConverter.ToInt32(value, idx);
                        idx += 4;
                    }
                }
                else 
                {
                    scanData = null;
                }
                return true;
            }
            #endregion
        }
        public class Pack_State 
        {
            public int posOfGrid;
            public Pack_State_SampleCell[] samples;
            public Pack_State_SampleFeature[] features;


            #region IPack 成员

            public byte[] ToBytes()
            {
                List<byte> buf = new List<byte>();

                buf.AddRange(BitConverter.GetBytes(posOfGrid));
                buf.AddRange(BitConverter.GetBytes(samples.Length));
                for (int i = 0; i < samples.Length; i++)
                {
                    buf.AddRange(samples[i].ToBytes());
                }
                buf.AddRange(BitConverter.GetBytes(features.Length));
                for (int i = 0; i < features.Length; i++)
                {
                    buf.AddRange(features[i].ToBytes());
                }

                return buf.ToArray();
            }


            /// <summary>
            /// 返回由字节数组中指定位置转换来的数据。
            /// </summary>
            /// <param name="value"></param>
            /// <returns></returns>
            public bool TryParse(byte[] value)
            {
                int startIndex = 0;
                int cnt = 4 + 4 + 4;
                if ((value.Length - startIndex) < cnt)
                    return false;
                int idx = startIndex;
                posOfGrid = BitConverter.ToInt32(value, idx);
                idx += 4;

                int len = BitConverter.ToInt32(value, idx);
                idx += 4;

                samples = new Pack_State_SampleCell[len];
                for (int i = 0; i < len; i++)
                {
                    samples[i] = new Pack_State_SampleCell();
                    int c;
                    if (!samples[i].TryParse(value, idx, out c))
                        return false;

                    idx += c;
                    cnt += c;
                }

                len = BitConverter.ToInt32(value, idx);
                idx += 4;

                features = new Pack_State_SampleFeature[len];
                for (int i = 0; i < len; i++)
                {
                    features[i] = new Pack_State_SampleFeature();
                    int c;
                    if (!features[i].TryParse(value, idx, out c))
                        return false;

                    idx += c;
                    cnt += c;
                }
                return true;
            }
            #endregion
        }
        #endregion

        #region GetValue
        /// <summary>
        /// Pack_Params
        /// </summary>
        public const UInt16 GET_PARAMS = 0;
        public const UInt16 GET_STATE = 1;
        #endregion
        #region SetValue
        /// <summary>
        /// Pack_Params
        /// </summary>
        public const UInt16 SET_PARAMS = 0;
        #endregion
        #region PushMsg
        /// <summary>
        /// Pack_Params
        /// </summary>
        public const UInt16 PUSH_PARAMS = 0;
        public const UInt16 PUSH_STATE = 1;
        #endregion
    }
}