Compound.h

   1 // Compound type for compound discovery and display
   2 // Copyright © 2009 The University of Chicago
   3 #ifndef COMPOUND_H
   4 #define COMPOUND_H
   5
   6 class CCompound;
   7 class CCompoundListViewItem;
   8
   9 #include "LParse.h"
  10 #include <q3listview.h>
  11 #include <q3ptrvector.h>
  12 #include <Q3PtrList>
  13 #include <QList>
  14
  15 class CStem;
  16 class CLinker;
  17 class CEdge;
  18 class CCompoundCollection;
  19 class CLexicon;
  20
  21 typedef QList<CStem*> StemSet;
  22 typedef QMap<int,StemSet*> Components;
  23 typedef QMap<int,CLinker*> Linkers;
  24
  25 class CCompoundListViewItem : public Q3ListViewItem {
  26         CCompound* m_compound;
  27         int m_parse;
  28         double m_score;
  29         QString m_mostFreqPiece;
  30         double m_MFPCount;
  31         QString m_pieceCounts;
  32         double m_prefixness;
  33         double m_suffixness;
  34         int m_parseCount;
  35         QMap<QString, QString>* m_filter;
  36 public:
  37         // construction/destruction.
  38
  39         explicit CCompoundListViewItem(Q3ListView* parent = 0,
  40                 QString compound_text = QString(), CCompound* compound = 0,
  41                 int = -1, double = -1.0, QString = QString(),
  42                 double = 0.0, QString = QString(),
  43                 double = 0.0, double = 0.0, int = 1,
  44                 QMap<QString, QString>* filter = 0);
  45         explicit CCompoundListViewItem(Q3ListViewItem *parent,
  46                 QString compound_text = QString(), CCompound* compound = 0,
  47                 int = -1, double = -1.0, QString = QString(),
  48                 double = 0.0, QString = QString(),
  49                 double = 0.0, double = 0.0, int = 1,
  50                 QMap<QString, QString>* filter = 0);
  51         // destructor implicitly defined
  52
  53         // copy.
  54
  55         CCompoundListViewItem(const CCompoundListViewItem& x)
  56                 : Q3ListViewItem(x),
  57                 m_compound(x.m_compound),
  58                 m_parse(x.m_parse),
  59                 m_score(x.m_score),
  60                 m_mostFreqPiece(x.m_mostFreqPiece),
  61                 m_MFPCount(x.m_MFPCount),
  62                 m_pieceCounts(x.m_pieceCounts),
  63                 m_prefixness(x.m_prefixness),
  64                 m_suffixness(x.m_suffixness),
  65                 m_parseCount(x.m_parseCount),
  66                 m_filter(x.m_filter) { }
  67         CCompoundListViewItem& operator=(const CCompoundListViewItem& x)
  68         {
  69                 Q3ListViewItem::operator=(x);
  70                 m_compound = x.m_compound;
  71                 m_parse = x.m_parse;
  72                 m_score = x.m_score;
  73                 m_mostFreqPiece = x.m_mostFreqPiece;
  74                 m_MFPCount = x.m_MFPCount;
  75                 m_pieceCounts = x.m_pieceCounts;
  76                 m_prefixness = x.m_prefixness;
  77                 m_suffixness = x.m_suffixness;
  78                 m_parseCount = x.m_parseCount;
  79                 m_filter = x.m_filter;
  80                 return *this;
  81         }
  82
  83         // Qt3 list view item interface.
  84
  85         virtual QString text(int column_index) const;
  86         virtual QString key(int column, bool ascending) const;
  87
  88         // underlying compound object.
  89
  90         CCompound* GetCompound() const { return m_compound; }
  91         void SetCompound(CCompound* pCompound) { m_compound = pCompound; }
  92
  93         // compound properties.
  94
  95         void SetMFSCount(double d) { m_MFPCount = d; }
  96         void SetScore(double d) { m_score = d; }
  97         void SetPrefixness(double d) { m_prefixness = d; }
  98         void SetSuffixness(double d) { m_suffixness = d; }
  99         int GetParse() { return m_parse; }
 100 };
 101
 102 class CCompound : public CLParse {
 103         // The word components and linkers of the compound, but
 104         // only those reflected in the best parse (see m_BestParse)
 105         // and the CParse structure of the compound
 106         QMap<int, QList<CStem*>*>* m_MyComponents;
 107         QMap<int, CLinker*>* m_MyLinkers;
 108
 109         /// All "possible" parses of the compound as found
 110         /// by the Earley Parser and not deleted thereafter
 111         Q3PtrList<CEdge>* m_Parses;
 112
 113         /// This is the "best" parse chosen from the list above. This
 114         /// parse is reflected in the CParse structure of the compound.
 115         int m_BestParse;
 116
 117         /// The lexicon
 118         CLexicon* m_pLexicon;
 119 public:
 120         // construction/destruction.
 121
 122         explicit CCompound(CMiniLexicon* mini = 0);
 123         explicit CCompound(const CStringSurrogate& str, CMiniLexicon* mini = 0);
 124         virtual ~CCompound();
 125
 126         // disable copy.
 127 private:
 128         CCompound(const CCompound& x);
 129         CCompound& operator=(const CCompound& x);
 130 public:
 131
 132         QString DisplayBestParse(QMap<QString, QString>* filter = 0)
 133                 { return DisplayParse(m_BestParse, filter); }
 134         QString DisplayParse(int, QMap<QString, QString>* filter = 0);
 135         int GetNumberComponents() { return m_MyComponents->count(); }
 136         void CompoundListDisplay(Q3ListView* widget,
 137                 QMap<QString, QString>* filter = 0, QChar separator = QChar());
 138         int GetBestParse() { return m_BestParse; }
 139         QList<CStem*    >* GetComponent(int) const;
 140         Components* GetComponents() { return m_MyComponents; }
 141         CLinker* GetLinker(int) const;
 142         Linkers* GetLinkers() { return m_MyLinkers; }
 143         CEdge* GetParse(int i) { return m_Parses->at(i); }
 144         Q3PtrList<CEdge>* GetParses() { return m_Parses; }
 145         double GetPrefixness();
 146         double GetSuffixness();
 147
 148         void AddParse(CEdge*);
 149         void AttachComponentToWord(unsigned int piece, QList<CStem*>* word)
 150                 { m_MyComponents->insert(piece, word); }
 151         void DetachAllPieces();
 152         bool RemoveParse(CEdge*);
 153         bool RemoveParse(int i) { return RemoveParse(GetParse(i)); }
 154         void SetBestParse(int);
 155         void SetLexicon(CLexicon* lex) { m_pLexicon = lex; }
 156         void SetParses(Q3PtrList<CEdge>*, double*, double*);
 157 };
 158
 159 #endif // COMPOUND_H