KJB
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
HeadEnglish.h
Go to the documentation of this file.
1 #ifndef HEAD_ENGLISH_H_
2 #define HEAD_ENGLISH_H_
3 
11 #include <list>
12 #include <string>
13 
14 #include "spear/RCIPtr.h"
15 #include "spear/Assert.h"
16 #include "spear/Wide.h"
17 
18 #warning "[Code police] Do not put 'using namespace' in global scope of header."
19 using namespace std;
20 
21 #define TCI typename std::list< spear::RCIPtr<T> >::const_iterator
22 #define TCRI typename std::list< spear::RCIPtr<T> >::const_reverse_iterator
23 
24 namespace spear {
25 
26  template <typename T>
27  spear::RCIPtr<T>
28  traverseRightToLeft(const std::list< spear::RCIPtr<T> > & children,
29  const Char * labels [],
30  bool traverseLabelsFirst = true)
31  {
32  if(traverseLabelsFirst == true){
33  //
34  // Traverse labels than children
35  //
36  for(int i = 0; labels[i] != NULL; i ++){
37  for(TCRI it = (TCRI) children.rbegin();
38  it != (TCRI) children.rend(); it ++){
39  if((* it)->getLabel() == labels[i]){
40  return (* it);
41  }
42  }
43  }
44  } else{
45  //
46  // Traverse children than labels
47  //
48  for(TCRI it = (TCRI) children.rbegin();
49  it != (TCRI) children.rend(); it ++){
50  for(int i = 0; labels[i] != NULL; i ++){
51  if((* it)->getLabel() == labels[i]){
52  return (* it);
53  }
54  }
55  }
56  }
57 
58  return spear::RCIPtr<T>();
59  }
60 
61  template <typename T>
62  spear::RCIPtr<T>
63  traverseLeftToRight(const std::list< spear::RCIPtr<T> > & children,
64  const Char * labels [],
65  bool traverseLabelsFirst = true)
66  {
67  if(traverseLabelsFirst == true){
68  //
69  // Traverse labels than children
70  //
71  for(int i = 0; labels[i] != NULL; i ++){
72  for(TCI it = (TCI) children.begin();
73  it != (TCI) children.end(); it ++){
74  if((* it)->getLabel() == labels[i]){
75  return (* it);
76  }
77  }
78  }
79  } else{
80  //
81  // Traverse children than labels
82  //
83  for(TCI it = (TCI) children.begin();
84  it != (TCI) children.end(); it ++){
85  for(int i = 0; labels[i] != NULL; i ++){
86  if((* it)->getLabel() == labels[i]){
87  return (* it);
88  }
89  }
90  }
91  }
92 
93  return spear::RCIPtr<T>();
94  }
95 
96  template <typename T>
97  spear::RCIPtr<T>
98  findHeadEnglishNP(const String & parent,
99  const std::list< spear::RCIPtr<T> > & children)
100  {
101  static const Char * row1 [] =
102  { W("NN"), W("NNP"), W("NNPS"), W("NNS"), W("NX"), W("POS"), W("JJR"), NULL };
103  static const Char * row2 [] =
104  { W("NP"), W("NPB"), NULL };
105  static const Char * row3 [] =
106  { W("$"), W("ADJP"), W("PRN"), NULL };
107  static const Char * row4 [] =
108  { W("CD"), NULL };
109  static const Char * row5 [] =
110  { W("JJ"), W("JJS"), W("RB"), W("QP"), NULL };
111 
112  spear::RCIPtr<T> head;
113 
114  if((head = traverseRightToLeft<T>(children, row1, false)) !=
115  (const T *) NULL)
116  return head;
117 
118  if((head = traverseLeftToRight<T>(children, row2, false)) !=
119  (const T *) NULL)
120  return head;
121 
122  if((head = traverseRightToLeft<T>(children, row3, false)) !=
123  (const T *) NULL)
124  return head;
125 
126  if((head = traverseRightToLeft<T>(children, row4, false)) !=
127  (const T *) NULL)
128  return head;
129 
130  if((head = traverseRightToLeft<T>(children, row5, false)) !=
131  (const T *) NULL)
132  return head;
133 
134  return children.back();
135  }
136 
137  template <typename T>
138  spear::RCIPtr<T>
139  findHeadEnglishADJP(const String & parent,
140  const std::list< spear::RCIPtr<T> > & children)
141  {
142  static const Char * row1 [] = {
143  W("NNS"), W("QP"), W("NN"), W("$"), W("ADVP"), W("VBN"), W("JJ"), W("PRT"),
144  W("ADVP|PRT"), W("VBG"), W("ADJP"), W("JJR"), W("NP"), W("NPB"), W("JJS"), W("DT"),
145  W("FW"), W("RBR"), W("RBS"), W("SBAR"), W("RB"), W("IN"), W("VBD"), NULL
146  };
147 
148  spear::RCIPtr<T> head;
149 
150  if((head = traverseLeftToRight<T>(children, row1)) !=
151  (const T *) NULL)
152  return head;
153 
154  return children.front();
155  }
156 
157  template <typename T>
158  spear::RCIPtr<T>
159  findHeadEnglishADVP(const String & parent,
160  const std::list< spear::RCIPtr<T> > & children)
161  {
162  static const Char * row1 [] = {
163  W("RB"), W("RBR"), W("RBS"), W("FW"), W("ADVP"), W("PRT"), W("ADVP|PRT"), W("TO"),
164  W("CD"), W("JJR"), W("JJ"), W("IN"), W("NP"), W("NPB"), W("JJS"), W("NN"), W("PP"), NULL
165  };
166 
167  spear::RCIPtr<T> head;
168 
169  if((head = traverseRightToLeft<T>(children, row1)) !=
170  (const T *) NULL)
171  return head;
172 
173  return children.front();
174  }
175 
176  template <typename T>
177  spear::RCIPtr<T>
178  findHeadEnglishCONJP(const String & parent,
179  const std::list< spear::RCIPtr<T> > & children)
180  {
181  static const Char * row1 [] = { W("CC"), W("RB"), W("IN"), NULL };
182 
183  spear::RCIPtr<T> head;
184 
185  if((head = traverseRightToLeft<T>(children, row1)) !=
186  (const T *) NULL)
187  return head;
188 
189  return children.front();
190  }
191 
192  template <typename T>
193  spear::RCIPtr<T>
194  findHeadEnglishFRAG(const String & parent,
195  const std::list< spear::RCIPtr<T> > & children)
196  {
197  return children.back();
198  }
199 
200  template <typename T>
201  spear::RCIPtr<T>
202  findHeadEnglishINTJ(const String & parent,
203  const std::list< spear::RCIPtr<T> > & children)
204  {
205  return children.front();
206  }
207 
208  template <typename T>
209  spear::RCIPtr<T>
210  findHeadEnglishLST(const String & parent,
211  const std::list< spear::RCIPtr<T> > & children)
212  {
213  static const Char * row1 [] = { W("LS"), W(":"), W(","), NULL };
214 
215  spear::RCIPtr<T> head;
216 
217  if((head = traverseRightToLeft<T>(children, row1)) !=
218  (const T *) NULL)
219  return head;
220 
221  return children.front();
222  }
223 
224  template <typename T>
225  spear::RCIPtr<T>
226  findHeadEnglishNAC(const String & parent,
227  const std::list< spear::RCIPtr<T> > & children)
228  {
229  static const Char * row1 [] = {
230  W("NN"), W("NNS"), W("NNP"), W("NNPS"), W("NP"), W("NPB"), W("NAC"), W("EX"), W("$"),
231  W("CD"), W("QP"), W("PRP"), W("VBG"), W("JJ"), W("JJS"), W("JJR"), W("ADJP"), W("FW"),
232  NULL
233  };
234 
235  spear::RCIPtr<T> head;
236 
237  if((head = traverseLeftToRight<T>(children, row1)) !=
238  (const T *) NULL)
239  return head;
240 
241  return children.front();
242  }
243 
244  template <typename T>
245  spear::RCIPtr<T>
246  findHeadEnglishPP(const String & parent,
247  const std::list< spear::RCIPtr<T> > & children)
248  {
249  static const Char * row1 [] =
250  { W("IN"), W("TO"), W("VBG"), W("VBN"), W("RP"), W("FW"), W("PP"), W("ADJP"), NULL };
251 
252  spear::RCIPtr<T> head;
253 
254  if((head = traverseRightToLeft<T>(children, row1)) !=
255  (const T *) NULL)
256  return head;
257 
258  return children.back();
259  }
260 
261  template <typename T>
262  spear::RCIPtr<T>
263  findHeadEnglishPRN(const String & parent,
264  const std::list< spear::RCIPtr<T> > & children)
265  {
266  return children.front();
267  }
268 
269  template <typename T>
270  spear::RCIPtr<T>
271  findHeadEnglishQP(const String & parent,
272  const std::list< spear::RCIPtr<T> > & children)
273  {
274  static const Char * row1 [] = {
275  W("$"), W("IN"), W("NNS"), W("NN"), W("JJ"), W("RB"), W("DT"), W("CD"), W("QP"), W("JJR"),
276  W("JJS"), NULL
277  };
278 
279  spear::RCIPtr<T> head;
280 
281  if((head = traverseLeftToRight<T>(children, row1)) !=
282  (const T *) NULL)
283  return head;
284 
285  return children.front();
286  }
287 
288  template <typename T>
289  spear::RCIPtr<T>
290  findHeadEnglishRRC(const String & parent,
291  const std::list< spear::RCIPtr<T> > & children)
292  {
293  static const Char * row1 [] = {
294  W("VP"), W("NP"), W("NPB"), W("ADVP"), W("PRT"), W("ADVP|PRT"), W("ADJP"), W("PP"),
295  NULL
296  };
297 
298  spear::RCIPtr<T> head;
299 
300  if((head = traverseRightToLeft<T>(children, row1)) !=
301  (const T *) NULL)
302  return head;
303 
304  return children.front();
305  }
306 
307  template <typename T>
308  spear::RCIPtr<T>
309  findHeadEnglishS(const String & parent,
310  const std::list< spear::RCIPtr<T> > & children)
311  {
312  static const Char * row1 [] = {
313  W("TO"), W("IN"), W("VP"), W("S"), W("SBAR"), W("ADJP"), W("UCP"), W("NP"), W("NPB"),
314  NULL
315  };
316 
317  spear::RCIPtr<T> head;
318 
319  if((head = traverseLeftToRight<T>(children, row1)) !=
320  (const T *) NULL)
321  return head;
322 
323  return children.front();
324  }
325 
326  template <typename T>
327  spear::RCIPtr<T>
328  findHeadEnglishSBAR(const String & parent,
329  const std::list< spear::RCIPtr<T> > & children)
330  {
331  static const Char * row1 [] = {
332  W("WHNP"), W("WHPP"), W("WHADVP"), W("WHADJP"), W("IN"), W("DT"), W("S"), W("SQ"),
333  W("SINV"), W("SBAR"), W("FRAG"), NULL
334  };
335 
336  spear::RCIPtr<T> head;
337 
338  if((head = traverseLeftToRight<T>(children, row1)) !=
339  (const T *) NULL)
340  return head;
341 
342  return children.front();
343  }
344 
345  template <typename T>
346  spear::RCIPtr<T>
347  findHeadEnglishSBARQ(const String & parent,
348  const std::list< spear::RCIPtr<T> > & children)
349  {
350  static const Char * row1 [] = {
351  W("SQ"), W("S"), W("SINV"), W("SBARQ"), W("FRAG"), W("SBAR"), NULL
352  };
353 
354  spear::RCIPtr<T> head;
355 
356  if((head = traverseRightToLeft<T>(children, row1)) !=
357  (const T *) NULL)
358  return head;
359 
360  return children.front();
361  }
362 
363  template <typename T>
364  spear::RCIPtr<T>
365  findHeadEnglishSINV(const String & parent,
366  const std::list< spear::RCIPtr<T> > & children)
367  {
368  static const Char * row1 [] = {
369  W("VBZ"), W("VBD"), W("VBP"), W("VB"), W("MD"), W("VP"), W("S"), W("SINV"), W("ADJP"),
370  W("NP"), W("NPB"), NULL
371  };
372 
373  spear::RCIPtr<T> head;
374 
375  if((head = traverseLeftToRight<T>(children, row1)) !=
376  (const T *) NULL)
377  return head;
378 
379  return children.front();
380  }
381 
382  template <typename T>
383  spear::RCIPtr<T>
384  findHeadEnglishSQ(const String & parent,
385  const std::list< spear::RCIPtr<T> > & children)
386  {
387  static const Char * row1 [] = {
388  W("VBZ"), W("VBD"), W("VBP"), W("VB"), W("MD"), W("VP"), W("SQ"), NULL
389  };
390 
391  spear::RCIPtr<T> head;
392 
393  if((head = traverseLeftToRight<T>(children, row1)) !=
394  (const T *) NULL)
395  return head;
396 
397  return children.front();
398  }
399 
400  template <typename T>
401  spear::RCIPtr<T>
402  findHeadEnglishUCP(const String & parent,
403  const std::list< spear::RCIPtr<T> > & children)
404  {
405  return children.back();
406  }
407 
408  template <typename T>
409  spear::RCIPtr<T>
410  findHeadEnglishVP(const String & parent,
411  const std::list< spear::RCIPtr<T> > & children)
412  {
413  static const Char * row1 [] = {
414  W("TO"), W("VBD"), W("VBN"), W("MD"), W("VBZ"), W("VB"), W("VBG"), W("VBP"), W("VP"), W("VPB"),
415  W("ADJP"), W("NN"), W("NNS"), W("NP"), W("NPB"), NULL
416  };
417 
418  spear::RCIPtr<T> head;
419 
420  if((head = traverseLeftToRight<T>(children, row1)) !=
421  (const T *) NULL)
422  return head;
423 
424  return children.front();
425  }
426 
427  template <typename T>
428  spear::RCIPtr<T>
429  findHeadEnglishWHADJP(const String & parent,
430  const std::list< spear::RCIPtr<T> > & children)
431  {
432  static const Char * row1 [] = { W("CC"), W("WRB"), W("JJ"), W("ADJP"), NULL };
433 
434  spear::RCIPtr<T> head;
435 
436  if((head = traverseLeftToRight<T>(children, row1)) !=
437  (const T *) NULL)
438  return head;
439 
440  return children.front();
441  }
442 
443  template <typename T>
444  spear::RCIPtr<T>
445  findHeadEnglishWHADVP(const String & parent,
446  const std::list< spear::RCIPtr<T> > & children)
447  {
448  static const Char * row1 [] = { W("CC"), W("WRB"), NULL };
449 
450  spear::RCIPtr<T> head;
451 
452  if((head = traverseRightToLeft<T>(children, row1)) !=
453  (const T *) NULL)
454  return head;
455 
456  return children.front();
457  }
458 
459  template <typename T>
460  spear::RCIPtr<T>
461  findHeadEnglishWHNP(const String & parent,
462  const std::list< spear::RCIPtr<T> > & children)
463  {
464  static const Char * row1 [] =
465  { W("WDT"), W("WP"), W("WP$"), W("WHADJP"), W("WHPP"), W("WHNP"), NULL };
466 
467  spear::RCIPtr<T> head;
468 
469  if((head = traverseLeftToRight<T>(children, row1)) !=
470  (const T *) NULL)
471  return head;
472 
473  return children.front();
474  }
475 
476  template <typename T>
477  spear::RCIPtr<T>
478  findHeadEnglishWHPP(const String & parent,
479  const std::list< spear::RCIPtr<T> > & children)
480  {
481  static const Char * row1 [] = { W("IN"), W("TO"), W("FW"), NULL };
482 
483  spear::RCIPtr<T> head;
484 
485  if((head = traverseRightToLeft<T>(children, row1)) !=
486  (const T *) NULL)
487  return head;
488 
489  return children.front();
490  }
491 
492  template <typename T>
493  spear::RCIPtr<T>
494  findHeadEnglishTOP(const String & parent,
495  const std::list< spear::RCIPtr<T> > & children)
496  {
497  return children.front();
498  }
499 
500  template <typename T>
501  spear::RCIPtr<T>
502  findHeadEnglishX(const String & parent,
503  const std::list< spear::RCIPtr<T> > & children)
504  {
505  return children.front();
506  }
507 
508  template <typename T>
509  spear::RCIPtr<T>
510  findHeadEnglishNoCoord(const String & parent,
511  const std::list< spear::RCIPtr<T> > & children)
512  {
513  if(parent == W("NP") ||
514  parent == W("NPB")){
515  return findHeadEnglishNP<T>(parent, children);
516  } else if(parent == W("ADJP")){
517  return findHeadEnglishADJP<T>(parent, children);
518  } else if(parent == W("ADVP") ||
519  parent == W("PRT") ||
520  parent == W("ADVP|PRT") ||
521  parent == W("PRT|ADVP")){
522  return findHeadEnglishADVP<T>(parent, children);
523  } else if(parent == W("CONJP")){
524  return findHeadEnglishCONJP<T>(parent, children);
525  } else if(parent == W("FRAG")){
526  return findHeadEnglishFRAG<T>(parent, children);
527  } else if(parent == W("INTJ")){
528  return findHeadEnglishINTJ<T>(parent, children);
529  } else if(parent == W("LST")){
530  return findHeadEnglishLST<T>(parent, children);
531  } else if(parent == W("NAC")){
532  return findHeadEnglishNAC<T>(parent, children);
533  } else if(parent == W("PP")){
534  return findHeadEnglishPP<T>(parent, children);
535  } else if(parent == W("PRN")){
536  return findHeadEnglishPRN<T>(parent, children);
537  } else if(parent == W("QP")){
538  return findHeadEnglishQP<T>(parent, children);
539  } else if(parent == W("RRC")){
540  return findHeadEnglishRRC<T>(parent, children);
541  } else if(parent == W("S") ||
542  parent == W("SG")){
543  return findHeadEnglishS<T>(parent, children);
544  } else if(parent == W("SBAR")){
545  return findHeadEnglishSBAR<T>(parent, children);
546  } else if(parent == W("SBARQ")){
547  return findHeadEnglishSBARQ<T>(parent, children);
548  } else if(parent == W("SINV")){
549  return findHeadEnglishSINV<T>(parent, children);
550  } else if(parent == W("SQ")){
551  return findHeadEnglishSQ<T>(parent, children);
552  } else if(parent == W("UCP")){
553  return findHeadEnglishUCP<T>(parent, children);
554  } else if(parent == W("VP")){
555  return findHeadEnglishVP<T>(parent, children);
556  } else if(parent == W("WHADJP")){
557  return findHeadEnglishWHADJP<T>(parent, children);
558  } else if(parent == W("WHADVP")){
559  return findHeadEnglishWHADVP<T>(parent, children);
560  } else if(parent == W("WHNP")){
561  return findHeadEnglishWHNP<T>(parent, children);
562  } else if(parent == W("WHPP")){
563  return findHeadEnglishWHPP<T>(parent, children);
564  } else if(parent == W("TOP")){
565  return findHeadEnglishTOP<T>(parent, children);
566  } else if(parent == W("X") ||
567  parent == W("NX")){
568  return findHeadEnglishX<T>(parent, children);
569  } else{
570  CERR << "Can not find head edge for label " << parent << endl;
571  CERR << "The children are:\n";
572  for(TCI it = (TCI) children.begin();
573  it != (TCI) children.end(); it ++){
574  (* it)->display(CERR);
575  CERR << endl;
576  }
577  LASSERT(false, "unknown edge label");
578  }
579 
580  return children.front();
581  }
582 
583  template <typename T>
584  TCRI
585  isCoordinatedHead(const std::list< spear::RCIPtr<T> > & children,
586  TCRI current)
587  {
588  // Advance over head
589  current ++;
590  if(current == children.rend()) return children.rend();
591 
592  // Advance over CC
593  if((* current)->getLabel() == W("CC")){
594  current ++;
595  if(current == children.rend()) return children.rend();
596  } else{
597  return children.rend();
598  }
599 
600  // Advance over any commas
601  for(; current != (TCRI) children.rend() &&
602  (* current)->getLabel() == W(",");
603  current ++);
604  if(current == children.rend()) return children.rend();
605 
606  return current;
607  }
608 
609  template <typename T>
610  spear::RCIPtr<T>
611  findHeadEnglish(const String & parent,
612  const std::list< spear::RCIPtr<T> > & children)
613  {
614  LASSERT(children.empty() == false, "empty children set");
615 
616  // Find the head edge before the CC condition
617  spear::RCIPtr<T> head =
618  findHeadEnglishNoCoord<T>(parent, children);
619 
620  // Check for coordinations
621  for(TCRI it = (TCRI) children.rbegin();
622  it != (TCRI) children.rend(); it ++){
623 
624  // Found the head
625  if((* it) == head){
626  TCRI newHead;
627 
628  // If it is a valid CC change the head to the edge before the CC
629  if((parent != W("NPB")) &&
630  (newHead = isCoordinatedHead<T>(children, it)) != children.rend()){
631  return (* newHead);
632  }
633 
634  return head;
635  }
636  }
637 
638  return head;
639  }
640 
641 } // end namespace spear
642 
643 #endif /* ENGLISH_HEAD_H */
spear::findHeadEnglishADVP
spear::RCIPtr< T > findHeadEnglishADVP(const String &parent, const std::list< spear::RCIPtr< T > > &children)
Definition: HeadEnglish.h:159
RCIPtr.h
Reference counting pointer class This file contains the code for the classes and class templates maki...
spear::findHeadEnglishWHNP
spear::RCIPtr< T > findHeadEnglishWHNP(const String &parent, const std::list< spear::RCIPtr< T > > &children)
Definition: HeadEnglish.h:461
spear::isCoordinatedHead
TCRI isCoordinatedHead(const std::list< spear::RCIPtr< T > > &children, TCRI current)
Definition: HeadEnglish.h:585
spear::findHeadEnglishTOP
spear::RCIPtr< T > findHeadEnglishTOP(const String &parent, const std::list< spear::RCIPtr< T > > &children)
Definition: HeadEnglish.h:494
spear::findHeadEnglishSBARQ
spear::RCIPtr< T > findHeadEnglishSBARQ(const String &parent, const std::list< spear::RCIPtr< T > > &children)
Definition: HeadEnglish.h:347
spear::findHeadEnglishWHADJP
spear::RCIPtr< T > findHeadEnglishWHADJP(const String &parent, const std::list< spear::RCIPtr< T > > &children)
Definition: HeadEnglish.h:429
spear::RCIPtr
Definition: RCIPtr.h:67
spear::findHeadEnglishUCP
spear::RCIPtr< T > findHeadEnglishUCP(const String &parent, const std::list< spear::RCIPtr< T > > &children)
Definition: HeadEnglish.h:402
spear::findHeadEnglishPP
spear::RCIPtr< T > findHeadEnglishPP(const String &parent, const std::list< spear::RCIPtr< T > > &children)
Definition: HeadEnglish.h:246
spear::findHeadEnglishNoCoord
spear::RCIPtr< T > findHeadEnglishNoCoord(const String &parent, const std::list< spear::RCIPtr< T > > &children)
Definition: HeadEnglish.h:510
Char
char Char
Definition: Wide.h:34
spear::findHeadEnglishSQ
spear::RCIPtr< T > findHeadEnglishSQ(const String &parent, const std::list< spear::RCIPtr< T > > &children)
Definition: HeadEnglish.h:384
spear::findHeadEnglish
spear::RCIPtr< T > findHeadEnglish(const String &parent, const std::list< spear::RCIPtr< T > > &children)
Definition: HeadEnglish.h:611
spear::findHeadEnglishPRN
spear::RCIPtr< T > findHeadEnglishPRN(const String &parent, const std::list< spear::RCIPtr< T > > &children)
Definition: HeadEnglish.h:263
spear::findHeadEnglishWHPP
spear::RCIPtr< T > findHeadEnglishWHPP(const String &parent, const std::list< spear::RCIPtr< T > > &children)
Definition: HeadEnglish.h:478
spear::findHeadEnglishS
spear::RCIPtr< T > findHeadEnglishS(const String &parent, const std::list< spear::RCIPtr< T > > &children)
Definition: HeadEnglish.h:309
TCRI
#define TCRI
Definition: HeadEnglish.h:22
spear::traverseLeftToRight
spear::RCIPtr< T > traverseLeftToRight(const std::list< spear::RCIPtr< T > > &children, const Char *labels[], bool traverseLabelsFirst=true)
Definition: HeadEnglish.h:63
spear::findHeadEnglishQP
spear::RCIPtr< T > findHeadEnglishQP(const String &parent, const std::list< spear::RCIPtr< T > > &children)
Definition: HeadEnglish.h:271
spear::findHeadEnglishFRAG
spear::RCIPtr< T > findHeadEnglishFRAG(const String &parent, const std::list< spear::RCIPtr< T > > &children)
Definition: HeadEnglish.h:194
String
#define String
Definition: Wide.h:36
spear::findHeadEnglishNP
spear::RCIPtr< T > findHeadEnglishNP(const String &parent, const std::list< spear::RCIPtr< T > > &children)
Definition: HeadEnglish.h:98
spear::findHeadEnglishSINV
spear::RCIPtr< T > findHeadEnglishSINV(const String &parent, const std::list< spear::RCIPtr< T > > &children)
Definition: HeadEnglish.h:365
spear::findHeadEnglishVP
spear::RCIPtr< T > findHeadEnglishVP(const String &parent, const std::list< spear::RCIPtr< T > > &children)
Definition: HeadEnglish.h:410
W
#define W(X)
Definition: Wide.h:45
spear::findHeadEnglishADJP
spear::RCIPtr< T > findHeadEnglishADJP(const String &parent, const std::list< spear::RCIPtr< T > > &children)
Definition: HeadEnglish.h:139
spear::findHeadEnglishX
spear::RCIPtr< T > findHeadEnglishX(const String &parent, const std::list< spear::RCIPtr< T > > &children)
Definition: HeadEnglish.h:502
i
get the indices of edges in each direction for i
Definition: APPgetLargeConnectedEdges.m:48
spear::findHeadEnglishLST
spear::RCIPtr< T > findHeadEnglishLST(const String &parent, const std::list< spear::RCIPtr< T > > &children)
Definition: HeadEnglish.h:210
spear::findHeadEnglishNAC
spear::RCIPtr< T > findHeadEnglishNAC(const String &parent, const std::list< spear::RCIPtr< T > > &children)
Definition: HeadEnglish.h:226
TCI
#define TCI
Definition: HeadEnglish.h:21
spear::findHeadEnglishINTJ
spear::RCIPtr< T > findHeadEnglishINTJ(const String &parent, const std::list< spear::RCIPtr< T > > &children)
Definition: HeadEnglish.h:202
spear::findHeadEnglishRRC
spear::RCIPtr< T > findHeadEnglishRRC(const String &parent, const std::list< spear::RCIPtr< T > > &children)
Definition: HeadEnglish.h:290
spear::findHeadEnglishWHADVP
spear::RCIPtr< T > findHeadEnglishWHADVP(const String &parent, const std::list< spear::RCIPtr< T > > &children)
Definition: HeadEnglish.h:445
spear::traverseRightToLeft
spear::RCIPtr< T > traverseRightToLeft(const std::list< spear::RCIPtr< T > > &children, const Char *labels[], bool traverseLabelsFirst=true)
Definition: HeadEnglish.h:28
LASSERT
#define LASSERT(condition, message)
Definition: Assert.h:14
spear::findHeadEnglishSBAR
spear::RCIPtr< T > findHeadEnglishSBAR(const String &parent, const std::list< spear::RCIPtr< T > > &children)
Definition: HeadEnglish.h:328
CERR
#define CERR
Definition: Wide.h:30
spear::findHeadEnglishCONJP
spear::RCIPtr< T > findHeadEnglishCONJP(const String &parent, const std::list< spear::RCIPtr< T > > &children)
Definition: HeadEnglish.h:178
Generated by   doxygen 1.8.6