2 * Copyright 2005-2011 the original author or authors.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
16 package org.wamblee.xmlrouter.impl;
18 import java.util.ArrayList;
19 import java.util.Collection;
20 import java.util.Collections;
21 import java.util.HashSet;
22 import java.util.LinkedHashMap;
23 import java.util.List;
26 import java.util.concurrent.atomic.AtomicLong;
28 import org.wamblee.xmlrouter.common.Id;
29 import org.wamblee.xmlrouter.config.Transformation;
31 public class Transformations {
33 private AtomicLong sequenceNumber;
34 private Map<Id<Transformation>, Transformation> transformations;
35 private List<String> vertices;
36 private TransformationPath[][] matrix;
38 private Map<String, List<TransformationPath>> sequences;
40 public Transformations() {
41 sequenceNumber = new AtomicLong(1);
42 transformations = new LinkedHashMap<Id<Transformation>, Transformation>();
43 vertices = new ArrayList<String>();
44 matrix = new TransformationPath[0][0];
47 public Id<Transformation> addTransformation(Transformation aTransformation) {
48 long seqno = sequenceNumber.getAndIncrement();
49 Id<Transformation> id = new Id<Transformation>(seqno);
50 transformations.put(id, new RobustTransformation(id, aTransformation));
51 computeTransformationSequences();
55 public Collection<String> getPossibleTargetTypes(String aType) {
56 int index = vertices.indexOf(aType);
57 Set<String> res = new HashSet<String>();
58 for (int j = 0; j < vertices.size(); j++) {
59 if (matrix[index][j] != null) {
60 String value = matrix[index][j].getToType();
72 * Gets the transformation path from A to B.
78 * @return Transformatkon path or null if not found.
80 public TransformationPath getPath(String aFrom, String aTo) {
81 int i = vertices.indexOf(aFrom);
83 if (aFrom.equals(aTo)) {
84 return new TransformationPath();
89 int j = vertices.indexOf(aTo);
96 private void computeTransformationSequences() {
97 vertices = new ArrayList<String>();
99 // Obtain possible starting points.
100 Set<String> v = new HashSet<String>();
101 for (Transformation transformation : transformations.values()) {
102 v.add(transformation.getFromType());
103 v.add(transformation.getToType());
108 matrix = new TransformationPath[vertices.size()][vertices.size()];
110 // Floyd's algorithm.
111 int nvertices = vertices.size();
112 for (int i = 0; i < nvertices; i++) {
113 matrix[i][i] = new TransformationPath();
115 for (Transformation transformation : transformations.values()) {
116 int from = vertices.indexOf(transformation.getFromType());
117 int to = vertices.indexOf(transformation.getToType());
118 TransformationPath path = new TransformationPath(transformation);
119 matrix[from][to] = path;
122 for (int k = 0; k < nvertices; k++) {
123 for (int i = 0; i < nvertices; i++) {
124 for (int j = 0; j < nvertices; j++) {
125 // if the path from i to j through k is shorter then the
126 // existing path then
128 int lij = getPathLength(i, j);
129 int lik = getPathLength(i, k);
130 int lkj = getPathLength(k, j);
131 if (lik + lkj < lij) {
132 matrix[i][j] = matrix[i][k].appendPath(matrix[k][j]);
139 private int getPathLength(int i, int j) {
140 // We use MAX_INT/3 as infinity. This ensures that the default integer
141 // comparison in Floyd's algorithm does not lead to overflow.
142 return matrix[i][j] == null ? Integer.MAX_VALUE / 3 : matrix[i][j]
146 public void removeTransformation(Id<Transformation> aId) {
147 transformations.remove(aId);
148 computeTransformationSequences();
151 public Collection<Id<Transformation>> getTransformations() {
152 return Collections.unmodifiableCollection(transformations.keySet());
155 public Transformation getTransformation(Id<Transformation> aId) {
156 return transformations.get(aId);
160 public String toString() {
161 StringBuffer buf = new StringBuffer();
162 buf.append("Transformations(");
163 int nvertices = vertices.size();
164 for (int i = 0; i < nvertices; i++) {
165 for (int j = 0; j < nvertices; j++) {
166 TransformationPath path = matrix[i][j];
168 buf.append(vertices.get(i));
170 buf.append(vertices.get(j));
178 return buf.toString();