RightsManagementEncryptionTransform(
TransformEnvironment transformEnvironment
)
{
Debug.Assert(transformEnvironment != null);
Stream instanceDataStream = transformEnvironment.GetPrimaryInstanceData();
Debug.Assert(instanceDataStream != null, SR.Get(SRID.NoPublishLicenseStream));
_useLicenseStorage = transformEnvironment.GetInstanceDataStorage();
Debug.Assert(_useLicenseStorage != null, SR.Get(SRID.NoUseLicenseStorage));
// Create a wrapper that manages persistence and comparison of FormatVersion
// in our InstanceData stream. We can read/write to this stream as needed (though CompressionTransform
// does not because we don't house any non-FormatVersion data in the instance data stream).
// We need to give out our current code version so it can compare with any file version as appropriate.
_publishLicenseStream = new VersionedStreamOwner(
instanceDataStream,
new FormatVersion(FeatureName, MinimumReaderVersion, MinimumUpdaterVersion, CurrentFeatureVersion));
}
/// <summary>
/// Define a data transform object with the given object identification and
/// labeled with the given name.
/// </summary>
/// <param name="transformClassName">Transform identification string</param>
/// <param name="newTransformLabel">Label to use for new transform</param>
internal void DefineTransform(string transformClassName, string newTransformLabel )
{
CheckDisposedStatus();
// Check to see if transform name is obviously invalid
CU.CheckStringAgainstNullAndEmpty( transformClassName, "Transform identifier name" );
// Check to see if transform name is valid
CU.CheckStringAgainstNullAndEmpty( newTransformLabel, "Transform label" );
// Given transform name must not be a reserved string
CU.CheckStringAgainstReservedName( newTransformLabel, "Transform label" );
// Can't re-use an existing transform name
if( TransformLabelIsDefined( newTransformLabel ) )
throw new ArgumentException(
SR.Get(SRID.TransformLabelInUse));
// Create class the transform object will use to communicate to us
TransformEnvironment transformEnvironment = new TransformEnvironment( this, newTransformLabel );
// Create a TransformInstance object to represent this transform instance.
TransformInstance newTransform = new TransformInstance(
TransformIdentifierTypes_PredefinedTransformName,
transformClassName,
null,
transformEnvironment );
SetTransformDefinition( newTransformLabel, newTransform );
// Create the transform object
IDataTransform transformObject = InstantiateDataTransformObject(
TransformIdentifierTypes_PredefinedTransformName,
transformClassName,
transformEnvironment );
newTransform.transformReference = transformObject;
// If transform is not ready out-of-the-box, do an initialization run.
// Note: Transform is not required to be "ready" after this. This is
// done for those transforms that need initialization work up-front.
if( ! transformObject.IsReady )
{
CallTransformInitializers(
new TransformInitializationEventArgs(
transformObject,
null,
null,
newTransformLabel)
);
}
_dirtyFlag = true;
return;
}
/// <summary>
/// Internal method to get the transform object corresponding to the specified
/// transform instance label. The transform object is created if it does not exist.
/// </summary>
/// <param name="transformLabel">
/// String that identifies the transform instance.
/// </param>
/// <returns>
/// An IDataTransform interface pointer to the transform object identified by
/// <paramref name="transformLabel"/>, or null if there is no such transform.
/// </returns>
internal IDataTransform GetTransformFromName(string transformLabel)
{
TransformInstance transformInstance = _transformDefinitions[transformLabel] as TransformInstance;
if (transformInstance == null)
{
//
// There is no transform instance with the specified name.
//
return null;
}
IDataTransform transformObject = transformInstance.transformReference;
if (transformObject == null)
{
//
// There is a transform instance with the specified name, but its transform
// object has not yet been created. Create it now. This code is modeled on the
// code in DefineTransform.
//
TransformEnvironment transformEnvironment = new TransformEnvironment(this, transformLabel);
// Create the transform object.
transformObject = InstantiateDataTransformObject(
transformInstance.ClassType,
transformInstance.typeName,
transformEnvironment);
transformInstance.transformReference = transformObject;
}
return transformObject;
}
/// <summary>
/// Tranform object is created. We are no longer using reflection to do this. We are supporting limited data transforms.
/// </summary>
private IDataTransform InstantiateDataTransformObject(int transformClassType, string transformClassName, TransformEnvironment transformEnvironment )
{
object transformInstance = null;
if (transformClassType != (int) TransformIdentifierTypes_PredefinedTransformName)
throw new NotSupportedException(SR.Get(SRID.TransformTypeUnsupported));
// Transform Identifier: we preserve casing, but do case-insensitive comparison
if (((IEqualityComparer) CU.StringCaseInsensitiveComparer).Equals(transformClassName,
RightsManagementEncryptionTransform.ClassTransformIdentifier))
{
transformInstance = new RightsManagementEncryptionTransform( transformEnvironment);
}
else if (((IEqualityComparer) CU.StringCaseInsensitiveComparer).Equals(transformClassName,
CompressionTransform.ClassTransformIdentifier))
{
transformInstance = new CompressionTransform( transformEnvironment );
}
else
{
//this transform class is not supported. Need to change this to appropriate error.
throw new ArgumentException(
SR.Get(SRID.TransformLabelUndefined));
}
if (null != transformInstance)
{
if( !( transformInstance is IDataTransform ) )
throw new ArgumentException(
SR.Get(SRID.TransformObjectImplementIDataTransform));
return (IDataTransform)transformInstance;
}
return null;
}
// When we know everything to put into a TransformInstance.
internal TransformInstance(
int classType,
string name,
IDataTransform instance,
TransformEnvironment environment,
Stream primaryStream,
StorageInfo storage )
{
typeName = name;
transformReference = instance;
transformEnvironment = environment;
transformPrimaryStream = primaryStream;
transformStorage = storage;
_classType = classType;
}
// When we also have an actual object in memory and its associated
// environment object
internal TransformInstance(
int classType,
string name,
IDataTransform instance,
TransformEnvironment environment ) : this(classType, name, instance, environment, null, null ) {;}
/// <summary>
/// constructor
/// </summary>
/// <param name="myEnvironment">environment</param>
/// <remarks>this should only be used by the DataSpaceManager class</remarks>
public CompressionTransform(TransformEnvironment myEnvironment)
{
_transformEnvironment = myEnvironment;
// Create a wrapper that manages persistence and comparison of FormatVersion
// in our InstanceData stream. We can read/write to this stream as needed (though CompressionTransform
// does not because we don't house any non-FormatVersion data in the instance data stream).
// We need to give out our current code version so it can compare with any file version as appropriate.
_versionedStreamOwner = new VersionedStreamOwner(
_transformEnvironment.GetPrimaryInstanceData(),
new FormatVersion(_featureName, _minimumReaderVersion, _minimumUpdaterVersion, _currentFeatureVersion));
}