public MemoryBytesViewModel(MemoryBytes model, string formatString, Func <byte[], IList <T> > converter)
        {
            lastChangedValues = new List <MemoryValueViewModel <T> >();

            this.values = new ObservableCollection <MemoryValueViewModel <T> >();

            this.converter = converter;

            this.text = GetText(model.Data);

            this.actualAddress = model.Address;
            this.address       = string.Format("0x{0:X8}", model.Address);
            ulong currentAddress = model.Address;

            ulong typeSize = (ulong)System.Runtime.InteropServices.Marshal.SizeOf(typeof(T));

            var values = converter(model.Data);

            foreach (var value in values)
            {
                this.values.Add(new MemoryValueViewModel <T>(currentAddress, value, formatString));
                currentAddress += typeSize;
            }

            count = (uint)(values.Count * (int)typeSize);
        }
Exemple #2
0
        private MemoryBytesViewModel GenerateViewModels(MemoryBytes data)
        {
            switch (IntegerDisplaySize)
            {
            case IntegerSize.NoData:
                return(new MemoryBytesViewModel <byte>(data, string.Empty, (source) => { return source; }));

            case IntegerSize.U8:
                return(new MemoryBytesViewModel <byte>(data, "{0:X2}", (source) => { return source; }));

            case IntegerSize.U16:
                return(new MemoryBytesViewModel <UInt16>(data, "{0:X4}", (source) =>
                {
                    var values = new List <UInt16>();

                    for (int i = 0; i < source.Length; i += 2)
                    {
                        values.Add(BitConverter.ToUInt16(source, i));
                    }

                    return values;
                }));

            case IntegerSize.U32:
                return(new MemoryBytesViewModel <UInt32>(data, "{0:X8}", (source) =>
                {
                    var values = new List <UInt32>();

                    for (int i = 0; i < source.Length; i += 4)
                    {
                        values.Add(BitConverter.ToUInt32(source, i));
                    }

                    return values;
                }));

            case IntegerSize.U64:
                return(new MemoryBytesViewModel <UInt64>(data, "{0:X16}", (source) =>
                {
                    var values = new List <UInt64>();

                    for (int i = 0; i < source.Length; i += 8)
                    {
                        values.Add(BitConverter.ToUInt64(source, i));
                    }

                    return values;
                }));

            default:
                throw new NotImplementedException();
            }
        }
		public static List<MemoryBytes> FromDataString(string data)
		{
			var result = new List<MemoryBytes>();

			var responsePair = data.Substring(6).ToNameValuePair();

			if (responsePair.Name == "memory")
			{
				var memoryBlocks = responsePair.Value.ToArray();

				foreach (var memoryBlock in memoryBlocks)
				{
					var block = new MemoryBytes();

					var pairs = memoryBlocks[0].RemoveBraces().ToNameValuePairs();

					foreach (var pair in pairs)
					{
						switch (pair.Name)
						{
							case "begin":
								block.Address = Convert.ToUInt64(pair.Value, 16);
								break;

							case "offset":
								block.Offset = Convert.ToUInt64(pair.Value, 16);
								break;

							case "end":
								block.End = Convert.ToUInt64(pair.Value, 16);
								break;

							case "contents":
								block.Data = StringToByteArray(pair.Value);
								block.Values = pair.Value;
								break;
						}
					}

					result.Add(block);
				}
			}

			return result;
		}
Exemple #4
0
        public static List <MemoryBytes> FromDataString(string data)
        {
            var result = new List <MemoryBytes>();

            var responsePair = data.Substring(6).ToNameValuePair();

            if (responsePair.Name == "memory")
            {
                var memoryBlocks = responsePair.Value.ToArray();

                foreach (var memoryBlock in memoryBlocks)
                {
                    var block = new MemoryBytes();

                    var pairs = memoryBlocks[0].RemoveBraces().ToNameValuePairs();

                    foreach (var pair in pairs)
                    {
                        switch (pair.Name)
                        {
                        case "begin":
                            block.Address = Convert.ToUInt64(pair.Value, 16);
                            break;

                        case "offset":
                            block.Offset = Convert.ToUInt64(pair.Value, 16);
                            break;

                        case "end":
                            block.End = Convert.ToUInt64(pair.Value, 16);
                            break;

                        case "contents":
                            block.Data   = StringToByteArray(pair.Value);
                            block.Values = pair.Value;
                            break;
                        }
                    }

                    result.Add(block);
                }
            }

            return(result);
        }