Example #1
0
        public string GetPath(bool excludeEntry = true)
        {
            string path = "";

            if (this.Property == 0 && this.Parent is BINContainer)
            {
                path += string.Format("{0}/[{1}]", this.Parent.GetPath(excludeEntry), (this.Parent as BINContainer).Values.IndexOf(this));
            }
            else if (this.Property == 0 && this.Parent is BINMap)
            {
                BINMap map = this.Parent as BINMap;
                if (map.Values.ContainsValue(this))
                {
                    path += map.Values.First(x => x.Value == this).Key.GetPath(excludeEntry);
                }
                else
                {
                    if (map.KeyType == BINValueType.Byte)
                    {
                        path += string.Format("{0}/{1}", this.Parent.GetPath(excludeEntry), (byte)this.Value);
                    }
                    else if (map.KeyType == BINValueType.UInt16)
                    {
                        path += string.Format("{0}/{1}", this.Parent.GetPath(excludeEntry), (ushort)this.Value);
                    }
                    else if (map.KeyType == BINValueType.UInt32)
                    {
                        path += string.Format("{0}/{1}", this.Parent.GetPath(excludeEntry), (uint)this.Value);
                    }
                    else if (map.KeyType == BINValueType.UInt64)
                    {
                        path += string.Format("{0}/{1}", this.Parent.GetPath(excludeEntry), (ulong)this.Value);
                    }
                    else if (map.KeyType == BINValueType.String)
                    {
                        path += string.Format("{0}/{1}", this.Parent.GetPath(excludeEntry), (string)this.Value);
                    }
                    else if (map.KeyType == BINValueType.Hash)
                    {
                        path += string.Format("{0}/{1}", this.Parent.GetPath(excludeEntry), (uint)this.Value);
                    }
                    else
                    {
                        throw new Exception();
                    }
                }
            }
            else if (this.Property == 0 && this.Parent is BINOptional)
            {
                path += this.Parent.GetPath(excludeEntry);
            }
            else if (this.Parent is BINStructure)
            {
                path += string.Format("{0}.{1}", this.Parent.GetPath(excludeEntry), BINGlobal.GetField(this.Property));
            }
            else if (this.Parent is BINEntry)
            {
                path += string.Format("{0}/{1}", this.Parent.GetPath(excludeEntry), BINGlobal.GetField(this.Property));
            }
            else
            {
                path += string.Format("{0}/{1}", this.Parent.GetPath(excludeEntry), BINGlobal.GetClass(this.Property));
            }

            return(excludeEntry ? path.Remove(0, path.IndexOf('/') + 1) : path);
        }
Example #2
0
        public BINValue this[string path]
        {
            get
            {
                string[] properties = path.Split('/');
                string   property   = properties[0];

                //Build next recursive property path
                string nextPath = string.Empty;
                if (properties.Length != 1)
                {
                    for (int i = 1; i < properties.Length; i++)
                    {
                        nextPath += properties[i];

                        if (i + 1 != properties.Length)
                        {
                            nextPath += '/';
                        }
                    }
                }

                //Determine the property type
                if (Regex.IsMatch(property, @"^\[\d+\]"))
                {
                    int valueIndex = int.Parse(property.Substring(1, property.IndexOf(']') - 1));

                    return((this.Value as BINContainer).Values[valueIndex]);
                }
                else if (property.Contains('[') && !property.Contains('.'))
                {
                    int startIndex = property.IndexOf('[');
                    int valueIndex = int.Parse(property.Substring(startIndex + 1, property.IndexOf(']') - startIndex - 1));

                    if (this.Type == BINValueType.Container &&
                        (this.Value as BINContainer).EntryType == BINValueType.Embedded ||
                        (this.Value as BINContainer).EntryType == BINValueType.Structure)
                    {
                        BINContainer container = this.Value as BINContainer;

                        return(container.Values[valueIndex]);
                    }
                }
                else if (property.Contains('.'))
                {
                    string[] structureProperties = property.Split('.');
                    string   structureProperty   = structureProperties[0];
                    string   fieldProperty       = structureProperties[1];
                    int?     structureIndex      = null;

                    //Check if structure property has an array index
                    if (structureProperty.Contains('['))
                    {
                        int startIndex = structureProperty.IndexOf('[');
                        structureIndex    = int.Parse(structureProperty.Substring(startIndex + 1, structureProperty.IndexOf(']') - startIndex - 1));
                        structureProperty = structureProperty.Remove(structureProperty.IndexOf('['));
                    }

                    uint structureHash = 0;
                    uint fieldHash;
                    if (structureIndex == null && !uint.TryParse(structureProperty, out structureHash))
                    {
                        structureHash = Cryptography.FNV32Hash(structureProperty);
                    }
                    if (!uint.TryParse(fieldProperty, out fieldHash))
                    {
                        fieldHash = Cryptography.FNV32Hash(fieldProperty);
                    }

                    BINStructure structure  = (structureIndex == null) ? this.Value as BINStructure : (this.Value as BINContainer).Values[(int)structureIndex].Value as BINStructure;
                    BINValue     fieldValue = structure[fieldHash];
                    if (nextPath != string.Empty)
                    {
                        return(structure[fieldHash][nextPath]);
                    }
                    else
                    {
                        return(structure[fieldHash]);
                    }
                }
                else if (this.Type == BINValueType.Map)
                {
                    BINMap map = this.Value as BINMap;

                    if (map.KeyType == BINValueType.Byte)
                    {
                        return(map[map.Values.Keys.Where(x => byte.Parse(property).Equals(x.Value)).First()]);
                    }
                    else if (map.KeyType == BINValueType.UInt16)
                    {
                        return(map[map.Values.Keys.Where(x => ushort.Parse(property).Equals(x.Value)).First()]);
                    }
                    else if (map.KeyType == BINValueType.UInt32)
                    {
                        return(map[map.Values.Keys.Where(x => uint.Parse(property).Equals(x.Value)).First()]);
                    }
                    else if (map.KeyType == BINValueType.UInt64)
                    {
                        return(map[map.Values.Keys.Where(x => ulong.Parse(property).Equals(x.Value)).First()]);
                    }
                    else if (map.KeyType == BINValueType.String)
                    {
                        return(map[map.Values.Keys.Where(x => string.Equals(property, x.Value)).First()]);
                    }
                    else if (map.KeyType == BINValueType.Hash)
                    {
                        return(map[map.Values.Keys.Where(x => uint.Parse(property).Equals(x.Value)).First()]);
                    }
                    else
                    {
                        throw new Exception("Unsupported Map Key Type: " + map.KeyType);
                    }
                }

                return(null);
            }
        }