~slub.team/goobi-indexserver/3.x

* @deprecated (3.4) use {@link SynonymFilterFactory} instead. only for precise index backwards compatibility. this factory will be removed in Lucene 5.0

@Deprecated

class SlowSynonymMap {

/** @lucene.internal */

public CharArrayMap<SlowSynonymMap> submap; // recursive: Map<String, SynonymMap>

/** @lucene.internal */

public Token[] synonyms;

int flags;

static final int INCLUDE_ORIG=0x01;

static final int IGNORE_CASE=0x02;

public SlowSynonymMap() {}

public SlowSynonymMap(boolean ignoreCase) {

if (ignoreCase) flags |= IGNORE_CASE;

}

public boolean includeOrig() { return (flags & INCLUDE_ORIG) != 0; }

public boolean ignoreCase() { return (flags & IGNORE_CASE) != 0; }

/**

* @param singleMatch List<String>, the sequence of strings to match

* @param replacement List<Token> the list of tokens to use on a match

* @param includeOrig sets a flag on this mapping signaling the generation of matched tokens in addition to the replacement tokens

* @param mergeExisting merge the replacement tokens with any other mappings that exist

public void add(List<String> singleMatch, List<Token> replacement, boolean includeOrig, boolean mergeExisting) {

SlowSynonymMap currMap = this;

for (String str : singleMatch) {

if (currMap.submap==null) {

// for now hardcode at 2.9, as its what the old code did.

// would be nice to fix, but shouldn't store a version in each submap!!!

currMap.submap = new CharArrayMap<SlowSynonymMap>(Version.LUCENE_29, 1, ignoreCase());

}

SlowSynonymMap map = currMap.submap.get(str);

if (map==null) {

map = new SlowSynonymMap();

map.flags |= flags & IGNORE_CASE;

currMap.submap.put(str, map);

}

currMap = map;

}

if (currMap.synonyms != null && !mergeExisting) {

throw new RuntimeException("SynonymFilter: there is already a mapping for " + singleMatch);

}

List<Token> superset = currMap.synonyms==null ? replacement :

mergeTokens(Arrays.asList(currMap.synonyms), replacement);

currMap.synonyms = superset.toArray(new Token[superset.size()]);

if (includeOrig) currMap.flags |= INCLUDE_ORIG;

}

@Override

public String toString() {

StringBuilder sb = new StringBuilder("<");

if (synonyms!=null) {

sb.append("[");

for (int i=0; i<synonyms.length; i++) {

if (i!=0) sb.append(',');

sb.append(synonyms[i]);

}

if ((flags & INCLUDE_ORIG)!=0) {

sb.append(",ORIG");

}

sb.append("],");

}

sb.append(submap);

sb.append(">");

return sb.toString();

100

}

101

102

103

104

/** Produces a List<Token> from a List<String> */

105

public static List<Token> makeTokens(List<String> strings) {

106

List<Token> ret = new ArrayList<Token>(strings.size());

107

for (String str : strings) {

108

//Token newTok = new Token(str,0,0,"SYNONYM");

109

Token newTok = new Token(str, 0,0,"SYNONYM");

110

ret.add(newTok);

111

}

112

return ret;

113

}

114

115

116

/**

117

* Merge two lists of tokens, producing a single list with manipulated positionIncrements so that

118

* the tokens end up at the same position.

119

120

* Example: [a b] merged with [c d] produces [a/b c/d] ('/' denotes tokens in the same position)

121

* Example: [a,5 b,2] merged with [c d,4 e,4] produces [c a,5/d b,2 e,2] (a,n means a has posInc=n)

122

123

124

public static List<Token> mergeTokens(List<Token> lst1, List<Token> lst2) {

125

ArrayList<Token> result = new ArrayList<Token>();

126

if (lst1 ==null || lst2 ==null) {

127

if (lst2 != null) result.addAll(lst2);

128

if (lst1 != null) result.addAll(lst1);

129

return result;

130

}

131

132

int pos=0;

133

Iterator<Token> iter1=lst1.iterator();

134

Iterator<Token> iter2=lst2.iterator();

135

Token tok1 = iter1.hasNext() ? iter1.next() : null;

136

Token tok2 = iter2.hasNext() ? iter2.next() : null;

137

int pos1 = tok1!=null ? tok1.getPositionIncrement() : 0;

138

int pos2 = tok2!=null ? tok2.getPositionIncrement() : 0;

139

while(tok1!=null || tok2!=null) {

140

while (tok1 != null && (pos1 <= pos2 || tok2==null)) {

141

Token tok = new Token(tok1.startOffset(), tok1.endOffset(), tok1.type());

142

tok.copyBuffer(tok1.buffer(), 0, tok1.length());

143

tok.setPositionIncrement(pos1-pos);

144

result.add(tok);

145

pos=pos1;

146

tok1 = iter1.hasNext() ? iter1.next() : null;

147

pos1 += tok1!=null ? tok1.getPositionIncrement() : 0;

148

}

149

while (tok2 != null && (pos2 <= pos1 || tok1==null)) {

150

Token tok = new Token(tok2.startOffset(), tok2.endOffset(), tok2.type());

151

tok.copyBuffer(tok2.buffer(), 0, tok2.length());

152

tok.setPositionIncrement(pos2-pos);

153

result.add(tok);

154

pos=pos2;

155

tok2 = iter2.hasNext() ? iter2.next() : null;

156

pos2 += tok2!=null ? tok2.getPositionIncrement() : 0;

157

}

158

}

159

return result;

160

}

161

162

}

Older »