Beispiel #1
0
        private static T[] InternalToArray <T>(PacketReader reader, PacketConverter converter)
        {
            var readerList = reader.GetList();
            var count      = readerList.Count;

            if (count < 1)
            {
                return(new T[0]);
            }

            try
            {
                var result  = new T[count];
                var generic = (PacketConverter <T>)converter;
                for (var i = 0; i < count; i++)
                {
                    result[i] = generic.GetValue(readerList[i].block);
                }
                return(result);
            }
            catch (Exception ex) when(PacketException.ReThrowFilter(ex))
            {
                throw PacketException.ConversionError(ex);
            }
        }
Beispiel #2
0
        internal void ToDictionary <TK, TV>(PacketConverter indexConverter, PacketConverter elementConverter, DictionaryAbstract <TK, TV> dictionary)
        {
            if (this.Length == 0)
            {
                return;
            }
            var indexGeneric   = (PacketConverter <TK>)indexConverter;
            var elementGeneric = (PacketConverter <TV>)elementConverter;
            var vernier        = (Vernier)this;

            try
            {
                while (vernier.Any)
                {
                    vernier.FlushExcept(indexGeneric.Length);
                    var key = indexGeneric.GetValue(vernier.Buffer, vernier.Offset, vernier.Length);
                    vernier.FlushExcept(elementGeneric.Length);
                    var value = elementGeneric.GetValue(vernier.Buffer, vernier.Offset, vernier.Length);
                    dictionary.Add(key, value);
                }
            }
            catch (Exception ex) when(PacketException.ReThrowFilter(ex))
            {
                throw PacketException.ConversionError(ex);
            }
        }
Beispiel #3
0
 internal static T GetValueChecked <T>(this PacketConverter <T> converter, byte[] buffer, int offset, int length, bool check = false)
 {
     try
     {
         if (check && converter.Length > length)
         {
             throw PacketException.Overflow();
         }
         return(converter.GetValue(buffer, offset, length));
     }
     catch (Exception ex) when(PacketException.ReThrowFilter(ex))
     {
         throw PacketException.ConversionError(ex);
     }
 }
Beispiel #4
0
 internal static byte[] GetBytesChecked <T>(this PacketConverter <T> converter, T value)
 {
     try
     {
         var buffer = converter.GetBytes(value);
         if (buffer == null)
         {
             buffer = Empty.Array <byte>();
         }
         var define = converter.Length;
         if (define > 0 && define != buffer.Length)
         {
             throw PacketException.ConversionMismatch(define);
         }
         return(buffer);
     }
     catch (Exception ex) when(PacketException.ReThrowFilter(ex))
     {
         throw PacketException.ConversionError(ex);
     }
 }
Beispiel #5
0
        internal        T[] ToArray <T>(PacketConverter converter)
        {
            if (this.Length < 1)
            {
                return(new T[0]);
            }
            if (typeof(T) == typeof(byte))
            {
                return((T[])(object)UnmanagedArrayConverter <byte> .ToValue(this.Buffer, this.Offset, this.Length));
            }
            else if (typeof(T) == typeof(sbyte))
            {
                return((T[])(object)UnmanagedArrayConverter <sbyte> .ToValue(this.Buffer, this.Offset, this.Length));
            }

            var define   = converter.Length;
            var quotient = Math.DivRem(this.Length, define, out var remainder);

            if (remainder != 0)
            {
                throw PacketException.Overflow();
            }

            try
            {
                var target  = new T[quotient];
                var generic = (PacketConverter <T>)converter;
                for (var i = 0; i < quotient; i++)
                {
                    target[i] = generic.GetValue(this.Buffer, this.Offset + i * define, define);
                }
                return(target);
            }
            catch (Exception ex) when(PacketException.ReThrowFilter(ex))
            {
                throw PacketException.ConversionError(ex);
            }
        }