private void WriteAbiStruct(MemoryStream ms, object value, AbiStruct abiStruct, Abi abi)
        {
            if (value == null)
            {
                return;
            }

            if (!string.IsNullOrWhiteSpace(abiStruct.Base))
            {
                WriteAbiType(ms, value, abiStruct.Base, abi);
            }

            var accessor = ObjectAccessor.Create(value);

            foreach (var field in abiStruct.Fields)
            {
                var fieldName = FindObjectFieldName(field.Name, value.GetType());

                if (string.IsNullOrWhiteSpace(fieldName))
                {
                    throw new Exception("Missing " + abiStruct.Name + "." + field.Name + " (type=" + field.Type + ")");
                }

                WriteAbiType(ms, accessor[fieldName], field.Type, abi);
            }
        }
Exemple #2
0
        private void WriteAbiStruct(MemoryStream ms, object value, AbiStruct abiStruct, Abi abi)
        {
            if (value == null)
            {
                return;
            }

            if (!string.IsNullOrWhiteSpace(abiStruct.@base))
            {
                WriteAbiType(ms, value, abiStruct.@base, abi);
            }

            if (value is System.Collections.IDictionary)
            {
                var valueDict = value as System.Collections.IDictionary;
                foreach (var field in abiStruct.fields)
                {
                    var fieldName = FindObjectFieldName(field.name, valueDict);

                    if (string.IsNullOrWhiteSpace(fieldName))
                    {
                        throw new Exception("Missing " + abiStruct.name + "." + field.name + " (type=" + field.type +
                                            ")");
                    }

                    WriteAbiType(ms, valueDict[fieldName], field.type, abi);
                }
            }
            else
            {
                var valueType = value.GetType();
                foreach (var field in abiStruct.fields)
                {
                    var fieldInfo = valueType.GetField(field.name);

                    if (fieldInfo != null)
                    {
                        WriteAbiType(ms, fieldInfo.GetValue(value), field.type, abi);
                    }
                    else
                    {
                        var propInfo = valueType.GetProperty(field.name);

                        if (propInfo != null)
                        {
                            WriteAbiType(ms, propInfo.GetValue(value), field.type, abi);
                        }
                        else
                        {
                            throw new Exception("Missing " + abiStruct.name + "." + field.name + " (type=" +
                                                field.type + ")");
                        }
                    }
                }
            }
        }
Exemple #3
0
        private void WriteStruct(MemoryStream ms, object value, AbiStruct abiStruct, Abi abi)
        {
            if (!string.IsNullOrWhiteSpace(abiStruct.Base))
            {
                WriteAbiType(ms, value, abiStruct.Base, abi);
            }

            var accessor = ObjectAccessor.Create(value);

            foreach (var field in abiStruct.Fields)
            {
                WriteAbiType(ms, accessor[field.Name], field.Type, abi);
            }
        }
Exemple #4
0
        private T ReadAbiStruct <T>(byte[] data, AbiStruct abiStruct, Abi abi, ref int readIndex)
        {
            object value = default(T);

            if (!string.IsNullOrWhiteSpace(abiStruct.@base))
            {
                value = (T)ReadAbiType(data, abiStruct.@base, abi, ref readIndex);
            }
            else
            {
                value = Activator.CreateInstance(typeof(T));
            }

            var valueType = value.GetType();

            foreach (var field in abiStruct.fields)
            {
                var abiValue  = ReadAbiType(data, field.type, abi, ref readIndex);
                var fieldName = FindObjectFieldName(field.name, value.GetType());

                if (string.IsNullOrWhiteSpace(fieldName))
                {
                    if (valueType is IDictionary <string, Object> )
                    {
                        (value as IDictionary <string, Object>).Add(field.name, abiValue);
                    }
                    else if (typeof(T) == typeof(object))
                    {
                        valueType.GetField(field.name).SetValue(value, abiValue);
                    }

                    continue;
                }

                valueType.GetField(fieldName).SetValue(value, abiValue);
            }

            return((T)value);
        }
Exemple #5
0
        private object ReadStruct(byte[] data, ref Int32 readIndex, AbiStruct abiStruct, Abi abi)
        {
            object value = null;

            if (!string.IsNullOrWhiteSpace(abiStruct.Base))
            {
                value = ReadAbiType(data, ref readIndex, abiStruct.Base, abi);
            }
            else
            {
                value = new object();
            }

            var accessor = TypeAccessor.Create(value.GetType());

            foreach (var field in abiStruct.Fields)
            {
                accessor[value, field.Name] = ReadAbiType(data, ref readIndex, field.Type, abi);
            }

            return(value);
        }
        private T ReadAbiStruct <T>(byte[] data, ref Int32 readIndex, AbiStruct abiStruct, Abi abi)
        {
            object value = default(T);

            if (!string.IsNullOrWhiteSpace(abiStruct.Base))
            {
                value = (T)ReadAbiType(data, ref readIndex, abiStruct.Base, abi);
            }
            else if (typeof(T) == typeof(object))
            {
                value = new ExpandoObject();
            }
            else
            {
                value = Activator.CreateInstance(typeof(T));
            }

            var accessor = TypeAccessor.Create(value.GetType());

            foreach (var field in abiStruct.Fields)
            {
                var abiValue  = ReadAbiType(data, ref readIndex, field.Type, abi);
                var fieldName = FindObjectFieldName(field.Name, value.GetType());

                if (string.IsNullOrWhiteSpace(fieldName))
                {
                    if (typeof(T) == typeof(object))
                    {
                        accessor[value, field.Name] = abiValue;
                    }
                    continue;
                }

                accessor[value, fieldName] = abiValue;
            }

            return((T)value);
        }
 private object ReadAbiStruct(byte[] data, ref Int32 readIndex, AbiStruct abiStruct, Abi abi)
 {
     return(ReadAbiStruct <object>(data, ref readIndex, abiStruct, abi));
 }
Exemple #8
0
 private object ReadAbiStruct(byte[] data, AbiStruct abiStruct, Abi abi, ref int readIndex)
 {
     return(ReadAbiStruct <object>(data, abiStruct, abi, ref readIndex));
 }