gt: 		catch (Throwable t) {
context: /**
   * Copyright (c) 2000-present Liferay, Inc. All rights reserved.
   *
   * This library is free software; you can redistribute it and/or modify it under
   * the terms of the GNU Lesser General Public License as published by the Free
   * Software Foundation; either version 2.1 of the License, or (at your option)
   * any later version.
   *
   * This library is distributed in the hope that it will be useful, but WITHOUT
   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
   * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
   * details.
   */
  
  package org.opencps.datamgt.service;
  
  import com.liferay.portal.service.InvokableLocalService;
  
  /**
   * @author khoavd
   * @generated
   */
  public class DictCollectionLocalServiceClp implements DictCollectionLocalService {
  	public DictCollectionLocalServiceClp(
  		InvokableLocalService invokableLocalService) {
  		_invokableLocalService = invokableLocalService;
  
  		_methodName0 = "addDictCollection";
  
  		_methodParameterTypes0 = new String[] {
  				"org.opencps.datamgt.model.DictCollection"
  			};
  
  		_methodName1 = "createDictCollection";
  
  		_methodParameterTypes1 = new String[] { "long" };
  
  		_methodName2 = "deleteDictCollection";
  
  		_methodParameterTypes2 = new String[] { "long" };
  
  		_methodName3 = "deleteDictCollection";
  
  		_methodParameterTypes3 = new String[] {
  				"org.opencps.datamgt.model.DictCollection"
  			};
  
  		_methodName4 = "dynamicQuery";
  
  		_methodParameterTypes4 = new String[] {  };
  
  		_methodName5 = "dynamicQuery";
  
  		_methodParameterTypes5 = new String[] {
  				"com.liferay.portal.kernel.dao.orm.DynamicQuery"
  			};
  
  		_methodName6 = "dynamicQuery";
  
  		_methodParameterTypes6 = new String[] {
  				"com.liferay.portal.kernel.dao.orm.DynamicQuery", "int", "int"
  			};
  
  		_methodName7 = "dynamicQuery";
  
  		_methodParameterTypes7 = new String[] {
  				"com.liferay.portal.kernel.dao.orm.DynamicQuery", "int", "int",
  				"com.liferay.portal.kernel.util.OrderByComparator"
  			};
  
  		_methodName8 = "dynamicQueryCount";
  
  		_methodParameterTypes8 = new String[] {
  				"com.liferay.portal.kernel.dao.orm.DynamicQuery"
  			};
  
  		_methodName9 = "dynamicQueryCount";
  
  		_methodParameterTypes9 = new String[] {
  				"com.liferay.portal.kernel.dao.orm.DynamicQuery",
  				"com.liferay.portal.kernel.dao.orm.Projection"
  			};
  
  		_methodName10 = "fetchDictCollection";
  
  		_methodParameterTypes10 = new String[] { "long" };
  
  		_methodName11 = "getDictCollection";
  
  		_methodParameterTypes11 = new String[] { "long" };
  
  		_methodName12 = "getPersistedModel";
  
  		_methodParameterTypes12 = new String[] { "java.io.Serializable" };
  
  		_methodName13 = "getDictCollections";
  
  		_methodParameterTypes13 = new String[] { "int", "int" };
  
  		_methodName14 = "getDictCollectionsCount";
  
  		_methodParameterTypes14 = new String[] {  };
  
  		_methodName15 = "updateDictCollection";
  
  		_methodParameterTypes15 = new String[] {
  				"org.opencps.datamgt.model.DictCollection"
  			};
  
  		_methodName16 = "getBeanIdentifier";
  
  		_methodParameterTypes16 = new String[] {  };
  
  		_methodName17 = "setBeanIdentifier";
  
  		_methodParameterTypes17 = new String[] { "java.lang.String" };
  
  		_methodName19 = "addDictCollection";
  
  		_methodParameterTypes19 = new String[] {
  				"long", "java.lang.String", "java.util.Map", "java.lang.String",
  				"com.liferay.portal.service.ServiceContext"
  			};
  
  		_methodName20 = "countAll";
  
  		_methodParameterTypes20 = new String[] {  };
  
  		_methodName21 = "countDictCollection";
  
  		_methodParameterTypes21 = new String[] { "long", "java.lang.String[][]" };
  
  		_methodName22 = "deleteCollection";
  
  		_methodParameterTypes22 = new String[] { "long" };
  
  		_methodName23 = "getDictCollection";
  
  		_methodParameterTypes23 = new String[] { "long", "java.lang.String" };
  
  		_methodName24 = "getDictCollections";
  
  		_methodParameterTypes24 = new String[] {  };
  
  		_methodName25 = "getDictCollections";
  
  		_methodParameterTypes25 = new String[] {
  				"int", "int", "com.liferay.portal.kernel.util.OrderByComparator"
  			};
  
  		_methodName26 = "getDictCollections";
  
  		_methodParameterTypes26 = new String[] { "long" };
  
  		_methodName27 = "getDictCollections";
  
  		_methodParameterTypes27 = new String[] {
  				"long", "java.lang.String[][]", "int", "int",
  				"com.liferay.portal.kernel.util.OrderByComparator"
  			};
  
  		_methodName28 = "updateDictCollection";
  
  		_methodParameterTypes28 = new String[] {
  				"long", "long", "java.lang.String", "java.util.Map",
  				"java.lang.String", "com.liferay.portal.service.ServiceContext"
  			};
  	}
  
  	@Override
  	public org.opencps.datamgt.model.DictCollection addDictCollection(
  		org.opencps.datamgt.model.DictCollection dictCollection)
  		throws com.liferay.portal.kernel.exception.SystemException {
  		Object returnObj = null;
  
  		try {
  			returnObj = _invokableLocalService.invokeMethod(_methodName0,
  					_methodParameterTypes0,
  					new Object[] { ClpSerializer.translateInput(dictCollection) });
  		}
  		catch (Throwable t) {
  			t = ClpSerializer.translateThrowable(t);
  
  			if (t instanceof com.liferay.portal.kernel.exception.SystemException) {
  				throw (com.liferay.portal.kernel.exception.SystemException)t;
  			}
  
  			if (t instanceof RuntimeException) {
  				throw (RuntimeException)t;
  			}
  			else {
  				throw new RuntimeException(t.getClass().getName() +
  					" is not a valid exception");
  			}
  		}
  
  		return (org.opencps.datamgt.model.DictCollection)ClpSerializer.translateOutput(returnObj);
  	}
  
  	@Override
  	public org.opencps.datamgt.model.DictCollection createDictCollection(
  		long dictCollectionId) {
  		Object returnObj = null;
  
  		try {
  			returnObj = _invokableLocalService.invokeMethod(_methodName1,
  					_methodParameterTypes1, new Object[] { dictCollectionId });
  		}
  		catch (Throwable t) {
  			t = ClpSerializer.translateThrowable(t);
  
  			if (t instanceof RuntimeException) {
  				throw (RuntimeException)t;
  			}
  			else {
  				throw new RuntimeException(t.getClass().getName() +
  					" is not a valid exception");
  			}
  		}
  
  		return (org.opencps.datamgt.model.DictCollection)ClpSerializer.translateOutput(returnObj);
  	}
  
  	@Override
  	public org.opencps.datamgt.model.DictCollection deleteDictCollection(
  		long dictCollectionId)
  		throws com.liferay.portal.kernel.exception.PortalException,
  			com.liferay.portal.kernel.exception.SystemException {
  		Object returnObj = null;
  
  		try {
  			returnObj = _invokableLocalService.invokeMethod(_methodName2,
  					_methodParameterTypes2, new Object[] { dictCollectionId });
  		}
  		catch (Throwable t) {
  			t = ClpSerializer.translateThrowable(t);
  
  			if (t instanceof com.liferay.portal.kernel.exception.PortalException) {
  				throw (com.liferay.portal.kernel.exception.PortalException)t;
  			}
  
  			if (t instanceof com.liferay.portal.kernel.exception.SystemException) {
  				throw (com.liferay.portal.kernel.exception.SystemException)t;
  			}
  
  			if (t instanceof RuntimeException) {
  				throw (RuntimeException)t;
  			}
  			else {
  				throw new RuntimeException(t.getClass().getName() +
  					" is not a valid exception");
  			}
  		}
  
  		return (org.opencps.datamgt.model.DictCollection)ClpSerializer.translateOutput(returnObj);
  	}
  
  	@Override
  	public org.opencps.datamgt.model.DictCollection deleteDictCollection(
  		org.opencps.datamgt.model.DictCollection dictCollection)
  		throws com.liferay.portal.kernel.exception.SystemException {
  		Object returnObj = null;
  
  		try {
  			returnObj = _invokableLocalService.invokeMethod(_methodName3,
  					_methodParameterTypes3,
  					new Object[] { ClpSerializer.translateInput(dictCollection) });
  		}
  		catch (Throwable t) {
  			t = ClpSerializer.translateThrowable(t);
  
  			if (t instanceof com.liferay.portal.kernel.exception.SystemException) {
  				throw (com.liferay.portal.kernel.exception.SystemException)t;
  			}
  
  			if (t instanceof RuntimeException) {
  				throw (RuntimeException)t;
  			}
  			else {
  				throw new RuntimeException(t.getClass().getName() +
  					" is not a valid exception");
  			}
  		}
  
  		return (org.opencps.datamgt.model.DictCollection)ClpSerializer.translateOutput(returnObj);
  	}
  
  	@Override
  	public com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery() {
  		Object returnObj = null;
  
  		try {
  			returnObj = _invokableLocalService.invokeMethod(_methodName4,
  					_methodParameterTypes4, new Object[] {  });
  		}
  		catch (Throwable t) {
  			t = ClpSerializer.translateThrowable(t);
  
  			if (t instanceof RuntimeException) {
  				throw (RuntimeException)t;
  			}
  			else {
  				throw new RuntimeException(t.getClass().getName() +
  					" is not a valid exception");
  			}
  		}
  
  		return (com.liferay.portal.kernel.dao.orm.DynamicQuery)ClpSerializer.translateOutput(returnObj);
  	}
  
  	@Override
  	@SuppressWarnings("rawtypes")
  	public java.util.List dynamicQuery(
  		com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery)
  		throws com.liferay.portal.kernel.exception.SystemException {
  		Object returnObj = null;
  
  		try {
  			returnObj = _invokableLocalService.invokeMethod(_methodName5,
  					_methodParameterTypes5,
  					new Object[] { ClpSerializer.translateInput(dynamicQuery) });
  		}
  		catch (Throwable t) {
  			t = ClpSerializer.translateThrowable(t);
  
  			if (t instanceof com.liferay.portal.kernel.exception.SystemException) {
  				throw (com.liferay.portal.kernel.exception.SystemException)t;
  			}
  
  			if (t instanceof RuntimeException) {
  				throw (RuntimeException)t;
  			}
  			else {
  				throw new RuntimeException(t.getClass().getName() +
  					" is not a valid exception");
  			}
  		}
  
  		return (java.util.List)ClpSerializer.translateOutput(returnObj);
  	}
  
  	@Override
  	@SuppressWarnings("rawtypes")
  	public java.util.List dynamicQuery(
  		com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, int start,
  		int end) throws com.liferay.portal.kernel.exception.SystemException {
  		Object returnObj = null;
  
  		try {
  			returnObj = _invokableLocalService.invokeMethod(_methodName6,
  					_methodParameterTypes6,
  					new Object[] {
  						ClpSerializer.translateInput(dynamicQuery),
  						
  					start,
  						
  					end
  					});
  		}
  		catch (Throwable t) {
  			t = ClpSerializer.translateThrowable(t);
  
  			if (t instanceof com.liferay.portal.kernel.exception.SystemException) {
  				throw (com.liferay.portal.kernel.exception.SystemException)t;
  			}
  
  			if (t instanceof RuntimeException) {
  				throw (RuntimeException)t;
  			}
  			else {
  				throw new RuntimeException(t.getClass().getName() +
  					" is not a valid exception");
  			}
  		}
  
  		return (java.util.List)ClpSerializer.translateOutput(returnObj);
  	}
  
  	@Override
  	@SuppressWarnings("rawtypes")
  	public java.util.List dynamicQuery(
  		com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, int start,
  		int end,
  		com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
  		throws com.liferay.portal.kernel.exception.SystemException {
  		Object returnObj = null;
  
  		try {
  			returnObj = _invokableLocalService.invokeMethod(_methodName7,
  					_methodParameterTypes7,
  					new Object[] {
  						ClpSerializer.translateInput(dynamicQuery),
  						
  					start,
  						
  					end,
  						
  					ClpSerializer.translateInput(orderByComparator)
  					});
  		}
  		catch (Throwable t) {
  			t = ClpSerializer.translateThrowable(t);
  
  			if (t instanceof com.liferay.portal.kernel.exception.SystemException) {
  				throw (com.liferay.portal.kernel.exception.SystemException)t;
  			}
  
  			if (t instanceof RuntimeException) {
  				throw (RuntimeException)t;
  			}
  			else {
  				throw new RuntimeException(t.getClass().getName() +
  					" is not a valid exception");
  			}
  		}
  
  		return (java.util.List)ClpSerializer.translateOutput(returnObj);
  	}
  
  	@Override
  	public long dynamicQueryCount(
  		com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery)
  		throws com.liferay.portal.kernel.exception.SystemException {
  		Object returnObj = null;
  
  		try {
  			returnObj = _invokableLocalService.invokeMethod(_methodName8,
  					_methodParameterTypes8,
  					new Object[] { ClpSerializer.translateInput(dynamicQuery) });
  		}
  		catch (Throwable t) {
  			t = ClpSerializer.translateThrowable(t);
  
  			if (t instanceof com.liferay.portal.kernel.exception.SystemException) {
  				throw (com.liferay.portal.kernel.exception.SystemException)t;
  			}
  
  			if (t instanceof RuntimeException) {
  				throw (RuntimeException)t;
  			}
  			else {
  				throw new RuntimeException(t.getClass().getName() +
  					" is not a valid exception");
  			}
  		}
  
  		return ((Long)returnObj).longValue();
  	}
  
  	@Override
  	public long dynamicQueryCount(
  		com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery,
  		com.liferay.portal.kernel.dao.orm.Projection projection)
  		throws com.liferay.portal.kernel.exception.SystemException {
  		Object returnObj = null;
  
  		try {
  			returnObj = _invokableLocalService.invokeMethod(_methodName9,
  					_methodParameterTypes9,
  					new Object[] {
  						ClpSerializer.translateInput(dynamicQuery),
  						
  					ClpSerializer.translateInput(projection)
  					});
  		}
  		catch (Throwable t) {
  			t = ClpSerializer.translateThrowable(t);
  
  			if (t instanceof com.liferay.portal.kernel.exception.SystemException) {
  				throw (com.liferay.portal.kernel.exception.SystemException)t;
  			}
  
  			if (t instanceof RuntimeException) {
  				throw (RuntimeException)t;
  			}
  			else {
  				throw new RuntimeException(t.getClass().getName() +
  					" is not a valid exception");
  			}
  		}
  
  		return ((Long)returnObj).longValue();
  	}
  
  	@Override
  	public org.opencps.datamgt.model.DictCollection fetchDictCollection(
  		long dictCollectionId)
  		throws com.liferay.portal.kernel.exception.SystemException {
  		Object returnObj = null;
  
  		try {
  			returnObj = _invokableLocalService.invokeMethod(_methodName10,
  					_methodParameterTypes10, new Object[] { dictCollectionId });
  		}
  		catch (Throwable t) {
  			t = ClpSerializer.translateThrowable(t);
  
  			if (t instanceof com.liferay.portal.kernel.exception.SystemException) {
  				throw (com.liferay.portal.kernel.exception.SystemException)t;
  			}
  
  			if (t instanceof RuntimeException) {
  				throw (RuntimeException)t;
  			}
  			else {
  				throw new RuntimeException(t.getClass().getName() +
  					" is not a valid exception");
  			}
  		}
  
  		return (org.opencps.datamgt.model.DictCollection)ClpSerializer.translateOutput(returnObj);
  	}
  
  	@Override
  	public org.opencps.datamgt.model.DictCollection getDictCollection(
  		long dictCollectionId)
  		throws com.liferay.portal.kernel.exception.PortalException,
  			com.liferay.portal.kernel.exception.SystemException,
  			org.opencps.datamgt.NoSuchDictCollectionException {
  		Object returnObj = null;
  
  		try {
  			returnObj = _invokableLocalService.invokeMethod(_methodName11,
  					_methodParameterTypes11, new Object[] { dictCollectionId });
  		}
  		catch (Throwable t) {
  			t = ClpSerializer.translateThrowable(t);
  
  			if (t instanceof com.liferay.portal.kernel.exception.PortalException) {
  				throw (com.liferay.portal.kernel.exception.PortalException)t;
  			}
  
  			if (t instanceof com.liferay.portal.kernel.exception.SystemException) {
  				throw (com.liferay.portal.kernel.exception.SystemException)t;
  			}
  
  			if (t instanceof org.opencps.datamgt.NoSuchDictCollectionException) {
  				throw (org.opencps.datamgt.NoSuchDictCollectionException)t;
  			}
  
  			if (t instanceof RuntimeException) {
  				throw (RuntimeException)t;
  			}
  			else {
  				throw new RuntimeException(t.getClass().getName() +
  					" is not a valid exception");
  			}
  		}
  
  		return (org.opencps.datamgt.model.DictCollection)ClpSerializer.translateOutput(returnObj);
  	}
  
  	@Override
  	public com.liferay.portal.model.PersistedModel getPersistedModel(
  		java.io.Serializable primaryKeyObj)
  		throws com.liferay.portal.kernel.exception.PortalException,
  			com.liferay.portal.kernel.exception.SystemException {
  		Object returnObj = null;
  
  		try {
  			returnObj = _invokableLocalService.invokeMethod(_methodName12,
  					_methodParameterTypes12,
  					new Object[] { ClpSerializer.translateInput(primaryKeyObj) });
  		}
  		catch (Throwable t) {
  			t = ClpSerializer.translateThrowable(t);
  
  			if (t instanceof com.liferay.portal.kernel.exception.PortalException) {
  				throw (com.liferay.portal.kernel.exception.PortalException)t;
  			}
  
  			if (t instanceof com.liferay.portal.kernel.exception.SystemException) {
  				throw (com.liferay.portal.kernel.exception.SystemException)t;
  			}
  
  			if (t instanceof RuntimeException) {
  				throw (RuntimeException)t;
  			}
  			else {
  				throw new RuntimeException(t.getClass().getName() +
  					" is not a valid exception");
  			}
  		}
  
  		return (com.liferay.portal.model.PersistedModel)ClpSerializer.translateOutput(returnObj);
  	}
  
  	@Override
  	public java.util.List<org.opencps.datamgt.model.DictCollection> getDictCollections(
  		int start, int end)
  		throws com.liferay.portal.kernel.exception.SystemException {
  		Object returnObj = null;
  
  		try {
  			returnObj = _invokableLocalService.invokeMethod(_methodName13,
  					_methodParameterTypes13, new Object[] { start, end });
  		}
  		catch (Throwable t) {
  			t = ClpSerializer.translateThrowable(t);
  
  			if (t instanceof com.liferay.portal.kernel.exception.SystemException) {
  				throw (com.liferay.portal.kernel.exception.SystemException)t;
  			}
  
  			if (t instanceof RuntimeException) {
  				throw (RuntimeException)t;
  			}
  			else {
  				throw new RuntimeException(t.getClass().getName() +
  					" is not a valid exception");
  			}
  		}
  
  		return (java.util.List<org.opencps.datamgt.model.DictCollection>)ClpSerializer.translateOutput(returnObj);
  	}
  
  	@Override
  	public int getDictCollectionsCount()
  		throws com.liferay.portal.kernel.exception.SystemException {
  		Object returnObj = null;
  
  		try {
  			returnObj = _invokableLocalService.invokeMethod(_methodName14,
  					_methodParameterTypes14, new Object[] {  });
  		}
  		catch (Throwable t) {
  			t = ClpSerializer.translateThrowable(t);
  
  			if (t instanceof com.liferay.portal.kernel.exception.SystemException) {
  				throw (com.liferay.portal.kernel.exception.SystemException)t;
  			}
  
  			if (t instanceof RuntimeException) {
  				throw (RuntimeException)t;
  			}
  			else {
  				throw new RuntimeException(t.getClass().getName() +
  					" is not a valid exception");
  			}
  		}
  
  		return ((Integer)returnObj).intValue();
  	}
  
  	@Override
  	public org.opencps.datamgt.model.DictCollection updateDictCollection(
  		org.opencps.datamgt.model.DictCollection dictCollection)
  		throws com.liferay.portal.kernel.exception.SystemException {
  		Object returnObj = null;
  
  		try {
  			returnObj = _invokableLocalService.invokeMethod(_methodName15,
  					_methodParameterTypes15,
  					new Object[] { ClpSerializer.translateInput(dictCollection) });
  		}
  		catch (Throwable t) {
  			t = ClpSerializer.translateThrowable(t);
  
  			if (t instanceof com.liferay.portal.kernel.exception.SystemException) {
  				throw (com.liferay.portal.kernel.exception.SystemException)t;
  			}
  
  			if (t instanceof RuntimeException) {
  				throw (RuntimeException)t;
  			}
  			else {
  				throw new RuntimeException(t.getClass().getName() +
  					" is not a valid exception");
  			}
  		}
  
  		return (org.opencps.datamgt.model.DictCollection)ClpSerializer.translateOutput(returnObj);
  	}
  
  	@Override
  	public java.lang.String getBeanIdentifier() {
  		Object returnObj = null;
  
  		try {
  			returnObj = _invokableLocalService.invokeMethod(_methodName16,
  					_methodParameterTypes16, new Object[] {  });
  		}
  		catch (Throwable t) {
  			t = ClpSerializer.translateThrowable(t);
  
  			if (t instanceof RuntimeException) {
  				throw (RuntimeException)t;
  			}
  			else {
  				throw new RuntimeException(t.getClass().getName() +
  					" is not a valid exception");
  			}
  		}
  
  		return (java.lang.String)ClpSerializer.translateOutput(returnObj);
  	}
  
  	@Override
  	public void setBeanIdentifier(java.lang.String beanIdentifier) {
  		try {
  			_invokableLocalService.invokeMethod(_methodName17,
  				_methodParameterTypes17,
  				new Object[] { ClpSerializer.translateInput(beanIdentifier) });
  		}
  		catch (Throwable t) {
  			t = ClpSerializer.translateThrowable(t);
  
  			if (t instanceof RuntimeException) {
  				throw (RuntimeException)t;
  			}
  			else {
  				throw new RuntimeException(t.getClass().getName() +
  					" is not a valid exception");
  			}
  		}
  	}
  
  	@Override
  	public java.lang.Object invokeMethod(java.lang.String name,
  		java.lang.String[] parameterTypes, java.lang.Object[] arguments)
  		throws java.lang.Throwable {
  		throw new UnsupportedOperationException();
  	}
  
  	@Override
  	public org.opencps.datamgt.model.DictCollection addDictCollection(
  		long userId, java.lang.String collectionCode,
  		java.util.Map<java.util.Locale, java.lang.String> collectionNameMap,
  		java.lang.String description,
  		com.liferay.portal.service.ServiceContext serviceContext)
  		throws com.liferay.portal.kernel.exception.SystemException {
  		Object returnObj = null;
  
  		try {
  			returnObj = _invokableLocalService.invokeMethod(_methodName19,
  					_methodParameterTypes19,
  					new Object[] {
  						userId,
  						
  					ClpSerializer.translateInput(collectionCode),
  						
  					ClpSerializer.translateInput(collectionNameMap),
  						
  					ClpSerializer.translateInput(description),
  						
  					ClpSerializer.translateInput(serviceContext)
  					});
  		}
  		catch (Throwable t) {
  			t = ClpSerializer.translateThrowable(t);
  
  			if (t instanceof com.liferay.portal.kernel.exception.SystemException) {
  				throw (com.liferay.portal.kernel.exception.SystemException)t;
  			}
  
  			if (t instanceof RuntimeException) {
  				throw (RuntimeException)t;
  			}
  			else {
  				throw new RuntimeException(t.getClass().getName() +
  					" is not a valid exception");
  			}
  		}
  
  		return (org.opencps.datamgt.model.DictCollection)ClpSerializer.translateOutput(returnObj);
  	}
  
  	@Override
  	public int countAll()
  		throws com.liferay.portal.kernel.exception.SystemException {
  		Object returnObj = null;
  
  		try {
  			returnObj = _invokableLocalService.invokeMethod(_methodName20,
  					_methodParameterTypes20, new Object[] {  });
  		}
  		catch (Throwable t) {
  			t = ClpSerializer.translateThrowable(t);
  
  			if (t instanceof com.liferay.portal.kernel.exception.SystemException) {
  				throw (com.liferay.portal.kernel.exception.SystemException)t;
  			}
  
  			if (t instanceof RuntimeException) {
  				throw (RuntimeException)t;
  			}
  			else {
  				throw new RuntimeException(t.getClass().getName() +
  					" is not a valid exception");
  			}
  		}
  
  		return ((Integer)returnObj).intValue();
  	}
  
  	@Override
  	public int countDictCollection(long groupId,
  		java.lang.String[] collectionNames)
  		throws com.liferay.portal.kernel.exception.SystemException {
  		Object returnObj = null;
  
  		try {
  			returnObj = _invokableLocalService.invokeMethod(_methodName21,
  					_methodParameterTypes21,
  					new Object[] {
  						groupId,
  						
  					ClpSerializer.translateInput(collectionNames)
  					});
  		}
  		catch (Throwable t) {
  			t = ClpSerializer.translateThrowable(t);
  
  			if (t instanceof com.liferay.portal.kernel.exception.SystemException) {
  				throw (com.liferay.portal.kernel.exception.SystemException)t;
  			}
  
  			if (t instanceof RuntimeException) {
  				throw (RuntimeException)t;
  			}
  			else {
  				throw new RuntimeException(t.getClass().getName() +
  					" is not a valid exception");
  			}
  		}
  
  		return ((Integer)returnObj).intValue();
  	}
  
  	@Override
  	public void deleteCollection(long dictCollectionId)
  		throws com.liferay.portal.kernel.exception.SystemException,
  			org.opencps.datamgt.NoSuchDictCollectionException {
  		try {
  			_invokableLocalService.invokeMethod(_methodName22,
  				_methodParameterTypes22, new Object[] { dictCollectionId });
  		}
  		catch (Throwable t) {
  			t = ClpSerializer.translateThrowable(t);
  
  			if (t instanceof com.liferay.portal.kernel.exception.SystemException) {
  				throw (com.liferay.portal.kernel.exception.SystemException)t;
  			}
  
  			if (t instanceof org.opencps.datamgt.NoSuchDictCollectionException) {
  				throw (org.opencps.datamgt.NoSuchDictCollectionException)t;
  			}
  
  			if (t instanceof RuntimeException) {
  				throw (RuntimeException)t;
  			}
  			else {
  				throw new RuntimeException(t.getClass().getName() +
  					" is not a valid exception");
  			}
  		}
  	}
  
  	@Override
  	public org.opencps.datamgt.model.DictCollection getDictCollection(
  		long groupId, java.lang.String collectionCode)
  		throws com.liferay.portal.kernel.exception.SystemException,
  			org.opencps.datamgt.NoSuchDictCollectionException {
  		Object returnObj = null;
  
  		try {
  			returnObj = _invokableLocalService.invokeMethod(_methodName23,
  					_methodParameterTypes23,
  					new Object[] {
  						groupId,
  						
  					ClpSerializer.translateInput(collectionCode)
  					});
  		}
  		catch (Throwable t) {
  			t = ClpSerializer.translateThrowable(t);
  
  			if (t instanceof com.liferay.portal.kernel.exception.SystemException) {
  				throw (com.liferay.portal.kernel.exception.SystemException)t;
  			}
  
  			if (t instanceof org.opencps.datamgt.NoSuchDictCollectionException) {
  				throw (org.opencps.datamgt.NoSuchDictCollectionException)t;
  			}
  
  			if (t instanceof RuntimeException) {
  				throw (RuntimeException)t;
  			}
  			else {
  				throw new RuntimeException(t.getClass().getName() +
  					" is not a valid exception");
  			}
  		}
  
  		return (org.opencps.datamgt.model.DictCollection)ClpSerializer.translateOutput(returnObj);
  	}
  
  	@Override
  	public java.util.List<org.opencps.datamgt.model.DictCollection> getDictCollections()
  		throws com.liferay.portal.kernel.exception.SystemException {
  		Object returnObj = null;
  
  		try {
  			returnObj = _invokableLocalService.invokeMethod(_methodName24,
  					_methodParameterTypes24, new Object[] {  });
  		}
  		catch (Throwable t) {
  			t = ClpSerializer.translateThrowable(t);
  
  			if (t instanceof com.liferay.portal.kernel.exception.SystemException) {
  				throw (com.liferay.portal.kernel.exception.SystemException)t;
  			}
  
  			if (t instanceof RuntimeException) {
  				throw (RuntimeException)t;
  			}
  			else {
  				throw new RuntimeException(t.getClass().getName() +
  					" is not a valid exception");
  			}
  		}
  
  		return (java.util.List<org.opencps.datamgt.model.DictCollection>)ClpSerializer.translateOutput(returnObj);
  	}
  
  	@Override
  	public java.util.List<org.opencps.datamgt.model.DictCollection> getDictCollections(
  		int start, int end, com.liferay.portal.kernel.util.OrderByComparator odc)
  		throws com.liferay.portal.kernel.exception.SystemException {
  		Object returnObj = null;
  
  		try {
  			returnObj = _invokableLocalService.invokeMethod(_methodName25,
  					_methodParameterTypes25,
  					new Object[] { start, end, ClpSerializer.translateInput(odc) });
  		}
  		catch (Throwable t) {
  			t = ClpSerializer.translateThrowable(t);
  
  			if (t instanceof com.liferay.portal.kernel.exception.SystemException) {
  				throw (com.liferay.portal.kernel.exception.SystemException)t;
  			}
  
  			if (t instanceof RuntimeException) {
  				throw (RuntimeException)t;
  			}
  			else {
  				throw new RuntimeException(t.getClass().getName() +
  					" is not a valid exception");
  			}
  		}
  
  		return (java.util.List<org.opencps.datamgt.model.DictCollection>)ClpSerializer.translateOutput(returnObj);
  	}
  
  	@Override
  	public java.util.List<org.opencps.datamgt.model.DictCollection> getDictCollections(
  		long groupId)
  		throws com.liferay.portal.kernel.exception.SystemException {
  		Object returnObj = null;
  
  		try {
  			returnObj = _invokableLocalService.invokeMethod(_methodName26,
  					_methodParameterTypes26, new Object[] { groupId });
  		}
  		catch (Throwable t) {
  			t = ClpSerializer.translateThrowable(t);
  
  			if (t instanceof com.liferay.portal.kernel.exception.SystemException) {
  				throw (com.liferay.portal.kernel.exception.SystemException)t;
  			}
  
  			if (t instanceof RuntimeException) {
  				throw (RuntimeException)t;
  			}
  			else {
  				throw new RuntimeException(t.getClass().getName() +
  					" is not a valid exception");
  			}
  		}
  
  		return (java.util.List<org.opencps.datamgt.model.DictCollection>)ClpSerializer.translateOutput(returnObj);
  	}
  
  	@Override
  	public java.util.List<org.opencps.datamgt.model.DictCollection> getDictCollections(
  		long groupId, java.lang.String[] collectionNames, int start, int end,
  		com.liferay.portal.kernel.util.OrderByComparator odc)
  		throws com.liferay.portal.kernel.exception.SystemException {
  		Object returnObj = null;
  
  		try {
  			returnObj = _invokableLocalService.invokeMethod(_methodName27,
  					_methodParameterTypes27,
  					new Object[] {
  						groupId,
  						
  					ClpSerializer.translateInput(collectionNames),
  						
  					start,
  						
  					end,
  						
  					ClpSerializer.translateInput(odc)
  					});
  		}
  