001    /**
002     * Copyright (c) 2000-present Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portal.service.persistence;
016    
017    import aQute.bnd.annotation.ProviderType;
018    
019    import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil;
020    import com.liferay.portal.kernel.dao.orm.DynamicQuery;
021    import com.liferay.portal.kernel.util.OrderByComparator;
022    import com.liferay.portal.kernel.util.ReferenceRegistry;
023    import com.liferay.portal.model.LayoutSetPrototype;
024    import com.liferay.portal.service.ServiceContext;
025    
026    import java.util.List;
027    
028    /**
029     * The persistence utility for the layout set prototype service. This utility wraps {@link com.liferay.portal.service.persistence.impl.LayoutSetPrototypePersistenceImpl} 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.
030     *
031     * <p>
032     * Caching information and settings can be found in <code>portal.properties</code>
033     * </p>
034     *
035     * @author Brian Wing Shun Chan
036     * @see LayoutSetPrototypePersistence
037     * @see com.liferay.portal.service.persistence.impl.LayoutSetPrototypePersistenceImpl
038     * @generated
039     */
040    @ProviderType
041    public class LayoutSetPrototypeUtil {
042            /*
043             * NOTE FOR DEVELOPERS:
044             *
045             * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
046             */
047    
048            /**
049             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
050             */
051            public static void clearCache() {
052                    getPersistence().clearCache();
053            }
054    
055            /**
056             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
057             */
058            public static void clearCache(LayoutSetPrototype layoutSetPrototype) {
059                    getPersistence().clearCache(layoutSetPrototype);
060            }
061    
062            /**
063             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
064             */
065            public static long countWithDynamicQuery(DynamicQuery dynamicQuery) {
066                    return getPersistence().countWithDynamicQuery(dynamicQuery);
067            }
068    
069            /**
070             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
071             */
072            public static List<LayoutSetPrototype> findWithDynamicQuery(
073                    DynamicQuery dynamicQuery) {
074                    return getPersistence().findWithDynamicQuery(dynamicQuery);
075            }
076    
077            /**
078             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
079             */
080            public static List<LayoutSetPrototype> findWithDynamicQuery(
081                    DynamicQuery dynamicQuery, int start, int end) {
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<LayoutSetPrototype> findWithDynamicQuery(
089                    DynamicQuery dynamicQuery, int start, int end,
090                    OrderByComparator<LayoutSetPrototype> orderByComparator) {
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)
098             */
099            public static LayoutSetPrototype update(
100                    LayoutSetPrototype layoutSetPrototype) {
101                    return getPersistence().update(layoutSetPrototype);
102            }
103    
104            /**
105             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
106             */
107            public static LayoutSetPrototype update(
108                    LayoutSetPrototype layoutSetPrototype, ServiceContext serviceContext) {
109                    return getPersistence().update(layoutSetPrototype, serviceContext);
110            }
111    
112            /**
113            * Returns all the layout set prototypes where uuid = &#63;.
114            *
115            * @param uuid the uuid
116            * @return the matching layout set prototypes
117            */
118            public static List<LayoutSetPrototype> findByUuid(java.lang.String uuid) {
119                    return getPersistence().findByUuid(uuid);
120            }
121    
122            /**
123            * Returns a range of all the layout set prototypes where uuid = &#63;.
124            *
125            * <p>
126            * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
127            * </p>
128            *
129            * @param uuid the uuid
130            * @param start the lower bound of the range of layout set prototypes
131            * @param end the upper bound of the range of layout set prototypes (not inclusive)
132            * @return the range of matching layout set prototypes
133            */
134            public static List<LayoutSetPrototype> findByUuid(java.lang.String uuid,
135                    int start, int end) {
136                    return getPersistence().findByUuid(uuid, start, end);
137            }
138    
139            /**
140            * Returns an ordered range of all the layout set prototypes where uuid = &#63;.
141            *
142            * <p>
143            * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
144            * </p>
145            *
146            * @param uuid the uuid
147            * @param start the lower bound of the range of layout set prototypes
148            * @param end the upper bound of the range of layout set prototypes (not inclusive)
149            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
150            * @return the ordered range of matching layout set prototypes
151            */
152            public static List<LayoutSetPrototype> findByUuid(java.lang.String uuid,
153                    int start, int end,
154                    OrderByComparator<LayoutSetPrototype> orderByComparator) {
155                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
156            }
157    
158            /**
159            * Returns the first layout set prototype in the ordered set where uuid = &#63;.
160            *
161            * @param uuid the uuid
162            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
163            * @return the first matching layout set prototype
164            * @throws NoSuchLayoutSetPrototypeException if a matching layout set prototype could not be found
165            */
166            public static LayoutSetPrototype findByUuid_First(java.lang.String uuid,
167                    OrderByComparator<LayoutSetPrototype> orderByComparator)
168                    throws com.liferay.portal.NoSuchLayoutSetPrototypeException {
169                    return getPersistence().findByUuid_First(uuid, orderByComparator);
170            }
171    
172            /**
173            * Returns the first layout set prototype in the ordered set where uuid = &#63;.
174            *
175            * @param uuid the uuid
176            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
177            * @return the first matching layout set prototype, or <code>null</code> if a matching layout set prototype could not be found
178            */
179            public static LayoutSetPrototype fetchByUuid_First(java.lang.String uuid,
180                    OrderByComparator<LayoutSetPrototype> orderByComparator) {
181                    return getPersistence().fetchByUuid_First(uuid, orderByComparator);
182            }
183    
184            /**
185            * Returns the last layout set prototype in the ordered set where uuid = &#63;.
186            *
187            * @param uuid the uuid
188            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
189            * @return the last matching layout set prototype
190            * @throws NoSuchLayoutSetPrototypeException if a matching layout set prototype could not be found
191            */
192            public static LayoutSetPrototype findByUuid_Last(java.lang.String uuid,
193                    OrderByComparator<LayoutSetPrototype> orderByComparator)
194                    throws com.liferay.portal.NoSuchLayoutSetPrototypeException {
195                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
196            }
197    
198            /**
199            * Returns the last layout set prototype in the ordered set where uuid = &#63;.
200            *
201            * @param uuid the uuid
202            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
203            * @return the last matching layout set prototype, or <code>null</code> if a matching layout set prototype could not be found
204            */
205            public static LayoutSetPrototype fetchByUuid_Last(java.lang.String uuid,
206                    OrderByComparator<LayoutSetPrototype> orderByComparator) {
207                    return getPersistence().fetchByUuid_Last(uuid, orderByComparator);
208            }
209    
210            /**
211            * Returns the layout set prototypes before and after the current layout set prototype in the ordered set where uuid = &#63;.
212            *
213            * @param layoutSetPrototypeId the primary key of the current layout set prototype
214            * @param uuid the uuid
215            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
216            * @return the previous, current, and next layout set prototype
217            * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found
218            */
219            public static LayoutSetPrototype[] findByUuid_PrevAndNext(
220                    long layoutSetPrototypeId, java.lang.String uuid,
221                    OrderByComparator<LayoutSetPrototype> orderByComparator)
222                    throws com.liferay.portal.NoSuchLayoutSetPrototypeException {
223                    return getPersistence()
224                                       .findByUuid_PrevAndNext(layoutSetPrototypeId, uuid,
225                            orderByComparator);
226            }
227    
228            /**
229            * Returns all the layout set prototypes that the user has permission to view where uuid = &#63;.
230            *
231            * @param uuid the uuid
232            * @return the matching layout set prototypes that the user has permission to view
233            */
234            public static List<LayoutSetPrototype> filterFindByUuid(
235                    java.lang.String uuid) {
236                    return getPersistence().filterFindByUuid(uuid);
237            }
238    
239            /**
240            * Returns a range of all the layout set prototypes that the user has permission to view where uuid = &#63;.
241            *
242            * <p>
243            * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
244            * </p>
245            *
246            * @param uuid the uuid
247            * @param start the lower bound of the range of layout set prototypes
248            * @param end the upper bound of the range of layout set prototypes (not inclusive)
249            * @return the range of matching layout set prototypes that the user has permission to view
250            */
251            public static List<LayoutSetPrototype> filterFindByUuid(
252                    java.lang.String uuid, int start, int end) {
253                    return getPersistence().filterFindByUuid(uuid, start, end);
254            }
255    
256            /**
257            * Returns an ordered range of all the layout set prototypes that the user has permissions to view where uuid = &#63;.
258            *
259            * <p>
260            * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
261            * </p>
262            *
263            * @param uuid the uuid
264            * @param start the lower bound of the range of layout set prototypes
265            * @param end the upper bound of the range of layout set prototypes (not inclusive)
266            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
267            * @return the ordered range of matching layout set prototypes that the user has permission to view
268            */
269            public static List<LayoutSetPrototype> filterFindByUuid(
270                    java.lang.String uuid, int start, int end,
271                    OrderByComparator<LayoutSetPrototype> orderByComparator) {
272                    return getPersistence()
273                                       .filterFindByUuid(uuid, start, end, orderByComparator);
274            }
275    
276            /**
277            * Returns the layout set prototypes before and after the current layout set prototype in the ordered set of layout set prototypes that the user has permission to view where uuid = &#63;.
278            *
279            * @param layoutSetPrototypeId the primary key of the current layout set prototype
280            * @param uuid the uuid
281            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
282            * @return the previous, current, and next layout set prototype
283            * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found
284            */
285            public static LayoutSetPrototype[] filterFindByUuid_PrevAndNext(
286                    long layoutSetPrototypeId, java.lang.String uuid,
287                    OrderByComparator<LayoutSetPrototype> orderByComparator)
288                    throws com.liferay.portal.NoSuchLayoutSetPrototypeException {
289                    return getPersistence()
290                                       .filterFindByUuid_PrevAndNext(layoutSetPrototypeId, uuid,
291                            orderByComparator);
292            }
293    
294            /**
295            * Removes all the layout set prototypes where uuid = &#63; from the database.
296            *
297            * @param uuid the uuid
298            */
299            public static void removeByUuid(java.lang.String uuid) {
300                    getPersistence().removeByUuid(uuid);
301            }
302    
303            /**
304            * Returns the number of layout set prototypes where uuid = &#63;.
305            *
306            * @param uuid the uuid
307            * @return the number of matching layout set prototypes
308            */
309            public static int countByUuid(java.lang.String uuid) {
310                    return getPersistence().countByUuid(uuid);
311            }
312    
313            /**
314            * Returns the number of layout set prototypes that the user has permission to view where uuid = &#63;.
315            *
316            * @param uuid the uuid
317            * @return the number of matching layout set prototypes that the user has permission to view
318            */
319            public static int filterCountByUuid(java.lang.String uuid) {
320                    return getPersistence().filterCountByUuid(uuid);
321            }
322    
323            /**
324            * Returns all the layout set prototypes where uuid = &#63; and companyId = &#63;.
325            *
326            * @param uuid the uuid
327            * @param companyId the company ID
328            * @return the matching layout set prototypes
329            */
330            public static List<LayoutSetPrototype> findByUuid_C(java.lang.String uuid,
331                    long companyId) {
332                    return getPersistence().findByUuid_C(uuid, companyId);
333            }
334    
335            /**
336            * Returns a range of all the layout set prototypes where uuid = &#63; and companyId = &#63;.
337            *
338            * <p>
339            * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
340            * </p>
341            *
342            * @param uuid the uuid
343            * @param companyId the company ID
344            * @param start the lower bound of the range of layout set prototypes
345            * @param end the upper bound of the range of layout set prototypes (not inclusive)
346            * @return the range of matching layout set prototypes
347            */
348            public static List<LayoutSetPrototype> findByUuid_C(java.lang.String uuid,
349                    long companyId, int start, int end) {
350                    return getPersistence().findByUuid_C(uuid, companyId, start, end);
351            }
352    
353            /**
354            * Returns an ordered range of all the layout set prototypes where uuid = &#63; and companyId = &#63;.
355            *
356            * <p>
357            * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
358            * </p>
359            *
360            * @param uuid the uuid
361            * @param companyId the company ID
362            * @param start the lower bound of the range of layout set prototypes
363            * @param end the upper bound of the range of layout set prototypes (not inclusive)
364            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
365            * @return the ordered range of matching layout set prototypes
366            */
367            public static List<LayoutSetPrototype> findByUuid_C(java.lang.String uuid,
368                    long companyId, int start, int end,
369                    OrderByComparator<LayoutSetPrototype> orderByComparator) {
370                    return getPersistence()
371                                       .findByUuid_C(uuid, companyId, start, end, orderByComparator);
372            }
373    
374            /**
375            * Returns the first layout set prototype in the ordered set where uuid = &#63; and companyId = &#63;.
376            *
377            * @param uuid the uuid
378            * @param companyId the company ID
379            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
380            * @return the first matching layout set prototype
381            * @throws NoSuchLayoutSetPrototypeException if a matching layout set prototype could not be found
382            */
383            public static LayoutSetPrototype findByUuid_C_First(java.lang.String uuid,
384                    long companyId, OrderByComparator<LayoutSetPrototype> orderByComparator)
385                    throws com.liferay.portal.NoSuchLayoutSetPrototypeException {
386                    return getPersistence()
387                                       .findByUuid_C_First(uuid, companyId, orderByComparator);
388            }
389    
390            /**
391            * Returns the first layout set prototype in the ordered set where uuid = &#63; and companyId = &#63;.
392            *
393            * @param uuid the uuid
394            * @param companyId the company ID
395            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
396            * @return the first matching layout set prototype, or <code>null</code> if a matching layout set prototype could not be found
397            */
398            public static LayoutSetPrototype fetchByUuid_C_First(
399                    java.lang.String uuid, long companyId,
400                    OrderByComparator<LayoutSetPrototype> orderByComparator) {
401                    return getPersistence()
402                                       .fetchByUuid_C_First(uuid, companyId, orderByComparator);
403            }
404    
405            /**
406            * Returns the last layout set prototype in the ordered set where uuid = &#63; and companyId = &#63;.
407            *
408            * @param uuid the uuid
409            * @param companyId the company ID
410            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
411            * @return the last matching layout set prototype
412            * @throws NoSuchLayoutSetPrototypeException if a matching layout set prototype could not be found
413            */
414            public static LayoutSetPrototype findByUuid_C_Last(java.lang.String uuid,
415                    long companyId, OrderByComparator<LayoutSetPrototype> orderByComparator)
416                    throws com.liferay.portal.NoSuchLayoutSetPrototypeException {
417                    return getPersistence()
418                                       .findByUuid_C_Last(uuid, companyId, orderByComparator);
419            }
420    
421            /**
422            * Returns the last layout set prototype in the ordered set where uuid = &#63; and companyId = &#63;.
423            *
424            * @param uuid the uuid
425            * @param companyId the company ID
426            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
427            * @return the last matching layout set prototype, or <code>null</code> if a matching layout set prototype could not be found
428            */
429            public static LayoutSetPrototype fetchByUuid_C_Last(java.lang.String uuid,
430                    long companyId, OrderByComparator<LayoutSetPrototype> orderByComparator) {
431                    return getPersistence()
432                                       .fetchByUuid_C_Last(uuid, companyId, orderByComparator);
433            }
434    
435            /**
436            * Returns the layout set prototypes before and after the current layout set prototype in the ordered set where uuid = &#63; and companyId = &#63;.
437            *
438            * @param layoutSetPrototypeId the primary key of the current layout set prototype
439            * @param uuid the uuid
440            * @param companyId the company ID
441            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
442            * @return the previous, current, and next layout set prototype
443            * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found
444            */
445            public static LayoutSetPrototype[] findByUuid_C_PrevAndNext(
446                    long layoutSetPrototypeId, java.lang.String uuid, long companyId,
447                    OrderByComparator<LayoutSetPrototype> orderByComparator)
448                    throws com.liferay.portal.NoSuchLayoutSetPrototypeException {
449                    return getPersistence()
450                                       .findByUuid_C_PrevAndNext(layoutSetPrototypeId, uuid,
451                            companyId, orderByComparator);
452            }
453    
454            /**
455            * Returns all the layout set prototypes that the user has permission to view where uuid = &#63; and companyId = &#63;.
456            *
457            * @param uuid the uuid
458            * @param companyId the company ID
459            * @return the matching layout set prototypes that the user has permission to view
460            */
461            public static List<LayoutSetPrototype> filterFindByUuid_C(
462                    java.lang.String uuid, long companyId) {
463                    return getPersistence().filterFindByUuid_C(uuid, companyId);
464            }
465    
466            /**
467            * Returns a range of all the layout set prototypes that the user has permission to view where uuid = &#63; and companyId = &#63;.
468            *
469            * <p>
470            * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
471            * </p>
472            *
473            * @param uuid the uuid
474            * @param companyId the company ID
475            * @param start the lower bound of the range of layout set prototypes
476            * @param end the upper bound of the range of layout set prototypes (not inclusive)
477            * @return the range of matching layout set prototypes that the user has permission to view
478            */
479            public static List<LayoutSetPrototype> filterFindByUuid_C(
480                    java.lang.String uuid, long companyId, int start, int end) {
481                    return getPersistence().filterFindByUuid_C(uuid, companyId, start, end);
482            }
483    
484            /**
485            * Returns an ordered range of all the layout set prototypes that the user has permissions to view where uuid = &#63; and companyId = &#63;.
486            *
487            * <p>
488            * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
489            * </p>
490            *
491            * @param uuid the uuid
492            * @param companyId the company ID
493            * @param start the lower bound of the range of layout set prototypes
494            * @param end the upper bound of the range of layout set prototypes (not inclusive)
495            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
496            * @return the ordered range of matching layout set prototypes that the user has permission to view
497            */
498            public static List<LayoutSetPrototype> filterFindByUuid_C(
499                    java.lang.String uuid, long companyId, int start, int end,
500                    OrderByComparator<LayoutSetPrototype> orderByComparator) {
501                    return getPersistence()
502                                       .filterFindByUuid_C(uuid, companyId, start, end,
503                            orderByComparator);
504            }
505    
506            /**
507            * Returns the layout set prototypes before and after the current layout set prototype in the ordered set of layout set prototypes that the user has permission to view where uuid = &#63; and companyId = &#63;.
508            *
509            * @param layoutSetPrototypeId the primary key of the current layout set prototype
510            * @param uuid the uuid
511            * @param companyId the company ID
512            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
513            * @return the previous, current, and next layout set prototype
514            * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found
515            */
516            public static LayoutSetPrototype[] filterFindByUuid_C_PrevAndNext(
517                    long layoutSetPrototypeId, java.lang.String uuid, long companyId,
518                    OrderByComparator<LayoutSetPrototype> orderByComparator)
519                    throws com.liferay.portal.NoSuchLayoutSetPrototypeException {
520                    return getPersistence()
521                                       .filterFindByUuid_C_PrevAndNext(layoutSetPrototypeId, uuid,
522                            companyId, orderByComparator);
523            }
524    
525            /**
526            * Removes all the layout set prototypes where uuid = &#63; and companyId = &#63; from the database.
527            *
528            * @param uuid the uuid
529            * @param companyId the company ID
530            */
531            public static void removeByUuid_C(java.lang.String uuid, long companyId) {
532                    getPersistence().removeByUuid_C(uuid, companyId);
533            }
534    
535            /**
536            * Returns the number of layout set prototypes where uuid = &#63; and companyId = &#63;.
537            *
538            * @param uuid the uuid
539            * @param companyId the company ID
540            * @return the number of matching layout set prototypes
541            */
542            public static int countByUuid_C(java.lang.String uuid, long companyId) {
543                    return getPersistence().countByUuid_C(uuid, companyId);
544            }
545    
546            /**
547            * Returns the number of layout set prototypes that the user has permission to view where uuid = &#63; and companyId = &#63;.
548            *
549            * @param uuid the uuid
550            * @param companyId the company ID
551            * @return the number of matching layout set prototypes that the user has permission to view
552            */
553            public static int filterCountByUuid_C(java.lang.String uuid, long companyId) {
554                    return getPersistence().filterCountByUuid_C(uuid, companyId);
555            }
556    
557            /**
558            * Returns all the layout set prototypes where companyId = &#63;.
559            *
560            * @param companyId the company ID
561            * @return the matching layout set prototypes
562            */
563            public static List<LayoutSetPrototype> findByCompanyId(long companyId) {
564                    return getPersistence().findByCompanyId(companyId);
565            }
566    
567            /**
568            * Returns a range of all the layout set prototypes where companyId = &#63;.
569            *
570            * <p>
571            * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
572            * </p>
573            *
574            * @param companyId the company ID
575            * @param start the lower bound of the range of layout set prototypes
576            * @param end the upper bound of the range of layout set prototypes (not inclusive)
577            * @return the range of matching layout set prototypes
578            */
579            public static List<LayoutSetPrototype> findByCompanyId(long companyId,
580                    int start, int end) {
581                    return getPersistence().findByCompanyId(companyId, start, end);
582            }
583    
584            /**
585            * Returns an ordered range of all the layout set prototypes where companyId = &#63;.
586            *
587            * <p>
588            * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
589            * </p>
590            *
591            * @param companyId the company ID
592            * @param start the lower bound of the range of layout set prototypes
593            * @param end the upper bound of the range of layout set prototypes (not inclusive)
594            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
595            * @return the ordered range of matching layout set prototypes
596            */
597            public static List<LayoutSetPrototype> findByCompanyId(long companyId,
598                    int start, int end,
599                    OrderByComparator<LayoutSetPrototype> orderByComparator) {
600                    return getPersistence()
601                                       .findByCompanyId(companyId, start, end, orderByComparator);
602            }
603    
604            /**
605            * Returns the first layout set prototype in the ordered set where companyId = &#63;.
606            *
607            * @param companyId the company ID
608            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
609            * @return the first matching layout set prototype
610            * @throws NoSuchLayoutSetPrototypeException if a matching layout set prototype could not be found
611            */
612            public static LayoutSetPrototype findByCompanyId_First(long companyId,
613                    OrderByComparator<LayoutSetPrototype> orderByComparator)
614                    throws com.liferay.portal.NoSuchLayoutSetPrototypeException {
615                    return getPersistence()
616                                       .findByCompanyId_First(companyId, orderByComparator);
617            }
618    
619            /**
620            * Returns the first layout set prototype in the ordered set where companyId = &#63;.
621            *
622            * @param companyId the company ID
623            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
624            * @return the first matching layout set prototype, or <code>null</code> if a matching layout set prototype could not be found
625            */
626            public static LayoutSetPrototype fetchByCompanyId_First(long companyId,
627                    OrderByComparator<LayoutSetPrototype> orderByComparator) {
628                    return getPersistence()
629                                       .fetchByCompanyId_First(companyId, orderByComparator);
630            }
631    
632            /**
633            * Returns the last layout set prototype in the ordered set where companyId = &#63;.
634            *
635            * @param companyId the company ID
636            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
637            * @return the last matching layout set prototype
638            * @throws NoSuchLayoutSetPrototypeException if a matching layout set prototype could not be found
639            */
640            public static LayoutSetPrototype findByCompanyId_Last(long companyId,
641                    OrderByComparator<LayoutSetPrototype> orderByComparator)
642                    throws com.liferay.portal.NoSuchLayoutSetPrototypeException {
643                    return getPersistence()
644                                       .findByCompanyId_Last(companyId, orderByComparator);
645            }
646    
647            /**
648            * Returns the last layout set prototype in the ordered set where companyId = &#63;.
649            *
650            * @param companyId the company ID
651            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
652            * @return the last matching layout set prototype, or <code>null</code> if a matching layout set prototype could not be found
653            */
654            public static LayoutSetPrototype fetchByCompanyId_Last(long companyId,
655                    OrderByComparator<LayoutSetPrototype> orderByComparator) {
656                    return getPersistence()
657                                       .fetchByCompanyId_Last(companyId, orderByComparator);
658            }
659    
660            /**
661            * Returns the layout set prototypes before and after the current layout set prototype in the ordered set where companyId = &#63;.
662            *
663            * @param layoutSetPrototypeId the primary key of the current layout set prototype
664            * @param companyId the company ID
665            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
666            * @return the previous, current, and next layout set prototype
667            * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found
668            */
669            public static LayoutSetPrototype[] findByCompanyId_PrevAndNext(
670                    long layoutSetPrototypeId, long companyId,
671                    OrderByComparator<LayoutSetPrototype> orderByComparator)
672                    throws com.liferay.portal.NoSuchLayoutSetPrototypeException {
673                    return getPersistence()
674                                       .findByCompanyId_PrevAndNext(layoutSetPrototypeId,
675                            companyId, orderByComparator);
676            }
677    
678            /**
679            * Returns all the layout set prototypes that the user has permission to view where companyId = &#63;.
680            *
681            * @param companyId the company ID
682            * @return the matching layout set prototypes that the user has permission to view
683            */
684            public static List<LayoutSetPrototype> filterFindByCompanyId(long companyId) {
685                    return getPersistence().filterFindByCompanyId(companyId);
686            }
687    
688            /**
689            * Returns a range of all the layout set prototypes that the user has permission to view where companyId = &#63;.
690            *
691            * <p>
692            * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
693            * </p>
694            *
695            * @param companyId the company ID
696            * @param start the lower bound of the range of layout set prototypes
697            * @param end the upper bound of the range of layout set prototypes (not inclusive)
698            * @return the range of matching layout set prototypes that the user has permission to view
699            */
700            public static List<LayoutSetPrototype> filterFindByCompanyId(
701                    long companyId, int start, int end) {
702                    return getPersistence().filterFindByCompanyId(companyId, start, end);
703            }
704    
705            /**
706            * Returns an ordered range of all the layout set prototypes that the user has permissions to view where companyId = &#63;.
707            *
708            * <p>
709            * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
710            * </p>
711            *
712            * @param companyId the company ID
713            * @param start the lower bound of the range of layout set prototypes
714            * @param end the upper bound of the range of layout set prototypes (not inclusive)
715            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
716            * @return the ordered range of matching layout set prototypes that the user has permission to view
717            */
718            public static List<LayoutSetPrototype> filterFindByCompanyId(
719                    long companyId, int start, int end,
720                    OrderByComparator<LayoutSetPrototype> orderByComparator) {
721                    return getPersistence()
722                                       .filterFindByCompanyId(companyId, start, end,
723                            orderByComparator);
724            }
725    
726            /**
727            * Returns the layout set prototypes before and after the current layout set prototype in the ordered set of layout set prototypes that the user has permission to view where companyId = &#63;.
728            *
729            * @param layoutSetPrototypeId the primary key of the current layout set prototype
730            * @param companyId the company ID
731            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
732            * @return the previous, current, and next layout set prototype
733            * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found
734            */
735            public static LayoutSetPrototype[] filterFindByCompanyId_PrevAndNext(
736                    long layoutSetPrototypeId, long companyId,
737                    OrderByComparator<LayoutSetPrototype> orderByComparator)
738                    throws com.liferay.portal.NoSuchLayoutSetPrototypeException {
739                    return getPersistence()
740                                       .filterFindByCompanyId_PrevAndNext(layoutSetPrototypeId,
741                            companyId, orderByComparator);
742            }
743    
744            /**
745            * Removes all the layout set prototypes where companyId = &#63; from the database.
746            *
747            * @param companyId the company ID
748            */
749            public static void removeByCompanyId(long companyId) {
750                    getPersistence().removeByCompanyId(companyId);
751            }
752    
753            /**
754            * Returns the number of layout set prototypes where companyId = &#63;.
755            *
756            * @param companyId the company ID
757            * @return the number of matching layout set prototypes
758            */
759            public static int countByCompanyId(long companyId) {
760                    return getPersistence().countByCompanyId(companyId);
761            }
762    
763            /**
764            * Returns the number of layout set prototypes that the user has permission to view where companyId = &#63;.
765            *
766            * @param companyId the company ID
767            * @return the number of matching layout set prototypes that the user has permission to view
768            */
769            public static int filterCountByCompanyId(long companyId) {
770                    return getPersistence().filterCountByCompanyId(companyId);
771            }
772    
773            /**
774            * Returns all the layout set prototypes where companyId = &#63; and active = &#63;.
775            *
776            * @param companyId the company ID
777            * @param active the active
778            * @return the matching layout set prototypes
779            */
780            public static List<LayoutSetPrototype> findByC_A(long companyId,
781                    boolean active) {
782                    return getPersistence().findByC_A(companyId, active);
783            }
784    
785            /**
786            * Returns a range of all the layout set prototypes where companyId = &#63; and active = &#63;.
787            *
788            * <p>
789            * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
790            * </p>
791            *
792            * @param companyId the company ID
793            * @param active the active
794            * @param start the lower bound of the range of layout set prototypes
795            * @param end the upper bound of the range of layout set prototypes (not inclusive)
796            * @return the range of matching layout set prototypes
797            */
798            public static List<LayoutSetPrototype> findByC_A(long companyId,
799                    boolean active, int start, int end) {
800                    return getPersistence().findByC_A(companyId, active, start, end);
801            }
802    
803            /**
804            * Returns an ordered range of all the layout set prototypes where companyId = &#63; and active = &#63;.
805            *
806            * <p>
807            * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
808            * </p>
809            *
810            * @param companyId the company ID
811            * @param active the active
812            * @param start the lower bound of the range of layout set prototypes
813            * @param end the upper bound of the range of layout set prototypes (not inclusive)
814            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
815            * @return the ordered range of matching layout set prototypes
816            */
817            public static List<LayoutSetPrototype> findByC_A(long companyId,
818                    boolean active, int start, int end,
819                    OrderByComparator<LayoutSetPrototype> orderByComparator) {
820                    return getPersistence()
821                                       .findByC_A(companyId, active, start, end, orderByComparator);
822            }
823    
824            /**
825            * Returns the first layout set prototype in the ordered set where companyId = &#63; and active = &#63;.
826            *
827            * @param companyId the company ID
828            * @param active the active
829            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
830            * @return the first matching layout set prototype
831            * @throws NoSuchLayoutSetPrototypeException if a matching layout set prototype could not be found
832            */
833            public static LayoutSetPrototype findByC_A_First(long companyId,
834                    boolean active, OrderByComparator<LayoutSetPrototype> orderByComparator)
835                    throws com.liferay.portal.NoSuchLayoutSetPrototypeException {
836                    return getPersistence()
837                                       .findByC_A_First(companyId, active, orderByComparator);
838            }
839    
840            /**
841            * Returns the first layout set prototype in the ordered set where companyId = &#63; and active = &#63;.
842            *
843            * @param companyId the company ID
844            * @param active the active
845            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
846            * @return the first matching layout set prototype, or <code>null</code> if a matching layout set prototype could not be found
847            */
848            public static LayoutSetPrototype fetchByC_A_First(long companyId,
849                    boolean active, OrderByComparator<LayoutSetPrototype> orderByComparator) {
850                    return getPersistence()
851                                       .fetchByC_A_First(companyId, active, orderByComparator);
852            }
853    
854            /**
855            * Returns the last layout set prototype in the ordered set where companyId = &#63; and active = &#63;.
856            *
857            * @param companyId the company ID
858            * @param active the active
859            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
860            * @return the last matching layout set prototype
861            * @throws NoSuchLayoutSetPrototypeException if a matching layout set prototype could not be found
862            */
863            public static LayoutSetPrototype findByC_A_Last(long companyId,
864                    boolean active, OrderByComparator<LayoutSetPrototype> orderByComparator)
865                    throws com.liferay.portal.NoSuchLayoutSetPrototypeException {
866                    return getPersistence()
867                                       .findByC_A_Last(companyId, active, orderByComparator);
868            }
869    
870            /**
871            * Returns the last layout set prototype in the ordered set where companyId = &#63; and active = &#63;.
872            *
873            * @param companyId the company ID
874            * @param active the active
875            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
876            * @return the last matching layout set prototype, or <code>null</code> if a matching layout set prototype could not be found
877            */
878            public static LayoutSetPrototype fetchByC_A_Last(long companyId,
879                    boolean active, OrderByComparator<LayoutSetPrototype> orderByComparator) {
880                    return getPersistence()
881                                       .fetchByC_A_Last(companyId, active, orderByComparator);
882            }
883    
884            /**
885            * Returns the layout set prototypes before and after the current layout set prototype in the ordered set where companyId = &#63; and active = &#63;.
886            *
887            * @param layoutSetPrototypeId the primary key of the current layout set prototype
888            * @param companyId the company ID
889            * @param active the active
890            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
891            * @return the previous, current, and next layout set prototype
892            * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found
893            */
894            public static LayoutSetPrototype[] findByC_A_PrevAndNext(
895                    long layoutSetPrototypeId, long companyId, boolean active,
896                    OrderByComparator<LayoutSetPrototype> orderByComparator)
897                    throws com.liferay.portal.NoSuchLayoutSetPrototypeException {
898                    return getPersistence()
899                                       .findByC_A_PrevAndNext(layoutSetPrototypeId, companyId,
900                            active, orderByComparator);
901            }
902    
903            /**
904            * Returns all the layout set prototypes that the user has permission to view where companyId = &#63; and active = &#63;.
905            *
906            * @param companyId the company ID
907            * @param active the active
908            * @return the matching layout set prototypes that the user has permission to view
909            */
910            public static List<LayoutSetPrototype> filterFindByC_A(long companyId,
911                    boolean active) {
912                    return getPersistence().filterFindByC_A(companyId, active);
913            }
914    
915            /**
916            * Returns a range of all the layout set prototypes that the user has permission to view where companyId = &#63; and active = &#63;.
917            *
918            * <p>
919            * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
920            * </p>
921            *
922            * @param companyId the company ID
923            * @param active the active
924            * @param start the lower bound of the range of layout set prototypes
925            * @param end the upper bound of the range of layout set prototypes (not inclusive)
926            * @return the range of matching layout set prototypes that the user has permission to view
927            */
928            public static List<LayoutSetPrototype> filterFindByC_A(long companyId,
929                    boolean active, int start, int end) {
930                    return getPersistence().filterFindByC_A(companyId, active, start, end);
931            }
932    
933            /**
934            * Returns an ordered range of all the layout set prototypes that the user has permissions to view where companyId = &#63; and active = &#63;.
935            *
936            * <p>
937            * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
938            * </p>
939            *
940            * @param companyId the company ID
941            * @param active the active
942            * @param start the lower bound of the range of layout set prototypes
943            * @param end the upper bound of the range of layout set prototypes (not inclusive)
944            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
945            * @return the ordered range of matching layout set prototypes that the user has permission to view
946            */
947            public static List<LayoutSetPrototype> filterFindByC_A(long companyId,
948                    boolean active, int start, int end,
949                    OrderByComparator<LayoutSetPrototype> orderByComparator) {
950                    return getPersistence()
951                                       .filterFindByC_A(companyId, active, start, end,
952                            orderByComparator);
953            }
954    
955            /**
956            * Returns the layout set prototypes before and after the current layout set prototype in the ordered set of layout set prototypes that the user has permission to view where companyId = &#63; and active = &#63;.
957            *
958            * @param layoutSetPrototypeId the primary key of the current layout set prototype
959            * @param companyId the company ID
960            * @param active the active
961            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
962            * @return the previous, current, and next layout set prototype
963            * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found
964            */
965            public static LayoutSetPrototype[] filterFindByC_A_PrevAndNext(
966                    long layoutSetPrototypeId, long companyId, boolean active,
967                    OrderByComparator<LayoutSetPrototype> orderByComparator)
968                    throws com.liferay.portal.NoSuchLayoutSetPrototypeException {
969                    return getPersistence()
970                                       .filterFindByC_A_PrevAndNext(layoutSetPrototypeId,
971                            companyId, active, orderByComparator);
972            }
973    
974            /**
975            * Removes all the layout set prototypes where companyId = &#63; and active = &#63; from the database.
976            *
977            * @param companyId the company ID
978            * @param active the active
979            */
980            public static void removeByC_A(long companyId, boolean active) {
981                    getPersistence().removeByC_A(companyId, active);
982            }
983    
984            /**
985            * Returns the number of layout set prototypes where companyId = &#63; and active = &#63;.
986            *
987            * @param companyId the company ID
988            * @param active the active
989            * @return the number of matching layout set prototypes
990            */
991            public static int countByC_A(long companyId, boolean active) {
992                    return getPersistence().countByC_A(companyId, active);
993            }
994    
995            /**
996            * Returns the number of layout set prototypes that the user has permission to view where companyId = &#63; and active = &#63;.
997            *
998            * @param companyId the company ID
999            * @param active the active
1000            * @return the number of matching layout set prototypes that the user has permission to view
1001            */
1002            public static int filterCountByC_A(long companyId, boolean active) {
1003                    return getPersistence().filterCountByC_A(companyId, active);
1004            }
1005    
1006            /**
1007            * Caches the layout set prototype in the entity cache if it is enabled.
1008            *
1009            * @param layoutSetPrototype the layout set prototype
1010            */
1011            public static void cacheResult(LayoutSetPrototype layoutSetPrototype) {
1012                    getPersistence().cacheResult(layoutSetPrototype);
1013            }
1014    
1015            /**
1016            * Caches the layout set prototypes in the entity cache if it is enabled.
1017            *
1018            * @param layoutSetPrototypes the layout set prototypes
1019            */
1020            public static void cacheResult(List<LayoutSetPrototype> layoutSetPrototypes) {
1021                    getPersistence().cacheResult(layoutSetPrototypes);
1022            }
1023    
1024            /**
1025            * Creates a new layout set prototype with the primary key. Does not add the layout set prototype to the database.
1026            *
1027            * @param layoutSetPrototypeId the primary key for the new layout set prototype
1028            * @return the new layout set prototype
1029            */
1030            public static LayoutSetPrototype create(long layoutSetPrototypeId) {
1031                    return getPersistence().create(layoutSetPrototypeId);
1032            }
1033    
1034            /**
1035            * Removes the layout set prototype with the primary key from the database. Also notifies the appropriate model listeners.
1036            *
1037            * @param layoutSetPrototypeId the primary key of the layout set prototype
1038            * @return the layout set prototype that was removed
1039            * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found
1040            */
1041            public static LayoutSetPrototype remove(long layoutSetPrototypeId)
1042                    throws com.liferay.portal.NoSuchLayoutSetPrototypeException {
1043                    return getPersistence().remove(layoutSetPrototypeId);
1044            }
1045    
1046            public static LayoutSetPrototype updateImpl(
1047                    LayoutSetPrototype layoutSetPrototype) {
1048                    return getPersistence().updateImpl(layoutSetPrototype);
1049            }
1050    
1051            /**
1052            * Returns the layout set prototype with the primary key or throws a {@link NoSuchLayoutSetPrototypeException} if it could not be found.
1053            *
1054            * @param layoutSetPrototypeId the primary key of the layout set prototype
1055            * @return the layout set prototype
1056            * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found
1057            */
1058            public static LayoutSetPrototype findByPrimaryKey(long layoutSetPrototypeId)
1059                    throws com.liferay.portal.NoSuchLayoutSetPrototypeException {
1060                    return getPersistence().findByPrimaryKey(layoutSetPrototypeId);
1061            }
1062    
1063            /**
1064            * Returns the layout set prototype with the primary key or returns <code>null</code> if it could not be found.
1065            *
1066            * @param layoutSetPrototypeId the primary key of the layout set prototype
1067            * @return the layout set prototype, or <code>null</code> if a layout set prototype with the primary key could not be found
1068            */
1069            public static LayoutSetPrototype fetchByPrimaryKey(
1070                    long layoutSetPrototypeId) {
1071                    return getPersistence().fetchByPrimaryKey(layoutSetPrototypeId);
1072            }
1073    
1074            public static java.util.Map<java.io.Serializable, LayoutSetPrototype> fetchByPrimaryKeys(
1075                    java.util.Set<java.io.Serializable> primaryKeys) {
1076                    return getPersistence().fetchByPrimaryKeys(primaryKeys);
1077            }
1078    
1079            /**
1080            * Returns all the layout set prototypes.
1081            *
1082            * @return the layout set prototypes
1083            */
1084            public static List<LayoutSetPrototype> findAll() {
1085                    return getPersistence().findAll();
1086            }
1087    
1088            /**
1089            * Returns a range of all the layout set prototypes.
1090            *
1091            * <p>
1092            * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1093            * </p>
1094            *
1095            * @param start the lower bound of the range of layout set prototypes
1096            * @param end the upper bound of the range of layout set prototypes (not inclusive)
1097            * @return the range of layout set prototypes
1098            */
1099            public static List<LayoutSetPrototype> findAll(int start, int end) {
1100                    return getPersistence().findAll(start, end);
1101            }
1102    
1103            /**
1104            * Returns an ordered range of all the layout set prototypes.
1105            *
1106            * <p>
1107            * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1108            * </p>
1109            *
1110            * @param start the lower bound of the range of layout set prototypes
1111            * @param end the upper bound of the range of layout set prototypes (not inclusive)
1112            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1113            * @return the ordered range of layout set prototypes
1114            */
1115            public static List<LayoutSetPrototype> findAll(int start, int end,
1116                    OrderByComparator<LayoutSetPrototype> orderByComparator) {
1117                    return getPersistence().findAll(start, end, orderByComparator);
1118            }
1119    
1120            /**
1121            * Removes all the layout set prototypes from the database.
1122            */
1123            public static void removeAll() {
1124                    getPersistence().removeAll();
1125            }
1126    
1127            /**
1128            * Returns the number of layout set prototypes.
1129            *
1130            * @return the number of layout set prototypes
1131            */
1132            public static int countAll() {
1133                    return getPersistence().countAll();
1134            }
1135    
1136            public static LayoutSetPrototypePersistence getPersistence() {
1137                    if (_persistence == null) {
1138                            _persistence = (LayoutSetPrototypePersistence)PortalBeanLocatorUtil.locate(LayoutSetPrototypePersistence.class.getName());
1139    
1140                            ReferenceRegistry.registerReference(LayoutSetPrototypeUtil.class,
1141                                    "_persistence");
1142                    }
1143    
1144                    return _persistence;
1145            }
1146    
1147            /**
1148             * @deprecated As of 6.2.0
1149             */
1150            @Deprecated
1151            public void setPersistence(LayoutSetPrototypePersistence persistence) {
1152            }
1153    
1154            private static LayoutSetPrototypePersistence _persistence;
1155    }