Ejemplo n.º 1
0
 /// <summary>
 /// Returns a delegate to read the specific column into a boxed 
 /// strongly typed variable
 /// </summary>
 /// <param name="column"></param>
 /// <returns></returns>
 private ByteReaderDelegate GetByteReaderDelegate(FitsTableColumn column)
 {
     // Complex types firts, then scalar and arrays
     if (column.DataType.Type == typeof(String))
     {
         return delegate(BitConverterBase converter, byte[] bytes, int startIndex, int count, out object value)
         {
             value = Encoding.ASCII.GetString(bytes, startIndex, count);
             return count;
         };
     }
     else if (column.DataType.Repeat == 1)
     {
         // Scalars
         if (column.DataType.Type == typeof(Boolean))
         {
             return delegate(BitConverterBase converter, byte[] bytes, int startIndex, int count, out object value)
             {
                 Boolean val;
                 var res = converter.ToBoolean(bytes, startIndex, out val);
                 value = val;
                 return res;
             };
         }
         else if (column.DataType.Type == typeof(SByte))
         {
             return delegate(BitConverterBase converter, byte[] bytes, int startIndex, int count, out object value)
             {
                 SByte val;
                 var res = converter.ToSByte(bytes, startIndex, out val);
                 value = val;
                 return res;
             };
         }
         else if (column.DataType.Type == typeof(Byte))
         {
             return delegate(BitConverterBase converter, byte[] bytes, int startIndex, int count, out object value)
             {
                 Byte val;
                 var res = converter.ToByte(bytes, startIndex, out val);
                 value = val;
                 return res;
             };
         }
         else if (column.DataType.Type == typeof(Char))
         {
             return delegate(BitConverterBase converter, byte[] bytes, int startIndex, int count, out object value)
             {
                 Char val;
                 var res = converter.ToChar(bytes, startIndex, out val);
                 value = val;
                 return res;
             };
         }
         else if (column.DataType.Type == typeof(Int16))
         {
             return delegate(BitConverterBase converter, byte[] bytes, int startIndex, int count, out object value)
             {
                 Int16 val;
                 var res = converter.ToInt16(bytes, startIndex, out val);
                 value = val;
                 return res;
             };
         }
         else if (column.DataType.Type == typeof(UInt16))
         {
             return delegate(BitConverterBase converter, byte[] bytes, int startIndex, int count, out object value)
             {
                 UInt16 val;
                 var res = converter.ToUInt16(bytes, startIndex, out val);
                 value = val;
                 return res;
             };
         }
         else if (column.DataType.Type == typeof(Int32))
         {
             return delegate(BitConverterBase converter, byte[] bytes, int startIndex, int count, out object value)
             {
                 Int32 val;
                 var res = converter.ToInt32(bytes, startIndex, out val);
                 value = val;
                 return res;
             };
         }
         else if (column.DataType.Type == typeof(UInt32))
         {
             return delegate(BitConverterBase converter, byte[] bytes, int startIndex, int count, out object value)
             {
                 UInt32 val;
                 var res = converter.ToUInt32(bytes, startIndex, out val);
                 value = val;
                 return res;
             };
         }
         else if (column.DataType.Type == typeof(Int64))
         {
             return delegate(BitConverterBase converter, byte[] bytes, int startIndex, int count, out object value)
             {
                 Int64 val;
                 var res = converter.ToInt64(bytes, startIndex, out val);
                 value = val;
                 return res;
             };
         }
         else if (column.DataType.Type == typeof(UInt64))
         {
             return delegate(BitConverterBase converter, byte[] bytes, int startIndex, int count, out object value)
             {
                 UInt64 val;
                 var res = converter.ToUInt64(bytes, startIndex, out val);
                 value = val;
                 return res;
             };
         }
         else if (column.DataType.Type == typeof(Single))
         {
             return delegate(BitConverterBase converter, byte[] bytes, int startIndex, int count, out object value)
             {
                 Single val;
                 var res = converter.ToSingle(bytes, startIndex, out val);
                 value = val;
                 return res;
             };
         }
         else if (column.DataType.Type == typeof(Double))
         {
             return delegate(BitConverterBase converter, byte[] bytes, int startIndex, int count, out object value)
             {
                 Double val;
                 var res = converter.ToDouble(bytes, startIndex, out val);
                 value = val;
                 return res;
             };
         }
         else if (column.DataType.Type == typeof(SingleComplex))
         {
             return delegate(BitConverterBase converter, byte[] bytes, int startIndex, int count, out object value)
             {
                 SingleComplex val;
                 var res = converter.ToSingleComplex(bytes, startIndex, out val);
                 value = val;
                 return res;
             };
         }
         else if (column.DataType.Type == typeof(DoubleComplex))
         {
             return delegate(BitConverterBase converter, byte[] bytes, int startIndex, int count, out object value)
             {
                 DoubleComplex val;
                 var res = converter.ToDoubleComplex(bytes, startIndex, out val);
                 value = val;
                 return res;
             };
         }
         else
         {
             throw new NotImplementedException();
         }
     }
     else
     {
         // Arrays
         if (column.DataType.Type == typeof(Boolean))
         {
             return delegate(BitConverterBase converter, byte[] bytes, int startIndex, int count, out object value)
             {
                 Boolean[] val;
                 var res = converter.ToBoolean(bytes, startIndex, count, out val);
                 value = val;
                 return res;
             };
         }
         else if (column.DataType.Type == typeof(SByte))
         {
             return delegate(BitConverterBase converter, byte[] bytes, int startIndex, int count, out object value)
             {
                 SByte[] val;
                 var res = converter.ToSByte(bytes, startIndex, count, out val);
                 value = val;
                 return res;
             };
         }
         else if (column.DataType.Type == typeof(Byte))
         {
             return delegate(BitConverterBase converter, byte[] bytes, int startIndex, int count, out object value)
             {
                 Byte[] val;
                 var res = converter.ToByte(bytes, startIndex, count, out val);
                 value = val;
                 return res;
             };
         }
         else if (column.DataType.Type == typeof(Char))
         {
             return delegate(BitConverterBase converter, byte[] bytes, int startIndex, int count, out object value)
             {
                 Char[] val;
                 var res = converter.ToChar(bytes, startIndex, count, out val);
                 value = val;
                 return res;
             };
         }
         else if (column.DataType.Type == typeof(Int16))
         {
             return delegate(BitConverterBase converter, byte[] bytes, int startIndex, int count, out object value)
             {
                 Int16[] val;
                 var res = converter.ToInt16(bytes, startIndex, count, out val);
                 value = val;
                 return res;
             };
         }
         else if (column.DataType.Type == typeof(UInt16))
         {
             return delegate(BitConverterBase converter, byte[] bytes, int startIndex, int count, out object value)
             {
                 UInt16[] val;
                 var res = converter.ToUInt16(bytes, startIndex, count, out val);
                 value = val;
                 return res;
             };
         }
         else if (column.DataType.Type == typeof(Int32))
         {
             return delegate(BitConverterBase converter, byte[] bytes, int startIndex, int count, out object value)
             {
                 Int32[] val;
                 var res = converter.ToInt32(bytes, startIndex, count, out val);
                 value = val;
                 return res;
             };
         }
         else if (column.DataType.Type == typeof(UInt32))
         {
             return delegate(BitConverterBase converter, byte[] bytes, int startIndex, int count, out object value)
             {
                 UInt32[] val;
                 var res = converter.ToUInt32(bytes, startIndex, count, out val);
                 value = val;
                 return res;
             };
         }
         else if (column.DataType.Type == typeof(Int64))
         {
             return delegate(BitConverterBase converter, byte[] bytes, int startIndex, int count, out object value)
             {
                 Int64[] val;
                 var res = converter.ToInt64(bytes, startIndex, count, out val);
                 value = val;
                 return res;
             };
         }
         else if (column.DataType.Type == typeof(UInt64))
         {
             return delegate(BitConverterBase converter, byte[] bytes, int startIndex, int count, out object value)
             {
                 UInt64[] val;
                 var res = converter.ToUInt64(bytes, startIndex, count, out val);
                 value = val;
                 return res;
             };
         }
         else if (column.DataType.Type == typeof(Single))
         {
             return delegate(BitConverterBase converter, byte[] bytes, int startIndex, int count, out object value)
             {
                 Single[] val;
                 var res = converter.ToSingle(bytes, startIndex, count, out val);
                 value = val;
                 return res;
             };
         }
         else if (column.DataType.Type == typeof(Double))
         {
             return delegate(BitConverterBase converter, byte[] bytes, int startIndex, int count, out object value)
             {
                 Double[] val;
                 var res = converter.ToDouble(bytes, startIndex, count, out val);
                 value = val;
                 return res;
             };
         }
         else if (column.DataType.Type == typeof(SingleComplex))
         {
             return delegate(BitConverterBase converter, byte[] bytes, int startIndex, int count, out object value)
             {
                 SingleComplex[] val;
                 var res = converter.ToSingleComplex(bytes, startIndex, count, out val);
                 value = val;
                 return res;
             };
         }
         else if (column.DataType.Type == typeof(DoubleComplex))
         {
             return delegate(BitConverterBase converter, byte[] bytes, int startIndex, int count, out object value)
             {
                 DoubleComplex[] val;
                 var res = converter.ToDoubleComplex(bytes, startIndex, count, out val);
                 value = val;
                 return res;
             };
         }
         else
         {
             throw new NotImplementedException();
         }
     }
 }
Ejemplo n.º 2
0
 private void CopyMembers(FitsTableColumn old)
 {
     this.id = old.id;
     this.name = old.name;
     this.dataType = new FitsDataType(old.dataType);
     this.nullValue = old.nullValue;
     this.unit = old.unit;
     this.scale = old.scale;
     this.zero = old.zero;
     this.format = old.format;
     this.dimensions = old.dimensions;
 }
Ejemplo n.º 3
0
 public FitsTableColumn(FitsTableColumn old)
 {
     CopyMembers(old);
 }
Ejemplo n.º 4
0
        internal static FitsTableColumn CreateFromHeader(HduBase hdu, int index)
        {
            Card card;

            // Get data type
            if (!hdu.Cards.TryGetValue(Constants.FitsKeywordTForm, index, out card))
            {
                throw new FitsException("Keyword expected but not found:"); // TODO
            }

            var tform = card.GetString();
            var dt = FitsDataType.CreateFromTForm(tform);

            // Create column

            var column = new FitsTableColumn()
            {
                ID = index,
            };

            // Set optional parameters

            // --- Column name
            if (hdu.Cards.TryGetValue(Constants.FitsKeywordTType, index, out card))
            {
                column.Name = card.GetString();
            }

            // Unit
            if (hdu.Cards.TryGetValue(Constants.FitsKeywordTUnit, index, out card))
            {
                column.Unit = card.GetString();
            }

            // Null value equivalent
            if (hdu.Cards.TryGetValue(Constants.FitsKeywordTNull, index, out card))
            {
                column.NullValue = card.GetInt32();
            }

            // Scale
            if (hdu.Cards.TryGetValue(Constants.FitsKeywordTScal, index, out card))
            {
                column.Scale = card.GetDouble();
            }

            // Zero offset
            if (hdu.Cards.TryGetValue(Constants.FitsKeywordTZero, index, out card))
            {
                column.Zero = card.GetDouble();
            }

            // Format
            if (hdu.Cards.TryGetValue(Constants.FitsKeywordTDisp, index, out card))
            {
                column.Format = card.GetString();
            }

            return column;
        }