001    /*
002     * Copyright (C) 2008-2010 by Holger Arndt
003     *
004     * This file is part of the Universal Java Matrix Package (UJMP).
005     * See the NOTICE file distributed with this work for additional
006     * information regarding copyright ownership and licensing.
007     *
008     * UJMP is free software; you can redistribute it and/or modify
009     * it under the terms of the GNU Lesser General Public License as
010     * published by the Free Software Foundation; either version 2
011     * of the License, or (at your option) any later version.
012     *
013     * UJMP is distributed in the hope that it will be useful,
014     * but WITHOUT ANY WARRANTY; without even the implied warranty of
015     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
016     * GNU Lesser General Public License for more details.
017     *
018     * You should have received a copy of the GNU Lesser General Public
019     * License along with UJMP; if not, write to the
020     * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
021     * Boston, MA  02110-1301  USA
022     */
023    
024    package org.ujmp.core.graphmatrix;
025    
026    import java.util.Collection;
027    import java.util.List;
028    
029    public interface GenericGraph<N, E> {
030    
031            public List<N> getNodeList();
032    
033            public boolean isDirected();
034    
035            public void setDirected(boolean directed);
036    
037            public Collection<E> getEdgeList();
038    
039            public E getEdgeValue(long nodeIndex1, long nodeIndex2);
040    
041            /**
042             * @holger Wuerde ich weglassen
043             * @deprecated
044             */
045            @Deprecated
046            public E getEdgeValue(N node1, N node2);
047    
048            /**
049             * @holger Methode macht keinen Sinn, da Kante nich erzeugt werden kann.
050             * @param node1
051             * @param node2
052             * @deprecated
053             */
054            @Deprecated
055            public void addEdge(N node1, N node2);
056    
057            /**
058             * @holger Methode macht keinen Sinn, da Kante nich erzeugt werden kann.
059             * @param nodeIndex1
060             * @param nodeIndex2
061             * @deprecated
062             */
063            @Deprecated
064            public void addEdge(long nodeIndex1, long nodeIndex2);
065    
066            /**
067             * @holger Methode macht keinen Sinn, da Kante nich erzeugt werden kann.
068             * @param node1
069             * @param node2
070             * @deprecated
071             */
072            @Deprecated
073            public void addDirectedEdge(N node1, N node2);
074    
075            /**
076             * @holger Methode macht keinen Sinn, da Kante nich erzeugt werden kann.
077             * @param nodeIndex1
078             * @param nodeIndex2
079             * @deprecated
080             */
081            @Deprecated
082            public void addDirectedEdge(long nodeIndex1, long nodeIndex2);
083    
084            /**
085             * @holger Wuerde ich weglassen
086             * @param edgeObject
087             * @param nodeIndex1
088             * @param nodeIndex2
089             * @deprecated
090             */
091            @Deprecated
092            public void setDirectedEdge(E edgeObject, long nodeIndex1, long nodeIndex2);
093    
094            public void setEdge(E edgeObject, long nodeIndex1, long nodeIndex2);
095    
096            /**
097             * @holger Wuerde ich weglassen
098             * @deprecated
099             */
100            @Deprecated
101            public void setDirectedEdge(E edgeObject, N node1, N node2);
102    
103            /**
104             * @holger Wuerde ich weglassen
105             * @deprecated
106             */
107            @Deprecated
108            public void setEdge(E edgeObject, N node1, N node2);
109    
110            public void setUndirectedEdge(E edgeObject, long nodeIndex1, long nodeIndex2);
111    
112            /**
113             * @holger Wuerde ich weglassen
114             * @deprecated
115             */
116            @Deprecated
117            public void setUndirectedEdge(E edgeObject, N node1, N node2);
118    
119            /**
120             * @holger Wuerde ich weglassen
121             * @deprecated
122             */
123            @Deprecated
124            public void addUndirectedEdge(N node1, N node2);
125    
126            /**
127             * @holger Wuerde ich weglassen
128             * @deprecated
129             */
130            @Deprecated
131            public void addUndirectedEdge(long nodeIndex1, long nodeIndex2);
132    
133            /**
134             * @holger Wuerde ich weglassen
135             * @deprecated
136             */
137            @Deprecated
138            public void removeDirectedEdge(long nodeIndex1, long nodeIndex2);
139    
140            public void removeEdge(long nodeIndex1, long nodeIndex2);
141    
142            /**
143             * @holger Wuerde ich weglassen
144             * @deprecated
145             */
146            @Deprecated
147            public void removeDirectedEdge(N node1, N node2);
148    
149            /**
150             * @holger Wuerde ich weglassen
151             * @deprecated
152             */
153            @Deprecated
154            public void removeEdge(N node1, N node2);
155    
156            public void removeUndirectedEdge(long nodeIndex1, long nodeIndex2);
157    
158            /**
159             * @holger Wuerde ich weglassen
160             * @deprecated
161             */
162            @Deprecated
163            public void removeUndirectedEdge(N node1, N node2);
164    
165            public N getNode(long index);
166    
167            public void addNode(N node);
168    
169            public void setNode(N node, long index);
170    
171            /**
172             * @holger Wuerde ich weglassen, es gibt ja addNode und setNode
173             * @deprecated
174             */
175            @Deprecated
176            public void insertNode(N node, long index);
177    
178            public void removeNode(N node);
179    
180            public void removeNode(long node);
181    
182            public boolean isConnected(long nodeIndex1, long nodeIndex2);
183    
184            /**
185             * @holger Wuerde ich weglassen
186             * @deprecated
187             */
188            @Deprecated
189            public boolean isConnected(N node1, N node2);
190    
191            public long getIndexOfNode(N node);
192    
193            public int getEdgeCount();
194    
195            public int getNodeCount();
196    
197            public int getChildCount(long nodeIndex);
198    
199            /**
200             * @holger Wuerde ich weglassen
201             * @deprecated
202             */
203            @Deprecated
204            public int getChildCount(N node);
205    
206            public int getParentCount(long nodeIndex);
207    
208            /**
209             * @holger Wuerde ich weglassen
210             * @deprecated
211             */
212            @Deprecated
213            public int getParentCount(N node);
214    
215            public int getDegree(long nodeIndex);
216    
217            /**
218             * @holger Wuerde ich weglassen
219             * @deprecated
220             */
221            @Deprecated
222            public int getDegree(N node);
223    
224            public List<N> getChildren(long nodeIndex);
225    
226            public List<Long> getChildIndices(long nodeIndex);
227    
228            /**
229             * @holger Wuerde ich weglassen
230             * @deprecated
231             */
232            @Deprecated
233            public List<Long> getChildIndices(N node);
234    
235            /**
236             * @holger Wuerde ich weglassen
237             * @deprecated
238             */
239            @Deprecated
240            public List<N> getChildren(N node);
241    
242            public List<N> getParents(long nodeIndex);
243    
244            /**
245             * @holger Wuerde ich weglassen
246             * @deprecated
247             */
248            @Deprecated
249            public List<N> getParents(N node);
250    
251            public List<Long> getParentIndices(long nodeIndex);
252    
253            /**
254             * @holger Wuerde ich weglassen
255             * @deprecated
256             */
257            @Deprecated
258            public List<Long> getParentIndices(N node);
259    
260            /**
261             * @holger Wuerde ich weglassen
262             * @deprecated
263             */
264            @Deprecated
265            public void addChild(N node, N child);
266    
267            /**
268             * @holger Wuerde ich weglassen
269             * @deprecated
270             */
271            @Deprecated
272            public void addChild(long nodeIndex, long childIndex);
273    
274            /**
275             * @holger Wuerde ich weglassen
276             * @deprecated
277             */
278            @Deprecated
279            public void addParent(N node, N parent);
280    
281            /**
282             * @holger Wuerde ich weglassen
283             * @deprecated
284             */
285            @Deprecated
286            public void addParent(long nodeIndex, long parentIndex);
287    
288    }