/// <summary>
        /// Gets the reference definition.
        /// </summary>
        /// <param name="table">The table definition.</param>
        /// <param name="field">The field definition.</param>
        /// <param name="pathToField">The path to field.</param>
        /// <returns>The generated code fragment.</returns>
        protected internal override string GetReferenceDefinition(ITableDefinition table, TableFieldDefinition field, string pathToField)
        {
            var sb = new StringBuilder();
            var fieldAlias = field.ColumnName;
            var includeInList = field.IsRuntimeAvailable || field.CrossRefIsOwner;

            if (field.ColumnType == ColumnTypes.MultiReference)
                fieldAlias = string.Format("{0}_{1}", table.Name, field.ColumnName);

            sb.AppendFormat(
                @"
            {0} = new Cebos.Veyron.SharedTypes.ReferenceFieldDefinition
                    {{
                        Name = {1},
                        SystemName = {1},
                        DisplayName = {2},
                        ColumnType = Cebos.Veyron.SharedTypes.ColumnTypes.{3},
                        IncludeInResult = {4},
                        Alias = {5},
                        ShowLatestVersion = {6},
                        IsFilterable = {7}
                    }};
",
                pathToField,
                field.ColumnName.ToLiteral(),
                field.DisplayName.ToLiteral(),
                field.ColumnType,
                includeInList.ToString().ToLower(),
                fieldAlias.ToLiteral(),
                field.ShowLatestVersion.ToLiteral(),
                field.IsFilterable.ToString().ToLower());

            sb.Append(GetReferenceProcessDefinition(field.ReferenceProcess, pathToField + ".ReferenceProcess"));

            if (field.ColumnType == ColumnTypes.TreeView)
            {
                sb.AppendFormat(@"
            {0}.ChildCrossReferenceColumnName = ""{1}"";", pathToField, field.ChildCrossReferenceColumnName);
                sb.AppendFormat(@"
            {0}.TreeViewProcess = ""{1}"";", pathToField, field.TreeViewProcess);
                sb.AppendFormat(@"
            {0}.ReferenceMatchField = ""{1}"";", pathToField, field.ReferenceMatchField);
            }
            
            var definedIn = new ReferenceProcessDefinition
                                {
                                    Name = table.Name,
                                    SystemName = table.Name
                                };

            sb.Append(GetReferenceProcessDefinition(definedIn, pathToField + ".DefinedIn"));
            sb.Append(GetReferenceJoinFieldDefinition(field.ReferenceField, pathToField + ".ReferenceField"));

            if (field.ReferenceDisplayFields.Any())
            {
                var subfieldName = string.Format(@"s_{0}", Guid.NewGuid().ToString().Replace('-', '_'));

                sb.AppendFormat(
                    @"
            Cebos.Veyron.SharedTypes.ReferenceDisplayFieldDefinition {0} = null;
",
                    subfieldName);

                foreach (var subfield in field.ReferenceDisplayFields)
                {
                    sb.Append(GetReferenceDisplayFieldDefinition(subfield, subfieldName));
                    sb.AppendFormat(@"
            {0}.DisplayFields.Add({1});
", pathToField, subfieldName);
                }
            }

            return sb.ToString();
        }
        /// <summary>
        /// Gets the reference process definition.
        /// </summary>
        /// <param name="process">The process.</param>
        /// <param name="pathToField">The path to field.</param>
        /// <returns>System.String.</returns>
        private static string GetReferenceProcessDefinition(ReferenceProcessDefinition process, string pathToField)
        {
            if (process == null)
                return string.Format(@"
            {0} = null;", pathToField);

            var sb = new StringBuilder();

            while (process != null)
            {
                sb.AppendFormat(@"
            {0} = new Cebos.Veyron.SharedTypes.ReferenceProcessDefinition {{ Name = {1}, SystemName = {2} }};
            {0}.SupportedLocalizations.AddRange(Cebos.Veyron.SharedTypes.Localization.LocalizationUtils.GetSupportedLocalizations({2}));
", pathToField, process.Name.ToLiteral(), process.SystemName.ToLiteral());

                pathToField += ".BaseProcess";
                process = process.BaseProcess;
            }

            return sb.ToString();
        }
        /// <summary>
        /// Gets the reference process definition.
        /// </summary>
        /// <param name="process">The process.</param>
        /// <param name="pathToField">The path to field.</param>
        /// <returns>System.String.</returns>
        private static string GetReferenceProcessDefinition(ReferenceProcessDefinition process, string pathToField)
        {
            if (process == null)
                return string.Format(@"
            {0} = null;", pathToField);

            var sb = new StringBuilder();

            while (process != null)
            {
                sb.AppendFormat(
                    @"
            {0} = new ReferenceProcessDefinition {{ Name = {1}, SystemName = {2} }};",
                    pathToField, process.Name.ToLiteral(), process.SystemName.ToLiteral());
                pathToField += ".BaseProcess";
                process = process.BaseProcess;
            }

            return sb.ToString();
        }