Example #1
0
        /// <summary>
        /// Gets a code model for the specified document. If the code model is not present in the
        /// cache, a new code model will be generated and added to the cache.
        /// </summary>
        /// <param name="document">The document.</param>
        /// <returns>A code model representing the document.</returns>
        internal CodeModel GetCodeModel(Document document)
        {
            CodeModel codeModel;

            OutputWindowHelper.DiagnosticWriteLine($"CodeModelCache.GetCodeModel for '{document.FullName}'");

            lock (_cache)
            {
                if (!_cache.TryGetValue(document.FullName, out codeModel))
                {
                    codeModel = new CodeModel(document) { IsStale = true };

                    if (Settings.Default.General_CacheFiles)
                    {
                        _cache.Add(document.FullName, codeModel);
                        OutputWindowHelper.DiagnosticWriteLine("  --added to cache (stale).");
                    }
                }
                else
                {
                    OutputWindowHelper.DiagnosticWriteLine(codeModel.IsStale
                        ? "  --retrieved from cache (stale)."
                        : "  --retrieved from cache (not stale).");
                }
            }

            return codeModel;
        }
Example #2
0
 /// <summary>
 /// An event handler called when the <see cref="CodeModelManager" /> raises a <see
 /// cref="CodeModelManager.CodeModelBuilt" /> event. If the code model was built for the
 /// document currently being shown by Spade, the raw code items will be processed and displayed.
 /// </summary>
 /// <param name="codeModel">The code model.</param>
 private void OnCodeModelBuilt(CodeModel codeModel)
 {
     if (Document == codeModel.Document)
     {
         UpdateViewModelRawCodeItems(codeModel.CodeItems);
     }
 }
Example #3
0
        /// <summary>
        /// Raises the <see cref="CodeModelBuilt" /> event.
        /// </summary>
        /// <param name="codeModel">The code model.</param>
        private void RaiseCodeModelBuilt(CodeModel codeModel)
        {
            var codeModelBuilt = CodeModelBuilt;
            if (codeModelBuilt != null)
            {
                OutputWindowHelper.DiagnosticWriteLine(
                    $"CodeModelManager.CodeModelBuilt raised for '{codeModel.Document.FullName}'");

                codeModelBuilt(codeModel);
            }
        }
Example #4
0
        /// <summary>
        /// Loads all lazy initialized values for items within the code model.
        /// </summary>
        /// <param name="codeModel">The code model.</param>
        private void LoadLazyInitializedValues(CodeModel codeModel)
        {
            try
            {
                OutputWindowHelper.DiagnosticWriteLine(
                    $"CodeModelManager.LoadLazyInitializedValues for '{codeModel.Document.FullName}'");

                foreach (var codeItem in codeModel.CodeItems)
                {
                    codeItem.LoadLazyInitializedValues();
                }
            }
            catch (Exception ex)
            {
                OutputWindowHelper.ExceptionWriteLine(
                    $"Unable to load lazy initialized values for '{codeModel.Document.FullName}'", ex);
            }
        }
Example #5
0
 /// <summary>
 /// An event handler called when the <see cref="CodeModelManager" /> raises a <see
 /// cref="CodeModelManager.CodeModelBuilt" /> event. If the code model was built for the
 /// document currently being shown by Spade, the raw code items will be processed and displayed.
 /// </summary>
 /// <param name="codeModel">The code model.</param>
 private void OnCodeModelBuilt(CodeModel codeModel)
 {
     if (Document == codeModel.Document)
     {
         UpdateViewModelRawCodeItems(codeModel.CodeItems);
     }
 }
Example #6
0
        /// <summary>
        /// Raises the <see cref="CodeModelBuilt" /> event.
        /// </summary>
        /// <param name="codeModel">The code model.</param>
        private void RaiseCodeModelBuilt(CodeModel codeModel)
        {
            var codeModelBuilt = CodeModelBuilt;
            if (codeModelBuilt != null)
            {
                OutputWindowHelper.DiagnosticWriteLine(
                    $"CodeModelManager.CodeModelBuilt raised for '{codeModel.Document.FullName}'");

                codeModelBuilt(codeModel);
            }
        }
Example #7
0
        /// <summary>
        /// Loads all lazy initialized values for items within the code model.
        /// </summary>
        /// <param name="codeModel">The code model.</param>
        private void LoadLazyInitializedValues(CodeModel codeModel)
        {
            try
            {
                OutputWindowHelper.DiagnosticWriteLine(
                    $"CodeModelManager.LoadLazyInitializedValues for '{codeModel.Document.FullName}'");

                foreach (var codeItem in codeModel.CodeItems)
                {
                    codeItem.LoadLazyInitializedValues();
                }
            }
            catch (Exception ex)
            {
                OutputWindowHelper.ExceptionWriteLine(
                    $"Unable to load lazy initialized values for '{codeModel.Document.FullName}'", ex);
            }
        }
Example #8
0
        /// <summary>
        /// Builds a <see cref="SetCodeItems" /> of CodeItems based on the specified code model. If
        /// the document gets marked as stale during execution this process will recursively call
        /// itself to start over in order to guarantee a valid code model is returned.
        /// </summary>
        /// <param name="codeModel">The code model.</param>
        private void BuildCodeItems(CodeModel codeModel)
        {
            try
            {
                OutputWindowHelper.DiagnosticWriteLine(
                    $"CodeModelManager.BuildCodeItems started for '{codeModel.Document.FullName}'");

                codeModel.IsBuilding = true;
                codeModel.IsStale = false;

                var codeItems = _codeModelBuilder.RetrieveAllCodeItems(codeModel.Document);

                if (codeModel.IsStale)
                {
                    BuildCodeItems(codeModel);
                    return;
                }

                codeModel.CodeItems = codeItems;
                codeModel.IsBuilding = false;

                OutputWindowHelper.DiagnosticWriteLine(
                    $"CodeModelManager.BuildCodeItems completed for '{codeModel.Document.FullName}'");
            }
            catch (Exception ex)
            {
                OutputWindowHelper.DiagnosticWriteLine(
                    $"Unable to build code model for '{codeModel.Document.FullName}': {ex}");

                codeModel.CodeItems = new SetCodeItems();
                codeModel.IsBuilding = false;
            }
        }
Example #9
0
        /// <summary>
        /// Loads all lazy initialized values for items within the code model.
        /// </summary>
        /// <param name="codeModel">The code model.</param>
        private void LoadLazyInitializedValues(CodeModel codeModel)
        {
            try
            {
                OutputWindowHelper.DiagnosticWriteLine(
                    string.Format("CodeModelManager.LoadLazyInitializedValues for '{0}'", codeModel.Document.FullName));

                if (Settings.Default.General_Multithread)
                {
                    Parallel.ForEach(codeModel.CodeItems, x => x.LoadLazyInitializedValues());
                }
                else
                {
                    foreach (var codeItem in codeModel.CodeItems)
                    {
                        codeItem.LoadLazyInitializedValues();
                    }
                }
            }
            catch (Exception ex)
            {
                OutputWindowHelper.ExceptionWriteLine(
                    string.Format("Unable to load lazy initialized values for '{0}'", codeModel.Document.FullName), ex);
            }
        }