예제 #1
0
        public override ArchiveBase GetArchive(Memory.Archive archive)
        {
            if (archive == Memory.Archives.ZZZ_MAIN || archive == Memory.Archives.ZZZ_OTHER)
            {
                var zzz = archive.ZZZ;
                if (FindFile(ref zzz) <= -1 || string.IsNullOrWhiteSpace(zzz))
                {
                    return(null);
                }
                if (File.Exists(zzz))
                {
                    archive.SetFilename(zzz);
                }
                return(!CacheTryGetValue(archive, out var ab) ? ArchiveZzz.Load(zzz) : ab);
            }

            if (CacheTryGetValue(archive, out var value))
            {
                return(value);
            }
            GetArchive(archive, out var fI, out var fS, out StreamWithRangeValues fL);
            return(fI == null || fS == null || fL == null ||
                   fI.Length == 0 || fL.Length == 0
                ? null
                : new ArchiveWorker(archive, fI, fS, fL));
        }
예제 #2
0
            protected void SetValues(Memory.Archive archive, params string[] filenames)
            {
                Memory.Log.WriteLine($"{nameof(StringsBase)}::{nameof(SetValues)} Archive= \"{archive}\", Files= {{{string.Join(", ", filenames)}}}");

                Archive   = archive;
                Filenames = filenames;
            }
예제 #3
0
        //prevent two loads at the same time.

        #region Methods

        public static ArchiveBase Load(Memory.Archive path, bool skipList = false)
        {
            if (string.IsNullOrWhiteSpace(path))
            {
                return(null);
            }
            lock (Locker)
            {
                if (CacheTryGetValue(path, out ArchiveBase value))
                {
                    return(value);
                }
                else
                {
                    value = new ArchiveZzz(path, skipList);
                    if (!value.IsOpen)
                    {
                        value = null;
                    }
                    if (value == null || string.IsNullOrWhiteSpace(path))
                    {
                        return(null);
                    }
                    if (CacheTryAdd(value.GetPath() ?? path, value))
                    {
                    }
                    path.SetFilename(value.GetPath() ?? path);
                }
                return(value);
            }
        }
예제 #4
0
        public static ArchiveBase Load(Memory.Archive archive)
        {
            if (archive.IsDir)
            {
                return(ArchiveWorker.Load(archive));
            }

            if (archive.IsFile)
            {
                if (archive.IsFileArchive || archive.IsFileIndex || archive.IsFileList)
                {
                    var a = new Memory.Archive(Path.GetFileNameWithoutExtension(archive), Path.GetDirectoryName(archive));
                    return(ArchiveWorker.Load(a));
                }

                if (archive.IsZZZ)
                {
                    return(ArchiveZzz.Load(archive));
                }

                return(ArchiveWorker.Load(archive));
            }

            return(null);
        }
예제 #5
0
 public void GetArchive(Memory.Archive archive, out byte[] fi, out byte[] fs, out byte[] fl)
 {
     Memory.Log.WriteLine($"{nameof(ArchiveBase)}::{nameof(GetArchive)} - Reading: {archive.FI}, {archive.FS}, {archive.FL}");
     fi = GetBinaryFile(archive.FI);
     fs = GetBinaryFile(archive.FS, cache: true);
     fl = GetBinaryFile(archive.FL);
 }
예제 #6
0
 public void GetArchive(Memory.Archive archive, out StreamWithRangeValues fi, out ArchiveBase fs, out StreamWithRangeValues fl)
 {
     Memory.Log.WriteLine($"{nameof(ArchiveBase)}::{nameof(GetArchive)} - Reading: {archive.FI}, {archive.FS}, {archive.FL}");
     fi = GetStreamWithRangeValues(archive.FI);
     fs = this;
     fl = GetStreamWithRangeValues(archive.FL);
 }
예제 #7
0
 public FF8StringReference(Memory.Archive archive, string filename, long offset, ushort length = 0, Settings settings = Settings.None)
 {
     Archive        = archive;
     Filename       = filename;
     Offset         = offset;
     ReadLength     = length;
     StringSettings = settings;
 }
예제 #8
0
 /// <summary>
 /// Saves the active archive and file list.
 /// </summary>
 /// <param name="path">Memory.Archive</param>
 /// <param name="skiplist">If list generation is unneeded you can skip it by setting true</param>
 public ArchiveWorker(Memory.Archive path, bool skiplist = false)
 {
     _path = path;
     if (!skiplist)
     {
         FileList = ProduceFileLists();
     }
 }
예제 #9
0
            protected void SetValues(Memory.Archive archive, params string[] filenames)
            {
                Debug.WriteLine("Task={0}, Thread={2}, [Files={1}]",
                                Task.CurrentId, string.Join(", ", filenames),
                                Thread.CurrentThread.ManagedThreadId);

                Archive   = archive;
                Filenames = filenames;
            }
예제 #10
0
 public override ArchiveBase GetArchive(Memory.Archive archive)
 {
     lock (GetArchiveLock)
     {
         if (!CacheTryGetValue(archive, out ArchiveBase value))
         {
             return(ArchiveWorker.Load(archive, GetStreamWithRangeValues(archive.FI), this, GetStreamWithRangeValues(archive.FL)));
         }
         return(value);
     }
 }
예제 #11
0
 /// <summary>
 /// Saves the active archive and file list.
 /// </summary>
 /// <param name="path">Memory.Archive</param>
 /// <param name="skiplist">If list generation is unneeded you can skip it by setting true</param>
 public ArchiveWorker(Memory.Archive path, bool skiplist = false)
 {
     if (Directory.Exists(path))
     {
         isDir = true;
     }
     _path = path;
     if (!skiplist)
     {
         FileList = ProduceFileLists();
     }
 }
예제 #12
0
        private ArchiveWorker(Memory.Archive archive, StreamWithRangeValues fI, ArchiveBase fS, StreamWithRangeValues fL, bool skipList = false)
        {
            ArchiveMap = new ArchiveMap(fI, fL, fS.GetMaxSize(archive));
            Archive    = archive;
            FsArchive  = fS;
            //FS = null;
            if (!skipList)
            {
                GetListOfFiles();
            }

            IsOpen = true;
        }
예제 #13
0
 public override ArchiveBase GetArchive(Memory.Archive archive)
 {
     byte[] fI = GetBinaryFile(archive.FI);
     byte[] fS = GetBinaryFile(archive.FS);
     byte[] fL = GetBinaryFile(archive.FL);
     if (fI == null || fS == null || fL == null ||
         fI.Length == 0 || fS.Length == 0 || fL.Length == 0)
     {
         return(null);
     }
     return(new ArchiveWorker(fI, fS, fL)
     {
         _path = archive
     });
 }
예제 #14
0
        /// <summary>
        /// Load Archive with out storing FS in byte[] works for archive that aren't compressed.
        /// </summary>
        /// <param name="path">Archive file archive.</param>
        /// <param name="fI">Stream containing the FI file</param>
        /// <param name="fS">Archive where the FS file is.</param>
        /// <param name="fL">Stream containing the FL file</param>
        /// <param name="skipList">Skip generating list of files</param>
        /// <returns>ArchiveWorker</returns>
        public static ArchiveBase Load(Memory.Archive path, StreamWithRangeValues fI, ArchiveBase fS, StreamWithRangeValues fL, bool skipList = false)
        {
            if (CacheTryGetValue(path, out var value))
            {
                return(value);
            }

            value = new ArchiveWorker(path, fI, fS, fL, skipList);
            if (!value.IsOpen)
            {
                value = null;
            }
            if (CacheTryAdd(path, value))
            {
            }
            return(value);
        }
예제 #15
0
        private ArchiveZzz(Memory.Archive archive, bool skipList = false)
        {
            ArchiveBase tempArchive = null;

            ParentPath = FindParentPath(archive);
            if (ParentPath != null && ParentPath.Count > 0)
            {
                foreach (Memory.Archive p in ParentPath)
                {
                    if (p.IsDir)
                    {
                        tempArchive = ArchiveBase.Load(p);
                    }
                    else if (tempArchive != null)
                    {
                        throw new Exception("zzz shouldn't be inside an archive.");
                    }
                }
            }
            Archive = archive;
            if (tempArchive != null)
            {
                archive.SetFilename(tempArchive.GetListOfFiles()
                                    .FirstOrDefault(x => x.IndexOf(archive.ZZZ, StringComparison.OrdinalIgnoreCase) > 0));
            }
            Memory.Log.WriteLine($"{nameof(ArchiveZzz)}:: opening archiveFile: {archive}");
            if (string.IsNullOrWhiteSpace(archive))
            {
                return;
            }
            using (BinaryReader br = Open())
            {
                if (br == null)
                {
                    return;
                }
                ArchiveMap = Header.Load(br);
            }
            if (!skipList)
            {
                GetListOfFiles();
            }
            IsOpen = true;
        }
예제 #16
0
        public static ArchiveBase Load(Memory.Archive path, bool skipList = false)
        {
            if (path.IsZZZ)
            {
                return(ArchiveZzz.Load(path, skipList));
            }
            if (CacheTryGetValue(path, out var value))
            {
                return(value);
            }

            value = new ArchiveWorker(path, skipList);
            if (!value.IsOpen)
            {
                value = null;
            }
            if (CacheTryAdd(path, value))
            {
            }
            return(value);
        }
예제 #17
0
        /// <summary>
        /// Saves the active archive and file list.
        /// </summary>
        /// <param name="archive">Memory.Archive</param>
        /// <param name="skipList">If list generation is unneeded you can skip it by setting true</param>
        private ArchiveWorker(Memory.Archive archive, bool skipList = false)
        {
            if (archive.IsDir)
            {
                Memory.Log.WriteLine($"{nameof(ArchiveWorker)}:: opening directory: {archive}");
                IsDir = true;
            }
            else
            {
                Memory.Log.WriteLine($"{nameof(ArchiveWorker)}:: opening archiveFile: {archive}");
            }
            Archive    = archive;
            ParentPath = FindParentPath(archive);
            ArchiveBase tempArchive = null;

            if (ParentPath != null && ParentPath.Count > 0)
            {
                foreach (var p in ParentPath)
                {
                    if (tempArchive != null)
                    {
                        tempArchive = tempArchive.GetArchive(p);
                    }
                    else if (p.IsDir || p.IsFile)
                    {
                        tempArchive = ArchiveBase.Load(p);
                    }
                }
            }
            if (tempArchive != null)
            {
                tempArchive.GetArchive(archive, out var fi, out FsArchive, out var fl);
                ArchiveMap = new ArchiveMap(fi, fl, tempArchive.GetMaxSize(archive));
            }
            if (!skipList)
            {
                GetListOfFiles();
            }
            IsOpen = true;
        }
예제 #18
0
 protected StringsBase(Memory.Archive archive, params string[] filenames)
 {
     Archive   = archive;
     Filenames = filenames;
     Init();
 }
예제 #19
0
 public override ArchiveBase GetArchive(Memory.Archive archive)
 {
     return(new ArchiveWorker(GetBinaryFile(archive.FI), GetBinaryFile(archive.FS), GetBinaryFile(archive.FL)));
 }
예제 #20
0
 public virtual int GetMaxSize(Memory.Archive archive)
 {
     using (var s = GetStreamWithRangeValues(archive.FS))
         return(checked ((int)s.Size));
 }
예제 #21
0
        /// <summary>
        /// Generate archive worker and get file
        /// </summary>
        /// <param name="archive">which archive you want to read from</param>
        /// <param name="fileName">name of file you want to recieve</param>
        /// <returns>Uncompressed binary file data</returns>
        public static byte[] GetBinaryFile(Memory.Archive archive, string fileName)
        {
            ArchiveWorker tmp = new ArchiveWorker(archive, true);

            return(tmp.GetBinaryFile(fileName));
        }
예제 #22
0
 public abstract ArchiveBase GetArchive(Memory.Archive archive);