Revision 347

tmp/org.txm.para.core/.classpath (revision 347)
1
<?xml version="1.0" encoding="UTF-8"?>
2
<classpath>
3
	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>
4
	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
5
	<classpathentry kind="src" path="src"/>
6
	<classpathentry kind="output" path="bin"/>
7
</classpath>
0 8

  
tmp/org.txm.para.core/META-INF/MANIFEST.MF (revision 347)
1
Manifest-Version: 1.0
2
Bundle-ManifestVersion: 2
3
Bundle-Name: Core
4
Bundle-SymbolicName: org.txm.para.core
5
Bundle-Version: 1.0.0.qualifier
6
Bundle-Activator: org.txm.para.core.Activator
7
Require-Bundle: org.txm.core;bundle-version="0.7.0",
8
 org.eclipse.ui,
9
 org.eclipse.core.runtime
10
Bundle-RequiredExecutionEnvironment: JavaSE-1.6
11
Bundle-ActivationPolicy: lazy
12
Export-Package: org.txm.para.functions
0 13

  
tmp/org.txm.para.core/.project (revision 347)
1
<?xml version="1.0" encoding="UTF-8"?>
2
<projectDescription>
3
	<name>org.txm.para.core</name>
4
	<comment></comment>
5
	<projects>
6
	</projects>
7
	<buildSpec>
8
		<buildCommand>
9
			<name>org.eclipse.jdt.core.javabuilder</name>
10
			<arguments>
11
			</arguments>
12
		</buildCommand>
13
		<buildCommand>
14
			<name>org.eclipse.pde.ManifestBuilder</name>
15
			<arguments>
16
			</arguments>
17
		</buildCommand>
18
		<buildCommand>
19
			<name>org.eclipse.pde.SchemaBuilder</name>
20
			<arguments>
21
			</arguments>
22
		</buildCommand>
23
	</buildSpec>
24
	<natures>
25
		<nature>org.eclipse.pde.PluginNature</nature>
26
		<nature>org.eclipse.jdt.core.javanature</nature>
27
	</natures>
28
</projectDescription>
0 29

  
tmp/org.txm.para.core/src/org/txm/para/core/Activator.java (revision 347)
1
package org.txm.para.core;
2

  
3
import org.eclipse.ui.plugin.AbstractUIPlugin;
4
import org.osgi.framework.BundleContext;
5

  
6
/**
7
 * The activator class controls the plug-in life cycle
8
 */
9
public class Activator extends AbstractUIPlugin {
10

  
11
	// The plug-in ID
12
	public static final String PLUGIN_ID = "org.txm.para.core"; //$NON-NLS-1$
13

  
14
	// The shared instance
15
	private static Activator plugin;
16
	
17
	/**
18
	 * The constructor
19
	 */
20
	public Activator() {
21
	}
22

  
23
	/*
24
	 * (non-Javadoc)
25
	 * @see org.eclipse.ui.plugin.AbstractUIPlugin#start(org.osgi.framework.BundleContext)
26
	 */
27
	public void start(BundleContext context) throws Exception {
28
		super.start(context);
29
		plugin = this;
30
	}
31

  
32
	/*
33
	 * (non-Javadoc)
34
	 * @see org.eclipse.ui.plugin.AbstractUIPlugin#stop(org.osgi.framework.BundleContext)
35
	 */
36
	public void stop(BundleContext context) throws Exception {
37
		plugin = null;
38
		super.stop(context);
39
	}
40

  
41
	/**
42
	 * Returns the shared instance
43
	 *
44
	 * @return the shared instance
45
	 */
46
	public static Activator getDefault() {
47
		return plugin;
48
	}
49

  
50
}
0 51

  
tmp/org.txm.para.core/src/org/txm/para/functions/package.html (revision 347)
1
<html>
2
<body>
3
<p>Prototype of aligned edition browser</p>
4
</body>
5
</html>
0 6

  
tmp/org.txm.para.core/src/org/txm/para/functions/ParaCell.java (revision 347)
1
package org.txm.para.functions;
2

  
3
public class ParaCell {
4
	public String CCG, CCD, CG, keyword, CD, ref;
5
	public ParaCell(String CCG, String CG, String keyword, String CD, String CCD, String ref)
6
	{
7
		this.CCG = CCG;
8
		this.CG = CG;
9
		this.CD = CD;
10
		this.CCD = CCD;
11
		this.keyword = keyword;
12
		this.ref = ref;
13
	}
14
	/* (non-Javadoc)
15
	 * @see java.lang.Object#toString()
16
	 */
17
	@Override
18
	public String toString() {
19
		return ref + ": " + CCG + ">" + CG + "|" + keyword + "|" + CD + "<" + CCD; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
20
	}
21
}
0 22

  
tmp/org.txm.para.core/src/org/txm/para/functions/ParallelContexts.java (revision 347)
1
package org.txm.para.functions;
2

  
3
import groovy.lang.IntRange;
4

  
5
import java.io.IOException;
6
import java.util.ArrayList;
7
import java.util.Collections;
8
import java.util.HashMap;
9
import java.util.LinkedHashMap;
10
import java.util.List;
11

  
12
import org.txm.Toolbox;
13
import org.txm.searchengine.cqp.AbstractCqiClient;
14
import org.txm.searchengine.cqp.clientExceptions.CqiClientException;
15
import org.txm.searchengine.cqp.corpus.Corpus;
16
import org.txm.searchengine.cqp.corpus.CorpusManager;
17
import org.txm.searchengine.cqp.corpus.Property;
18
import org.txm.searchengine.cqp.corpus.QueryResult;
19
import org.txm.searchengine.cqp.corpus.StructuralUnitProperty;
20
import org.txm.searchengine.cqp.corpus.query.Match;
21
import org.txm.searchengine.cqp.corpus.query.Query;
22
import org.txm.searchengine.cqp.serverException.CqiServerError;
23

  
24
public class ParallelContexts {
25

  
26
	ArrayList<String> queries;
27
	String struct;
28
	ArrayList<Corpus> corpora; 
29
	ArrayList<String> props; 
30
	ArrayList<String> refs; 
31
	ArrayList<Integer> CGs;
32
	ArrayList<Integer> CDs;
33
	ArrayList<Boolean> participates;
34

  
35
	// TODO : manage 
36
	HashMap<String, Match[]> keywordsStartsEnds = new HashMap<String, Match[]>();
37
	HashMap<String, ParaCell[]> keywordsStrings = new HashMap<String, ParaCell[]>();
38
	ArrayList<String> segKeys;
39
	private String structprop;
40

  
41
	public ParallelContexts(ArrayList<String> queries, String struct, String structprop, ArrayList<Corpus> corpora, 
42
			ArrayList<String> props, ArrayList<String> refs, 
43
			ArrayList<Integer> CGs, ArrayList<Integer> CDs,
44
			ArrayList<Boolean> participates) throws CqiClientException, IOException, CqiServerError
45
			{
46
		this.queries = queries;
47
		this.corpora = corpora;
48
		this.struct = struct;
49
		this.structprop = structprop;
50
		this.props = props;
51
		this.refs = refs;
52
		this.CGs = CGs;
53
		this.CDs = CDs;
54
		this.participates = participates;
55

  
56
		for (int num = 0; num < corpora.size() ; num++) {
57
			if (!participates.get(num))
58
				continue;
59
			Corpus corpus = corpora.get(num);
60
			//String lang = corpus.getLang();
61
			String query = queries.get(num);
62
			System.out.println(corpus.getName()+" query: "+query);
63
			QueryResult result = corpus.query(new Query(query), "TMP", true);
64

  
65
			try {
66
				List<Match> matches = result.getMatches();
67
				int[] positions = result.getStarts();
68

  
69
				StructuralUnitProperty align_id = corpus.getStructuralUnit(struct).getProperty(structprop);
70
				System.out.println("struct: "+struct+" prop: "+structprop+" -> "+align_id);
71
				int[] struct_pos = Toolbox.getCqiClient().cpos2Struc(align_id.getQualifiedName(), positions);
72
				String[] struct_ids = Toolbox.getCqiClient().struc2Str(align_id.getQualifiedName(), struct_pos);
73

  
74
				// fill allsegments
75
				for (int i = 0 ; i < struct_ids.length ; i++) {
76
					String id = struct_ids[i];
77
					if (!keywordsStartsEnds.containsKey(id)) {
78
						keywordsStartsEnds.put(id, new Match[corpora.size()]);
79
						keywordsStrings.put(id, new ParaCell[corpora.size()]);
80
					}
81
					keywordsStartsEnds.get(id)[num] = matches.get(i); // take the first one
82
				}
83
			} catch(Exception e) {
84
				System.out.println("Result is NULL ! "+e.toString());
85
				org.txm.utils.logger.Log.printStackTrace(e);
86
			}	
87
		}
88

  
89
		//sort allsegments
90
		segKeys = new ArrayList<String>(keywordsStartsEnds.keySet());
91
		Collections.sort(segKeys);
92
		System.out.println("segKeys : "+segKeys.size());
93
			}
94

  
95
	/**
96
	 * @return the keywordsStartsEnds
97
	 */
98
	public HashMap<String, Match[]> getKeywordsStartsEnds() {
99
		return keywordsStartsEnds;
100
	}
101

  
102
	/**
103
	 * @return the keywordsStrings
104
	 * @throws CqiServerError 
105
	 * @throws IOException 
106
	 * @throws CqiClientException 
107
	 */
108
	public HashMap<String, ParaCell[]> getKeywordsStrings() throws CqiClientException, IOException, CqiServerError {
109
		return getKeywordsStrings(0, segKeys.size());
110
	}
111

  
112
	/**
113
	 * @return the keywordsStrings
114
	 * @throws CqiClientException 
115
	 * @throws CqiServerError 
116
	 * @throws IOException 
117
	 */
118
	public LinkedHashMap<String, ParaCell[]> getKeywordsStrings(int from, int to) throws CqiClientException, IOException, CqiServerError {
119
		if (from < 0 ) from = 0;
120
		if (to > segKeys.size()) to = segKeys.size();
121

  
122
		LinkedHashMap<String, ParaCell[]> rez = new LinkedHashMap<String, ParaCell[]>();
123
		getMissingValues(from, to);
124
		if (segKeys.size()>0) {
125
			for (int i = from ; i < to ; i++)
126
				rez.put(segKeys.get(i), keywordsStrings.get(segKeys.get(i)));
127
			//System.out.println("getKeywordsStrings [REZ="+rez+"]");
128
		} else {
129
			System.out.println("getKeywordsStrings - NO SEG KEYS !!");
130
		}
131

  
132
		return rez;
133
	}
134

  
135
	private void getMissingValues(int from , int to) throws CqiClientException, IOException, CqiServerError
136
	{
137
		AbstractCqiClient cqiClient = CorpusManager.getCorpusManager().getCqiClient();
138
		if (segKeys.size()>0){
139
			String segquery = "<"+struct+"_"+structprop+"=\""; //\"]";
140
			for (int i = from ; i < to ; i++) {
141
				segquery += segKeys.get(i)+"|";
142
			}
143
			segquery = segquery.substring(0, segquery.length() -1 );
144
			segquery += "\">[]";
145
			System.out.println("align_seg_query : "+segquery);
146

  
147
			// loop over corpus to minimize the number of queries
148
			for (int nocorpus = 0; nocorpus < corpora.size() ; nocorpus++) {
149
				Corpus corpus = corpora.get(nocorpus);
150
				int MAXPOSITION = corpus.getSize();
151
				StructuralUnitProperty align_id = corpus.getStructuralUnit(struct).getProperty(structprop);
152
				Property prop = corpus.getProperty(props.get(nocorpus));
153
				//PropertyHashMap<CqpDataProxy> proxies = CorpusManager.getCorpusManager().getCorpusProxies(corpus);
154
				int iCG = CGs.get(nocorpus);
155
				int iCD = CDs.get(nocorpus);
156
				//System.out.println("iCG "+iCG+" iCD "+iCD);
157
				//CqpDataProxy wordp = cqiClient.get(prop);
158
				String[] split = refs.get(nocorpus).split("_", 2);
159
				//System.out.println("refs : "+refs);
160
				StructuralUnitProperty ref = null;
161
				if (split.length == 2)
162
					ref = corpus.getStructuralUnit(split[0]).getProperty(split[1]);
163

  
164
				// get the seg that actually are in the corpus
165
				QueryResult resul2t = corpus.query(new Query(segquery), "TMP", true);
166
				int[] struct_starts = resul2t.getStarts();
167
				int[] struct_pos = Toolbox.getCqiClient().cpos2Struc(align_id.getQualifiedName(), struct_starts);
168
				String[] struct_ids = Toolbox.getCqiClient().struc2Str(align_id.getQualifiedName(), struct_pos);
169

  
170
				//System.out.println("segs: "+Arrays.toString(struct_ids));
171

  
172
				// get ref if asked
173
				String[] ref_values = null;
174
				if (ref != null) {
175
					int[] struct_pos2 = Toolbox.getCqiClient().cpos2Struc(ref.getQualifiedName(), struct_starts);
176
					ref_values = Toolbox.getCqiClient().struc2Str(ref.getQualifiedName(), struct_pos2);
177
				}
178
				//System.out.println("ref values: "+Arrays.toString(ref_values));
179

  
180
				// get the words values of segs
181
				QueryResult result = corpus.query(new Query(segquery+"+</"+struct+">"), "TMP", false);
182
				List<Match> matches = result.getMatches();
183
				//System.out.println("seg matches: "+matches);
184
				ArrayList<Integer> positions = new ArrayList<Integer>();
185
				for (Match m : matches) {
186
					groovy.lang.IntRange range = (IntRange) m.getRange();
187

  
188
					int minpos = range.get(0);
189
					int maxpos = range.get(range.size()-1);
190
					//System.out.println("range size "+range.size()+" minpos "+minpos+" maxpos "+maxpos);
191
					//int n = 0;
192
					for (int i = iCG ; i > 0 ; i--) {
193
						if (minpos - i >= 0) {
194
							positions.add(minpos - i);
195
							//System.out.println("CG add "+(minpos-i));
196
						}
197
					}
198
					positions.addAll(range);
199
					//System.out.println("add "+range);
200
					for (int i = 1 ; i <= iCD ; i++) {
201
						if (maxpos+i < MAXPOSITION) {
202
							positions.add(maxpos + i);
203
							//System.out.println("CD add "+(maxpos+i));
204
						}
205
					}
206
				}
207

  
208
				int[] cpos = new int[positions.size()];
209
				for (int i = 0 ; i < positions.size() ; i++)
210
					cpos[i] = positions.get(i);
211

  
212
				List<String> words = cqiClient.getSingleData(prop, cpos);
213
				//System.out.println("words: "+(words));
214

  
215
				int wordIterator = 0;
216
				//System.out.println("loop");
217
				for (int i = 0 ; i < struct_ids.length ; i++) // for each seg actually in the corpus
218
				{
219
					if (keywordsStrings.get(struct_ids[i])[nocorpus] != null)
220
						continue; // this cell has already been computed
221
					if (wordIterator >= words.size())
222
						break; // no more words to process
223
					Match m = matches.get(i);
224

  
225
					Match keyWordMatch = keywordsStartsEnds.get(struct_ids[i])[nocorpus];
226
					//System.out.println("wordIterator "+wordIterator+" str "+words.get(wordIterator)+ " str2 "+words.get(wordIterator+1)+" pos "+cpos[wordIterator]+" seg no "+i+" match "+m+" keyword "+keyWordMatch);
227
					//if ((m.getStart() - cpos[wordIterator]) < iCG) System.out.println("WARNING CG");
228
					String CCG="", CG ="", keyword="", CD="", CCD="", refValue = "";
229
					int state = 1; // 0 CCG, 1 CG 2 keyword 3 CD 4 CCD
230
					int previouspos = -1;
231
					while (wordIterator < cpos.length 
232
							&& cpos[wordIterator] <= m.getEnd() + iCD
233
							&& previouspos <= cpos[wordIterator])
234
					{ // concat word value
235
						int pos = cpos[wordIterator];
236
						previouspos = pos ;
237
						//if (keyWordMatch != null) {
238
						if (pos < m.getStart())
239
							state = 0;
240
						else if (keyWordMatch != null && pos < keyWordMatch.getStart())
241
							state = 1;
242
						else if (keyWordMatch != null && pos <= keyWordMatch.getEnd())
243
							state = 2;
244
						else if (pos <= m.getEnd())
245
							state = 3;
246
						else 
247
							state = 4;
248
						//}	
249
						switch (state) {
250
						case 0:
251
							CCG += words.get(wordIterator)+" "; break;
252
						case 1:
253
							CG += words.get(wordIterator)+" "; break;
254
						case 2:
255
							keyword += words.get(wordIterator)+" "; break;
256
						case 3:
257
							CD += words.get(wordIterator)+" "; break;
258
						case 4:
259
							CCD += words.get(wordIterator)+" "; break;
260
						}
261
						wordIterator++;
262
					}
263

  
264
					if (ref_values != null) {
265
						refValue = ref_values[i];
266
						//System.out.println("ref: "+refValue);
267
					}
268

  
269
					// set ParaCell
270
					ParaCell cell = new ParaCell(CCG, CG, keyword, CD, CCD, refValue);
271
					keywordsStrings.get(struct_ids[i])[nocorpus] = cell;
272
				}
273
			}
274
		}
275
	}
276

  
277
	/**
278
	 * @return the segKeys
279
	 */
280
	public ArrayList<String> getSegKeys() {
281
		return segKeys;
282
	}
283

  
284
	/**
285
	 * @return the queries
286
	 */
287
	public ArrayList<String> getQueries() {
288
		return queries;
289
	}
290

  
291
	/**
292
	 * @return the struct
293
	 */
294
	public String getStruct() {
295
		return struct;
296
	}
297

  
298
	/**
299
	 * @return the corpora
300
	 */
301
	public ArrayList<Corpus> getCorpora() {
302
		return corpora;
303
	}
304

  
305
	/**
306
	 * @return the props
307
	 */
308
	public ArrayList<String> getProps() {
309
		return props;
310
	}
311

  
312
	/**
313
	 * @return the refs
314
	 */
315
	public ArrayList<String> getRefs() {
316
		return refs;
317
	}
318

  
319
	/**
320
	 * @return the cGs
321
	 */
322
	public ArrayList<Integer> getCGs() {
323
		return CGs;
324
	}
325

  
326
	/**
327
	 * @return the cDs
328
	 */
329
	public ArrayList<Integer> getCDs() {
330
		return CDs;
331
	}
332

  
333
	/**
334
	 * @return the participates
335
	 */
336
	public ArrayList<Boolean> getParticipates() {
337
		return participates;
338
	}
339

  
340
	/* (non-Javadoc)
341
	 * @see java.lang.Object#hashCode()
342
	 */
343
	@Override
344
	public int hashCode() {
345
		final int prime = 31;
346
		int result = 1;
347
		result = prime * result + ((CDs == null) ? 0 : CDs.hashCode());
348
		result = prime * result + ((CGs == null) ? 0 : CGs.hashCode());
349
		result = prime * result + ((corpora == null) ? 0 : corpora.hashCode());
350
		result = prime * result
351
				+ ((participates == null) ? 0 : participates.hashCode());
352
		result = prime * result + ((props == null) ? 0 : props.hashCode());
353
		result = prime * result + ((queries == null) ? 0 : queries.hashCode());
354
		result = prime * result + ((refs == null) ? 0 : refs.hashCode());
355
		result = prime * result + ((struct == null) ? 0 : struct.hashCode());
356
		return result;
357
	}
358

  
359
	/* (non-Javadoc)
360
	 * @see java.lang.Object#equals(java.lang.Object)
361
	 */
362
	@Override
363
	public boolean equals(Object obj) {
364
		if (this == obj)
365
			return true;
366
		if (obj == null)
367
			return false;
368
		if (getClass() != obj.getClass())
369
			return false;
370
		ParallelContexts other = (ParallelContexts) obj;
371
		if (CDs == null) {
372
			if (other.CDs != null)
373
				return false;
374
		} else if (!CDs.equals(other.CDs))
375
			return false;
376
		if (CGs == null) {
377
			if (other.CGs != null)
378
				return false;
379
		} else if (!CGs.equals(other.CGs))
380
			return false;
381
		if (corpora == null) {
382
			if (other.corpora != null)
383
				return false;
384
		} else if (!corpora.equals(other.corpora))
385
			return false;
386
		if (participates == null) {
387
			if (other.participates != null)
388
				return false;
389
		} else if (!participates.equals(other.participates))
390
			return false;
391
		if (props == null) {
392
			if (other.props != null)
393
				return false;
394
		} else if (!props.equals(other.props))
395
			return false;
396
		if (queries == null) {
397
			if (other.queries != null)
398
				return false;
399
		} else if (!queries.equals(other.queries))
400
			return false;
401
		if (refs == null) {
402
			if (other.refs != null)
403
				return false;
404
		} else if (!refs.equals(other.refs))
405
			return false;
406
		if (struct == null) {
407
			if (other.struct != null)
408
				return false;
409
		} else if (!struct.equals(other.struct))
410
			return false;
411
		return true;
412
	}
413

  
414
	/* (non-Javadoc)
415
	 * @see java.lang.Object#toString()
416
	 */
417
	@Override
418
	public String toString() {
419
		return "ParallelContexts [queries=" + queries + ", struct=" + struct
420
				+ ", corpora=" + corpora + ", props=" + props + ", refs="
421
				+ refs + ", CGs=" + CGs + ", CDs=" + CDs + ", participates="
422
				+ participates + "]";
423
	}
424
}
0 425

  
tmp/org.txm.para.core/src/org/txm/para/functions/ParaBrowser.java (revision 347)
1
package org.txm.para.functions;
2

  
3
import java.util.ArrayList;
4
import java.util.HashMap;
5
import java.util.LinkedHashMap;
6
import java.util.List;
7
import java.util.Map;
8

  
9
import org.txm.core.results.TXMResult;
10
import org.txm.functions.ReferencePattern;
11
import org.txm.searchengine.cqp.CqpDataProxy;
12
import org.txm.searchengine.cqp.clientExceptions.CqiClientException;
13
import org.txm.searchengine.cqp.corpus.MainCorpus;
14
import org.txm.searchengine.cqp.corpus.Property;
15
import org.txm.searchengine.cqp.corpus.QueryResult;
16
import org.txm.searchengine.cqp.corpus.StructuralUnit;
17
import org.txm.searchengine.cqp.corpus.StructuralUnitProperty;
18
import org.txm.searchengine.cqp.corpus.query.Match;
19
import org.txm.searchengine.cqp.corpus.query.Query;
20
import org.txm.searchengine.cqp.corpus.query.QueryPart;
21
import org.txm.utils.Pair;
22
import org.txm.utils.i18n.LangFormater;
23

  
24
public class ParaBrowser extends TXMResult  {
25
	
26
	/**
27
	 * Gets the nextor previous.
28
	 *
29
	 * @param unit the unit
30
	 * @param property the property
31
	 * @param value the value
32
	 * @param isNext the is next
33
	 * @return the nextor previous
34
	 */
35
	public String getNextOrPrevious(MainCorpus corpus, StructuralUnit unit,
36
			StructuralUnitProperty property, String value, boolean isNext) {
37
		String next = "";
38
		Query query = null;
39
		System.out.println("GET NEXT or PREVIOUS : " + value + " unit " + unit
40
				+ " property " + property + " next? " + isNext);
41
		if (isNext) {
42
			query = new Query("<" + unit.getName() + "_id=\"" + value
43
					+ "\">[]+</" + unit.getName() + ">[]");
44
		} else {
45
			query = new Query("<" + unit.getName() + ">[]+" + "</"
46
					+ unit.getName() + "><" + unit.getName() + "_id=\"" + value
47
					+ "\">[]+");
48
		}
49
		Property text_id = unit.getProperty("id"); //$NON-NLS-1$
50
		// System.out.println("text_id = unit "+unit+" get props de id");
51
		// System.out.println("Query : "+query);
52
		if (property != null) {
53
//			List<Line> lines;
54
			int nLines;
55

  
56
			ReferencePattern referencePattern = new ReferencePattern();
57
			referencePattern.addProperty(text_id);
58
			
59
			QueryResult queryResult;
60
			try {
61
				Map<Property, List<List<String>>> wordPropValues = new HashMap<Property, List<List<String>>>();
62

  
63
				queryResult = corpus.query(query, query.getQueryString().replace(
64
						" ", "_")
65
						+ "_parallel", false);
66
				nLines = queryResult.getNMatch(); // get number of tokens
67
				// System.out.println("nLines : "+nLines);
68
//				lines = new ArrayList<Line>();
69

  
70
				List<Match> matches = null;
71
				if (nLines > 0)
72
					matches = queryResult.getMatches(0, nLines - 1); // get the
73
				// indexes
74
				// sequences
75
				// of
76
				// result's
77
				// tokens
78
				else
79
					matches = new ArrayList<Match>();
80

  
81
				List<Integer> beginingOfKeywordsPositions = new ArrayList<Integer>();
82
				List<Integer> lengthOfKeywords = new ArrayList<Integer>();
83
				// keywordsViewPropValues = new HashMap<Property,
84
				// List<List<String>>>();
85
				int nb = 0;
86
				for (int j = 0; j < nLines; j++) {
87
					Match match = matches.get(j);
88
					beginingOfKeywordsPositions.add(match.getStart()); // get
89
					// the first
90
					// index
91
					lengthOfKeywords.add(match.getEnd() - match.getStart() + 1);// get
92
					// the last index
93
					nb = match.getEnd() - match.getStart() + 1;
94
				}
95

  
96
				if (!isNext) {
97
					nb = 1;
98
				}
99

  
100
				// get all reference values of all lines
101
				for (Property prop : referencePattern) {
102
//					List<List<String>> propVals = cache.get(prop).getData(
103
//							beginingOfKeywordsPositions,
104
//							Collections.nCopies(beginingOfKeywordsPositions
105
//									.size(), nb));
106
//					// for the first word = 1
107
//					// for the last word = nb
108
//
109
//					for (List<String> propVal : propVals) {
110
//						for (String str : propVal) {
111
//							// System.out.println("Next  = "+str);
112
//							next = str;
113
//						}
114
//					}
115
				}
116

  
117
			} catch (CqiClientException e1) {
118
				org.txm.utils.logger.Log.printStackTrace(e1);
119
			}
120
		}
121
		return next;
122
	}
123
	
124
	
125
	/**
126
	 * Gets the text region.
127
	 *
128
	 * @param unit the unit
129
	 * @param property the property
130
	 * @param value the value
131
	 * @return the text region
132
	 */
133
	public Pair<String, QueryResult> getTextRegion(MainCorpus corpus, StructuralUnit unit,
134
			StructuralUnitProperty property, String value) {
135
		Query query = new QueryPart(unit, property, value);
136
		System.out.println("GET REGION : " + value);
137

  
138
		String text = "";
139

  
140
		if (property != null) {
141
			LinkedHashMap<String, Integer> counts;
142
//			List<Line> lines;
143
			int nLines;
144

  
145
			CqpDataProxy cache;
146
			try {
147
				cache = new CqpDataProxy(null, corpus.getProperty("word")); // TODO: not null
148
			} catch (CqiClientException e1) {
149
				org.txm.utils.logger.Log.printStackTrace(e1);
150
				return new Pair<String, QueryResult>(
151
						"error can't get word property", null);
152
			}
153

  
154
			// get the cqp result of the query
155
			QueryResult result;
156
			try {
157
				result = corpus.query(query, query.getQueryString().replace(" ",
158
						"_")
159
						+ "_parallel", false);
160
				nLines = result.getNMatch(); // get number of tokens
161
				System.out.println("nMatchs : " + nLines);
162
//				lines = new ArrayList<Line>();
163

  
164
				List<Match> matches = null;
165
				if (nLines > 0)
166
					matches = result.getMatches(0, nLines - 1); // get the
167
				// indexes
168
				// sequences of
169
				// result's
170
				// tokens
171
				else
172
					matches = new ArrayList<Match>();
173

  
174
				List<Integer> beginingOfKeywordsPositions = new ArrayList<Integer>();
175
				List<Integer> lengthOfKeywords = new ArrayList<Integer>();
176
				// keywordsViewPropValues = new HashMap<Property,
177
				// List<List<String>>>();
178

  
179
				for (int j = 0; j < nLines; j++) {
180
					Match match = matches.get(j);
181
					beginingOfKeywordsPositions.add(match.getStart()); // get
182
					// the
183
					// first
184
					// index
185
					lengthOfKeywords.add(match.getEnd() - match.getStart() + 1);// get
186
					// the
187
					// last
188
					// index
189
				}
190

  
191
				List<List<String>> propVals = cache.getData(
192
						beginingOfKeywordsPositions, lengthOfKeywords);
193
				for (List<String> prop : propVals) {
194
					text += "\n\n";
195
					for (String str : prop) {
196
						text += str + " ";
197
						// System.out.println("Region word = "+str);
198
					}
199
				}
200
			} catch (CqiClientException e) {
201
				org.txm.utils.logger.Log.printStackTrace(e);
202
				return new Pair<String, QueryResult>("error", null);
203
			} 
204
			return new Pair<String, QueryResult>(LangFormater.format(text, corpus
205
					.getAttribute("lang")), result);
206
		}
207
		// return keywordsViewPropValues;
208
		return new Pair<String, QueryResult>("error no property", null);
209
	}
210

  
211

  
212
	@Override
213
	public String getName() {
214
		// TODO Auto-generated method stub
215
		return null;
216
	}
217

  
218

  
219
	@Override
220
	public String getSimpleName() {
221
		// TODO Auto-generated method stub
222
		return null;
223
	}
224

  
225

  
226
	@Override
227
	public String getDetails() {
228
		// TODO Auto-generated method stub
229
		return null;
230
	}
231

  
232

  
233
	@Override
234
	public void clean() {
235
		// TODO Auto-generated method stub
236
		
237
	}
238
}
0 239

  
tmp/org.txm.para.core/build.properties (revision 347)
1
source.. = src/
2
output.. = bin/
3
bin.includes = META-INF/,\
4
               .
0 5

  
tmp/org.txm.para.core/.settings/org.eclipse.jdt.core.prefs (revision 347)
1
eclipse.preferences.version=1
2
org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
3
org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6
4
org.eclipse.jdt.core.compiler.compliance=1.6
5
org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
6
org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
7
org.eclipse.jdt.core.compiler.source=1.6
0 8

  

Also available in: Unified diff