compute_engine.h

Go to the documentation of this file.

#ifndef UPE_CORE_API_COMPUTE_ENGINE_H_
#define UPE_CORE_API_COMPUTE_ENGINE_H_
 
#include <map>
#include <memory>
#include <string>
#include <vector>
 
#include "core/api/diagnostic/diagnostic_event_factory.h"
#include "mip/audit_delegate.h"
#include "mip/common_types.h"
#include "mip/flighting_feature.h"
#include "mip/logger_delegate.h"
#include "mip/mip_namespace.h"
#include "mip/telemetry_delegate.h"
#include "mip/upe/action.h"
#include "mip/upe/content_label.h"
#include "mip/upe/core/application_action_state.h"
#include "mip/upe/core/compute_engine_context.h"
#include "mip/upe/core/document_state.h"
#include "mip/upe/core/dto/sync_file_data.h"
#include "mip/upe/core/upe_core_export.h"
#include "mip/upe/label.h"
#include "mip/upe/sensitivity_types_rule_package.h"
 
MIP_NAMESPACE_BEGIN
 
class ComputeEngine {
public:
 
  virtual const std::vector<std::shared_ptr<Label>> ListSensitivityLabels(
      const std::vector<std::string>& contentFormats = std::vector<std::string>()) = 0;
 
  virtual std::shared_ptr<ContentLabel> GetSensitivityLabel(
      ComputeEngineContext& context,
      const DocumentState& state) = 0;
 
  virtual std::vector<std::shared_ptr<Action>> ComputeActions(
      ComputeEngineContext& context,
      const DocumentState& documentState,
      const ApplicationActionState& actionState) = 0;
 
  virtual std::pair<std::vector<std::shared_ptr<Action>>, bool> ComputeActionsWithRemoteState(
      ComputeEngineContext& context,
      const DocumentState& localDocumentState,
      const DocumentState& remoteDocumentState,
      const ApplicationActionState& actionState) = 0;
 
  virtual void NotifyCommittedActions(
      ComputeEngineContext& context,
      const DocumentState& documentState,
      const ApplicationActionState& actionState) = 0;
 
  virtual const std::shared_ptr<Label> GetDefaultLabel(const std::string& contentFormat = std::string()) const = 0;
  
  virtual const std::string& GetMoreInfoUrl() const = 0;
 
  virtual const std::string& GetUpn() const = 0;
 
  virtual bool IsLabelingRequired(const std::string& contentFormat = std::string()) const = 0;
 
  virtual bool IsDowngradeJustificationRequired() const = 0;
 
  virtual const std::string& GetFileId() const = 0;
 
  virtual bool HasClassificationRules(const std::vector<std::string>& contentFormats = std::vector<std::string>()) const = 0;
 
  virtual bool IsEnhancedClassificationEnabled() const = 0;
 
  virtual std::shared_ptr<Label> GetLabelById(const std::string& id) const = 0;
 
  virtual const std::string& GetTenantId() const = 0;
 
  virtual void SetSensitivityTypesRulePackages(std::vector<std::shared_ptr<SensitivityTypesRulePackage>>&& custom) = 0;
  
  virtual const std::vector<std::shared_ptr<SensitivityTypesRulePackage>>& GetSensitivityTypesRulePackages() const = 0;
 
  virtual const std::vector<std::pair<std::string, std::string>>& GetCustomSettings() const = 0;
 
  virtual uint32_t GetOpcMetadataVersion() const = 0;
 
  virtual const std::string& GetUserObjectId() const = 0;
  
  virtual bool HasWorkloadConsent(Workload workload) const = 0;
 
  class Settings {
 
  public:
    Settings(
        const Identity& identity,
        const ApplicationInfo& applicationInfo,
        const std::shared_ptr<TelemetryDelegate>& telemetryDelegate,
        const std::shared_ptr<AuditDelegate>& auditDelegate,
        const std::shared_ptr<DiagnosticEventFactory>& eventFactory,
        LogLevel thresholdLogLevel,
        const std::shared_ptr<LoggerDelegate>& loggerDelegate,
        const std::string& hostName,
        const std::vector<std::pair<std::string, std::string>>& customProperties,
        const std::vector<LabelFilterType>& deprecatedFilters,
        const std::map<FunctionalityFilterType, bool>& configuredFunctionality)
      : mIdentity(identity),
        mApplicationInfo(applicationInfo),
        mTelemetryDelegate(telemetryDelegate),
        mAuditDelegate(auditDelegate),
        mEventFactory(eventFactory),
        mThresholdLogLevel(thresholdLogLevel),
        mLoggerDelegate(loggerDelegate),
        mHostName(hostName),
        mCustomProperties(customProperties),
        mDeprecatedLabelFilters(deprecatedFilters),
        mConfiguredFunctionality(configuredFunctionality) {}
 
    const Identity& GetIdentity() const { return mIdentity; }
    
    void SetIdentity(const Identity& identity) { mIdentity = identity; }
 
    const ApplicationInfo& GetApplicationInfo() const { return mApplicationInfo; }
 
    std::shared_ptr<TelemetryDelegate> GetTelemetryDelegate() const { return mTelemetryDelegate; }
 
    std::shared_ptr<AuditDelegate> GetAuditDelegate() const { return mAuditDelegate; }
 
    std::shared_ptr<DiagnosticEventFactory> GetEventFactory() const { return mEventFactory; }
 
    std::shared_ptr<LoggerDelegate> GetLoggerDelegate() const { return mLoggerDelegate; }
 
    const std::string& GetHostName() const { return mHostName; }
 
    const std::vector<std::pair<std::string, std::string>>& GetCustomProperties() const { return mCustomProperties; };
 
    void SetParentCorrelationId(const std::string correlationId, const std::string description) {
      mParentCorrelationId = correlationId;
      mParentCorrelationIdDescription = description;
    }
 
    const std::string& GetParentCorrelationId() const {
      return mParentCorrelationId;
    }
 
    const std::string& GetParentCorrelationIdDescription() const {
      return mParentCorrelationIdDescription;
    }
 
    const std::vector<LabelFilterType>& GetDeprecatedLabelFilter() const {
      return mDeprecatedLabelFilters;
    }
    
    const std::map<FunctionalityFilterType, bool>& GetConfiguredFunctionality() const { return mConfiguredFunctionality; }
 
    void SetVariableTextMarkingType(VariableTextMarkingType variableTextMarkingType) {
      mVariableTextMarkingType = variableTextMarkingType;
    }
 
    VariableTextMarkingType GetVariableTextMarkingType() const {
      return mVariableTextMarkingType;
    }
 
    LogLevel GetThresholdLogLevel() const {
      return mThresholdLogLevel;
    }
 
    const std::shared_ptr<void>& GetLoggerContext() const { return mLoggerContext; }
 
    void SetLoggerContext(const std::shared_ptr<void>& loggerContext) {
      mLoggerContext = loggerContext;
    }
 
  private:
    Identity mIdentity;
    ApplicationInfo mApplicationInfo;
    std::shared_ptr<TelemetryDelegate> mTelemetryDelegate;
    std::shared_ptr<AuditDelegate> mAuditDelegate;
    std::shared_ptr<DiagnosticEventFactory> mEventFactory;
    LogLevel mThresholdLogLevel;
    std::shared_ptr<LoggerDelegate> mLoggerDelegate;
    std::string mHostName;
    std::vector<std::pair<std::string, std::string>> mCustomProperties;
    std::vector<LabelFilterType> mDeprecatedLabelFilters;    //Labels that the client does not want to view
    std::map<FunctionalityFilterType, bool> mConfiguredFunctionality;  //Functionality that has been turned on or off
    std::string mParentCorrelationId;
    std::string mParentCorrelationIdDescription;
    VariableTextMarkingType mVariableTextMarkingType = VariableTextMarkingType::Default;
    std::shared_ptr<void> mLoggerContext;
  };
 
  MIP_UPE_CORE_API static std::shared_ptr<ComputeEngine> Create(
      const SyncFilePolicyData& policyData,
      const ComputeEngine::Settings& settings);
 
  MIP_UPE_CORE_API static std::shared_ptr<ComputeEngineContext> CreateContext(
      const std::map<FlightingFeature, bool>& flightingFeatures,
      bool isAuditDiscoveryEnabled);
  
  virtual ~ComputeEngine() {};
};
 
MIP_NAMESPACE_END
 
#endif  // UPE_CORE_API_COMPUTE_ENGINE_H_