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.portal.service.persistence;
016    
017    import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil;
018    import com.liferay.portal.kernel.dao.orm.DynamicQuery;
019    import com.liferay.portal.kernel.exception.SystemException;
020    import com.liferay.portal.kernel.util.OrderByComparator;
021    import com.liferay.portal.kernel.util.ReferenceRegistry;
022    import com.liferay.portal.model.LayoutPrototype;
023    import com.liferay.portal.service.ServiceContext;
024    
025    import java.util.List;
026    
027    /**
028     * The persistence utility for the layout prototype service. This utility wraps {@link LayoutPrototypePersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class.
029     *
030     * <p>
031     * Caching information and settings can be found in <code>portal.properties</code>
032     * </p>
033     *
034     * @author Brian Wing Shun Chan
035     * @see LayoutPrototypePersistence
036     * @see LayoutPrototypePersistenceImpl
037     * @generated
038     */
039    public class LayoutPrototypeUtil {
040            /*
041             * NOTE FOR DEVELOPERS:
042             *
043             * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
044             */
045    
046            /**
047             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
048             */
049            public static void clearCache() {
050                    getPersistence().clearCache();
051            }
052    
053            /**
054             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
055             */
056            public static void clearCache(LayoutPrototype layoutPrototype) {
057                    getPersistence().clearCache(layoutPrototype);
058            }
059    
060            /**
061             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
062             */
063            public long countWithDynamicQuery(DynamicQuery dynamicQuery)
064                    throws SystemException {
065                    return getPersistence().countWithDynamicQuery(dynamicQuery);
066            }
067    
068            /**
069             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
070             */
071            public static List<LayoutPrototype> findWithDynamicQuery(
072                    DynamicQuery dynamicQuery) throws SystemException {
073                    return getPersistence().findWithDynamicQuery(dynamicQuery);
074            }
075    
076            /**
077             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
078             */
079            public static List<LayoutPrototype> findWithDynamicQuery(
080                    DynamicQuery dynamicQuery, int start, int end)
081                    throws SystemException {
082                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
083            }
084    
085            /**
086             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
087             */
088            public static List<LayoutPrototype> findWithDynamicQuery(
089                    DynamicQuery dynamicQuery, int start, int end,
090                    OrderByComparator orderByComparator) throws SystemException {
091                    return getPersistence()
092                                       .findWithDynamicQuery(dynamicQuery, start, end,
093                            orderByComparator);
094            }
095    
096            /**
097             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean)
098             */
099            public static LayoutPrototype update(LayoutPrototype layoutPrototype,
100                    boolean merge) throws SystemException {
101                    return getPersistence().update(layoutPrototype, merge);
102            }
103    
104            /**
105             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean, ServiceContext)
106             */
107            public static LayoutPrototype update(LayoutPrototype layoutPrototype,
108                    boolean merge, ServiceContext serviceContext) throws SystemException {
109                    return getPersistence().update(layoutPrototype, merge, serviceContext);
110            }
111    
112            /**
113            * Caches the layout prototype in the entity cache if it is enabled.
114            *
115            * @param layoutPrototype the layout prototype
116            */
117            public static void cacheResult(
118                    com.liferay.portal.model.LayoutPrototype layoutPrototype) {
119                    getPersistence().cacheResult(layoutPrototype);
120            }
121    
122            /**
123            * Caches the layout prototypes in the entity cache if it is enabled.
124            *
125            * @param layoutPrototypes the layout prototypes
126            */
127            public static void cacheResult(
128                    java.util.List<com.liferay.portal.model.LayoutPrototype> layoutPrototypes) {
129                    getPersistence().cacheResult(layoutPrototypes);
130            }
131    
132            /**
133            * Creates a new layout prototype with the primary key. Does not add the layout prototype to the database.
134            *
135            * @param layoutPrototypeId the primary key for the new layout prototype
136            * @return the new layout prototype
137            */
138            public static com.liferay.portal.model.LayoutPrototype create(
139                    long layoutPrototypeId) {
140                    return getPersistence().create(layoutPrototypeId);
141            }
142    
143            /**
144            * Removes the layout prototype with the primary key from the database. Also notifies the appropriate model listeners.
145            *
146            * @param layoutPrototypeId the primary key of the layout prototype
147            * @return the layout prototype that was removed
148            * @throws com.liferay.portal.NoSuchLayoutPrototypeException if a layout prototype with the primary key could not be found
149            * @throws SystemException if a system exception occurred
150            */
151            public static com.liferay.portal.model.LayoutPrototype remove(
152                    long layoutPrototypeId)
153                    throws com.liferay.portal.NoSuchLayoutPrototypeException,
154                            com.liferay.portal.kernel.exception.SystemException {
155                    return getPersistence().remove(layoutPrototypeId);
156            }
157    
158            public static com.liferay.portal.model.LayoutPrototype updateImpl(
159                    com.liferay.portal.model.LayoutPrototype layoutPrototype, boolean merge)
160                    throws com.liferay.portal.kernel.exception.SystemException {
161                    return getPersistence().updateImpl(layoutPrototype, merge);
162            }
163    
164            /**
165            * Returns the layout prototype with the primary key or throws a {@link com.liferay.portal.NoSuchLayoutPrototypeException} if it could not be found.
166            *
167            * @param layoutPrototypeId the primary key of the layout prototype
168            * @return the layout prototype
169            * @throws com.liferay.portal.NoSuchLayoutPrototypeException if a layout prototype with the primary key could not be found
170            * @throws SystemException if a system exception occurred
171            */
172            public static com.liferay.portal.model.LayoutPrototype findByPrimaryKey(
173                    long layoutPrototypeId)
174                    throws com.liferay.portal.NoSuchLayoutPrototypeException,
175                            com.liferay.portal.kernel.exception.SystemException {
176                    return getPersistence().findByPrimaryKey(layoutPrototypeId);
177            }
178    
179            /**
180            * Returns the layout prototype with the primary key or returns <code>null</code> if it could not be found.
181            *
182            * @param layoutPrototypeId the primary key of the layout prototype
183            * @return the layout prototype, or <code>null</code> if a layout prototype with the primary key could not be found
184            * @throws SystemException if a system exception occurred
185            */
186            public static com.liferay.portal.model.LayoutPrototype fetchByPrimaryKey(
187                    long layoutPrototypeId)
188                    throws com.liferay.portal.kernel.exception.SystemException {
189                    return getPersistence().fetchByPrimaryKey(layoutPrototypeId);
190            }
191    
192            /**
193            * Returns all the layout prototypes where uuid = &#63;.
194            *
195            * @param uuid the uuid
196            * @return the matching layout prototypes
197            * @throws SystemException if a system exception occurred
198            */
199            public static java.util.List<com.liferay.portal.model.LayoutPrototype> findByUuid(
200                    java.lang.String uuid)
201                    throws com.liferay.portal.kernel.exception.SystemException {
202                    return getPersistence().findByUuid(uuid);
203            }
204    
205            /**
206            * Returns a range of all the layout prototypes where uuid = &#63;.
207            *
208            * <p>
209            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
210            * </p>
211            *
212            * @param uuid the uuid
213            * @param start the lower bound of the range of layout prototypes
214            * @param end the upper bound of the range of layout prototypes (not inclusive)
215            * @return the range of matching layout prototypes
216            * @throws SystemException if a system exception occurred
217            */
218            public static java.util.List<com.liferay.portal.model.LayoutPrototype> findByUuid(
219                    java.lang.String uuid, int start, int end)
220                    throws com.liferay.portal.kernel.exception.SystemException {
221                    return getPersistence().findByUuid(uuid, start, end);
222            }
223    
224            /**
225            * Returns an ordered range of all the layout prototypes where uuid = &#63;.
226            *
227            * <p>
228            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
229            * </p>
230            *
231            * @param uuid the uuid
232            * @param start the lower bound of the range of layout prototypes
233            * @param end the upper bound of the range of layout prototypes (not inclusive)
234            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
235            * @return the ordered range of matching layout prototypes
236            * @throws SystemException if a system exception occurred
237            */
238            public static java.util.List<com.liferay.portal.model.LayoutPrototype> findByUuid(
239                    java.lang.String uuid, int start, int end,
240                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
241                    throws com.liferay.portal.kernel.exception.SystemException {
242                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
243            }
244    
245            /**
246            * Returns the first layout prototype in the ordered set where uuid = &#63;.
247            *
248            * <p>
249            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
250            * </p>
251            *
252            * @param uuid the uuid
253            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
254            * @return the first matching layout prototype
255            * @throws com.liferay.portal.NoSuchLayoutPrototypeException if a matching layout prototype could not be found
256            * @throws SystemException if a system exception occurred
257            */
258            public static com.liferay.portal.model.LayoutPrototype findByUuid_First(
259                    java.lang.String uuid,
260                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
261                    throws com.liferay.portal.NoSuchLayoutPrototypeException,
262                            com.liferay.portal.kernel.exception.SystemException {
263                    return getPersistence().findByUuid_First(uuid, orderByComparator);
264            }
265    
266            /**
267            * Returns the last layout prototype in the ordered set where uuid = &#63;.
268            *
269            * <p>
270            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
271            * </p>
272            *
273            * @param uuid the uuid
274            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
275            * @return the last matching layout prototype
276            * @throws com.liferay.portal.NoSuchLayoutPrototypeException if a matching layout prototype could not be found
277            * @throws SystemException if a system exception occurred
278            */
279            public static com.liferay.portal.model.LayoutPrototype findByUuid_Last(
280                    java.lang.String uuid,
281                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
282                    throws com.liferay.portal.NoSuchLayoutPrototypeException,
283                            com.liferay.portal.kernel.exception.SystemException {
284                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
285            }
286    
287            /**
288            * Returns the layout prototypes before and after the current layout prototype in the ordered set where uuid = &#63;.
289            *
290            * <p>
291            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
292            * </p>
293            *
294            * @param layoutPrototypeId the primary key of the current layout prototype
295            * @param uuid the uuid
296            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
297            * @return the previous, current, and next layout prototype
298            * @throws com.liferay.portal.NoSuchLayoutPrototypeException if a layout prototype with the primary key could not be found
299            * @throws SystemException if a system exception occurred
300            */
301            public static com.liferay.portal.model.LayoutPrototype[] findByUuid_PrevAndNext(
302                    long layoutPrototypeId, java.lang.String uuid,
303                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
304                    throws com.liferay.portal.NoSuchLayoutPrototypeException,
305                            com.liferay.portal.kernel.exception.SystemException {
306                    return getPersistence()
307                                       .findByUuid_PrevAndNext(layoutPrototypeId, uuid,
308                            orderByComparator);
309            }
310    
311            /**
312            * Returns all the layout prototypes that the user has permission to view where uuid = &#63;.
313            *
314            * @param uuid the uuid
315            * @return the matching layout prototypes that the user has permission to view
316            * @throws SystemException if a system exception occurred
317            */
318            public static java.util.List<com.liferay.portal.model.LayoutPrototype> filterFindByUuid(
319                    java.lang.String uuid)
320                    throws com.liferay.portal.kernel.exception.SystemException {
321                    return getPersistence().filterFindByUuid(uuid);
322            }
323    
324            /**
325            * Returns a range of all the layout prototypes that the user has permission to view where uuid = &#63;.
326            *
327            * <p>
328            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
329            * </p>
330            *
331            * @param uuid the uuid
332            * @param start the lower bound of the range of layout prototypes
333            * @param end the upper bound of the range of layout prototypes (not inclusive)
334            * @return the range of matching layout prototypes that the user has permission to view
335            * @throws SystemException if a system exception occurred
336            */
337            public static java.util.List<com.liferay.portal.model.LayoutPrototype> filterFindByUuid(
338                    java.lang.String uuid, int start, int end)
339                    throws com.liferay.portal.kernel.exception.SystemException {
340                    return getPersistence().filterFindByUuid(uuid, start, end);
341            }
342    
343            /**
344            * Returns an ordered range of all the layout prototypes that the user has permissions to view where uuid = &#63;.
345            *
346            * <p>
347            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
348            * </p>
349            *
350            * @param uuid the uuid
351            * @param start the lower bound of the range of layout prototypes
352            * @param end the upper bound of the range of layout prototypes (not inclusive)
353            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
354            * @return the ordered range of matching layout prototypes that the user has permission to view
355            * @throws SystemException if a system exception occurred
356            */
357            public static java.util.List<com.liferay.portal.model.LayoutPrototype> filterFindByUuid(
358                    java.lang.String uuid, int start, int end,
359                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
360                    throws com.liferay.portal.kernel.exception.SystemException {
361                    return getPersistence()
362                                       .filterFindByUuid(uuid, start, end, orderByComparator);
363            }
364    
365            /**
366            * Returns the layout prototypes before and after the current layout prototype in the ordered set of layout prototypes that the user has permission to view where uuid = &#63;.
367            *
368            * @param layoutPrototypeId the primary key of the current layout prototype
369            * @param uuid the uuid
370            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
371            * @return the previous, current, and next layout prototype
372            * @throws com.liferay.portal.NoSuchLayoutPrototypeException if a layout prototype with the primary key could not be found
373            * @throws SystemException if a system exception occurred
374            */
375            public static com.liferay.portal.model.LayoutPrototype[] filterFindByUuid_PrevAndNext(
376                    long layoutPrototypeId, java.lang.String uuid,
377                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
378                    throws com.liferay.portal.NoSuchLayoutPrototypeException,
379                            com.liferay.portal.kernel.exception.SystemException {
380                    return getPersistence()
381                                       .filterFindByUuid_PrevAndNext(layoutPrototypeId, uuid,
382                            orderByComparator);
383            }
384    
385            /**
386            * Returns all the layout prototypes where companyId = &#63;.
387            *
388            * @param companyId the company ID
389            * @return the matching layout prototypes
390            * @throws SystemException if a system exception occurred
391            */
392            public static java.util.List<com.liferay.portal.model.LayoutPrototype> findByCompanyId(
393                    long companyId)
394                    throws com.liferay.portal.kernel.exception.SystemException {
395                    return getPersistence().findByCompanyId(companyId);
396            }
397    
398            /**
399            * Returns a range of all the layout prototypes where companyId = &#63;.
400            *
401            * <p>
402            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
403            * </p>
404            *
405            * @param companyId the company ID
406            * @param start the lower bound of the range of layout prototypes
407            * @param end the upper bound of the range of layout prototypes (not inclusive)
408            * @return the range of matching layout prototypes
409            * @throws SystemException if a system exception occurred
410            */
411            public static java.util.List<com.liferay.portal.model.LayoutPrototype> findByCompanyId(
412                    long companyId, int start, int end)
413                    throws com.liferay.portal.kernel.exception.SystemException {
414                    return getPersistence().findByCompanyId(companyId, start, end);
415            }
416    
417            /**
418            * Returns an ordered range of all the layout prototypes where companyId = &#63;.
419            *
420            * <p>
421            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
422            * </p>
423            *
424            * @param companyId the company ID
425            * @param start the lower bound of the range of layout prototypes
426            * @param end the upper bound of the range of layout prototypes (not inclusive)
427            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
428            * @return the ordered range of matching layout prototypes
429            * @throws SystemException if a system exception occurred
430            */
431            public static java.util.List<com.liferay.portal.model.LayoutPrototype> findByCompanyId(
432                    long companyId, int start, int end,
433                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
434                    throws com.liferay.portal.kernel.exception.SystemException {
435                    return getPersistence()
436                                       .findByCompanyId(companyId, start, end, orderByComparator);
437            }
438    
439            /**
440            * Returns the first layout prototype in the ordered set where companyId = &#63;.
441            *
442            * <p>
443            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
444            * </p>
445            *
446            * @param companyId the company ID
447            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
448            * @return the first matching layout prototype
449            * @throws com.liferay.portal.NoSuchLayoutPrototypeException if a matching layout prototype could not be found
450            * @throws SystemException if a system exception occurred
451            */
452            public static com.liferay.portal.model.LayoutPrototype findByCompanyId_First(
453                    long companyId,
454                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
455                    throws com.liferay.portal.NoSuchLayoutPrototypeException,
456                            com.liferay.portal.kernel.exception.SystemException {
457                    return getPersistence()
458                                       .findByCompanyId_First(companyId, orderByComparator);
459            }
460    
461            /**
462            * Returns the last layout prototype in the ordered set where companyId = &#63;.
463            *
464            * <p>
465            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
466            * </p>
467            *
468            * @param companyId the company ID
469            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
470            * @return the last matching layout prototype
471            * @throws com.liferay.portal.NoSuchLayoutPrototypeException if a matching layout prototype could not be found
472            * @throws SystemException if a system exception occurred
473            */
474            public static com.liferay.portal.model.LayoutPrototype findByCompanyId_Last(
475                    long companyId,
476                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
477                    throws com.liferay.portal.NoSuchLayoutPrototypeException,
478                            com.liferay.portal.kernel.exception.SystemException {
479                    return getPersistence()
480                                       .findByCompanyId_Last(companyId, orderByComparator);
481            }
482    
483            /**
484            * Returns the layout prototypes before and after the current layout prototype in the ordered set where companyId = &#63;.
485            *
486            * <p>
487            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
488            * </p>
489            *
490            * @param layoutPrototypeId the primary key of the current layout prototype
491            * @param companyId the company ID
492            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
493            * @return the previous, current, and next layout prototype
494            * @throws com.liferay.portal.NoSuchLayoutPrototypeException if a layout prototype with the primary key could not be found
495            * @throws SystemException if a system exception occurred
496            */
497            public static com.liferay.portal.model.LayoutPrototype[] findByCompanyId_PrevAndNext(
498                    long layoutPrototypeId, long companyId,
499                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
500                    throws com.liferay.portal.NoSuchLayoutPrototypeException,
501                            com.liferay.portal.kernel.exception.SystemException {
502                    return getPersistence()
503                                       .findByCompanyId_PrevAndNext(layoutPrototypeId, companyId,
504                            orderByComparator);
505            }
506    
507            /**
508            * Returns all the layout prototypes that the user has permission to view where companyId = &#63;.
509            *
510            * @param companyId the company ID
511            * @return the matching layout prototypes that the user has permission to view
512            * @throws SystemException if a system exception occurred
513            */
514            public static java.util.List<com.liferay.portal.model.LayoutPrototype> filterFindByCompanyId(
515                    long companyId)
516                    throws com.liferay.portal.kernel.exception.SystemException {
517                    return getPersistence().filterFindByCompanyId(companyId);
518            }
519    
520            /**
521            * Returns a range of all the layout prototypes that the user has permission to view where companyId = &#63;.
522            *
523            * <p>
524            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
525            * </p>
526            *
527            * @param companyId the company ID
528            * @param start the lower bound of the range of layout prototypes
529            * @param end the upper bound of the range of layout prototypes (not inclusive)
530            * @return the range of matching layout prototypes that the user has permission to view
531            * @throws SystemException if a system exception occurred
532            */
533            public static java.util.List<com.liferay.portal.model.LayoutPrototype> filterFindByCompanyId(
534                    long companyId, int start, int end)
535                    throws com.liferay.portal.kernel.exception.SystemException {
536                    return getPersistence().filterFindByCompanyId(companyId, start, end);
537            }
538    
539            /**
540            * Returns an ordered range of all the layout prototypes that the user has permissions to view where companyId = &#63;.
541            *
542            * <p>
543            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
544            * </p>
545            *
546            * @param companyId the company ID
547            * @param start the lower bound of the range of layout prototypes
548            * @param end the upper bound of the range of layout prototypes (not inclusive)
549            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
550            * @return the ordered range of matching layout prototypes that the user has permission to view
551            * @throws SystemException if a system exception occurred
552            */
553            public static java.util.List<com.liferay.portal.model.LayoutPrototype> filterFindByCompanyId(
554                    long companyId, int start, int end,
555                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
556                    throws com.liferay.portal.kernel.exception.SystemException {
557                    return getPersistence()
558                                       .filterFindByCompanyId(companyId, start, end,
559                            orderByComparator);
560            }
561    
562            /**
563            * Returns the layout prototypes before and after the current layout prototype in the ordered set of layout prototypes that the user has permission to view where companyId = &#63;.
564            *
565            * @param layoutPrototypeId the primary key of the current layout prototype
566            * @param companyId the company ID
567            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
568            * @return the previous, current, and next layout prototype
569            * @throws com.liferay.portal.NoSuchLayoutPrototypeException if a layout prototype with the primary key could not be found
570            * @throws SystemException if a system exception occurred
571            */
572            public static com.liferay.portal.model.LayoutPrototype[] filterFindByCompanyId_PrevAndNext(
573                    long layoutPrototypeId, long companyId,
574                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
575                    throws com.liferay.portal.NoSuchLayoutPrototypeException,
576                            com.liferay.portal.kernel.exception.SystemException {
577                    return getPersistence()
578                                       .filterFindByCompanyId_PrevAndNext(layoutPrototypeId,
579                            companyId, orderByComparator);
580            }
581    
582            /**
583            * Returns all the layout prototypes where companyId = &#63; and active = &#63;.
584            *
585            * @param companyId the company ID
586            * @param active the active
587            * @return the matching layout prototypes
588            * @throws SystemException if a system exception occurred
589            */
590            public static java.util.List<com.liferay.portal.model.LayoutPrototype> findByC_A(
591                    long companyId, boolean active)
592                    throws com.liferay.portal.kernel.exception.SystemException {
593                    return getPersistence().findByC_A(companyId, active);
594            }
595    
596            /**
597            * Returns a range of all the layout prototypes where companyId = &#63; and active = &#63;.
598            *
599            * <p>
600            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
601            * </p>
602            *
603            * @param companyId the company ID
604            * @param active the active
605            * @param start the lower bound of the range of layout prototypes
606            * @param end the upper bound of the range of layout prototypes (not inclusive)
607            * @return the range of matching layout prototypes
608            * @throws SystemException if a system exception occurred
609            */
610            public static java.util.List<com.liferay.portal.model.LayoutPrototype> findByC_A(
611                    long companyId, boolean active, int start, int end)
612                    throws com.liferay.portal.kernel.exception.SystemException {
613                    return getPersistence().findByC_A(companyId, active, start, end);
614            }
615    
616            /**
617            * Returns an ordered range of all the layout prototypes where companyId = &#63; and active = &#63;.
618            *
619            * <p>
620            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
621            * </p>
622            *
623            * @param companyId the company ID
624            * @param active the active
625            * @param start the lower bound of the range of layout prototypes
626            * @param end the upper bound of the range of layout prototypes (not inclusive)
627            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
628            * @return the ordered range of matching layout prototypes
629            * @throws SystemException if a system exception occurred
630            */
631            public static java.util.List<com.liferay.portal.model.LayoutPrototype> findByC_A(
632                    long companyId, boolean active, int start, int end,
633                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
634                    throws com.liferay.portal.kernel.exception.SystemException {
635                    return getPersistence()
636                                       .findByC_A(companyId, active, start, end, orderByComparator);
637            }
638    
639            /**
640            * Returns the first layout prototype in the ordered set where companyId = &#63; and active = &#63;.
641            *
642            * <p>
643            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
644            * </p>
645            *
646            * @param companyId the company ID
647            * @param active the active
648            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
649            * @return the first matching layout prototype
650            * @throws com.liferay.portal.NoSuchLayoutPrototypeException if a matching layout prototype could not be found
651            * @throws SystemException if a system exception occurred
652            */
653            public static com.liferay.portal.model.LayoutPrototype findByC_A_First(
654                    long companyId, boolean active,
655                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
656                    throws com.liferay.portal.NoSuchLayoutPrototypeException,
657                            com.liferay.portal.kernel.exception.SystemException {
658                    return getPersistence()
659                                       .findByC_A_First(companyId, active, orderByComparator);
660            }
661    
662            /**
663            * Returns the last layout prototype in the ordered set where companyId = &#63; and active = &#63;.
664            *
665            * <p>
666            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
667            * </p>
668            *
669            * @param companyId the company ID
670            * @param active the active
671            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
672            * @return the last matching layout prototype
673            * @throws com.liferay.portal.NoSuchLayoutPrototypeException if a matching layout prototype could not be found
674            * @throws SystemException if a system exception occurred
675            */
676            public static com.liferay.portal.model.LayoutPrototype findByC_A_Last(
677                    long companyId, boolean active,
678                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
679                    throws com.liferay.portal.NoSuchLayoutPrototypeException,
680                            com.liferay.portal.kernel.exception.SystemException {
681                    return getPersistence()
682                                       .findByC_A_Last(companyId, active, orderByComparator);
683            }
684    
685            /**
686            * Returns the layout prototypes before and after the current layout prototype in the ordered set where companyId = &#63; and active = &#63;.
687            *
688            * <p>
689            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
690            * </p>
691            *
692            * @param layoutPrototypeId the primary key of the current layout prototype
693            * @param companyId the company ID
694            * @param active the active
695            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
696            * @return the previous, current, and next layout prototype
697            * @throws com.liferay.portal.NoSuchLayoutPrototypeException if a layout prototype with the primary key could not be found
698            * @throws SystemException if a system exception occurred
699            */
700            public static com.liferay.portal.model.LayoutPrototype[] findByC_A_PrevAndNext(
701                    long layoutPrototypeId, long companyId, boolean active,
702                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
703                    throws com.liferay.portal.NoSuchLayoutPrototypeException,
704                            com.liferay.portal.kernel.exception.SystemException {
705                    return getPersistence()
706                                       .findByC_A_PrevAndNext(layoutPrototypeId, companyId, active,
707                            orderByComparator);
708            }
709    
710            /**
711            * Returns all the layout prototypes that the user has permission to view where companyId = &#63; and active = &#63;.
712            *
713            * @param companyId the company ID
714            * @param active the active
715            * @return the matching layout prototypes that the user has permission to view
716            * @throws SystemException if a system exception occurred
717            */
718            public static java.util.List<com.liferay.portal.model.LayoutPrototype> filterFindByC_A(
719                    long companyId, boolean active)
720                    throws com.liferay.portal.kernel.exception.SystemException {
721                    return getPersistence().filterFindByC_A(companyId, active);
722            }
723    
724            /**
725            * Returns a range of all the layout prototypes that the user has permission to view where companyId = &#63; and active = &#63;.
726            *
727            * <p>
728            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
729            * </p>
730            *
731            * @param companyId the company ID
732            * @param active the active
733            * @param start the lower bound of the range of layout prototypes
734            * @param end the upper bound of the range of layout prototypes (not inclusive)
735            * @return the range of matching layout prototypes that the user has permission to view
736            * @throws SystemException if a system exception occurred
737            */
738            public static java.util.List<com.liferay.portal.model.LayoutPrototype> filterFindByC_A(
739                    long companyId, boolean active, int start, int end)
740                    throws com.liferay.portal.kernel.exception.SystemException {
741                    return getPersistence().filterFindByC_A(companyId, active, start, end);
742            }
743    
744            /**
745            * Returns an ordered range of all the layout prototypes that the user has permissions to view where companyId = &#63; and active = &#63;.
746            *
747            * <p>
748            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
749            * </p>
750            *
751            * @param companyId the company ID
752            * @param active the active
753            * @param start the lower bound of the range of layout prototypes
754            * @param end the upper bound of the range of layout prototypes (not inclusive)
755            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
756            * @return the ordered range of matching layout prototypes that the user has permission to view
757            * @throws SystemException if a system exception occurred
758            */
759            public static java.util.List<com.liferay.portal.model.LayoutPrototype> filterFindByC_A(
760                    long companyId, boolean active, int start, int end,
761                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
762                    throws com.liferay.portal.kernel.exception.SystemException {
763                    return getPersistence()
764                                       .filterFindByC_A(companyId, active, start, end,
765                            orderByComparator);
766            }
767    
768            /**
769            * Returns the layout prototypes before and after the current layout prototype in the ordered set of layout prototypes that the user has permission to view where companyId = &#63; and active = &#63;.
770            *
771            * @param layoutPrototypeId the primary key of the current layout prototype
772            * @param companyId the company ID
773            * @param active the active
774            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
775            * @return the previous, current, and next layout prototype
776            * @throws com.liferay.portal.NoSuchLayoutPrototypeException if a layout prototype with the primary key could not be found
777            * @throws SystemException if a system exception occurred
778            */
779            public static com.liferay.portal.model.LayoutPrototype[] filterFindByC_A_PrevAndNext(
780                    long layoutPrototypeId, long companyId, boolean active,
781                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
782                    throws com.liferay.portal.NoSuchLayoutPrototypeException,
783                            com.liferay.portal.kernel.exception.SystemException {
784                    return getPersistence()
785                                       .filterFindByC_A_PrevAndNext(layoutPrototypeId, companyId,
786                            active, orderByComparator);
787            }
788    
789            /**
790            * Returns all the layout prototypes.
791            *
792            * @return the layout prototypes
793            * @throws SystemException if a system exception occurred
794            */
795            public static java.util.List<com.liferay.portal.model.LayoutPrototype> findAll()
796                    throws com.liferay.portal.kernel.exception.SystemException {
797                    return getPersistence().findAll();
798            }
799    
800            /**
801            * Returns a range of all the layout prototypes.
802            *
803            * <p>
804            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
805            * </p>
806            *
807            * @param start the lower bound of the range of layout prototypes
808            * @param end the upper bound of the range of layout prototypes (not inclusive)
809            * @return the range of layout prototypes
810            * @throws SystemException if a system exception occurred
811            */
812            public static java.util.List<com.liferay.portal.model.LayoutPrototype> findAll(
813                    int start, int end)
814                    throws com.liferay.portal.kernel.exception.SystemException {
815                    return getPersistence().findAll(start, end);
816            }
817    
818            /**
819            * Returns an ordered range of all the layout prototypes.
820            *
821            * <p>
822            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
823            * </p>
824            *
825            * @param start the lower bound of the range of layout prototypes
826            * @param end the upper bound of the range of layout prototypes (not inclusive)
827            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
828            * @return the ordered range of layout prototypes
829            * @throws SystemException if a system exception occurred
830            */
831            public static java.util.List<com.liferay.portal.model.LayoutPrototype> findAll(
832                    int start, int end,
833                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
834                    throws com.liferay.portal.kernel.exception.SystemException {
835                    return getPersistence().findAll(start, end, orderByComparator);
836            }
837    
838            /**
839            * Removes all the layout prototypes where uuid = &#63; from the database.
840            *
841            * @param uuid the uuid
842            * @throws SystemException if a system exception occurred
843            */
844            public static void removeByUuid(java.lang.String uuid)
845                    throws com.liferay.portal.kernel.exception.SystemException {
846                    getPersistence().removeByUuid(uuid);
847            }
848    
849            /**
850            * Removes all the layout prototypes where companyId = &#63; from the database.
851            *
852            * @param companyId the company ID
853            * @throws SystemException if a system exception occurred
854            */
855            public static void removeByCompanyId(long companyId)
856                    throws com.liferay.portal.kernel.exception.SystemException {
857                    getPersistence().removeByCompanyId(companyId);
858            }
859    
860            /**
861            * Removes all the layout prototypes where companyId = &#63; and active = &#63; from the database.
862            *
863            * @param companyId the company ID
864            * @param active the active
865            * @throws SystemException if a system exception occurred
866            */
867            public static void removeByC_A(long companyId, boolean active)
868                    throws com.liferay.portal.kernel.exception.SystemException {
869                    getPersistence().removeByC_A(companyId, active);
870            }
871    
872            /**
873            * Removes all the layout prototypes from the database.
874            *
875            * @throws SystemException if a system exception occurred
876            */
877            public static void removeAll()
878                    throws com.liferay.portal.kernel.exception.SystemException {
879                    getPersistence().removeAll();
880            }
881    
882            /**
883            * Returns the number of layout prototypes where uuid = &#63;.
884            *
885            * @param uuid the uuid
886            * @return the number of matching layout prototypes
887            * @throws SystemException if a system exception occurred
888            */
889            public static int countByUuid(java.lang.String uuid)
890                    throws com.liferay.portal.kernel.exception.SystemException {
891                    return getPersistence().countByUuid(uuid);
892            }
893    
894            /**
895            * Returns the number of layout prototypes that the user has permission to view where uuid = &#63;.
896            *
897            * @param uuid the uuid
898            * @return the number of matching layout prototypes that the user has permission to view
899            * @throws SystemException if a system exception occurred
900            */
901            public static int filterCountByUuid(java.lang.String uuid)
902                    throws com.liferay.portal.kernel.exception.SystemException {
903                    return getPersistence().filterCountByUuid(uuid);
904            }
905    
906            /**
907            * Returns the number of layout prototypes where companyId = &#63;.
908            *
909            * @param companyId the company ID
910            * @return the number of matching layout prototypes
911            * @throws SystemException if a system exception occurred
912            */
913            public static int countByCompanyId(long companyId)
914                    throws com.liferay.portal.kernel.exception.SystemException {
915                    return getPersistence().countByCompanyId(companyId);
916            }
917    
918            /**
919            * Returns the number of layout prototypes that the user has permission to view where companyId = &#63;.
920            *
921            * @param companyId the company ID
922            * @return the number of matching layout prototypes that the user has permission to view
923            * @throws SystemException if a system exception occurred
924            */
925            public static int filterCountByCompanyId(long companyId)
926                    throws com.liferay.portal.kernel.exception.SystemException {
927                    return getPersistence().filterCountByCompanyId(companyId);
928            }
929    
930            /**
931            * Returns the number of layout prototypes where companyId = &#63; and active = &#63;.
932            *
933            * @param companyId the company ID
934            * @param active the active
935            * @return the number of matching layout prototypes
936            * @throws SystemException if a system exception occurred
937            */
938            public static int countByC_A(long companyId, boolean active)
939                    throws com.liferay.portal.kernel.exception.SystemException {
940                    return getPersistence().countByC_A(companyId, active);
941            }
942    
943            /**
944            * Returns the number of layout prototypes that the user has permission to view where companyId = &#63; and active = &#63;.
945            *
946            * @param companyId the company ID
947            * @param active the active
948            * @return the number of matching layout prototypes that the user has permission to view
949            * @throws SystemException if a system exception occurred
950            */
951            public static int filterCountByC_A(long companyId, boolean active)
952                    throws com.liferay.portal.kernel.exception.SystemException {
953                    return getPersistence().filterCountByC_A(companyId, active);
954            }
955    
956            /**
957            * Returns the number of layout prototypes.
958            *
959            * @return the number of layout prototypes
960            * @throws SystemException if a system exception occurred
961            */
962            public static int countAll()
963                    throws com.liferay.portal.kernel.exception.SystemException {
964                    return getPersistence().countAll();
965            }
966    
967            public static LayoutPrototypePersistence getPersistence() {
968                    if (_persistence == null) {
969                            _persistence = (LayoutPrototypePersistence)PortalBeanLocatorUtil.locate(LayoutPrototypePersistence.class.getName());
970    
971                            ReferenceRegistry.registerReference(LayoutPrototypeUtil.class,
972                                    "_persistence");
973                    }
974    
975                    return _persistence;
976            }
977    
978            public void setPersistence(LayoutPrototypePersistence persistence) {
979                    _persistence = persistence;
980    
981                    ReferenceRegistry.registerReference(LayoutPrototypeUtil.class,
982                            "_persistence");
983            }
984    
985            private static LayoutPrototypePersistence _persistence;
986    }