public void CommitFromMemory(
            IRegistryFileDescriptor registryFileDesc,
            SparseClusteredArray <byte> memSCA,
            SparseClusteredArray <byte> rtxSCA)
        {
            memSCA.Lock.EnterUpgradeableReadLock();
            rtxSCA.Lock.EnterUpgradeableReadLock();

            try
            {
                foreach (var memStream in memSCA.GetStreams())
                {
                    var memElems = memStream.StreamToStruct <RegMemElem17, RegMemElem17>(
                        RegMemElem17.SizeOfMemElem,
                        e => e
                        );

                    foreach (var memElemKeyValue in memElems.OrderBy(kv => kv.Value.rtxOffset))
                    {
                        var id      = memElemKeyValue.Key;
                        var memElem = memElemKeyValue.Value;

                        var lower = memElem.rtxOffset - 1;
                        var upper = memElem.rtxOffset + memElem.rtxLength - 2;

                        if (upper < lower || upper < 0)
                        {
                            LogTo.Warning($"({registryFileDesc.RegistryName}) Invalid rtx offsets, upper: {upper}, lower: {lower}");
                            continue;
                        }

                        SparseClusteredArray <byte> .Bounds rtxBounds = new SparseClusteredArray <byte> .Bounds(
                            lower,
                            upper
                            );

                        using (var rtStream = rtxSCA.GetSubsetStream(rtxBounds))
                        {
                            RegRtElem17 rtxElem = default;

                            if (rtStream != null)
                            {
                                rtxElem = ParseRtStream(rtStream,
                                                        memElem);
                            }

                            Commit(id, memElem, rtxElem);
                        }
                    }
                }

                memSCA.Clear();
                rtxSCA.Clear();
            }
            finally
            {
                memSCA.Lock.ExitUpgradeableReadLock();
                rtxSCA.Lock.ExitUpgradeableReadLock();
            }
        }
Exemplo n.º 2
0
 public static string GetRtfFilePath(
     this SMCollection collection,
     IRegistryFileDescriptor fileDesc)
 {
     return(collection.GetFilePath(SMConst.Paths.RegistryFolder,
                                   fileDesc.RtfFileName));
 }
        public void CommitFromFiles(SMCollection collection,
                                    IRegistryFileDescriptor registryFileDesc)
        {
            var memFilePath = collection.GetMemFilePath(registryFileDesc);
            var rtxFilePath = collection.GetRtxFilePath(registryFileDesc);

            var memExists = File.Exists(memFilePath);
            var rtxExists = File.Exists(rtxFilePath);

            switch (registryFileDesc.IsOptional)
            {
            case true when rtxExists == false || memExists == false:
                return;

            case false when memExists == false:
                throw new InvalidOperationException($"({GetType().Name}) Failed to load registry file: no such file {memFilePath}");

            case false when rtxExists == false:
                throw new InvalidOperationException($"({GetType().Name}) Failed to load registry file: no such file {rtxFilePath}");
            }

            using (Stream memStream = File.OpenRead(memFilePath))
                using (Stream rtxStream = File.OpenRead(rtxFilePath))
                //using (Stream rtfStream = File.OpenRead(rtfFilePath))
                {
                    Dictionary <int, RegMemElem17> memElems = memStream.StreamToStruct <RegMemElem17, RegMemElem17>(
                        RegMemElem17.SizeOfMemElem,
                        e => e
                        );

                    foreach (var id in memElems.Keys.OrderBy(id => id))
                    {
                        var memElem = memElems[id];
                        var rtxElem = ParseRtStream(rtxStream, memElem);

                        Commit(id, memElem, rtxElem);
                    }
                }
        }