void CMnemosynthDb::Write (const CString &sCollection, const CString &sKey, CDatum dValue) // Write // // Write an entry in a collection { CSmartLock Lock(m_cs); // Get the entry (creating it if necessary) SEntry *pEntry = GetWriteEntry(sCollection, sKey); // Set the sequence number and owner. Since this is a local write, the // owner is always us (which is always the first entry). pEntry->dwOwnerID = 0; pEntry->dwSequence = GetNextSequence(); // Set the data pEntry->dValue = dValue; #ifdef DEBUG_MNEMOSYNTH printf("[CMnemosynthDb::Write]: Wrote %s/%s Seq = %x\n", (LPSTR)sCollection, (LPSTR)sKey, pEntry->dwSequence); #endif // Modified m_ModifiedEvent.Set(); }
// **************************************************************************** // Method: PointSequenceList::GetNextSequence // // Purpose: // Extract another sequence from the connectivity array and return it // as a PointSequence. Skip repeated adjacent points. // // Returns: true if we found another sequence; false otherwise // // Programmer: Jeremy Meredith // Creation: November 1, 2002 // // Modifications: // Rich Cook and Hank Childs, Thu Oct 2 16:32:55 PDT 2008 // Added support for loops. // // Eric Brugger, Tue Dec 29 16:35:34 PST 2009 // I modified the logic that looks for loops to only consider points // that have 2 neighbors. Previously it would have considered points // with no neighbors, which caused it to reference uninitialized memory. // // Jean Favre, Tue May 7 16:38:37 CEST 2013 // I modified the calls to GetPoint() to use the other variant of the call // with two arguments. The previous version would never succeed in the test // to remove sequential identical points. // Used vtkIdType where needed // **************************************************************************** bool vtkConnectedTubeFilter::PointSequenceList::GetNextSequence(PointSequence &seq) { // index is already set by InitTraversal and previous calls to this fn for (; index < len; index++) { // if numneighbors is 1, then this is a start point if (((lookforloops && numneighbors[index] == 2) || numneighbors[index] == 1) && !visited[index]) { vtkIdType current = index; vtkIdType previous = -1; seq.Init(len); seq.Add(current, cellindex[current]); visited[current] = true; while (true) { vtkIdType n1 = connectivity[0][current]; vtkIdType n2 = connectivity[1][current]; vtkIdType next = (n1 == previous) ? n2 : n1; previous = current; current = next; // we must skip any sequential identical points: // 1) they are useless, and 2) they mess up calculations double prePt[3]; double curPt[3]; pts->GetPoint(previous, prePt); pts->GetPoint(current, curPt); if (prePt[0] != curPt[0] || prePt[1] != curPt[1] || prePt[2] != curPt[2]) { seq.Add(current, cellindex[current]); } // check for a loop (AFTER adding the node again...) if (lookforloops && visited[current]) { break; } visited[current] = true; bool endpoint = (numneighbors[current] == 1); if (endpoint) break; } // We may have one duplicated cell index due to the way the // connectivity was built -- shift them all down by one from // the right spot, so the only duplicated one is the last one. for (int i=1; i<seq.length-1; i++) { if (seq.cellindex[i-1] == seq.cellindex[i]) seq.cellindex[i] = seq.cellindex[i+1]; } // true ==> success; got another sequence return true; } } if (index == len && !lookforloops) { lookforloops = true; index=0; return GetNextSequence(seq); } // false ==> failed; no more sequences return false; }