SentencePattern.cc

Go to the documentation of this file.
00001 #include "LinguisticDefinition/SentencePattern.h"
00002 
00003 using namespace std;
00004 using namespace LinguisticDefinition;
00005 
00009 SentencePattern::SentencePattern() :
00010   d_hasBeginningOperator(false),
00011   d_hasEndOperator(false) {
00012 }
00013 
00017 SentencePattern::~SentencePattern() {
00018   {for (ElementIterator it = elementsBegin(); it != elementsEnd(); ++it) {
00019     delete *it;
00020   }}
00021 }
00022 
00026 SentencePattern::SentencePattern(const SentencePattern &o) :
00027   d_hasBeginningOperator(o.d_hasBeginningOperator),
00028   d_hasEndOperator(o.d_hasEndOperator) {
00029   {for (ElementIterator it = o.elementsBegin(); it != o.elementsEnd(); ++it) {
00030     Element *element = new Element(**it);
00031     element->d_parent = this;
00032     d_elements.push_back(element);
00033   }}
00034 }
00035 
00039 bool SentencePattern::hasEndOperator() const {
00040   return d_hasEndOperator;
00041 }
00042 
00046 bool SentencePattern::hasBeginningOperator() const {
00047   return d_hasBeginningOperator;
00048 }
00049 
00053 void SentencePattern::setEndOperator(bool val) {
00054   d_hasEndOperator = val;
00055 }
00056 
00060 void SentencePattern::setBeginningOperator(bool val) {
00061   d_hasBeginningOperator = val;
00062 }
00063 
00067 SentencePattern::ElementIterator SentencePattern::elementsBegin() const {
00068   return d_elements.begin();
00069 }
00070 
00074 SentencePattern::ElementIterator SentencePattern::elementsEnd() const {
00075   return d_elements.end();
00076 }
00077 
00081 SentencePattern::Element &SentencePattern::createElement() {
00082   Element *element = new Element(*this, d_elements.size() + 1);
00083   d_elements.push_back(element);
00084   return *element;
00085 }
00086 
00090 const SentencePattern::Element *
00091 SentencePattern::getElementAtPosition(int index) const {
00092   if (1 <= index && index <= (int) d_elements.size()) {
00093     return d_elements[index - 1];
00094   }
00095   return NULL;
00096 }
00097 
00101 SentencePattern::Element::Element(const SentencePattern &parent,
00102                                   int listPosition) :
00103   d_parent(&parent),
00104   d_listPosition(listPosition),
00105   d_loopMin(1),
00106   d_loopMax(1),
00107   d_hasOnlyOperator(false) {
00108 }
00109 
00113 const SentencePattern &SentencePattern::Element::getSentencePattern() const {
00114   return *d_parent;
00115 }
00116 
00120 const WordPattern &SentencePattern::Element::getWordPattern() const {
00121   return d_wordPattern;
00122 }
00123 
00127 const WordPattern &SentencePattern::Element::getHeadPattern() const {
00128   return d_headPattern;
00129 }
00130 
00134 WordPattern &SentencePattern::Element::getModifiableWordPattern() {
00135   return d_wordPattern;
00136 }
00137 
00141 WordPattern &SentencePattern::Element::getModifiableHeadPattern() {
00142   return d_headPattern;
00143 }
00144 
00148 bool SentencePattern::Element::hasHeadPattern() const {
00149   return
00150     d_headPattern.getRootElement().elementsBegin() !=
00151     d_headPattern.getRootElement().elementsEnd();
00152 }
00153 
00157 int SentencePattern::Element::getMinimumLoopCount() const {
00158   return d_loopMin;
00159 }
00160 
00164 int SentencePattern::Element::getMaximumLoopCount() const {
00165   return d_loopMax;
00166 }
00167 
00171 bool SentencePattern::Element::hasOnlyOperator() const {
00172   return d_hasOnlyOperator;
00173 }
00174 
00178 bool SentencePattern::Element::isWildcard() const {
00179   // No matching information means that it is a wildcard
00180   const WordPattern::GroupElement &wordElement =
00181     d_wordPattern.getRootElement();
00182   return wordElement.elementsBegin() == wordElement.elementsEnd();
00183 }
00184 
00188 void SentencePattern::Element::setMinimumLoopCount(int val) {
00189   d_loopMin = val;
00190 }
00191 
00195 void SentencePattern::Element::setMaximumLoopCount(int val) {
00196   d_loopMax = val;
00197 }
00198 
00202 void SentencePattern::Element::setOnlyOperator(bool val) {
00203   d_hasOnlyOperator = val;
00204 }
00205 
00209 const SentencePattern::Element *SentencePattern::Element::getNext() const {
00210   return d_parent->getElementAtPosition(d_listPosition + 1);
00211 }
00212 
00216 const SentencePattern::Element *SentencePattern::Element::getPrevious() const {
00217   return d_parent->getElementAtPosition(d_listPosition - 1);
00218 }
00219 
00223 int SentencePattern::Element::getPatternPosition() const {
00224   return d_listPosition;
00225 }

Generated on Fri Jun 23 14:03:15 2006 for LinguisticDefinition by  doxygen 1.4.7