694 lines
23 KiB
C++
694 lines
23 KiB
C++
/**
|
|
* @file wfassoc++.h
|
|
* @brief Windows File Association C++ API header
|
|
*
|
|
* This header provides C++ API for managing Windows file associations,
|
|
* based on its C-compatible API.
|
|
* The API is designed to work with at least C++17.
|
|
*/
|
|
|
|
#pragma once
|
|
#ifndef WFASSOCPP_H_
|
|
#define WFASSOCPP_H_
|
|
|
|
#include "wfassoc.h"
|
|
#include <optional>
|
|
#include <stdexcept>
|
|
#include <string>
|
|
#include <utility>
|
|
|
|
/**
|
|
* @brief Windows File Association C++ API namespace
|
|
*
|
|
* Provides C++ RAII wrappers around the C-compatible wfassoc API.
|
|
*/
|
|
namespace wfassocpp {
|
|
|
|
/** @brief Type representing a null-terminated UTF-8 C-style string */
|
|
using CString = wfassoc::WFCString;
|
|
/**
|
|
* @brief Type representing a handle/token for managed objects
|
|
*
|
|
* This library uses an object pool to manage any objects created during calling.
|
|
* This type is exposed as an opaque handle for visiting your created object.
|
|
*/
|
|
using Token = wfassoc::WFToken;
|
|
/**
|
|
* @brief Type representing an icon handle (opaque pointer)
|
|
*
|
|
* This type is equivalent to the Win32 HICON type.
|
|
*/
|
|
using HICON = wfassoc::WFHICON;
|
|
/** @brief Invalid icon handle value */
|
|
using INVALID_HICON = wfassoc::WF_INVALID_HICON;
|
|
/** @brief Invalid index value used for error conditions */
|
|
using INVALID_INDEX = wfassoc::WF_INVALID_INDEX;
|
|
/**
|
|
* @brief Registration scope for file associations
|
|
*
|
|
* Determines whether a program is registered for the current user or system-wide.
|
|
*/
|
|
using Scope = wfassoc::WFScope;
|
|
/**
|
|
* @brief View mode for querying file association status
|
|
*
|
|
* Determines how the association status is viewed/queried.
|
|
*/
|
|
using View = wfassoc::WFView;
|
|
|
|
/**
|
|
* @private
|
|
* @brief Check the result of a C API call and throw on failure
|
|
*
|
|
* @param[in] result Boolean result from a C API call
|
|
* @throws std::runtime_error if result is false, with the error message from WFGetLastError()
|
|
*/
|
|
inline void _Check(bool result) {
|
|
if (!result) {
|
|
throw std::runtime_error(wfassoc::WFGetLastError());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @private
|
|
* @brief Get the invalid token value
|
|
*
|
|
* In theory, invalid token value should be a constant value.
|
|
* However, due to the library used in Rust side, this value can only be fetched at runtime.
|
|
* This function caches the value on first call for subsequent use.
|
|
*
|
|
* @return An invalid token value
|
|
*/
|
|
inline Token _INVALID_TOKEN() {
|
|
static Token v = wfassoc::WFInvalidToken();
|
|
return v;
|
|
}
|
|
|
|
/**
|
|
* @brief Schema object for defining a program's file association configuration
|
|
*
|
|
* A Schema is a sketchpad of a complete program.
|
|
* Create a Schema object first, then convert it to a Program object for following operations.
|
|
*
|
|
* This class is move-only (non-copyable).
|
|
*/
|
|
class Schema {
|
|
public:
|
|
/**
|
|
* @brief Construct a new Schema object
|
|
* @throws std::runtime_error if schema creation fails
|
|
*/
|
|
Schema() { _Check(wfassoc::WFSchemaCreate(&_token)); }
|
|
|
|
/**
|
|
* @brief Destroy the Schema object
|
|
*
|
|
* Releases resources associated with the Schema object.
|
|
*/
|
|
~Schema() {
|
|
if (_token != _INVALID_TOKEN()) {
|
|
wfassoc::WFSchemaDestroy(_token);
|
|
}
|
|
}
|
|
|
|
/** @brief Non-copyable */
|
|
Schema(const Schema&) = delete;
|
|
/** @brief Non-copyable */
|
|
Schema& operator=(const Schema&) = delete;
|
|
|
|
/** @brief Move constructor */
|
|
Schema(Schema&& other) noexcept : _token(other._token) { other._token = _INVALID_TOKEN(); }
|
|
/** @brief Move assignment operator */
|
|
Schema& operator=(Schema&& other) noexcept {
|
|
if (this != &other) {
|
|
if (_token != _INVALID_TOKEN()) {
|
|
wfassoc::WFSchemaDestroy(_token);
|
|
}
|
|
_token = other._token;
|
|
other._token = _INVALID_TOKEN();
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
/**
|
|
* @brief Set the program identifier for this Schema
|
|
*
|
|
* @param[in] value Null-terminated UTF-8 string containing the identifier.
|
|
* This identifier should not be empty, must start with alphabet character,
|
|
* and follow with alphabet characters, digits, underline, or hyphens.
|
|
* @throws std::runtime_error if the operation fails
|
|
*/
|
|
void SetIdentifier(const char* value) { _Check(wfassoc::WFSchemaSetIdentifier(_token, value)); }
|
|
|
|
/**
|
|
* @brief Set the program path for this Schema
|
|
*
|
|
* @param[in] value Null-terminated UTF-8 string containing the program path.
|
|
* This path should be the fully qualified path to the application.
|
|
* @throws std::runtime_error if the operation fails
|
|
*/
|
|
void SetPath(const char* value) { _Check(wfassoc::WFSchemaSetPath(_token, value)); }
|
|
|
|
/**
|
|
* @brief Set the program CLSID for this Schema
|
|
*
|
|
* @param[in] value Null-terminated UTF-8 string containing the CLSID.
|
|
* This CLSID string should be in the format of @c {xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}.
|
|
* Please note that curly braces are required.
|
|
* @throws std::runtime_error if the operation fails
|
|
*/
|
|
void SetClsid(const char* value) { _Check(wfassoc::WFSchemaSetClsid(_token, value)); }
|
|
|
|
/**
|
|
* @brief Set the program name for this Schema (optional)
|
|
*
|
|
* @param[in] value Null-terminated UTF-8 string containing the name, or nullptr to clear
|
|
* @throws std::runtime_error if the operation fails
|
|
*/
|
|
void SetName(const char* value) { _Check(wfassoc::WFSchemaSetName(_token, value)); }
|
|
|
|
/**
|
|
* @brief Set the program icon for this Schema (optional)
|
|
*
|
|
* @param[in] value Null-terminated UTF-8 string containing the icon path, or nullptr to clear
|
|
* @throws std::runtime_error if the operation fails
|
|
*/
|
|
void SetIcon(const char* value) { _Check(wfassoc::WFSchemaSetIcon(_token, value)); }
|
|
|
|
/**
|
|
* @brief Set the program behavior for this Schema (optional)
|
|
*
|
|
* @param[in] value Null-terminated UTF-8 string containing the behavior command, or nullptr to clear
|
|
* @throws std::runtime_error if the operation fails
|
|
*/
|
|
void SetBehavior(const char* value) { _Check(wfassoc::WFSchemaSetBehavior(_token, value)); }
|
|
|
|
/**
|
|
* @brief Add a string resource entry to this Schema
|
|
*
|
|
* @param[in] name Null-terminated UTF-8 string containing the name of this entry
|
|
* @param[in] value Null-terminated UTF-8 string containing the value of this entry.
|
|
* It can be a plain string or a reference string to resource.
|
|
* @throws std::runtime_error if the operation fails
|
|
*/
|
|
void AddStr(const char* name, const char* value) { _Check(wfassoc::WFSchemaAddStr(_token, name, value)); }
|
|
|
|
/**
|
|
* @brief Add an icon registry entry to this Schema
|
|
*
|
|
* @param[in] name Null-terminated UTF-8 string containing the name of this entry
|
|
* @param[in] value Null-terminated UTF-8 string containing the value of this entry.
|
|
* It can be a path to icon or a reference string to resource.
|
|
* @throws std::runtime_error if the operation fails
|
|
*/
|
|
void AddIcon(const char* name, const char* value) { _Check(wfassoc::WFSchemaAddIcon(_token, name, value)); }
|
|
|
|
/**
|
|
* @brief Add a behavior registry entry to this Schema
|
|
*
|
|
* @param[in] name Null-terminated UTF-8 string containing the name of this entry
|
|
* @param[in] value Null-terminated UTF-8 string containing the value of this entry.
|
|
* It should be a valid command line string which uses @c %1, @c %2, etc. to represent parameters.
|
|
* @throws std::runtime_error if the operation fails
|
|
*/
|
|
void AddBehavior(const char* name, const char* value) { _Check(wfassoc::WFSchemaAddBehavior(_token, name, value)); }
|
|
|
|
/**
|
|
* @brief Add a file extension to this Schema
|
|
*
|
|
* @param[in] ext Null-terminated UTF-8 string containing the file extension name (without leading dot)
|
|
* @param[in] ext_name Null-terminated UTF-8 string containing the name pointing to associated name for this extension.
|
|
* This name should be registered by calling AddStr().
|
|
* @param[in] ext_icon Null-terminated UTF-8 string containing the name pointing to associated icon for this extension.
|
|
* This name should be registered by calling AddIcon().
|
|
* @param[in] ext_behavior Null-terminated UTF-8 string containing the name pointing to associated behavior for this extension.
|
|
* This name should be registered by calling AddBehavior().
|
|
* @throws std::runtime_error if the operation fails
|
|
*/
|
|
void AddExt(const char* ext, const char* ext_name, const char* ext_icon, const char* ext_behavior) {
|
|
_Check(wfassoc::WFSchemaAddExt(_token, ext, ext_name, ext_icon, ext_behavior));
|
|
}
|
|
|
|
private:
|
|
friend class Program;
|
|
|
|
/**
|
|
* @private
|
|
* @brief Release ownership of the token
|
|
*
|
|
* @return The released token
|
|
*/
|
|
Token Release() noexcept {
|
|
Token t = _token;
|
|
_token = _INVALID_TOKEN();
|
|
return t;
|
|
}
|
|
|
|
Token _token;
|
|
};
|
|
|
|
/**
|
|
* @brief Icon resource object for managing icon handles
|
|
*
|
|
* This class wraps an icon resource token and provides access to the icon handle.
|
|
* The icon handle will be freed when this object is destroyed.
|
|
*
|
|
* This class is move-only (non-copyable).
|
|
*/
|
|
class IconRc {
|
|
public:
|
|
/**
|
|
* @brief Construct an IconRc from an existing token
|
|
*
|
|
* @param[in] token The icon resource token to wrap
|
|
*/
|
|
explicit IconRc(Token token) : _token(token) {}
|
|
|
|
/**
|
|
* @brief Destroy the IconRc object
|
|
*
|
|
* Releases resources associated with the icon resource.
|
|
*/
|
|
~IconRc() {
|
|
if (_token != _INVALID_TOKEN()) {
|
|
wfassoc::WFIconRcDestroy(_token);
|
|
}
|
|
}
|
|
|
|
/** @brief Non-copyable */
|
|
IconRc(const IconRc&) = delete;
|
|
/** @brief Non-copyable */
|
|
IconRc& operator=(const IconRc&) = delete;
|
|
|
|
/** @brief Move constructor */
|
|
IconRc(IconRc&& other) noexcept : _token(other._token) { other._token = _INVALID_TOKEN(); }
|
|
/** @brief Move assignment operator */
|
|
IconRc& operator=(IconRc&& other) noexcept {
|
|
if (this != &other) {
|
|
if (_token != _INVALID_TOKEN()) {
|
|
wfassoc::WFIconRcDestroy(_token);
|
|
}
|
|
_token = other._token;
|
|
other._token = _INVALID_TOKEN();
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
/**
|
|
* @brief Get the icon handle from this icon resource
|
|
*
|
|
* @return The icon handle. This handle will be freed when this object is destroyed.
|
|
* Please make a copy immediately if you need to use it longer.
|
|
* @throws std::runtime_error if the operation fails
|
|
*/
|
|
HICON GetIcon() {
|
|
HICON icon = nullptr;
|
|
_Check(wfassoc::WFIconRcGetIcon(_token, &icon));
|
|
return icon;
|
|
}
|
|
|
|
private:
|
|
Token _token;
|
|
};
|
|
|
|
/**
|
|
* @brief Extension status object for querying file extension registration status
|
|
*
|
|
* This class wraps an extension status token and provides access to extension details.
|
|
* The extension status object will be freed when this object is destroyed.
|
|
*
|
|
* This class is move-only (non-copyable).
|
|
*/
|
|
class ExtStatus {
|
|
public:
|
|
/**
|
|
* @brief Construct an ExtStatus from an existing token
|
|
*
|
|
* @param[in] token The extension status token to wrap
|
|
*/
|
|
explicit ExtStatus(Token token) : _token(token) {}
|
|
|
|
/**
|
|
* @brief Destroy the ExtStatus object
|
|
*
|
|
* Releases resources associated with the extension status.
|
|
*/
|
|
~ExtStatus() {
|
|
if (_token != _INVALID_TOKEN()) {
|
|
wfassoc::WFExtStatusDestroy(_token);
|
|
}
|
|
}
|
|
|
|
/** @brief Non-copyable */
|
|
ExtStatus(const ExtStatus&) = delete;
|
|
/** @brief Non-copyable */
|
|
ExtStatus& operator=(const ExtStatus&) = delete;
|
|
|
|
/** @brief Move constructor */
|
|
ExtStatus(ExtStatus&& other) noexcept : _token(other._token) { other._token = _INVALID_TOKEN(); }
|
|
/** @brief Move assignment operator */
|
|
ExtStatus& operator=(ExtStatus&& other) noexcept {
|
|
if (this != &other) {
|
|
if (_token != _INVALID_TOKEN()) {
|
|
wfassoc::WFExtStatusDestroy(_token);
|
|
}
|
|
_token = other._token;
|
|
other._token = _INVALID_TOKEN();
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
/**
|
|
* @brief Get the display name from this extension status
|
|
*
|
|
* The display name will be user specified first, then fallback to its ProgId verbatim.
|
|
* The library will try to use localized name first, then use raw ProgId name if localized name is not available.
|
|
*
|
|
* @return The display name string. There is no possibility that this value is empty.
|
|
* @throws std::runtime_error if the operation fails
|
|
*/
|
|
std::string GetName() {
|
|
const char* name = nullptr;
|
|
_Check(wfassoc::WFExtStatusGetName(_token, &name));
|
|
return std::string(name);
|
|
}
|
|
|
|
/**
|
|
* @brief Get the icon from this extension status
|
|
*
|
|
* The icon will be user specified first, then fallback to the system default file icon.
|
|
*
|
|
* @return The icon handle. This handle will be freed when this object is destroyed.
|
|
* Please make a copy immediately if you need to use it longer.
|
|
* @throws std::runtime_error if the operation fails
|
|
*/
|
|
HICON GetIcon() {
|
|
HICON icon = nullptr;
|
|
_Check(wfassoc::WFExtStatusGetIcon(_token, &icon));
|
|
return icon;
|
|
}
|
|
|
|
private:
|
|
Token _token;
|
|
};
|
|
|
|
/**
|
|
* @brief Self extension status object for accessing program-provided extension details
|
|
*
|
|
* This class wraps a self extension status token and provides access to extension details
|
|
* as defined by the program itself.
|
|
*
|
|
* This class is move-only (non-copyable).
|
|
*/
|
|
class SelfExtStatus {
|
|
public:
|
|
/**
|
|
* @brief Construct a SelfExtStatus from an existing token
|
|
*
|
|
* @param[in] token The self extension status token to wrap
|
|
*/
|
|
explicit SelfExtStatus(Token token) : _token(token) {}
|
|
|
|
/**
|
|
* @brief Destroy the SelfExtStatus object
|
|
*
|
|
* Releases resources associated with the self extension status.
|
|
*/
|
|
~SelfExtStatus() {
|
|
if (_token != _INVALID_TOKEN()) {
|
|
wfassoc::WFSelfExtStatusDestroy(_token);
|
|
}
|
|
}
|
|
|
|
/** @brief Non-copyable */
|
|
SelfExtStatus(const SelfExtStatus&) = delete;
|
|
/** @brief Non-copyable */
|
|
SelfExtStatus& operator=(const SelfExtStatus&) = delete;
|
|
|
|
/** @brief Move constructor */
|
|
SelfExtStatus(SelfExtStatus&& other) noexcept : _token(other._token) { other._token = _INVALID_TOKEN(); }
|
|
/** @brief Move assignment operator */
|
|
SelfExtStatus& operator=(SelfExtStatus&& other) noexcept {
|
|
if (this != &other) {
|
|
if (_token != _INVALID_TOKEN()) {
|
|
wfassoc::WFSelfExtStatusDestroy(_token);
|
|
}
|
|
_token = other._token;
|
|
other._token = _INVALID_TOKEN();
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
/**
|
|
* @brief Get the display name from this self extension status
|
|
*
|
|
* The display name will be user specified first, then fallback to its ProgId verbatim.
|
|
*
|
|
* @return The display name string. There is no possibility that this value is empty.
|
|
* @throws std::runtime_error if the operation fails
|
|
*/
|
|
std::string GetName() {
|
|
const char* name = nullptr;
|
|
_Check(wfassoc::WFSelfExtStatusGetName(_token, &name));
|
|
return std::string(name);
|
|
}
|
|
|
|
/**
|
|
* @brief Get the icon from this self extension status
|
|
*
|
|
* The icon will be user specified first, then fallback to the system default file icon.
|
|
*
|
|
* @return The icon handle. This handle will be freed when this object is destroyed.
|
|
* Please make a copy immediately if you need to use it longer.
|
|
* @throws std::runtime_error if the operation fails
|
|
*/
|
|
HICON GetIcon() {
|
|
HICON icon = nullptr;
|
|
_Check(wfassoc::WFSelfExtStatusGetIcon(_token, &icon));
|
|
return icon;
|
|
}
|
|
|
|
/**
|
|
* @brief Get the extension string (without leading dot) from this self extension status
|
|
*
|
|
* @return The file extension name (without leading dot). There is no possibility that this value is empty.
|
|
* @throws std::runtime_error if the operation fails
|
|
*/
|
|
std::string GetExt() {
|
|
const char* inner = nullptr;
|
|
_Check(wfassoc::WFSelfExtStatusGetExt(_token, &inner));
|
|
return std::string(inner);
|
|
}
|
|
|
|
/**
|
|
* @brief Get the dotted extension string (with leading dot) from this self extension status
|
|
*
|
|
* @return The file extension string (with leading dot). There is no possibility that this value is empty.
|
|
* @throws std::runtime_error if the operation fails
|
|
*/
|
|
std::string GetDottedExt() {
|
|
const char* inner = nullptr;
|
|
_Check(wfassoc::WFSelfExtStatusGetDottedExt(_token, &inner));
|
|
return std::string(inner);
|
|
}
|
|
|
|
private:
|
|
Token _token;
|
|
};
|
|
|
|
/**
|
|
* @brief Program object for managing file association registration
|
|
*
|
|
* A Program is created from a Schema and provides methods for registering,
|
|
* unregistering, and querying file associations.
|
|
*
|
|
* This class is move-only (non-copyable).
|
|
*/
|
|
class Program {
|
|
public:
|
|
/**
|
|
* @brief Construct a Program from a Schema
|
|
*
|
|
* This constructor consumes the Schema object.
|
|
* The Schema object cannot be used after this call.
|
|
*
|
|
* @param[in] schema The Schema to create the Program from (will be consumed)
|
|
* @throws std::runtime_error if program creation fails
|
|
*/
|
|
explicit Program(Schema&& schema) {
|
|
_Check(wfassoc::WFProgramCreate(schema.Release(), &_token));
|
|
}
|
|
|
|
/**
|
|
* @brief Destroy the Program object
|
|
*
|
|
* Releases resources associated with the Program.
|
|
*/
|
|
~Program() {
|
|
if (_token != _INVALID_TOKEN()) {
|
|
wfassoc::WFProgramDestroy(_token);
|
|
}
|
|
}
|
|
|
|
/** @brief Non-copyable */
|
|
Program(const Program&) = delete;
|
|
/** @brief Non-copyable */
|
|
Program& operator=(const Program&) = delete;
|
|
|
|
/** @brief Move constructor */
|
|
Program(Program&& other) noexcept : _token(other._token) { other._token = _INVALID_TOKEN(); }
|
|
/** @brief Move assignment operator */
|
|
Program& operator=(Program&& other) noexcept {
|
|
if (this != &other) {
|
|
if (_token != _INVALID_TOKEN()) {
|
|
wfassoc::WFProgramDestroy(_token);
|
|
}
|
|
_token = other._token;
|
|
other._token = _INVALID_TOKEN();
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
/**
|
|
* @brief Resolve the provided program name of this Program
|
|
*
|
|
* The name will be user specified first,
|
|
* then fallback to program manifest file specified name,
|
|
* and finally fallback to the file name of executable.
|
|
*
|
|
* @return The resolved program name. There is no possibility that this value is empty.
|
|
* @throws std::runtime_error if the operation fails
|
|
*/
|
|
std::string ResolveName() {
|
|
const char* name = nullptr;
|
|
_Check(wfassoc::WFProgramResolveName(_token, &name));
|
|
return std::string(name);
|
|
}
|
|
|
|
/**
|
|
* @brief Resolve the Program icon resource
|
|
*
|
|
* The icon will be user specified first,
|
|
* then fallback to the first icon of program,
|
|
* and finally fallback to the system default executable icon.
|
|
*
|
|
* @return An IconRc object containing the resolved icon
|
|
* @throws std::runtime_error if the operation fails
|
|
*/
|
|
IconRc ResolveIcon() {
|
|
Token token = _INVALID_TOKEN();
|
|
_Check(wfassoc::WFProgramResolveIcon(_token, &token));
|
|
return IconRc(token);
|
|
}
|
|
|
|
/**
|
|
* @brief Get the number of file extensions in the Program
|
|
*
|
|
* @return The number of extensions
|
|
* @throws std::runtime_error if the operation fails
|
|
*/
|
|
size_t ExtsLen() {
|
|
size_t len = 0;
|
|
_Check(wfassoc::WFProgramExtsLen(_token, &len));
|
|
return len;
|
|
}
|
|
|
|
/**
|
|
* @brief Find a file extension by its body (extension string)
|
|
*
|
|
* @param[in] body Null-terminated UTF-8 string containing the file extension name (without leading dot) to find
|
|
* @return The index of the extension, or INVALID_INDEX if not found
|
|
* @throws std::runtime_error if the operation fails
|
|
*/
|
|
size_t FindExt(const char* body) {
|
|
size_t index = INVALID_INDEX;
|
|
_Check(wfassoc::WFProgramFindExt(_token, body, &index));
|
|
return index;
|
|
}
|
|
|
|
/**
|
|
* @brief Resolve this program provided extension's details by index
|
|
*
|
|
* @param[in] index Index of the extension to resolve
|
|
* @return A SelfExtStatus object containing the extension details
|
|
* @throws std::runtime_error if the operation fails
|
|
*/
|
|
SelfExtStatus ResolveExt(size_t index) {
|
|
Token token = _INVALID_TOKEN();
|
|
_Check(wfassoc::WFProgramResolveExt(_token, index, &token));
|
|
return SelfExtStatus(token);
|
|
}
|
|
|
|
/**
|
|
* @brief Register the Program in the specified scope
|
|
*
|
|
* @param[in] scope Registration scope
|
|
* @throws std::runtime_error if the operation fails
|
|
*/
|
|
void Register(Scope scope) { _Check(wfassoc::WFProgramRegister(_token, scope)); }
|
|
|
|
/**
|
|
* @brief Unregister the Program from the specified scope
|
|
*
|
|
* @param[in] scope Registration scope
|
|
* @throws std::runtime_error if the operation fails
|
|
*/
|
|
void Unregister(Scope scope) { _Check(wfassoc::WFProgramUnregister(_token, scope)); }
|
|
|
|
/**
|
|
* @brief Check if the Program is registered in the specified scope
|
|
*
|
|
* @param[in] scope Registration scope for checking
|
|
* @return true if the Program is registered in the specified scope, false otherwise
|
|
* @throws std::runtime_error if the operation fails
|
|
*/
|
|
bool IsRegistered(Scope scope) {
|
|
bool result = false;
|
|
_Check(wfassoc::WFProgramIsRegistered(_token, scope, &result));
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* @brief Link a file extension in the specified scope
|
|
*
|
|
* @param[in] scope Registration scope
|
|
* @param[in] index Index of the extension to link
|
|
* @throws std::runtime_error if the operation fails
|
|
*/
|
|
void LinkExt(Scope scope, size_t index) { _Check(wfassoc::WFProgramLinkExt(_token, scope, index)); }
|
|
|
|
/**
|
|
* @brief Unlink a file extension in the specified scope
|
|
*
|
|
* @param[in] scope Registration scope
|
|
* @param[in] index Index of the extension to unlink
|
|
* @throws std::runtime_error if the operation fails
|
|
*/
|
|
void UnlinkExt(Scope scope, size_t index) { _Check(wfassoc::WFProgramUnlinkExt(_token, scope, index)); }
|
|
|
|
/**
|
|
* @brief Query the status of a file extension
|
|
*
|
|
* @param[in] view View viewpoint
|
|
* @param[in] index Index of the extension to query
|
|
* @return An optional ExtStatus object. Returns std::nullopt if the extension is not found
|
|
* (usually means that this extension is not registered in the specified scope).
|
|
* @throws std::runtime_error if the operation fails
|
|
*/
|
|
std::optional<ExtStatus> QueryExt(View view, size_t index) {
|
|
Token token = _INVALID_TOKEN();
|
|
_Check(wfassoc::WFProgramQueryExt(_token, view, index, &token));
|
|
if (token == _INVALID_TOKEN()) {
|
|
return std::nullopt;
|
|
}
|
|
return ExtStatus(token);
|
|
}
|
|
|
|
private:
|
|
Token _token;
|
|
};
|
|
|
|
} // namespace wfassocpp
|
|
|
|
#endif // WFASSOCPP_H_
|