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