#pragma once
#include <LibLsp/lsp/general/lsClientCapabilities.h>
#include <LibLsp/lsp/utils.h>
#include <memory>
#include <vector>
#include <string>

class ClientPreferences
{
public:
   std::shared_ptr<lsWorkspaceClientCapabilites> workspace;
   lsTextDocumentClientCapabilities textDocument;

   ClientPreferences(lsClientCapabilities const& capabilities)
   {
       v3supported = capabilities.textDocument.has_value();
       if (v3supported)
       {
           textDocument = capabilities.textDocument.value();
       }
       if (capabilities.workspace)
       {
           workspace = std::make_shared<lsWorkspaceClientCapabilites>(capabilities.workspace.value());
       }
   }

   bool v3supported = false;

   bool isSignatureHelpSupported()
   {

       return v3supported && (textDocument.signatureHelp);
   }
   bool isWorkspaceDidChangeConfigurationSupported() const
   {
       return workspace && isDynamicRegistrationSupported(workspace->didChangeConfiguration);
   }
   bool isWorkspaceFoldersSupported()
   {
       return workspace != nullptr && isTrue(workspace->workspaceFolders);
   }

   bool isCompletionDynamicRegistered()
   {
       return v3supported && isDynamicRegistrationSupported(textDocument.completion);
   }

   bool isCompletionSnippetsSupported()
   {
       //@formatter:off
       if (!v3supported || !textDocument.completion)
       {
           return false;
       }
       auto const& completion = textDocument.completion.value();
       if (completion.completionItem)
       {
           return isTrue(completion.completionItem.value().snippetSupport);
       }
       return false;
   }

   bool isV3Supported()
   {
       return v3supported;
   }

   bool isFormattingDynamicRegistrationSupported()
   {
       return v3supported && isDynamicRegistrationSupported(textDocument.formatting);
   }

   bool isRangeFormattingDynamicRegistrationSupported()
   {
       return v3supported && isDynamicRegistrationSupported(textDocument.rangeFormatting);
   }

   bool isOnTypeFormattingDynamicRegistrationSupported()
   {
       return v3supported && isDynamicRegistrationSupported(textDocument.onTypeFormatting);
   }

   bool isCodeLensDynamicRegistrationSupported()
   {
       return v3supported && isDynamicRegistrationSupported(textDocument.codeLens);
   }

   bool isSignatureHelpDynamicRegistrationSupported()
   {
       return v3supported && isDynamicRegistrationSupported(textDocument.signatureHelp);
   }
   template<typename T>
   static bool isDynamicRegistrationSupported(optional<T>& capability)
   {
       if (capability)
       {
           return (capability.value().dynamicRegistration.value());
       }
       return false;
   }

   bool isTrue(optional<bool> const& value)
   {
       if (value)
       {
           return *value;
       }
       else
       {
           return false;
       }
   }

   bool isRenameDynamicRegistrationSupported()
   {
       return v3supported && isDynamicRegistrationSupported(textDocument.rename);
   }

   bool isExecuteCommandDynamicRegistrationSupported()
   {
       return v3supported && workspace != nullptr && isDynamicRegistrationSupported(workspace->executeCommand);
   }

   bool isWorkspaceSymbolDynamicRegistered()
   {
       return v3supported && workspace != nullptr && isDynamicRegistrationSupported(workspace->symbol);
   }

   bool isWorkspaceChangeWatchedFilesDynamicRegistered()
   {
       return v3supported && workspace != nullptr && isDynamicRegistrationSupported(workspace->didChangeWatchedFiles);
   }

   bool isDocumentSymbolDynamicRegistered()
   {
       return v3supported && isDynamicRegistrationSupported(textDocument.documentSymbol);
   }

   bool isCodeActionDynamicRegistered()
   {
       return v3supported && isDynamicRegistrationSupported(textDocument.codeAction);
   }

   bool isDefinitionDynamicRegistered()
   {
       return v3supported && isDynamicRegistrationSupported(textDocument.definition);
   }

   bool isTypeDefinitionDynamicRegistered()
   {
       return v3supported && isDynamicRegistrationSupported(textDocument.typeDefinition);
   }

   bool isHoverDynamicRegistered()
   {
       return v3supported && isDynamicRegistrationSupported(textDocument.hover);
   }

   bool isReferencesDynamicRegistered()
   {
       return v3supported && isDynamicRegistrationSupported(textDocument.references);
   }

   bool isDocumentHighlightDynamicRegistered()
   {
       return v3supported && isDynamicRegistrationSupported(textDocument.documentHighlight);
   }

   bool isDocumentLinkDynamicRegistered()
   {
       return v3supported && isDynamicRegistrationSupported(textDocument.documentLink);
   }

   bool isFoldgingRangeDynamicRegistered()
   {
       return v3supported && isDynamicRegistrationSupported(textDocument.foldingRange);
   }

   bool isInlayHintDynamicRegistered()
   {
       return v3supported && isDynamicRegistrationSupported(textDocument.inlayHint);
   }

   bool isImplementationDynamicRegistered()
   {
       return v3supported && isDynamicRegistrationSupported(textDocument.implementation);
   }

   bool isSelectionRangeDynamicRegistered()
   {
       return v3supported && isDynamicRegistrationSupported(textDocument.selectionRange);
   }

   bool isWillSaveRegistered()
   {
       return v3supported && isTrue(textDocument.synchronization.willSave);
   }

   bool isWillSaveWaitUntilRegistered()
   {
       return v3supported && isTrue(textDocument.synchronization.willSaveWaitUntil);
   }

   bool isWorkspaceApplyEditSupported()
   {
       return workspace != nullptr && isTrue(workspace->applyEdit);
   }

   bool isSupportsCompletionDocumentationMarkdown()
   {

       if (!v3supported || !textDocument.completion)
       {
           return false;
       }
       auto const& completion = textDocument.completion.value();
       if (completion.completionItem)
       {
           auto& documentationFormat = completion.completionItem.value().documentationFormat;
           if (documentationFormat)
           {
               auto& data = documentationFormat.value();
               for (auto& it : data)
               {
                   if (it == "markdown")
                   {
                       return true;
                   }
               }
           }
       }
       return false;
   }

   bool isWorkspaceEditResourceChangesSupported()
   {
       if (!workspace)
       {
           return false;
       }

       if (workspace->workspaceEdit)
       {
           return isTrue(workspace->workspaceEdit.value().resourceChanges);
       }
       return false;
   }
   static bool contains(std::vector<std::string> const& v, std::string const& target)
   {
       for (auto& it : v)
       {
           if (it == target)
           {
               return true;
           }
       }
       return false;
   }
   bool isResourceOperationSupported() const
   {
       if (!workspace)
       {
           return false;
       }
       if (!workspace->workspaceEdit)
       {
           return false;
       }
       auto& it = (workspace->workspaceEdit.value());
       if (!it.resourceOperations)
       {
           return false;
       }
       auto const& resourceOperations = it.resourceOperations.value();
       return contains(resourceOperations, "create") && contains(resourceOperations, "rename")
              && contains(resourceOperations, "delete");
   }

   /**
        * {@code true} if the client has explicitly set the
        * {@code textDocument.documentSymbol.hierarchicalDocumentSymbolSupport} to
        * {@code true} when initializing the LS. Otherwise, {@code false}.
        */
   bool isHierarchicalDocumentSymbolSupported()
   {
       if (!v3supported || !textDocument.documentSymbol)
       {
           return false;
       }
       return isTrue(textDocument.documentSymbol.value().hierarchicalDocumentSymbolSupport);
   }

   bool isSemanticHighlightingSupported()
   {
       //@formatter:off
       if (!v3supported || !textDocument.semanticHighlightingCapabilities)
       {
           return false;
       }
       return isTrue(textDocument.semanticHighlightingCapabilities.value().semanticHighlighting);
       //@formatter:on
   }

   /**
        * {@code true} if the client has explicitly set the
        * {@code textDocument.codeAction.codeActionLiteralSupport.codeActionKind.valueSet}
        * value. Otherwise, {@code false}.
        */
   bool isSupportedCodeActionKind(std::string const& kind)
   {
       if (!v3supported || !textDocument.codeAction)
       {
           return false;
       }
       //@formatter:off
       auto const& codeAction = textDocument.codeAction.value();
       if (codeAction.codeActionLiteralSupport)
       {
           auto const& codeActionKind = codeAction.codeActionLiteralSupport.value().codeActionKind;
           if (codeActionKind)
           {
               auto const& valueSet = codeActionKind.value().valueSet;
               if (valueSet)
               {
                   for (auto& k : valueSet.value())
                   {
                       if (lsp::StartsWith(kind, k))
                       {
                           return true;
                       }
                   }
               }
           }
       }
       return false;

       //@formatter:on
   }

   /**
        * {@code true} if the client has explicitly set the
        * {@code textDocument.publishDiagnostics.tagSupport} to
        * {@code true} when initializing the LS. Otherwise, {@code false}.
        */
   bool isDiagnosticTagSupported()
   {
       if (!v3supported || !textDocument.publishDiagnostics)
       {
           return false;
       }
       auto const& publishDiagnostics = textDocument.publishDiagnostics.value();
       if (publishDiagnostics.tagSupport)
       {
           isTagSupported(publishDiagnostics.tagSupport);
       }
       return false;
   }

   bool isTagSupported(optional<std::pair<optional<bool>, optional<DiagnosticsTagSupport>>> const& tagSupport)
   {
       if (tagSupport)
       {
           auto& v = tagSupport.value();
           if (v.first)
           {
               return v.first.value();
           }
           if (v.second)
           {
               return !v.second.value().valueSet.empty();
           }
       }
       return false;
   }

   bool isCallHierarchyDynamicRegistered()
   {
       return v3supported && isDynamicRegistrationSupported(textDocument.callHierarchy);
   }
};

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.