Example #1
0
        internal Subfield(Subfield subfield)
        {
            if (subfield == null)
            {
                this.name       = "unknown";
                this.type       = 0;
                this.scale      = 1f;
                this.offset     = 0f;
                this.units      = "";
                this.maps       = new List <SubfieldMap>();
                this.components = new List <FieldComponent>();
                return;
            }

            this.name   = subfield.name;
            this.type   = subfield.type;
            this.scale  = subfield.scale;
            this.offset = subfield.offset;
            this.units  = subfield.units;

            this.maps = new List <SubfieldMap>();
            foreach (SubfieldMap map in subfield.maps)
            {
                this.maps.Add(new SubfieldMap(map));
            }
            this.components = new List <FieldComponent>();
            foreach (FieldComponent comp in subfield.components)
            {
                this.components.Add(new FieldComponent(comp));
            }
        }
Example #2
0
        internal Subfield(Subfield subfield)
        {
            if (subfield == null)
             {
            this.name = "unknown";
            this.type = 0;
            this.scale = 1f;
            this.offset = 0f;
            this.units = "";
            this.maps = new List<SubfieldMap>();
            return;
             }

             this.name = subfield.name;
             this.type = subfield.type;
             this.scale = subfield.scale;
             this.offset = subfield.offset;
             this.units = subfield.units;

             this.maps = new List<SubfieldMap>();
             foreach (SubfieldMap map in subfield.maps)
             {
            this.maps.Add(new SubfieldMap(map));
             }
        }
Example #3
0
        public void SetFieldValue(byte fieldNum, int fieldArrayIndex, Object value, String subfieldName)
        {
            Field    testField = new Field(this.GetField(fieldNum));
            Subfield subfield  = testField.GetSubfield(subfieldName);

            if ((subfield != null) && !(subfield.CanMesgSupport(this)))
            {
                return;
            }

            Field field = GetField(fieldNum);

            if (field == null)
            {
                // We normally won't have fields attached to our skeleton message,
                // as we add values we need to add the fields too based on the mesg,field
                // combo in the profile.
                field = new Field(Profile.GetMesg(this.Num).GetField(fieldNum));
                if (field.Num == Fit.FieldNumInvalid)
                {
                    // If there was no info in the profile our FieldNum will get set to invalid,
                    // at least preserve FieldNum while we know it
                    field.Num = fieldNum;
                }
                SetField(field);
            }
            field.SetValue(fieldArrayIndex, value, subfieldName);
        }
Example #4
0
        public object GetFieldValue(byte fieldNum, int fieldArrayIndex, ushort subFieldIndex)
        {
            Field field = GetField(fieldNum);

            if (field == null)
            {
                return(null);
            }

            if (subFieldIndex == Fit.SubfieldIndexActiveSubfield)
            {
                return(field.GetValue(fieldArrayIndex, GetActiveSubFieldIndex(fieldNum)));
            }
            else
            {
                Subfield subfield = field.GetSubfield(subFieldIndex);

                if ((subfield == null) || (subfield.CanMesgSupport(this)))
                {
                    return(field.GetValue(fieldArrayIndex, subFieldIndex));
                }
                else
                {
                    return(null);
                }
            }
        }
Example #5
0
        public int GetNumFieldValues(byte fieldNum, ushort subfieldIndex)
        {
            Field field = GetField(fieldNum);

            if (field == null)
            {
                return(0);
            }

            if (subfieldIndex == Fit.SubfieldIndexActiveSubfield)
            {
                return(field.GetNumValues());
            }

            Subfield subfield = field.GetSubfield(subfieldIndex);

            if ((subfield == null) || (subfield.CanMesgSupport(this)))
            {
                return(field.GetNumValues());
            }
            else
            {
                return(0);
            }
        }
Example #6
0
        internal bool IsSigned(Subfield subfield)
        {
            byte type = subfield == null ? Type : subfield.Type;

            type &= Fit.BaseTypeNumMask;
            return(Fit.BaseType[type].isSigned);
        }
Example #7
0
        public object GetValue(int index, Subfield subfield)
        {
            float scale, offset;

            if (index >= values.Count || index < 0)
            {
                return(null);
            }

            if (subfield == null)
            {
                scale  = this.Scale;
                offset = this.Offset;
            }
            else
            {
                scale  = subfield.Scale;
                offset = subfield.Offset;
            }

            object value = values[index];

            if (IsNumeric())
            {
                if (scale != 1.0 || Offset != 0.0)
                {
                    value = Convert.ToSingle(value);
                    value = (float)value / scale - offset;
                }
            }
            return(value);
        }
Example #8
0
 private string GetName(Subfield subfield)
 {
     if (subfield == null)
     {
         return(name);
     }
     else
     {
         return(subfield.Name);
     }
 }
Example #9
0
 private string GetUnits(Subfield subfield)
 {
     if (subfield == null)
     {
         return(units);
     }
     else
     {
         return(subfield.Units);
     }
 }
Example #10
0
 internal bool IsSigned(Subfield subfield)
 {
     if (subfield == null)
     {
         return(Fit.BaseType[Type & Fit.BaseTypeNumMask].isSigned);
     }
     else
     {
         return(Fit.BaseType[subfield.Type & Fit.BaseTypeNumMask].isSigned);
     }
 }
Example #11
0
 private byte GetType(Subfield subfield)
 {
     if (subfield == null)
     {
         return(type);
     }
     else
     {
         return(subfield.Type);
     }
 }
Example #12
0
        public void SetFieldValue(String name, int fieldArrayIndex, Object value)
        {
            Field    testField = new Field(this.GetField(name));
            Subfield subfield  = testField.GetSubfield(name);

            if ((subfield != null) && !(subfield.CanMessageSupport(this)))
            {
                return;
            }

            Field field = GetField(name, false);

            if (field == null)
            {
                field = new Field(Profile.GetMessage(this.MessageNumber).GetField(name));
                SetField(field);
            }

            field.SetValue(fieldArrayIndex, value, name);
        }
Example #13
0
        public object GetFieldValue(string name, int fieldArrayIndex)
        {
            Field field = GetField(name, false);

            if (field == null)
            {
                return(null);
            }

            Subfield subfield = field.GetSubfield(name);

            if ((subfield == null) || (subfield.CanMessageSupport(this)))
            {
                return(field.GetValue(fieldArrayIndex, name));
            }
            else
            {
                return(null);
            }
        }
Example #14
0
        public object GetFieldValue(byte fieldNum, int fieldArrayIndex, string subfieldName)
        {
            Field field = GetField(fieldNum);

            if (field == null)
            {
                return(null);
            }

            Subfield subfield = field.GetSubfield(subfieldName);

            if ((subfield == null) || (subfield.CanMessageSupport(this)))
            {
                return(field.GetValue(fieldArrayIndex, subfieldName));
            }
            else
            {
                return(null);
            }
        }
Example #15
0
        public int GetNumFieldValues(byte fieldNum, string subfieldName)
        {
            Field field = GetField(fieldNum);

            if (field == null)
            {
                return(0);
            }

            Subfield subfield = field.GetSubfield(subfieldName);

            if ((subfield == null) || (subfield.CanMessageSupport(this)))
            {
                return(field.GetNumValues());
            }
            else
            {
                return(0);
            }
        }
Example #16
0
 private byte GetType(Subfield subfield)
 {
     return(subfield == null ? Type : subfield.Type);
 }
Example #17
0
 internal bool IsSigned(Subfield subfield)
 {
     if (subfield == null)
      {
     return Fit.BaseType[Type & Fit.BaseTypeNumMask].isSigned;
      }
      else
      {
     return Fit.BaseType[subfield.Type & Fit.BaseTypeNumMask].isSigned;
      }
 }
Example #18
0
        public void SetValue(int index, object value, Subfield subfield)
        {
            double scale, offset;

            while (index >= GetNumValues())
            {
                // Add placeholders of the correct type so GetSize() will
                // still compute correctly
                switch (Type & Fit.BaseTypeNumMask)
                {
                case Fit.Enum:
                case Fit.Byte:
                case Fit.UInt8:
                case Fit.UInt8z:
                    values.Add(new byte());
                    break;

                case Fit.SInt8:
                    values.Add(new sbyte());
                    break;

                case Fit.SInt16:
                    values.Add(new short());
                    break;

                case Fit.UInt16:
                case Fit.UInt16z:
                    values.Add(new ushort());
                    break;

                case Fit.SInt32:
                    values.Add(new int());
                    break;

                case Fit.UInt32:
                case Fit.UInt32z:
                    values.Add(new uint());
                    break;

                case Fit.SInt64:
                    values.Add(new long());
                    break;

                case Fit.UInt64:
                case Fit.UInt64z:
                    values.Add(new ulong());
                    break;

                case Fit.Float32:
                    values.Add(new float());
                    break;

                case Fit.Float64:
                    values.Add(new double());
                    break;

                case Fit.String:
                    values.Add(new byte[0]);
                    break;

                default:
                    break;
                }
            }

            if (subfield == null)
            {
                scale  = Scale;
                offset = Offset;
            }
            else
            {
                scale  = subfield.Scale;
                offset = Offset;
            }

            // Cast to long as scale and offset only apply to integer based types
            // and we want to make sure we have maximum precision.
            long invalidValue = 0;
            long castedValue  = 0;

            if (IsNumeric())
            {
                // Cast to long as scale and offset only apply to integer based types
                // and we want to make sure we have maximum precision.
                invalidValue = (long)Convert.ToDouble(Fit.BaseType[Type & Fit.BaseTypeNumMask].invalidValue);
                castedValue  = (long)Convert.ToDouble(value);

                // If the field is numeric, check if the value is less than the base
                // type's invalid value. For "z" base types where 0 is invalid, check
                // that the value is > 0. Apply scale and offset if valid.
                if ((castedValue < invalidValue) ||
                    ((invalidValue == 0) && (castedValue > 0)))
                {
                    if (scale != 1.0 || Offset != 0.0)
                    {
                        value = Convert.ToSingle(value);
                        value = ((float)value + offset) * scale;
                    }
                }
            }

            // Must convert value back to the base type, if there was a scale or offset it will
            // have been converted to float.  Caller also may have passed in an unexpected type.
            bool success = false;

            switch (Type & Fit.BaseTypeNumMask)
            {
            case Fit.Enum:
            case Fit.Byte:
            case Fit.UInt8:
            case Fit.UInt8z:
                if ((Convert.ToDouble(value) >= byte.MinValue) && (Convert.ToDouble(value) <= byte.MaxValue))
                {
                    value   = Convert.ToByte(value);
                    success = true;
                }
                break;

            case Fit.SInt8:
                if ((Convert.ToDouble(value) >= sbyte.MinValue) && (Convert.ToDouble(value) <= sbyte.MaxValue))
                {
                    value   = Convert.ToSByte(value);
                    success = true;
                }
                break;

            case Fit.SInt16:
                if ((Convert.ToDouble(value) >= short.MinValue) && (Convert.ToDouble(value) <= short.MaxValue))
                {
                    value   = Convert.ToInt16(value);
                    success = true;
                }
                break;

            case Fit.UInt16:
            case Fit.UInt16z:
                if ((Convert.ToDouble(value) >= ushort.MinValue) && (Convert.ToDouble(value) <= ushort.MaxValue))
                {
                    value   = Convert.ToUInt16(value);
                    success = true;
                }
                break;

            case Fit.SInt32:
                if ((Convert.ToDouble(value) >= int.MinValue) && (Convert.ToDouble(value) <= int.MaxValue))
                {
                    value   = Convert.ToInt32(value);
                    success = true;
                }
                break;

            case Fit.UInt32:
            case Fit.UInt32z:
                if ((Convert.ToDouble(value) >= uint.MinValue) && (Convert.ToDouble(value) <= uint.MaxValue))
                {
                    value   = Convert.ToUInt32(value);
                    success = true;
                }
                break;

            case Fit.SInt64:
                value   = Convert.ToInt64(value);
                success = true;
                break;

            case Fit.UInt64:
            case Fit.UInt64z:
                value   = Convert.ToUInt64(value);
                success = true;
                break;

            case Fit.Float32:
                if ((Convert.ToDouble(value) >= float.MinValue) && (Convert.ToDouble(value) <= float.MaxValue))
                {
                    value   = Convert.ToSingle(value);
                    success = true;
                }
                break;

            case Fit.Float64:
                if (((double)value >= double.MinValue) && ((double)value <= double.MaxValue))
                {
                    value   = Convert.ToDouble(value);
                    success = true;
                }
                break;

            case Fit.String:
                success = true;
                break;

            default:
                break;
            }

            // If the conversion failed, set the value to invalid
            if (success == false)
            {
                value = Fit.BaseType[Type & Fit.BaseTypeNumMask].invalidValue;
            }
            values[index] = value;
        }
Example #19
0
        public object GetValue(int index, Subfield subfield)
        {
            float scale, offset;

             if (index >= values.Count || index < 0)
             {
            return null;
             }

             if (subfield == null)
             {
            scale = this.Scale;
            offset = this.Offset;
             }
             else
             {
            scale = subfield.Scale;
            offset = subfield.Offset;
             }

             object value = values[index];
             if (IsNumeric())
             {
            if (scale != 1.0 || Offset != 0.0)
            {
               value = Convert.ToSingle(value);
               value = (float)value / scale - offset;
            }
             }
             return value;
        }
Example #20
0
 private string GetUnits(Subfield subfield)
 {
     if (subfield == null)
      {
     return units;
      }
      else
      {
     return subfield.Units;
      }
 }
Example #21
0
 private byte GetType(Subfield subfield)
 {
     if (subfield == null)
      {
     return type;
      }
      else
      {
     return subfield.Type;
      }
 }
Example #22
0
 private string GetName(Subfield subfield)
 {
     if (subfield == null)
      {
     return name;
      }
      else
      {
     return subfield.Name;
      }
 }
Example #23
0
 private string GetUnits(Subfield subfield)
 {
     return(subfield == null ? Units : subfield.Units);
 }
Example #24
0
        public object GetValue(int index, Subfield subfield)
        {
            double scale, offset;

            if (index >= values.Count || index < 0)
            {
                return(null);
            }

            if (subfield == null)
            {
                scale  = Scale;
                offset = Offset;
            }
            else
            {
                scale  = subfield.Scale;
                offset = subfield.Offset;
            }

            object value;
            bool   castToFloat = false;

            switch (Type & Fit.BaseTypeNumMask)
            {
            case Fit.Enum:
            case Fit.Byte:
            case Fit.UInt8:
            case Fit.UInt8z:
                value = Convert.ToByte(values[index]);
                if (((byte)value == (byte)Fit.BaseType[Type & Fit.BaseTypeNumMask].invalidValue) &&
                    (scale != 1.0))
                {
                    castToFloat = true;
                }
                break;

            case Fit.SInt8:
                value = Convert.ToSByte(values[index]);
                if (((sbyte)value == (sbyte)Fit.BaseType[Type & Fit.BaseTypeNumMask].invalidValue) &&
                    (scale != 1.0))
                {
                    castToFloat = true;
                }
                break;

            case Fit.SInt16:
                value = Convert.ToInt16(values[index]);
                if (((short)value == (short)Fit.BaseType[Type & Fit.BaseTypeNumMask].invalidValue) &&
                    (scale != 1.0))
                {
                    castToFloat = true;
                }
                break;

            case Fit.UInt16:
            case Fit.UInt16z:
                value = Convert.ToUInt16(values[index]);
                if (((ushort)value == (ushort)Fit.BaseType[Type & Fit.BaseTypeNumMask].invalidValue) &&
                    (scale != 1.0))
                {
                    castToFloat = true;
                }
                break;

            case Fit.SInt32:
                value = Convert.ToInt32(values[index]);
                if (((int)value == (int)Fit.BaseType[Type & Fit.BaseTypeNumMask].invalidValue) &&
                    (scale != 1.0))
                {
                    castToFloat = true;
                }
                break;

            case Fit.UInt32:
            case Fit.UInt32z:
                value = Convert.ToUInt32(values[index]);
                if (((uint)value == (uint)Fit.BaseType[Type & Fit.BaseTypeNumMask].invalidValue) &&
                    (scale != 1.0))
                {
                    castToFloat = true;
                }
                break;

            case Fit.SInt64:
                value = Convert.ToInt64(values[index]);
                if (((long)value == (long)Fit.BaseType[Type & Fit.BaseTypeNumMask].invalidValue) &&
                    (scale != 1.0))
                {
                    castToFloat = true;
                }
                break;

            case Fit.UInt64:
            case Fit.UInt64z:
                value = Convert.ToUInt64(values[index]);
                if (((ulong)value == (ulong)Fit.BaseType[Type & Fit.BaseTypeNumMask].invalidValue) &&
                    (scale != 1.0))
                {
                    castToFloat = true;
                }
                break;

            case Fit.Float32:
                value = Convert.ToSingle(values[index]);
                if (float.IsNaN((float)value) &&
                    (scale != 1.0))
                {
                    castToFloat = true;
                }
                break;

            case Fit.Float64:
                value = Convert.ToDouble(values[index]);
                if (double.IsNaN((double)value) &&
                    (scale != 1.0))
                {
                    castToFloat = true;
                }
                break;

            case Fit.String:
                value = values[index];
                break;

            default:
                value = null;
                break;
            }

            if (castToFloat == true)
            {
                //Cast to Single Precision (float) since its expecting a float value if scale > 1
                value = Convert.ToSingle(value);
                return(value);
            }

            if (IsNumeric())
            {
                if (scale != 1.0 || Offset != 0.0)
                {
                    value = (float)((Convert.ToSingle(value) / scale) - offset);
                }
            }
            return(value);
        }
Example #25
0
        public void SetValue(int index, object value, Subfield subfield)
        {
            double scale, offset;

            while (index >= GetNumValues())
            {
                // Add placeholders of the correct type so GetSize() will
                // still compute correctly
                switch (Type & Fit.BaseTypeNumMask)
                {
                case Fit.Enum:
                case Fit.Byte:
                case Fit.UInt8:
                case Fit.UInt8z:
                    values.Add(new byte());
                    break;

                case Fit.SInt8:
                    values.Add(new sbyte());
                    break;

                case Fit.SInt16:
                    values.Add(new short());
                    break;

                case Fit.UInt16:
                case Fit.UInt16z:
                    values.Add(new ushort());
                    break;

                case Fit.SInt32:
                    values.Add(new int());
                    break;

                case Fit.UInt32:
                case Fit.UInt32z:
                    values.Add(new uint());
                    break;

                case Fit.Float32:
                    values.Add(new float());
                    break;

                case Fit.Float64:
                    values.Add(new double());
                    break;

                case Fit.String:
                    values.Add(new byte[0]);
                    break;

                default:
                    break;
                }
            }

            if (subfield == null)
            {
                scale  = this.Scale;
                offset = this.Offset;
            }
            else
            {
                scale  = subfield.Scale;
                offset = this.Offset;
            }

            if (IsNumeric())
            {
                if (scale != 1.0 || Offset != 0.0)
                {
                    value = Convert.ToSingle(value);
                    value = ((float)value + offset) * scale;
                }
            }
            // Must convert value back to the base type, if there was a scale or offset it will
            // have been converted to float.  Caller also may have passed in an unexpected type.
            try
            {
                switch (Type & Fit.BaseTypeNumMask)
                {
                case Fit.Enum:
                case Fit.Byte:
                case Fit.UInt8:
                case Fit.UInt8z:
                    value = Convert.ToByte(value);
                    break;

                case Fit.SInt8:
                    value = Convert.ToSByte(value);
                    break;

                case Fit.SInt16:
                    value = Convert.ToInt16(value);
                    break;

                case Fit.UInt16:
                case Fit.UInt16z:
                    value = Convert.ToUInt16(value);
                    break;

                case Fit.SInt32:
                    value = Convert.ToInt32(value);
                    break;

                case Fit.UInt32:
                case Fit.UInt32z:
                    value = Convert.ToUInt32(value);
                    break;

                case Fit.Float32:
                    value = Convert.ToSingle(value);
                    break;

                case Fit.Float64:
                    value = Convert.ToDouble(value);
                    break;

                default:
                    break;
                }
            }
            // If an exception happens while converting, set the value to invalid
            catch (Exception)
            {
                value = Fit.BaseType[Type & Fit.BaseTypeNumMask].invalidValue;
            }
            values[index] = value;
        }
Example #26
0
 private string GetName(Subfield subfield)
 {
     return(subfield == null ? Name : subfield.Name);
 }
Example #27
0
        public void SetValue(int index, object value, Subfield subfield)
        {
            float scale, offset;

             while (index >= GetNumValues())
             {
            // Add placeholders of the correct type so GetSize() will
            // still compute correctly
            switch (Type & Fit.BaseTypeNumMask)
            {
               case Fit.Enum:
               case Fit.Byte:
               case Fit.UInt8:
               case Fit.UInt8z:
                  values.Add(new byte());
                  break;

               case Fit.SInt8:
                  values.Add(new sbyte());
                  break;

               case Fit.SInt16:
                  values.Add(new short());
                  break;

               case Fit.UInt16:
               case Fit.UInt16z:
                  values.Add(new ushort());
                  break;

               case Fit.SInt32:
                  values.Add(new int());
                  break;

               case Fit.UInt32:
               case Fit.UInt32z:
                  values.Add(new uint());
                  break;

               case Fit.Float32:
                  values.Add(new float());
                  break;

               case Fit.Float64:
                  values.Add(new double());
                  break;

               case Fit.String:
                  values.Add(new byte[0]);
               break;

               default:
                  break;
            }
             }

             if (subfield == null)
             {
            scale = this.Scale;
            offset = this.Offset;
             }
             else
             {
            scale = subfield.Scale;
            offset = this.Offset;
             }

             if (IsNumeric())
             {
            if (scale != 1.0 || Offset != 0.0)
            {
               value = Convert.ToSingle(value);
               value = ((float)value + offset) * scale;
            }
             }
             // Must convert value back to the base type, if there was a scale or offset it will
             // have been converted to float.  Caller also may have passed in an unexpected type.
             switch (Type & Fit.BaseTypeNumMask)
             {
            case Fit.Enum:
            case Fit.Byte:
            case Fit.UInt8:
            case Fit.UInt8z:
               value = Convert.ToByte(value);
               break;

            case Fit.SInt8:
               value = Convert.ToSByte(value);
               break;

            case Fit.SInt16:
               value = Convert.ToInt16(value);
               break;

            case Fit.UInt16:
            case Fit.UInt16z:
               value = Convert.ToUInt16(value);
               break;

            case Fit.SInt32:
               value = Convert.ToInt32(value);
               break;

            case Fit.UInt32:
            case Fit.UInt32z:
               value = Convert.ToUInt32(value);
               break;

            case Fit.Float32:
               value = Convert.ToSingle(value);
               break;

            case Fit.Float64:
               value = Convert.ToDouble(value);
               break;

            default:
               break;
             }
             values[index] = value;
        }