001    /**
002     * Copyright (c) 2000-2012 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.portlet.expando.model.impl;
016    
017    import com.liferay.portal.kernel.exception.PortalException;
018    import com.liferay.portal.kernel.exception.SystemException;
019    import com.liferay.portal.kernel.util.GetterUtil;
020    import com.liferay.portal.kernel.util.StringBundler;
021    import com.liferay.portal.kernel.util.StringPool;
022    import com.liferay.portal.kernel.util.StringUtil;
023    import com.liferay.portlet.expando.ValueDataException;
024    import com.liferay.portlet.expando.model.ExpandoColumn;
025    import com.liferay.portlet.expando.model.ExpandoColumnConstants;
026    import com.liferay.portlet.expando.service.ExpandoColumnLocalServiceUtil;
027    
028    import java.io.Serializable;
029    
030    import java.util.Date;
031    
032    /**
033     * @author Raymond Augé
034     * @author Brian Wing Shun Chan
035     */
036    public class ExpandoValueImpl extends ExpandoValueBaseImpl {
037    
038            public ExpandoValueImpl() {
039            }
040    
041            public boolean getBoolean() throws PortalException, SystemException {
042                    validate(ExpandoColumnConstants.BOOLEAN);
043    
044                    return GetterUtil.getBoolean(getData());
045            }
046    
047            public boolean[] getBooleanArray() throws PortalException, SystemException {
048                    validate(ExpandoColumnConstants.BOOLEAN_ARRAY);
049    
050                    return GetterUtil.getBooleanValues(StringUtil.split(getData()));
051            }
052    
053            public ExpandoColumn getColumn() throws PortalException, SystemException {
054                    if (_column != null) {
055                            return _column;
056                    }
057    
058                    long columnId = getColumnId();
059    
060                    if (columnId <= 0) {
061                            return null;
062                    }
063    
064                    return ExpandoColumnLocalServiceUtil.getColumn(columnId);
065            }
066    
067            public Date getDate() throws PortalException, SystemException {
068                    validate(ExpandoColumnConstants.DATE);
069    
070                    return new Date(GetterUtil.getLong(getData()));
071            }
072    
073            public Date[] getDateArray() throws PortalException, SystemException {
074                    validate(ExpandoColumnConstants.DATE_ARRAY);
075    
076                    String[] data = StringUtil.split(getData());
077    
078                    Date[] dateArray = new Date[data.length];
079    
080                    for (int i = 0; i < data.length; i++) {
081                            dateArray[i] = new Date(GetterUtil.getLong(data[i]));
082                    }
083    
084                    return dateArray;
085            }
086    
087            public double getDouble() throws PortalException, SystemException {
088                    validate(ExpandoColumnConstants.DOUBLE);
089    
090                    return GetterUtil.getDouble(getData());
091            }
092    
093            public double[] getDoubleArray() throws PortalException, SystemException {
094                    validate(ExpandoColumnConstants.DOUBLE_ARRAY);
095    
096                    return GetterUtil.getDoubleValues(StringUtil.split(getData()));
097            }
098    
099            public float getFloat() throws PortalException, SystemException {
100                    validate(ExpandoColumnConstants.FLOAT);
101    
102                    return GetterUtil.getFloat(getData());
103            }
104    
105            public float[] getFloatArray() throws PortalException, SystemException {
106                    validate(ExpandoColumnConstants.FLOAT_ARRAY);
107    
108                    return GetterUtil.getFloatValues(StringUtil.split(getData()));
109            }
110    
111            public int getInteger() throws PortalException, SystemException {
112                    validate(ExpandoColumnConstants.INTEGER);
113    
114                    return GetterUtil.getInteger(getData());
115            }
116    
117            public int[] getIntegerArray() throws PortalException, SystemException {
118                    validate(ExpandoColumnConstants.INTEGER_ARRAY);
119    
120                    return GetterUtil.getIntegerValues(StringUtil.split(getData()));
121            }
122    
123            public long getLong() throws PortalException, SystemException {
124                    validate(ExpandoColumnConstants.LONG);
125    
126                    return GetterUtil.getLong(getData());
127            }
128    
129            public long[] getLongArray() throws PortalException, SystemException {
130                    validate(ExpandoColumnConstants.LONG_ARRAY);
131    
132                    return GetterUtil.getLongValues(StringUtil.split(getData()));
133            }
134    
135            public Serializable getSerializable()
136                    throws PortalException, SystemException {
137    
138                    ExpandoColumn column = getColumn();
139    
140                    int type = column.getType();
141    
142                    if (type == ExpandoColumnConstants.BOOLEAN) {
143                            return getBoolean();
144                    }
145                    else if (type == ExpandoColumnConstants.BOOLEAN_ARRAY) {
146                            return getBooleanArray();
147                    }
148                    else if (type == ExpandoColumnConstants.DATE) {
149                            return getDate();
150                    }
151                    else if (type == ExpandoColumnConstants.DATE_ARRAY) {
152                            return getDateArray();
153                    }
154                    else if (type == ExpandoColumnConstants.DOUBLE) {
155                            return getDouble();
156                    }
157                    else if (type == ExpandoColumnConstants.DOUBLE_ARRAY) {
158                            return getDoubleArray();
159                    }
160                    else if (type == ExpandoColumnConstants.FLOAT) {
161                            return getFloat();
162                    }
163                    else if (type == ExpandoColumnConstants.FLOAT_ARRAY) {
164                            return getFloatArray();
165                    }
166                    else if (type == ExpandoColumnConstants.INTEGER) {
167                            return getInteger();
168                    }
169                    else if (type == ExpandoColumnConstants.INTEGER_ARRAY) {
170                            return getIntegerArray();
171                    }
172                    else if (type == ExpandoColumnConstants.LONG) {
173                            return getLong();
174                    }
175                    else if (type == ExpandoColumnConstants.LONG_ARRAY) {
176                            return getLongArray();
177                    }
178                    else if (type == ExpandoColumnConstants.SHORT) {
179                            return getShort();
180                    }
181                    else if (type == ExpandoColumnConstants.SHORT_ARRAY) {
182                            return getShortArray();
183                    }
184                    else if (type == ExpandoColumnConstants.STRING_ARRAY) {
185                            return getStringArray();
186                    }
187                    else {
188                            return getData();
189                    }
190            }
191    
192            public short getShort() throws PortalException, SystemException {
193                    validate(ExpandoColumnConstants.SHORT);
194    
195                    return GetterUtil.getShort(getData());
196            }
197    
198            public short[] getShortArray() throws PortalException, SystemException {
199                    validate(ExpandoColumnConstants.SHORT_ARRAY);
200    
201                    return GetterUtil.getShortValues(StringUtil.split(getData()));
202            }
203    
204            public String getString() throws PortalException, SystemException {
205                    validate(ExpandoColumnConstants.STRING);
206    
207                    return getData();
208            }
209    
210            public String[] getStringArray() throws PortalException, SystemException {
211                    validate(ExpandoColumnConstants.STRING_ARRAY);
212    
213                    String[] dataArray = StringUtil.split(getData());
214    
215                    for (int i = 0; i < dataArray.length; i++) {
216                            dataArray[i] = StringUtil.replace(
217                                    dataArray[i], _EXPANDO_COMMA, StringPool.COMMA);
218                    }
219    
220                    return dataArray;
221            }
222    
223            public void setBoolean(boolean data)
224                    throws PortalException, SystemException {
225    
226                    validate(ExpandoColumnConstants.BOOLEAN);
227    
228                    setData(String.valueOf(data));
229            }
230    
231            public void setBooleanArray(boolean[] data)
232                    throws PortalException, SystemException {
233    
234                    validate(ExpandoColumnConstants.BOOLEAN_ARRAY);
235    
236                    setData(StringUtil.merge(data));
237            }
238    
239            public void setColumn(ExpandoColumn column) {
240                    _column = column;
241    
242                    setColumnId(_column.getColumnId());
243            }
244    
245            public void setDate(Date data) throws PortalException, SystemException {
246                    validate(ExpandoColumnConstants.DATE);
247    
248                    setData(String.valueOf(data.getTime()));
249            }
250    
251            public void setDateArray(Date[] data)
252                    throws PortalException, SystemException {
253    
254                    validate(ExpandoColumnConstants.DATE_ARRAY);
255    
256                    setData(StringUtil.merge(data));
257            }
258    
259            public void setDouble(double data) throws PortalException, SystemException {
260                    validate(ExpandoColumnConstants.DOUBLE);
261    
262                    setData(String.valueOf(data));
263            }
264    
265            public void setDoubleArray(double[] data)
266                    throws PortalException, SystemException {
267    
268                    validate(ExpandoColumnConstants.DOUBLE_ARRAY);
269    
270                    setData(StringUtil.merge(data));
271            }
272    
273            public void setFloat(float data) throws PortalException, SystemException {
274                    validate(ExpandoColumnConstants.FLOAT);
275    
276                    setData(String.valueOf(data));
277            }
278    
279            public void setFloatArray(float[] data)
280                    throws PortalException, SystemException {
281    
282                    validate(ExpandoColumnConstants.FLOAT_ARRAY);
283    
284                    setData(StringUtil.merge(data));
285            }
286    
287            public void setInteger(int data) throws PortalException, SystemException {
288                    validate(ExpandoColumnConstants.INTEGER);
289    
290                    setData(String.valueOf(data));
291            }
292    
293            public void setIntegerArray(int[] data)
294                    throws PortalException, SystemException {
295    
296                    validate(ExpandoColumnConstants.INTEGER_ARRAY);
297    
298                    setData(StringUtil.merge(data));
299            }
300    
301            public void setLong(long data) throws PortalException, SystemException {
302                    validate(ExpandoColumnConstants.LONG);
303    
304                    setData(String.valueOf(data));
305            }
306    
307            public void setLongArray(long[] data)
308                    throws PortalException, SystemException {
309    
310                    validate(ExpandoColumnConstants.LONG_ARRAY);
311    
312                    setData(StringUtil.merge(data));
313            }
314    
315            public void setNumber(Number data)
316                    throws PortalException, SystemException {
317    
318                    validate(ExpandoColumnConstants.NUMBER);
319    
320                    setData(String.valueOf(data));
321            }
322    
323            public void setNumberArray(Number[] data)
324                    throws PortalException, SystemException {
325    
326                    validate(ExpandoColumnConstants.NUMBER_ARRAY);
327    
328                    setData(StringUtil.merge(data));
329            }
330    
331            public void setShort(short data) throws PortalException, SystemException {
332                    validate(ExpandoColumnConstants.SHORT);
333    
334                    setData(String.valueOf(data));
335            }
336    
337            public void setShortArray(short[] data)
338                    throws PortalException, SystemException {
339    
340                    validate(ExpandoColumnConstants.SHORT_ARRAY);
341    
342                    setData(StringUtil.merge(data));
343            }
344    
345            public void setString(String data) throws PortalException, SystemException {
346                    validate(ExpandoColumnConstants.STRING);
347    
348                    setData(data);
349            }
350    
351            public void setStringArray(String[] data)
352                    throws PortalException, SystemException {
353    
354                    validate(ExpandoColumnConstants.STRING_ARRAY);
355    
356                    if (data != null) {
357                            for (int i = 0; i < data.length; i++) {
358                                    data[i] = StringUtil.replace(
359                                            data[i], StringPool.COMMA, _EXPANDO_COMMA);
360                            }
361                    }
362    
363                    setData(StringUtil.merge(data));
364            }
365    
366            protected void validate(int type) throws PortalException, SystemException {
367                    ExpandoColumn column = getColumn();
368    
369                    if (column == null) {
370                            return;
371                    }
372    
373                    if (column.getType() == type) {
374                            return;
375                    }
376    
377                    StringBundler sb = new StringBundler(6);
378    
379                    sb.append("Column ");
380                    sb.append(getColumnId());
381                    sb.append(" has type ");
382                    sb.append(ExpandoColumnConstants.getTypeLabel(column.getType()));
383                    sb.append(" and is not compatible with type ");
384                    sb.append(ExpandoColumnConstants.getTypeLabel(type));
385    
386                    throw new ValueDataException(sb.toString());
387            }
388    
389            private static final String _EXPANDO_COMMA = "[$LIFERAY_EXPANDO_COMMA$]";
390    
391            private transient ExpandoColumn _column;
392    
393    }