WordPattern.cc

Go to the documentation of this file.
00001 #include "LinguisticDefinition/WordPattern.h"
00002 
00003 using namespace std;
00004 using namespace LinguisticDefinition;
00005 
00009 WordPattern::WordPattern() :
00010   d_rootElement(*this) {
00011 }
00012 
00016 WordPattern::~WordPattern() {
00017   {for (ReferenceIterator it = referencesBegin();
00018         it != referencesEnd(); ++it) {
00019     delete *it;
00020   }}
00021 }
00022 
00026 WordPattern::WordPattern(const WordPattern &o) :
00027   d_rootElement(o.d_rootElement) {
00028   {for (ReferenceIterator it = o.referencesBegin();
00029         it != o.referencesEnd(); ++it) {
00030     d_references.push_back(new Reference(**it));
00031   }}
00032 }
00033 
00037 WordPattern::OrGroupElement &WordPattern::getModifiableRootElement() {
00038   return d_rootElement;
00039 }
00040 
00044 const WordPattern::OrGroupElement &WordPattern::getRootElement() const {
00045   return d_rootElement;
00046 }
00047 
00051 bool WordPattern::matches(const LingFeatures &features) const {
00052   return d_rootElement.matches(features);
00053 }
00054 
00058 bool WordPattern::matches(const LingFeaturesSet &features) const {
00059   {for (LingFeaturesSet::ElementIterator it = features.elementsBegin();
00060         it != features.elementsEnd(); ++it) {
00061     if (d_rootElement.matches(**it)) {
00062       return true;
00063     }
00064   }}
00065 
00066   return features.isEmpty();
00067 }
00068 
00072 LingFeaturesSet WordPattern::reduce(const LingFeaturesSet &inSet) const {
00073   LingFeaturesSet outSet;
00074 
00075   {for (LingFeaturesSet::ElementIterator it = inSet.elementsBegin();
00076         it != inSet.elementsEnd(); ++it) {
00077     if (d_rootElement.matches(**it)) {
00078       outSet.add(**it);
00079     }
00080   }}
00081 
00082   return outSet;
00083 }
00084 
00088 void WordPattern::generate(vector<const LingFeatures *> &v) const {
00089   d_rootElement.generate(v, NULL);
00090 }
00091 
00095 WordPattern::Element::Element(const WordPattern &element) :
00096   d_element(element),
00097   d_negative(false) {
00098 }
00099 
00103 WordPattern::GroupElement::GroupElement(const WordPattern &element) :
00104   Element(element) {
00105 }
00106 
00110 WordPattern::AndGroupElement::AndGroupElement(const WordPattern &element) :
00111   GroupElement(element) {
00112 }
00113 
00117 WordPattern::OrGroupElement::OrGroupElement(const WordPattern &element) :
00118   GroupElement(element) {
00119 }
00120 
00124 WordPattern::LeafElement::LeafElement(const WordPattern &element) :
00125   Element(element),
00126   d_pos(NULL),
00127   d_feature(NULL) {
00128 }
00129 
00133 WordPattern::Element::Element(const Element &o) :
00134   d_element(o.d_element),
00135   d_negative(o.d_negative) {
00136 }
00137 
00141 WordPattern::GroupElement::GroupElement(const GroupElement &o) :
00142   Element(o) {
00143   {for (ElementIterator it = o.elementsBegin(); it != o.elementsEnd(); ++it) {
00144     d_elements.push_back((*it)->clone());
00145   }}
00146 }
00147 
00151 WordPattern::OrGroupElement::OrGroupElement(const OrGroupElement &o) :
00152   GroupElement(o) {
00153 }
00154 
00158 WordPattern::AndGroupElement::AndGroupElement(const AndGroupElement &o) :
00159   GroupElement(o) {
00160 }
00161 
00165 WordPattern::LeafElement::LeafElement(const LeafElement &o) :
00166   Element(o),
00167   d_pos(o.d_pos),
00168   d_feature(o.d_feature),
00169   d_form(o.d_form),
00170   d_lemma(o.d_lemma) {
00171 }
00172 
00176 WordPattern::Element *WordPattern::OrGroupElement::clone() const {
00177   return new OrGroupElement(*this);
00178 }
00179 
00183 WordPattern::Element *WordPattern::AndGroupElement::clone() const {
00184   return new AndGroupElement(*this);
00185 }
00186 
00190 WordPattern::Element *WordPattern::LeafElement::clone() const {
00191   return new LeafElement(*this);
00192 }
00193 
00197 WordPattern::Element::~Element() {
00198 }
00199 
00203 WordPattern::GroupElement::~GroupElement() {
00204   {for (ElementIterator it = d_elements.begin();
00205         it != d_elements.end(); ++it) {
00206     delete *it;
00207   }}
00208 }
00209 
00213 WordPattern::OrGroupElement::~OrGroupElement() {
00214 }
00215 
00219 WordPattern::AndGroupElement::~AndGroupElement() {
00220 }
00221 
00225 WordPattern::LeafElement::~LeafElement() {
00226 }
00227 
00231 const WordPattern &WordPattern::Element::getElement() const {
00232   return d_element;
00233 }
00234 
00238 WordPattern::GroupElement::ElementIterator
00239 WordPattern::GroupElement::elementsBegin() const {
00240   return d_elements.begin();
00241 }
00242 
00246 WordPattern::GroupElement::ElementIterator
00247 WordPattern::GroupElement::elementsEnd() const {
00248   return d_elements.end();
00249 }
00250 
00254 bool
00255 WordPattern::LeafElement::matches(const LingFeatures &features) const {
00256   if (d_feature != NULL) {
00257     if (!features.has(*d_feature)) {
00258       return isNegative();
00259     }
00260   } else {
00261     if (d_pos != NULL && features.getPosDef() != d_pos) {
00262       return isNegative();
00263     }
00264   }
00265 
00266   if (d_lemma != "" && features.getLemma() != d_lemma) {
00267     return isNegative();
00268   }
00269 
00270   if (d_form != "" && features.getForm() != d_form) {
00271     return isNegative();
00272   }
00273 
00274   return !isNegative();
00275 }
00276 
00280 bool
00281 WordPattern::AndGroupElement::matches(const LingFeatures &features) const {
00282   {for (ElementIterator it = elementsBegin(); it != elementsEnd(); ++it) {
00283     if (!(*it)->matches(features)) {
00284       return isNegative();
00285     }
00286   }}
00287   return !isNegative();
00288 }
00289 
00293 bool
00294 WordPattern::OrGroupElement::matches(const LingFeatures &features) const {
00295   {for (ElementIterator it = elementsBegin(); it != elementsEnd(); ++it) {
00296     if ((*it)->matches(features)) {
00297       return !isNegative();
00298     }
00299   }}
00300   return isNegative();
00301 }
00302 
00306 void WordPattern::LeafElement::generate(vector<const LingFeatures *> &v,
00307                                         LingFeatures *current)
00308   const {
00309 
00310   if (isNegative()) {
00311     // What to do?
00312     return;
00313   }
00314 
00315   if (current == NULL) {
00316     const LingDef::Pos *posDef = d_pos;
00317     if (posDef == NULL && d_feature != NULL) {
00318       posDef = d_feature->getPosDef();
00319     }
00320     if (posDef != NULL) {
00321       current = new LingFeatures(*posDef);
00322       v.push_back(current);
00323     }
00324   }
00325 
00326   if (current != NULL && d_feature != NULL) {
00327     current->set(*d_feature);
00328   }
00329 }
00330 
00334 void WordPattern::OrGroupElement::generate(vector<const LingFeatures *> &v,
00335                                            LingFeatures *current)
00336   const {
00337   {for (ElementIterator it = elementsBegin(); it != elementsEnd(); ++it) {
00338     (*it)->generate(v, current);
00339   }}  
00340 }
00341 
00345 void WordPattern::AndGroupElement::generate(vector<const LingFeatures *> &v,
00346                                             LingFeatures *current)
00347   const {
00348   {for (ElementIterator it = elementsBegin(); it != elementsEnd(); ++it) {
00349     (*it)->generate(v, current);
00350   }}  
00351 }
00352 
00356 void WordPattern::LeafElement::setPosDef(const LingDef::Pos &val) {
00357   d_pos = &val;
00358 }
00359 
00363 const LingDef::Pos *WordPattern::LeafElement::getPosDef() const {
00364   return d_pos;
00365 }
00366 
00370 void WordPattern::LeafElement::setForm(const string &val) {
00371   d_form = val;
00372 }
00373 
00377 void WordPattern::LeafElement::setLemma(const string &val) {
00378   d_lemma = val;
00379 }
00380 
00384 void WordPattern::LeafElement::setFeature(const LingDef::Feature &val) {
00385   d_feature = &val;
00386 }
00387 
00391 void
00392 WordPattern::LeafElement::setFeature(const LingDef::Feature &enumFeat,
00393                                      const LingDef::Feature &enumValFeat) {
00394   if (enumValFeat.getParentEnum() != &enumFeat) {
00395     //ERROR
00396     return;
00397   }
00398 
00399   d_feature = &enumValFeat;
00400 }
00401 
00405 WordPattern::AndGroupElement &WordPattern::GroupElement::createAnd() {
00406   AndGroupElement *element = new AndGroupElement(getElement());
00407   d_elements.push_back(element);
00408   return *element;
00409 }
00410 
00414 WordPattern::OrGroupElement &WordPattern::GroupElement::createOr() {
00415   OrGroupElement *element = new OrGroupElement(getElement());
00416   d_elements.push_back(element);
00417   return *element;
00418 }
00419 
00423 WordPattern::LeafElement &WordPattern::GroupElement::createLeaf() {
00424   LeafElement *element = new LeafElement(getElement());
00425   d_elements.push_back(element);
00426   return *element;
00427 }
00428 
00432 void WordPattern::Element::setNegative(bool val) {
00433   d_negative = val;
00434 }
00435 
00439 bool WordPattern::Element::isNegative() const {
00440   return d_negative;
00441 }
00442 
00446 WordPattern::Reference::Reference(const string &featureName,
00447                                   int sourceElementIndex,
00448                                   const string &sourceFeatureName) :
00449   d_featureName(featureName),
00450   d_sourceElementIndex(sourceElementIndex),
00451   d_sourceFeatureName(sourceFeatureName) {
00452 }
00453 
00457 const string &WordPattern::Reference::getFeatureName() const {
00458   return d_featureName;
00459 }
00460 
00464 int WordPattern::Reference::getSourceElementIndex() const {
00465   return d_sourceElementIndex;
00466 }
00467 
00471 const string &WordPattern::Reference::getSourceFeatureName() const {
00472   return d_sourceFeatureName;
00473 }
00474 
00478 WordPattern::Reference &
00479 WordPattern::createReference(const string &featureName,
00480                              int sourceElementIndex,
00481                              const string &sourceFeatureName) {
00482   Reference *newReference = new Reference(featureName,
00483                                           sourceElementIndex,
00484                                           sourceFeatureName);
00485   d_references.push_back(newReference);
00486   return *newReference;
00487 }
00488 
00492 WordPattern::ReferenceIterator
00493 WordPattern::referencesBegin() const {
00494   return d_references.begin();
00495 }
00496 
00500 WordPattern::ReferenceIterator
00501 WordPattern::referencesEnd() const {
00502   return d_references.end();
00503 }

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