Microsoft Information Protection SDK: Observadores del SDK de archivo

El SDK de archivo contiene dos clases de observador. Los miembros del observador son virtuales y se pueden invalidar para controlar las devolución de llamada de eventos.

Cuando se completa una operación asincrónica, se llama a la función OnXxx() miembro correspondiente al resultado. Algunos ejemplos OnLoadSuccess() son , y para OnLoadFailure()OnAddEngineSuccess()mip::FileProfile::Observer .

En los ejemplos siguientes se muestra el patrón de promesa/futuro, que también se usa en los ejemplos del SDK y se puede ampliar para implementar el comportamiento de devolución de llamada deseado.

Implementación del observador de perfil de archivo

En el siguiente ejemplo, hemos creado una clase, ProfileObserver que se deriva de mip::FileProfile::Observer . Las funciones miembro se han anulado para usar el patrón de promesa/futuro usado en las muestras.

Nota:Los ejemplos siguientes solo se implementan parcialmente y no incluyen invalidaciones para los observadores relacionados.

profile_observer.h

En el encabezado, definimos ProfileObserver , derivando de y, a continuación, mip::FileProfile::Observer reemplazamos cada una de las funciones miembro.

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

En la propia implementación, definimos una acción para cada función miembro del observador.

Cada miembro acepta dos parámetros. El primero es un puntero compartido a la clase que estamos administrando en la función. ProfileObserver::OnLoadSuccess esperaría recibir un mip::FileProfile . ProfileObserver::OnAddEngineSuccess esperaría mip::FileEngine .

El segundo es un puntero compartido al contexto. En nuestra implementación, el contexto es una referencia a una std::promise , pasada por referencia como std::shared_ptr<void> . La primera línea de la función la convierte en y, a std::promise continuación, se almacena en un objeto llamado promise .

Por último, el futuro está listo estableciendo el promise->set_value() objeto y mip::FileProfile pasandolo.

#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.

Cuando creamos instancias de cualquier clase de SDK o usamos una función que realiza operaciones asincrónicas, pasaremos la implementación del observador al constructor de configuración o a la función asincrónica en sí. Al crear una instancia del mip::FileProfile::Settings objeto, el constructor toma mip::FileProfile::Observer como uno de los parámetros. En el ejemplo siguiente se muestra nuestro ProfileObserver personalizado , usado en un mip::FileProfile::Settings constructor.

Implementación de Observador de FileHandler

De forma similar al observador de perfil, implementa una clase para controlar las notificaciones de mip::FileHandlermip::FileHandler::Observers eventos asíncronas durante las operaciones de archivo. La implementación es similar a la que se ha detallado anteriormente. FileHandlerObserver se define parcialmente a continuación.

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

Este ejemplo es solo las dos primeras funciones, pero las funciones restantes usan un patrón similar a estas y 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