Microsoft Information Protection SDK - Osservatori di File SDK

Articolo
01/30/2024

File SDK contiene due classi observer. I membri observer sono virtuali e possono essere sottoposti a override per gestire i callback degli eventi.

Al termine di un'operazione asincrona, viene chiamata la OnXxx() funzione membro corrispondente al risultato. Gli esempi sono OnLoadSuccess(), OnLoadFailure()e OnAddEngineSuccess() per mip::FileProfile::Observer.

Gli esempi seguenti illustrano il modello promise/future, che viene usato anche dagli esempi dell'SDK e possono essere estesi per implementare il comportamento di callback desiderato.

Implementazione di File Profile Observer

Nell'esempio seguente è stata creata una classe derivata ProfileObserver da mip::FileProfile::Observer. Le funzioni membro sono state sottoposte a override per usare il modello futuro/promessa usato in tutti gli esempi.

Nota: gli esempi seguenti sono implementati solo parzialmente e non includono sostituzioni per gli mip::FileEngine osservatori correlati.

profile_observer.h

Nell'intestazione si definisce ProfileObserver, derivando da mip::FileProfile::Observer, quindi si esegue l'override di ognuna delle funzioni membro.

class ProfileObserver final : public mip::FileProfile::Observer {
public:
ProfileObserver() { }
  void OnLoadSuccess(const std::shared_ptr<mip::FileProfile>& profile, const std::shared_ptr<void>& context) override;
  void OnLoadFailure(const std::exception_ptr& error, const std::shared_ptr<void>& context) override;
  //TODO: Implement mip::FileEngine related observers.
};

profile_observer.cpp

Nell'implementazione stessa viene definita un'azione da eseguire per ogni funzione membro osservatore.

Ogni membro accetta due parametri. Il primo è un puntatore condiviso alla classe gestita nella funzione. ProfileObserver::OnLoadSuccess si prevede di ricevere un oggetto mip::FileProfile. ProfileObserver::OnAddEngineSuccess si aspetterebbe mip::FileEngine.

Il secondo è un puntatore condiviso al contesto. Nell'implementazione il contesto è un riferimento a un std::promiseoggetto , passato per riferimento come std::shared_ptr<void>. La prima riga della funzione esegue il cast di questo oggetto in std::promise, quindi archiviato in un oggetto denominato promise.

Infine, il futuro è pronto impostando promise->set_value() e passando l'oggetto mip::FileProfile .

#include "profile_observer.h"
#include <future>

//Called when FileProfile is successfully loaded
void ProfileObserver::OnLoadSuccess(const std::shared_ptr<mip::FileProfile>& profile, const std::shared_ptr<void>& context) {
  //cast context to promise
  auto promise = 
  std::static_pointer_cast<std::promise<std::shared_ptr<mip::FileProfile>>>(context);
  //set promise value to profile
  promise->set_value(profile);
}

//Called when FileProfile fails to load
void ProfileObserver::OnLoadFailure(const std::exception_ptr& error, const std::shared_ptr<void>& context) {
  auto promise = std::static_pointer_cast<std::promise<std::shared_ptr<mip::FileProfile>>>(context);
  promise->set_exception(error);
}

//TODO: Implement mip::FileEngine related observers.

Quando si crea un'istanza di qualsiasi classe SDK o si usa una funzione che esegue operazioni asincrone, si passerà l'implementazione dell'osservatore al costruttore delle impostazioni o alla funzione asincrona stessa. Quando si crea un'istanza dell'oggetto mip::FileProfile::Settings , il costruttore accetta mip::FileProfile::Observer come uno dei parametri. L'esempio seguente mostra l'oggetto personalizzato ProfileObserverusato in un mip::FileProfile::Settings costruttore.

Implementazione di FileHandler Observer

Analogamente all'osservatore del profilo, mip::FileHandler implementa una mip::FileHandler::Observers classe per la gestione delle notifiche di eventi asincrone durante le operazioni sui file. L'implementazione è simile a quella descritta in precedenza. FileHandlerObserver è parzialmente definito di seguito.

file_handler_observer.h

#include "mip/file/file_handler.h"

class FileHandlerObserver final : public mip::FileHandler::Observer {
public:
  void OnCreateFileHandlerSuccess(
      const std::shared_ptr<mip::FileHandler>& fileHandler,
      const std::shared_ptr<void>& context) override;

  void OnCreateFileHandlerFailure(
      const std::exception_ptr& error,
      const std::shared_ptr<void>& context) override;

  //TODO: override remaining member functions inherited from mip::FileHandler::Observer
};

file_handler_observer.cpp

Questo esempio è solo le prime due funzioni, ma le funzioni rimanenti usano un modello simile a questi e a ProfileObserver.

#include "file_handler_observer.h"

void FileHandlerObserver::OnCreateFileHandlerSuccess(const std::shared_ptr<mip::FileHandler>& fileHandler, const std::shared_ptr<void>& context) {
    auto promise = std::static_pointer_cast<std::promise<std::shared_ptr<mip::FileHandler>>>(context);
    promise->set_value(fileHandler);
}

void FileHandlerObserver::OnCreateFileHandlerFailure(const std::exception_ptr& error, const std::shared_ptr<void>& context) {
    auto promise = std::static_pointer_cast<std::promise<std::shared_ptr<mip::FileHandler>>>(context);
    promise->set_exception(error);
}

//TODO: override remaining member functions inherited from mip::FileHandler::Observer

Condividi tramite