Example #1
0
        ///////////////////////////////////////////////////////////////////////

        #region Public Parsing Methods
        public static bool ParseData(
            Configuration configuration,
            string text,
            ref IEqualityComparer <Configuration> comparer,
            ref IDictionary <Configuration, Release> releases,
            ref int[] protocolCounts,
            ref string error
            )
        {
            if (configuration == null)
            {
                error = "Invalid configuration.";
                return(false);
            }

            if (text == null)
            {
                error = "Invalid release data.";
                return(false);
            }

            //
            // NOTE: This will contain the counts of the protocols encountered
            //       while parsing the release data (e.g. "1", "2", "3", or
            //       other).
            //
            if (protocolCounts == null)
            {
                protocolCounts = new int[4];
            }

            int parseCount = 0;

            string[] lines = text.Split(Line.Separators);

            for (int lineIndex = 0; lineIndex < lines.Length; lineIndex++)
            {
                string line = lines[lineIndex];

                if (line == null)
                {
                    continue;
                }

                line = line.Trim(Characters.Space);

                if (line.Length == 0)
                {
                    continue;
                }

                if (GenericOps <char> .Contains(Line.Comments, line[0]))
                {
                    continue;
                }

                Release release = ParseLine(
                    configuration, NextId(), lineIndex, line, ref error);

                if (release != null)
                {
                    /* IGNORED */
                    release.MaybeUseDownloadBaseUri(configuration.Assembly);

                    parseCount++;

                    if (release.ProtocolId != null)
                    {
                        switch (release.ProtocolId)
                        {
                        case Protocol.Build:     /* NOTE: Release build. */
                        {
                            protocolCounts[0]++;
                            break;
                        }

                        case Protocol.Script:     /* NOTE: Update script. */
                        {
                            protocolCounts[1]++;
                            break;
                        }

                        case Protocol.Self:     /* NOTE: Updater itself. */
                        {
                            protocolCounts[2]++;
                            break;
                        }

                        default:     /* NOTE: Other and/or unknown. */
                        {
                            protocolCounts[3]++;
                            break;
                        }
                        }
                    }

                    if (comparer == null)
                    {
                        comparer = new _Comparers._Configuration(
                            StringComparison.Ordinal, Defaults.Encoding);
                    }

                    if (releases == null)
                    {
                        releases = new Dictionary <Configuration, Release>(
                            comparer);
                    }

                    Configuration releaseConfiguration =
                        Configuration.CreateFrom(release);

                    if (releaseConfiguration == null)
                    {
                        Trace(configuration, String.Format(
                                  "Could not create configuration from parsed " +
                                  "release {0} on line #{1}, using the " +
                                  "pre-existing one...", FormatOps.ForDisplay(
                                      release), lineIndex), TraceCategory);

                        releaseConfiguration = configuration;
                    }

                    releases[releaseConfiguration] = release;
                }
            }

            return((parseCount > 0) ? true : false);
        }