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
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
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 }