001    /**
002     * Copyright (c) 2000-present Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portal.kernel.transaction;
016    
017    import com.liferay.portal.kernel.util.HashUtil;
018    import com.liferay.portal.kernel.util.StringBundler;
019    import com.liferay.portal.kernel.util.StringPool;
020    
021    import java.util.Arrays;
022    
023    /**
024     * @author Shuyang Zhou
025     */
026    public class TransactionConfig {
027    
028            @Override
029            public boolean equals(Object obj) {
030                    if (this == obj) {
031                            return true;
032                    }
033    
034                    if (!(obj instanceof TransactionConfig)) {
035                            return false;
036                    }
037    
038                    TransactionConfig transactionConfig = (TransactionConfig)obj;
039    
040                    if ((_isolation == transactionConfig._isolation) &&
041                            Arrays.equals(
042                                    _noRollbackForClassNames,
043                                    transactionConfig._noRollbackForClassNames) &&
044                            Arrays.equals(
045                                    _noRollbackForClasses,
046                                    transactionConfig._noRollbackForClasses) &&
047                            (_propagation == transactionConfig._propagation) &&
048                            (_readOnly == transactionConfig._readOnly) &&
049                            Arrays.equals(
050                                    _rollbackForClassNames,
051                                    transactionConfig._rollbackForClassNames) &&
052                            Arrays.equals(
053                                    _rollbackForClasses, transactionConfig._rollbackForClasses) &&
054                            (_timeout == transactionConfig._timeout)) {
055    
056                            return true;
057                    }
058    
059                    return false;
060            }
061    
062            public Isolation getIsolation() {
063                    return _isolation;
064            }
065    
066            public Class<?>[] getNoRollbackForClasses() {
067                    return _noRollbackForClasses;
068            }
069    
070            public String[] getNoRollbackForClassNames() {
071                    return _noRollbackForClassNames;
072            }
073    
074            public Propagation getPropagation() {
075                    return _propagation;
076            }
077    
078            public Class<?>[] getRollbackForClasses() {
079                    return _rollbackForClasses;
080            }
081    
082            public String[] getRollbackForClassNames() {
083                    return _rollbackForClassNames;
084            }
085    
086            public int getTimeout() {
087                    return _timeout;
088            }
089    
090            @Override
091            public int hashCode() {
092                    int hash = HashUtil.hash(0, _isolation);
093    
094                    if (_noRollbackForClassNames == null) {
095                            hash = HashUtil.hash(hash, 0);
096                    }
097                    else {
098                            for (String noRollbackForClassName : _noRollbackForClassNames) {
099                                    hash = HashUtil.hash(hash, noRollbackForClassName);
100                            }
101                    }
102    
103                    if (_noRollbackForClasses == null) {
104                            hash = HashUtil.hash(hash, 0);
105                    }
106                    else {
107                            for (Class<?> noRollbackForClass : _noRollbackForClasses) {
108                                    hash = HashUtil.hash(hash, noRollbackForClass);
109                            }
110                    }
111    
112                    hash = HashUtil.hash(hash, _propagation);
113    
114                    hash = HashUtil.hash(hash, _readOnly);
115    
116                    if (_rollbackForClassNames == null) {
117                            hash = HashUtil.hash(hash, 0);
118                    }
119                    else {
120                            for (String rollbackForClassName : _rollbackForClassNames) {
121                                    hash = HashUtil.hash(hash, rollbackForClassName);
122                            }
123                    }
124    
125                    if (_rollbackForClasses == null) {
126                            hash = HashUtil.hash(hash, 0);
127                    }
128                    else {
129                            for (Class<?> rollbackForClass : _rollbackForClasses) {
130                                    hash = HashUtil.hash(hash, rollbackForClass);
131                            }
132                    }
133    
134                    hash = HashUtil.hash(hash, _timeout);
135    
136                    return hash;
137            }
138    
139            public boolean isReadOnly() {
140                    return _readOnly;
141            }
142    
143            @Override
144            public String toString() {
145                    StringBundler sb = new StringBundler(17);
146    
147                    sb.append("{isolation=");
148                    sb.append(_isolation);
149                    sb.append(", noRollbackForClassNames=");
150                    sb.append(Arrays.toString(_noRollbackForClassNames));
151                    sb.append(", noRollbackForClasses=");
152                    sb.append(Arrays.toString(_noRollbackForClasses));
153                    sb.append(", propagation=");
154                    sb.append(_propagation);
155                    sb.append(", readOnly=");
156                    sb.append(_readOnly);
157                    sb.append(", rollbackForClassNames=");
158                    sb.append(Arrays.toString(_rollbackForClassNames));
159                    sb.append(", rollbackForClasses=");
160                    sb.append(Arrays.toString(_rollbackForClasses));
161                    sb.append(", timeout=");
162                    sb.append(_timeout);
163                    sb.append(StringPool.CLOSE_CURLY_BRACE);
164    
165                    return sb.toString();
166            }
167    
168            public static class Builder {
169    
170                    public TransactionConfig build() {
171                            return new TransactionConfig(this);
172                    }
173    
174                    public Builder setIsolation(Isolation isolation) {
175                            _isolation = isolation;
176    
177                            return this;
178                    }
179    
180                    public Builder setNoRollbackForClasses(
181                            Class<?>... noRollbackForClasses) {
182    
183                            _noRollbackForClasses = noRollbackForClasses;
184    
185                            return this;
186                    }
187    
188                    public Builder setNoRollbackForClassNames(
189                            String... noRollbackForClassNames) {
190    
191                            _noRollbackForClassNames = noRollbackForClassNames;
192    
193                            return this;
194                    }
195    
196                    public Builder setPropagation(Propagation propagation) {
197                            _propagation = propagation;
198    
199                            return this;
200                    }
201    
202                    public Builder setReadOnly(boolean readOnly) {
203                            _readOnly = readOnly;
204    
205                            return this;
206                    }
207    
208                    public Builder setRollbackForClasses(Class<?>... rollbackForClasses) {
209                            _rollbackForClasses = rollbackForClasses;
210    
211                            return this;
212                    }
213    
214                    public Builder setRollbackForClassNames(
215                            String... rollbackForClassNames) {
216    
217                            _rollbackForClassNames = rollbackForClassNames;
218    
219                            return this;
220                    }
221    
222                    public Builder setTimeout(int timeout) {
223                            _timeout = timeout;
224    
225                            return this;
226                    }
227    
228                    private static final Class<?>[] _emptyClassArray = new Class<?>[0];
229    
230                    private Isolation _isolation = Isolation.DEFAULT;
231                    private Class<?>[] _noRollbackForClasses = _emptyClassArray;
232                    private String[] _noRollbackForClassNames = StringPool.EMPTY_ARRAY;
233                    private Propagation _propagation = Propagation.REQUIRED;
234                    private boolean _readOnly;
235                    private Class<?>[] _rollbackForClasses = _emptyClassArray;
236                    private String[] _rollbackForClassNames = StringPool.EMPTY_ARRAY;
237                    private int _timeout = TransactionDefinition.TIMEOUT_DEFAULT;
238    
239            }
240    
241            public static class Factory {
242    
243                    public static TransactionConfig create(
244                            Isolation isolation, Propagation propagation, boolean readOnly,
245                            int timeout, Class<?>[] rollbackForClasses,
246                            String[] rollbackForClassNames, Class<?>[] noRollbackForClasses,
247                            String[] noRollbackForClassNames) {
248    
249                            Builder builder = new Builder();
250    
251                            builder.setIsolation(isolation);
252                            builder.setPropagation(propagation);
253                            builder.setReadOnly(readOnly);
254                            builder.setTimeout(timeout);
255                            builder.setRollbackForClasses(rollbackForClasses);
256                            builder.setRollbackForClassNames(rollbackForClassNames);
257                            builder.setNoRollbackForClasses(noRollbackForClasses);
258                            builder.setNoRollbackForClassNames(noRollbackForClassNames);
259    
260                            return builder.build();
261                    }
262    
263                    public static TransactionConfig create(
264                            Propagation propagation, Class<?>[] rollbackForClasses,
265                            Class<?>... noRollbackForClasses) {
266    
267                            return create(
268                                    Isolation.PORTAL, propagation, false, -1, rollbackForClasses,
269                                    new String[0], noRollbackForClasses, new String[0]);
270                    }
271    
272            }
273    
274            private TransactionConfig(Builder builder) {
275                    _isolation = builder._isolation;
276                    _noRollbackForClassNames = builder._noRollbackForClassNames;
277                    _noRollbackForClasses = builder._noRollbackForClasses;
278                    _propagation = builder._propagation;
279                    _readOnly = builder._readOnly;
280                    _rollbackForClassNames = builder._rollbackForClassNames;
281                    _rollbackForClasses = builder._rollbackForClasses;
282                    _timeout = builder._timeout;
283            }
284    
285            private final Isolation _isolation;
286            private final Class<?>[] _noRollbackForClasses;
287            private final String[] _noRollbackForClassNames;
288            private final Propagation _propagation;
289            private final boolean _readOnly;
290            private final Class<?>[] _rollbackForClasses;
291            private final String[] _rollbackForClassNames;
292            private final int _timeout;
293    
294    }