/// <summary> /// Creates a new instance relative to the given parent /// </summary> /// <param name="parent">The parent storage</param> /// <param name="streamName">Path to stream under parent storage</param> /// <param name="compressionOption">CompressionOption</param> /// <param name="encryptionOption">EncryptionOption</param> internal StreamInfo(StorageInfo parent, string streamName, CompressionOption compressionOption, EncryptionOption encryptionOption) { // Parameter validation CU.CheckAgainstNull(parent, "parent"); CU.CheckStringAgainstNullAndEmpty(streamName, "streamName"); // Parse path relative to given parent. BuildStreamInfoRelativeToStorage(parent, streamName); _compressionOption = compressionOption; _encryptionOption = encryptionOption; _streamReference = new CompoundFileStreamReference(this.parentStorage.FullNameInternal, this.core.streamName); }
/***********************************************************************/ // Constructors private void BuildStreamInfoRelativeToStorage( StorageInfo parent, string path ) { parentStorage = parent; core = parentStorage.CoreForChildStream( path ); }
/// <summary> /// Creates a new instance relative to the given parent /// </summary> /// <param name="parent">The parent storage</param> /// <param name="streamName">Path to stream under parent storage</param> internal StreamInfo(StorageInfo parent, string streamName) : this(parent, streamName, CompressionOption.NotCompressed, EncryptionOption.None) { }
/// <summary> /// Destroys an element and removes the references ued internally. /// </summary> internal void DestroyElement( string elementNameInternal ) { object deadElementWalking = core.elementInfoCores[ elementNameInternal ]; // It's an internal error if we try to call this without first // verifying that it is indeed there. Debug.Assert( null != deadElementWalking, "Caller should have already verified that there's something to delete."); // Can't delete if we're in read-only mode. This catches some but not // all invalid delete scenarios - anything else would come back as a // COMException of some kind that will be caught and wrapped in an // IOException in the try/catch below. if( FileAccess.Read == Root.OpenAccess ) { throw new UnauthorizedAccessException( SR.Get(SRID.CanNotDeleteInReadOnly)); } //Clean out the entry in dataspacemanager for stream transforms DataSpaceManager manager = Root.GetDataSpaceManager(); if( null != manager ) { if( deadElementWalking is StorageInfoCore ) { //if the element getting deleted is a storage, make sure to delete all its children's references. string name = ((StorageInfoCore)deadElementWalking).storageName; StorageInfo stInfo = new StorageInfo(this, name); RemoveSubStorageEntryFromDataSpaceMap(stInfo); } else if( deadElementWalking is StreamInfoCore ) { //if the element getting deleted is a stream, the container reference should be removed from dataspacemap of dataspace manager. manager.RemoveContainerFromDataSpaceMap(new CompoundFileStreamReference( FullNameInternal, elementNameInternal )); } } // Make the call to the underlying OLE mechanism to remove the element. try { core.safeIStorage.DestroyElement( elementNameInternal ); } catch( COMException e ) { if( e.ErrorCode == SafeNativeCompoundFileConstants.STG_E_ACCESSDENIED ) { throw new UnauthorizedAccessException( SR.Get(SRID.CanNotDeleteAccessDenied), e ); } else { throw new IOException( SR.Get(SRID.CanNotDelete), e ); } } // Invalidate enumerators InvalidateEnumerators(); // Remove the now-meaningless name, which also signifies disposed status. if( deadElementWalking is StorageInfoCore ) { StorageInfoCore deadStorageInfoCore = (StorageInfoCore)deadElementWalking; // Erase this storage's existence deadStorageInfoCore.storageName = null; if( null != deadStorageInfoCore.safeIStorage ) { ((IDisposable) deadStorageInfoCore.safeIStorage).Dispose(); deadStorageInfoCore.safeIStorage = null; } } else if( deadElementWalking is StreamInfoCore ) { StreamInfoCore deadStreamInfoCore = (StreamInfoCore)deadElementWalking; // Erase this stream's existence deadStreamInfoCore.streamName = null; try { if (null != deadStreamInfoCore.exposedStream) { ((Stream)(deadStreamInfoCore.exposedStream)).Close(); } } catch(Exception e) { if(CriticalExceptions.IsCriticalException(e)) { // PreSharp Warning 56500 throw; } else { // We don't care if there are any issues - // the user wanted this stream gone anyway. } } deadStreamInfoCore.exposedStream = null; if( null != deadStreamInfoCore.safeIStream ) { ((IDisposable) deadStreamInfoCore.safeIStream).Dispose(); deadStreamInfoCore.safeIStream = null; } } // Remove reference for destroyed element core.elementInfoCores.Remove(elementNameInternal); }
private StorageInfo CreateStorage(string name) { // Create new StorageInfo StorageInfo newSubStorage = new StorageInfo( this, name ); // Make it real if( !newSubStorage.InternalExists(name) ) { /* TBD if( !CU.IsValidCompoundFileName(name)) { throw new IOException( SR.Get(SRID.UnableToCreateStorage), new COMException( SR.Get(SRID.NamedAPIFailure, "IStorage.CreateStorage"), nativeCallErrorCode )); } */ // It doesn't already exist, please create. StorageInfoCore newStorage = core.elementInfoCores[ name ] as StorageInfoCore; Invariant.Assert( null != newStorage); int nativeCallErrorCode = core.safeIStorage.CreateStorage( name, (GetStat().grfMode & SafeNativeCompoundFileConstants.STGM_READWRITE_Bits) | SafeNativeCompoundFileConstants.STGM_SHARE_EXCLUSIVE, 0, 0, #pragma warning suppress 6506 // Invariant.Assert(null != newStorage) out newStorage.safeIStorage ); if( SafeNativeCompoundFileConstants.S_OK != nativeCallErrorCode ) { if( nativeCallErrorCode == SafeNativeCompoundFileConstants.STG_E_ACCESSDENIED ) { throw new UnauthorizedAccessException( SR.Get(SRID.CanNotCreateAccessDenied), new COMException( SR.Get(SRID.NamedAPIFailure, "IStorage.CreateStorage"), nativeCallErrorCode )); } else { throw new IOException( SR.Get(SRID.UnableToCreateStorage), new COMException( SR.Get(SRID.NamedAPIFailure, "IStorage.CreateStorage"), nativeCallErrorCode )); } } // Invalidate enumerators InvalidateEnumerators(); } else { throw new IOException(SR.Get(SRID.StorageAlreadyExist)); } // Return a reference return newSubStorage; }
/// <summary> /// Checks if a storage exists by the passed name. /// </summary> /// <param name="name">Name of storage</param> /// <returns>Reference to new storage</returns> public bool SubStorageExists(string name) { StorageInfo storageInfo = new StorageInfo(this, name); return storageInfo.InternalExists(name); }
/// <summary> /// Constructor for a StorageInfo given a parent StorageInfo and a name /// </summary> /// <param name="parent">Reference to the parent storage</param> /// <param name="fileName">filename for the new StorageInfo</param> internal StorageInfo( StorageInfo parent, string fileName ) { CU.CheckAgainstNull( parent, "parent" ); CU.CheckAgainstNull( fileName, "fileName" ); BuildStorageInfoRelativeToStorage( parent, fileName ); }
public PreviewImage(string fileName, StorageInfo storage) : base(fileName, storage) { ReadStructuredStorageFile(); }
/// <summary> /// Reads a data space map from the associated container, if such a thing /// is written to the file. /// </summary> void ReadDataSpaceMap() { // See if there's even a data spaces storage StorageInfo dataSpaceStorage = new StorageInfo( _associatedStorage, DataSpaceStorageName ); StreamInfo dataSpaceMapStreamInfo = new StreamInfo( dataSpaceStorage, DataSpaceMapTableName ); if( dataSpaceStorage.StreamExists(DataSpaceMapTableName) ) { // There is an existing data space mapping table to read. // Read the versioning information ReadDataSpaceVersionInformation(dataSpaceStorage); // Check if its the correct version for reading ThrowIfIncorrectReaderVersion(); // Read the data space mapping table using(Stream dataSpaceMapStream = dataSpaceMapStreamInfo.GetStream(FileMode.Open)) { using(BinaryReader dataSpaceMapReader = new BinaryReader( dataSpaceMapStream, System.Text.Encoding.Unicode )) { int headerLength = dataSpaceMapReader.ReadInt32(); int entryCount = dataSpaceMapReader.ReadInt32(); if (headerLength < KnownBytesInMapTableHeader || entryCount < 0) throw new FileFormatException(SR.Get(SRID.CorruptedData)); int extraDataSize = headerLength - KnownBytesInMapTableHeader; if( 0 < extraDataSize ) { if (extraDataSize > AllowedExtraDataMaximumSize) throw new FileFormatException(SR.Get(SRID.CorruptedData)); _mapTableHeaderPreservation = dataSpaceMapReader.ReadBytes(extraDataSize); if (_mapTableHeaderPreservation.Length != extraDataSize) throw new FileFormatException(SR.Get(SRID.CorruptedData)); } _dataSpaceMap.Capacity = entryCount; int entryLength; int bytesRead; int totalBytesRead; for( int i = 0; i < entryCount; i++ ) { entryLength = dataSpaceMapReader.ReadInt32(); if (entryLength < 0) throw new FileFormatException(SR.Get(SRID.CorruptedData)); totalBytesRead = 4; // entryLength // Read the container reference entry CompoundFileReference entryRef = CompoundFileReference.Load( dataSpaceMapReader, out bytesRead ); checked { totalBytesRead += bytesRead; } // Read data space string and add to data space mapping table string label = CU.ReadByteLengthPrefixedDWordPaddedUnicodeString(dataSpaceMapReader, out bytesRead); checked { totalBytesRead += bytesRead; } _dataSpaceMap[entryRef] = label; // Verify entryLength against what was actually read: if (entryLength != totalBytesRead) { throw new IOException(SR.Get(SRID.DataSpaceMapEntryInvalid)); } } } } } }
public BasicFileInfo(string fileName, StorageInfo storage) : base(fileName, storage) { ReadStructuredStorageFile(); }
private void OpenStructuredStorageFile() { //int checkResult = IsStorageFile(FileName); IsInitialized = false; //if(checkResult == 0) //{ // return; //} try { StorageRoot = GetStorageRoot(FileName); } catch(Exception ex) { Debug.WriteLine(ex.Message); } }
private void CloseStorageRoot(StorageInfo storageRoot) { InvokeStorageRootMethod(storageRoot, "Close"); }
/// <summary> /// Creates a new instance relative to the given parent /// </summary> /// <param name="parent">The parent storage</param> /// <param name="streamName">Path to stream under parent storage</param> /// <param name="compressionOption">CompressionOption</param> /// <param name="encryptionOption">EncryptionOption</param> internal StreamInfo( StorageInfo parent, string streamName, CompressionOption compressionOption, EncryptionOption encryptionOption ) { // Parameter validation CU.CheckAgainstNull( parent, "parent" ); CU.CheckStringAgainstNullAndEmpty( streamName, "streamName" ); // Parse path relative to given parent. BuildStreamInfoRelativeToStorage( parent, streamName); _compressionOption = compressionOption; _encryptionOption = encryptionOption; _streamReference = new CompoundFileStreamReference(this.parentStorage.FullNameInternal, this.core.streamName); }
/// <summary> /// Creates a new instance relative to the given parent /// </summary> /// <param name="parent">The parent storage</param> /// <param name="streamName">Path to stream under parent storage</param> internal StreamInfo( StorageInfo parent, string streamName ) : this (parent, streamName, CompressionOption.NotCompressed, EncryptionOption.None) { }
/// <summary> /// Internally visible constructor /// </summary> /// <param name="containerInstance">The container instance we're associated with</param> internal DataSpaceManager( StorageRoot containerInstance ) { _associatedStorage = containerInstance; // Storage under which all data space information is stored. StorageInfo dataSpaceStorage = new StorageInfo( _associatedStorage, DataSpaceStorageName ); // Initialize internal data structures. // _dataSpaceMap = new SortedList(); _mapTableHeaderPreservation = new byte[0]; _dataSpaceDefinitions = new Hashtable(CU.StringCaseInsensitiveComparer); _transformDefinitions = new Hashtable(CU.StringCaseInsensitiveComparer); _transformedStreams = new ArrayList(); // Check to see if we have any data space information to read if (dataSpaceStorage.Exists) { // Read any existing data space mapping information from the container // ReadDataSpaceMap(); ReadDataSpaceDefinitions(); ReadTransformDefinitions(); } return; }
/// <summary> /// Internal method to get the StorageInfo where the transform instance /// data is stored. This StorageInfo may not yet exist! /// </summary> /// <param name="transformLabel">Transform Label</param> /// <returns>StorageInfo pointing to transform instance data storage</returns> internal StorageInfo GetInstanceDataStorageOf( string transformLabel ) { TransformInstance targetInstance = GetTransformInstanceOf( transformLabel ); if( null == targetInstance.transformStorage ) { //string name = DataSpaceStorageName + '\\' + TransformDefinitions + '\\' + transformLabel; //targetInstance.transformStorage = new StorageInfo(_associatedStorage,name); StorageInfo dataSpaceStorage = new StorageInfo( _associatedStorage, DataSpaceStorageName ); if (!dataSpaceStorage.Exists ) { dataSpaceStorage.Create(); } StorageInfo transformDefinition = new StorageInfo( dataSpaceStorage, TransformDefinitions ); if (!transformDefinition.Exists) { transformDefinition.Create(); } targetInstance.transformStorage = new StorageInfo(transformDefinition,transformLabel); } return targetInstance.transformStorage; }
/// <summary> /// Write the data space mapping table to underlying storage. /// </summary> void WriteDataSpaceMap() { ThrowIfIncorrectUpdaterVersion(); StorageInfo dataSpaceStorage = new StorageInfo( _associatedStorage, DataSpaceStorageName ); StreamInfo dataSpaceMapStreamInfo = new StreamInfo ( dataSpaceStorage, DataSpaceMapTableName ); if( 0 < _dataSpaceMap.Count ) { // Write versioning information StreamInfo versionStreamInfo = null; if (dataSpaceStorage.StreamExists( DataSpaceVersionName ) ) versionStreamInfo = dataSpaceStorage.GetStreamInfo( DataSpaceVersionName ); else versionStreamInfo = dataSpaceStorage.CreateStream( DataSpaceVersionName ); Stream versionStream = versionStreamInfo.GetStream(); _fileFormatVersion.SaveToStream(versionStream); versionStream.Close(); // Create stream for write, overwrite any existing using(Stream dataSpaceMapStream = dataSpaceMapStreamInfo.GetStream(FileMode.Create)) { using(BinaryWriter dataSpaceMapWriter = new BinaryWriter( dataSpaceMapStream, System.Text.Encoding.Unicode )) { // Write header // header length = our known size + preserved array size dataSpaceMapWriter.Write( checked ((Int32) (KnownBytesInMapTableHeader + _mapTableHeaderPreservation.Length))); // number of entries dataSpaceMapWriter.Write( _dataSpaceMap.Count ); // anything else we've preserved dataSpaceMapWriter.Write( _mapTableHeaderPreservation ); // Loop to write entries foreach( CompoundFileReference o in _dataSpaceMap.Keys ) { // determine the entry length string label = (string)_dataSpaceMap[o]; int entryLength = CompoundFileReference.Save(o, null); checked { entryLength += CU.WriteByteLengthPrefixedDWordPaddedUnicodeString(null, label); } // length of entryLength itself checked { entryLength += 4; } // write out the entry length dataSpaceMapWriter.Write((Int32) entryLength); // Write out reference CompoundFileReference.Save( o, dataSpaceMapWriter); // Write out dataspace label CU.WriteByteLengthPrefixedDWordPaddedUnicodeString( dataSpaceMapWriter, label); } } } } else { // data space map is empty, remove existing stream if there. if ( dataSpaceStorage.StreamExists( DataSpaceMapTableName ) ) dataSpaceStorage.DeleteStream( DataSpaceMapTableName ); } }
/// <summary> /// Given a parent and a path under it, step through each of the path /// elements and create an intermediate StorageInfo at each step because /// a StorageInfo is only meaningful relative to its immediate parent - /// multi-step relations can't be represented. /// </summary> private void BuildStorageInfoRelativeToStorage( StorageInfo parent, string fileName ) { parentStorage = parent; core = parent.CoreForChildStorage( fileName ); rootStorage = parent.Root; }
/// <summary> /// Read all data space definitions in one chunk. To be replaced /// with on-demand reading mechanism. /// </summary> void ReadDataSpaceDefinitions() { ThrowIfIncorrectReaderVersion(); StorageInfo dataSpaceStorage = new StorageInfo( _associatedStorage, DataSpaceStorageName ); StorageInfo dataSpaceDefinitionsStorage = new StorageInfo( dataSpaceStorage, DataSpaceDefinitionsStorageName ); if( dataSpaceDefinitionsStorage.Exists ) { // Fill in the Data Space Definitions hash table foreach( StreamInfo definitionStreamInfo in dataSpaceDefinitionsStorage.GetStreams()) { // Open up the stream for this data space definition using(Stream definitionStream = definitionStreamInfo.GetStream(FileMode.Open)) { using(BinaryReader definitionReader = new BinaryReader( definitionStream, System.Text.Encoding.Unicode )) { // Read data space definition stream int headerLength = definitionReader.ReadInt32(); int transformCount = definitionReader.ReadInt32(); if (headerLength < KnownBytesInDataSpaceDefinitionHeader || transformCount < 0) throw new FileFormatException(SR.Get(SRID.CorruptedData)); ArrayList transformLabels = new ArrayList(transformCount); byte[] extraData = null; int extraDataSize = headerLength - KnownBytesInDataSpaceDefinitionHeader; if (extraDataSize > AllowedExtraDataMaximumSize) throw new FileFormatException(SR.Get(SRID.CorruptedData)); if (extraDataSize > 0) { extraData = definitionReader.ReadBytes(extraDataSize); if (extraData.Length != extraDataSize) throw new FileFormatException(SR.Get(SRID.CorruptedData)); } // Read the array of strings that make up the transform stack for( int i = 0; i < transformCount; i++ ) { transformLabels.Add( CU.ReadByteLengthPrefixedDWordPaddedUnicodeString( definitionReader ) ); } // Add data space definition to table SetDataSpaceDefinition( definitionStreamInfo.Name, new DataSpaceDefinition(transformLabels, extraData)); } } } } }
/// <summary> /// Returns the storage by the passed name. /// </summary> /// <param name="name">Name of storage</param> /// <returns>Reference to the storage</returns> public StorageInfo GetSubStorageInfo(string name) { //Find if this storage exists StorageInfo storageInfo = new StorageInfo(this, name); if (storageInfo.InternalExists(name)) { return storageInfo; } else { throw new IOException(SR.Get(SRID.StorageNotExist)); } }
/// <summary> /// Write all data space definitions to underlying storage in one chunk. /// </summary> /// // void WriteDataSpaceDefinitions() { ThrowIfIncorrectUpdaterVersion(); StorageInfo dataSpaceStorage = new StorageInfo( _associatedStorage, DataSpaceStorageName ); // // Write out data space definitions if( 0 < _dataSpaceDefinitions.Count ) { StorageInfo dataSpaceDefinitionsStorage = new StorageInfo(dataSpaceStorage, DataSpaceDefinitionsStorageName); dataSpaceDefinitionsStorage.Create(); foreach( string name in _dataSpaceDefinitions.Keys ) { StreamInfo singleDefinitionInfo = new StreamInfo(dataSpaceDefinitionsStorage,name); using(Stream singleDefinition = singleDefinitionInfo.GetStream()) { using(BinaryWriter definitionWriter =new BinaryWriter( singleDefinition, System.Text.Encoding.Unicode )) { DataSpaceDefinition definition = (DataSpaceDefinition) _dataSpaceDefinitions[name]; int headerSize = KnownBytesInDataSpaceDefinitionHeader; if (definition.ExtraData != null) { checked { headerSize += definition.ExtraData.Length; } } definitionWriter.Write( headerSize ); definitionWriter.Write( definition.TransformStack.Count ); if (definition.ExtraData != null) { definitionWriter.Write(definition.ExtraData); } foreach( object transformLabel in definition.TransformStack) { CU.WriteByteLengthPrefixedDWordPaddedUnicodeString( definitionWriter, (string)transformLabel); } } } } } }
/// <summary> /// Deletes a storage recursively. /// </summary> /// <param name="name">Name of storage</param> public void DeleteSubStorage(string name) { CheckDisposedStatus(); //check the arguments if( null == name ) throw new ArgumentNullException("name"); StorageInfo storageInfo = new StorageInfo(this, name); if (storageInfo.InternalExists(name)) { InvalidateEnumerators(); // Go ahead and delete "this" storage DestroyElement( name ); } //We will not throw exceptions if the storage does not exist. This is to be consistent with Package.DeletePart. }
/// <summary> /// Read all transform definitions in one chunk /// </summary> // void ReadTransformDefinitions() { ThrowIfIncorrectReaderVersion(); StorageInfo dataSpaceStorage = new StorageInfo( _associatedStorage, DataSpaceStorageName ); StorageInfo transformDefinitionsStorage = new StorageInfo( dataSpaceStorage, TransformDefinitions ); if( transformDefinitionsStorage.Exists ) { // Read transform definitions from file foreach( StorageInfo transformStorage in transformDefinitionsStorage.GetSubStorages() ) { // Read from primary stream StreamInfo transformPrimary = new StreamInfo( transformStorage, TransformPrimaryInfo ); using(Stream transformDefinition = transformPrimary.GetStream(FileMode.Open)) { using(BinaryReader definitionReader = new BinaryReader( transformDefinition, System.Text.Encoding.Unicode )) { int headerLength = definitionReader.ReadInt32(); // We don't actually do anything with HeaderLen at the moment int transformType = definitionReader.ReadInt32(); if (headerLength < 0) throw new FileFormatException(SR.Get(SRID.CorruptedData)); // Create a TransformInstance class using name from file TransformInstance transformInstance = new TransformInstance(transformType, CU.ReadByteLengthPrefixedDWordPaddedUnicodeString( definitionReader ) ); int extraDataSize = checked ((int) (headerLength - transformDefinition.Position)); if (extraDataSize < 0) throw new FileFormatException(SR.Get(SRID.CorruptedData)); if (extraDataSize > 0) { if (extraDataSize > AllowedExtraDataMaximumSize) throw new FileFormatException(SR.Get(SRID.CorruptedData)); // Preserve the fields we don't know about. byte[] extraData = definitionReader.ReadBytes(extraDataSize); if (extraData.Length != extraDataSize) throw new FileFormatException(SR.Get(SRID.CorruptedData)); transformInstance.ExtraData = extraData; } if( transformDefinition.Length > transformDefinition.Position ) { // We have additional data in the primary instance data stream int instanceDataSize = checked ((int)(transformDefinition.Length - transformDefinition.Position)); byte[] instanceData = new byte[instanceDataSize]; PackagingUtilities.ReliableRead(transformDefinition, instanceData, 0, instanceDataSize); //build memory stream on the byte[] , and allow writes only if // FileAccess is Write or ReadWrite MemoryStream instanceDataStream; if (_associatedStorage.OpenAccess == FileAccess.Read) { // NOTE: Building MemoryStream directly on top of // instanceData byte array because we want it to be // NOT resizable and NOT writable. instanceDataStream = new MemoryStream(instanceData, false /* Not writable */); } else { // Copy additional data into a memory stream // NOTE: Not building MemoryStream directly on top of // instanceData byte array because we want it to be // resizable. instanceDataStream = new MemoryStream(); instanceDataStream.Write( instanceData, 0, instanceDataSize ); } instanceDataStream.Seek( 0, SeekOrigin.Begin ); // Dirty state should be tracked after the original data is read in from the disk into the memory stream transformInstance.transformPrimaryStream = new DirtyStateTrackingStream(instanceDataStream); } transformInstance.transformStorage = transformStorage; SetTransformDefinition( transformStorage.Name, transformInstance ); } } } } }
/// <summary> /// When a substorage is getting deleted, its references in the dataspacemanager's transform definition are removed. /// This is called recursively because the DeleteSubStorage deletes all its children by default. /// </summary> internal void RemoveSubStorageEntryFromDataSpaceMap(StorageInfo storageInfo) { StorageInfo[] subStorages = storageInfo.GetSubStorages(); foreach(StorageInfo storage in subStorages) { //If this is a storage, call recursively till we encounter a stream. Then we can use that container (storage,stream) reference to remove from the // dataspace manager's data space map. RemoveSubStorageEntryFromDataSpaceMap(storage); //recursive call } //Now we have StorageInfo. Find if there is a stream underneath so a container can be used as reference in data space map of data spacemanager. StreamInfo[] streams = storageInfo.GetStreams(); DataSpaceManager manager = Root.GetDataSpaceManager(); foreach(StreamInfo stream in streams) { manager.RemoveContainerFromDataSpaceMap(new CompoundFileStreamReference( storageInfo.FullNameInternal, stream.Name )); } }
/// <summary> /// Write out all transform definitions all at once /// </summary> /// // void WriteTransformDefinitions() { ThrowIfIncorrectUpdaterVersion(); StorageInfo dataSpaceStorage = new StorageInfo( _associatedStorage, DataSpaceStorageName ); StorageInfo transformDefinitionsStorage = new StorageInfo( dataSpaceStorage, TransformDefinitions ); // if( 0 < _transformDefinitions.Count ) { foreach( string transformDef in _transformDefinitions.Keys ) { // 'transformDef' is the normalized label. We need to dig a // bit to retrieve the original transform label. string transformLabel = null; TransformInstance transformInstance = GetTransformInstanceOf( transformDef ); Debug.Assert( transformInstance != null, "A transform instance should be available if its name is in the transformDefinitions hashtable"); if( transformInstance.transformEnvironment != null ) { // We have a transform environment object - it has the transform label. transformLabel = transformInstance.transformEnvironment.TransformLabel; } else { // We don't have a transform environment object - we'll need to do a // more expensive reverse-lookup with the name manager. transformLabel = transformDef; } // Now use transformLabel to create the storage. StorageInfo singleTransformStorage = new StorageInfo( transformDefinitionsStorage, transformLabel ); StreamInfo transformPrimaryInfo = new StreamInfo( singleTransformStorage, TransformPrimaryInfo ); using(Stream transformPrimary = transformPrimaryInfo.GetStream()) { using(BinaryWriter transformWriter = new BinaryWriter( transformPrimary, System.Text.Encoding.Unicode )) { // Header length size = Known (the number itself + identifier) + // to be calculated (length of type name) int headerLength = checked (KnownBytesInTransformDefinitionHeader + CU.WriteByteLengthPrefixedDWordPaddedUnicodeString( null, transformInstance.typeName)); if (transformInstance.ExtraData != null) { Debug.Assert(transformInstance.ExtraData.Length > 0); checked { headerLength += transformInstance.ExtraData.Length; } } transformWriter.Write(headerLength); transformWriter.Write((int)TransformIdentifierTypes_PredefinedTransformName); CU.WriteByteLengthPrefixedDWordPaddedUnicodeString( transformWriter, transformInstance.typeName); // Write out the preserved unknown data if there are some if (transformInstance.ExtraData != null) { transformWriter.Write(transformInstance.ExtraData); } if( null != transformInstance.transformPrimaryStream ) { byte[] memoryBuffer = ((MemoryStream) ((DirtyStateTrackingStream) transformInstance.transformPrimaryStream).BaseStream).GetBuffer(); transformPrimary.Write( memoryBuffer, 0, memoryBuffer.Length ); } } } } } else // No transform definitions { if ( transformDefinitionsStorage.Exists) { dataSpaceStorage.Delete(true, TransformDefinitions); //transformDefinitionStorage.Delete(true); } } }
/***********************************************************************/ // Constructors private void BuildStreamInfoRelativeToStorage(StorageInfo parent, string path) { parentStorage = parent; core = parentStorage.CoreForChildStream(path); }
// 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; }
/// <summary> /// Read the version information that specifies the minimum versions of the /// DataSpaceManager software that can read, write, or update the data space /// information in this file. /// </summary> /// <param name="dataSpaceStorage"></param> /// <exception cref="FileFormatException"> /// If the format version information in the stream is corrupt. /// </exception> private void ReadDataSpaceVersionInformation(StorageInfo dataSpaceStorage) { if (_fileFormatVersion == null) { if (dataSpaceStorage.StreamExists( DataSpaceVersionName )) { StreamInfo versionStreamInfo = dataSpaceStorage.GetStreamInfo( DataSpaceVersionName ); using (Stream versionStream = versionStreamInfo.GetStream(FileMode.Open)) { _fileFormatVersion = FormatVersion.LoadFromStream(versionStream); // Transform Identifier: we preserve casing, but do case-insensitive comparison //Case-insensitive comparison. As per recommendations, we convert both strings //to Upper case and then compare with StringComparison.Ordinal if (!((IEqualityComparer) CU.StringCaseInsensitiveComparer).Equals(_fileFormatVersion.FeatureIdentifier, DataSpaceVersionIdentifier)) { throw new FileFormatException( SR.Get(SRID.InvalidTransformFeatureName, _fileFormatVersion.FeatureIdentifier, DataSpaceVersionIdentifier)); } // If we ever write this version number out again, we will want to record // the fact that it was done by the current version of the Dataspace software. _fileFormatVersion.WriterVersion = DataSpaceCurrentWriterVersion; } } } }
public StorageStreamBase(string fileName, StorageInfo storage) : base(fileName) { FileName = fileName; Storage = storage; }