mirror of https://github.com/UMSKT/xpmgr.git
785 lines
36 KiB
Plaintext
785 lines
36 KiB
Plaintext
//////////////////////////////////////
|
|
// Imports
|
|
//
|
|
|
|
import "oaidl.idl";
|
|
|
|
import "fsrm.idl";
|
|
|
|
|
|
//////////////////////////////////////
|
|
// Forward declarations
|
|
//
|
|
|
|
interface IFsrmPropertyDefinition;
|
|
interface IFsrmProperty;
|
|
interface IFsrmRule;
|
|
interface IFsrmClassificationRule;
|
|
interface IFsrmPipelineModuleDefinition;
|
|
interface IFsrmClassifierModuleDefinition;
|
|
interface IFsrmStorageModuleDefinition;
|
|
interface IFsrmClassificationManager;
|
|
interface IFsrmPropertyBag;
|
|
interface IFsrmPipelineModuleImplementation;
|
|
interface IFsrmClassifierModuleImplementation;
|
|
interface IFsrmStorageModuleImplementation;
|
|
interface IFsrmPipelineModuleConnector;
|
|
|
|
|
|
//////////////////////////////////////
|
|
// Dispatch IDs
|
|
//
|
|
|
|
#define FSRM_PROPERTY(x) x | FSRM_DISPID_IS_PROPERTY
|
|
|
|
// Dispatch ID base of classification interfaces
|
|
const DISPID FSRM_DISPID_PROPERTY_DEFINITION = FSRM_DISPID_FEATURE_CLASSIFICATION | 0x100000;
|
|
|
|
const DISPID FSRM_DISPID_PROPERTY = FSRM_DISPID_FEATURE_CLASSIFICATION | 0x200000;
|
|
|
|
const DISPID FSRM_DISPID_RULE = FSRM_DISPID_FEATURE_CLASSIFICATION | 0x300000;
|
|
const DISPID FSRM_DISPID_CLASSIFICATION_RULE = FSRM_DISPID_RULE | 0x010000;
|
|
const DISPID FSRM_DISPID_EXPIRATION_RULE = FSRM_DISPID_RULE | 0x020000;
|
|
|
|
const DISPID FSRM_DISPID_PIPELINE_MODULE_DEFINITION = FSRM_DISPID_FEATURE_CLASSIFICATION | 0x400000;
|
|
const DISPID FSRM_DISPID_CLASSIFIER_MODULE_DEFINITION = FSRM_DISPID_PIPELINE_MODULE_DEFINITION | 0x010000;
|
|
const DISPID FSRM_DISPID_STORAGE_MODULE_DEFINITION = FSRM_DISPID_PIPELINE_MODULE_DEFINITION | 0x020000;
|
|
|
|
const DISPID FSRM_DISPID_CLASSIFICATION_MANAGER = FSRM_DISPID_FEATURE_CLASSIFICATION | 0x500000;
|
|
|
|
// Dispatch ID base of pipeline interfaces
|
|
const DISPID FSRM_DISPID_PROPERTY_BAG = FSRM_DISPID_FEATURE_PIPELINE | 0x100000;
|
|
|
|
const DISPID FSRM_DISPID_PIPELINE_MODULE_IMPLEMENTATION = FSRM_DISPID_FEATURE_PIPELINE | 0x200000;
|
|
const DISPID FSRM_DISPID_CLASSIFIER_MODULE_IMPLEMENTATION = FSRM_DISPID_PIPELINE_MODULE_IMPLEMENTATION | 0x010000;
|
|
const DISPID FSRM_DISPID_STORAGE_MODULE_IMPLEMENTATION = FSRM_DISPID_PIPELINE_MODULE_IMPLEMENTATION | 0x020000;
|
|
|
|
const DISPID FSRM_DISPID_PIPELINE_MODULE_CONNECTOR = FSRM_DISPID_FEATURE_PIPELINE | 0x300000;
|
|
|
|
|
|
|
|
//////////////////////////////////////
|
|
// Constants
|
|
//
|
|
|
|
const ULONG FsrmMaxNumberPropertyDefinitions = 100;
|
|
|
|
|
|
//////////////////////////////////////
|
|
// Interfaces
|
|
//
|
|
|
|
[
|
|
object,
|
|
uuid(ede0150f-e9a3-419c-877c-01fe5d24c5d3),
|
|
dual,
|
|
helpstring("IFsrmPropertyDefinition Interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IFsrmPropertyDefinition : IFsrmObject
|
|
{
|
|
|
|
// Properties
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_PROPERTY_DEFINITION | 0x01)), helpstring("This property is the name of the property definition")]
|
|
HRESULT Name([out, retval] BSTR *name);
|
|
|
|
[propput, id(FSRM_PROPERTY(FSRM_DISPID_PROPERTY_DEFINITION | 0x01)), helpstring("This property is the name of the property definition")]
|
|
HRESULT Name([in] BSTR name);
|
|
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_PROPERTY_DEFINITION | 0x02)), helpstring("This property is the type of the property definition")]
|
|
HRESULT Type([out, retval] FsrmPropertyDefinitionType *type);
|
|
|
|
[propput, id(FSRM_PROPERTY(FSRM_DISPID_PROPERTY_DEFINITION | 0x02)), helpstring("This property is the type of the property definition")]
|
|
HRESULT Type([in] FsrmPropertyDefinitionType type);
|
|
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_PROPERTY_DEFINITION | 0x03)), helpstring("This property contains the possible values of the property definition")]
|
|
HRESULT PossibleValues([out, retval] SAFEARRAY(VARIANT) *possibleValues);
|
|
|
|
[propput, id(FSRM_PROPERTY(FSRM_DISPID_PROPERTY_DEFINITION | 0x03)), helpstring("This property contains the possible values of the property definition")]
|
|
HRESULT PossibleValues([in] SAFEARRAY(VARIANT) possibleValues);
|
|
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_PROPERTY_DEFINITION | 0x04)), helpstring("This property contains the descriptions of the possible values of the property definition")]
|
|
HRESULT ValueDescriptions([out, retval] SAFEARRAY(VARIANT) *valueDescriptions);
|
|
|
|
[propput, id(FSRM_PROPERTY(FSRM_DISPID_PROPERTY_DEFINITION | 0x04)), helpstring("This property contains the descriptions of the possible values of the property definition")]
|
|
HRESULT ValueDescriptions([in] SAFEARRAY(VARIANT) valueDescriptions);
|
|
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_PROPERTY_DEFINITION | 0x05)), helpstring("This property contains the parameters for the property definition")]
|
|
HRESULT Parameters([out, retval] SAFEARRAY(VARIANT) *parameters);
|
|
|
|
[propput, id(FSRM_PROPERTY(FSRM_DISPID_PROPERTY_DEFINITION | 0x05)), helpstring("This property contains the parameters for the property definition")]
|
|
HRESULT Parameters([in] SAFEARRAY(VARIANT) parameters);
|
|
|
|
};
|
|
|
|
|
|
[
|
|
object,
|
|
uuid(4a73fee4-4102-4fcc-9ffb-38614f9ee768),
|
|
dual,
|
|
helpstring("IFsrmProperty Interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IFsrmProperty : IDispatch
|
|
{
|
|
|
|
// Properties
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_PROPERTY | 0x01)), helpstring("This property is the name of the property")]
|
|
HRESULT Name([out, retval] BSTR *name);
|
|
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_PROPERTY | 0x02)), helpstring("This property is the aggregated value of the property")]
|
|
HRESULT Value([out, retval] BSTR *value);
|
|
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_PROPERTY | 0x03)), helpstring("This property contains the modules and rules that have set the value; entries are strings of the form MODULE,RULE")]
|
|
HRESULT Sources([out, retval] SAFEARRAY(VARIANT) *sources);
|
|
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_PROPERTY | 0x04)), helpstring("This property contains the flags of the property")]
|
|
HRESULT PropertyFlags([out, retval] long *flags);
|
|
|
|
};
|
|
|
|
|
|
[
|
|
object,
|
|
uuid(cb0df960-16f5-4495-9079-3f9360d831df),
|
|
dual,
|
|
helpstring("IFsrmRule Interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IFsrmRule : IFsrmObject
|
|
{
|
|
|
|
// Properties
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_RULE | 0x01)), helpstring("This property is the name of the rule")]
|
|
HRESULT Name([out, retval] BSTR *name);
|
|
|
|
[propput, id(FSRM_PROPERTY(FSRM_DISPID_RULE | 0x01)), helpstring("This property is the name of the rule")]
|
|
HRESULT Name([in] BSTR name);
|
|
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_RULE | 0x02)), helpstring("This property returns the type of the rule")]
|
|
HRESULT RuleType([out, retval] FsrmRuleType *ruleType);
|
|
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_RULE | 0x03)), helpstring("This property is the name of the module definition on which the rule will run")]
|
|
HRESULT ModuleDefinitionName([out, retval] BSTR *moduleDefinitionName);
|
|
|
|
[propput, id(FSRM_PROPERTY(FSRM_DISPID_RULE | 0x03)), helpstring("This property is the name of the module definition on which the rule will run")]
|
|
HRESULT ModuleDefinitionName([in] BSTR moduleDefinitionName);
|
|
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_RULE | 0x04)), helpstring("This property contains the paths on which the rule will run")]
|
|
HRESULT NamespaceRoots([out, retval] SAFEARRAY(VARIANT) *namespaceRoots);
|
|
|
|
[propput, id(FSRM_PROPERTY(FSRM_DISPID_RULE | 0x04)), helpstring("This property contains the paths on which the rule will run")]
|
|
HRESULT NamespaceRoots([in] SAFEARRAY(VARIANT) namespaceRoots);
|
|
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_RULE | 0x05)), helpstring("This property contains the flags for the rules")]
|
|
HRESULT RuleFlags([out, retval] long *ruleFlags);
|
|
|
|
[propput, id(FSRM_PROPERTY(FSRM_DISPID_RULE | 0x05)), helpstring("This property contains the flags for the rules")]
|
|
HRESULT RuleFlags([in] long ruleFlags);
|
|
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_RULE | 0x06)), helpstring("This property contains the parameters for the rule")]
|
|
HRESULT Parameters([out, retval] SAFEARRAY(VARIANT) *parameters);
|
|
|
|
[propput, id(FSRM_PROPERTY(FSRM_DISPID_RULE | 0x06)), helpstring("This property contains the parameters for the rule")]
|
|
HRESULT Parameters([in] SAFEARRAY(VARIANT) parameters);
|
|
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_RULE | 0x07)), helpstring("This property indicates the last time the rule was modified as a 64-bit FILETIME")]
|
|
HRESULT LastModified([out, retval] VARIANT *lastModified);
|
|
|
|
};
|
|
|
|
|
|
[
|
|
object,
|
|
uuid(afc052c2-5315-45ab-841b-c6db0e120148),
|
|
dual,
|
|
helpstring("IFsrmClassificationRule Interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IFsrmClassificationRule : IFsrmRule
|
|
{
|
|
|
|
// Properties
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_CLASSIFICATION_RULE | 0x01)), helpstring("This property indicates how often to execute the classification rule")]
|
|
HRESULT ExecutionOption([out, retval] FsrmExecutionOption *executionOption);
|
|
|
|
[propput, id(FSRM_PROPERTY(FSRM_DISPID_CLASSIFICATION_RULE | 0x01)), helpstring("This property indicates how often to execute the classification rule")]
|
|
HRESULT ExecutionOption([in] FsrmExecutionOption executionOption);
|
|
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_CLASSIFICATION_RULE | 0x02)), helpstring("This property is the property that this rule will potentially affect")]
|
|
HRESULT PropertyAffected([out, retval] BSTR *property);
|
|
|
|
[propput, id(FSRM_PROPERTY(FSRM_DISPID_CLASSIFICATION_RULE | 0x02)), helpstring("This property is the property that this rule will potentially affect")]
|
|
HRESULT PropertyAffected([in] BSTR property);
|
|
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_CLASSIFICATION_RULE | 0x03)), helpstring("This property is the value that this rule will set the property to, if explicitly defined")]
|
|
HRESULT Value([out, retval] BSTR *value);
|
|
|
|
[propput, id(FSRM_PROPERTY(FSRM_DISPID_CLASSIFICATION_RULE | 0x03)), helpstring("This property is the value that this rule will set the property to, if explicitly defined")]
|
|
HRESULT Value([in] BSTR value);
|
|
|
|
};
|
|
|
|
|
|
[
|
|
object,
|
|
uuid(515c1277-2c81-440e-8fcf-367921ed4f59),
|
|
dual,
|
|
helpstring("IFsrmPipelineModuleDefinition Interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IFsrmPipelineModuleDefinition : IFsrmObject
|
|
{
|
|
|
|
// Properties
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_PIPELINE_MODULE_DEFINITION | 0x01)), helpstring("This property is the string verison of the COM class ID of the module that is being defined")]
|
|
HRESULT ModuleClsid([out, retval] BSTR *moduleClsid);
|
|
|
|
[propput, id(FSRM_PROPERTY(FSRM_DISPID_PIPELINE_MODULE_DEFINITION | 0x01)), helpstring("This property is the string verison of the COM class ID of the module that is being defined")]
|
|
HRESULT ModuleClsid([in] BSTR moduleClsid);
|
|
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_PIPELINE_MODULE_DEFINITION | 0x02)), helpstring("This property is the name of the pipeline module definition")]
|
|
HRESULT Name([out, retval] BSTR *name);
|
|
|
|
[propput, id(FSRM_PROPERTY(FSRM_DISPID_PIPELINE_MODULE_DEFINITION | 0x02)), helpstring("This property is the name of the pipeline module definition")]
|
|
HRESULT Name([in] BSTR name);
|
|
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_PIPELINE_MODULE_DEFINITION | 0x03)), helpstring("This property is the company name of the pipeline module definition")]
|
|
HRESULT Company([out, retval] BSTR *company);
|
|
|
|
[propput, id(FSRM_PROPERTY(FSRM_DISPID_PIPELINE_MODULE_DEFINITION | 0x03)), helpstring("This property is the company name of the pipeline module definition")]
|
|
HRESULT Company([in] BSTR company);
|
|
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_PIPELINE_MODULE_DEFINITION | 0x04)), helpstring("This property is the version of the pipeline module definition")]
|
|
HRESULT Version([out, retval] BSTR *version);
|
|
|
|
[propput, id(FSRM_PROPERTY(FSRM_DISPID_PIPELINE_MODULE_DEFINITION | 0x04)), helpstring("This property is the version of the pipeline module definition")]
|
|
HRESULT Version([in] BSTR version);
|
|
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_PIPELINE_MODULE_DEFINITION | 0x05)), helpstring("This property is the type of the pipeline module")]
|
|
HRESULT ModuleType([out, retval] FsrmPipelineModuleType *moduleType);
|
|
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_PIPELINE_MODULE_DEFINITION | 0x06)), helpstring("This property determines if the module is enabled")]
|
|
HRESULT Enabled([out, retval] VARIANT_BOOL *enabled);
|
|
|
|
[propput, id(FSRM_PROPERTY(FSRM_DISPID_PIPELINE_MODULE_DEFINITION | 0x06)), helpstring("This property determines if the module is enabled")]
|
|
HRESULT Enabled([in] VARIANT_BOOL enabled);
|
|
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_PIPELINE_MODULE_DEFINITION | 0x07)), helpstring("This property determines if the module needs access to the content of the file")]
|
|
HRESULT NeedsFileContent([out, retval] VARIANT_BOOL *needsFileContent);
|
|
|
|
[propput, id(FSRM_PROPERTY(FSRM_DISPID_PIPELINE_MODULE_DEFINITION | 0x07)), helpstring("This property determines if the module needs access to the content of the file")]
|
|
HRESULT NeedsFileContent([in] VARIANT_BOOL needsFileContent);
|
|
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_PIPELINE_MODULE_DEFINITION | 0x08)), helpstring("This property is the account to use when running the classification module")]
|
|
HRESULT Account([out, retval] FsrmAccountType *retrievalAccount);
|
|
|
|
[propput, id(FSRM_PROPERTY(FSRM_DISPID_PIPELINE_MODULE_DEFINITION | 0x08)), helpstring("This property is the account to use when running the classification module")]
|
|
HRESULT Account([in] FsrmAccountType retrievalAccount);
|
|
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_PIPELINE_MODULE_DEFINITION | 0x09)), helpstring("This property is the list of file extensions this module supports")]
|
|
HRESULT SupportedExtensions([out, retval] SAFEARRAY(VARIANT) *supportedExtensions);
|
|
|
|
[propput, id(FSRM_PROPERTY(FSRM_DISPID_PIPELINE_MODULE_DEFINITION | 0x09)), helpstring("This property is the list of file extensions this module supports")]
|
|
HRESULT SupportedExtensions([in] SAFEARRAY(VARIANT) supportedExtensions);
|
|
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_PIPELINE_MODULE_DEFINITION | 0xA)), helpstring("This property contains the parameters for the pipeline module definition")]
|
|
HRESULT Parameters([out, retval] SAFEARRAY(VARIANT) *parameters);
|
|
|
|
[propput, id(FSRM_PROPERTY(FSRM_DISPID_PIPELINE_MODULE_DEFINITION | 0xA)), helpstring("This property contains the parameters for the pipeline module definition")]
|
|
HRESULT Parameters([in] SAFEARRAY(VARIANT) parameters);
|
|
|
|
};
|
|
|
|
|
|
[
|
|
object,
|
|
uuid(bb36ea26-6318-4b8c-8592-f72dd602e7a5),
|
|
dual,
|
|
helpstring("IFsrmClassifierModuleDefinition Interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IFsrmClassifierModuleDefinition : IFsrmPipelineModuleDefinition
|
|
{
|
|
|
|
// Properties
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_CLASSIFIER_MODULE_DEFINITION | 0x01)), helpstring("This property contains the names of the properties potentially affected by this classifier")]
|
|
HRESULT PropertiesAffected([out, retval] SAFEARRAY(VARIANT) *propertiesAffected);
|
|
|
|
[propput, id(FSRM_PROPERTY(FSRM_DISPID_CLASSIFIER_MODULE_DEFINITION | 0x01)), helpstring("This property contains the names of the properties potentially affected by this classifier")]
|
|
HRESULT PropertiesAffected([in] SAFEARRAY(VARIANT) propertiesAffected);
|
|
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_CLASSIFIER_MODULE_DEFINITION | 0x02)), helpstring("This property contains the names of the properties potentially used by this classifier")]
|
|
HRESULT PropertiesUsed([out, retval] SAFEARRAY(VARIANT) *propertiesUsed);
|
|
|
|
[propput, id(FSRM_PROPERTY(FSRM_DISPID_CLASSIFIER_MODULE_DEFINITION | 0x02)), helpstring("This property contains the names of the properties potentially used by this classifier")]
|
|
HRESULT PropertiesUsed([in] SAFEARRAY(VARIANT) propertiesUsed);
|
|
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_CLASSIFIER_MODULE_DEFINITION | 0x03)), helpstring("This property determines if a rule using this classifier needs to provide an explicit value for the property being modified")]
|
|
HRESULT NeedsExplicitValue([out, retval] VARIANT_BOOL *needsExplicitValue);
|
|
|
|
[propput, id(FSRM_PROPERTY(FSRM_DISPID_CLASSIFIER_MODULE_DEFINITION | 0x03)), helpstring("This property determines if a rule using this classifier needs to provide an explicit value for the property being modified")]
|
|
HRESULT NeedsExplicitValue([in] VARIANT_BOOL needsExplicitValue);
|
|
|
|
};
|
|
|
|
|
|
[
|
|
object,
|
|
uuid(15a81350-497d-4aba-80e9-d4dbcc5521fe),
|
|
dual,
|
|
helpstring("IFsrmStorageModuleDefinition Interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IFsrmStorageModuleDefinition : IFsrmPipelineModuleDefinition
|
|
{
|
|
|
|
// Properties
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_STORAGE_MODULE_DEFINITION | 0x01)), helpstring("This property is the bit field containing capabilities of the storage module")]
|
|
HRESULT Capabilities([out, retval] FsrmStorageModuleCaps *capabilities);
|
|
|
|
[propput, id(FSRM_PROPERTY(FSRM_DISPID_STORAGE_MODULE_DEFINITION | 0x01)), helpstring("This property is the bit field containing capabilities of the storage module")]
|
|
HRESULT Capabilities([in] FsrmStorageModuleCaps capabilities);
|
|
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_STORAGE_MODULE_DEFINITION | 0x02)), helpstring("This property is the type of storage for the storage module")]
|
|
HRESULT StorageType([out, retval] FsrmStorageModuleType *storageType);
|
|
|
|
[propput, id(FSRM_PROPERTY(FSRM_DISPID_STORAGE_MODULE_DEFINITION | 0x02)), helpstring("This property is the type of storage for the storage module")]
|
|
HRESULT StorageType([in] FsrmStorageModuleType storageType);
|
|
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_STORAGE_MODULE_DEFINITION | 0x03)), helpstring("This property determines if the module updates the content of the file")]
|
|
HRESULT UpdatesFileContent([out, retval] VARIANT_BOOL *updatesFileContent);
|
|
|
|
[propput, id(FSRM_PROPERTY(FSRM_DISPID_STORAGE_MODULE_DEFINITION | 0x03)), helpstring("This property determines if the module updates the content of the file")]
|
|
HRESULT UpdatesFileContent([in] VARIANT_BOOL updatesFileContent);
|
|
|
|
};
|
|
|
|
|
|
[
|
|
object,
|
|
uuid(d2dc89da-ee91-48a0-85d8-cc72a56f7d04),
|
|
dual,
|
|
helpstring("IFsrmClassificationManager Interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IFsrmClassificationManager : IDispatch
|
|
{
|
|
|
|
// Properties
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_CLASSIFICATION_MANAGER | 0x01)), helpstring("This property contains the formats in which to generate the classification reports")]
|
|
HRESULT ClassificationReportFormats([out, retval] SAFEARRAY(VARIANT) *formats);
|
|
|
|
[propput, id(FSRM_PROPERTY(FSRM_DISPID_CLASSIFICATION_MANAGER | 0x01)), helpstring("This property contains the formats in which to generate the classification reports")]
|
|
HRESULT ClassificationReportFormats([in] SAFEARRAY(VARIANT) formats);
|
|
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_CLASSIFICATION_MANAGER | 0x02)), helpstring("This property contains the types of logging that should be done for classificaiton")]
|
|
HRESULT Logging([out, retval] long *logging);
|
|
|
|
[propput, id(FSRM_PROPERTY(FSRM_DISPID_CLASSIFICATION_MANAGER | 0x02)), helpstring("This property contains the types of logging that should be done for classificaiton")]
|
|
HRESULT Logging([in] long logging);
|
|
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_CLASSIFICATION_MANAGER | 0x03)), helpstring("This property is the e-mail address to which to send the classification reports, if any")]
|
|
HRESULT ClassificationReportMailTo([out, retval] BSTR *mailTo);
|
|
|
|
[propput, id(FSRM_PROPERTY(FSRM_DISPID_CLASSIFICATION_MANAGER | 0x03)), helpstring("This property is the e-mail address to which to send the classification reports, if any")]
|
|
HRESULT ClassificationReportMailTo([in] BSTR mailTo);
|
|
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_CLASSIFICATION_MANAGER | 0x04)), helpstring("This property specifies whether report is enabled or not")]
|
|
HRESULT ClassificationReportEnabled([out, retval] VARIANT_BOOL *reportEnabled);
|
|
|
|
[propput, id(FSRM_PROPERTY(FSRM_DISPID_CLASSIFICATION_MANAGER | 0x04)), helpstring("This property specifies whether report is enabled or not")]
|
|
HRESULT ClassificationReportEnabled([in] VARIANT_BOOL reportEnabled);
|
|
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_CLASSIFICATION_MANAGER | 0x05)), helpstring("This property is the last classification report path without extension, if any")]
|
|
HRESULT ClassificationLastReportPathWithoutExtension([out, retval] BSTR *lastReportPath);
|
|
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_CLASSIFICATION_MANAGER | 0x06)), helpstring("This property is the last classification error, if any")]
|
|
HRESULT ClassificationLastError([out, retval] BSTR *lastError);
|
|
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_CLASSIFICATION_MANAGER | 0x07)), helpstring("This property is the classification running status")]
|
|
HRESULT ClassificationRunningStatus([out, retval] FsrmReportRunningStatus *runningStatus);
|
|
|
|
|
|
// Methods
|
|
|
|
[id(FSRM_DISPID_CLASSIFICATION_MANAGER | 0x01), helpstring("This method is used to enumerate property definitions")]
|
|
HRESULT EnumPropertyDefinitions(
|
|
[in, defaultvalue(FsrmEnumOptions_None)] FsrmEnumOptions options,
|
|
[out, retval] IFsrmCollection **propertyDefinitions);
|
|
|
|
[id(FSRM_DISPID_CLASSIFICATION_MANAGER | 0x02), helpstring("This method is used to create a new property definition")]
|
|
HRESULT CreatePropertyDefinition(
|
|
[out, retval] IFsrmPropertyDefinition **propertyDefinition);
|
|
|
|
[id(FSRM_DISPID_CLASSIFICATION_MANAGER | 0x03), helpstring("This method is used to get a property definition having a specific name")]
|
|
HRESULT GetPropertyDefinition(
|
|
[in] BSTR propertyName,
|
|
[out, retval] IFsrmPropertyDefinition **propertyDefinition);
|
|
|
|
|
|
[id(FSRM_DISPID_CLASSIFICATION_MANAGER | 0x04), helpstring("This method is used to enumerate rules of a specified type")]
|
|
HRESULT EnumRules(
|
|
[in] FsrmRuleType ruleType,
|
|
[in, defaultvalue(FsrmEnumOptions_None)] FsrmEnumOptions options,
|
|
[out, retval] IFsrmCollection **Rules);
|
|
|
|
[id(FSRM_DISPID_CLASSIFICATION_MANAGER | 0x05), helpstring("This method is used to create a new rule of a specified type")]
|
|
HRESULT CreateRule(
|
|
[in] FsrmRuleType ruleType,
|
|
[out, retval] IFsrmRule **Rule);
|
|
|
|
[id(FSRM_DISPID_CLASSIFICATION_MANAGER | 0x06), helpstring("This method is used to get a rule having a specific nameand a specified type")]
|
|
HRESULT GetRule(
|
|
[in] BSTR ruleName,
|
|
[in] FsrmRuleType ruleType,
|
|
[out, retval] IFsrmRule **Rule);
|
|
|
|
|
|
[id(FSRM_DISPID_CLASSIFICATION_MANAGER | 0x07), helpstring("This method is used to enumerate module definitions of a specified type")]
|
|
HRESULT EnumModuleDefinitions(
|
|
[in] FsrmPipelineModuleType moduleType,
|
|
[in, defaultvalue(FsrmEnumOptions_None)] FsrmEnumOptions options,
|
|
[out, retval] IFsrmCollection **moduleDefinitions);
|
|
|
|
[id(FSRM_DISPID_CLASSIFICATION_MANAGER | 0x08), helpstring("This method is used to create a new module definition of a specified type")]
|
|
HRESULT CreateModuleDefinition(
|
|
[in] FsrmPipelineModuleType moduleType,
|
|
[out, retval] IFsrmPipelineModuleDefinition**moduleDefinition);
|
|
|
|
[id(FSRM_DISPID_CLASSIFICATION_MANAGER | 0x09), helpstring("This method is used to get a module definition having a specific name and a specified type")]
|
|
HRESULT GetModuleDefinition(
|
|
[in] BSTR moduleName,
|
|
[in] FsrmPipelineModuleType moduleType,
|
|
[out, retval] IFsrmPipelineModuleDefinition**moduleDefinition);
|
|
|
|
|
|
[id(FSRM_DISPID_CLASSIFICATION_MANAGER | 0x0A), helpstring("This method is used to run the classification rules")]
|
|
HRESULT RunClassification(
|
|
[in] FsrmReportGenerationContext context,
|
|
[in] BSTR reserved);
|
|
|
|
[id(FSRM_DISPID_CLASSIFICATION_MANAGER | 0x0B), helpstring("This method is used to wait for the specified period of time or until classification is finished running and return whether or not the job is still running")]
|
|
HRESULT WaitForClassificationCompletion(
|
|
[in] long waitSeconds,
|
|
[out, retval] VARIANT_BOOL *completed);
|
|
|
|
[id(FSRM_DISPID_CLASSIFICATION_MANAGER | 0x0C), helpstring("This method cancels the currently running classification")]
|
|
HRESULT CancelClassification();
|
|
|
|
|
|
[id(FSRM_DISPID_CLASSIFICATION_MANAGER | 0x0D), helpstring("This method is used to enumerate all the properties of a file")]
|
|
HRESULT EnumFileProperties(
|
|
[in] BSTR filePath,
|
|
[in, defaultvalue(FsrmGetFilePropertyOptions_None)] FsrmGetFilePropertyOptions options,
|
|
[out, retval] IFsrmCollection **fileProperties);
|
|
|
|
[id(FSRM_DISPID_CLASSIFICATION_MANAGER | 0x0E), helpstring("This method is used to get a specific property from a file")]
|
|
HRESULT GetFileProperty(
|
|
[in] BSTR filePath,
|
|
[in] BSTR propertyName,
|
|
[in, defaultvalue(FsrmGetFilePropertyOptions_None)] FsrmGetFilePropertyOptions options,
|
|
[out, retval] IFsrmProperty **property);
|
|
|
|
[id(FSRM_DISPID_CLASSIFICATION_MANAGER | 0x0F), helpstring("This method is used to set a specific property from a file")]
|
|
HRESULT SetFileProperty(
|
|
[in] BSTR filePath,
|
|
[in] BSTR propertyName,
|
|
[in] BSTR propertyValue);
|
|
|
|
[id(FSRM_DISPID_CLASSIFICATION_MANAGER | 0x10), helpstring("This method is used to clear the specified property from a file")]
|
|
HRESULT ClearFileProperty(
|
|
[in] BSTR filePath,
|
|
[in] BSTR property);
|
|
|
|
};
|
|
|
|
|
|
//
|
|
// Interfaces needed for pipeline module implementation
|
|
//
|
|
|
|
|
|
[
|
|
object,
|
|
uuid(774589d1-d300-4f7a-9a24-f7b766800250),
|
|
dual,
|
|
helpstring("IFsrmPropertyBag Interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IFsrmPropertyBag : IDispatch
|
|
{
|
|
|
|
const long MessageSizeLimit = 4096;
|
|
|
|
|
|
// Properties
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_PROPERTY_BAG | 0x01)), helpstring("This property is the name of the file")]
|
|
HRESULT Name([out, retval] BSTR *name);
|
|
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_PROPERTY_BAG | 0x02)), helpstring("This property is the relative path to the file")]
|
|
HRESULT RelativePath([out, retval] BSTR *path);
|
|
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_PROPERTY_BAG | 0x03)), helpstring("This property is the name of the volume on which the file exists")]
|
|
HRESULT VolumeName([out, retval] BSTR *volumeName);
|
|
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_PROPERTY_BAG | 0x04)), helpstring("This property is the relative path of the namespace root under which the file was scanned")]
|
|
HRESULT RelativeNamespaceRoot([out, retval] BSTR *relativeNamespaceRoot);
|
|
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_PROPERTY_BAG | 0x05)), helpstring("This property is the index that the scanner uses to refer to the volume on which the file exists")]
|
|
HRESULT VolumeIndex([out, retval] unsigned long *volumeId);
|
|
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_PROPERTY_BAG | 0x06)), helpstring("This property is the ID of the file")]
|
|
HRESULT FileId([out, retval] VARIANT *fileId);
|
|
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_PROPERTY_BAG | 0x07)), helpstring("This property is the ID of the file's parent directory")]
|
|
HRESULT ParentDirectoryId([out, retval] VARIANT *parentDirectoryId);
|
|
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_PROPERTY_BAG | 0x08)), helpstring("This property is the size of the file")]
|
|
HRESULT Size([out, retval] VARIANT *size);
|
|
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_PROPERTY_BAG | 0x09)), helpstring("This property is the allocated size of the file")]
|
|
HRESULT SizeAllocated([out, retval] VARIANT *sizeAllocated);
|
|
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_PROPERTY_BAG | 0x0A)), helpstring("This property is the creation time of the file as a 64-bit FILETIME")]
|
|
HRESULT CreationTime([out, retval] VARIANT *creationTime);
|
|
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_PROPERTY_BAG | 0x0B)), helpstring("This property is the last access time of the file as a 64-bit FILETIME")]
|
|
HRESULT LastAccessTime([out, retval] VARIANT *lastAccessTime);
|
|
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_PROPERTY_BAG | 0x0C)), helpstring("This property is the last modification time of the file as a 64-bit FILETIME")]
|
|
HRESULT LastModificationTime([out, retval] VARIANT *lastModificationTime);
|
|
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_PROPERTY_BAG | 0x0D)), helpstring("This property is the attributes of the file")]
|
|
HRESULT Attributes([out, retval] unsigned long *attributes);
|
|
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_PROPERTY_BAG | 0x0E)), helpstring("This property is the SID of the file owner")]
|
|
HRESULT OwnerSid([out, retval] BSTR *ownerSid);
|
|
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_PROPERTY_BAG | 0x0F)), helpstring("This property contains a list of the names of the file metadata properties")]
|
|
HRESULT FilePropertyNames([out, retval] SAFEARRAY(VARIANT) *filePropertyNames);
|
|
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_PROPERTY_BAG | 0x10)), helpstring("This property contains a list of all messages concerning classification of the file that were added")]
|
|
HRESULT Messages([out, retval] SAFEARRAY(VARIANT) *messages);
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_PROPERTY_BAG | 0x11)), helpstring("This property is a set of flags for the property bag")]
|
|
HRESULT PropertyBagFlags([out, retval] unsigned long *flags);
|
|
|
|
|
|
// Methods
|
|
|
|
[id(FSRM_DISPID_PROPERTY_BAG | 0x01), helpstring("This method is used to get a file metadata property by name")]
|
|
HRESULT GetFileProperty(
|
|
[in] BSTR name,
|
|
[out, retval] IFsrmProperty **fileProperty);
|
|
|
|
[id(FSRM_DISPID_PROPERTY_BAG | 0x02), helpstring("This method is used to set a file metadata property")]
|
|
HRESULT SetFileProperty(
|
|
[in] BSTR name,
|
|
[in] BSTR value);
|
|
|
|
[id(FSRM_DISPID_PROPERTY_BAG | 0x03), helpstring("This method is used to add a message about the file")]
|
|
HRESULT AddMessage([in] BSTR message);
|
|
|
|
[id(FSRM_DISPID_PROPERTY_BAG | 0x04), helpstring("Gets a file stream interface to access the file content")]
|
|
HRESULT GetFileStreamInterface(
|
|
[in] FsrmFileStreamingMode accessMode,
|
|
[in] FsrmFileStreamingInterfaceType interfaceType,
|
|
[out, retval] VARIANT * pStreamInterface
|
|
);
|
|
|
|
};
|
|
|
|
|
|
[
|
|
object,
|
|
uuid(b7907906-2b02-4cb5-84a9-fdf54613d6cd),
|
|
dual,
|
|
helpstring("IFsrmPipelineModuleImplementation Interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IFsrmPipelineModuleImplementation : IDispatch
|
|
{
|
|
|
|
// Methods
|
|
|
|
[id(FSRM_DISPID_PIPELINE_MODULE_IMPLEMENTATION | 0x01), helpstring("This method is used to initialize the pipeline module")]
|
|
HRESULT OnLoad(
|
|
[in] IFsrmPipelineModuleDefinition *moduleDefinition,
|
|
[out] IFsrmPipelineModuleConnector **moduleConnector);
|
|
|
|
[id(FSRM_DISPID_PIPELINE_MODULE_IMPLEMENTATION | 0x02), helpstring("This method is used to tell the module to perform any cleanup tasks")]
|
|
HRESULT OnUnload();
|
|
|
|
};
|
|
|
|
|
|
[
|
|
object,
|
|
uuid(4c968fc6-6edb-4051-9c18-73b7291ae106),
|
|
dual,
|
|
helpstring("IFsrmClassifierModuleImplementation Interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IFsrmClassifierModuleImplementation : IFsrmPipelineModuleImplementation
|
|
{
|
|
cpp_quote("#define FsrmNeverModified ((ULONGLONG) 0x0000000000000000ui64)")
|
|
cpp_quote("#define FsrmAlwaysModified ((ULONGLONG) 0xFFFFFFFFFFFFFFFFui64)")
|
|
|
|
|
|
// Properties
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_CLASSIFIER_MODULE_IMPLEMENTATION | 0x01)), helpstring("This property contains the last time the classifier's internal rules were modified as a 64-bit FILETIME")]
|
|
HRESULT LastModified([out, retval] VARIANT *lastModified);
|
|
|
|
|
|
// Methods
|
|
|
|
[id(FSRM_DISPID_CLASSIFIER_MODULE_IMPLEMENTATION | 0x01), helpstring("This method is used to tell the classifier the collection of rules and relevant property definitions it should expect to process")]
|
|
HRESULT UseRulesAndDefinitions(
|
|
[in] IFsrmCollection *rules,
|
|
[in] IFsrmCollection *propertyDefinitions);
|
|
|
|
[id(FSRM_DISPID_CLASSIFIER_MODULE_IMPLEMENTATION | 0x02), helpstring("This method is used to tell the classifier to prepare for processing a file with the specified property bag")]
|
|
HRESULT OnBeginFile([in] IFsrmPropertyBag *propertyBag,
|
|
[in] SAFEARRAY(VARIANT) arrayRuleIds);
|
|
|
|
[id(FSRM_DISPID_CLASSIFIER_MODULE_IMPLEMENTATION | 0x03), helpstring("This method is used to ask the classifier whether the specified property value applies to the file")]
|
|
HRESULT DoesPropertyValueApply(
|
|
[in] BSTR property,
|
|
[in] BSTR value,
|
|
[out] VARIANT_BOOL *applyValue,
|
|
[in] FSRM_OBJECT_ID idRule,
|
|
[in] FSRM_OBJECT_ID idPropDef);
|
|
|
|
[id(FSRM_DISPID_CLASSIFIER_MODULE_IMPLEMENTATION | 0x04), helpstring("This method is used to ask the classifier what value should be applied for the specified property of the file")]
|
|
HRESULT GetPropertyValueToApply(
|
|
[in] BSTR property,
|
|
[out] BSTR *value,
|
|
[in] FSRM_OBJECT_ID idRule,
|
|
[in] FSRM_OBJECT_ID idPropDef);
|
|
|
|
[id(FSRM_DISPID_CLASSIFIER_MODULE_IMPLEMENTATION | 0x05), helpstring("This method is used to tell the classifier to perform any cleanup after processing a file")]
|
|
HRESULT OnEndFile();
|
|
|
|
};
|
|
|
|
|
|
[
|
|
object,
|
|
uuid(0af4a0da-895a-4e50-8712-a96724bcec64),
|
|
dual,
|
|
helpstring("IFsrmStorageModuleImplementation Interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IFsrmStorageModuleImplementation : IFsrmPipelineModuleImplementation
|
|
{
|
|
|
|
// Methods
|
|
|
|
[id(FSRM_DISPID_STORAGE_MODULE_IMPLEMENTATION | 0x01), helpstring("This method is used to tell the storage module the collection property definitions FSRM recognizes")]
|
|
HRESULT UseDefinitions([in] IFsrmCollection *propertyDefinitions);
|
|
|
|
[id(FSRM_DISPID_STORAGE_MODULE_IMPLEMENTATION | 0x02), helpstring("This method is used to tell the storage module to load all properties")]
|
|
HRESULT LoadProperties([in] IFsrmPropertyBag *propertyBag);
|
|
|
|
[id(FSRM_DISPID_STORAGE_MODULE_IMPLEMENTATION | 0x03), helpstring("This method is used to tell the storage module to save all properties")]
|
|
HRESULT SaveProperties([in] IFsrmPropertyBag *propertyBag);
|
|
|
|
};
|
|
|
|
|
|
[
|
|
object,
|
|
uuid(c16014f3-9aa1-46b3-b0a7-ab146eb205f2),
|
|
dual,
|
|
helpstring("IFsrmPipelineModuleConnector Interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IFsrmPipelineModuleConnector : IDispatch
|
|
{
|
|
|
|
// Properties
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_PIPELINE_MODULE_CONNECTOR | 0x01)), helpstring("Get the module implementation")]
|
|
HRESULT ModuleImplementation([out, retval] IFsrmPipelineModuleImplementation **pipelineModuleImplementation);
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_PIPELINE_MODULE_CONNECTOR | 0x02)), helpstring("Get the module name")]
|
|
HRESULT ModuleName([out, retval] BSTR *userName);
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_PIPELINE_MODULE_CONNECTOR | 0x03)), helpstring("Get the module hosting process user account")]
|
|
HRESULT HostingUserAccount([out, retval] BSTR *userAccount);
|
|
|
|
[propget, id(FSRM_PROPERTY(FSRM_DISPID_PIPELINE_MODULE_CONNECTOR | 0x04)), helpstring("Get the module hosting process PID")]
|
|
HRESULT HostingProcessPid([out, retval] long *pid);
|
|
|
|
|
|
// Methods
|
|
|
|
[id(FSRM_DISPID_PIPELINE_MODULE_CONNECTOR | 0x01), helpstring("This method is used to bind the pipeline module implementation")]
|
|
HRESULT Bind(
|
|
[in] IFsrmPipelineModuleDefinition *moduleDefinition,
|
|
[in] IFsrmPipelineModuleImplementation *moduleImplementation);
|
|
|
|
};
|
|
|
|
|