void SG_vector_i64__alloc__from_varray(SG_context* pCtx, SG_varray* pva, SG_vector_i64 ** ppVector) { SG_uint32 count = 0; SG_uint32 i = 0; SG_vector_i64* pvec = NULL; SG_ERR_CHECK( SG_varray__count(pCtx, pva, &count) ); SG_ERR_CHECK( SG_vector_i64__alloc(pCtx, &pvec, count) ); for (i=0; i<count; i++) { SG_int64 v = 0; SG_ERR_CHECK( SG_varray__get__int64(pCtx, pva, i, &v) ); SG_ERR_CHECK( SG_vector_i64__append(pCtx, pvec, v, NULL) ); } *ppVector = pvec; pvec = NULL; return; fail: SG_VECTOR_I64_NULLFREE(pCtx, pvec); return; }
void sg_wc_tx__merge__add_to_kill_list(SG_context * pCtx, SG_mrg * pMrg, SG_uint64 uiAliasGid) { if (!pMrg->pVecRevertAllKillList) SG_ERR_CHECK( SG_VECTOR_I64__ALLOC(pCtx, &pMrg->pVecRevertAllKillList, 10) ); SG_ERR_CHECK( SG_vector_i64__append(pCtx, pMrg->pVecRevertAllKillList, (SG_int64)uiAliasGid, NULL) ); fail: return; }
void MyFn(test1)(SG_context * pCtx) { SG_vector_i64 * pVec = NULL; SG_uint32 k, ndx, len; VERIFY_ERR_CHECK( SG_vector_i64__alloc(pCtx,&pVec,20) ); VERIFY_ERR_CHECK( SG_vector_i64__length(pCtx,pVec,&len) ); VERIFY_COND("test1",(len==0)); for (k=0; k<100; k++) { SG_int64 kValue = (SG_int64)k; VERIFY_ERR_CHECK( SG_vector_i64__append(pCtx,pVec,kValue,&ndx) ); VERIFY_COND("append",(ndx==k)); } for (k=0; k<100; k++) { SG_int64 value; VERIFY_ERR_CHECK( SG_vector_i64__get(pCtx,pVec,k,&value) ); VERIFY_COND("get1",(value == ((SG_int64)k))); } for (k=0; k<100; k++) { SG_int64 kValue = (SG_int64)k+10000; VERIFY_ERR_CHECK( SG_vector_i64__set(pCtx,pVec,k,kValue) ); } for (k=0; k<100; k++) { SG_int64 value; VERIFY_ERR_CHECK( SG_vector_i64__get(pCtx,pVec,k,&value) ); VERIFY_COND("get2",(value == ((SG_int64)(k+10000)))); } VERIFY_ERR_CHECK( SG_vector_i64__length(pCtx,pVec,&len) ); VERIFY_COND("test1",(len==100)); VERIFY_ERR_CHECK( SG_vector_i64__clear(pCtx,pVec) ); VERIFY_ERR_CHECK( SG_vector_i64__length(pCtx,pVec,&len) ); VERIFY_COND("test1",(len==0)); // fall thru to common cleanup fail: SG_VECTOR_I64_NULLFREE(pCtx, pVec); }
void SG_mrg_cset_entry_conflict__append_change(SG_context * pCtx, SG_mrg_cset_entry_conflict * pMrgCSetEntryConflict, SG_mrg_cset_entry * pMrgCSetEntry_Leaf_k, SG_mrg_cset_entry_neq neq) { SG_NULLARGCHECK_RETURN(pMrgCSetEntryConflict); SG_NULLARGCHECK_RETURN(pMrgCSetEntry_Leaf_k); if (!pMrgCSetEntryConflict->pVec_MrgCSetEntry_Changes) SG_ERR_CHECK_RETURN( SG_vector__alloc(pCtx,&pMrgCSetEntryConflict->pVec_MrgCSetEntry_Changes,2) ); SG_ERR_CHECK_RETURN( SG_vector__append(pCtx,pMrgCSetEntryConflict->pVec_MrgCSetEntry_Changes,(void *)pMrgCSetEntry_Leaf_k,NULL) ); if (!pMrgCSetEntryConflict->pVec_MrgCSetEntryNeq_Changes) SG_ERR_CHECK_RETURN( SG_vector_i64__alloc(pCtx,&pMrgCSetEntryConflict->pVec_MrgCSetEntryNeq_Changes,2) ); SG_ERR_CHECK_RETURN( SG_vector_i64__append(pCtx,pMrgCSetEntryConflict->pVec_MrgCSetEntryNeq_Changes,(SG_int64)neq,NULL) ); ////////////////////////////////////////////////////////////////// // add the value of the changed fields to the prbUnique_ rbtrees so that we can get a count of the unique new values. // ////////////////////////////////////////////////////////////////// // the values for RENAME, MOVE, ATTRBITS, SYMLINKS, and SUBMODULES are collapsable. that is, if we // have something like: // A // / \. // L0 a0 // / \. // L1 L2 // // and a rename in each Leaf, then we can either: // [a] prompt for them to choose L1 or L2's name and then // prompt for them to choose L0 or the name from step 1. // // [b] prompt for them to choose L0, L1, or L2 in one question. // // unlike file-content-merging, the net-net is that we have 1 new value // that is one of the inputs (or maybe we let them pick a new onw), but // it is not a combination of them and so we don't need to display the // immediate ancestor in the prompt. // // so we carry-forward the unique values from the leaves for each of // these fields. so the final merge-result may have more unique values // that it has direct parents. ////////////////////////////////////////////////////////////////// if (neq & SG_MRG_CSET_ENTRY_NEQ__ATTRBITS) { SG_int_to_string_buffer buf; SG_int64_to_sz((SG_int64)pMrgCSetEntry_Leaf_k->attrBits, buf); if (!pMrgCSetEntryConflict->prbUnique_AttrBits) SG_ERR_CHECK_RETURN( SG_RBTREE__ALLOC(pCtx,&pMrgCSetEntryConflict->prbUnique_AttrBits) ); SG_ERR_CHECK_RETURN( _update_1_rbUnique(pCtx,pMrgCSetEntryConflict->prbUnique_AttrBits,buf,pMrgCSetEntry_Leaf_k) ); if (pMrgCSetEntry_Leaf_k->pMrgCSetEntryConflict && pMrgCSetEntry_Leaf_k->pMrgCSetEntryConflict->prbUnique_AttrBits) SG_ERR_CHECK_RETURN( _carry_forward_unique_values(pCtx, pMrgCSetEntryConflict->prbUnique_AttrBits, pMrgCSetEntry_Leaf_k->pMrgCSetEntryConflict->prbUnique_AttrBits) ); } if (neq & SG_MRG_CSET_ENTRY_NEQ__ENTRYNAME) { if (!pMrgCSetEntryConflict->prbUnique_Entryname) SG_ERR_CHECK_RETURN( SG_RBTREE__ALLOC(pCtx,&pMrgCSetEntryConflict->prbUnique_Entryname) ); SG_ERR_CHECK_RETURN( _update_1_rbUnique(pCtx, pMrgCSetEntryConflict->prbUnique_Entryname, SG_string__sz(pMrgCSetEntry_Leaf_k->pStringEntryname), pMrgCSetEntry_Leaf_k) ); if (pMrgCSetEntry_Leaf_k->pMrgCSetEntryConflict && pMrgCSetEntry_Leaf_k->pMrgCSetEntryConflict->prbUnique_Entryname) SG_ERR_CHECK_RETURN( _carry_forward_unique_values(pCtx, pMrgCSetEntryConflict->prbUnique_Entryname, pMrgCSetEntry_Leaf_k->pMrgCSetEntryConflict->prbUnique_Entryname) ); } if (neq & SG_MRG_CSET_ENTRY_NEQ__GID_PARENT) { if (!pMrgCSetEntryConflict->prbUnique_GidParent) SG_ERR_CHECK_RETURN( SG_RBTREE__ALLOC(pCtx,&pMrgCSetEntryConflict->prbUnique_GidParent) ); SG_ERR_CHECK_RETURN( _update_1_rbUnique(pCtx,pMrgCSetEntryConflict->prbUnique_GidParent,pMrgCSetEntry_Leaf_k->bufGid_Parent,pMrgCSetEntry_Leaf_k) ); if (pMrgCSetEntry_Leaf_k->pMrgCSetEntryConflict && pMrgCSetEntry_Leaf_k->pMrgCSetEntryConflict->prbUnique_GidParent) SG_ERR_CHECK_RETURN( _carry_forward_unique_values(pCtx, pMrgCSetEntryConflict->prbUnique_GidParent, pMrgCSetEntry_Leaf_k->pMrgCSetEntryConflict->prbUnique_GidParent) ); } if (neq & SG_MRG_CSET_ENTRY_NEQ__SYMLINK_HID_BLOB) { if (!pMrgCSetEntryConflict->prbUnique_Symlink_HidBlob) SG_ERR_CHECK_RETURN( SG_RBTREE__ALLOC(pCtx,&pMrgCSetEntryConflict->prbUnique_Symlink_HidBlob) ); SG_ERR_CHECK_RETURN( _update_1_rbUnique(pCtx,pMrgCSetEntryConflict->prbUnique_Symlink_HidBlob,pMrgCSetEntry_Leaf_k->bufHid_Blob,pMrgCSetEntry_Leaf_k) ); if (pMrgCSetEntry_Leaf_k->pMrgCSetEntryConflict && pMrgCSetEntry_Leaf_k->pMrgCSetEntryConflict->prbUnique_Symlink_HidBlob) SG_ERR_CHECK_RETURN( _carry_forward_unique_values(pCtx, pMrgCSetEntryConflict->prbUnique_Symlink_HidBlob, pMrgCSetEntry_Leaf_k->pMrgCSetEntryConflict->prbUnique_Symlink_HidBlob) ); } if (neq & SG_MRG_CSET_ENTRY_NEQ__SUBMODULE_HID_BLOB) { if (!pMrgCSetEntryConflict->prbUnique_Submodule_HidBlob) SG_ERR_CHECK_RETURN( SG_RBTREE__ALLOC(pCtx,&pMrgCSetEntryConflict->prbUnique_Submodule_HidBlob) ); SG_ERR_CHECK_RETURN( _update_1_rbUnique(pCtx,pMrgCSetEntryConflict->prbUnique_Submodule_HidBlob,pMrgCSetEntry_Leaf_k->bufHid_Blob,pMrgCSetEntry_Leaf_k) ); if (pMrgCSetEntry_Leaf_k->pMrgCSetEntryConflict && pMrgCSetEntry_Leaf_k->pMrgCSetEntryConflict->prbUnique_Submodule_HidBlob) SG_ERR_CHECK_RETURN( _carry_forward_unique_values(pCtx, pMrgCSetEntryConflict->prbUnique_Submodule_HidBlob, pMrgCSetEntry_Leaf_k->pMrgCSetEntryConflict->prbUnique_Submodule_HidBlob) ); } // 2010/09/13 Update: we now do the carry-forward on the set of // unique HIDs for the various versions of the file // content from each of the leaves. This lets us // completely flatten the sub-merges into one final // result (with upto n values). // // This means we won't be creating the auto-merge-plan // at this point. // // The problem with the auto-merge-plan as originally // designed is that it was being driven based upon // the overall topology of the DAG as a whole rather // than the topology/history of the individual file. // And by respecting the history of the individual // file, I think we can get closer ancestors and better // per-file merging and perhaps fewer criss-crosses // and/or we push all of these issues to RESOLVE. if (neq & SG_MRG_CSET_ENTRY_NEQ__FILE_HID_BLOB) { if (!pMrgCSetEntryConflict->prbUnique_File_HidBlob) SG_ERR_CHECK_RETURN( SG_RBTREE__ALLOC(pCtx,&pMrgCSetEntryConflict->prbUnique_File_HidBlob) ); SG_ASSERT( (pMrgCSetEntry_Leaf_k->bufHid_Blob[0]) ); // TODO 2010/09/13 the code that sets __FILE_HID_BLOB probably cannot tell // TODO whether this branch did not change the file content // TODO relative to the LCA or whether it did change it back to // TODO the original value (an UNDO of the edits). I would argue // TODO that we should not list the former as a change, but that // TODO we SHOULD list the latter. The fix doesn't belong here, // TODO but this is just where I was typing when I thought of it. SG_ERR_CHECK_RETURN( _update_1_rbUnique(pCtx,pMrgCSetEntryConflict->prbUnique_File_HidBlob,pMrgCSetEntry_Leaf_k->bufHid_Blob,pMrgCSetEntry_Leaf_k) ); if (pMrgCSetEntry_Leaf_k->pMrgCSetEntryConflict && pMrgCSetEntry_Leaf_k->pMrgCSetEntryConflict->prbUnique_File_HidBlob) SG_ERR_CHECK_RETURN( _carry_forward_unique_values(pCtx, pMrgCSetEntryConflict->prbUnique_File_HidBlob, pMrgCSetEntry_Leaf_k->pMrgCSetEntryConflict->prbUnique_File_HidBlob) ); } }