1. seqbias
  2. src
  3. yaml-cpp
  4. regeximpl.h
Browse code

A complete refactor/rewrite of the original seqbias code. This should behave more or less identically, but is much more coherent.

git-svn-id: file:///home/git/hedgehog.fhcrc.org/bioconductor/trunk/madman/Rpacks/seqbias@57223 bc3139a8-67e5-0310-9ffc-ced21a209358

Daniel Jones authored on 04/08/2011 07:36:48
Showing1 changed files
src/yaml-cpp/regeximpl.h
History View file @23b1bf8
... ... 
@@ -1,8 +1,10 @@
1 
-#pragma once
2 
-
3 1 
 #ifndef REGEXIMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
4 2 
 #define REGEXIMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
5 3
4 
+#if !defined(__GNUC__) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4) // GCC supports "pragma once" correctly since 3.4
5 
+#pragma once
6 
+#endif
7 
+
6 8
7 9 
 #include "stream.h"
8 10 
 #include "stringsource.h"
... ... 
@@ -58,7 +60,13 @@ namespace YAML
58 60 
 	template<>
59 61 
 	inline bool RegEx::IsValidSource<StringCharSource>(const StringCharSource&source) const
60 62 
 	{
61 
-		return source || m_op == REGEX_EMPTY;
63 
+		switch(m_op) {
64 
+			case REGEX_MATCH:
65 
+			case REGEX_RANGE:
66 
+				return source;
67 
+			default:
68 
+				return true;
69 
+		}
62 70 
 	}
63 71
64 72 
 	template <typename Source>
Browse code

Added the seqbias package to the repository.

git-svn-id: file:///home/git/hedgehog.fhcrc.org/bioconductor/trunk/madman/Rpacks/seqbias@52013 bc3139a8-67e5-0310-9ffc-ced21a209358

Chao-Jen Wong authored on 22/01/2011 00:26:36
Showing1 changed files
src/yaml-cpp/regeximpl.h
History View file @d958d35
1 1 
new file mode 100644
... ... 
@@ -0,0 +1,178 @@
1 
+#pragma once
2 
+
3 
+#ifndef REGEXIMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
4 
+#define REGEXIMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
5 
+
6 
+
7 
+#include "stream.h"
8 
+#include "stringsource.h"
9 
+#include "streamcharsource.h"
10 
+
11 
+namespace YAML
12 
+{
13 
+	// query matches
14 
+	inline bool RegEx::Matches(char ch) const {
15 
+		std::string str;
16 
+		str += ch;
17 
+		return Matches(str);
18 
+	}
19 
+
20 
+	inline bool RegEx::Matches(const std::string& str) const {
21 
+		return Match(str) >= 0;
22 
+	}
23 
+
24 
+	inline bool RegEx::Matches(const Stream& in) const {
25 
+		return Match(in) >= 0;
26 
+	}
27 
+
28 
+	template <typename Source>
29 
+	inline bool RegEx::Matches(const Source& source) const {
30 
+		return Match(source) >= 0;
31 
+	}
32 
+
33 
+	// Match
34 
+	// . Matches the given string against this regular expression.
35 
+	// . Returns the number of characters matched.
36 
+	// . Returns -1 if no characters were matched (the reason for
37 
+	//   not returning zero is that we may have an empty regex
38 
+	//   which is ALWAYS successful at matching zero characters).
39 
+	// . REMEMBER that we only match from the start of the buffer!
40 
+	inline int RegEx::Match(const std::string& str) const
41 
+	{
42 
+		StringCharSource source(str.c_str(), str.size());
43 
+		return Match(source);
44 
+	}
45 
+
46 
+	inline int RegEx::Match(const Stream& in) const
47 
+	{
48 
+		StreamCharSource source(in);
49 
+		return Match(source);
50 
+	}
51 
+
52 
+	template <typename Source>
53 
+	inline bool RegEx::IsValidSource(const Source& source) const
54 
+	{
55 
+		return source;
56 
+	}
57 
+
58 
+	template<>
59 
+	inline bool RegEx::IsValidSource<StringCharSource>(const StringCharSource&source) const
60 
+	{
61 
+		return source || m_op == REGEX_EMPTY;
62 
+	}
63 
+
64 
+	template <typename Source>
65 
+	inline int RegEx::Match(const Source& source) const
66 
+	{
67 
+		return IsValidSource(source) ? MatchUnchecked(source) : -1;
68 
+	}
69 
+
70 
+	template <typename Source>
71 
+	inline int RegEx::MatchUnchecked(const Source& source) const
72 
+	{
73 
+		switch(m_op) {
74 
+			case REGEX_EMPTY:
75 
+				return MatchOpEmpty(source);
76 
+			case REGEX_MATCH:
77 
+				return MatchOpMatch(source);
78 
+			case REGEX_RANGE:
79 
+				return MatchOpRange(source);
80 
+			case REGEX_OR:
81 
+				return MatchOpOr(source);
82 
+			case REGEX_AND:
83 
+				return MatchOpAnd(source);
84 
+			case REGEX_NOT:
85 
+				return MatchOpNot(source);
86 
+			case REGEX_SEQ:
87 
+				return MatchOpSeq(source);
88 
+		}
89 
+
90 
+		return -1;
91 
+	}
92 
+
93 
+	//////////////////////////////////////////////////////////////////////////////
94 
+	// Operators
95 
+	// Note: the convention MatchOp*<Source> is that we can assume IsSourceValid(source).
96 
+	//       So we do all our checks *before* we call these functions
97 
+
98 
+	// EmptyOperator
99 
+	template <typename Source>
100 
+	inline int RegEx::MatchOpEmpty(const Source& source) const {
101 
+		return source[0] == Stream::eof() ? 0 : -1;
102 
+	}
103 
+
104 
+	template <>
105 
+	inline int RegEx::MatchOpEmpty<StringCharSource>(const StringCharSource& source) const {
106 
+		return !source ? 0 : -1;  // the empty regex only is successful on the empty string
107 
+	}
108 
+
109 
+	// MatchOperator
110 
+	template <typename Source>
111 
+	inline int RegEx::MatchOpMatch(const Source& source) const {
112 
+		if(source[0] != m_a)
113 
+			return -1;
114 
+		return 1;
115 
+	}
116 
+
117 
+	// RangeOperator
118 
+	template <typename Source>
119 
+	inline int RegEx::MatchOpRange(const Source& source) const {
120 
+		if(m_a > source[0] || m_z < source[0])
121 
+			return -1;
122 
+		return 1;
123 
+	}
124 
+
125 
+	// OrOperator
126 
+	template <typename Source>
127 
+	inline int RegEx::MatchOpOr(const Source& source) const {
128 
+		for(std::size_t i=0;i<m_params.size();i++) {
129 
+			int n = m_params[i].MatchUnchecked(source);
130 
+			if(n >= 0)
131 
+				return n;
132 
+		}
133 
+		return -1;
134 
+	}
135 
+
136 
+	// AndOperator
137 
+	// Note: 'AND' is a little funny, since we may be required to match things
138 
+	//       of different lengths. If we find a match, we return the length of
139 
+	//       the FIRST entry on the list.
140 
+	template <typename Source>
141 
+	inline int RegEx::MatchOpAnd(const Source& source) const {
142 
+		int first = -1;
143 
+		for(std::size_t i=0;i<m_params.size();i++) {
144 
+			int n = m_params[i].MatchUnchecked(source);
145 
+			if(n == -1)
146 
+				return -1;
147 
+			if(i == 0)
148 
+				first = n;
149 
+		}
150 
+		return first;
151 
+	}
152 
+
153 
+	// NotOperator
154 
+	template <typename Source>
155 
+	inline int RegEx::MatchOpNot(const Source& source) const {
156 
+		if(m_params.empty())
157 
+			return -1;
158 
+		if(m_params[0].MatchUnchecked(source) >= 0)
159 
+			return -1;
160 
+		return 1;
161 
+	}
162 
+
163 
+	// SeqOperator
164 
+	template <typename Source>
165 
+	inline int RegEx::MatchOpSeq(const Source& source) const {
166 
+		int offset = 0;
167 
+		for(std::size_t i=0;i<m_params.size();i++) {
168 
+			int n = m_params[i].Match(source + offset); // note Match, not MatchUnchecked because we need to check validity after the offset
169 
+			if(n == -1)
170 
+				return -1;
171 
+			offset += n;
172 
+		}
173 
+
174 
+		return offset;
175 
+	}
176 
+}
177 
+
178 
+#endif // REGEXIMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66