C++根据头文件自动生成实现文件框架（支持模版）
以前写了一个，也贴出来了不过对模版支持不好，不带模版的函数和类成员函数还是支持的。
最近写模版类的头文件，而模版类的话如果不想inline在外部实现的化，书写起来格式很麻烦。尤其是如果返回变量的类型是在类内部typedef的类型。
所以对以前的程序修改了以下，还是利用Python正则表示生成对应的实现文件，对于模版类其实也可以生产.cc文件的将函数的实现写在.cc文件中，
如在MeshT.h文件的最后include的实现文件MeshT.cc就可以了（Openmesh就是这么做的,下面有例子），
这样避免代码都写在.h中比较乱，而且头文件太长。
嗯，现在的h2cc.py基本能完成要求，可能有些特殊情况会出问题，待验证，另外代码有多个地方重复的地方待整理。
下一步要做的，
1.进一步测试对各种情况正确无误，包括更复杂的模版测试，
2.当前完全按照格式处理，不考虑语义理解，所以对于SGI STL源代码那样头文件中把函数返回变量单独写一行的无法处理。这个以后有好的办法再处理。
（感觉做编译器的完全能写个.h到.cc的自动转换工具为啥我搜不到呢，还得自己写....肯定不如人家的精确）
3. 当前如果存在生成文件了已经，比如用户开始生成了.cc然后又在.h中增加方法，再次生成.cc的时候我会将新的方法统一写在原来.cc文件的最后，具体合适
的位置用户再改动。 下一步考虑自动将新的方法插入到原来.cc文件的合适位置,不过用户如果改动如函数格式，nameapce名称，新添加namespace等等肯定会带来问题
那个用户自己处理吧(注意这里的.cc文件都是按照h2cc.py生成）
4.像java或者python那样，将所有的代码都写到一起，即不存在头文件的写法，这样代码写起来更方便。对于C++代码可以全部写到.h中。然后调用转换
工具，自动生成.cc文件，将所有没有声明inline的函数并且实现代码长度超过n行的（如10行）自动在.h中转换为声明格式，在.cc中写成实现格式
并把实现代码拷贝过去，
可以用户紧挨函数在上面一行开头加注释如//*标明下面的函数不做转换处理在.h中inline。
个人觉得这样还是能提高写程序的效率的，不知道现在有没有现成的转换工具。
5.要做上面的工作需要对代码修改，当前的代码可扩充性太差....，扩展功能麻烦，首先把各个重复的地方提前出来统一处理。如去掉=的模式。
试图写子函数，但是问题是我需要对每一行代码做太多的情形分析，这样while循环太长了，又不好分子程序，
尤其是 python不支持类似c++的引用，写子函数修改输入变量如输入行号i并在子函数中修改，用Python还得返回i才行，别扭：（
嗯，最后决定暂时就这样了，程序不改了，当前的做法对于{}的处理采用统一忽略的做法包括类似if abc() {}的处理，修改实现其它的功能比较麻烦。。。
//h2cc.py
1 #!/usr/local/bin/python3.1
2 #file h2cc.py
3 #author pku_goldenlock@qq.com
4 #date 2009-10-23 18:19:38.970028
5
6 #.h convert to .cpp framework
7 #注意!!
8 #1. 我们假定你的.h代码书写正确 当前不做异常，错误处理
9 #2. 函数的返回类型如 int 与 与函数名称要写到一行,否则会有问题,因为不太好判断函数名称.
10 #3. 如果已经存在要生成的文件,会只写入你在.h中新加入的函数,
11 # 但是注意原来已经存在的实现文件也应该是用h2cc.py生成的,因为我不是按语意判断,只是按照格式判断
12 # 新写的实现函数框架,会附加到原来的生成文件最后面,需要自己调整到需要的位置,尤其是有namespace的时候
13 # TODO 新写的函数直接放到原来生成文件中适当的位置
14 #4. 在生成的实现文件中,可能会把返回值单独一行,取决于行的长度,过长则分行
15 #5. 如果template模板写成多行,确保最后一行只有一个单独的>
16 # template <
17 # typename T = char,
18 # template<typename> class _Decoder = HuffDecoder<int> #pattern like this might cause error
19 # >
20
21
22 #在某行发现) ; 之后,删除该行;之后的内容,该行开始的空白去掉
23 #改为 \n\{\n\}
24 # virtual = 0 对于纯虚函数也生成实体,如不需要自己去掉. TODO 用户选项
25 #TODO 允许向SGI STL源代码那样,将返回值单独一行,在函数名称上面,不过似乎比较困难,因为当前
26 #我的程序基本按照(){}；template class typdef define // /* */识别这些字符的,仅仅考虑格式
27 #不考虑语意如果返回值
28 #单独一行,如何判断什么样的是返回值类型呢?比较麻烦.比如还要区分仅仅挨着占两行的两个函数声明.
29
30 #最常用的pattern
31 #查找如下 ) ; 或者 ) const ; 但是不包括纯虚函数
32 #()z中如找到 ; //从队尾删除
33 #开始的空白要找到并删除，
34 #pattern = re.compile(r"([\s]*?).*[)](?!\s*=\s*0).*(;.*)\n$")
35
36 #class A : public 读出A未解决 done
37 #template done 支持模板类,模板函数,带有默认参数的模板,模板类中的模板函数,特化和偏特化
38 # TODO 更复杂的情况可能有问题,比如模板类中嵌套模板类
39 #vitrual = 0 done
40 #支持 const done
41 #宏 DFDFDFEE（ABC); done
42 #把注释拷贝 done
43 #已经有.cpp了 仅仅加新的接口的实现 partly done
44 #忽略返回类型，返回类型不能重载
45 #operator done
46
47 import sys,re,getopt
48
49 def usage():
50 """
51 Run the program like this
52
53 ./h2cc.py abc.h ok.cc
54 It will read abc.h and append the fuctions
55 to be implemented to ok.cc
56
57 or
58 ./h2cc.py abc.h #will create abc.cc
59 ./h2cc.py abc.h cpp #will create abc.cpp
60 """
61 pattern_comment = re.compile(r'^\s*//')
62
63 #传入一个打开的文件(我们要生成的或者已经存在要分析处理)的handle，如abc.cc
64 #调用该函数者负责关闭该文件,该函数只负责处理
65 func_list_exist = []
66 def AnalyzeOutputFile(file_handle):
67 print('Analyze output file right now ,the reslt of existing functions is below\n')
68 file_handle.seek(0,0)
69 m = file_handle.readlines()
70 i = 0
71 #---------------------------------------------------逐行处理
72 while (i < len(m)):
73 line = m[i]
74 #---------------------判断是注释则略过 re.search(r'^s*$',line) 空行判断
75 if re.search(r'^s*$',line) or pattern_comment.search(line): #null line or comment using //
76 i += 1
77 continue
78 if re.search('^\s*/[*]', line): #comment using /*
79 while (not re.search('[*]/\s*$',line)): # */
80 i += 1
81 line = m[i]
82 i += 1
83 continue
84 #-------------------------find exists functions
85 find1 = re.search('[(]',line)
86 find2 = re.search('[)]',line)
87 find3 = re.search('template',line)
88 find4 = re.search('::',line)
89 if ((find1 or find3 or find4) and (not find2)):
90 i += 1
91 line += m[i]
92 while (i < len(m) and (not re.search('[)]',line))):
93 i += 1
94 line += m[i]
95 match = re.search('^.*\)',line,re.MULTILINE|re.DOTALL)
96 if match:
97 print(match.group())
98 func_list_exist.append(match.group())
99 i += 1
100 print('Output file analze done!')
101 print('There are already %d functions exit\n'%len(func_list_exist))
102
103 #转化核心函数,当前比较乱,代码重复,一个循环中代码太长了 TODO
104 #基本实现就是按照栈处理名称,区分是否class域的函数,忽略.h中已经实现函数{}内部的内容
105 def h2cc(input_file,output_file):
106 """
107 kernal function given a .h file
108 convert to a .cc one with
109 all the functions properly listed
110 """
111 print('The file you want to deal with is '+input_file + \
112 '\n It is converted to ' + output_file)
113
114 #----核心的函数匹配模式
115 pattern = re.compile(r"""(^[\s]*) #leading withe space,we will find and delete after
116 ([a-zA-Z~_] # void int likely the first caracter v or i
117 .*
118 [)] #we find )
119 #(?!\s*=\s*0) #if we find = 0 which means pur virtual we will not match after
120 #(?=\s*=\s*0)
121 (?!.*{) # we do not want the case int abc() const { return 1;}
122 .*)
123 (;.*) #we want to find ; and after for we will replace these later
124 \n$
125 """,re.VERBOSE | re.MULTILINE | re.DOTALL)
126
127 #----处理virtual,explicit,friend,static
128 pattern2 = re.compile(r'(virtual\s+|explicit\s+|friend\s+|static\s+)')
129
130 #----开头的空白
131 leading_space_pattern = re.compile('(^[\s]*)[a-zA-Z~]')
132
133 #我们默认函数都会有 如 abc( abc ( 这样的模式存在
134 #但是operator 是个例外,类名要加在operaotr前面，而且不存在上面的模式
135 #operator = () ClassName::operator = ()
136 #pattern_func_name = re.compile(r'([a-zA-Z0-9~_\-]+\s*[(]|operator.*[(])')
137 #难道替换不是仅仅替换括号里面的 而是全部替换? 恩，大括号 必须的 然后用\1没有\0
138 pattern_func_name = re.compile(r'([a-zA-Z0-9~_\-]+\s*|operator.*)[(]')
139
140 pattern_template = re.compile('^\s*template')
141 #pattern_template_end = re.compile('^\s*>\s*$') #TODO why wrong?
142 pattern_template_end = re.compile('>\s*$')
143
144 pattern_namespace = re.compile(r'namespace.*{') #判断该行是否是 namespace出现
145 #p2 = re.compile(r'class\s*(.*?)\s*{|struct\s*(.*?)\s*{')
146 #.*? 最小匹配 是否class出现,并记录class 名称
147 pattern_class = re.compile(r'^[\s]*(class|struct)\s+([a-zA-Z0-9_\-]+<?)(?!.*;)')
148 #modify 09.6.6 可以处理classa a 和 { 不在同一行，但是如果class 后发现;不处理
149 #class一定是行开始或者前面可有空白
150
151 pattern_start = re.compile('{')
152 pattern_end = re.compile('}')
153
154 stack = [] #----状态可能是normal_now(位于{}中间的时候),class_now,namespace_now
155 stack_class = [] #----存储class name
156 stack_template = [] #----存储template name
157 stack_typedef = [] #----存储当前class 作用域下的所有typedef得到的名称,函数返回类型需要
158
159 first_convert = True #是否是第一次生成的实现文件
160
161 #--------------------------------------文件处理
162 try: #09.6.6 处理要转换生成的.cc 或 .cpp文件不存在的情况，添加读异常
163 f_out = open(output_file,'r+') #r+ 可读写但要求文件已经存在
164 print(output_file + ' exists already, we will anlyze it to find the existing functions to avoid adding twice')
165 AnalyzeOutputFile(f_out) #对输出文件进行预处理分析
166 first_convert = False
167 except IOError:
168 print(output_file + ' does not exist yet, we will create am empty ' + output_file)
169 f_out = open(output_file,'a') #追加打开，这里因为用了异常先判断了是否文件存在，所以也可以用 w
170 #如果没有前面的判断只能用 a ,w 会自动删除前面已有的内容
171 print('Below functions will be added\n')
172 if first_convert:
173 f_out.write('#include "' + input_file + '"\n\n') #注意 如果out文件已存在 那么经过前面的分析处理 指针已经指向了文件尾部
174
175 func_sum = 0
176 #--------------------------------------------------核心处理循环,逐行处理输入.h文件
177 with open(input_file,'r') as f:
178 m = f.readlines()
179 i = 0
180 while i < len(m):
181 line = m[i]
182 #-------------------------------------------判断是注释则略过 re.search(r'^s*$',line) 空行判断
183 if re.search(r'^s*$',line) or pattern_comment.search(line): #/n or comment using //
184 i += 1
185 continue
186 if re.search('^\s*/[*]', line): #comment using /*
187 while (not re.search('[*]/\s*$',line)): # */
188 i += 1
189 line = m[i]
190 i += 1
191 continue
192 #---------------------------------------------判断是则define略过
193 define_match = re.search(r'^\s*#define',line)
194 if define_match:
195 while re.search(r'^\s*$',line) or re.search(r'\\\s*$', line):
196 i += 1
197 line = m[i]
198 i += 1
199 continue
200 #-----------------------------------------------判断是否namespace
201 match_namespace = pattern_namespace.search(line)
202 if match_namespace: #we face namespace
203 if first_convert:
204 f_out.write(line+'\n')
205 stack.append('namespace_now')
206 i += 1
207 continue
208 #----------------------------------------------------判断并处理类里面的typedef
209 if (len(stack) > 0 and stack[-1] == 'class_now'):
210 pattern_typedef = re.compile(r'typedef\s+.*\s+(.*);')
211 match_typedef = pattern_typedef.search(line)
212 if match_typedef:
213 stack_typedef.append(match_typedef.group(1))
214 #----------------------------------------------------判断并处理模板情况
215 match_template = pattern_template.search(line)
216 template_string = ''
217 if match_template:
218 match_template_end = pattern_template_end.search(line)
219 template_string = line
220 while(not match_template_end):
221 i += 1
222 line = m[i]
223 template_string += line
224 match_template_end = pattern_template_end.search(line)
225 i += 1
226 line = m[i]
227 #--------------------------------------------判断是否是class 或者遇到 { start
228 match_class = pattern_class.search(line)
229 match_start = pattern_start.search(line)
230
231 if match_class: #we face a class
232 stack_template.append(template_string)
233 stack.append('class_now')
234 class_name = match_class.group(2) #TODO f2.group(1)如果为空则异常
235 #-----------模板类特化或者偏特化的情况 如 class A<u,Node<u> > 为了获得整个名称
236 if '<' in class_name:
237 k = line.index('<')
238 fit = 1;
239 for l in range(k+1, len(line)):
240 if line[l] == '<':
241 fit += 1
242 if line[l] == '>':
243 fit -= 1
244 if (fit == 0):
245 break
246 class_name += line[k+1:l+1]
247 stack_class.append(class_name)
248 while not match_start:
249 i += 1
250 line = m[i]
251 match_start = pattern_start.search(line)
252 i += 1
253 continue
254 #-------------------------------------------------判断是否是结束符号 }
255 match_end = pattern_end.search(line)
256 if match_start:
257 stack.append('normal_now')
258 if match_end:
259 top_status = stack.pop()
260 if top_status == 'namespace_now':
261 if first_convert:
262 f_out.write(line+'\n')
263 elif top_status == 'class_now':
264 stack_class.pop()
265 stack_template.pop()
266 stack_typedef = []
267 if match_start or match_end:
268 i += 1
269 continue
270 #注意我判断是函数只是根据 我看到该行有) 然后 后面有; important!!
271 #------------------------------------------------就像忽略注释一样忽略normal_now状态下的行,因为那是在{}中间的实现
272 if len(stack) >0 and stack[-1] == 'normal_now':
273 i += 1
274 continue
275 #---------------------------------------------------------下面我们该处理需要生成实体框架的函数了,
276 #deal with
277 #int abc(int a,
278 # int b) #能够处理这种(与)不在同一行的情况
279 find1 = re.search('[(]',line)
280 if not find1:
281 i += 1
282 continue
283 find2 = re.search('[)]',line)
284 start_i = i
285 if (find1 and (not find2)):
286 #space = leading_space_pattern.search(line).group(1)
287 space_match = leading_space_pattern.search(line)
288 i += 1
289 line2 = m[i]
290 if space_match:
291 line2 = re.sub('^'+space_match.group(1),'',line2)
292 #注意sub会替换所有的匹配，这里我们只让它替换第一个,count=1，或者对于space 前面加^
293 line += line2
294 while (i < len(m) and (not re.search('[)]',line2))):
295 i += 1
296 line2 = m[i]
297 line2 = re.sub('^'+space_match.group(1),'',line2)
298 line += line2
299
300 match_start = pattern_start.search(m[i])
301 match_end = pattern_end.search(m[i])
302 if (match_start): # like ) { or ) {} int the last line
303 if not match_end:
304 stack.append('normal_now')
305 i += 1
306 continue
307
308 #here we do the kernel sub #--------------------------------如果找到,先进行了替换abc();->abc{}
309 (line,match) = pattern.subn(r'\2 \n{\n\n}\n\n',line)
310 if (not match): # like abc() not ; after 就是说{在函数名下面单独一行的情况
311 i += 1
312 continue
313
314 #-------------------------------------------------------------OK,找到了函数,下面进行处理后输出
315 if match:
316 friend_match = re.search('friend ',line)
317 line = pattern2.sub('',line) #--------------------delete virtural explict friend!
318 func_name = ''
319 template_line = ''
320 if len(stack_class) > 0 and not friend_match : #-----类成员函数class status if friend we will not add class name
321 x = ''
322 if (template_string != ''): #-----类中模板函数,多一个模板
323 template_string = re.sub(r'\s*template','template',template_string)
324 #template_string = re.sub(r'\s*=\s*[\'a-zA-Z0-9_\-\.]+', '', template_string)
325 #------------------delete < class T = a, class U = A(3)> -> <class T, class U>
326 template_string = re.sub('\s*=.*>(\s*)$',r'>\1',template_string)
327 template_string = re.sub(r'\s*=.*,',',',template_string)
328 template_string = re.sub(r'\s*=.*','',template_string)
329 if (stack_template[-1] != ''):
330 if not (re.search(r'<\s*>', stack_template[-1])): #----不是全特化!template<>
331 template_line = re.sub(r'^\s*template','template',stack_template[-1])
332 if not (re.search(r'<.*>', stack_class[-1])): #----不是偏特化!,like template<typename T> class A<T,int>
333 #------for x we get like template<class T, typename U> -> <T,U>
334 x = re.sub(r'template\s*<','<',template_line) #remove template -> <class T, typename U>
335 x = re.sub(r'\n','',x) #取消分行,合并成一行
336 #去掉 = 及其后面的东西
337 x = re.sub(r'\s*=.*,', ',', x)
338 x = re.sub(r'\s*=.*\>', '>', x)
339 x = x.rstrip() #remove \n
340 x = re.sub(r'(class|typename)\s+|(<class>|<typename>\s*class)','',x) #去掉class,typename -> <T, U>
341 x = re.sub(r'<\s+','<',x)
342 x = re.sub(r'\s+>','>',x)
343 x = re.sub(r'\s+,', ',',x)
344 x = re.sub(r',\s+', ', ',x)
345 line = re.sub(r'\s*=\s*0','',line) #纯虚函数我们也给函数实现体，这里特别判断一下去掉 = 0
346 line = re.sub(r'\s*=.*,',',', line) #去掉=后面的东西 foo(int a = cd(32));foo(int x =(3), int y= 4);
347 line = re.sub(r'\s*=.*\)',')', line) #先去掉所有的(),最后去掉()),这两个步骤都需要不能颠倒
348 #---------如果函数较长,在void ABC::foo() 断开成两行 void ABC::\n foo()
349 temp_line = pattern_func_name.sub(stack_class[-1] + x + '::' + r'\1(',line)
350 if len(temp_line) > 60:
351 line = pattern_func_name.sub(stack_class[-1] + x + '::\n' + r'\1(',line)
352 else:
353 line = temp_line
354 #----------得到返回变量的类型
355 return_type = re.search('^(\S+)', line).group(1)
356 if (return_type in stack_typedef): #------对于返回值,需要指明是在该类中typedef指定的名称的情况
357 if (x == ''): #----全特化的情况特殊处理
358 line = re.sub('^'+return_type+r'\s+', stack_class[-1]+'::'+return_type+'\\n', line)
359 else:
360 line = re.sub('^'+return_type+r'\s+', 'typename '+stack_class[-1]+'::'+return_type+'\\n', line)
361 #----------add template as the above if there is one
362 #template_line = re.sub(r'\s*=\s*[\'a-zA-Z0-9_\-\.]+', '', template_line)
363 #------------------delete < class T = a, class U = A(3)> -> <class T, class U>
364 template_line = re.sub('\s*=.*>(\s*)$',r'>\1',template_line)
365 template_line = re.sub(r'\s*=.*,',',',template_line)
366 template_line = re.sub(r'\s*=.*','',template_line) #最后,不换行删除后面所有的
367 line = template_line + template_string + line;
368 func_name = re.search('^.*\)',line,re.MULTILINE|re.DOTALL).group()
369 else: #--------------------------------普通函数(非类成员函数)的情况!
370 stack_template.append(template_string)
371 if (stack_template[-1] != ''):
372 template_line = re.sub(r'\s*template','template',stack_template[-1])
373 #template_line = re.sub(r'\s*=\s*[\'a-zA-Z0-9_\-\.]+', '', template_line)
374 #------------------delete < class T = a, class U = A(3)> -> <class T, class U>
375 template_line = re.sub('\s*=.*>(\s*)$',r'>\1',template_line) #代码重复,TODO以后整合
376 template_line = re.sub(r'\s*=.*,',',',template_line)
377 template_line = re.sub(r'\s*=.*','',template_line)
378 line = re.sub(r'\s*=.*,', ',', line)
379 line = re.sub(r'\s*=.*\)', ')', line)
380 line = template_line + line
381 stack_template.pop()
382 func_name = re.search('^.*\)',line,re.MULTILINE|re.DOTALL).group()
383 #-------------------------------------------------------------------------加上上面的注释也拷贝过去
384 comment_line = ''
385 #假定函数的注释在函数声明的紧上面，把他们拷贝过去
386 #TODO 如果是模板函数,模板占多于1行注释没拷贝
387 k = start_i - 1 #one line befor this func start
388 if pattern_template.search(m[k]):
389 k -= 1
390 if re.search('[*]/\s*$',m[k]):
391 comment_line = m[k].lstrip()
392 while not re.search('^\s*/[*]',m[k]):
393 k -= 1
394 comment_line = m[k].lstrip() + comment_line
395 else:
396 for j in range(k,0,-1):
397 c_line = m[j]
398 if pattern_comment.search(c_line):
399 c_line = re.sub('\s*//','//',c_line) #TODO use strtip is ok?
400 comment_line = c_line + comment_line
401 else:
402 break
403 line = comment_line + line #------------------我们最终要输出的东东
404 #----------------------------------------------如果函数已经在实现文件中存在,不输出
405 if not(func_name in func_list_exist):
406 #if not first_convert and func_sum == 0:
407 # f_out.write("//newly added functions, you may need to move them to the right position\n")
408 f_out.write(line)
409 func_sum += 1
410 print(func_name)
411 i += 1 #-----------------------------------------------------------------------next line处理下一行
412 #------------------------------loop done 处理结束
413 print('\nSucessfully converted,please see '+output_file)
414 print('Added %d functions'%func_sum)
415
416
417 #-----------------------------------------------------------user input
418 def main(argv):
419 try:
420 opts, args = getopt.getopt(argv, "h", ["help"])
421 except getopt.GetoptError:
422 print(usage.__doc__)
423 sys.exit(2)
424
425 if len(opts) > 0:
426 for o, a in opts:
427 if o in ("-h", "--help"):
428 print(usage.__doc__)
429 sys.exit()
430 elif len(args) > 0:
431 input_file = args[0]
432 if len(args) == 1 or args[1] == 'cc':
433 output_file = re.sub('.h*$','.cc',input_file) # 默认转的是对应的.cc文件
434 elif (args[1] == 'cpp'):
435 output_file = re.sub('.h*$','.cpp',input_file)
436 else:
437 output_file = args[1]
438
439 h2cc(input_file,output_file)
440 else:
441 print(usage.__doc__)
442 sys.exit()
443
444
445 if __name__ == "__main__":
446 main(sys.argv[1:])
447
3 #author pku_goldenlock@qq.com
4 #date 2009-10-23 18:19:38.970028
5
6 #.h convert to .cpp framework
7 #注意!!
8 #1. 我们假定你的.h代码书写正确 当前不做异常，错误处理
9 #2. 函数的返回类型如 int 与 与函数名称要写到一行,否则会有问题,因为不太好判断函数名称.
10 #3. 如果已经存在要生成的文件,会只写入你在.h中新加入的函数,
11 # 但是注意原来已经存在的实现文件也应该是用h2cc.py生成的,因为我不是按语意判断,只是按照格式判断
12 # 新写的实现函数框架,会附加到原来的生成文件最后面,需要自己调整到需要的位置,尤其是有namespace的时候
13 # TODO 新写的函数直接放到原来生成文件中适当的位置
14 #4. 在生成的实现文件中,可能会把返回值单独一行,取决于行的长度,过长则分行
15 #5. 如果template模板写成多行,确保最后一行只有一个单独的>
16 # template <
17 # typename T = char,
18 # template<typename> class _Decoder = HuffDecoder<int> #pattern like this might cause error
19 # >
20
21
22 #在某行发现) ; 之后,删除该行;之后的内容,该行开始的空白去掉
23 #改为 \n\{\n\}
24 # virtual = 0 对于纯虚函数也生成实体,如不需要自己去掉. TODO 用户选项
25 #TODO 允许向SGI STL源代码那样,将返回值单独一行,在函数名称上面,不过似乎比较困难,因为当前
26 #我的程序基本按照(){}；template class typdef define // /* */识别这些字符的,仅仅考虑格式
27 #不考虑语意如果返回值
28 #单独一行,如何判断什么样的是返回值类型呢?比较麻烦.比如还要区分仅仅挨着占两行的两个函数声明.
29
30 #最常用的pattern
31 #查找如下 ) ; 或者 ) const ; 但是不包括纯虚函数
32 #()z中如找到 ; //从队尾删除
33 #开始的空白要找到并删除，
34 #pattern = re.compile(r"([\s]*?).*[)](?!\s*=\s*0).*(;.*)\n$")
35
36 #class A : public 读出A未解决 done
37 #template done 支持模板类,模板函数,带有默认参数的模板,模板类中的模板函数,特化和偏特化
38 # TODO 更复杂的情况可能有问题,比如模板类中嵌套模板类
39 #vitrual = 0 done
40 #支持 const done
41 #宏 DFDFDFEE（ABC); done
42 #把注释拷贝 done
43 #已经有.cpp了 仅仅加新的接口的实现 partly done
44 #忽略返回类型，返回类型不能重载
45 #operator done
46
47 import sys,re,getopt
48
49 def usage():
50 """
51 Run the program like this
52
53 ./h2cc.py abc.h ok.cc
54 It will read abc.h and append the fuctions
55 to be implemented to ok.cc
56
57 or
58 ./h2cc.py abc.h #will create abc.cc
59 ./h2cc.py abc.h cpp #will create abc.cpp
60 """
61 pattern_comment = re.compile(r'^\s*//')
62
63 #传入一个打开的文件(我们要生成的或者已经存在要分析处理)的handle，如abc.cc
64 #调用该函数者负责关闭该文件,该函数只负责处理
65 func_list_exist = []
66 def AnalyzeOutputFile(file_handle):
67 print('Analyze output file right now ,the reslt of existing functions is below\n')
68 file_handle.seek(0,0)
69 m = file_handle.readlines()
70 i = 0
71 #---------------------------------------------------逐行处理
72 while (i < len(m)):
73 line = m[i]
74 #---------------------判断是注释则略过 re.search(r'^s*$',line) 空行判断
75 if re.search(r'^s*$',line) or pattern_comment.search(line): #null line or comment using //
76 i += 1
77 continue
78 if re.search('^\s*/[*]', line): #comment using /*
79 while (not re.search('[*]/\s*$',line)): # */
80 i += 1
81 line = m[i]
82 i += 1
83 continue
84 #-------------------------find exists functions
85 find1 = re.search('[(]',line)
86 find2 = re.search('[)]',line)
87 find3 = re.search('template',line)
88 find4 = re.search('::',line)
89 if ((find1 or find3 or find4) and (not find2)):
90 i += 1
91 line += m[i]
92 while (i < len(m) and (not re.search('[)]',line))):
93 i += 1
94 line += m[i]
95 match = re.search('^.*\)',line,re.MULTILINE|re.DOTALL)
96 if match:
97 print(match.group())
98 func_list_exist.append(match.group())
99 i += 1
100 print('Output file analze done!')
101 print('There are already %d functions exit\n'%len(func_list_exist))
102
103 #转化核心函数,当前比较乱,代码重复,一个循环中代码太长了 TODO
104 #基本实现就是按照栈处理名称,区分是否class域的函数,忽略.h中已经实现函数{}内部的内容
105 def h2cc(input_file,output_file):
106 """
107 kernal function given a .h file
108 convert to a .cc one with
109 all the functions properly listed
110 """
111 print('The file you want to deal with is '+input_file + \
112 '\n It is converted to ' + output_file)
113
114 #----核心的函数匹配模式
115 pattern = re.compile(r"""(^[\s]*) #leading withe space,we will find and delete after
116 ([a-zA-Z~_] # void int likely the first caracter v or i
117 .*
118 [)] #we find )
119 #(?!\s*=\s*0) #if we find = 0 which means pur virtual we will not match after
120 #(?=\s*=\s*0)
121 (?!.*{) # we do not want the case int abc() const { return 1;}
122 .*)
123 (;.*) #we want to find ; and after for we will replace these later
124 \n$
125 """,re.VERBOSE | re.MULTILINE | re.DOTALL)
126
127 #----处理virtual,explicit,friend,static
128 pattern2 = re.compile(r'(virtual\s+|explicit\s+|friend\s+|static\s+)')
129
130 #----开头的空白
131 leading_space_pattern = re.compile('(^[\s]*)[a-zA-Z~]')
132
133 #我们默认函数都会有 如 abc( abc ( 这样的模式存在
134 #但是operator 是个例外,类名要加在operaotr前面，而且不存在上面的模式
135 #operator = () ClassName::operator = ()
136 #pattern_func_name = re.compile(r'([a-zA-Z0-9~_\-]+\s*[(]|operator.*[(])')
137 #难道替换不是仅仅替换括号里面的 而是全部替换? 恩，大括号 必须的 然后用\1没有\0
138 pattern_func_name = re.compile(r'([a-zA-Z0-9~_\-]+\s*|operator.*)[(]')
139
140 pattern_template = re.compile('^\s*template')
141 #pattern_template_end = re.compile('^\s*>\s*$') #TODO why wrong?
142 pattern_template_end = re.compile('>\s*$')
143
144 pattern_namespace = re.compile(r'namespace.*{') #判断该行是否是 namespace出现
145 #p2 = re.compile(r'class\s*(.*?)\s*{|struct\s*(.*?)\s*{')
146 #.*? 最小匹配 是否class出现,并记录class 名称
147 pattern_class = re.compile(r'^[\s]*(class|struct)\s+([a-zA-Z0-9_\-]+<?)(?!.*;)')
148 #modify 09.6.6 可以处理classa a 和 { 不在同一行，但是如果class 后发现;不处理
149 #class一定是行开始或者前面可有空白
150
151 pattern_start = re.compile('{')
152 pattern_end = re.compile('}')
153
154 stack = [] #----状态可能是normal_now(位于{}中间的时候),class_now,namespace_now
155 stack_class = [] #----存储class name
156 stack_template = [] #----存储template name
157 stack_typedef = [] #----存储当前class 作用域下的所有typedef得到的名称,函数返回类型需要
158
159 first_convert = True #是否是第一次生成的实现文件
160
161 #--------------------------------------文件处理
162 try: #09.6.6 处理要转换生成的.cc 或 .cpp文件不存在的情况，添加读异常
163 f_out = open(output_file,'r+') #r+ 可读写但要求文件已经存在
164 print(output_file + ' exists already, we will anlyze it to find the existing functions to avoid adding twice')
165 AnalyzeOutputFile(f_out) #对输出文件进行预处理分析
166 first_convert = False
167 except IOError:
168 print(output_file + ' does not exist yet, we will create am empty ' + output_file)
169 f_out = open(output_file,'a') #追加打开，这里因为用了异常先判断了是否文件存在，所以也可以用 w
170 #如果没有前面的判断只能用 a ,w 会自动删除前面已有的内容
171 print('Below functions will be added\n')
172 if first_convert:
173 f_out.write('#include "' + input_file + '"\n\n') #注意 如果out文件已存在 那么经过前面的分析处理 指针已经指向了文件尾部
174
175 func_sum = 0
176 #--------------------------------------------------核心处理循环,逐行处理输入.h文件
177 with open(input_file,'r') as f:
178 m = f.readlines()
179 i = 0
180 while i < len(m):
181 line = m[i]
182 #-------------------------------------------判断是注释则略过 re.search(r'^s*$',line) 空行判断
183 if re.search(r'^s*$',line) or pattern_comment.search(line): #/n or comment using //
184 i += 1
185 continue
186 if re.search('^\s*/[*]', line): #comment using /*
187 while (not re.search('[*]/\s*$',line)): # */
188 i += 1
189 line = m[i]
190 i += 1
191 continue
192 #---------------------------------------------判断是则define略过
193 define_match = re.search(r'^\s*#define',line)
194 if define_match:
195 while re.search(r'^\s*$',line) or re.search(r'\\\s*$', line):
196 i += 1
197 line = m[i]
198 i += 1
199 continue
200 #-----------------------------------------------判断是否namespace
201 match_namespace = pattern_namespace.search(line)
202 if match_namespace: #we face namespace
203 if first_convert:
204 f_out.write(line+'\n')
205 stack.append('namespace_now')
206 i += 1
207 continue
208 #----------------------------------------------------判断并处理类里面的typedef
209 if (len(stack) > 0 and stack[-1] == 'class_now'):
210 pattern_typedef = re.compile(r'typedef\s+.*\s+(.*);')
211 match_typedef = pattern_typedef.search(line)
212 if match_typedef:
213 stack_typedef.append(match_typedef.group(1))
214 #----------------------------------------------------判断并处理模板情况
215 match_template = pattern_template.search(line)
216 template_string = ''
217 if match_template:
218 match_template_end = pattern_template_end.search(line)
219 template_string = line
220 while(not match_template_end):
221 i += 1
222 line = m[i]
223 template_string += line
224 match_template_end = pattern_template_end.search(line)
225 i += 1
226 line = m[i]
227 #--------------------------------------------判断是否是class 或者遇到 { start
228 match_class = pattern_class.search(line)
229 match_start = pattern_start.search(line)
230
231 if match_class: #we face a class
232 stack_template.append(template_string)
233 stack.append('class_now')
234 class_name = match_class.group(2) #TODO f2.group(1)如果为空则异常
235 #-----------模板类特化或者偏特化的情况 如 class A<u,Node<u> > 为了获得整个名称
236 if '<' in class_name:
237 k = line.index('<')
238 fit = 1;
239 for l in range(k+1, len(line)):
240 if line[l] == '<':
241 fit += 1
242 if line[l] == '>':
243 fit -= 1
244 if (fit == 0):
245 break
246 class_name += line[k+1:l+1]
247 stack_class.append(class_name)
248 while not match_start:
249 i += 1
250 line = m[i]
251 match_start = pattern_start.search(line)
252 i += 1
253 continue
254 #-------------------------------------------------判断是否是结束符号 }
255 match_end = pattern_end.search(line)
256 if match_start:
257 stack.append('normal_now')
258 if match_end:
259 top_status = stack.pop()
260 if top_status == 'namespace_now':
261 if first_convert:
262 f_out.write(line+'\n')
263 elif top_status == 'class_now':
264 stack_class.pop()
265 stack_template.pop()
266 stack_typedef = []
267 if match_start or match_end:
268 i += 1
269 continue
270 #注意我判断是函数只是根据 我看到该行有) 然后 后面有; important!!
271 #------------------------------------------------就像忽略注释一样忽略normal_now状态下的行,因为那是在{}中间的实现
272 if len(stack) >0 and stack[-1] == 'normal_now':
273 i += 1
274 continue
275 #---------------------------------------------------------下面我们该处理需要生成实体框架的函数了,
276 #deal with
277 #int abc(int a,
278 # int b) #能够处理这种(与)不在同一行的情况
279 find1 = re.search('[(]',line)
280 if not find1:
281 i += 1
282 continue
283 find2 = re.search('[)]',line)
284 start_i = i
285 if (find1 and (not find2)):
286 #space = leading_space_pattern.search(line).group(1)
287 space_match = leading_space_pattern.search(line)
288 i += 1
289 line2 = m[i]
290 if space_match:
291 line2 = re.sub('^'+space_match.group(1),'',line2)
292 #注意sub会替换所有的匹配，这里我们只让它替换第一个,count=1，或者对于space 前面加^
293 line += line2
294 while (i < len(m) and (not re.search('[)]',line2))):
295 i += 1
296 line2 = m[i]
297 line2 = re.sub('^'+space_match.group(1),'',line2)
298 line += line2
299
300 match_start = pattern_start.search(m[i])
301 match_end = pattern_end.search(m[i])
302 if (match_start): # like ) { or ) {} int the last line
303 if not match_end:
304 stack.append('normal_now')
305 i += 1
306 continue
307
308 #here we do the kernel sub #--------------------------------如果找到,先进行了替换abc();->abc{}
309 (line,match) = pattern.subn(r'\2 \n{\n\n}\n\n',line)
310 if (not match): # like abc() not ; after 就是说{在函数名下面单独一行的情况
311 i += 1
312 continue
313
314 #-------------------------------------------------------------OK,找到了函数,下面进行处理后输出
315 if match:
316 friend_match = re.search('friend ',line)
317 line = pattern2.sub('',line) #--------------------delete virtural explict friend!
318 func_name = ''
319 template_line = ''
320 if len(stack_class) > 0 and not friend_match : #-----类成员函数class status if friend we will not add class name
321 x = ''
322 if (template_string != ''): #-----类中模板函数,多一个模板
323 template_string = re.sub(r'\s*template','template',template_string)
324 #template_string = re.sub(r'\s*=\s*[\'a-zA-Z0-9_\-\.]+', '', template_string)
325 #------------------delete < class T = a, class U = A(3)> -> <class T, class U>
326 template_string = re.sub('\s*=.*>(\s*)$',r'>\1',template_string)
327 template_string = re.sub(r'\s*=.*,',',',template_string)
328 template_string = re.sub(r'\s*=.*','',template_string)
329 if (stack_template[-1] != ''):
330 if not (re.search(r'<\s*>', stack_template[-1])): #----不是全特化!template<>
331 template_line = re.sub(r'^\s*template','template',stack_template[-1])
332 if not (re.search(r'<.*>', stack_class[-1])): #----不是偏特化!,like template<typename T> class A<T,int>
333 #------for x we get like template<class T, typename U> -> <T,U>
334 x = re.sub(r'template\s*<','<',template_line) #remove template -> <class T, typename U>
335 x = re.sub(r'\n','',x) #取消分行,合并成一行
336 #去掉 = 及其后面的东西
337 x = re.sub(r'\s*=.*,', ',', x)
338 x = re.sub(r'\s*=.*\>', '>', x)
339 x = x.rstrip() #remove \n
340 x = re.sub(r'(class|typename)\s+|(<class>|<typename>\s*class)','',x) #去掉class,typename -> <T, U>
341 x = re.sub(r'<\s+','<',x)
342 x = re.sub(r'\s+>','>',x)
343 x = re.sub(r'\s+,', ',',x)
344 x = re.sub(r',\s+', ', ',x)
345 line = re.sub(r'\s*=\s*0','',line) #纯虚函数我们也给函数实现体，这里特别判断一下去掉 = 0
346 line = re.sub(r'\s*=.*,',',', line) #去掉=后面的东西 foo(int a = cd(32));foo(int x =(3), int y= 4);
347 line = re.sub(r'\s*=.*\)',')', line) #先去掉所有的(),最后去掉()),这两个步骤都需要不能颠倒
348 #---------如果函数较长,在void ABC::foo() 断开成两行 void ABC::\n foo()
349 temp_line = pattern_func_name.sub(stack_class[-1] + x + '::' + r'\1(',line)
350 if len(temp_line) > 60:
351 line = pattern_func_name.sub(stack_class[-1] + x + '::\n' + r'\1(',line)
352 else:
353 line = temp_line
354 #----------得到返回变量的类型
355 return_type = re.search('^(\S+)', line).group(1)
356 if (return_type in stack_typedef): #------对于返回值,需要指明是在该类中typedef指定的名称的情况
357 if (x == ''): #----全特化的情况特殊处理
358 line = re.sub('^'+return_type+r'\s+', stack_class[-1]+'::'+return_type+'\\n', line)
359 else:
360 line = re.sub('^'+return_type+r'\s+', 'typename '+stack_class[-1]+'::'+return_type+'\\n', line)
361 #----------add template as the above if there is one
362 #template_line = re.sub(r'\s*=\s*[\'a-zA-Z0-9_\-\.]+', '', template_line)
363 #------------------delete < class T = a, class U = A(3)> -> <class T, class U>
364 template_line = re.sub('\s*=.*>(\s*)$',r'>\1',template_line)
365 template_line = re.sub(r'\s*=.*,',',',template_line)
366 template_line = re.sub(r'\s*=.*','',template_line) #最后,不换行删除后面所有的
367 line = template_line + template_string + line;
368 func_name = re.search('^.*\)',line,re.MULTILINE|re.DOTALL).group()
369 else: #--------------------------------普通函数(非类成员函数)的情况!
370 stack_template.append(template_string)
371 if (stack_template[-1] != ''):
372 template_line = re.sub(r'\s*template','template',stack_template[-1])
373 #template_line = re.sub(r'\s*=\s*[\'a-zA-Z0-9_\-\.]+', '', template_line)
374 #------------------delete < class T = a, class U = A(3)> -> <class T, class U>
375 template_line = re.sub('\s*=.*>(\s*)$',r'>\1',template_line) #代码重复,TODO以后整合
376 template_line = re.sub(r'\s*=.*,',',',template_line)
377 template_line = re.sub(r'\s*=.*','',template_line)
378 line = re.sub(r'\s*=.*,', ',', line)
379 line = re.sub(r'\s*=.*\)', ')', line)
380 line = template_line + line
381 stack_template.pop()
382 func_name = re.search('^.*\)',line,re.MULTILINE|re.DOTALL).group()
383 #-------------------------------------------------------------------------加上上面的注释也拷贝过去
384 comment_line = ''
385 #假定函数的注释在函数声明的紧上面，把他们拷贝过去
386 #TODO 如果是模板函数,模板占多于1行注释没拷贝
387 k = start_i - 1 #one line befor this func start
388 if pattern_template.search(m[k]):
389 k -= 1
390 if re.search('[*]/\s*$',m[k]):
391 comment_line = m[k].lstrip()
392 while not re.search('^\s*/[*]',m[k]):
393 k -= 1
394 comment_line = m[k].lstrip() + comment_line
395 else:
396 for j in range(k,0,-1):
397 c_line = m[j]
398 if pattern_comment.search(c_line):
399 c_line = re.sub('\s*//','//',c_line) #TODO use strtip is ok?
400 comment_line = c_line + comment_line
401 else:
402 break
403 line = comment_line + line #------------------我们最终要输出的东东
404 #----------------------------------------------如果函数已经在实现文件中存在,不输出
405 if not(func_name in func_list_exist):
406 #if not first_convert and func_sum == 0:
407 # f_out.write("//newly added functions, you may need to move them to the right position\n")
408 f_out.write(line)
409 func_sum += 1
410 print(func_name)
411 i += 1 #-----------------------------------------------------------------------next line处理下一行
412 #------------------------------loop done 处理结束
413 print('\nSucessfully converted,please see '+output_file)
414 print('Added %d functions'%func_sum)
415
416
417 #-----------------------------------------------------------user input
418 def main(argv):
419 try:
420 opts, args = getopt.getopt(argv, "h", ["help"])
421 except getopt.GetoptError:
422 print(usage.__doc__)
423 sys.exit(2)
424
425 if len(opts) > 0:
426 for o, a in opts:
427 if o in ("-h", "--help"):
428 print(usage.__doc__)
429 sys.exit()
430 elif len(args) > 0:
431 input_file = args[0]
432 if len(args) == 1 or args[1] == 'cc':
433 output_file = re.sub('.h*$','.cc',input_file) # 默认转的是对应的.cc文件
434 elif (args[1] == 'cpp'):
435 output_file = re.sub('.h*$','.cpp',input_file)
436 else:
437 output_file = args[1]
438
439 h2cc(input_file,output_file)
440 else:
441 print(usage.__doc__)
442 sys.exit()
443
444
445 if __name__ == "__main__":
446 main(sys.argv[1:])
447
下面看一下常用的几种函数声明，其对应函数实现的写法，包括模版类函数，模版类中的模版函数等等。
1 /*演示函数定义的格式，主要演示在模版类外面定义成员函数的写法*/
2 #include <iostream>
3 using namespace std;
4
5 int abc(int x = 3, int y = 4);
6
7 template<typename T>
8 struct HuffDecoder {
9
10 };
11 template <
12 typename T = char,
13 template<typename> class _Decoder = HuffDecoder
14 >
15 struct Hand{
16 bool operator > (const Hand<T,_Decoder>& other);
17 static void print();
18 };
19
20 template<typename T, template<typename> class _Decoder>
21 void Hand<T, _Decoder>::print()
22 {
23 cout << "this is hand" << endl;
24 }
25
26 template<typename T = char>
27 class Foo {
28 public:
29 typedef T Node;
30 typedef Hand<T> Handle;
31 typedef int size;
32
33 Handle foo(Node a);
34
35 //Handle foo(Node a) {
36 // cout << "haha" << endl;
37 //}
38
39 //static Handle foo2(Node a = 'a') {
40 // cout << "haha" << endl;
41 //}
42 static Handle foo2(Node a = 'a');
43
44 Hand<T> foo3();
45
46 template <typename U>
47 void swap(U x);
48
49 //template <typename U>
50 //class abc {
51 // public:
52 // static swap()
53 //};
54 };
55
56 template<typename T = char>
57 class Derive : public Foo<T>
58 {
59 public:
60 typedef typename Foo<T>::size size;
61 static void print() {
62 size l = 3333;
63 cout << l << endl;
64 }
65 };
66 template<>
67 class Foo<int>
68 {
69 public:
70 typedef int Node;
71 typedef Hand<int> Handle;
72 Handle foo(Node a);
73 //Handle foo(Node a) {
74 // cout << "int foo" << endl;
75 //}
76
77 };
78
79 template <typename T>
80 class Foo<T*>
81 {
82 public:
83 typedef Hand<int> Handle;
84 typedef int Node;
85 Handle foo(Node a);
86 };
87
88 template <typename T>
89 typename Foo<T*>::Handle Foo<T*>::foo(Node a) {
90 cout << "T * foo" << endl;
91 }
92
93 //template<>
94 //typename Foo<int>::Handle Foo<int>::foo(Node a)
95 //{
96 // cout << "int foo" << endl;
97 //}
98 //
99 Foo<int>::Handle Foo<int>::foo(Node a)
100 {
101 cout << "int foo" << endl;
102 }
103
104 //Hand<int> Foo<int>::foo(Node a)
105 //{
106 // cout << "int foo" << endl;
107 //}
108 //
109 template <typename T>
110 void print(T x);
111
112 template <typename T>
113 void print(T x)
114 {
115 cout << x << endl;
116 }
117
118 template<typename T>
119 template<typename U>
120 void Foo<T>::swap(U x)
121 {
122 cout << "hehe" << endl;
123 }
124
125 template<typename T>
126 typename Foo<T>::Handle Foo<T>::foo(Node a)
127 //Handle Foo<T>::foo(Node a)
128 {
129 size x = 23;
130 cout << x << endl;
131 cout << "haha" << endl;
132 }
133
134 template<typename T>
135 typename Foo<T>::Handle Foo<T>::foo2(Node a)
136 {
137 cout << "haha" << endl;
138 }
139
140 template<typename T>
141 Hand<T> Foo<T>::foo3()
142 {
143 cout << "haha" << endl;
144 }
145
146
147 int main(int argc, char *argv[])
148 {
149
150 Derive<>::print();
151
152 Hand<int> hand;
153 hand.print();
154
155 Foo<>::foo2();
156 Foo<> foo;
157 foo.foo('a');
158
159 foo.foo3();
160
161 foo.swap(3);
162
163 ::print(10);
164
165 Foo<int> fooint;
166 fooint.foo(4);
167
168 Foo<int *> foopint;
169 foopint.foo(4);
170
171 return 0;
172 }
173
3 using namespace std;
4
5 int abc(int x = 3, int y = 4);
6
7 template<typename T>
8 struct HuffDecoder {
9
10 };
11 template <
12 typename T = char,
13 template<typename> class _Decoder = HuffDecoder
14 >
15 struct Hand{
16 bool operator > (const Hand<T,_Decoder>& other);
17 static void print();
18 };
19
20 template<typename T, template<typename> class _Decoder>
21 void Hand<T, _Decoder>::print()
22 {
23 cout << "this is hand" << endl;
24 }
25
26 template<typename T = char>
27 class Foo {
28 public:
29 typedef T Node;
30 typedef Hand<T> Handle;
31 typedef int size;
32
33 Handle foo(Node a);
34
35 //Handle foo(Node a) {
36 // cout << "haha" << endl;
37 //}
38
39 //static Handle foo2(Node a = 'a') {
40 // cout << "haha" << endl;
41 //}
42 static Handle foo2(Node a = 'a');
43
44 Hand<T> foo3();
45
46 template <typename U>
47 void swap(U x);
48
49 //template <typename U>
50 //class abc {
51 // public:
52 // static swap()
53 //};
54 };
55
56 template<typename T = char>
57 class Derive : public Foo<T>
58 {
59 public:
60 typedef typename Foo<T>::size size;
61 static void print() {
62 size l = 3333;
63 cout << l << endl;
64 }
65 };
66 template<>
67 class Foo<int>
68 {
69 public:
70 typedef int Node;
71 typedef Hand<int> Handle;
72 Handle foo(Node a);
73 //Handle foo(Node a) {
74 // cout << "int foo" << endl;
75 //}
76
77 };
78
79 template <typename T>
80 class Foo<T*>
81 {
82 public:
83 typedef Hand<int> Handle;
84 typedef int Node;
85 Handle foo(Node a);
86 };
87
88 template <typename T>
89 typename Foo<T*>::Handle Foo<T*>::foo(Node a) {
90 cout << "T * foo" << endl;
91 }
92
93 //template<>
94 //typename Foo<int>::Handle Foo<int>::foo(Node a)
95 //{
96 // cout << "int foo" << endl;
97 //}
98 //
99 Foo<int>::Handle Foo<int>::foo(Node a)
100 {
101 cout << "int foo" << endl;
102 }
103
104 //Hand<int> Foo<int>::foo(Node a)
105 //{
106 // cout << "int foo" << endl;
107 //}
108 //
109 template <typename T>
110 void print(T x);
111
112 template <typename T>
113 void print(T x)
114 {
115 cout << x << endl;
116 }
117
118 template<typename T>
119 template<typename U>
120 void Foo<T>::swap(U x)
121 {
122 cout << "hehe" << endl;
123 }
124
125 template<typename T>
126 typename Foo<T>::Handle Foo<T>::foo(Node a)
127 //Handle Foo<T>::foo(Node a)
128 {
129 size x = 23;
130 cout << x << endl;
131 cout << "haha" << endl;
132 }
133
134 template<typename T>
135 typename Foo<T>::Handle Foo<T>::foo2(Node a)
136 {
137 cout << "haha" << endl;
138 }
139
140 template<typename T>
141 Hand<T> Foo<T>::foo3()
142 {
143 cout << "haha" << endl;
144 }
145
146
147 int main(int argc, char *argv[])
148 {
149
150 Derive<>::print();
151
152 Hand<int> hand;
153 hand.print();
154
155 Foo<>::foo2();
156 Foo<> foo;
157 foo.foo('a');
158
159 foo.foo3();
160
161 foo.swap(3);
162
163 ::print(10);
164
165 Foo<int> fooint;
166 fooint.foo(4);
167
168 Foo<int *> foopint;
169 foopint.foo(4);
170
171 return 0;
172 }
173
//用h2cc.py脚本生成的实现文件框架
1 #include "test.h"
2
3 int abc(int x, int y)
4 {
5
6 }
7
8 template <
9 typename T,
10 template<typename> class _Decoder
11 >
12 bool Hand<T, _Decoder>::
13 operator > (const Hand<T,_Decoder>& other)
14 {
15
16 }
17
18 template <
19 typename T,
20 template<typename> class _Decoder
21 >
22 void Hand<T, _Decoder>::print()
23 {
24
25 }
26
27 template<typename T>
28 typename Foo::Handle
29 Foo<T>::foo(Node a)
30 {
31
32 }
33
34 //static Handle foo2(Node a = 'a') {
35 // cout << "haha" << endl;
36 //}
37 template<typename T>
38 typename Foo::Handle
39 Foo<T>::foo2(Node a)
40 {
41
42 }
43
44 template<typename T>
45 Hand<T> Foo<T>::foo3()
46 {
47
48 }
49
50 template<typename T>
51 template <typename U>
52 void Foo<T>::swap(U x)
53 {
54
55 }
56
57 Foo<int>::Handle
58 Foo<int>::foo(Node a)
59 {
60
61 }
62
63 template <typename T>
64 Foo<T*>::Handle
65 Foo<T*>::foo(Node a)
66 {
67
68 }
69
70 //Hand<int> Foo<int>::foo(Node a)
71 //{
72 // cout << "int foo" << endl;
73 //}
74 //
75 template <typename T>
76 void print(T x)
77 {
78
79 }
80
3 int abc(int x, int y)
4 {
5
6 }
7
8 template <
9 typename T,
10 template<typename> class _Decoder
11 >
12 bool Hand<T, _Decoder>::
13 operator > (const Hand<T,_Decoder>& other)
14 {
15
16 }
17
18 template <
19 typename T,
20 template<typename> class _Decoder
21 >
22 void Hand<T, _Decoder>::print()
23 {
24
25 }
26
27 template<typename T>
28 typename Foo::Handle
29 Foo<T>::foo(Node a)
30 {
31
32 }
33
34 //static Handle foo2(Node a = 'a') {
35 // cout << "haha" << endl;
36 //}
37 template<typename T>
38 typename Foo::Handle
39 Foo<T>::foo2(Node a)
40 {
41
42 }
43
44 template<typename T>
45 Hand<T> Foo<T>::foo3()
46 {
47
48 }
49
50 template<typename T>
51 template <typename U>
52 void Foo<T>::swap(U x)
53 {
54
55 }
56
57 Foo<int>::Handle
58 Foo<int>::foo(Node a)
59 {
60
61 }
62
63 template <typename T>
64 Foo<T*>::Handle
65 Foo<T*>::foo(Node a)
66 {
67
68 }
69
70 //Hand<int> Foo<int>::foo(Node a)
71 //{
72 // cout << "int foo" << endl;
73 //}
74 //
75 template <typename T>
76 void print(T x)
77 {
78
79 }
80
// openmesh 中的一个头文件PolyMeshT.hh生成实现文件框架的示例
//PolyMeshT.hh
1 /*===========================================================================*\
2 * *
3 * OpenMesh *
4 * Copyright (C) 2001-2009 by Computer Graphics Group, RWTH Aachen *
5 //=============================================================================
6 //
7 // CLASS PolyMeshT
8 //
9 //=============================================================================
10
11
12 #ifndef OPENMESH_POLYMESHT_HH
13 #define OPENMESH_POLYMESHT_HH
14
15
16 //== INCLUDES =================================================================
17
18
19 #include <OpenMesh/Core/System/config.h>
20 #include <OpenMesh/Core/Geometry/MathDefs.hh>
21 #include <OpenMesh/Core/Mesh/PolyConnectivity.hh>
22 #include <vector>
23
24
25 //== NAMESPACES ===============================================================
26
27
28 namespace OpenMesh {
29
30
31 //== CLASS DEFINITION =========================================================
32
33
34 /** \class PolyMeshT PolyMeshT.hh <OpenMesh/Mesh/PolyMeshT.hh>
35
36 Base type for a polygonal mesh.
37
38 This is the base class for a polygonal mesh. It is parameterized
39 by a mesh kernel that is given as a template argument. This class
40 inherits all methods from its mesh kernel.
41
42 \param Kernel: template argument for the mesh kernel
43 \note You should use the predefined mesh-kernel combinations in
44 \ref mesh_types_group
45 \see \ref mesh_type
46 */
47
48 template <class Kernel>
49 class PolyMeshT : public Kernel
50 {
51 public:
52
53 /// Self type. Used to specify iterators/circulators.
54 typedef PolyMeshT<Kernel> This;
55 //--- item types ---
56
57 //@{
58 /// Determine whether this is a PolyMeshT or TriMeshT ( This function does not check the per face vertex count! It only checks if the datatype is PolyMeshT or TriMeshT )
59 enum { IsPolyMesh = 1 };
60 enum { IsTriMesh = 0 };
61 static bool is_polymesh() { return true; }
62 static bool is_trimesh() { return false; }
63 //@}
64
65 /// \name Mesh Items
66 //@{
67 /// Scalar type
68 typedef typename Kernel::Scalar Scalar;
69 /// Coordinate type
70 typedef typename Kernel::Point Point;
71 /// Normal type
72 typedef typename Kernel::Normal Normal;
73 /// Color type
74 typedef typename Kernel::Color Color;
75 /// TexCoord1D type
76 typedef typename Kernel::TexCoord1D TexCoord1D;
77 /// TexCoord2D type
78 typedef typename Kernel::TexCoord2D TexCoord2D;
79 /// TexCoord3D type
80 typedef typename Kernel::TexCoord3D TexCoord3D;
81 /// Vertex type
82 typedef typename Kernel::Vertex Vertex;
83 /// Halfedge type
84 typedef typename Kernel::Halfedge Halfedge;
85 /// Edge type
86 typedef typename Kernel::Edge Edge;
87 /// Face type
88 typedef typename Kernel::Face Face;
89 //@}
90
91 //--- handle types ---
92
93 /// Handle for referencing the corresponding item
94 typedef typename Kernel::VertexHandle VertexHandle;
95 typedef typename Kernel::HalfedgeHandle HalfedgeHandle;
96 typedef typename Kernel::EdgeHandle EdgeHandle;
97 typedef typename Kernel::FaceHandle FaceHandle;
98
99
100
101 typedef typename Kernel::VertexIter VertexIter;
102 typedef typename Kernel::HalfedgeIter HalfedgeIter;
103 typedef typename Kernel::EdgeIter EdgeIter;
104 typedef typename Kernel::FaceIter FaceIter;
105
106 typedef typename Kernel::ConstVertexIter ConstVertexIter;
107 typedef typename Kernel::ConstHalfedgeIter ConstHalfedgeIter;
108 typedef typename Kernel::ConstEdgeIter ConstEdgeIter;
109 typedef typename Kernel::ConstFaceIter ConstFaceIter;
110 //@}
111
112 //--- circulators ---
113
114 /** \name Mesh Circulators
115 Refer to OpenMesh::Mesh::Iterators or \ref mesh_iterators
116 for documentation.
117 */
118 //@{
119 /// Circulator
120 typedef typename Kernel::VertexVertexIter VertexVertexIter;
121 typedef typename Kernel::VertexOHalfedgeIter VertexOHalfedgeIter;
122 typedef typename Kernel::VertexIHalfedgeIter VertexIHalfedgeIter;
123 typedef typename Kernel::VertexEdgeIter VertexEdgeIter;
124 typedef typename Kernel::VertexFaceIter VertexFaceIter;
125 typedef typename Kernel::FaceVertexIter FaceVertexIter;
126 typedef typename Kernel::FaceHalfedgeIter FaceHalfedgeIter;
127 typedef typename Kernel::FaceEdgeIter FaceEdgeIter;
128 typedef typename Kernel::FaceFaceIter FaceFaceIter;
129
130 typedef typename Kernel::ConstVertexVertexIter ConstVertexVertexIter;
131 typedef typename Kernel::ConstVertexOHalfedgeIter ConstVertexOHalfedgeIter;
132 typedef typename Kernel::ConstVertexIHalfedgeIter ConstVertexIHalfedgeIter;
133 typedef typename Kernel::ConstVertexEdgeIter ConstVertexEdgeIter;
134 typedef typename Kernel::ConstVertexFaceIter ConstVertexFaceIter;
135 typedef typename Kernel::ConstFaceVertexIter ConstFaceVertexIter;
136 typedef typename Kernel::ConstFaceHalfedgeIter ConstFaceHalfedgeIter;
137 typedef typename Kernel::ConstFaceEdgeIter ConstFaceEdgeIter;
138 typedef typename Kernel::ConstFaceFaceIter ConstFaceFaceIter;
139 //@}
140
141
142 // --- constructor/destructor
143 PolyMeshT() {}
144 virtual ~PolyMeshT() {}
145
146 /** Uses default copy and assignment operator.
147 Use them to assign two meshes of \b equal type.
148 If the mesh types vary, use PolyMeshT::assign() instead. */
149
150 // --- creation ---
151 inline VertexHandle new_vertex()
152 { return Kernel::new_vertex(); }
153
154 inline VertexHandle new_vertex(const Point& _p)
155 {
156 VertexHandle vh(Kernel::new_vertex());
157 set_point(vh, _p);
158 return vh;
159 }
160
161 inline VertexHandle add_vertex(const Point& _p)
162 { return new_vertex(_p); }
163
164 // --- normal vectors ---
165
166 /** \name Normal vector computation
167 */
168 //@{
169
170 /** Calls update_face_normals() and update_vertex_normals() if
171 these normals (i.e. the properties) exist */
172 void update_normals();
173
174 /// Update normal for face _fh
175 void update_normal(FaceHandle _fh)
176 { set_normal(_fh, calc_face_normal(_fh)); }
177
178 /** Update normal vectors for all faces.
179 \attention Needs the Attributes::Normal attribute for faces. */
180 void update_face_normals();
181
182 /** Calculate normal vector for face _fh. */
183 Normal calc_face_normal(FaceHandle _fh) const;
184
185 /** Calculate normal vector for face (_p0, _p1, _p2). */
186 Normal calc_face_normal(const Point& _p0, const Point& _p1,
187 const Point& _p2) const;
188 // calculates the average of the vertices defining _fh
189 void calc_face_centroid(FaceHandle _fh, Point& _pt) const;
190 /// Update normal for vertex _vh
191 void update_normal(VertexHandle _vh)
192 { set_normal(_vh, calc_vertex_normal(_vh)); }
193
194 /** Update normal vectors for all vertices. \attention Needs the
195 Attributes::Normal attribute for faces and vertices. */
196 void update_vertex_normals();
197
198 /** Calculate normal vector for vertex _vh by averaging normals
199 of adjacent faces. Face normals have to be computed first.
200 \attention Needs the Attributes::Normal attribute for faces. */
201 Normal calc_vertex_normal(VertexHandle _vh) const;
202
203 /** Different methods for calculation of the normal at _vh:
204 - -"-_fast - the default one - the same as calc vertex_normal()
205 - needs the Attributes::Normal attribute for faces
206 - -"-_correct - works properly for non-triangular meshes
207 - does not need any attributes
208 - -"-_loop - calculates loop surface normals
209 - does not need any attributes */
210 void calc_vertex_normal_fast(VertexHandle _vh, Normal& _n) const;
211 void calc_vertex_normal_correct(VertexHandle _vh, Normal& _n) const;
212 void calc_vertex_normal_loop(VertexHandle _vh, Normal& _n) const;
213
214
215 //@}
216
217 // --- Geometry API - still in development ---
218
219 /** Calculates the edge vector as the vector defined by
220 the halfedge with id #0 (see below) */
221 void calc_edge_vector(EdgeHandle _eh, Normal& _edge_vec) const
222 { calc_edge_vector(halfedge_handle(_eh,0), _edge_vec); }
223
224 /** Calculates the edge vector as the difference of the
225 the points defined by to_vertex_handle() and from_vertex_handle() */
226 void calc_edge_vector(HalfedgeHandle _heh, Normal& _edge_vec) const
227 {
228 _edge_vec = point(to_vertex_handle(_heh));
229 _edge_vec -= point(from_vertex_handle(_heh));
230 }
231
232 // Calculates the length of the edge _eh
233 Scalar calc_edge_length(EdgeHandle _eh) const
234 { return calc_edge_length(halfedge_handle(_eh,0)); }
235
236 /** Calculates the length of the edge _heh
237 */
238 Scalar calc_edge_length(HalfedgeHandle _heh) const
239 { return (Scalar)sqrt(calc_edge_sqr_length(_heh)); }
240
241 Scalar calc_edge_sqr_length(EdgeHandle _eh) const
242 { return calc_edge_sqr_length(halfedge_handle(_eh,0)); }
243
244 Scalar calc_edge_sqr_length(HalfedgeHandle _heh) const
245 {
246 Normal edge_vec;
247 calc_edge_vector(_heh, edge_vec);
248 return edge_vec.sqrnorm();
249 }
250
251 /** defines a consistent representation of a sector geometry:
252 the halfedge _in_heh defines the sector orientation
253 the vertex pointed by _in_heh defines the sector center
254 _vec0 and _vec1 are resp. the first and the second vectors defining the sector */
255 void calc_sector_vectors(HalfedgeHandle _in_heh, Normal& _vec0, Normal& _vec1) const
256 {
257 calc_edge_vector(next_halfedge_handle(_in_heh), _vec0);//p2 - p1
258 calc_edge_vector(opposite_halfedge_handle(_in_heh), _vec1);//p0 - p1
259 }
260
261 /** calculates the sector angle.\n
262 * The vertex pointed by _in_heh defines the sector center
263 * The angle will be calculated between the given halfedge and the next halfedge.\n
264 * Seen from the center vertex this will be the next halfedge in clockwise direction.\n
265 NOTE: only boundary concave sectors are treated correctly */
266 Scalar calc_sector_angle(HalfedgeHandle _in_heh) const
267 {
268 Normal v0, v1;
269 calc_sector_vectors(_in_heh, v0, v1);
270 Scalar denom = v0.norm()*v1.norm();
271 if (is_zero(denom))
272 {
273 return 0;
274 }
275 Scalar cos_a = (v0 | v1) / denom;
276 if (is_boundary(_in_heh))
277 {//determine if the boundary sector is concave or convex
278 FaceHandle fh(face_handle(opposite_halfedge_handle(_in_heh)));
279 Normal f_n(calc_face_normal(fh));//this normal is (for convex fh) OK
280 Scalar sign_a = dot(cross(v0, v1), f_n);
281 return angle(cos_a, sign_a);
282 }
283 else
284 {
285 return acos(sane_aarg(cos_a));
286 }
287 }
288
289 // calculate the cos and the sin of angle <(_in_heh,next_halfedge(_in_heh))
290 /*
291 void calc_sector_angle_cos_sin(HalfedgeHandle _in_heh, Scalar& _cos_a, Scalar& _sin_a) const
292 {
293 Normal in_vec, out_vec;
294 calc_edge_vector(_in_heh, in_vec);
295 calc_edge_vector(next_halfedge_handle(_in_heh), out_vec);
296 Scalar denom = in_vec.norm()*out_vec.norm();
297 if (is_zero(denom))
298 {
299 _cos_a = 1;
300 _sin_a = 0;
301 }
302 else
303 {
304 _cos_a = dot(in_vec, out_vec)/denom;
305 _sin_a = cross(in_vec, out_vec).norm()/denom;
306 }
307 }
308 */
309 /** calculates the normal (non-normalized) of the face sector defined by
310 the angle <(_in_heh,next_halfedge(_in_heh)) */
311 void calc_sector_normal(HalfedgeHandle _in_heh, Normal& _sector_normal) const
312 {
313 Normal vec0, vec1;
314 calc_sector_vectors(_in_heh, vec0, vec1);
315 _sector_normal = cross(vec0, vec1);//(p2-p1)^(p0-p1)
316 }
317
318 /** calculates the area of the face sector defined by
319 the angle <(_in_heh,next_halfedge(_in_heh))
320 NOTE: special cases (e.g. concave sectors) are not handled correctly */
321 Scalar calc_sector_area(HalfedgeHandle _in_heh) const
322 {
323 Normal sector_normal;
324 calc_sector_normal(_in_heh, sector_normal);
325 return sector_normal.norm()/2;
326 }
327
328 /** calculates the dihedral angle on the halfedge _heh
329 \attention Needs the Attributes::Normal attribute for faces */
330 Scalar calc_dihedral_angle_fast(HalfedgeHandle _heh) const
331 {
332 CHECK(Kernel::has_face_normals());
333 if (is_boundary(edge_handle(_heh)))
334 {//the dihedral angle at a boundary edge is 0
335 return 0;
336 }
337 const Normal& n0 = normal(face_handle(_heh));
338 const Normal& n1 = normal(face_handle(opposite_halfedge_handle(_heh)));
339 Normal he;
340 calc_edge_vector(_heh, he);
341 Scalar da_cos = dot(n0, n1);
342 //should be normalized, but we need only the sign
343 Scalar da_sin_sign = dot(cross(n0, n1), he);
344 return angle(da_cos, da_sin_sign);
345 }
346
347 /** calculates the dihedral angle on the edge _eh
348 \attention Needs the Attributes::Normal attribute for faces */
349 Scalar calc_dihedral_angle_fast(EdgeHandle _eh) const
350 { return calc_dihedral_angle_fast(halfedge_handle(_eh,0)); }
351
352 // calculates the dihedral angle on the halfedge _heh
353 Scalar calc_dihedral_angle(HalfedgeHandle _heh) const
354 {
355 if (is_boundary(edge_handle(_heh)))
356 {//the dihedral angle at a boundary edge is 0
357 return 0;
358 }
359 Normal n0, n1, he;
360 calc_sector_normal(_heh, n0);
361 calc_sector_normal(opposite_halfedge_handle(_heh), n1);
362 calc_edge_vector(_heh, he);
363 Scalar denom = n0.norm()*n1.norm();
364 if (denom == Scalar(0))
365 {
366 return 0;
367 }
368 Scalar da_cos = dot(n0, n1)/denom;
369 //should be normalized, but we need only the sign
370 Scalar da_sin_sign = dot(cross(n0, n1), he);
371 return angle(da_cos, da_sin_sign);
372 }
373
374 // calculates the dihedral angle on the edge _eh
375 Scalar calc_dihedral_angle(EdgeHandle _eh) const
376 { return calc_dihedral_angle(halfedge_handle(_eh,0)); }
377
378 /** tags an edge as a feature if its dihedral angle is larger than _angle_tresh
379 returns the number of the found feature edges, requires edge_status property*/
380 uint find_feature_edges(Scalar _angle_tresh = OpenMesh::deg_to_rad(44.0));
381 // --- misc ---
382
383 /// Face split (= 1-to-n split)
384 inline void split(FaceHandle _fh, const Point& _p)
385 { Kernel::split(_fh, add_vertex(_p)); }
386
387 inline void split(FaceHandle _fh, VertexHandle _vh)
388 { Kernel::split(_fh, _vh); }
389
390 inline void split(EdgeHandle _eh, const Point& _p)
391 { Kernel::split(_eh, add_vertex(_p)); }
392
393 inline void split(EdgeHandle _eh, VertexHandle _vh)
394 { Kernel::split(_eh, _vh); }
395 };
396
397
398 //=============================================================================
399 } // namespace OpenMesh
400 //=============================================================================
401 #if defined(OM_INCLUDE_TEMPLATES) && !defined(OPENMESH_POLYMESH_C)
402 # define OPENMESH_POLYMESH_TEMPLATES
403 # include "PolyMeshT.cc"
404 #endif
405 //=============================================================================
406 #endif // OPENMESH_POLYMESHT_HH defined
407 //=============================================================================
2 * *
3 * OpenMesh *
4 * Copyright (C) 2001-2009 by Computer Graphics Group, RWTH Aachen *
5 //=============================================================================
6 //
7 // CLASS PolyMeshT
8 //
9 //=============================================================================
10
11
12 #ifndef OPENMESH_POLYMESHT_HH
13 #define OPENMESH_POLYMESHT_HH
14
15
16 //== INCLUDES =================================================================
17
18
19 #include <OpenMesh/Core/System/config.h>
20 #include <OpenMesh/Core/Geometry/MathDefs.hh>
21 #include <OpenMesh/Core/Mesh/PolyConnectivity.hh>
22 #include <vector>
23
24
25 //== NAMESPACES ===============================================================
26
27
28 namespace OpenMesh {
29
30
31 //== CLASS DEFINITION =========================================================
32
33
34 /** \class PolyMeshT PolyMeshT.hh <OpenMesh/Mesh/PolyMeshT.hh>
35
36 Base type for a polygonal mesh.
37
38 This is the base class for a polygonal mesh. It is parameterized
39 by a mesh kernel that is given as a template argument. This class
40 inherits all methods from its mesh kernel.
41
42 \param Kernel: template argument for the mesh kernel
43 \note You should use the predefined mesh-kernel combinations in
44 \ref mesh_types_group
45 \see \ref mesh_type
46 */
47
48 template <class Kernel>
49 class PolyMeshT : public Kernel
50 {
51 public:
52
53 /// Self type. Used to specify iterators/circulators.
54 typedef PolyMeshT<Kernel> This;
55 //--- item types ---
56
57 //@{
58 /// Determine whether this is a PolyMeshT or TriMeshT ( This function does not check the per face vertex count! It only checks if the datatype is PolyMeshT or TriMeshT )
59 enum { IsPolyMesh = 1 };
60 enum { IsTriMesh = 0 };
61 static bool is_polymesh() { return true; }
62 static bool is_trimesh() { return false; }
63 //@}
64
65 /// \name Mesh Items
66 //@{
67 /// Scalar type
68 typedef typename Kernel::Scalar Scalar;
69 /// Coordinate type
70 typedef typename Kernel::Point Point;
71 /// Normal type
72 typedef typename Kernel::Normal Normal;
73 /// Color type
74 typedef typename Kernel::Color Color;
75 /// TexCoord1D type
76 typedef typename Kernel::TexCoord1D TexCoord1D;
77 /// TexCoord2D type
78 typedef typename Kernel::TexCoord2D TexCoord2D;
79 /// TexCoord3D type
80 typedef typename Kernel::TexCoord3D TexCoord3D;
81 /// Vertex type
82 typedef typename Kernel::Vertex Vertex;
83 /// Halfedge type
84 typedef typename Kernel::Halfedge Halfedge;
85 /// Edge type
86 typedef typename Kernel::Edge Edge;
87 /// Face type
88 typedef typename Kernel::Face Face;
89 //@}
90
91 //--- handle types ---
92
93 /// Handle for referencing the corresponding item
94 typedef typename Kernel::VertexHandle VertexHandle;
95 typedef typename Kernel::HalfedgeHandle HalfedgeHandle;
96 typedef typename Kernel::EdgeHandle EdgeHandle;
97 typedef typename Kernel::FaceHandle FaceHandle;
98
99
100
101 typedef typename Kernel::VertexIter VertexIter;
102 typedef typename Kernel::HalfedgeIter HalfedgeIter;
103 typedef typename Kernel::EdgeIter EdgeIter;
104 typedef typename Kernel::FaceIter FaceIter;
105
106 typedef typename Kernel::ConstVertexIter ConstVertexIter;
107 typedef typename Kernel::ConstHalfedgeIter ConstHalfedgeIter;
108 typedef typename Kernel::ConstEdgeIter ConstEdgeIter;
109 typedef typename Kernel::ConstFaceIter ConstFaceIter;
110 //@}
111
112 //--- circulators ---
113
114 /** \name Mesh Circulators
115 Refer to OpenMesh::Mesh::Iterators or \ref mesh_iterators
116 for documentation.
117 */
118 //@{
119 /// Circulator
120 typedef typename Kernel::VertexVertexIter VertexVertexIter;
121 typedef typename Kernel::VertexOHalfedgeIter VertexOHalfedgeIter;
122 typedef typename Kernel::VertexIHalfedgeIter VertexIHalfedgeIter;
123 typedef typename Kernel::VertexEdgeIter VertexEdgeIter;
124 typedef typename Kernel::VertexFaceIter VertexFaceIter;
125 typedef typename Kernel::FaceVertexIter FaceVertexIter;
126 typedef typename Kernel::FaceHalfedgeIter FaceHalfedgeIter;
127 typedef typename Kernel::FaceEdgeIter FaceEdgeIter;
128 typedef typename Kernel::FaceFaceIter FaceFaceIter;
129
130 typedef typename Kernel::ConstVertexVertexIter ConstVertexVertexIter;
131 typedef typename Kernel::ConstVertexOHalfedgeIter ConstVertexOHalfedgeIter;
132 typedef typename Kernel::ConstVertexIHalfedgeIter ConstVertexIHalfedgeIter;
133 typedef typename Kernel::ConstVertexEdgeIter ConstVertexEdgeIter;
134 typedef typename Kernel::ConstVertexFaceIter ConstVertexFaceIter;
135 typedef typename Kernel::ConstFaceVertexIter ConstFaceVertexIter;
136 typedef typename Kernel::ConstFaceHalfedgeIter ConstFaceHalfedgeIter;
137 typedef typename Kernel::ConstFaceEdgeIter ConstFaceEdgeIter;
138 typedef typename Kernel::ConstFaceFaceIter ConstFaceFaceIter;
139 //@}
140
141
142 // --- constructor/destructor
143 PolyMeshT() {}
144 virtual ~PolyMeshT() {}
145
146 /** Uses default copy and assignment operator.
147 Use them to assign two meshes of \b equal type.
148 If the mesh types vary, use PolyMeshT::assign() instead. */
149
150 // --- creation ---
151 inline VertexHandle new_vertex()
152 { return Kernel::new_vertex(); }
153
154 inline VertexHandle new_vertex(const Point& _p)
155 {
156 VertexHandle vh(Kernel::new_vertex());
157 set_point(vh, _p);
158 return vh;
159 }
160
161 inline VertexHandle add_vertex(const Point& _p)
162 { return new_vertex(_p); }
163
164 // --- normal vectors ---
165
166 /** \name Normal vector computation
167 */
168 //@{
169
170 /** Calls update_face_normals() and update_vertex_normals() if
171 these normals (i.e. the properties) exist */
172 void update_normals();
173
174 /// Update normal for face _fh
175 void update_normal(FaceHandle _fh)
176 { set_normal(_fh, calc_face_normal(_fh)); }
177
178 /** Update normal vectors for all faces.
179 \attention Needs the Attributes::Normal attribute for faces. */
180 void update_face_normals();
181
182 /** Calculate normal vector for face _fh. */
183 Normal calc_face_normal(FaceHandle _fh) const;
184
185 /** Calculate normal vector for face (_p0, _p1, _p2). */
186 Normal calc_face_normal(const Point& _p0, const Point& _p1,
187 const Point& _p2) const;
188 // calculates the average of the vertices defining _fh
189 void calc_face_centroid(FaceHandle _fh, Point& _pt) const;
190 /// Update normal for vertex _vh
191 void update_normal(VertexHandle _vh)
192 { set_normal(_vh, calc_vertex_normal(_vh)); }
193
194 /** Update normal vectors for all vertices. \attention Needs the
195 Attributes::Normal attribute for faces and vertices. */
196 void update_vertex_normals();
197
198 /** Calculate normal vector for vertex _vh by averaging normals
199 of adjacent faces. Face normals have to be computed first.
200 \attention Needs the Attributes::Normal attribute for faces. */
201 Normal calc_vertex_normal(VertexHandle _vh) const;
202
203 /** Different methods for calculation of the normal at _vh:
204 - -"-_fast - the default one - the same as calc vertex_normal()
205 - needs the Attributes::Normal attribute for faces
206 - -"-_correct - works properly for non-triangular meshes
207 - does not need any attributes
208 - -"-_loop - calculates loop surface normals
209 - does not need any attributes */
210 void calc_vertex_normal_fast(VertexHandle _vh, Normal& _n) const;
211 void calc_vertex_normal_correct(VertexHandle _vh, Normal& _n) const;
212 void calc_vertex_normal_loop(VertexHandle _vh, Normal& _n) const;
213
214
215 //@}
216
217 // --- Geometry API - still in development ---
218
219 /** Calculates the edge vector as the vector defined by
220 the halfedge with id #0 (see below) */
221 void calc_edge_vector(EdgeHandle _eh, Normal& _edge_vec) const
222 { calc_edge_vector(halfedge_handle(_eh,0), _edge_vec); }
223
224 /** Calculates the edge vector as the difference of the
225 the points defined by to_vertex_handle() and from_vertex_handle() */
226 void calc_edge_vector(HalfedgeHandle _heh, Normal& _edge_vec) const
227 {
228 _edge_vec = point(to_vertex_handle(_heh));
229 _edge_vec -= point(from_vertex_handle(_heh));
230 }
231
232 // Calculates the length of the edge _eh
233 Scalar calc_edge_length(EdgeHandle _eh) const
234 { return calc_edge_length(halfedge_handle(_eh,0)); }
235
236 /** Calculates the length of the edge _heh
237 */
238 Scalar calc_edge_length(HalfedgeHandle _heh) const
239 { return (Scalar)sqrt(calc_edge_sqr_length(_heh)); }
240
241 Scalar calc_edge_sqr_length(EdgeHandle _eh) const
242 { return calc_edge_sqr_length(halfedge_handle(_eh,0)); }
243
244 Scalar calc_edge_sqr_length(HalfedgeHandle _heh) const
245 {
246 Normal edge_vec;
247 calc_edge_vector(_heh, edge_vec);
248 return edge_vec.sqrnorm();
249 }
250
251 /** defines a consistent representation of a sector geometry:
252 the halfedge _in_heh defines the sector orientation
253 the vertex pointed by _in_heh defines the sector center
254 _vec0 and _vec1 are resp. the first and the second vectors defining the sector */
255 void calc_sector_vectors(HalfedgeHandle _in_heh, Normal& _vec0, Normal& _vec1) const
256 {
257 calc_edge_vector(next_halfedge_handle(_in_heh), _vec0);//p2 - p1
258 calc_edge_vector(opposite_halfedge_handle(_in_heh), _vec1);//p0 - p1
259 }
260
261 /** calculates the sector angle.\n
262 * The vertex pointed by _in_heh defines the sector center
263 * The angle will be calculated between the given halfedge and the next halfedge.\n
264 * Seen from the center vertex this will be the next halfedge in clockwise direction.\n
265 NOTE: only boundary concave sectors are treated correctly */
266 Scalar calc_sector_angle(HalfedgeHandle _in_heh) const
267 {
268 Normal v0, v1;
269 calc_sector_vectors(_in_heh, v0, v1);
270 Scalar denom = v0.norm()*v1.norm();
271 if (is_zero(denom))
272 {
273 return 0;
274 }
275 Scalar cos_a = (v0 | v1) / denom;
276 if (is_boundary(_in_heh))
277 {//determine if the boundary sector is concave or convex
278 FaceHandle fh(face_handle(opposite_halfedge_handle(_in_heh)));
279 Normal f_n(calc_face_normal(fh));//this normal is (for convex fh) OK
280 Scalar sign_a = dot(cross(v0, v1), f_n);
281 return angle(cos_a, sign_a);
282 }
283 else
284 {
285 return acos(sane_aarg(cos_a));
286 }
287 }
288
289 // calculate the cos and the sin of angle <(_in_heh,next_halfedge(_in_heh))
290 /*
291 void calc_sector_angle_cos_sin(HalfedgeHandle _in_heh, Scalar& _cos_a, Scalar& _sin_a) const
292 {
293 Normal in_vec, out_vec;
294 calc_edge_vector(_in_heh, in_vec);
295 calc_edge_vector(next_halfedge_handle(_in_heh), out_vec);
296 Scalar denom = in_vec.norm()*out_vec.norm();
297 if (is_zero(denom))
298 {
299 _cos_a = 1;
300 _sin_a = 0;
301 }
302 else
303 {
304 _cos_a = dot(in_vec, out_vec)/denom;
305 _sin_a = cross(in_vec, out_vec).norm()/denom;
306 }
307 }
308 */
309 /** calculates the normal (non-normalized) of the face sector defined by
310 the angle <(_in_heh,next_halfedge(_in_heh)) */
311 void calc_sector_normal(HalfedgeHandle _in_heh, Normal& _sector_normal) const
312 {
313 Normal vec0, vec1;
314 calc_sector_vectors(_in_heh, vec0, vec1);
315 _sector_normal = cross(vec0, vec1);//(p2-p1)^(p0-p1)
316 }
317
318 /** calculates the area of the face sector defined by
319 the angle <(_in_heh,next_halfedge(_in_heh))
320 NOTE: special cases (e.g. concave sectors) are not handled correctly */
321 Scalar calc_sector_area(HalfedgeHandle _in_heh) const
322 {
323 Normal sector_normal;
324 calc_sector_normal(_in_heh, sector_normal);
325 return sector_normal.norm()/2;
326 }
327
328 /** calculates the dihedral angle on the halfedge _heh
329 \attention Needs the Attributes::Normal attribute for faces */
330 Scalar calc_dihedral_angle_fast(HalfedgeHandle _heh) const
331 {
332 CHECK(Kernel::has_face_normals());
333 if (is_boundary(edge_handle(_heh)))
334 {//the dihedral angle at a boundary edge is 0
335 return 0;
336 }
337 const Normal& n0 = normal(face_handle(_heh));
338 const Normal& n1 = normal(face_handle(opposite_halfedge_handle(_heh)));
339 Normal he;
340 calc_edge_vector(_heh, he);
341 Scalar da_cos = dot(n0, n1);
342 //should be normalized, but we need only the sign
343 Scalar da_sin_sign = dot(cross(n0, n1), he);
344 return angle(da_cos, da_sin_sign);
345 }
346
347 /** calculates the dihedral angle on the edge _eh
348 \attention Needs the Attributes::Normal attribute for faces */
349 Scalar calc_dihedral_angle_fast(EdgeHandle _eh) const
350 { return calc_dihedral_angle_fast(halfedge_handle(_eh,0)); }
351
352 // calculates the dihedral angle on the halfedge _heh
353 Scalar calc_dihedral_angle(HalfedgeHandle _heh) const
354 {
355 if (is_boundary(edge_handle(_heh)))
356 {//the dihedral angle at a boundary edge is 0
357 return 0;
358 }
359 Normal n0, n1, he;
360 calc_sector_normal(_heh, n0);
361 calc_sector_normal(opposite_halfedge_handle(_heh), n1);
362 calc_edge_vector(_heh, he);
363 Scalar denom = n0.norm()*n1.norm();
364 if (denom == Scalar(0))
365 {
366 return 0;
367 }
368 Scalar da_cos = dot(n0, n1)/denom;
369 //should be normalized, but we need only the sign
370 Scalar da_sin_sign = dot(cross(n0, n1), he);
371 return angle(da_cos, da_sin_sign);
372 }
373
374 // calculates the dihedral angle on the edge _eh
375 Scalar calc_dihedral_angle(EdgeHandle _eh) const
376 { return calc_dihedral_angle(halfedge_handle(_eh,0)); }
377
378 /** tags an edge as a feature if its dihedral angle is larger than _angle_tresh
379 returns the number of the found feature edges, requires edge_status property*/
380 uint find_feature_edges(Scalar _angle_tresh = OpenMesh::deg_to_rad(44.0));
381 // --- misc ---
382
383 /// Face split (= 1-to-n split)
384 inline void split(FaceHandle _fh, const Point& _p)
385 { Kernel::split(_fh, add_vertex(_p)); }
386
387 inline void split(FaceHandle _fh, VertexHandle _vh)
388 { Kernel::split(_fh, _vh); }
389
390 inline void split(EdgeHandle _eh, const Point& _p)
391 { Kernel::split(_eh, add_vertex(_p)); }
392
393 inline void split(EdgeHandle _eh, VertexHandle _vh)
394 { Kernel::split(_eh, _vh); }
395 };
396
397
398 //=============================================================================
399 } // namespace OpenMesh
400 //=============================================================================
401 #if defined(OM_INCLUDE_TEMPLATES) && !defined(OPENMESH_POLYMESH_C)
402 # define OPENMESH_POLYMESH_TEMPLATES
403 # include "PolyMeshT.cc"
404 #endif
405 //=============================================================================
406 #endif // OPENMESH_POLYMESHT_HH defined
407 //=============================================================================
408
//用h2cc.py生成的实现文件框架PolyMeshT.cpp
//PolyMeshT.cpp #h2cc.py自动生成
1 #include "PolyMeshT.hh"
2
3 namespace OpenMesh {
4
5 /** Calls update_face_normals() and update_vertex_normals() if
6 these normals (i.e. the properties) exist */
7 template <class Kernel>
8 void PolyMeshT<Kernel>::update_normals()
9 {
10
11 }
12
13 /** Update normal vectors for all faces.
14 \attention Needs the Attributes::Normal attribute for faces. */
15 template <class Kernel>
16 void PolyMeshT<Kernel>::update_face_normals()
17 {
18
19 }
20
21 /** Calculate normal vector for face _fh. */
22 template <class Kernel>
23 typename PolyMeshT::Normal
24 PolyMeshT<Kernel>::
25 calc_face_normal(FaceHandle _fh) const
26 {
27
28 }
29
30 /** Calculate normal vector for face (_p0, _p1, _p2). */
31 template <class Kernel>
32 typename PolyMeshT::Normal
33 PolyMeshT<Kernel>::
34 calc_face_normal(const Point& _p0, const Point& _p1,
35 const Point& _p2) const
36 {
37
38 }
39
40 // calculates the average of the vertices defining _fh
41 template <class Kernel>
42 void PolyMeshT<Kernel>::
43 calc_face_centroid(FaceHandle _fh, Point& _pt) const
44 {
45
46 }
47
48 /** Update normal vectors for all vertices. \attention Needs the
49 Attributes::Normal attribute for faces and vertices. */
50 template <class Kernel>
51 void PolyMeshT<Kernel>::update_vertex_normals()
52 {
53
54 }
55
56 /** Calculate normal vector for vertex _vh by averaging normals
57 of adjacent faces. Face normals have to be computed first.
58 \attention Needs the Attributes::Normal attribute for faces. */
59 template <class Kernel>
60 typename PolyMeshT::Normal
61 PolyMeshT<Kernel>::
62 calc_vertex_normal(VertexHandle _vh) const
63 {
64
65 }
66
67 /** Different methods for calculation of the normal at _vh:
68 - -"-_fast - the default one - the same as calc vertex_normal()
69 - needs the Attributes::Normal attribute for faces
70 - -"-_correct - works properly for non-triangular meshes
71 - does not need any attributes
72 - -"-_loop - calculates loop surface normals
73 - does not need any attributes */
74 template <class Kernel>
75 void PolyMeshT<Kernel>::
76 calc_vertex_normal_fast(VertexHandle _vh, Normal& _n) const
77 {
78
79 }
80
81 template <class Kernel>
82 void PolyMeshT<Kernel>::
83 calc_vertex_normal_correct(VertexHandle _vh, Normal& _n) const
84 {
85
86 }
87
88 template <class Kernel>
89 void PolyMeshT<Kernel>::
90 calc_vertex_normal_loop(VertexHandle _vh, Normal& _n) const
91 {
92
93 }
94
95 /** tags an edge as a feature if its dihedral angle is larger than _angle_tresh
96 returns the number of the found feature edges, requires edge_status property*/
97 template <class Kernel>
98 uint PolyMeshT<Kernel>::
99 find_feature_edges(Scalar _angle_tresh)
100 {
101
102 }
103
104 } // namespace OpenMesh
105
3 namespace OpenMesh {
4
5 /** Calls update_face_normals() and update_vertex_normals() if
6 these normals (i.e. the properties) exist */
7 template <class Kernel>
8 void PolyMeshT<Kernel>::update_normals()
9 {
10
11 }
12
13 /** Update normal vectors for all faces.
14 \attention Needs the Attributes::Normal attribute for faces. */
15 template <class Kernel>
16 void PolyMeshT<Kernel>::update_face_normals()
17 {
18
19 }
20
21 /** Calculate normal vector for face _fh. */
22 template <class Kernel>
23 typename PolyMeshT::Normal
24 PolyMeshT<Kernel>::
25 calc_face_normal(FaceHandle _fh) const
26 {
27
28 }
29
30 /** Calculate normal vector for face (_p0, _p1, _p2). */
31 template <class Kernel>
32 typename PolyMeshT::Normal
33 PolyMeshT<Kernel>::
34 calc_face_normal(const Point& _p0, const Point& _p1,
35 const Point& _p2) const
36 {
37
38 }
39
40 // calculates the average of the vertices defining _fh
41 template <class Kernel>
42 void PolyMeshT<Kernel>::
43 calc_face_centroid(FaceHandle _fh, Point& _pt) const
44 {
45
46 }
47
48 /** Update normal vectors for all vertices. \attention Needs the
49 Attributes::Normal attribute for faces and vertices. */
50 template <class Kernel>
51 void PolyMeshT<Kernel>::update_vertex_normals()
52 {
53
54 }
55
56 /** Calculate normal vector for vertex _vh by averaging normals
57 of adjacent faces. Face normals have to be computed first.
58 \attention Needs the Attributes::Normal attribute for faces. */
59 template <class Kernel>
60 typename PolyMeshT::Normal
61 PolyMeshT<Kernel>::
62 calc_vertex_normal(VertexHandle _vh) const
63 {
64
65 }
66
67 /** Different methods for calculation of the normal at _vh:
68 - -"-_fast - the default one - the same as calc vertex_normal()
69 - needs the Attributes::Normal attribute for faces
70 - -"-_correct - works properly for non-triangular meshes
71 - does not need any attributes
72 - -"-_loop - calculates loop surface normals
73 - does not need any attributes */
74 template <class Kernel>
75 void PolyMeshT<Kernel>::
76 calc_vertex_normal_fast(VertexHandle _vh, Normal& _n) const
77 {
78
79 }
80
81 template <class Kernel>
82 void PolyMeshT<Kernel>::
83 calc_vertex_normal_correct(VertexHandle _vh, Normal& _n) const
84 {
85
86 }
87
88 template <class Kernel>
89 void PolyMeshT<Kernel>::
90 calc_vertex_normal_loop(VertexHandle _vh, Normal& _n) const
91 {
92
93 }
94
95 /** tags an edge as a feature if its dihedral angle is larger than _angle_tresh
96 returns the number of the found feature edges, requires edge_status property*/
97 template <class Kernel>
98 uint PolyMeshT<Kernel>::
99 find_feature_edges(Scalar _angle_tresh)
100 {
101
102 }
103
104 } // namespace OpenMesh
105
//Openmesh提供的对应PolyMeshT.hh的实现文件PolyMeshT.cc可以和上面自动生成的框架对比一下：）
1 //=============================================================================
2 //
3 // CLASS PolyMeshT - IMPLEMENTATION
4 //
5 //=============================================================================
6
7
8 #define OPENMESH_POLYMESH_C
9
10
11 //== INCLUDES =================================================================
12
13 #include <OpenMesh/Core/Mesh/PolyMeshT.hh>
14 #include <OpenMesh/Core/Geometry/LoopSchemeMaskT.hh>
15 #include <OpenMesh/Core/Utils/vector_cast.hh>
16 #include <OpenMesh/Core/System/omstream.hh>
17 #include <vector>
18
19
20 //== NAMESPACES ===============================================================
21
22
23 namespace OpenMesh {
24
25 //== IMPLEMENTATION ==========================================================
26
27 template <class Kernel>
28 uint PolyMeshT<Kernel>::find_feature_edges(Scalar _angle_tresh)
29 {
30 assert(Kernel::has_edge_status());//this function needs edge status property
31 uint n_feature_edges = 0;
32 for (EdgeIter e_it = Kernel::edges_begin(); e_it != Kernel::edges_end(); ++e_it)
33 {
34 if (fabs(calc_dihedral_angle(e_it)) > _angle_tresh)
35 {//note: could be optimized by comparing cos(dih_angle) vs. cos(_angle_tresh)
36 status(e_it).set_feature(true);
37 n_feature_edges++;
38 }
39 else
40 {
41 status(e_it).set_feature(false);
42 }
43 }
44 return n_feature_edges;
45 }
46
47 //-----------------------------------------------------------------------------
48
49 template <class Kernel>
50 typename PolyMeshT<Kernel>::Normal
51 PolyMeshT<Kernel>::
52 calc_face_normal(FaceHandle _fh) const
53 {
54 assert(halfedge_handle(_fh).is_valid());
55 ConstFaceVertexIter fv_it(cfv_iter(_fh));
56
57 const Point& p0(point(fv_it)); ++fv_it;
58 const Point& p1(point(fv_it)); ++fv_it;
59 const Point& p2(point(fv_it));
60
61 return calc_face_normal(p0, p1, p2);
62 }
63
64
65 //-----------------------------------------------------------------------------
66
67
68 template <class Kernel>
69 typename PolyMeshT<Kernel>::Normal
70 PolyMeshT<Kernel>::
71 calc_face_normal(const Point& _p0,
72 const Point& _p1,
73 const Point& _p2) const
74 {
75 #if 1
76 // The OpenSG <Vector>::operator -= () does not support the type Point
77 // as rhs. Therefore use vector_cast at this point!!!
78 // Note! OpenSG distinguishes between Normal and Point!!!
79 Normal p1p0(_p0); p1p0 -= vector_cast<Normal>(_p1);
80 Normal p1p2(_p2); p1p2 -= vector_cast<Normal>(_p1);
81
82 Normal n = cross(p1p2, p1p0);
83 Scalar norm = n.length();
84
85 // The expression ((n *= (1.0/norm)),n) is used because the OpenSG
86 // vector class does not return self after component-wise
87 // self-multiplication with a scalar!!!
88 return (norm != Scalar(0)) ? ((n *= (Scalar(1)/norm)),n) : Normal(0,0,0);
89 #else
90 Point p1p0 = _p0; p1p0 -= _p1;
91 Point p1p2 = _p2; p1p2 -= _p1;
92
93 Normal n = vector_cast<Normal>(cross(p1p2, p1p0));
94 Scalar norm = n.length();
95
96 return (norm != 0.0) ? n *= (1.0/norm) : Normal(0,0,0);
97 #endif
98 }
99
100 //-----------------------------------------------------------------------------
101
102 template <class Kernel>
103 void
104 PolyMeshT<Kernel>::
105 calc_face_centroid(FaceHandle _fh, Point& _pt) const
106 {
107 _pt.vectorize(0);
108 uint valence = 0;
109 for (ConstFaceVertexIter cfv_it = cfv_iter(_fh); cfv_it; ++cfv_it, ++valence)
110 {
111 _pt += point(cfv_it);
112 }
113 _pt /= valence;
114 }
115 //-----------------------------------------------------------------------------
116
117
118 template <class Kernel>
119 void
120 PolyMeshT<Kernel>::
121 update_normals()
122 {
123 if (Kernel::has_face_normals()) update_face_normals();
124 if (Kernel::has_vertex_normals()) update_vertex_normals();
125 }
126
127
128 //-----------------------------------------------------------------------------
129
130
131 template <class Kernel>
132 void
133 PolyMeshT<Kernel>::
134 update_face_normals()
135 {
136 FaceIter f_it(Kernel::faces_begin()), f_end(Kernel::faces_end());
137
138 for (; f_it != f_end; ++f_it)
139 set_normal(f_it.handle(), calc_face_normal(f_it.handle()));
140 }
141
142
143 //-----------------------------------------------------------------------------
144
145
146 template <class Kernel>
147 typename PolyMeshT<Kernel>::Normal
148 PolyMeshT<Kernel>::
149 calc_vertex_normal(VertexHandle _vh) const
150 {
151 Normal n;
152 calc_vertex_normal_fast(_vh,n);
153
154 Scalar norm = n.length();
155 if (norm != 0.0) n *= (1.0/norm);
156
157 return n;
158 }
159
160 //-----------------------------------------------------------------------------
161 template <class Kernel>
162 void PolyMeshT<Kernel>::
163 calc_vertex_normal_fast(VertexHandle _vh, Normal& _n) const
164 {
165 _n.vectorize(0.0);
166 for (ConstVertexFaceIter vf_it=cvf_iter(_vh); vf_it; ++vf_it)
167 _n += normal(vf_it.handle());
168 }
169
170 //-----------------------------------------------------------------------------
171 template <class Kernel>
172 void PolyMeshT<Kernel>::
173 calc_vertex_normal_correct(VertexHandle _vh, Normal& _n) const
174 {
175 _n.vectorize(0.0);
176 ConstVertexIHalfedgeIter cvih_it = cvih_iter(_vh);
177 if (!cvih_it)
178 {//don't crash on isolated vertices
179 return;
180 }
181 Normal in_he_vec;
182 calc_edge_vector(cvih_it, in_he_vec);
183 for ( ; cvih_it; ++cvih_it)
184 {//calculates the sector normal defined by cvih_it and adds it to _n
185 if (is_boundary(cvih_it))
186 {
187 continue;
188 }
189 HalfedgeHandle out_heh(next_halfedge_handle(cvih_it));
190 Normal out_he_vec;
191 calc_edge_vector(out_heh, out_he_vec);
192 _n += cross(in_he_vec, out_he_vec);//sector area is taken into account
193 in_he_vec = out_he_vec;
194 in_he_vec *= -1;//change the orientation
195 }
196 }
197
198 //-----------------------------------------------------------------------------
199 template <class Kernel>
200 void PolyMeshT<Kernel>::
201 calc_vertex_normal_loop(VertexHandle _vh, Normal& _n) const
202 {
203 static const LoopSchemeMaskDouble& loop_scheme_mask__ =
204 LoopSchemeMaskDoubleSingleton::Instance();
205
206 Normal t_v(0.0,0.0,0.0), t_w(0.0,0.0,0.0);
207 unsigned int vh_val = valence(_vh);
208 unsigned int i = 0;
209 for (ConstVertexOHalfedgeIter cvoh_it = cvoh_iter(_vh); cvoh_it; ++cvoh_it, ++i)
210 {
211 VertexHandle r1_v(to_vertex_handle(cvoh_it));
212 t_v += (typename Point::value_type)(loop_scheme_mask__.tang0_weight(vh_val, i))*point(r1_v);
213 t_w += (typename Point::value_type)(loop_scheme_mask__.tang1_weight(vh_val, i))*point(r1_v);
214 }
215 _n = cross(t_w, t_v);//hack: should be cross(t_v, t_w), but then the normals are reversed?
216 }
217
218 //-----------------------------------------------------------------------------
219
220
221 template <class Kernel>
222 void
223 PolyMeshT<Kernel>::
224 update_vertex_normals()
225 {
226 VertexIter v_it(Kernel::vertices_begin()), v_end(Kernel::vertices_end());
227
228 for (; v_it!=v_end; ++v_it)
229 set_normal(v_it.handle(), calc_vertex_normal(v_it.handle()));
230 }
231
232 //=============================================================================
233 } // namespace OpenMesh
234 //=============================================================================
235
3 // CLASS PolyMeshT - IMPLEMENTATION
4 //
5 //=============================================================================
6
7
8 #define OPENMESH_POLYMESH_C
9
10
11 //== INCLUDES =================================================================
12
13 #include <OpenMesh/Core/Mesh/PolyMeshT.hh>
14 #include <OpenMesh/Core/Geometry/LoopSchemeMaskT.hh>
15 #include <OpenMesh/Core/Utils/vector_cast.hh>
16 #include <OpenMesh/Core/System/omstream.hh>
17 #include <vector>
18
19
20 //== NAMESPACES ===============================================================
21
22
23 namespace OpenMesh {
24
25 //== IMPLEMENTATION ==========================================================
26
27 template <class Kernel>
28 uint PolyMeshT<Kernel>::find_feature_edges(Scalar _angle_tresh)
29 {
30 assert(Kernel::has_edge_status());//this function needs edge status property
31 uint n_feature_edges = 0;
32 for (EdgeIter e_it = Kernel::edges_begin(); e_it != Kernel::edges_end(); ++e_it)
33 {
34 if (fabs(calc_dihedral_angle(e_it)) > _angle_tresh)
35 {//note: could be optimized by comparing cos(dih_angle) vs. cos(_angle_tresh)
36 status(e_it).set_feature(true);
37 n_feature_edges++;
38 }
39 else
40 {
41 status(e_it).set_feature(false);
42 }
43 }
44 return n_feature_edges;
45 }
46
47 //-----------------------------------------------------------------------------
48
49 template <class Kernel>
50 typename PolyMeshT<Kernel>::Normal
51 PolyMeshT<Kernel>::
52 calc_face_normal(FaceHandle _fh) const
53 {
54 assert(halfedge_handle(_fh).is_valid());
55 ConstFaceVertexIter fv_it(cfv_iter(_fh));
56
57 const Point& p0(point(fv_it)); ++fv_it;
58 const Point& p1(point(fv_it)); ++fv_it;
59 const Point& p2(point(fv_it));
60
61 return calc_face_normal(p0, p1, p2);
62 }
63
64
65 //-----------------------------------------------------------------------------
66
67
68 template <class Kernel>
69 typename PolyMeshT<Kernel>::Normal
70 PolyMeshT<Kernel>::
71 calc_face_normal(const Point& _p0,
72 const Point& _p1,
73 const Point& _p2) const
74 {
75 #if 1
76 // The OpenSG <Vector>::operator -= () does not support the type Point
77 // as rhs. Therefore use vector_cast at this point!!!
78 // Note! OpenSG distinguishes between Normal and Point!!!
79 Normal p1p0(_p0); p1p0 -= vector_cast<Normal>(_p1);
80 Normal p1p2(_p2); p1p2 -= vector_cast<Normal>(_p1);
81
82 Normal n = cross(p1p2, p1p0);
83 Scalar norm = n.length();
84
85 // The expression ((n *= (1.0/norm)),n) is used because the OpenSG
86 // vector class does not return self after component-wise
87 // self-multiplication with a scalar!!!
88 return (norm != Scalar(0)) ? ((n *= (Scalar(1)/norm)),n) : Normal(0,0,0);
89 #else
90 Point p1p0 = _p0; p1p0 -= _p1;
91 Point p1p2 = _p2; p1p2 -= _p1;
92
93 Normal n = vector_cast<Normal>(cross(p1p2, p1p0));
94 Scalar norm = n.length();
95
96 return (norm != 0.0) ? n *= (1.0/norm) : Normal(0,0,0);
97 #endif
98 }
99
100 //-----------------------------------------------------------------------------
101
102 template <class Kernel>
103 void
104 PolyMeshT<Kernel>::
105 calc_face_centroid(FaceHandle _fh, Point& _pt) const
106 {
107 _pt.vectorize(0);
108 uint valence = 0;
109 for (ConstFaceVertexIter cfv_it = cfv_iter(_fh); cfv_it; ++cfv_it, ++valence)
110 {
111 _pt += point(cfv_it);
112 }
113 _pt /= valence;
114 }
115 //-----------------------------------------------------------------------------
116
117
118 template <class Kernel>
119 void
120 PolyMeshT<Kernel>::
121 update_normals()
122 {
123 if (Kernel::has_face_normals()) update_face_normals();
124 if (Kernel::has_vertex_normals()) update_vertex_normals();
125 }
126
127
128 //-----------------------------------------------------------------------------
129
130
131 template <class Kernel>
132 void
133 PolyMeshT<Kernel>::
134 update_face_normals()
135 {
136 FaceIter f_it(Kernel::faces_begin()), f_end(Kernel::faces_end());
137
138 for (; f_it != f_end; ++f_it)
139 set_normal(f_it.handle(), calc_face_normal(f_it.handle()));
140 }
141
142
143 //-----------------------------------------------------------------------------
144
145
146 template <class Kernel>
147 typename PolyMeshT<Kernel>::Normal
148 PolyMeshT<Kernel>::
149 calc_vertex_normal(VertexHandle _vh) const
150 {
151 Normal n;
152 calc_vertex_normal_fast(_vh,n);
153
154 Scalar norm = n.length();
155 if (norm != 0.0) n *= (1.0/norm);
156
157 return n;
158 }
159
160 //-----------------------------------------------------------------------------
161 template <class Kernel>
162 void PolyMeshT<Kernel>::
163 calc_vertex_normal_fast(VertexHandle _vh, Normal& _n) const
164 {
165 _n.vectorize(0.0);
166 for (ConstVertexFaceIter vf_it=cvf_iter(_vh); vf_it; ++vf_it)
167 _n += normal(vf_it.handle());
168 }
169
170 //-----------------------------------------------------------------------------
171 template <class Kernel>
172 void PolyMeshT<Kernel>::
173 calc_vertex_normal_correct(VertexHandle _vh, Normal& _n) const
174 {
175 _n.vectorize(0.0);
176 ConstVertexIHalfedgeIter cvih_it = cvih_iter(_vh);
177 if (!cvih_it)
178 {//don't crash on isolated vertices
179 return;
180 }
181 Normal in_he_vec;
182 calc_edge_vector(cvih_it, in_he_vec);
183 for ( ; cvih_it; ++cvih_it)
184 {//calculates the sector normal defined by cvih_it and adds it to _n
185 if (is_boundary(cvih_it))
186 {
187 continue;
188 }
189 HalfedgeHandle out_heh(next_halfedge_handle(cvih_it));
190 Normal out_he_vec;
191 calc_edge_vector(out_heh, out_he_vec);
192 _n += cross(in_he_vec, out_he_vec);//sector area is taken into account
193 in_he_vec = out_he_vec;
194 in_he_vec *= -1;//change the orientation
195 }
196 }
197
198 //-----------------------------------------------------------------------------
199 template <class Kernel>
200 void PolyMeshT<Kernel>::
201 calc_vertex_normal_loop(VertexHandle _vh, Normal& _n) const
202 {
203 static const LoopSchemeMaskDouble& loop_scheme_mask__ =
204 LoopSchemeMaskDoubleSingleton::Instance();
205
206 Normal t_v(0.0,0.0,0.0), t_w(0.0,0.0,0.0);
207 unsigned int vh_val = valence(_vh);
208 unsigned int i = 0;
209 for (ConstVertexOHalfedgeIter cvoh_it = cvoh_iter(_vh); cvoh_it; ++cvoh_it, ++i)
210 {
211 VertexHandle r1_v(to_vertex_handle(cvoh_it));
212 t_v += (typename Point::value_type)(loop_scheme_mask__.tang0_weight(vh_val, i))*point(r1_v);
213 t_w += (typename Point::value_type)(loop_scheme_mask__.tang1_weight(vh_val, i))*point(r1_v);
214 }
215 _n = cross(t_w, t_v);//hack: should be cross(t_v, t_w), but then the normals are reversed?
216 }
217
218 //-----------------------------------------------------------------------------
219
220
221 template <class Kernel>
222 void
223 PolyMeshT<Kernel>::
224 update_vertex_normals()
225 {
226 VertexIter v_it(Kernel::vertices_begin()), v_end(Kernel::vertices_end());
227
228 for (; v_it!=v_end; ++v_it)
229 set_normal(v_it.handle(), calc_vertex_normal(v_it.handle()));
230 }
231
232 //=============================================================================
233 } // namespace OpenMesh
234 //=============================================================================
235
//看一个非模版类的示例，google test的一个头文件 gtest-filepath.h
1
2 #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
3 #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
4
5 #include <gtest/internal/gtest-string.h>
6
7 namespace testing {
8 namespace internal {
9
10 // FilePath - a class for file and directory pathname manipulation which
11 // handles platform-specific conventions (like the pathname separator).
12 // Used for helper functions for naming files in a directory for xml output.
13 // Except for Set methods, all methods are const or static, which provides an
14 // "immutable value object" -- useful for peace of mind.
15 // A FilePath with a value ending in a path separator ("like/this/") represents
16 // a directory, otherwise it is assumed to represent a file. In either case,
17 // it may or may not represent an actual file or directory in the file system.
18 // Names are NOT checked for syntax correctness -- no checking for illegal
19 // characters, malformed paths, etc.
20
21 class FilePath {
22 public:
23 FilePath() : pathname_("") { }
24 FilePath(const FilePath& rhs) : pathname_(rhs.pathname_) { }
25
26 explicit FilePath(const char* pathname) : pathname_(pathname) {
27 Normalize();
28 }
29
30 explicit FilePath(const String& pathname) : pathname_(pathname) {
31 Normalize();
32 }
33
34 FilePath& operator=(const FilePath& rhs) {
35 Set(rhs);
36 return *this;
37 }
38
39 void Set(const FilePath& rhs) {
40 pathname_ = rhs.pathname_;
41 }
42
43 String ToString() const { return pathname_; }
44 const char* c_str() const { return pathname_.c_str(); }
45
46 // Returns the current working directory, or "" if unsuccessful.
47 static FilePath GetCurrentDir();
48
49 // Given directory = "dir", base_name = "test", number = 0,
50 // extension = "xml", returns "dir/test.xml". If number is greater
51 // than zero (e.g., 12), returns "dir/test_12.xml".
52 // On Windows platform, uses \ as the separator rather than /.
53 static FilePath MakeFileName(const FilePath& directory,
54 const FilePath& base_name,
55 int number,
56 const char* extension);
57
58 // Given directory = "dir", relative_path = "test.xml",
59 // returns "dir/test.xml".
60 // On Windows, uses \ as the separator rather than /.
61 static FilePath ConcatPaths(const FilePath& directory,
62 const FilePath& relative_path);
63
64 // Returns a pathname for a file that does not currently exist. The pathname
65 // will be directory/base_name.extension or
66 // directory/base_name_<number>.extension if directory/base_name.extension
67 // already exists. The number will be incremented until a pathname is found
68 // that does not already exist.
69 // Examples: 'dir/foo_test.xml' or 'dir/foo_test_1.xml'.
70 // There could be a race condition if two or more processes are calling this
71 // function at the same time -- they could both pick the same filename.
72 static FilePath GenerateUniqueFileName(const FilePath& directory,
73 const FilePath& base_name,
74 const char* extension);
75
76 // Returns true iff the path is NULL or "".
77 bool IsEmpty() const { return c_str() == NULL || *c_str() == '\0'; }
78
79 // If input name has a trailing separator character, removes it and returns
80 // the name, otherwise return the name string unmodified.
81 // On Windows platform, uses \ as the separator, other platforms use /.
82 FilePath RemoveTrailingPathSeparator() const;
83
84 // Returns a copy of the FilePath with the directory part removed.
85 // Example: FilePath("path/to/file").RemoveDirectoryName() returns
86 // FilePath("file"). If there is no directory part ("just_a_file"), it returns
87 // the FilePath unmodified. If there is no file part ("just_a_dir/") it
88 // returns an empty FilePath ("").
89 // On Windows platform, '\' is the path separator, otherwise it is '/'.
90 FilePath RemoveDirectoryName() const;
91
92 // RemoveFileName returns the directory path with the filename removed.
93 // Example: FilePath("path/to/file").RemoveFileName() returns "path/to/".
94 // If the FilePath is "a_file" or "/a_file", RemoveFileName returns
95 // FilePath("./") or, on Windows, FilePath(".\\"). If the filepath does
96 // not have a file, like "just/a/dir/", it returns the FilePath unmodified.
97 // On Windows platform, '\' is the path separator, otherwise it is '/'.
98 FilePath RemoveFileName() const;
99
100 // Returns a copy of the FilePath with the case-insensitive extension removed.
101 // Example: FilePath("dir/file.exe").RemoveExtension("EXE") returns
102 // FilePath("dir/file"). If a case-insensitive extension is not
103 // found, returns a copy of the original FilePath.
104 FilePath RemoveExtension(const char* extension) const;
105
106 // Creates directories so that path exists. Returns true if successful or if
107 // the directories already exist; returns false if unable to create
108 // directories for any reason. Will also return false if the FilePath does
109 // not represent a directory (that is, it doesn't end with a path separator).
110 bool CreateDirectoriesRecursively() const;
111
112 // Create the directory so that path exists. Returns true if successful or
113 // if the directory already exists; returns false if unable to create the
114 // directory for any reason, including if the parent directory does not
115 // exist. Not named "CreateDirectory" because that's a macro on Windows.
116 bool CreateFolder() const;
117
118 // Returns true if FilePath describes something in the file-system,
119 // either a file, directory, or whatever, and that something exists.
120 bool FileOrDirectoryExists() const;
121
122 // Returns true if pathname describes a directory in the file-system
123 // that exists.
124 bool DirectoryExists() const;
125
126 // Returns true if FilePath ends with a path separator, which indicates that
127 // it is intended to represent a directory. Returns false otherwise.
128 // This does NOT check that a directory (or file) actually exists.
129 bool IsDirectory() const;
130
131 // Returns true if pathname describes a root directory. (Windows has one
132 // root directory per disk drive.)
133 bool IsRootDirectory() const;
134
135 // Returns true if pathname describes an absolute path.
136 bool IsAbsolutePath() const;
137
138 private:
139 // Replaces multiple consecutive separators with a single separator.
140 // For example, "bar///foo" becomes "bar/foo". Does not eliminate other
141 // redundancies that might be in a pathname involving "." or "..".
142 //
143 // A pathname with multiple consecutive separators may occur either through
144 // user error or as a result of some scripts or APIs that generate a pathname
145 // with a trailing separator. On other platforms the same API or script
146 // may NOT generate a pathname with a trailing "/". Then elsewhere that
147 // pathname may have another "/" and pathname components added to it,
148 // without checking for the separator already being there.
149 // The script language and operating system may allow paths like "foo//bar"
150 // but some of the functions in FilePath will not handle that correctly. In
151 // particular, RemoveTrailingPathSeparator() only removes one separator, and
152 // it is called in CreateDirectoriesRecursively() assuming that it will change
153 // a pathname from directory syntax (trailing separator) to filename syntax.
154
155 void Normalize();
156
157 String pathname_;
158 }; // class FilePath
159
160 } // namespace internal
161 } // namespace testing
162
163 #endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
2 #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
3 #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
4
5 #include <gtest/internal/gtest-string.h>
6
7 namespace testing {
8 namespace internal {
9
10 // FilePath - a class for file and directory pathname manipulation which
11 // handles platform-specific conventions (like the pathname separator).
12 // Used for helper functions for naming files in a directory for xml output.
13 // Except for Set methods, all methods are const or static, which provides an
14 // "immutable value object" -- useful for peace of mind.
15 // A FilePath with a value ending in a path separator ("like/this/") represents
16 // a directory, otherwise it is assumed to represent a file. In either case,
17 // it may or may not represent an actual file or directory in the file system.
18 // Names are NOT checked for syntax correctness -- no checking for illegal
19 // characters, malformed paths, etc.
20
21 class FilePath {
22 public:
23 FilePath() : pathname_("") { }
24 FilePath(const FilePath& rhs) : pathname_(rhs.pathname_) { }
25
26 explicit FilePath(const char* pathname) : pathname_(pathname) {
27 Normalize();
28 }
29
30 explicit FilePath(const String& pathname) : pathname_(pathname) {
31 Normalize();
32 }
33
34 FilePath& operator=(const FilePath& rhs) {
35 Set(rhs);
36 return *this;
37 }
38
39 void Set(const FilePath& rhs) {
40 pathname_ = rhs.pathname_;
41 }
42
43 String ToString() const { return pathname_; }
44 const char* c_str() const { return pathname_.c_str(); }
45
46 // Returns the current working directory, or "" if unsuccessful.
47 static FilePath GetCurrentDir();
48
49 // Given directory = "dir", base_name = "test", number = 0,
50 // extension = "xml", returns "dir/test.xml". If number is greater
51 // than zero (e.g., 12), returns "dir/test_12.xml".
52 // On Windows platform, uses \ as the separator rather than /.
53 static FilePath MakeFileName(const FilePath& directory,
54 const FilePath& base_name,
55 int number,
56 const char* extension);
57
58 // Given directory = "dir", relative_path = "test.xml",
59 // returns "dir/test.xml".
60 // On Windows, uses \ as the separator rather than /.
61 static FilePath ConcatPaths(const FilePath& directory,
62 const FilePath& relative_path);
63
64 // Returns a pathname for a file that does not currently exist. The pathname
65 // will be directory/base_name.extension or
66 // directory/base_name_<number>.extension if directory/base_name.extension
67 // already exists. The number will be incremented until a pathname is found
68 // that does not already exist.
69 // Examples: 'dir/foo_test.xml' or 'dir/foo_test_1.xml'.
70 // There could be a race condition if two or more processes are calling this
71 // function at the same time -- they could both pick the same filename.
72 static FilePath GenerateUniqueFileName(const FilePath& directory,
73 const FilePath& base_name,
74 const char* extension);
75
76 // Returns true iff the path is NULL or "".
77 bool IsEmpty() const { return c_str() == NULL || *c_str() == '\0'; }
78
79 // If input name has a trailing separator character, removes it and returns
80 // the name, otherwise return the name string unmodified.
81 // On Windows platform, uses \ as the separator, other platforms use /.
82 FilePath RemoveTrailingPathSeparator() const;
83
84 // Returns a copy of the FilePath with the directory part removed.
85 // Example: FilePath("path/to/file").RemoveDirectoryName() returns
86 // FilePath("file"). If there is no directory part ("just_a_file"), it returns
87 // the FilePath unmodified. If there is no file part ("just_a_dir/") it
88 // returns an empty FilePath ("").
89 // On Windows platform, '\' is the path separator, otherwise it is '/'.
90 FilePath RemoveDirectoryName() const;
91
92 // RemoveFileName returns the directory path with the filename removed.
93 // Example: FilePath("path/to/file").RemoveFileName() returns "path/to/".
94 // If the FilePath is "a_file" or "/a_file", RemoveFileName returns
95 // FilePath("./") or, on Windows, FilePath(".\\"). If the filepath does
96 // not have a file, like "just/a/dir/", it returns the FilePath unmodified.
97 // On Windows platform, '\' is the path separator, otherwise it is '/'.
98 FilePath RemoveFileName() const;
99
100 // Returns a copy of the FilePath with the case-insensitive extension removed.
101 // Example: FilePath("dir/file.exe").RemoveExtension("EXE") returns
102 // FilePath("dir/file"). If a case-insensitive extension is not
103 // found, returns a copy of the original FilePath.
104 FilePath RemoveExtension(const char* extension) const;
105
106 // Creates directories so that path exists. Returns true if successful or if
107 // the directories already exist; returns false if unable to create
108 // directories for any reason. Will also return false if the FilePath does
109 // not represent a directory (that is, it doesn't end with a path separator).
110 bool CreateDirectoriesRecursively() const;
111
112 // Create the directory so that path exists. Returns true if successful or
113 // if the directory already exists; returns false if unable to create the
114 // directory for any reason, including if the parent directory does not
115 // exist. Not named "CreateDirectory" because that's a macro on Windows.
116 bool CreateFolder() const;
117
118 // Returns true if FilePath describes something in the file-system,
119 // either a file, directory, or whatever, and that something exists.
120 bool FileOrDirectoryExists() const;
121
122 // Returns true if pathname describes a directory in the file-system
123 // that exists.
124 bool DirectoryExists() const;
125
126 // Returns true if FilePath ends with a path separator, which indicates that
127 // it is intended to represent a directory. Returns false otherwise.
128 // This does NOT check that a directory (or file) actually exists.
129 bool IsDirectory() const;
130
131 // Returns true if pathname describes a root directory. (Windows has one
132 // root directory per disk drive.)
133 bool IsRootDirectory() const;
134
135 // Returns true if pathname describes an absolute path.
136 bool IsAbsolutePath() const;
137
138 private:
139 // Replaces multiple consecutive separators with a single separator.
140 // For example, "bar///foo" becomes "bar/foo". Does not eliminate other
141 // redundancies that might be in a pathname involving "." or "..".
142 //
143 // A pathname with multiple consecutive separators may occur either through
144 // user error or as a result of some scripts or APIs that generate a pathname
145 // with a trailing separator. On other platforms the same API or script
146 // may NOT generate a pathname with a trailing "/". Then elsewhere that
147 // pathname may have another "/" and pathname components added to it,
148 // without checking for the separator already being there.
149 // The script language and operating system may allow paths like "foo//bar"
150 // but some of the functions in FilePath will not handle that correctly. In
151 // particular, RemoveTrailingPathSeparator() only removes one separator, and
152 // it is called in CreateDirectoriesRecursively() assuming that it will change
153 // a pathname from directory syntax (trailing separator) to filename syntax.
154
155 void Normalize();
156
157 String pathname_;
158 }; // class FilePath
159
160 } // namespace internal
161 } // namespace testing
162
163 #endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
164
//由h2cc.py生成的 gtest-filepath.cc实现框架
1 #include "gtest-filepath.h"
2
3 namespace testing {
4
5 namespace internal {
6
7 // Returns the current working directory, or "" if unsuccessful.
8 FilePath FilePath::GetCurrentDir()
9 {
10
11 }
12
13 // Given directory = "dir", base_name = "test", number = 0,
14 // extension = "xml", returns "dir/test.xml". If number is greater
15 // than zero (e.g., 12), returns "dir/test_12.xml".
16 // On Windows platform, uses \ as the separator rather than /.
17 FilePath FilePath::
18 MakeFileName(const FilePath& directory,
19 const FilePath& base_name,
20 int number,
21 const char* extension)
22 {
23
24 }
25
26 // Given directory = "dir", relative_path = "test.xml",
27 // returns "dir/test.xml".
28 // On Windows, uses \ as the separator rather than /.
29 FilePath FilePath::
30 ConcatPaths(const FilePath& directory,
31 const FilePath& relative_path)
32 {
33
34 }
35
36 // Returns a pathname for a file that does not currently exist. The pathname
37 // will be directory/base_name.extension or
38 // directory/base_name_<number>.extension if directory/base_name.extension
39 // already exists. The number will be incremented until a pathname is found
40 // that does not already exist.
41 // Examples: 'dir/foo_test.xml' or 'dir/foo_test_1.xml'.
42 // There could be a race condition if two or more processes are calling this
43 // function at the same time -- they could both pick the same filename.
44 FilePath FilePath::
45 GenerateUniqueFileName(const FilePath& directory,
46 const FilePath& base_name,
47 const char* extension)
48 {
49
50 }
51
52 // If input name has a trailing separator character, removes it and returns
53 // the name, otherwise return the name string unmodified.
54 // On Windows platform, uses \ as the separator, other platforms use /.
55 FilePath FilePath::
56 RemoveTrailingPathSeparator() const
57 {
58
59 }
60
61 // Returns a copy of the FilePath with the directory part removed.
62 // Example: FilePath("path/to/file").RemoveDirectoryName() returns
63 // FilePath("file"). If there is no directory part ("just_a_file"), it returns
64 // the FilePath unmodified. If there is no file part ("just_a_dir/") it
65 // returns an empty FilePath ("").
66 // On Windows platform, '\' is the path separator, otherwise it is '/'.
67 FilePath FilePath::RemoveDirectoryName() const
68 {
69
70 }
71
72 // RemoveFileName returns the directory path with the filename removed.
73 // Example: FilePath("path/to/file").RemoveFileName() returns "path/to/".
74 // If the FilePath is "a_file" or "/a_file", RemoveFileName returns
75 // FilePath("./") or, on Windows, FilePath(".\\"). If the filepath does
76 // not have a file, like "just/a/dir/", it returns the FilePath unmodified.
77 // On Windows platform, '\' is the path separator, otherwise it is '/'.
78 FilePath FilePath::RemoveFileName() const
79 {
80
81 }
82
83 // Returns a copy of the FilePath with the case-insensitive extension removed.
84 // Example: FilePath("dir/file.exe").RemoveExtension("EXE") returns
85 // FilePath("dir/file"). If a case-insensitive extension is not
86 // found, returns a copy of the original FilePath.
87 FilePath FilePath::
88 RemoveExtension(const char* extension) const
89 {
90
91 }
92
93 // Creates directories so that path exists. Returns true if successful or if
94 // the directories already exist; returns false if unable to create
95 // directories for any reason. Will also return false if the FilePath does
96 // not represent a directory (that is, it doesn't end with a path separator).
97 bool FilePath::CreateDirectoriesRecursively() const
98 {
99
100 }
101
102 // Create the directory so that path exists. Returns true if successful or
103 // if the directory already exists; returns false if unable to create the
104 // directory for any reason, including if the parent directory does not
105 // exist. Not named "CreateDirectory" because that's a macro on Windows.
106 bool FilePath::CreateFolder() const
107 {
108
109 }
110
111 // Returns true if FilePath describes something in the file-system,
112 // either a file, directory, or whatever, and that something exists.
113 bool FilePath::FileOrDirectoryExists() const
114 {
115
116 }
117
118 // Returns true if pathname describes a directory in the file-system
119 // that exists.
120 bool FilePath::DirectoryExists() const
121 {
122
123 }
124
125 // Returns true if FilePath ends with a path separator, which indicates that
126 // it is intended to represent a directory. Returns false otherwise.
127 // This does NOT check that a directory (or file) actually exists.
128 bool FilePath::IsDirectory() const
129 {
130
131 }
132
133 // Returns true if pathname describes a root directory. (Windows has one
134 // root directory per disk drive.)
135 bool FilePath::IsRootDirectory() const
136 {
137
138 }
139
140 // Returns true if pathname describes an absolute path.
141 bool FilePath::IsAbsolutePath() const
142 {
143
144 }
145
146 void FilePath::Normalize()
147 {
148
149 }
150
151 } // namespace internal
152
153 } // namespace testing
154
3 namespace testing {
4
5 namespace internal {
6
7 // Returns the current working directory, or "" if unsuccessful.
8 FilePath FilePath::GetCurrentDir()
9 {
10
11 }
12
13 // Given directory = "dir", base_name = "test", number = 0,
14 // extension = "xml", returns "dir/test.xml". If number is greater
15 // than zero (e.g., 12), returns "dir/test_12.xml".
16 // On Windows platform, uses \ as the separator rather than /.
17 FilePath FilePath::
18 MakeFileName(const FilePath& directory,
19 const FilePath& base_name,
20 int number,
21 const char* extension)
22 {
23
24 }
25
26 // Given directory = "dir", relative_path = "test.xml",
27 // returns "dir/test.xml".
28 // On Windows, uses \ as the separator rather than /.
29 FilePath FilePath::
30 ConcatPaths(const FilePath& directory,
31 const FilePath& relative_path)
32 {
33
34 }
35
36 // Returns a pathname for a file that does not currently exist. The pathname
37 // will be directory/base_name.extension or
38 // directory/base_name_<number>.extension if directory/base_name.extension
39 // already exists. The number will be incremented until a pathname is found
40 // that does not already exist.
41 // Examples: 'dir/foo_test.xml' or 'dir/foo_test_1.xml'.
42 // There could be a race condition if two or more processes are calling this
43 // function at the same time -- they could both pick the same filename.
44 FilePath FilePath::
45 GenerateUniqueFileName(const FilePath& directory,
46 const FilePath& base_name,
47 const char* extension)
48 {
49
50 }
51
52 // If input name has a trailing separator character, removes it and returns
53 // the name, otherwise return the name string unmodified.
54 // On Windows platform, uses \ as the separator, other platforms use /.
55 FilePath FilePath::
56 RemoveTrailingPathSeparator() const
57 {
58
59 }
60
61 // Returns a copy of the FilePath with the directory part removed.
62 // Example: FilePath("path/to/file").RemoveDirectoryName() returns
63 // FilePath("file"). If there is no directory part ("just_a_file"), it returns
64 // the FilePath unmodified. If there is no file part ("just_a_dir/") it
65 // returns an empty FilePath ("").
66 // On Windows platform, '\' is the path separator, otherwise it is '/'.
67 FilePath FilePath::RemoveDirectoryName() const
68 {
69
70 }
71
72 // RemoveFileName returns the directory path with the filename removed.
73 // Example: FilePath("path/to/file").RemoveFileName() returns "path/to/".
74 // If the FilePath is "a_file" or "/a_file", RemoveFileName returns
75 // FilePath("./") or, on Windows, FilePath(".\\"). If the filepath does
76 // not have a file, like "just/a/dir/", it returns the FilePath unmodified.
77 // On Windows platform, '\' is the path separator, otherwise it is '/'.
78 FilePath FilePath::RemoveFileName() const
79 {
80
81 }
82
83 // Returns a copy of the FilePath with the case-insensitive extension removed.
84 // Example: FilePath("dir/file.exe").RemoveExtension("EXE") returns
85 // FilePath("dir/file"). If a case-insensitive extension is not
86 // found, returns a copy of the original FilePath.
87 FilePath FilePath::
88 RemoveExtension(const char* extension) const
89 {
90
91 }
92
93 // Creates directories so that path exists. Returns true if successful or if
94 // the directories already exist; returns false if unable to create
95 // directories for any reason. Will also return false if the FilePath does
96 // not represent a directory (that is, it doesn't end with a path separator).
97 bool FilePath::CreateDirectoriesRecursively() const
98 {
99
100 }
101
102 // Create the directory so that path exists. Returns true if successful or
103 // if the directory already exists; returns false if unable to create the
104 // directory for any reason, including if the parent directory does not
105 // exist. Not named "CreateDirectory" because that's a macro on Windows.
106 bool FilePath::CreateFolder() const
107 {
108
109 }
110
111 // Returns true if FilePath describes something in the file-system,
112 // either a file, directory, or whatever, and that something exists.
113 bool FilePath::FileOrDirectoryExists() const
114 {
115
116 }
117
118 // Returns true if pathname describes a directory in the file-system
119 // that exists.
120 bool FilePath::DirectoryExists() const
121 {
122
123 }
124
125 // Returns true if FilePath ends with a path separator, which indicates that
126 // it is intended to represent a directory. Returns false otherwise.
127 // This does NOT check that a directory (or file) actually exists.
128 bool FilePath::IsDirectory() const
129 {
130
131 }
132
133 // Returns true if pathname describes a root directory. (Windows has one
134 // root directory per disk drive.)
135 bool FilePath::IsRootDirectory() const
136 {
137
138 }
139
140 // Returns true if pathname describes an absolute path.
141 bool FilePath::IsAbsolutePath() const
142 {
143
144 }
145
146 void FilePath::Normalize()
147 {
148
149 }
150
151 } // namespace internal
152
153 } // namespace testing
154
