00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021 #include "SyntaxNodeCollection.h"
00022
00023 #include <cassert>
00024 #include <iostream>
00025
00026 namespace MosesTraining
00027 {
00028
00029 SyntaxNodeCollection::~SyntaxNodeCollection()
00030 {
00031 Clear();
00032 }
00033
00034 void SyntaxNodeCollection::Clear()
00035 {
00036
00037 for(size_t i=0; i<m_nodes.size(); i++) {
00038 delete m_nodes[i];
00039 }
00040 m_nodes.clear();
00041 m_index.clear();
00042 }
00043
00044 SyntaxNode *SyntaxNodeCollection::AddNode(int startPos, int endPos,
00045 const std::string &label)
00046 {
00047 SyntaxNode* newNode = new SyntaxNode(label, startPos, endPos);
00048 m_nodes.push_back( newNode );
00049 m_index[ startPos ][ endPos ].push_back( newNode );
00050 m_endPositionsIndex[ endPos ].push_back( newNode );
00051 m_startPositionsIndex[ startPos ].push_back( newNode );
00052 m_numWords = std::max(endPos+1, m_numWords);
00053 return newNode;
00054 }
00055
00056 bool SyntaxNodeCollection::HasNode( int startPos, int endPos ) const
00057 {
00058 return GetNodes( startPos, endPos).size() > 0;
00059 }
00060
00061 const std::vector< SyntaxNode* >& SyntaxNodeCollection::GetNodes(
00062 int startPos, int endPos ) const
00063 {
00064 NodeIndex::const_iterator startIndex = m_index.find( startPos );
00065 if (startIndex == m_index.end() )
00066 return m_emptyNode;
00067
00068 InnerNodeIndex::const_iterator endIndex = startIndex->second.find( endPos );
00069 if (endIndex == startIndex->second.end())
00070 return m_emptyNode;
00071
00072 return endIndex->second;
00073 }
00074
00075 bool SyntaxNodeCollection::HasNodeStartingAtPosition( int startPos ) const
00076 {
00077 return GetNodesByStartPosition(startPos).size() > 0;
00078 }
00079
00080 const std::vector< SyntaxNode* >& SyntaxNodeCollection::GetNodesByStartPosition(
00081 int startPos ) const
00082 {
00083 InnerNodeIndex::const_iterator startIndex = m_startPositionsIndex.find( startPos );
00084 if (startIndex == m_startPositionsIndex.end() )
00085 return m_emptyNode;
00086
00087 return startIndex->second;
00088 }
00089
00090 bool SyntaxNodeCollection::HasNodeEndingAtPosition( int endPos ) const
00091 {
00092 return GetNodesByEndPosition(endPos).size() > 0;
00093 }
00094
00095 const std::vector< SyntaxNode* >& SyntaxNodeCollection::GetNodesByEndPosition(
00096 int endPos ) const
00097 {
00098 InnerNodeIndex::const_iterator endIndex = m_endPositionsIndex.find( endPos );
00099 if (endIndex == m_endPositionsIndex.end() )
00100 return m_emptyNode;
00101
00102 return endIndex->second;
00103 }
00104
00105 std::auto_ptr<SyntaxTree> SyntaxNodeCollection::ExtractTree()
00106 {
00107 std::map<SyntaxNode *, SyntaxTree *> nodeToTree;
00108
00109
00110 for (std::vector<SyntaxNode*>::const_iterator p = m_nodes.begin();
00111 p != m_nodes.end(); ++p) {
00112 nodeToTree[*p] = new SyntaxTree(**p);
00113 }
00114
00115
00116 typedef NodeIndex::const_iterator OuterIterator;
00117 typedef InnerNodeIndex::const_reverse_iterator InnerIterator;
00118
00119 SyntaxTree *root = 0;
00120 SyntaxNode *prevNode = 0;
00121 SyntaxTree *prevTree = 0;
00122
00123 for (OuterIterator p = m_index.begin(); p != m_index.end(); ++p) {
00124 const InnerNodeIndex &inner = p->second;
00125
00126 for (InnerIterator q = inner.rbegin(); q != inner.rend(); ++q) {
00127 const std::vector<SyntaxNode*> &nodes = q->second;
00128
00129
00130 for (std::vector<SyntaxNode*>::const_reverse_iterator r = nodes.rbegin();
00131 r != nodes.rend(); ++r) {
00132 SyntaxNode *node = *r;
00133 SyntaxTree *tree = nodeToTree[node];
00134 if (!prevNode) {
00135
00136 root = tree;
00137 tree->parent() = 0;
00138 } else if (prevNode->start == node->start) {
00139
00140 assert(prevNode->end >= node->end);
00141 tree->parent() = prevTree;
00142 prevTree->children().push_back(tree);
00143 } else {
00144
00145
00146 SyntaxTree *ancestor = prevTree->parent();
00147 while (ancestor->value().end < tree->value().end) {
00148 ancestor = ancestor->parent();
00149 }
00150 assert(ancestor);
00151 tree->parent() = ancestor;
00152 ancestor->children().push_back(tree);
00153 }
00154 prevNode = node;
00155 prevTree = tree;
00156 }
00157 }
00158 }
00159
00160 return std::auto_ptr<SyntaxTree>(root);
00161 }
00162
00163 }