4 #include "textfile.h"
\r
19 void PWPath::Clear()
\r
27 void PWPath::ExpandPath(unsigned uAdditionalEdgeCount)
\r
29 PWEdge *OldPath = m_Edges;
\r
30 unsigned uEdgeCount = m_uArraySize + uAdditionalEdgeCount;
\r
32 m_Edges = new PWEdge[uEdgeCount];
\r
33 m_uArraySize = uEdgeCount;
\r
34 if (m_uEdgeCount > 0)
\r
35 memcpy(m_Edges, OldPath, m_uEdgeCount*sizeof(PWEdge));
\r
39 void PWPath::AppendEdge(const PWEdge &Edge)
\r
41 if (0 == m_uArraySize || m_uEdgeCount + 1 == m_uArraySize)
\r
44 m_Edges[m_uEdgeCount] = Edge;
\r
48 void PWPath::AppendEdge(char cType, unsigned uPrefixLengthA, unsigned uPrefixLengthB)
\r
51 e.uPrefixLengthA = uPrefixLengthA;
\r
52 e.uPrefixLengthB = uPrefixLengthB;
\r
57 void PWPath::PrependEdge(const PWEdge &Edge)
\r
59 if (0 == m_uArraySize || m_uEdgeCount + 1 == m_uArraySize)
\r
61 if (m_uEdgeCount > 0)
\r
62 memmove(m_Edges + 1, m_Edges, sizeof(PWEdge)*m_uEdgeCount);
\r
67 const PWEdge &PWPath::GetEdge(unsigned uEdgeIndex) const
\r
69 assert(uEdgeIndex < m_uEdgeCount);
\r
70 return m_Edges[uEdgeIndex];
\r
73 void PWPath::Validate() const
\r
75 const unsigned uEdgeCount = GetEdgeCount();
\r
76 if (0 == uEdgeCount)
\r
78 const PWEdge &FirstEdge = GetEdge(0);
\r
79 const PWEdge &LastEdge = GetEdge(uEdgeCount - 1);
\r
80 unsigned uStartA = FirstEdge.uPrefixLengthA;
\r
81 unsigned uStartB = FirstEdge.uPrefixLengthB;
\r
82 if (FirstEdge.cType != 'I')
\r
84 if (FirstEdge.cType != 'D')
\r
87 unsigned uPrefixLengthA = FirstEdge.uPrefixLengthA;
\r
88 unsigned uPrefixLengthB = FirstEdge.uPrefixLengthB;
\r
89 for (unsigned uEdgeIndex = 1; uEdgeIndex < uEdgeCount; ++uEdgeIndex)
\r
91 const PWEdge &Edge = GetEdge(uEdgeIndex);
\r
95 if (uPrefixLengthA + 1 != Edge.uPrefixLengthA)
\r
96 Quit("PWPath::Validate MA %u", uPrefixLengthA);
\r
97 if (uPrefixLengthB + 1 != Edge.uPrefixLengthB)
\r
98 Quit("PWPath::Validate MB %u", uPrefixLengthB);
\r
103 if (uPrefixLengthA + 1 != Edge.uPrefixLengthA)
\r
104 Quit("PWPath::Validate DA %u", uPrefixLengthA);
\r
105 if (uPrefixLengthB != Edge.uPrefixLengthB)
\r
106 Quit("PWPath::Validate DB %u", uPrefixLengthB);
\r
110 if (uPrefixLengthA != Edge.uPrefixLengthA)
\r
111 Quit("PWPath::Validate IA %u", uPrefixLengthA);
\r
112 if (uPrefixLengthB + 1 != Edge.uPrefixLengthB)
\r
113 Quit("PWPath::Validate IB %u", uPrefixLengthB);
\r
120 void PWPath::LogMe() const
\r
122 for (unsigned uEdgeIndex = 0; uEdgeIndex < GetEdgeCount(); ++uEdgeIndex)
\r
124 const PWEdge &Edge = GetEdge(uEdgeIndex);
\r
125 if (uEdgeIndex > 0)
\r
129 Edge.uPrefixLengthA,
\r
130 Edge.uPrefixLengthB);
\r
131 if ((uEdgeIndex > 0 && uEdgeIndex%10 == 0) ||
\r
132 uEdgeIndex == GetEdgeCount() - 1)
\r
137 void PWPath::Copy(const PWPath &Path)
\r
140 const unsigned uEdgeCount = Path.GetEdgeCount();
\r
141 for (unsigned uEdgeIndex = 0; uEdgeIndex < uEdgeCount; ++uEdgeIndex)
\r
143 const PWEdge &Edge = Path.GetEdge(uEdgeIndex);
\r
148 void PWPath::FromMSAPair(const MSA &msaA, const MSA &msaB)
\r
150 const unsigned uColCount = msaA.GetColCount();
\r
151 if (uColCount != msaB.GetColCount())
\r
152 Quit("PWPath::FromMSAPair, lengths differ");
\r
156 unsigned uPrefixLengthA = 0;
\r
157 unsigned uPrefixLengthB = 0;
\r
158 for (unsigned uColIndex = 0; uColIndex < uColCount; ++uColIndex)
\r
160 bool bIsGapA = msaA.IsGapColumn(uColIndex);
\r
161 bool bIsGapB = msaB.IsGapColumn(uColIndex);
\r
165 if (!bIsGapA && !bIsGapB)
\r
171 else if (bIsGapA && !bIsGapB)
\r
176 else if (!bIsGapA && bIsGapB)
\r
183 assert(bIsGapB && bIsGapA);
\r
187 Edge.cType = cType;
\r
188 Edge.uPrefixLengthA = uPrefixLengthA;
\r
189 Edge.uPrefixLengthB = uPrefixLengthB;
\r
194 // Very similar to HMMPath::FromFile, should consolidate.
\r
195 void PWPath::FromFile(TextFile &File)
\r
198 char szToken[1024];
\r
199 File.GetTokenX(szToken, sizeof(szToken));
\r
200 if (0 != strcmp(szToken, "Path"))
\r
201 Quit("Invalid path file (Path)");
\r
203 File.GetTokenX(szToken, sizeof(szToken));
\r
204 if (0 != strcmp(szToken, "edges"))
\r
205 Quit("Invalid path file (edges)");
\r
207 File.GetTokenX(szToken, sizeof(szToken));
\r
208 if (!IsValidInteger(szToken))
\r
209 Quit("Invalid path file (edges value)");
\r
211 const unsigned uEdgeCount = (unsigned) atoi(szToken);
\r
212 unsigned uEdgeIndex = 0;
\r
213 for (unsigned uEdgeIndex = 0; uEdgeIndex < uEdgeCount; ++uEdgeIndex)
\r
216 File.GetTokenX(szToken, sizeof(szToken));
\r
217 if (!IsValidInteger(szToken))
\r
218 Quit("Invalid path file, invalid index '%s'", szToken);
\r
219 unsigned n = (unsigned) atoi(szToken);
\r
220 if (n != uEdgeIndex)
\r
221 Quit("Invalid path file, expecting edge %u got %u", uEdgeIndex, n);
\r
224 File.GetTokenX(szToken, sizeof(szToken));
\r
225 if (1 != strlen(szToken))
\r
226 Quit("Invalid path file, expecting state, got '%s'", szToken);
\r
227 const char cType = szToken[0];
\r
228 if ('M' != cType && 'D' != cType && cType != 'I' && 'S' != cType)
\r
229 Quit("Invalid path file, expecting state, got '%c'", cType);
\r
232 File.GetTokenX(szToken, sizeof(szToken));
\r
233 if (!IsValidInteger(szToken))
\r
234 Quit("Invalid path file, bad prefix length A '%s'", szToken);
\r
235 const unsigned uPrefixLengthA = (unsigned) atoi(szToken);
\r
238 File.GetTokenX(szToken, sizeof(szToken));
\r
239 if (!IsValidInteger(szToken))
\r
240 Quit("Invalid path file, bad prefix length B '%s'", szToken);
\r
241 const unsigned uPrefixLengthB = (unsigned) atoi(szToken);
\r
244 Edge.cType = cType;
\r
245 Edge.uPrefixLengthA = uPrefixLengthA;
\r
246 Edge.uPrefixLengthB = uPrefixLengthB;
\r
249 File.GetTokenX(szToken, sizeof(szToken));
\r
250 if (0 != strcmp(szToken, "//"))
\r
251 Quit("Invalid path file (//)");
\r
254 void PWPath::ToFile(TextFile &File) const
\r
256 const unsigned uEdgeCount = GetEdgeCount();
\r
258 File.PutString("Path\n");
\r
259 File.PutFormat("edges %u\n", uEdgeCount);
\r
260 for (unsigned uEdgeIndex = 0; uEdgeIndex < uEdgeCount; ++uEdgeIndex)
\r
262 const PWEdge &Edge = GetEdge(uEdgeIndex);
\r
263 File.PutFormat("%u %c %u %u\n",
\r
266 Edge.uPrefixLengthA,
\r
267 Edge.uPrefixLengthB);
\r
269 File.PutString("//\n");
\r
272 void PWPath::AssertEqual(const PWPath &Path) const
\r
274 const unsigned uEdgeCount = GetEdgeCount();
\r
275 if (uEdgeCount != Path.GetEdgeCount())
\r
277 Log("PWPath::AssertEqual, this=\n");
\r
279 Log("\nOther path=\n");
\r
282 Quit("PWPath::AssertEqual, Edge count different %u %u\n",
\r
283 uEdgeCount, Path.GetEdgeCount());
\r
286 for (unsigned uEdgeIndex = 0; uEdgeIndex < uEdgeCount; ++uEdgeIndex)
\r
288 const PWEdge &e1 = GetEdge(uEdgeIndex);
\r
289 const PWEdge &e2 = Path.GetEdge(uEdgeIndex);
\r
290 if (e1.cType != e2.cType || e1.uPrefixLengthA != e2.uPrefixLengthA ||
\r
291 e1.uPrefixLengthB != e2.uPrefixLengthB)
\r
293 Log("PWPath::AssertEqual, this=\n");
\r
295 Log("\nOther path=\n");
\r
298 Log("This edge %c%u.%u, other edge %c%u.%u\n",
\r
299 e1.cType, e1.uPrefixLengthA, e1.uPrefixLengthB,
\r
300 e2.cType, e2.uPrefixLengthA, e2.uPrefixLengthB);
\r
301 Quit("PWPath::AssertEqual, edge %u different\n", uEdgeIndex);
\r
306 bool PWPath::Equal(const PWPath &Path) const
\r
308 const unsigned uEdgeCount = GetEdgeCount();
\r
309 if (uEdgeCount != Path.GetEdgeCount())
\r
312 for (unsigned uEdgeIndex = 0; uEdgeIndex < uEdgeCount; ++uEdgeIndex)
\r
314 const PWEdge &e1 = GetEdge(uEdgeIndex);
\r
315 const PWEdge &e2 = Path.GetEdge(uEdgeIndex);
\r
316 if (e1.cType != e2.cType || e1.uPrefixLengthA != e2.uPrefixLengthA ||
\r
317 e1.uPrefixLengthB != e2.uPrefixLengthB)
\r
323 unsigned PWPath::GetMatchCount() const
\r
325 unsigned uMatchCount = 0;
\r
326 const unsigned uEdgeCount = GetEdgeCount();
\r
327 for (unsigned uEdgeIndex = 0; uEdgeIndex < uEdgeCount; ++uEdgeIndex)
\r
329 const PWEdge &e = GetEdge(uEdgeIndex);
\r
330 if ('M' == e.cType)
\r
333 return uMatchCount;
\r
336 unsigned PWPath::GetInsertCount() const
\r
338 unsigned uInsertCount = 0;
\r
339 const unsigned uEdgeCount = GetEdgeCount();
\r
340 for (unsigned uEdgeIndex = 0; uEdgeIndex < uEdgeCount; ++uEdgeIndex)
\r
342 const PWEdge &e = GetEdge(uEdgeIndex);
\r
343 if ('I' == e.cType)
\r
346 return uInsertCount;
\r
349 unsigned PWPath::GetDeleteCount() const
\r
351 unsigned uDeleteCount = 0;
\r
352 const unsigned uEdgeCount = GetEdgeCount();
\r
353 for (unsigned uEdgeIndex = 0; uEdgeIndex < uEdgeCount; ++uEdgeIndex)
\r
355 const PWEdge &e = GetEdge(uEdgeIndex);
\r
356 if ('D' == e.cType)
\r
359 return uDeleteCount;
\r
362 void PWPath::FromStr(const char Str[])
\r
365 unsigned uPrefixLengthA = 0;
\r
366 unsigned uPrefixLengthB = 0;
\r
367 while (char c = *Str++)
\r
382 Quit("PWPath::FromStr, invalid state %c", c);
\r
384 AppendEdge(c, uPrefixLengthA, uPrefixLengthB);
\r