KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > de > webman > generator > SiteReference


1 package de.webman.generator;
2
3 import com.teamkonzept.lib.*;
4 import com.teamkonzept.webman.*;
5
6 import java.util.*;
7 import java.sql.*;
8 import org.apache.log4j.Category;
9
10 /**
11     Verwaltet eine Referenz-Praesentations-Componenten eines Dokuments
12  * @author $Author: alex $
13  * @version $Revision: 1.4 $
14 */
15 public class SiteReference
16 {
17
18     /**
19         Verweis zurück auf den aktuellen statischen Kontext des laufenden Threads
20     */
21     GeneratorContext context;
22
23     private static Category cat = Category.getInstance(SiteReference.class.getName());
24     
25     public final static int COMPONENT_TYPE_FREE = 1;
26     public final static int COMPONENT_TYPE_TYPED = 2;
27
28     public final static int INTEGRATION_TYPE_GROUP = 2;
29     public final static int INTEGRATION_TYPE_SINGLE = 3;
30     
31     public final static int REF_TYPE_ABSOLUTE = 1;
32     public final static int REF_TYPE_RELATIVE = 2;
33     
34     /** Das Dokument, dem das Objekt zugeordet ist */
35     public SiteDocument src;
36     
37     /** der Name der Presentation Component */
38     private String JavaDoc integrationShortName;
39     /** freie oder getypte Referenz */
40     private int componentType;
41     /** die Integrationsart (Single oder Group) */
42     private int integrationType;
43     /** absolute oder relative Referenz */
44     private int referenceType;
45     /** idx der Component in der Praesentation */
46     private int presentationIdx;
47     /**
48         Knoten, in dem das Ziel-Dokument liegt, bzw.
49         über den der Zielknoten referenziert wird
50     */
51     private SiteNode destNode;
52     /** Name des Zieldokuments */
53     private String JavaDoc destShortName;
54     /** Selektionsklasse */
55     private String JavaDoc selectionType;
56     /** Selektions-Daten */
57     private String JavaDoc selectionData;
58     
59     /**
60         beinhaltet bei relativen Referenzen den Abstand der Quelle zum Zielknoten
61         1 := Parent
62     */
63     private int relDist;
64
65     /**
66         beinhaltet die Liste der Zieldokumente
67         umstellen auf Vector ??
68     */
69     private SiteDocument[] dest;
70     
71     /**
72         beinhaltet bei getypten Referenzen den Namen der Dokumente, ueber die der Content
73         der Referenz geholt wird
74     */
75     private String JavaDoc destContentSource;
76     
77     
78     /**
79         Initialisiert das Objekt mit den Daten der aktuellen
80         ResultRow des ResultSet der Query DBGenSiteRefs
81         
82         dest wird erst durch den Aufruf von expand erzeugt
83         destContentSource wird erst durch den Aufruf von findMatchingContentSource erzeugt
84     */
85     public SiteReference( GeneratorContext context, ResultSet rs, SiteDocument doc )
86         throws SQLException
87     {
88         this.context = context != null ? context : GeneratorContext.setup ();
89
90         src = doc;
91         dest = null;
92     
93         integrationShortName = rs.getString( "INTEGRATION_SHORTNAME" );
94         componentType = rs.getInt( "COMPONENT_TYPE" );
95         integrationType = rs.getInt( "INTEGRATION_TYPE" );
96         referenceType = rs.getInt( "REFERENCE_TYPE" );
97         presentationIdx = rs.getInt( "PRESENTATION_COMPONENT_IDX" );
98         destNode = this.context.siteNodes.getNode( rs.getInt( "DEST_SITE_NODE_ID" ) );
99         destShortName = rs.getString( "DEST_SITE_NODE_DOC_SHORTNAME" );
100         selectionType = rs.getString( "SELECTION_TYPE" );
101         selectionData = rs.getString( "SELECTION_DATA" );
102         
103         if( referenceType == REF_TYPE_RELATIVE ) {
104             relDist = src.getAnchor().findDistance( destNode );
105         }
106     }
107     
108     /**
109         Erzeugt eine geclonte Site-Referenz aus einem anderen Dokument.
110         Dieser Konstruktur wird benötigt, wenn ein Dokument geclont wird
111         und die im ursprunglichen Dokument enthaltenen Referenzen im geclonten
112         Dokument auf die neue Umgebung angepasst werden muß.
113
114         dest wird erst durch den Aufruf von expand erzeugt
115         destContentSource wird erst durch den Aufruf von findMatchingContentSource erzeugt
116     */
117     public SiteReference( GeneratorContext context, SiteReference srcRef, SiteDocument doc )
118     {
119         this.context = context != null ? context : GeneratorContext.setup ();
120
121         this.src = doc;
122         dest = null;
123     
124         integrationShortName = srcRef.integrationShortName;
125         componentType = srcRef.componentType;
126         integrationType = srcRef.integrationType;
127         referenceType = srcRef.referenceType;
128         presentationIdx = srcRef.presentationIdx;
129         relDist = srcRef.relDist;
130         if( referenceType == REF_TYPE_RELATIVE ) {
131             destNode = doc.getAnchor();
132             for( int i=relDist; i-- > 0; ) {
133                 destNode = destNode.getParent();
134             }
135         }
136         else {
137             destNode = srcRef.destNode;
138         }
139         destShortName = srcRef.destShortName;
140         
141         selectionType = srcRef.selectionType;
142         selectionData = srcRef.selectionData;
143     }
144     
145     public String JavaDoc path()
146     {
147         return src.path()+"."+integrationShortName;
148     }
149     
150     public String JavaDoc getPath()
151     {
152         return src.getPath() + "/" + integrationShortName;
153     }
154     
155     
156     public String JavaDoc ctToString(int componentType) {
157
158         if (componentType == COMPONENT_TYPE_FREE) return "FREE";
159         if (componentType == COMPONENT_TYPE_TYPED) return "TYPED";
160
161         return "UNKNOWN";
162     }
163     
164     public String JavaDoc toString()
165     {
166
167         String JavaDoc result =
168             "<reference '"+path()+"'>"+
169             " componentType = "+ctToString(componentType)+
170             " integrationType = "+(integrationType==INTEGRATION_TYPE_GROUP?"GROUP":"SINGLE")+
171             " referenceType = "+(referenceType==REF_TYPE_ABSOLUTE?"ABSOLUTE":"RELATIVE")+
172             " presentationIdx = "+presentationIdx+
173             " destNode = "+destNode.path()+
174             " destShortName = "+destShortName+
175             " selectionType = "+selectionType+
176             "";
177         
178         if( dest != null ) {
179             result += " referenced Docs:";
180             for( int i=0; i<dest.length; i++ ) {
181                 result += " "+dest[i].path();
182             }
183         }
184         return result+" </reference '"+path()+"'> ";
185     }
186
187     /**
188         Expandiert die Referenz, d.h. ermittelt die Dokumente auf die
189         die Referenz verweisst. Die ermittelten Dokumente stehen anschliessend
190         im Array dest.
191         
192         Die Methode gewaehrleistet, dass alle Referenzen, die in den referenzierten
193         Dokumenten enthalten sind, ebenfalls expandiert sind.
194     */
195     public void expand()
196     {
197         if( dest != null )
198         {
199             return;
200         }
201         
202         // Zunaechst Liste der Zielknoten ermitteln
203 SiteNode[] destNodes = { destNode };
204         if( selectionType != null )
205         {
206             cat.debug( "["+context.siteReferences.getLevel()+"]"+"expand selection reference "+selectionType+" results: " );
207             TKVector tmp = TKWMReferenceSelectorReg.getNodes( selectionType, selectionData, destNode.getId() );
208             destNodes = new SiteNode[ tmp.size() ];
209             for( int i=0; i<destNodes.length; i++ )
210             {
211                 destNodes[i] = context.siteNodes.getNode( ((Integer JavaDoc)tmp.get(i)).intValue() );
212                 if (destNodes[i] != null)
213                     cat.debug( "["+context.siteReferences.getLevel()+"]"+" "+destNodes[i].getPath()+"."+destShortName+"," );
214             }
215         }
216         else {
217             cat.debug( "["+context.siteReferences.getLevel()+"]"+"expand regular reference to "+destNode.getPath()+"."+destShortName );
218         }
219         
220         // nimmt temporaer die Dokumente auf
221 Vector temp = new Vector();
222         
223         // Dann alle Zieldocumente holen
224 for( int i=0; i < destNodes.length; i++ )
225         {
226             SiteDocument doc = destNodes[i].getDocument( destShortName );
227             if (doc != null)
228                 temp.addElement(doc);
229              else
230              {
231                 cat.warn(
232                     "unmatched reference to document '"+destShortName
233                     +"' of node '"+destNodes[i].path()
234                     +"' in document '"+src.path()+"'"
235                 );
236             }
237         }
238         
239         // Feld fuer Ziel-Dokumente erzeugen
240 dest = new SiteDocument[ temp.size() ];
241         temp.copyInto(dest);
242         // Zuletzt dafuer sorgen, dass alle Referenzen in den Zieldokumenten
243 // expandiert sind
244 for( int i=0; i < dest.length; i++ ) {
245             try {
246                 if (dest[i] != null)
247                     dest[i].expandReferences();
248             }
249             catch( Throwable JavaDoc t ) {
250                 cat.warn("could not expand subreferences of referenced document "+dest[i].path(), t );
251             }
252         }
253         
254     }
255     
256     /**
257         Ermittelt die Quelle fuer den Referenz-Content bei getypten Referenzen. Dabei wird
258         nach einem Dokument gesucht, dessen Praesentation in der Listen der erlaubten
259         Praesentationen der Referenz enthalten ist.
260         
261         Im Normalfall wird dies das referenzierte Dokument selbst sein. Falls das
262         referenzierte Dokument jedoch ein Frameset ist, muß der Inhalt aus einem Dokument
263         kommen, daß wiederum vom referenzierten Dokument referenziert wird.
264         
265         Bei dieser Suche werden nur solche Dokumente beruecksichtigt, die im gleichen
266         Struktur-Knoten liegen.
267         
268         Der Name des Quell-Dokuments ist anschliessend in destContentSource enthalten.
269         
270         Bei Gruppenreferenzen muessen alle Referenz-Contents aus gleichbenannten Dokumenten
271         kommen, unabhaengig davon aus wieviel unterschiedlichen Struktur-Knoten die Dokumente
272         kommen. Die Ermittlung des Namens erfolgt deshalb bei Gruppenreferenzen nur anhand
273         einer willkuerlich gewaehlten Referenz der Gruppe.
274         
275         @returns ob die Quelle gefunden werden konnte, oder nicht notwendig war.
276             Bei Fehlern in der Referenzdefinition wird ein Error geworfen. Es gibt nur
277             einen Moeglichkeit, daß eine Quelle nicht gefunden werden konnten und es sich
278             um keinen Fehler handelt: Eine Gruppenreferenz verweist auf einen Gruppenknoten,
279             der keinen Eintrag hat.
280     */
281     public boolean findMatchingContentSource()
282     {
283         destContentSource = null;
284         
285         // freie Referenzen benoetigen keinen Content
286 if( componentType == COMPONENT_TYPE_FREE )
287         {
288             destContentSource = destShortName;
289             return true;
290         }
291         
292         // Gruppen-Referenzen koennen auf leere Gruppen verweissen
293 if( (integrationType == INTEGRATION_TYPE_GROUP) && (dest == null) || (dest.length == 0) )
294         {
295             return false;
296         }
297         
298         // Namensermittlung erfolgt immer anhand des ersten Ziels
299 // check auf null !!!!
300 SiteDocument destDoc = dest[0];
301         for (int count = 1; destDoc == null && count < dest.length; count++)
302             destDoc = dest[count];
303             
304         // Passt das referenzierte Dokument schon?
305 if( context.referenceTypes.isValidType(
306             src.getPresentationId(),
307             presentationIdx,
308             destDoc.getPresentationId ()
309         ) )
310         {
311             destContentSource = destShortName;
312             return true;
313         }
314         
315         // Subreferenzen verfolgen
316 SiteNode destNode = destDoc.getAnchor();
317         TKHashtable visitedDocs = new TKHashtable(); // enthaelt alle Dokumente die bereits besucht wurden
318 TKVector visitDocs = new TKVector(); // enthaelt alle Dokumente die noch besucht werden muessen
319 visitedDocs.put( destDoc, "!" );
320         visitDocs.addElement( destDoc ); // los gehts mit dem referenzierten Dokument
321 while( visitDocs.size() > 0 )
322         {
323             destDoc = (SiteDocument) visitDocs.firstElement();
324             visitDocs.removeElementAt(0);
325             cat.debug("checking references in document"+destDoc.path() );
326
327             // alle Referenzen des aktuellen Dokuments verfolgen
328 Enumeration e = destDoc.getReferences().elements();
329             while( e.hasMoreElements() )
330             {
331                 SiteReference theRef = (SiteReference) e.nextElement();
332                 if( theRef == null ) {
333                     throw new Error JavaDoc("got null reference in document "+destDoc.path() );
334                 }
335                 
336                 if( theRef.dest == null ) {
337                     throw new Error JavaDoc ("got null reference-destinations in reference "+theRef.integrationShortName+" of document "+destDoc.path() );
338                 }
339                 
340                 if( theRef.dest.length == 0 ) {
341                     cat.warn("got zero reference-destinations in reference "+theRef.integrationShortName+" of document "+destDoc.path() );
342                     continue;
343                 }
344                 
345                 SiteDocument refDoc = theRef.dest[0]; // Zieldokument holen
346
347                 // nur Zieldocument im gleichen Site-Knoten beachten
348 if( refDoc.getAnchor() == destNode )
349                 {
350                     // passt das Zieldokument zur gesuchten Praesentation?
351 if( context.referenceTypes.isValidType(
352                         src.getPresentationId(),
353                         presentationIdx,
354                         refDoc.getPresentationId()
355                     ) )
356                     {
357                         destContentSource = refDoc.getShortName();
358                         return true;
359                     }
360                     // Zieldokument ggf. fuer weiter Untersuchung merken
361 if( ! visitedDocs.containsKey( refDoc ) )
362                     {
363                         visitDocs.addElement( refDoc );
364                         visitedDocs.put( refDoc, "!" );
365                     }
366                 }
367             }
368         }
369         throw new Error JavaDoc( "no matching document for ref " +
370             integrationShortName + " of document " +
371             src.getShortName() + " in node " + destNode.getShortName() );
372     }
373     
374     /**
375         traegt sich mit dem eigenen Integration-Shortname in die uebergebene
376         Hashtable ein
377     */
378     public void addGenReference( TKHashtable result )
379     {
380         result.put( integrationShortName, this );
381     }
382     
383     public String JavaDoc getIntegrationShortName()
384     {
385         return integrationShortName;
386     }
387     
388     public SiteNode getDestinationNode()
389     {
390         return destNode;
391     }
392     
393     public SiteDocument[] getDestinationDocuments()
394     {
395         return dest;
396     }
397     
398     public String JavaDoc getDestinationShortName()
399     {
400         return destShortName;
401     }
402     
403     public int getComponentType()
404     {
405         return componentType;
406     }
407     
408     public String JavaDoc getSelectionType()
409     {
410         return selectionType;
411     }
412     
413     public String JavaDoc getSelectionData()
414     {
415         return selectionData;
416     }
417     
418     public int getIntegrationType()
419     {
420         return integrationType;
421     }
422     
423     public String JavaDoc getDestinationContentSource()
424     {
425         // findMatchingContentSource();
426 return destContentSource;
427     }
428 }
429
Popular Tags