bool ExtractWithDependents(Blam.CacheExtractionInfo cei, TagManager tag) { ErrorTagDatabase etdb = cei.DatabaseErrors; bool error_root_is_initialized = false; var depns = cacheFile.ExtractionState.CurrentDependents(); var depns_to_extract = new List <Blam.DatumIndex>(); foreach (Blam.DatumIndex datum in depns) { if (!ExtractionDontExtract(cei, datum)) { cei.Database.AddDependent(cacheFile.Index.Tags[datum.Index]); depns_to_extract.Add(datum); } else { ExtractWithDependentsErrorSkipped(etdb, tag, ref error_root_is_initialized, datum); cacheFile.ExtractionState.Dequeue(datum); } } // extract the valid dependents foreach (Blam.DatumIndex datum in depns_to_extract) { cei.Reset(cacheFile.Index.Tags[datum.Index]); if (!Extract(cei, datum, true)) { ExtractWithDependentsErrorFailed(etdb, tag, ref error_root_is_initialized, datum); } } return(true); }
/// <summary> /// /// </summary> /// <param name="cei"></param> /// <returns>True if any tags were extracted and if they extracted successfully. False if otherwise</returns> public bool Extract(Blam.CacheExtractionInfo cei) { if (!ExtractionDontExtract(cei, cei.Definition.Datum)) { return(Extract(cei, cei.Definition.Datum, false)); } return(false); }
void ExtractWriteTagDatabases(Blam.CacheExtractionInfo cei, TagManager root_tag) { var tdb_group = Program.GetManager(Engine).TagDatabaseGroup; ExtractWriteTagDatabase(cei, root_tag, tdb_group, cei.Database.Definition, false); ExtractWriteTagDatabase(cei, root_tag, tdb_group, cei.DatabaseErrors.Definition, true); }
/// <summary> /// For deciding if <paramref name="tag_datum"/> exists on disk already and thus shouldn't be extracted /// </summary> /// <param name="cei"></param> /// <param name="tag_datum">Engine's index of the tag instance</param> /// <returns>True if the tag exists on disk, false if it doesn't</returns> protected virtual bool ExtractionTagExistsOnDisk(Blam.CacheExtractionInfo cei, Blam.DatumIndex tag_datum) { if (!cei.Arguments.OverwriteExisting) { string base_dir = cei.Arguments.OutputDirectory; string tag_name = cacheFile.GetTagIndexName(tag_datum, true); return(File.Exists(Path.Combine(base_dir, tag_name))); } return(false); }
void ExtractWriteTagDatabase(Blam.CacheExtractionInfo cei, TagManager root_tag, TagInterface.TagGroup database_group, TagInterface.Definition db_definition, bool is_error_db) { if ((db_definition as ITagDatabase).IsEmpty) { return; } // name the database after the root tag we're extracting string tag_name = root_tag.Name; if (is_error_db) { tag_name = string.Format("{0}.errors", tag_name); } Blam.CacheIndex.Item tdb_item; // Just in-case someone tries to extract the same root tag twice if (!cacheFile.TryAndFind(tag_name, database_group, out tdb_item)) { tdb_item = cacheFile.AddFeignTagInstance(tag_name, database_group); if (tdb_item == null) { extractionTrace.WriteLine("Couldn't create a tag_database for {0}! Couldn't create tag entry for database", root_tag.Name); return; } } try { var tdb_index = this.Open(tdb_item.Datum); var tdb = this[tdb_index]; tdb.Manage(db_definition); // Even though the tag isn't actually in the cache, the tag // manager needs to operate this way with CacheTagIndex elements tdb.OpenForExtract(cei.Arguments.OutputDirectory, null); tdb.Extract(); tdb.Close(); Unload(tdb_index); } catch (Exception ex) { extractionTrace.WriteLine("Error while trying to write tag_database!"); extractionTrace.WriteLine(ex); } }
/// <summary>Initialize the extraction process</summary> /// <param name="tag_datum"></param> /// <param name="args"></param> /// <returns></returns> public Blam.CacheExtractionInfo ExtractionBegin(Blam.DatumIndex tag_datum, Blam.CacheExtractionArguments args) { if (tag_datum == Blam.DatumIndex.Null) { throw new ArgumentNullException("tag_datum", "Null datum index!"); } var cei = new Blam.CacheExtractionInfo(cacheFile, tag_datum, args); cacheFile.PrepareForExtraction(cei); return(cei); }
/// <summary>For deciding if <paramref name="tag_datum"/> shouldn't be extracted to disc or not</summary> /// <param name="cei"></param> /// <param name="tag_datum">Engine's index of the tag instance</param> /// <returns>True if the tag is not suppose to be extract, false if it is</returns> protected virtual bool ExtractionDontExtract(Blam.CacheExtractionInfo cei, Blam.DatumIndex tag_datum) { bool dont_extract = false; var ignore_groups = cei.Arguments.DontExtractGroups; if (ignore_groups != null) { var item = cacheFile.Index.Tags[tag_datum.Index]; dont_extract = ignore_groups.Contains(item.GroupTag); } // tag isn't of a group tag which we're ignoring so then check if // it is ignored for already existing if (!dont_extract) { dont_extract = ExtractionTagExistsOnDisk(cei, tag_datum); } return(dont_extract); }
bool Extract(Blam.CacheExtractionInfo cei, Blam.DatumIndex tag_datum, bool remove_from_state) { if (remove_from_state) { // don't process it if it's already been done if (cacheFile.ExtractionState.Processed(tag_datum)) { return(true); } cacheFile.ExtractionState.Dequeue(tag_datum); } cacheFile.ExtractionState.CurrentTag = tag_datum; Blam.CacheIndex.Item ci = cacheFile.Index.Tags[tag_datum.Index]; bool error = false; Blam.DatumIndex handle = Open(tag_datum); if (handle != Blam.DatumIndex.Null) { // we're about to extract, update our depth level cei.ExtractionDepth++; TagManager tm = Array[handle]; #region read the tag from the cache try { tm.OpenForExtract(cei.Arguments.OutputDirectory, null); } catch (Exception ex) { extractionTrace.WriteLine("Failed to read tag, aborting extraction...'{0}.{1}'{2}{3}", tm.Name, tm.GroupTag.Name, Program.NewLine, ex); error = true; } #endregion #region if no errors if (!error) { try { tm.Extract(); } catch (Exception ex) { extractionTrace.WriteLine("Failed to write tag, aborting extraction...'{0}.{1}'{2}{3}", tm.Name, tm.GroupTag.Name, Program.NewLine, ex); error = true; } tm.Close(); } // something bad happened, so make sure we don't keep any bad tags if (error) { System.IO.File.Delete(Path.Combine(cei.Arguments.OutputDirectory, tm.Name)); } // process dependents if we want to if (!error && cei.Arguments.WithDependents) { error = !ExtractWithDependents(cei, tm); } #endregion // we're done with the extraction process, update depth level cei.ExtractionDepth--; // create and write database if (cei.Arguments.OutputDatabase && cei.ExtractionDepth == 0) { ExtractWriteTagDatabases(cei, tm); } Unload(handle); } else { error = true; } return(!error); }
/// <summary>Initialize the extraction process</summary> /// <param name="tag_datum"></param> /// <param name="args"></param> /// <returns></returns> public Blam.CacheExtractionInfo ExtractionBegin(Blam.DatumIndex tag_datum, Blam.CacheExtractionArguments args) { if (tag_datum == Blam.DatumIndex.Null) throw new ArgumentNullException("tag_datum", "Null datum index!"); var cei = new Blam.CacheExtractionInfo(cacheFile, tag_datum, args); cacheFile.PrepareForExtraction(cei); return cei; }