internal void Add(PropertyDescriptionRoute value, bool overwrite)
        {
            PropertyDescriptionRouteDictionary.EnsureValue(value);

            var key = PropertyRouteBuilder.ToPropertyRoute(value);

            this.Add(key, value, overwrite);
        }
        internal static PropertyRoute ToPropertyRoute(DataGridItemPropertyRoute itemProperty)
        {
            if (itemProperty == null)
            {
                return(null);
            }

            return(PropertyRoute.Combine(PropertyRouteBuilder.ToSegment(itemProperty.Current), PropertyRouteBuilder.ToPropertyRoute(itemProperty.Parent)));
        }
        internal static PropertyRoute ToPropertyRoute(PropertyDescriptionRoute description)
        {
            if (description == null)
            {
                return(null);
            }

            return(PropertyRoute.Combine(PropertyRouteBuilder.ToSegment(description.Current), PropertyRouteBuilder.ToPropertyRoute(description.Parent)));
        }
        internal static PropertyRoute Parse(string path)
        {
            path = (path != null) ? path.Trim() : string.Empty;

            var length = path.Length;

            if (length <= 0)
            {
                return(null);
            }

            var builder = new PropertyRouteBuilder();
            var state   = ParserState.Start;
            var index   = 0;

            while (index < length)
            {
                var c = path[index];

                if (char.IsWhiteSpace(c))
                {
                    index++;
                }
                else
                {
                    switch (state)
                    {
                    case ParserState.Start:
                    {
                        switch (c)
                        {
                        case '.':
                            index++;
                            break;

                        default:
                            state = ParserState.Property;
                            break;
                        }
                    }
                    break;

                    case ParserState.Separator:
                    {
                        switch (c)
                        {
                        case '.':
                            index++;
                            break;

                        case '[':
                            break;

                        default:
                        {
                            PropertyRouteParser.AddOther(path, length, ref index, builder);
                            Debug.Assert(index >= length);
                        }
                        break;
                        }

                        state = ParserState.Property;
                    }
                    break;

                    case ParserState.Property:
                    {
                        switch (c)
                        {
                        case '[':
                        {
                            if (PropertyRouteParser.AddIndexer(path, length, ref index, builder))
                            {
                                state = ParserState.Separator;
                            }
                            else
                            {
                                PropertyRouteParser.AddOther(path, length, ref index, builder);
                                Debug.Assert(index >= length);
                            }
                        }
                        break;

                        default:
                        {
                            if (PropertyRouteParser.AddProperty(path, length, ref index, builder))
                            {
                                state = ParserState.Separator;
                            }
                            else
                            {
                                PropertyRouteParser.AddOther(path, length, ref index, builder);
                                Debug.Assert(index >= length);
                            }
                        }
                        break;
                        }
                    }
                    break;

                    default:
                        throw new NotImplementedException();
                    }
                }
            }

            if (builder.IsEmpty)
            {
                builder.PushDescendant(PropertyRouteSegment.Self);
            }

            return(builder.ToPropertyRoute());
        }
 internal static string Parse(DataGridItemPropertyBase itemProperty)
 {
     return(PropertyRouteParser.Parse(PropertyRouteBuilder.ToPropertyRoute(DataGridItemPropertyRoute.Create(itemProperty))));
 }