blob: 3d4acc3603120d2d56cdc9258b70a5d06e454786 [file] [log] [blame]
////////////////////////////////////////////////////////////////////////////////
//
// Licensed to the Apache Software Foundation (ASF) under one or more
// contributor license agreements. See the NOTICE file distributed with
// this work for additional information regarding copyright ownership.
// The ASF licenses this file to You under the Apache License, Version 2.0
// (the "License"); you may not use this file except in compliance with
// the License. You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
////////////////////////////////////////////////////////////////////////////////
package com.adobe.linguistics.spelling.core
{
import com.adobe.linguistics.spelling.core.container.HashTable;
import com.adobe.linguistics.spelling.core.env.InternalConstants;
import com.adobe.linguistics.spelling.core.utils.StringUtils;
import flash.utils.Dictionary;
public class SquigglyDictionary
{
private var _hashtbl:HashTable;
private var _forbiddenword:int;
private var _ignoredCharSet:String;
private var _flag_mode:int;
private var _languageCode:String;
public function SquigglyDictionary(attrMgr:LinguisticRule)
{
_hashtbl = new HashTable( true ); // useWeakReferences:Boolean = true
if ( !attrMgr) {
_forbiddenword = InternalConstants.FORBIDDENWORD;
_ignoredCharSet = null;
_flag_mode = InternalConstants.FLAG_CHAR;
_languageCode = null;
}
}
private function set forbiddenword(value:int ) :void {
this._forbiddenword = value;
}
public function get forbiddenword():int {
return this._forbiddenword;
}
private function set ignoredCharSet(value:String):void {
this._ignoredCharSet = value;
}
public function get ignoredCharSet():String {
return this._ignoredCharSet;
}
private function set flag_mode(value:int):void {
this._flag_mode = value;
}
public function get flag_mode():int {
return this._flag_mode;
}
private function set languageCode(value:String ) :void {
this._languageCode = value;
}
public function get languageCode():String {
return this._languageCode;
}
public function containsKey(key:String ):Boolean
{
return _hashtbl.containsKey(key );
}
public function getElement( key:String ):HashEntry {
var res:* = _hashtbl.getElement(key );
return (res is HashEntry) ? res:null;
// return _hashtbl.getElement(key );
}
public function put(key:String, affixString:String=null, description:String = null):Boolean {
return addWord( key, affixString, description );
}
public function get dictionary():Dictionary {
return this._hashtbl.hashMap;
}
public function filter( callback:Function, thisObject:* = null):Array {
var res:Array = new Array();
var index:int;
var dict:Dictionary = this._hashtbl.hashMap;
for ( var key:* in dict ) {
if ( callback( key, index, res ) ) {
res.push( key );
}
}
return (res.length == 0) ? null: res;
}
public function addWord( word:String, affix:String = null, desc:String = null ) :Boolean {
var res:Boolean = false;
if ( word == null ) return false;
var captype:int = StringUtils.getCapType(word);
if ( addWordWithAffix(word,affix,desc,false ) )
res = true;
addHiddenCapitalizedWord(word,captype, affix,desc);
return res;
}
private function addHiddenCapitalizedWord( word:String, captype:int, affix:String=null, desc:String=null ) :Boolean {
// add inner capitalized forms to handle the following allcap forms:
// Mixed caps: OpenOffice.org -> OPENOFFICE.ORG
// Allcaps with suffixes: CIA's -> CIA'S
if (((captype == InternalConstants.HUHCAP) || (captype == InternalConstants.HUHINITCAP) ||((captype == InternalConstants.ALLCAP) && (affix != null))) &&
!((affix != null) && HashEntry.TESTAFF(affix, _forbiddenword))) {
affix += String.fromCharCode(InternalConstants.ONLYUPCASEFLAG);
word = word.toLocaleLowerCase();
word = word.charAt(0).toLocaleUpperCase() + word.substr(1);
addWordWithAffix(word,affix,desc,true);
}
return true;
}
private function addWordWithAffix( word:String, affix:String, desc:String, onlyupcase:Boolean ):Boolean {
var upcasehomonym:Boolean = false;
if (_ignoredCharSet != null) {
word = StringUtils.removeIgnoredChars(word, _ignoredCharSet);
}
//ToDo: the following comment should be removed after we have complex-affix support.
//
// if (complexprefixes) {
// reverseword(word);
// }
// hp->var = H_OPT;
// if (aliasm) {
// hp->var += H_OPT_ALIASM;
// store_pointer(hpw + wbl + 1, get_aliasm(atoi(desc)));
// } else {
// strcpy(hpw + wbl + 1, desc);
// if (complexprefixes) {
// if (utf8) reverseword_utf(HENTRY_DATA(hp));
// else reverseword(HENTRY_DATA(hp));
// }
// }
// if (strstr(HENTRY_DATA(hp), MORPH_PHON)) hp->var += H_OPT_PHON;
if ( _hashtbl.containsKey(word) ) {
var hentry:HashEntry = _hashtbl.getElement(word);
while ( hentry.next != null ) {
// remove hidden onlyupcase homonym
if ( !onlyupcase ) {
if ( (hentry.affixFlagVector != null) && hentry.testAffix(InternalConstants.ONLYUPCASEFLAG) ) {
hentry.affixFlagVector = affix;
hentry.variableFields = desc; /* need a better implementation,refer the beginning of this function */
return true;
}
}else {
upcasehomonym = true;
}
hentry = hentry.next;
}
// remove hidden onlyupcase homonym
if ( !onlyupcase ) {
if ( (hentry.affixFlagVector != null) && hentry.testAffix(InternalConstants.ONLYUPCASEFLAG) ) {
hentry.affixFlagVector = affix;
hentry.variableFields = desc; /* need a better implementation,refer the beginning of this function */
return true;
}
}else {
upcasehomonym = true;
}
if ( !upcasehomonym ) {
hentry.addEntry(affix,desc);
return true;
}else
return false;
}else {
_hashtbl.put(word, new HashEntry(affix,desc) );
return true;
}
}
}
}