private void Init()
        {
            ARMUri armUri = new ARMUri(this.FluentMethod.InnerMethod);

            //
            foreach (ParameterJv parameter in this.MethodParameters.Where(p => !p.IsConstant && !p.IsClientProperty))
            {
                FluentModelMemberVariable memberVariable = null;
                if (parameter.Location == ParameterLocation.Path)
                {
                    var parentSegment = armUri.OfType <ParentSegment>()
                                        .Where(segment => segment.Parameter.Name.Equals(parameter.Name))
                                        .FirstOrDefault();
                    if (parentSegment != null)
                    {
                        memberVariable = new FluentModelParentRefMemberVariable(parentSegment);
                    }
                    else
                    {
                        var positionalSegment = armUri.OfType <PositionalSegment>()
                                                .Where(segment => segment.Parameter.Name.Equals(parameter.Name))
                                                .FirstOrDefault();
                        if (positionalSegment != null)
                        {
                            memberVariable = new FluentModelPositionalPathMemberVariable(positionalSegment);
                        }
                    }
                    //
                    if (memberVariable == null)
                    {
                        throw new InvalidOperationException($"Unable to locate a parameter segment with name '{parameter.Name}' in the ARM Uri '{this.FluentMethod.InnerMethod.Url}'.");
                    }
                }
                else
                {
                    memberVariable = new FluentModelMemberVariable(variableName: parameter.Name, fromParameter: parameter);
                }
                memberVariable.Index = GetParameterIndex(parameter);
                //
                //
                this.Add(memberVariable.VariableName, memberVariable);
            }
        }
        private void Init()
        {
            IDictionary <string, ParameterJv> mapping = this.RequiredPathParametersMapping;

            //
            //
            foreach (ParameterJv parameter in this.MethodRequiredParameters.Where(p => !p.IsConstant && !p.IsClientProperty))
            {
                FluentModelMemberVariable memberVaraible;
                string variableName = parameter.Name;

                if (parameter.Location == ParameterLocation.Path)
                {
                    var entry = mapping.First(m => {
                        ParameterJv pathParam = m.Value;
                        return(pathParam.Name.Equals(variableName));
                    });

                    if (entry.Key.StartsWith("pos_"))
                    {
                        int pathPos = Int32.Parse(entry.Key.Substring("pos_".Length));
                        memberVaraible = new FluentModelPositionalPathMemberVariable(pathPos, variableName, parameter);
                    }
                    else
                    {
                        string parentRefName = entry.Key;
                        memberVaraible = new FluentModelParentRefMemberVariable(parentRefName, variableName, parameter);
                    }
                }
                else
                {
                    memberVaraible = new FluentModelMemberVariable(variableName, parameter);
                }

                memberVaraible.Index = GetParameterIndex(parameter);
                //
                //
                this.Add(memberVaraible.VariableName, memberVaraible);
            }
        }