public BlamEngine() { Name = ""; BuildRepository = new EngineBuildRepository(); mSystemPrototypes = new Dictionary <Values.KGuid, BlamEngineSystem>(); }
static int BranchIdResolver(EngineBuildRepository repo, string name) { int id = TypeExtensions.kNone; if (!string.IsNullOrEmpty(name)) { id = repo.Branches.FindIndex(x => x.Name == name); if (id.IsNone()) { throw new KeyNotFoundException(string.Format("Engine {0} doesn't define a branch named {1}", repo.Engine.Name, name)); } } return(id); }
/// <summary>Serialize a build handle, using a 'baseline' to populate or cull (from writing) root build information</summary> /// <param name="s"></param> /// <param name="baseline">Root build information (ie, engine, or engine and branch)</param> /// <param name="value"></param> public static void SerializeWithBaseline <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s, EngineBuildHandle baseline, ref EngineBuildHandle value) where TDoc : class where TCursor : class { int engine_index = baseline.EngineIndex; int branch_index = baseline.BranchIndex; int revisn_index = baseline.RevisionIndex; EngineBuildRepository repo = null; EngineBuildBranch branch = null; if (s.IsWriting) { #region prepare engine_index if (value.EngineIndex == engine_index) { repo = EngineRegistry.Engines[engine_index].BuildRepository; // cause engine_index not to be written engine_index = TypeExtensions.kNone; } else { engine_index = value.EngineIndex; } #endregion #region prepare branch_index if (value.BranchIndex == branch_index) { branch = repo.Branches[branch_index]; // cause branch_index not to be written branch_index = TypeExtensions.kNone; } else { branch_index = value.BranchIndex; } #endregion #region prepare revisn_index if (value.BranchIndex == revisn_index) { // cause branch_index not to be written branch_index = TypeExtensions.kNone; } else { revisn_index = value.RevisionIndex; } #endregion } // This is a logic driven mess, but having branches for both IsReading and IsWriting would result in more copy&paste code // reading: baseline EngineIndex is valid, or index is serialized // writing: value EngineIndex mismatches baseline if (engine_index.IsNotNone() || BlamEngine.SerializeId(s, kAttributeNameEngine, ref engine_index, true)) { repo = EngineRegistry.Engines[engine_index].BuildRepository; } // precondition: someone's EngineIndex was valid // reading: baseline BranchIndex is valid, or index is serialized // writing: value BranchIndex mismatches baseline if (repo != null && (branch_index.IsNotNone() || repo.SerializeBranchId(s, kAttributeNameBranch, ref branch_index, true))) { branch = repo.Branches[branch_index]; } // precondition: someone's BranchIndex was valid // reading: baseline RevisionIndex is valid // writing: value RevisionIndex mismatches baseline if (branch != null && (revisn_index.IsNotNone() || s.IsReading)) { branch.SerializeRevisionId(s, kAttributeNameRevisn, ref revisn_index, true); } if (s.IsReading) { if (engine_index.IsNotNone()) { value = new EngineBuildHandle(engine_index, branch_index, revisn_index); } else // engine_index is NONE, don't even bother trying to encode a new handle that should be all NONE anyway { value = EngineBuildHandle.None; } } }