diff options
Diffstat (limited to 'src/ispell/HyphenationRule.h')
| -rw-r--r-- | src/ispell/HyphenationRule.h | 113 |
1 files changed, 113 insertions, 0 deletions
diff --git a/src/ispell/HyphenationRule.h b/src/ispell/HyphenationRule.h new file mode 100644 index 0000000..4dfc89c --- /dev/null +++ b/src/ispell/HyphenationRule.h @@ -0,0 +1,113 @@ +/* libhyphenate: A TeX-like hyphenation algorithm.
+ * Copyright (C) 2007 Steve Wolter
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * If you have any questions, feel free to contact me:
+ * http://swolter.sdf1.org
+ **/
+#ifndef HYPHENATION_RULE_H
+#define HYPHENATION_RULE_H
+
+#include <string>
+#include <vector>
+
+namespace Hyphenate {
+ /** The HyphenationRule class represents a single Hyphenation Rule, that
+ * is, a pattern that has a number assigned to each letter and will,
+ * if applied, hyphenate a word at the given point. The number assigned
+ * to each letter and accessed by priority() is odd when hyphenation
+ * should occur before the letter, and only the rule with the highest
+ * number will be applied to any letter. */
+ class HyphenationRule {
+ private:
+ int del_pre, skip_post;
+ std::string key, insert_pre, insert_post;
+ std::vector<char> priorities;
+
+ std::string replacement;
+
+ public:
+ /* HyphenationRule is constructed from a string consisting of
+ * letters with numbers strewn in. The numbers are the priorities.
+ * In addition, a / will start a non-standard hyphenization. */
+ HyphenationRule(std::string source_string);
+
+ /** Call this method once an hyphen would, according to its base rule,
+ * be placed. Returns the number of bytes that should not be
+ * printed afterwards.
+ *
+ * For example, when applying the rules to "example", you should
+ * call the rules returned by HyphenationTree or Hyphenator as
+ * follows:
+ * string word = "ex";
+ * rule1.apply(word, "-");
+ * word += "am" ;
+ * rule2.apply(word, "-");
+ * word += "ple";
+ *
+ * Watch out for non-standard rules, though. Example: "Schiffahrt"
+ * string word = "Schif";
+ * int skip = rule1.apply(word, "-");
+ * char *rest = "fahrt";
+ * word += rest+skip;
+ */
+ int apply(std::string& word, const std::string &hyphen) const;
+ /** Only apply the first part, that is, up to and including the
+ * hyphen. */
+ void apply_first(std::string& word, const std::string &hyphen) const;
+ /** Only apply the second part, after the hyphen. */
+ int apply_second(std::string& word) const;
+
+ /** Returns true iff there is a priority value != 0 for this offset
+ * or a larger one. */
+ inline bool hasPriority(int offset) const
+ { return priorities.size() > offset; }
+ /** Returns the hyphenation priority for a hyphen preceding the byte
+ * at the given offset. */
+ inline char priority(int offset) const { return priorities[offset]; }
+
+ /** Returns the pattern to match for this rule to apply. */
+ inline std::string &getKey() { return key; }
+
+ /** Returns the amount of bytes that will additionally be needed
+ * in front of the hyphen if this rule is applied. 0 for standard
+ * hyphenation, 1 for Schiff-fahrt. */
+ int spaceNeededPreHyphen() const
+ { return insert_pre.size() - del_pre; }
+
+ /** Returns true iff this rule is not a standard hyphenation rule. */
+ bool isNonStandard() const
+ { return del_pre != 0 || skip_post != 0 ||
+ (!insert_pre.empty()) || (!insert_post.empty()); }
+
+ /** Only needed for libhnj implementation:
+ * Returns an malloc()-allocated char array consisting of the full
+ * replacement of this rule, with a = between the parts. For example,
+ * for Schiffahrt -> Schiff-fahrt this yields 'ff=' or 'ff=f',
+ * depending on implementation. */
+ std::auto_ptr<char> replacement_string() const;
+ /** Only needed for libhnj implementation:
+ * Get the offset at which the hyphen will end up compared to a
+ * standard rule. 0 for standard rules, Schiff-fahrt would yield 1. */
+ int getHyphenOffset() const { return insert_pre.size() - del_pre; }
+ /** Only needed for libhnj implementation:
+ * Returns the total number of bytes that need to be cut out
+ * before the replacement_string() should be inserted. */
+ int getTotalCutout() const { return skip_post + del_pre; }
+ };
+}
+
+#endif
|