Example #1
0
 public override void AppendRead(ILGenerator il, MessageField field)
 {
     il.Emit(OpCodes.Ldloc_0);
     il.Emit(OpCodes.Ldarg_1);
     field.AppendReadField(il);
     il.Emit(OpCodes.Call, property.GetSetMethod());
 }
		public override void AppendWrite(ILGenerator generator, MessageField field)
		{
			var done = generator.DefineLabel();
			var tmp = generator.DeclareLocal(typeof(Nullable<>).MakeGenericType(FieldType));

			generator.Emit(OpCodes.Ldloc_0);
			generator.Emit(OpCodes.Call, Property.GetGetMethod());
			generator.Emit(OpCodes.Stloc, tmp.LocalIndex);

			generator.Emit(OpCodes.Ldloca, tmp.LocalIndex);
			generator.Emit(OpCodes.Call, typeof(Nullable<>)
				.MakeGenericType(FieldType)
				.GetProperty("HasValue")
				.GetGetMethod());

			generator.Emit(OpCodes.Brfalse_S, done);

			field.AppendGuard(generator, Property.GetGetMethod(), done);
			field.AppendHeader(generator);

			generator.Emit(OpCodes.Ldloca, tmp.LocalIndex);
			generator.Emit(OpCodes.Call, typeof(Nullable<>)
				.MakeGenericType(FieldType)
				.GetProperty("Value")
				.GetGetMethod());

			field.AppendWriteField(generator);
			generator.Emit(OpCodes.Pop);
			generator.MarkLabel(done);
		}
        public MessageFieldPacked(MessageField parent)
            : base(parent)
        {
            if (!parent.WireType.EqualsAny(WireType.Varint, WireType.Fixed32, WireType.Fixed64))
                throw new NotSupportedException();

            this.parent = parent;
        }
Example #4
0
		public override void AppendRead(ILGenerator generator, MessageField field)
		{
			generator.Emit(OpCodes.Ldloc_0);
			generator.Emit(OpCodes.Ldarg_1);
			field.AppendReadField(generator);

			generator.Emit(OpCodes.Call, Property.GetSetMethod());
		}
Example #5
0
 public override void AppendRead(ILGenerator il, MessageField field)
 {
     il.Emit(OpCodes.Ldloc_0);
     il.Emit(OpCodes.Ldarg_1);
     field.AppendReadField(il);
     il.Emit(OpCodes.Newobj, typeof(Nullable<>).MakeGenericType(FieldType).GetConstructor(new Type[] { FieldType }));
     il.Emit(OpCodes.Call, property.GetSetMethod());
 }
		public MessageFieldPacked(MessageField parent)
			: base(parent)
		{
			if (!parent.WireType.EqualsAny(WireType.Varint, 
				WireType.Fixed32, WireType.Fixed64))
				throw new NotSupportedException(); // TODO: Написать Error.NotSupported

			_parent = parent;
		}
Example #7
0
 public override void AppendWrite(ILGenerator il, MessageField field)
 {
     var loop = new ForEachLoop(il, property);
     AppendMessageHeaderCore(il, loop, field);
     loop.Create(body =>
     {
         field.AppendHeader(il);
         loop.LoadCurrentAs(FieldType);
         field.AppendWriteField(il);
         body.Emit(OpCodes.Pop);
     });
 }
Example #8
0
		public override void AppendWrite(ILGenerator generator, MessageField field)
		{
			var done = generator.DefineLabel();
			field.AppendGuard(generator, Property.GetGetMethod(), done);

			field.AppendHeader(generator);

			generator.Emit(OpCodes.Ldloc_0);
			generator.Emit(OpCodes.Call, Property.GetGetMethod());
			field.AppendWriteField(generator);
			generator.Emit(OpCodes.Pop);
			generator.MarkLabel(done);
		}
Example #9
0
        public override void AppendWrite(ILGenerator il, MessageField field)
        {
            var done = il.DefineLabel();
            field.AppendGuard(il, property.GetGetMethod(), done);

            field.AppendHeader(il);

            il.Emit(OpCodes.Ldloc_0);
            il.Emit(OpCodes.Call, property.GetGetMethod());
            field.AppendWriteField(il);
            il.Emit(OpCodes.Pop);
            il.MarkLabel(done);
        }
Example #10
0
        public override void AppendRead(ILGenerator il, MessageField field)
        {
            var count = il.DeclareLocal(typeof(uint));
            var top = il.DefineLabel();
            var next = il.DefineLabel();

            il.Emit(OpCodes.Br_S, next);
            il.Emit(OpCodes.Nop);
            il.MarkLabel(top);
            il.Emit(OpCodes.Ldloc_0);
            il.Emit(OpCodes.Call, property.GetGetMethod());
            il.Emit(OpCodes.Ldarg_1);
            field.AppendReadField(il);
            il.Emit(OpCodes.Callvirt, addItem);
            il.MarkLabel(next);
            il.Emit(OpCodes.Ldarg_1);
            il.Emit(OpCodes.Call, typeof(MessageReader).GetProperty("EndOfStream").GetGetMethod());
            il.Emit(OpCodes.Brfalse_S, top);
        }
		public override void AppendRead(ILGenerator generator, MessageField field)
		{
			LocalBuilder count = generator.DeclareLocal(typeof(uint));
			Label top = generator.DefineLabel();
			Label next = generator.DefineLabel();

			generator.Emit(OpCodes.Br_S, next);
			generator.Emit(OpCodes.Nop);
			generator.MarkLabel(top);
			generator.Emit(OpCodes.Ldloc_0);
			generator.Emit(OpCodes.Call, Property.GetGetMethod());
			generator.Emit(OpCodes.Ldarg_1);
			field.AppendReadField(generator);
			generator.Emit(OpCodes.Callvirt, AddMethod);
			generator.MarkLabel(next);
			generator.Emit(OpCodes.Ldarg_1);
			generator.Emit(OpCodes.Call, typeof(MessageReader)
				.GetProperty("EndOfStream")
				.GetGetMethod());

			generator.Emit(OpCodes.Brfalse_S, top);
		}
Example #12
0
        private static CodeMemberProperty ToCodeMemberProperty(MessageField messageField, IDictionary <MessageDefinitions.Data.Enum, TypeInfo> typeInfoByEnum)
        {
            CodeMemberProperty codeMemberProperty = new CodeMemberProperty();

            codeMemberProperty.Attributes = MemberAttributes.Public | MemberAttributes.Final;
            codeMemberProperty.Name       = messageField.Name;
            codeMemberProperty.HasGet     = true;

            // Add metadata attribute
            String rawType = GetRawType(messageField);
            CodeAttributeDeclaration metadataAttributeDeclaration = CreateMessageFieldMetadataAttributeDeclaration(messageField.XmlDefinition.Name, rawType, messageField.Units, messageField.Display, messageField.Text);

            codeMemberProperty.CustomAttributes.Add(metadataAttributeDeclaration);

            // Type
            Type type = SystemTypeHelper.GetType(messageField.Type.DataType);
            CodeTypeReference codeTypeReference = GetCodeTypeReference(messageField.Type, type, typeInfoByEnum);

            codeMemberProperty.Type = codeTypeReference;

            string fieldName = GetFieldName(messageField.Name);

            // Getter
            codeMemberProperty.GetStatements.Add(new CodeMethodReturnStatement(
                                                     new CodeFieldReferenceExpression(
                                                         new CodeThisReferenceExpression(), fieldName)));

            // Setter
            codeMemberProperty.SetStatements.Add(new CodeAssignStatement(
                                                     new CodeFieldReferenceExpression(
                                                         new CodeThisReferenceExpression(), fieldName), new CodePropertySetValueReferenceExpression()));

            // Add summary comments
            CodeCommentStatement[] summaryCommentStatements = CodeCommentStatementHelper.GetSummaryCodeCommentStatements(messageField.Text);
            codeMemberProperty.Comments.AddRange(summaryCommentStatements);

            return(codeMemberProperty);
        }
Example #13
0
        private void __OnMessageReceived(object listener, MessageReceivedEventArgs messageReceivedEventArgs)
        {
            try
            {
                Message      message      = messageReceivedEventArgs.Message;
                MessageField messageField = message.GetField(FIELD_NAME);
                string       sHostMsg     = messageField.Value.ToString();
                Dictionary <string, string> oParseMessage = GetParseMessage(sHostMsg);

                string sHostFirstMsgName = (oParseMessage["MSG_NAME"].Contains("_")) ? sHostMsg.Substring(0, oParseMessage["MSG_NAME"].IndexOf('_')) : string.Empty;

                bool bExceptQueueMsg    = _mExceptQueueMessage.Contains(sHostFirstMsgName);//oParseMessage["MSG_NAME"]);
                bool bNoLogSecondaryMsg = _mNoLogSecondaryMessage.Contains(sHostFirstMsgName);

                // Log 먼저 찍고 Event Raise 함.
                //CHECK NEED  SystemLogger.Log(Level.Debug, string.Format(" RECV Start:{0}", oParseMessage["MSG_NAME"]), ToString(), this.Name);
                CLogManager.Instance.Log(new CTIBRVFormat(Catagory.Info, string.Format(" RECV Start:{0}", oParseMessage["MSG_NAME"]), sHostMsg));


                if (!IS_VIRTUAL && !bExceptQueueMsg)
                {
                    sHostMsg = RemoveQueueMessage(sHostMsg, oParseMessage["EQP"], oParseMessage["MSG_NAME"]);
                }

                if (!bNoLogSecondaryMsg || oParseMessage["RTN_CD"] != "0")
                {
                    // System Byte 를 찍기 위해 Log 위치 이동함.
                    //CHECK NEED  SystemLogger.Log(Level.Verbose, GetMessageLog(sHostMsg, false), ToString(), this.Name);
                    RaiseHostMsgReceived(sHostMsg);
                }
                // Event Raise 완료 로그
                //CHECK NEED  SystemLogger.Log(Level.Debug, string.Format(" RECV End :{0}", oParseMessage["MSG_NAME"]), ToString(), this.Name);
            }
            catch (Exception ex)
            {
                //CHECK NEED  SystemLogger.Log(ex);
            }
        }
		protected override void AppendMessageHeaderCore(
			ILGenerator generator, ForEachLoop loop, MessageField field)
		{
			LocalBuilder length = generator.DeclareLocal(typeof(int));
			loop.Create(body => {
				body.Emit(OpCodes.Ldarg_1);
				loop.LoadCurrentAs(FieldType);
				field.AppendFieldLength(generator);
				body.Emit(OpCodes.Ldloc, length.LocalIndex);
				body.Emit(OpCodes.Add);
				body.Emit(OpCodes.Stloc, length.LocalIndex);
			});

			generator.Emit(OpCodes.Ldloc, length.LocalIndex);
			Label done = generator.DefineLabel();
			generator.Emit(OpCodes.Brfalse, done);

			generator.Emit(OpCodes.Ldarg_1);
			generator.Emit(OpCodes.Ldc_I4, MessageTag.AsInt(field.Number, WireType.String));
			generator.Call<MessageWriter>("WriteVarint", typeof(uint));
			generator.Emit(OpCodes.Ldloc, length.LocalIndex);
			generator.Call<MessageWriter>("WriteVarint", typeof(uint)).Pop();
			generator.MarkLabel(done);
		}
Example #15
0
 public static bool GetBoolField(string[] parts, MessageField field)
 {
     return(GetField(parts, field) == "-1");
 }
Example #16
0
 /*
  * EVENT : Clear_Click()
  *
  * DESCRIPTION : this message clears the message field
  * if user clicks clear
  * PARAMETERS : object : sender
  *            : RoutedEventArgs : e
  *
  * RETURNS    : N/A
  */
 private void Clear_Click(object sender, RoutedEventArgs e)
 {
     MessageField.Clear();
 }
Example #17
0
        private int AddToPayload(ref MessageField field, string data, ref Span <byte> payload, int offset)

        {
            byte[] bytes = Encoding.Unicode.GetBytes(data);
            return(AddToPayload(ref field, bytes, ref payload, offset));
        }
Example #18
0
        // Section 3.3.2
        //
        // Set temp to ConcatenationOf(Responserversion, HiResponserversion, Z(6), Time, ClientChallenge, Z(4), ServerName, Z(4))
        // Set NTProofStr to HMAC_MD5(ResponseKeyNT, ConcatenationOf(CHALLENGE_MESSAGE.ServerChallenge, temp))
        // Set NtChallengeResponse to ConcatenationOf(NTProofStr, temp)
        private unsafe int makeNtlm2ChallengeResponse(byte[] lm2Hash, ReadOnlySpan <byte> serverChallenge, Span <byte> clientChallenge, ReadOnlySpan <byte> serverInfo, ref MessageField field, ref Span <byte> payload)
        {
            Debug.Assert(serverChallenge.Length == ChallengeLength);
            Debug.Assert(clientChallenge.Length == ChallengeLength);
            Debug.Assert(lm2Hash.Length == DigestLength);


            Span <byte> blob = payload.Slice(0, sizeof(NtChallengeResponse) + serverInfo.Length);
            Span <NtChallengeResponse> temp = MemoryMarshal.Cast <byte, NtChallengeResponse>(blob.Slice(0, sizeof(NtChallengeResponse)));

            temp[0].HiResponserversion = 1;
            temp[0].Responserversion   = 1;
            temp[0].Time = DateTime.Now.Ticks;

            int offset = (int)Marshal.OffsetOf(typeof(NtChallengeResponse), "ClientChallenge");

            clientChallenge.CopyTo(blob.Slice(offset, ChallengeLength));

            offset += ChallengeLength + 4; // challengeLength + Z4
            serverInfo.CopyTo(blob.Slice(offset));

            // We will prepend server chalenge for purpose of calculating NTProofStr
            // It will be overriten later.
            serverChallenge.CopyTo(blob.Slice(ChallengeLength, ChallengeLength));

            Span <byte> NTProofStr = stackalloc byte[DigestLength];
            HMACMD5     hmac       = new HMACMD5(lm2Hash);
            bool        result     = hmac.TryComputeHash(blob.Slice(ChallengeLength), NTProofStr, out int bytes);

            if (!result || bytes != DigestLength)
            {
                return(0);
            }

            // we created temp part in place where it needs to be.
            // now we need to prepend it with calculated hmac.
            // Write first 16 bytes, overiding challengeLength part.
            NTProofStr.CopyTo(blob);
            SetField(ref field, blob.Length, sizeof(AuthenticateMessage));

            payload = payload.Slice(blob.Length);
            return(blob.Length);
        }
Example #19
0
        public static double?GetDoubleField(string[] parts, MessageField field)
        {
            var str = GetField(parts, field);

            return(str == null ? default : double.Parse(str));
        }
Example #20
0
        private unsafe int GetFieldOffset(MessageField field)
        {
            ReadOnlySpan <byte> span = new ReadOnlySpan <byte>(&field, sizeof(MessageField));

            return(BinaryPrimitives.ReadInt16LittleEndian(span.Slice(4)));
        }
		protected virtual void AppendMessageHeaderCore(ILGenerator generator,
			ForEachLoop loop, MessageField field)
		{
		}
Example #22
0
 public static string GetField(string[] parts, MessageField field)
 {
     return(GetField(parts, (int)field));
 }
Example #23
0
        public static int GetIntField(string[] parts, MessageField field)
        {
            var str = GetField(parts, field);

            return(str == null ? default : int.Parse(str));
        }
Example #24
0
        /// <summary>
        /// Add common GLP message fields.
        /// </summary>
        /// <param name="deviceNamespace"></param>
        /// <param name="listFields"></param>
        /// <returns></returns>
        protected override void InstallMessageFields(MessageNamespace deviceNamespace, List <DeviceFieldProperty> listFields)
        {
            MessageField mf;

            mf = new MessageField("Ignition", "", deviceNamespace, typeof(bool), Franson.Unit.BOOLEAN);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("In1", "", deviceNamespace, typeof(bool), Franson.Unit.BOOLEAN);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("In2", "", deviceNamespace, typeof(bool), Franson.Unit.BOOLEAN);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("In3", "", deviceNamespace, typeof(bool), Franson.Unit.BOOLEAN);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("In4", "", deviceNamespace, typeof(bool), Franson.Unit.BOOLEAN);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("In5", "", deviceNamespace, typeof(bool), Franson.Unit.BOOLEAN);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("In6", "", deviceNamespace, typeof(bool), Franson.Unit.BOOLEAN);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("In7", "", deviceNamespace, typeof(bool), Franson.Unit.BOOLEAN);
            listFields.Add(new DeviceFieldProperty(mf, true));

            mf = new MessageField("Out1", "", deviceNamespace, typeof(bool), Franson.Unit.BOOLEAN);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Out2", "", deviceNamespace, typeof(bool), Franson.Unit.BOOLEAN);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Out3", "", deviceNamespace, typeof(bool), Franson.Unit.BOOLEAN);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Out4", "", deviceNamespace, typeof(bool), Franson.Unit.BOOLEAN);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Out5", "", deviceNamespace, typeof(bool), Franson.Unit.BOOLEAN);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Out6", "", deviceNamespace, typeof(bool), Franson.Unit.BOOLEAN);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Out7", "", deviceNamespace, typeof(bool), Franson.Unit.BOOLEAN);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Out8", "", deviceNamespace, typeof(bool), Franson.Unit.BOOLEAN);
            listFields.Add(new DeviceFieldProperty(mf, true));

            mf = new MessageField("Alarm0", "", deviceNamespace, typeof(bool), Franson.Unit.BOOLEAN);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Alarm1", "", deviceNamespace, typeof(bool), Franson.Unit.BOOLEAN);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Alarm2", "", deviceNamespace, typeof(bool), Franson.Unit.BOOLEAN);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Alarm3", "", deviceNamespace, typeof(bool), Franson.Unit.BOOLEAN);
            listFields.Add(new DeviceFieldProperty(mf, true));

            mf = new MessageField("HarshAcceleration", "", deviceNamespace, typeof(bool), Franson.Unit.BOOLEAN);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("HarshBraking", "", deviceNamespace, typeof(bool), Franson.Unit.BOOLEAN);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("HarshCornering", "", deviceNamespace, typeof(bool), Franson.Unit.BOOLEAN);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Accident", "", deviceNamespace, typeof(bool), Franson.Unit.BOOLEAN);
            listFields.Add(new DeviceFieldProperty(mf, true));


            mf = new MessageField("SatelliteCount", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Fix", "", deviceNamespace, typeof(bool), Franson.Unit.BOOLEAN);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("HDOP", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));

            //parametery 32 bitowe
            mf = new MessageField("Parameter2", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter3", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter4", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter5", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter6", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter7", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter8", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter9", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter10", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter11", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter12", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter13", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter14", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter15", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter16", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter17", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter18", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter19", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter20", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter21", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter22", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter23", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter24", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter25", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter26", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter27", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter28", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter29", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter30", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter31", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter32", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));

            //parametry 8 bitowe
            mf = new MessageField("Parameter64", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter65", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter66", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter67", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter68", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter69", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter70", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter71", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));

            //parametry 16 bitowe
            mf = new MessageField("Parameter128", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter129", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter130", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter131", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter132", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter133", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter134", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter135", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter136", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter137", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter138", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter139", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter140", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter141", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter142", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter143", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter144", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter145", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter146", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter147", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter148", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter149", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter150", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter151", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter152", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter153", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter154", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter155", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter156", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter157", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter158", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter159", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));

            //parametry 64 bitowe
            mf = new MessageField("Parameter194", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter195", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter196", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter197", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));

            mf = new MessageField("Parameter240", "", deviceNamespace, typeof(String), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter241", "", deviceNamespace, typeof(String), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter242", "", deviceNamespace, typeof(String), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter243", "", deviceNamespace, typeof(String), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter244", "", deviceNamespace, typeof(String), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Parameter245", "", deviceNamespace, typeof(String), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));

            mf = new MessageField("OdometerAcc", "", deviceNamespace, typeof(double), Franson.Unit.METER);
            listFields.Add(new DeviceFieldProperty(mf, true));

            mf = new MessageField("Csq", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));

            mf = new MessageField("FirmwareVersion", "", deviceNamespace, typeof(String), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));

            mf = new MessageField("ChatMessage", "Chat text", deviceNamespace, typeof(string), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, false));
            mf = new MessageField("JobAssignmentState", "Job assignment state", deviceNamespace, typeof(string), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, false));


            mf = new MessageField("SavedUnix", "", deviceNamespace, typeof(double), Franson.Unit.NONE);
            listFields.Add(new DeviceFieldProperty(mf, true));
            mf = new MessageField("Historic", "", deviceNamespace, typeof(bool), Franson.Unit.BOOLEAN);
            listFields.Add(new DeviceFieldProperty(mf, true));
        }
Example #25
0
 /// Utility method to get a field (if it exists), create it if it 
 /// doesn't, or replace it if it exists but is the wrong type.
 /// <param name="name"/>
 /// <param name="type">B_*_TYPE of the field to get or create.  
 /// B_ANY_TYPE should not be used.</param>
 /// <returns>The (possibly new, possible pre-existing) 
 /// MessageField object.</returns>
 private MessageField getCreateOrReplaceField(string name, int type)
 {
     ensureFieldTableAllocated();
     MessageField field = (MessageField) _fieldTable[name];
     if (field != null) {
       if (field.typeCode() != type) {
     _fieldTable.Remove(name);
     return getCreateOrReplaceField(name, type);
       }
     }
     else {
       field = new MessageField(type);
       _fieldTable.Add(name, field);
     }
     return field;
 }
Example #26
0
        public static void Parse(Message msg, MessageFields fields,
                                 ref MessageKeyValuePairs KVPairs, out string result)
        {
            foreach (MessageField fld in fields.Fields)
            {
                fld.Skip = false;
            }
            int fldIdx = 0;

            while (fldIdx <= fields.Fields.Count - 1)
            {
                MessageField fld = fields.Fields[fldIdx];

                int repetitions = 1;
                if (!String.IsNullOrEmpty(fld.Repetitions))
                {
                    int  Num;
                    bool isNum = int.TryParse(fld.Repetitions, out Num);
                    if (isNum)
                    {
                        repetitions = Convert.ToInt32(fld.Repetitions);
                    }
                    else
                    {
                        repetitions = Convert.ToInt32(KVPairs.Item(fld.Repetitions));
                    }

                    if (fld.StaticRepetitions)
                    {
                        int nextNonStaticRepField = fldIdx + 1;
                        while (nextNonStaticRepField <= fields.Fields.Count - 1 && fields.Fields[nextNonStaticRepField].StaticRepetitions)
                        {
                            nextNonStaticRepField++;
                        }

                        List <MessageField> dynamicFields = new List <MessageField>();
                        for (int i = fldIdx; i < nextNonStaticRepField; i++)
                        {
                            dynamicFields.Add(fields.Fields[i]);
                        }

                        for (int i = fldIdx; i < nextNonStaticRepField; i++)
                        {
                            fields.Fields.RemoveAt(fldIdx);
                        }

                        int           insertPos = fldIdx;
                        List <string> fieldList = new List <string>();
                        for (int i = 1; i < repetitions; i++)
                        {
                            for (int j = 0; j < dynamicFields.Count - 1; j++)
                            {
                                MessageField newFld = dynamicFields[j].Clone();
                                newFld.Repetitions       = "";
                                newFld.StaticRepetitions = false;
                                if (!fieldList.Contains(newFld.Name))
                                {
                                    fieldList.Add(newFld.Name);
                                }

                                //Save the ORIGINAL field name.
                                newFld.Name = newFld.Name + " #" + i.ToString();


                                if (fieldList.Contains(newFld.DependentField))
                                {
                                    newFld.DependentField = newFld.DependentField + " #" + i.ToString();
                                }

                                if (fieldList.Contains(newFld.DynamicLength))
                                {
                                    newFld.DynamicLength = newFld.DynamicLength + " #" + i.ToString();
                                }

                                fields.Fields.Insert(insertPos, newFld);

                                insertPos++;
                            }
                        }

                        repetitions = 1;

                        fld = fields.Fields[fldIdx];
                    }
                }

                for (int j = 0; j < repetitions; j++)
                {
                    if (((!fld.Skip) &&
                         (!String.IsNullOrEmpty(fld.DependentField) && KVPairs.ContainsKey(fld.DependentField)) &&
                         (fld.DependentValue.Count == 0 || fld.DependentValue.Contains(KVPairs.Item(fld.DependentField)))) ||
                        (String.IsNullOrEmpty(fld.DependentField)) ||
                        (!String.IsNullOrEmpty(fld.DependentField) && !KVPairs.ContainsKey(fld.DependentField) && fld.DependentValue.Count == 0))
                    {
                        string val = "";

                        if (fld.SkipUntilValid)
                        {
                            try
                            {
                                do
                                {
                                    val = msg.MessageData.Substring(msg.CurrentIndex, fld.Length);
                                    if (fld.ValidValues.Contains(val))
                                    {
                                        break;
                                    }
                                    else
                                    {
                                        msg.AdvanceIndex(1);
                                    }
                                }while (fld.ValidValues.Contains(val));
                            }
                            catch (ArgumentOutOfRangeException ex)
                            {
                                if (fld.AllowNotFoundValid)
                                {
                                    val = "";
                                }
                                else
                                {
                                    throw ex;
                                }
                            }
                        }
                        else if (fld.ParseUntilValue != "")
                        {
                            string tempVal = "";
                            do
                            {
                                val = msg.MessageData.Substring(msg.CurrentIndex, 1);
                                if (fld.ParseUntilValue == val)
                                {
                                    msg.DecreaseIndex(1);
                                    break;
                                }
                                else
                                {
                                    tempVal += val;
                                    msg.AdvanceIndex(1);
                                }
                            }while (true);
                            val = tempVal;
                        }
                        else
                        {
                            if (fld.DynamicLength != "")
                            {
                                foreach (MessageField scannedFld in fields.Fields)
                                {
                                    if (scannedFld.Name == fld.DynamicLength)
                                    {
                                        if (scannedFld.MessageFieldType == MessageFieldTypes.Hexadecimal)
                                        {
                                            fld.Length = Convert.ToInt32(KVPairs.Item(fld.DynamicLength), 16);
                                        }
                                        else
                                        {
                                            fld.Length = Convert.ToInt32(KVPairs.Item(fld.DynamicLength));
                                        }
                                    }
                                }
                            }
                            if (fld.Length != 0)
                            {
                                if ((fld.MessageFieldType != MessageFieldTypes.Binary))
                                {
                                    val = msg.MessageData.Substring(msg.CurrentIndex, fld.Length);
                                }
                                else
                                {
                                    val = msg.MessageData.Substring(msg.CurrentIndex, fld.Length * 2);
                                }
                            }
                            else
                            {
                                val = msg.MessageData.Substring(msg.CurrentIndex, msg.CharsLeft());
                            }
                        }
                        if (fld.OptionValues.Count == 0 || fld.OptionValues.Contains(val))
                        {
                            try
                            {
                                if (fld.ValidValues.Count > 0 || !fld.ValidValues.Contains(val))
                                {
                                    Log.Logger.MinorDebug(String.Format("Invalid value detected for field [{0}].", fld.Name));
                                    Log.Logger.MinorDebug(String.Format("Received [{0}] but can be one of [{1}]. ", val, GetCommaSeparetedListWithValues(fld.ValidValues)));
                                    throw new Exception(String.Format("Invalid value [{0}] for field [{1}].", val, fld.Name));
                                }
                                switch (fld.MessageFieldType)
                                {
                                case MessageFieldTypes.Hexadecimal:
                                case MessageFieldTypes.Binary:
                                    if (!Utility.IsHexString(val))
                                    {
                                        Log.Logger.MinorDebug(String.Format("Invalid value detected for field [{0}].", fld.Name));
                                        Log.Logger.MinorDebug(String.Format("Received [{0}] but expected a hexadecimal value.", val));
                                        throw new Exception(String.Format("Invalid value [{0}] for field [{1}].", val, fld.Name));
                                    }
                                    break;

                                case MessageFieldTypes.Numeric:
                                    int  Num;
                                    bool isNum = int.TryParse(fld.Repetitions, out Num);
                                    if (!isNum)
                                    {
                                        Log.Logger.MinorDebug(String.Format("Invalid value detected for field [{0}].", fld.Name));
                                        Log.Logger.MinorDebug(String.Format("Received [{0}] but expected a numeric value.", val));
                                        throw new Exception(String.Format("Invalid value [{0}] for field [{1}].", val, fld.Name));
                                    }
                                    break;
                                }
                            }
                            catch (Exception ex)
                            {
                                if (fld.RejectionCode != "")
                                {
                                    result = fld.RejectionCode;
                                }
                                else
                                {
                                    throw ex;
                                }
                            }

                            if (repetitions == 1)
                            {
                                KVPairs.Add(fld.Name, val);
                            }
                            else
                            {
                                KVPairs.Add(fld.Name + " #" + j.ToString(), val);
                            }

                            if (fld.MessageFieldType != MessageFieldTypes.Binary)
                            {
                                msg.AdvanceIndex(fld.Length);
                            }
                            else
                            {
                                msg.AdvanceIndex(fld.Length * 2);
                            }

                            if (j == repetitions)
                            {
                                fld.Skip = true;
                            }

                            if (fld.DependentField != "")
                            {
                                for (int z = fldIdx + 1; z < fields.Fields.Count - 1; z++)
                                {
                                    if (fields.Fields[z].DependentField == fld.DependentField && fields.Fields[z].ExclusiveDependency)
                                    {
                                        fields.Fields[z].Skip = true;
                                    }
                                }
                            }
                        }
                    }
                    if (msg.CharsLeft() == 0)
                    {
                        break;
                    }
                }
                if (msg.CharsLeft() == 0)
                {
                    break;
                }
                fldIdx += 1;
            }
            result = ErrorCodes.ER_00_NO_ERROR;
        }
        private static void AddPrimitiveReadCodeStatements(CodeStatementCollection codeStatementCollection, string readerParamName, MessageField messageField, CodePropertyReferenceExpression propertyExpression)
        {
            String readMethodName = GetReadMethodName(messageField.Type.DataType);
            CodeAssignStatement propertyAssignStatement = new CodeAssignStatement(propertyExpression,
                                                                                  new CodeMethodInvokeExpression(
                                                                                      new CodeVariableReferenceExpression(readerParamName), readMethodName));

            codeStatementCollection.Add(propertyAssignStatement);
        }
Example #28
0
            /// Makes an independent clone of this field object 
            /// (a bit expensive)
            public override Flattenable cloneFlat()
            {
                MessageField clone = new MessageField(_type);
                System.Array newArray;  // this will be a copy of our data array
                switch(_type)
                  {
                  case B_BOOL_TYPE:    newArray = new bool[_numItems]; break;
                  case B_INT8_TYPE:    newArray = new byte[_numItems];    break;
                  case B_INT16_TYPE:   newArray = new short[_numItems];   break;
                  case B_FLOAT_TYPE:   newArray = new float[_numItems];   break;
                  case B_INT32_TYPE:   newArray = new int[_numItems];     break;
                  case B_INT64_TYPE:   newArray = new long[_numItems];    break;
                  case B_DOUBLE_TYPE:  newArray = new double[_numItems];  break;
                  case B_STRING_TYPE:  newArray = new string[_numItems];  break;
                  case B_POINT_TYPE:   newArray = new Point[_numItems];   break;
                  case B_RECT_TYPE:    newArray = new Rect[_numItems];    break;
                  case B_MESSAGE_TYPE: newArray = new Message[_numItems]; break;
                  default:             newArray = new byte[_numItems][];  break;
                  }

                newArray = (System.Array) _payload.Clone();

                // If the contents of newArray are modifiable, we need to
                // clone the contents also
                switch(_type)
                  {
                  case B_POINT_TYPE:
                {
                  Point [] points = (Point[]) newArray;
                  for (int i=0; i<_numItems; i++)
                points[i] = (Point) points[i].cloneFlat();
                }
                break;

                  case B_RECT_TYPE:
                {
                  Rect [] rects = (Rect[]) newArray;
                  for (int i=0; i<_numItems; i++)
                rects[i] = (Rect) rects[i].cloneFlat();
                }
                break;

                  case B_MESSAGE_TYPE:
                {
                  Message [] messages = (Message[]) newArray;
                  for (int i=0; i<_numItems; i++)
                messages[i] = (Message) messages[i].cloneFlat();
                }
                break;

                  default:
                {
                  if (newArray is byte[][])
                {
                  // Clone the byte arrays, since they are modifiable
                  byte [][] array = (byte[][]) newArray;
                  for (int i=0; i<_numItems; i++)
                {
                  byte [] newBuf = (byte []) array[i].Clone();
                  array[i] = newBuf;
                }
                }
                }
                break;
                  }

                clone.setPayload(newArray, _numItems);
                return clone;
            }
        private static void AddArrayReadCodeStatements(CodeStatementCollection codeStatementCollection, string readerParamName, MessageField messageField, CodePropertyReferenceExpression propertyExpression)
        {
            String readMethodName = GetReadMethodName(messageField.Type.DataType);

            for (int i = 0; i < messageField.Type.ArrayLength; i++)
            {
                CodeArrayIndexerExpression codeArrayIndexerExpression =
                    new CodeArrayIndexerExpression(propertyExpression, new CodePrimitiveExpression(i));

                CodeAssignStatement propertyAssignStatement = new CodeAssignStatement(codeArrayIndexerExpression,
                                                                                      new CodeMethodInvokeExpression(
                                                                                          new CodeVariableReferenceExpression(readerParamName), readMethodName));

                codeStatementCollection.Add(propertyAssignStatement);
            }
        }