static void InitializeHandle(out uint handle, int engineIndex, int branchIndex, int revisionIndex) { var encoder = new Bitwise.HandleBitEncoder(); EngineBuildRevision.BitEncodeIndex(ref encoder, revisionIndex); EngineBuildBranch.BitEncodeIndex(ref encoder, branchIndex); BlamEngine.BitEncodeIndex(ref encoder, engineIndex); Contract.Assert(encoder.UsedBitCount == EngineBuildHandle.BitCount); handle = encoder.GetHandle32(); }
static int RevisionIdResolver(EngineBuildBranch branch, int version) { int id = TypeExtensions.kNone; if (version.IsNotNone()) { id = branch.Revisions.FindIndex(x => x.Version == version); if (id.IsNone()) { throw new KeyNotFoundException(string.Format("Engine branch {0} doesn't define a revision for version #{1}", branch.Name, version)); } } 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; } } }
/// <summary>Tests whether this handle and the branch's are of the same <see cref="Engine"/> and <see cref="Branch"/></summary> /// <param name="branch">The branch to compare with</param> /// <returns></returns> /// <remarks>If either handle in this equation <see cref="IsNone"/>, this will return false</remarks> public bool IsWithinSameBranch(EngineBuildBranch branch) { Contract.Requires(branch != null); return(this.IsWithinSameBranch(branch.BranchHandle)); }