Novacoin/Interop.cs

   1 \feff/**
   2  *  Novacoin classes library
   3  *  Copyright (C) 2015 Alex D. (balthazar.ad@gmail.com)
   4
   5  *  This program is free software: you can redistribute it and/or modify
   6  *  it under the terms of the GNU Affero General Public License as
   7  *  published by the Free Software Foundation, either version 3 of the
   8  *  License, or (at your option) any later version.
   9
  10  *  This program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU Affero General Public License for more details.
  14
  15  *  You should have received a copy of the GNU Affero General Public License
  16  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19 using System;
  20 using System.Collections.Generic;
  21 using System.Text;
  22
  23 namespace Novacoin
  24 {
  25     public class InteropException : Exception
  26     {
  27         public InteropException()
  28         {
  29         }
  30
  31         public InteropException(string message)
  32             : base(message)
  33         {
  34         }
  35
  36         public InteropException(string message, Exception inner)
  37             : base(message, inner)
  38         {
  39         }
  40     }
  41
  42     public class Interop
  43     {
  44         public static byte[] ReverseBytes(byte[] source)
  45         {
  46             var b = new byte[source.Length];
  47
  48             source.CopyTo(b, 0);
  49
  50             Array.Reverse(b);
  51
  52             return b;
  53         }
  54
  55         public static byte[] LEBytes(uint[] values)
  56         {
  57             var result = new byte[values.Length * sizeof(uint)];
  58             Buffer.BlockCopy(values, 0, result, 0, result.Length);
  59
  60             return result;
  61         }
  62
  63         public static uint[] ToUInt32Array(byte[] bytes)
  64         {
  65             var result = new uint[bytes.Length / sizeof(uint)];
  66             Buffer.BlockCopy(bytes, 0, result, 0, bytes.Length);
  67
  68             return result;
  69         }
  70
  71         public static byte[] BEBytes(ushort n)
  72         {
  73             var resultBytes = BitConverter.GetBytes(n);
  74
  75             Array.Reverse(resultBytes);
  76
  77             return resultBytes;
  78         }
  79
  80         public static byte[] BEBytes(uint n)
  81         {
  82             var resultBytes = BitConverter.GetBytes(n);
  83
  84             Array.Reverse(resultBytes);
  85
  86             return resultBytes;
  87         }
  88
  89         public static byte[] BEBytes(ulong n)
  90         {
  91             var resultBytes = BitConverter.GetBytes(n);
  92
  93             Array.Reverse(resultBytes);
  94
  95             return resultBytes;
  96         }
  97
  98
  99         public static ushort BEBytesToUInt16(byte[] bytes)
 100         {
 101             if (bytes.Length != sizeof(ushort))
 102             {
 103                 throw new InteropException("Array size doesn't match the ushort data type.");
 104             }
 105
 106             Array.Reverse(bytes);
 107
 108             return BitConverter.ToUInt16(bytes, 0);
 109         }
 110
 111         public static uint BEBytesToUInt32(byte[] bytes)
 112         {
 113             if (bytes.Length != sizeof(uint))
 114             {
 115                 throw new InteropException("Array size doesn't match the uint data type.");
 116             }
 117
 118             Array.Reverse(bytes);
 119
 120             return BitConverter.ToUInt32(bytes, 0);
 121         }
 122
 123         public static ulong BEBytesToUInt64(byte[] bytes)
 124         {
 125             if (bytes.Length != sizeof(ulong))
 126             {
 127                 throw new InteropException("Array size doesn't match the ulong data type.");
 128             }
 129
 130             Array.Reverse(bytes);
 131
 132             return BitConverter.ToUInt64(bytes, 0);
 133         }
 134
 135         public static byte[] HexToArray(string hex)
 136         {
 137             int nChars = hex.Length;
 138             var bytes = new byte[nChars / 2];
 139
 140             for (int i = 0; i < nChars; i += 2)
 141             {
 142                 bytes[i / 2] = Convert.ToByte(hex.Substring(i, 2), 16);
 143             }
 144
 145             return bytes;
 146         }
 147
 148         public static string ToHex(IEnumerable<byte> bytes)
 149         {
 150             var sb = new StringBuilder();
 151             foreach (var b in bytes)
 152             {
 153                 sb.AppendFormat("{0:x2}", b);
 154             }
 155             return sb.ToString();
 156         }
 157     }
 158 }