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 an ordered range of all the layout set prototypes where uuid = &#63;.
160            *
161            * <p>
162            * 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.
163            * </p>
164            *
165            * @param uuid the uuid
166            * @param start the lower bound of the range of layout set prototypes
167            * @param end the upper bound of the range of layout set prototypes (not inclusive)
168            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
169            * @param retrieveFromCache whether to retrieve from the finder cache
170            * @return the ordered range of matching layout set prototypes
171            */
172            public static List<LayoutSetPrototype> findByUuid(java.lang.String uuid,
173                    int start, int end,
174                    OrderByComparator<LayoutSetPrototype> orderByComparator,
175                    boolean retrieveFromCache) {
176                    return getPersistence()
177                                       .findByUuid(uuid, start, end, orderByComparator,
178                            retrieveFromCache);
179            }
180    
181            /**
182            * Returns the first layout set prototype in the ordered set where uuid = &#63;.
183            *
184            * @param uuid the uuid
185            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
186            * @return the first matching layout set prototype
187            * @throws NoSuchLayoutSetPrototypeException if a matching layout set prototype could not be found
188            */
189            public static LayoutSetPrototype findByUuid_First(java.lang.String uuid,
190                    OrderByComparator<LayoutSetPrototype> orderByComparator)
191                    throws com.liferay.portal.exception.NoSuchLayoutSetPrototypeException {
192                    return getPersistence().findByUuid_First(uuid, orderByComparator);
193            }
194    
195            /**
196            * Returns the first layout set prototype in the ordered set where uuid = &#63;.
197            *
198            * @param uuid the uuid
199            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
200            * @return the first matching layout set prototype, or <code>null</code> if a matching layout set prototype could not be found
201            */
202            public static LayoutSetPrototype fetchByUuid_First(java.lang.String uuid,
203                    OrderByComparator<LayoutSetPrototype> orderByComparator) {
204                    return getPersistence().fetchByUuid_First(uuid, orderByComparator);
205            }
206    
207            /**
208            * Returns the last layout set prototype in the ordered set where uuid = &#63;.
209            *
210            * @param uuid the uuid
211            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
212            * @return the last matching layout set prototype
213            * @throws NoSuchLayoutSetPrototypeException if a matching layout set prototype could not be found
214            */
215            public static LayoutSetPrototype findByUuid_Last(java.lang.String uuid,
216                    OrderByComparator<LayoutSetPrototype> orderByComparator)
217                    throws com.liferay.portal.exception.NoSuchLayoutSetPrototypeException {
218                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
219            }
220    
221            /**
222            * Returns the last layout set prototype in the ordered set where uuid = &#63;.
223            *
224            * @param uuid the uuid
225            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
226            * @return the last matching layout set prototype, or <code>null</code> if a matching layout set prototype could not be found
227            */
228            public static LayoutSetPrototype fetchByUuid_Last(java.lang.String uuid,
229                    OrderByComparator<LayoutSetPrototype> orderByComparator) {
230                    return getPersistence().fetchByUuid_Last(uuid, orderByComparator);
231            }
232    
233            /**
234            * Returns the layout set prototypes before and after the current layout set prototype in the ordered set where uuid = &#63;.
235            *
236            * @param layoutSetPrototypeId the primary key of the current layout set prototype
237            * @param uuid the uuid
238            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
239            * @return the previous, current, and next layout set prototype
240            * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found
241            */
242            public static LayoutSetPrototype[] findByUuid_PrevAndNext(
243                    long layoutSetPrototypeId, java.lang.String uuid,
244                    OrderByComparator<LayoutSetPrototype> orderByComparator)
245                    throws com.liferay.portal.exception.NoSuchLayoutSetPrototypeException {
246                    return getPersistence()
247                                       .findByUuid_PrevAndNext(layoutSetPrototypeId, uuid,
248                            orderByComparator);
249            }
250    
251            /**
252            * Returns all the layout set prototypes that the user has permission to view where uuid = &#63;.
253            *
254            * @param uuid the uuid
255            * @return the matching layout set prototypes that the user has permission to view
256            */
257            public static List<LayoutSetPrototype> filterFindByUuid(
258                    java.lang.String uuid) {
259                    return getPersistence().filterFindByUuid(uuid);
260            }
261    
262            /**
263            * Returns a range of all the layout set prototypes that the user has permission to view where uuid = &#63;.
264            *
265            * <p>
266            * 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.
267            * </p>
268            *
269            * @param uuid the uuid
270            * @param start the lower bound of the range of layout set prototypes
271            * @param end the upper bound of the range of layout set prototypes (not inclusive)
272            * @return the range of matching layout set prototypes that the user has permission to view
273            */
274            public static List<LayoutSetPrototype> filterFindByUuid(
275                    java.lang.String uuid, int start, int end) {
276                    return getPersistence().filterFindByUuid(uuid, start, end);
277            }
278    
279            /**
280            * Returns an ordered range of all the layout set prototypes that the user has permissions to view where uuid = &#63;.
281            *
282            * <p>
283            * 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.
284            * </p>
285            *
286            * @param uuid the uuid
287            * @param start the lower bound of the range of layout set prototypes
288            * @param end the upper bound of the range of layout set prototypes (not inclusive)
289            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
290            * @return the ordered range of matching layout set prototypes that the user has permission to view
291            */
292            public static List<LayoutSetPrototype> filterFindByUuid(
293                    java.lang.String uuid, int start, int end,
294                    OrderByComparator<LayoutSetPrototype> orderByComparator) {
295                    return getPersistence()
296                                       .filterFindByUuid(uuid, start, end, orderByComparator);
297            }
298    
299            /**
300            * 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;.
301            *
302            * @param layoutSetPrototypeId the primary key of the current layout set 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 set prototype
306            * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found
307            */
308            public static LayoutSetPrototype[] filterFindByUuid_PrevAndNext(
309                    long layoutSetPrototypeId, java.lang.String uuid,
310                    OrderByComparator<LayoutSetPrototype> orderByComparator)
311                    throws com.liferay.portal.exception.NoSuchLayoutSetPrototypeException {
312                    return getPersistence()
313                                       .filterFindByUuid_PrevAndNext(layoutSetPrototypeId, uuid,
314                            orderByComparator);
315            }
316    
317            /**
318            * Removes all the layout set prototypes where uuid = &#63; from the database.
319            *
320            * @param uuid the uuid
321            */
322            public static void removeByUuid(java.lang.String uuid) {
323                    getPersistence().removeByUuid(uuid);
324            }
325    
326            /**
327            * Returns the number of layout set prototypes where uuid = &#63;.
328            *
329            * @param uuid the uuid
330            * @return the number of matching layout set prototypes
331            */
332            public static int countByUuid(java.lang.String uuid) {
333                    return getPersistence().countByUuid(uuid);
334            }
335    
336            /**
337            * Returns the number of layout set prototypes that the user has permission to view where uuid = &#63;.
338            *
339            * @param uuid the uuid
340            * @return the number of matching layout set prototypes that the user has permission to view
341            */
342            public static int filterCountByUuid(java.lang.String uuid) {
343                    return getPersistence().filterCountByUuid(uuid);
344            }
345    
346            /**
347            * Returns all the layout set prototypes where uuid = &#63; and companyId = &#63;.
348            *
349            * @param uuid the uuid
350            * @param companyId the company ID
351            * @return the matching layout set prototypes
352            */
353            public static List<LayoutSetPrototype> findByUuid_C(java.lang.String uuid,
354                    long companyId) {
355                    return getPersistence().findByUuid_C(uuid, companyId);
356            }
357    
358            /**
359            * Returns a range of all the layout set prototypes where uuid = &#63; and companyId = &#63;.
360            *
361            * <p>
362            * 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.
363            * </p>
364            *
365            * @param uuid the uuid
366            * @param companyId the company ID
367            * @param start the lower bound of the range of layout set prototypes
368            * @param end the upper bound of the range of layout set prototypes (not inclusive)
369            * @return the range of matching layout set prototypes
370            */
371            public static List<LayoutSetPrototype> findByUuid_C(java.lang.String uuid,
372                    long companyId, int start, int end) {
373                    return getPersistence().findByUuid_C(uuid, companyId, start, end);
374            }
375    
376            /**
377            * Returns an ordered range of all the layout set prototypes where uuid = &#63; and companyId = &#63;.
378            *
379            * <p>
380            * 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.
381            * </p>
382            *
383            * @param uuid the uuid
384            * @param companyId the company ID
385            * @param start the lower bound of the range of layout set prototypes
386            * @param end the upper bound of the range of layout set prototypes (not inclusive)
387            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
388            * @return the ordered range of matching layout set prototypes
389            */
390            public static List<LayoutSetPrototype> findByUuid_C(java.lang.String uuid,
391                    long companyId, int start, int end,
392                    OrderByComparator<LayoutSetPrototype> orderByComparator) {
393                    return getPersistence()
394                                       .findByUuid_C(uuid, companyId, start, end, orderByComparator);
395            }
396    
397            /**
398            * Returns an ordered range of all the layout set prototypes where uuid = &#63; and companyId = &#63;.
399            *
400            * <p>
401            * 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.
402            * </p>
403            *
404            * @param uuid the uuid
405            * @param companyId the company ID
406            * @param start the lower bound of the range of layout set prototypes
407            * @param end the upper bound of the range of layout set prototypes (not inclusive)
408            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
409            * @param retrieveFromCache whether to retrieve from the finder cache
410            * @return the ordered range of matching layout set prototypes
411            */
412            public static List<LayoutSetPrototype> findByUuid_C(java.lang.String uuid,
413                    long companyId, int start, int end,
414                    OrderByComparator<LayoutSetPrototype> orderByComparator,
415                    boolean retrieveFromCache) {
416                    return getPersistence()
417                                       .findByUuid_C(uuid, companyId, start, end,
418                            orderByComparator, retrieveFromCache);
419            }
420    
421            /**
422            * Returns the first 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 first matching layout set prototype
428            * @throws NoSuchLayoutSetPrototypeException if a matching layout set prototype could not be found
429            */
430            public static LayoutSetPrototype findByUuid_C_First(java.lang.String uuid,
431                    long companyId, OrderByComparator<LayoutSetPrototype> orderByComparator)
432                    throws com.liferay.portal.exception.NoSuchLayoutSetPrototypeException {
433                    return getPersistence()
434                                       .findByUuid_C_First(uuid, companyId, orderByComparator);
435            }
436    
437            /**
438            * Returns the first layout set prototype in the ordered set where uuid = &#63; and companyId = &#63;.
439            *
440            * @param uuid the uuid
441            * @param companyId the company ID
442            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
443            * @return the first matching layout set prototype, or <code>null</code> if a matching layout set prototype could not be found
444            */
445            public static LayoutSetPrototype fetchByUuid_C_First(
446                    java.lang.String uuid, long companyId,
447                    OrderByComparator<LayoutSetPrototype> orderByComparator) {
448                    return getPersistence()
449                                       .fetchByUuid_C_First(uuid, companyId, orderByComparator);
450            }
451    
452            /**
453            * Returns the last layout set prototype in the ordered set where uuid = &#63; and companyId = &#63;.
454            *
455            * @param uuid the uuid
456            * @param companyId the company ID
457            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
458            * @return the last matching layout set prototype
459            * @throws NoSuchLayoutSetPrototypeException if a matching layout set prototype could not be found
460            */
461            public static LayoutSetPrototype findByUuid_C_Last(java.lang.String uuid,
462                    long companyId, OrderByComparator<LayoutSetPrototype> orderByComparator)
463                    throws com.liferay.portal.exception.NoSuchLayoutSetPrototypeException {
464                    return getPersistence()
465                                       .findByUuid_C_Last(uuid, companyId, orderByComparator);
466            }
467    
468            /**
469            * Returns the last layout set prototype in the ordered set where uuid = &#63; and companyId = &#63;.
470            *
471            * @param uuid the uuid
472            * @param companyId the company ID
473            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
474            * @return the last matching layout set prototype, or <code>null</code> if a matching layout set prototype could not be found
475            */
476            public static LayoutSetPrototype fetchByUuid_C_Last(java.lang.String uuid,
477                    long companyId, OrderByComparator<LayoutSetPrototype> orderByComparator) {
478                    return getPersistence()
479                                       .fetchByUuid_C_Last(uuid, companyId, orderByComparator);
480            }
481    
482            /**
483            * Returns the layout set prototypes before and after the current layout set prototype in the ordered set where uuid = &#63; and companyId = &#63;.
484            *
485            * @param layoutSetPrototypeId the primary key of the current layout set prototype
486            * @param uuid the uuid
487            * @param companyId the company ID
488            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
489            * @return the previous, current, and next layout set prototype
490            * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found
491            */
492            public static LayoutSetPrototype[] findByUuid_C_PrevAndNext(
493                    long layoutSetPrototypeId, java.lang.String uuid, long companyId,
494                    OrderByComparator<LayoutSetPrototype> orderByComparator)
495                    throws com.liferay.portal.exception.NoSuchLayoutSetPrototypeException {
496                    return getPersistence()
497                                       .findByUuid_C_PrevAndNext(layoutSetPrototypeId, uuid,
498                            companyId, orderByComparator);
499            }
500    
501            /**
502            * Returns all the layout set prototypes that the user has permission to view where uuid = &#63; and companyId = &#63;.
503            *
504            * @param uuid the uuid
505            * @param companyId the company ID
506            * @return the matching layout set prototypes that the user has permission to view
507            */
508            public static List<LayoutSetPrototype> filterFindByUuid_C(
509                    java.lang.String uuid, long companyId) {
510                    return getPersistence().filterFindByUuid_C(uuid, companyId);
511            }
512    
513            /**
514            * Returns a range of all the layout set prototypes that the user has permission to view where uuid = &#63; and companyId = &#63;.
515            *
516            * <p>
517            * 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.
518            * </p>
519            *
520            * @param uuid the uuid
521            * @param companyId the company ID
522            * @param start the lower bound of the range of layout set prototypes
523            * @param end the upper bound of the range of layout set prototypes (not inclusive)
524            * @return the range of matching layout set prototypes that the user has permission to view
525            */
526            public static List<LayoutSetPrototype> filterFindByUuid_C(
527                    java.lang.String uuid, long companyId, int start, int end) {
528                    return getPersistence().filterFindByUuid_C(uuid, companyId, start, end);
529            }
530    
531            /**
532            * Returns an ordered range of all the layout set prototypes that the user has permissions to view where uuid = &#63; and companyId = &#63;.
533            *
534            * <p>
535            * 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.
536            * </p>
537            *
538            * @param uuid the uuid
539            * @param companyId the company ID
540            * @param start the lower bound of the range of layout set prototypes
541            * @param end the upper bound of the range of layout set prototypes (not inclusive)
542            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
543            * @return the ordered range of matching layout set prototypes that the user has permission to view
544            */
545            public static List<LayoutSetPrototype> filterFindByUuid_C(
546                    java.lang.String uuid, long companyId, int start, int end,
547                    OrderByComparator<LayoutSetPrototype> orderByComparator) {
548                    return getPersistence()
549                                       .filterFindByUuid_C(uuid, companyId, start, end,
550                            orderByComparator);
551            }
552    
553            /**
554            * 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;.
555            *
556            * @param layoutSetPrototypeId the primary key of the current layout set prototype
557            * @param uuid the uuid
558            * @param companyId the company ID
559            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
560            * @return the previous, current, and next layout set prototype
561            * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found
562            */
563            public static LayoutSetPrototype[] filterFindByUuid_C_PrevAndNext(
564                    long layoutSetPrototypeId, java.lang.String uuid, long companyId,
565                    OrderByComparator<LayoutSetPrototype> orderByComparator)
566                    throws com.liferay.portal.exception.NoSuchLayoutSetPrototypeException {
567                    return getPersistence()
568                                       .filterFindByUuid_C_PrevAndNext(layoutSetPrototypeId, uuid,
569                            companyId, orderByComparator);
570            }
571    
572            /**
573            * Removes all the layout set prototypes where uuid = &#63; and companyId = &#63; from the database.
574            *
575            * @param uuid the uuid
576            * @param companyId the company ID
577            */
578            public static void removeByUuid_C(java.lang.String uuid, long companyId) {
579                    getPersistence().removeByUuid_C(uuid, companyId);
580            }
581    
582            /**
583            * Returns the number of layout set prototypes where uuid = &#63; and companyId = &#63;.
584            *
585            * @param uuid the uuid
586            * @param companyId the company ID
587            * @return the number of matching layout set prototypes
588            */
589            public static int countByUuid_C(java.lang.String uuid, long companyId) {
590                    return getPersistence().countByUuid_C(uuid, companyId);
591            }
592    
593            /**
594            * Returns the number of layout set prototypes that the user has permission to view where uuid = &#63; and companyId = &#63;.
595            *
596            * @param uuid the uuid
597            * @param companyId the company ID
598            * @return the number of matching layout set prototypes that the user has permission to view
599            */
600            public static int filterCountByUuid_C(java.lang.String uuid, long companyId) {
601                    return getPersistence().filterCountByUuid_C(uuid, companyId);
602            }
603    
604            /**
605            * Returns all the layout set prototypes where companyId = &#63;.
606            *
607            * @param companyId the company ID
608            * @return the matching layout set prototypes
609            */
610            public static List<LayoutSetPrototype> findByCompanyId(long companyId) {
611                    return getPersistence().findByCompanyId(companyId);
612            }
613    
614            /**
615            * Returns a range of all the layout set prototypes where companyId = &#63;.
616            *
617            * <p>
618            * 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.
619            * </p>
620            *
621            * @param companyId the company ID
622            * @param start the lower bound of the range of layout set prototypes
623            * @param end the upper bound of the range of layout set prototypes (not inclusive)
624            * @return the range of matching layout set prototypes
625            */
626            public static List<LayoutSetPrototype> findByCompanyId(long companyId,
627                    int start, int end) {
628                    return getPersistence().findByCompanyId(companyId, start, end);
629            }
630    
631            /**
632            * Returns an ordered range of all the layout set prototypes where companyId = &#63;.
633            *
634            * <p>
635            * 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.
636            * </p>
637            *
638            * @param companyId the company ID
639            * @param start the lower bound of the range of layout set prototypes
640            * @param end the upper bound of the range of layout set prototypes (not inclusive)
641            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
642            * @return the ordered range of matching layout set prototypes
643            */
644            public static List<LayoutSetPrototype> findByCompanyId(long companyId,
645                    int start, int end,
646                    OrderByComparator<LayoutSetPrototype> orderByComparator) {
647                    return getPersistence()
648                                       .findByCompanyId(companyId, start, end, orderByComparator);
649            }
650    
651            /**
652            * Returns an ordered range of all the layout set prototypes where companyId = &#63;.
653            *
654            * <p>
655            * 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.
656            * </p>
657            *
658            * @param companyId the company ID
659            * @param start the lower bound of the range of layout set prototypes
660            * @param end the upper bound of the range of layout set prototypes (not inclusive)
661            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
662            * @param retrieveFromCache whether to retrieve from the finder cache
663            * @return the ordered range of matching layout set prototypes
664            */
665            public static List<LayoutSetPrototype> findByCompanyId(long companyId,
666                    int start, int end,
667                    OrderByComparator<LayoutSetPrototype> orderByComparator,
668                    boolean retrieveFromCache) {
669                    return getPersistence()
670                                       .findByCompanyId(companyId, start, end, orderByComparator,
671                            retrieveFromCache);
672            }
673    
674            /**
675            * Returns the first layout set prototype in the ordered set where companyId = &#63;.
676            *
677            * @param companyId the company ID
678            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
679            * @return the first matching layout set prototype
680            * @throws NoSuchLayoutSetPrototypeException if a matching layout set prototype could not be found
681            */
682            public static LayoutSetPrototype findByCompanyId_First(long companyId,
683                    OrderByComparator<LayoutSetPrototype> orderByComparator)
684                    throws com.liferay.portal.exception.NoSuchLayoutSetPrototypeException {
685                    return getPersistence()
686                                       .findByCompanyId_First(companyId, orderByComparator);
687            }
688    
689            /**
690            * Returns the first layout set prototype in the ordered set where companyId = &#63;.
691            *
692            * @param companyId the company ID
693            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
694            * @return the first matching layout set prototype, or <code>null</code> if a matching layout set prototype could not be found
695            */
696            public static LayoutSetPrototype fetchByCompanyId_First(long companyId,
697                    OrderByComparator<LayoutSetPrototype> orderByComparator) {
698                    return getPersistence()
699                                       .fetchByCompanyId_First(companyId, orderByComparator);
700            }
701    
702            /**
703            * Returns the last layout set prototype in the ordered set where companyId = &#63;.
704            *
705            * @param companyId the company ID
706            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
707            * @return the last matching layout set prototype
708            * @throws NoSuchLayoutSetPrototypeException if a matching layout set prototype could not be found
709            */
710            public static LayoutSetPrototype findByCompanyId_Last(long companyId,
711                    OrderByComparator<LayoutSetPrototype> orderByComparator)
712                    throws com.liferay.portal.exception.NoSuchLayoutSetPrototypeException {
713                    return getPersistence()
714                                       .findByCompanyId_Last(companyId, orderByComparator);
715            }
716    
717            /**
718            * Returns the last layout set prototype in the ordered set where companyId = &#63;.
719            *
720            * @param companyId the company ID
721            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
722            * @return the last matching layout set prototype, or <code>null</code> if a matching layout set prototype could not be found
723            */
724            public static LayoutSetPrototype fetchByCompanyId_Last(long companyId,
725                    OrderByComparator<LayoutSetPrototype> orderByComparator) {
726                    return getPersistence()
727                                       .fetchByCompanyId_Last(companyId, orderByComparator);
728            }
729    
730            /**
731            * Returns the layout set prototypes before and after the current layout set prototype in the ordered set where companyId = &#63;.
732            *
733            * @param layoutSetPrototypeId the primary key of the current layout set prototype
734            * @param companyId the company ID
735            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
736            * @return the previous, current, and next layout set prototype
737            * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found
738            */
739            public static LayoutSetPrototype[] findByCompanyId_PrevAndNext(
740                    long layoutSetPrototypeId, long companyId,
741                    OrderByComparator<LayoutSetPrototype> orderByComparator)
742                    throws com.liferay.portal.exception.NoSuchLayoutSetPrototypeException {
743                    return getPersistence()
744                                       .findByCompanyId_PrevAndNext(layoutSetPrototypeId,
745                            companyId, orderByComparator);
746            }
747    
748            /**
749            * Returns all the layout set prototypes that the user has permission to view where companyId = &#63;.
750            *
751            * @param companyId the company ID
752            * @return the matching layout set prototypes that the user has permission to view
753            */
754            public static List<LayoutSetPrototype> filterFindByCompanyId(long companyId) {
755                    return getPersistence().filterFindByCompanyId(companyId);
756            }
757    
758            /**
759            * Returns a range of all the layout set prototypes that the user has permission to view where companyId = &#63;.
760            *
761            * <p>
762            * 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.
763            * </p>
764            *
765            * @param companyId the company ID
766            * @param start the lower bound of the range of layout set prototypes
767            * @param end the upper bound of the range of layout set prototypes (not inclusive)
768            * @return the range of matching layout set prototypes that the user has permission to view
769            */
770            public static List<LayoutSetPrototype> filterFindByCompanyId(
771                    long companyId, int start, int end) {
772                    return getPersistence().filterFindByCompanyId(companyId, start, end);
773            }
774    
775            /**
776            * Returns an ordered range of all the layout set prototypes that the user has permissions to view where companyId = &#63;.
777            *
778            * <p>
779            * 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.
780            * </p>
781            *
782            * @param companyId the company ID
783            * @param start the lower bound of the range of layout set prototypes
784            * @param end the upper bound of the range of layout set prototypes (not inclusive)
785            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
786            * @return the ordered range of matching layout set prototypes that the user has permission to view
787            */
788            public static List<LayoutSetPrototype> filterFindByCompanyId(
789                    long companyId, int start, int end,
790                    OrderByComparator<LayoutSetPrototype> orderByComparator) {
791                    return getPersistence()
792                                       .filterFindByCompanyId(companyId, start, end,
793                            orderByComparator);
794            }
795    
796            /**
797            * 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;.
798            *
799            * @param layoutSetPrototypeId the primary key of the current layout set prototype
800            * @param companyId the company ID
801            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
802            * @return the previous, current, and next layout set prototype
803            * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found
804            */
805            public static LayoutSetPrototype[] filterFindByCompanyId_PrevAndNext(
806                    long layoutSetPrototypeId, long companyId,
807                    OrderByComparator<LayoutSetPrototype> orderByComparator)
808                    throws com.liferay.portal.exception.NoSuchLayoutSetPrototypeException {
809                    return getPersistence()
810                                       .filterFindByCompanyId_PrevAndNext(layoutSetPrototypeId,
811                            companyId, orderByComparator);
812            }
813    
814            /**
815            * Removes all the layout set prototypes where companyId = &#63; from the database.
816            *
817            * @param companyId the company ID
818            */
819            public static void removeByCompanyId(long companyId) {
820                    getPersistence().removeByCompanyId(companyId);
821            }
822    
823            /**
824            * Returns the number of layout set prototypes where companyId = &#63;.
825            *
826            * @param companyId the company ID
827            * @return the number of matching layout set prototypes
828            */
829            public static int countByCompanyId(long companyId) {
830                    return getPersistence().countByCompanyId(companyId);
831            }
832    
833            /**
834            * Returns the number of layout set prototypes that the user has permission to view where companyId = &#63;.
835            *
836            * @param companyId the company ID
837            * @return the number of matching layout set prototypes that the user has permission to view
838            */
839            public static int filterCountByCompanyId(long companyId) {
840                    return getPersistence().filterCountByCompanyId(companyId);
841            }
842    
843            /**
844            * Returns all the layout set prototypes where companyId = &#63; and active = &#63;.
845            *
846            * @param companyId the company ID
847            * @param active the active
848            * @return the matching layout set prototypes
849            */
850            public static List<LayoutSetPrototype> findByC_A(long companyId,
851                    boolean active) {
852                    return getPersistence().findByC_A(companyId, active);
853            }
854    
855            /**
856            * Returns a range of all the layout set prototypes where companyId = &#63; and active = &#63;.
857            *
858            * <p>
859            * 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.
860            * </p>
861            *
862            * @param companyId the company ID
863            * @param active the active
864            * @param start the lower bound of the range of layout set prototypes
865            * @param end the upper bound of the range of layout set prototypes (not inclusive)
866            * @return the range of matching layout set prototypes
867            */
868            public static List<LayoutSetPrototype> findByC_A(long companyId,
869                    boolean active, int start, int end) {
870                    return getPersistence().findByC_A(companyId, active, start, end);
871            }
872    
873            /**
874            * Returns an ordered range of all the layout set prototypes where companyId = &#63; and active = &#63;.
875            *
876            * <p>
877            * 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.
878            * </p>
879            *
880            * @param companyId the company ID
881            * @param active the active
882            * @param start the lower bound of the range of layout set prototypes
883            * @param end the upper bound of the range of layout set prototypes (not inclusive)
884            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
885            * @return the ordered range of matching layout set prototypes
886            */
887            public static List<LayoutSetPrototype> findByC_A(long companyId,
888                    boolean active, int start, int end,
889                    OrderByComparator<LayoutSetPrototype> orderByComparator) {
890                    return getPersistence()
891                                       .findByC_A(companyId, active, start, end, orderByComparator);
892            }
893    
894            /**
895            * Returns an ordered range of all the layout set prototypes where companyId = &#63; and active = &#63;.
896            *
897            * <p>
898            * 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.
899            * </p>
900            *
901            * @param companyId the company ID
902            * @param active the active
903            * @param start the lower bound of the range of layout set prototypes
904            * @param end the upper bound of the range of layout set prototypes (not inclusive)
905            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
906            * @param retrieveFromCache whether to retrieve from the finder cache
907            * @return the ordered range of matching layout set prototypes
908            */
909            public static List<LayoutSetPrototype> findByC_A(long companyId,
910                    boolean active, int start, int end,
911                    OrderByComparator<LayoutSetPrototype> orderByComparator,
912                    boolean retrieveFromCache) {
913                    return getPersistence()
914                                       .findByC_A(companyId, active, start, end, orderByComparator,
915                            retrieveFromCache);
916            }
917    
918            /**
919            * Returns the first layout set prototype in the ordered set where companyId = &#63; and active = &#63;.
920            *
921            * @param companyId the company ID
922            * @param active the active
923            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
924            * @return the first matching layout set prototype
925            * @throws NoSuchLayoutSetPrototypeException if a matching layout set prototype could not be found
926            */
927            public static LayoutSetPrototype findByC_A_First(long companyId,
928                    boolean active, OrderByComparator<LayoutSetPrototype> orderByComparator)
929                    throws com.liferay.portal.exception.NoSuchLayoutSetPrototypeException {
930                    return getPersistence()
931                                       .findByC_A_First(companyId, active, orderByComparator);
932            }
933    
934            /**
935            * Returns the first layout set prototype in the ordered set where companyId = &#63; and active = &#63;.
936            *
937            * @param companyId the company ID
938            * @param active the active
939            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
940            * @return the first matching layout set prototype, or <code>null</code> if a matching layout set prototype could not be found
941            */
942            public static LayoutSetPrototype fetchByC_A_First(long companyId,
943                    boolean active, OrderByComparator<LayoutSetPrototype> orderByComparator) {
944                    return getPersistence()
945                                       .fetchByC_A_First(companyId, active, orderByComparator);
946            }
947    
948            /**
949            * Returns the last layout set prototype in the ordered set where companyId = &#63; and active = &#63;.
950            *
951            * @param companyId the company ID
952            * @param active the active
953            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
954            * @return the last matching layout set prototype
955            * @throws NoSuchLayoutSetPrototypeException if a matching layout set prototype could not be found
956            */
957            public static LayoutSetPrototype findByC_A_Last(long companyId,
958                    boolean active, OrderByComparator<LayoutSetPrototype> orderByComparator)
959                    throws com.liferay.portal.exception.NoSuchLayoutSetPrototypeException {
960                    return getPersistence()
961                                       .findByC_A_Last(companyId, active, orderByComparator);
962            }
963    
964            /**
965            * Returns the last layout set prototype in the ordered set where companyId = &#63; and active = &#63;.
966            *
967            * @param companyId the company ID
968            * @param active the active
969            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
970            * @return the last matching layout set prototype, or <code>null</code> if a matching layout set prototype could not be found
971            */
972            public static LayoutSetPrototype fetchByC_A_Last(long companyId,
973                    boolean active, OrderByComparator<LayoutSetPrototype> orderByComparator) {
974                    return getPersistence()
975                                       .fetchByC_A_Last(companyId, active, orderByComparator);
976            }
977    
978            /**
979            * Returns the layout set prototypes before and after the current layout set prototype in the ordered set where companyId = &#63; and active = &#63;.
980            *
981            * @param layoutSetPrototypeId the primary key of the current layout set prototype
982            * @param companyId the company ID
983            * @param active the active
984            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
985            * @return the previous, current, and next layout set prototype
986            * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found
987            */
988            public static LayoutSetPrototype[] findByC_A_PrevAndNext(
989                    long layoutSetPrototypeId, long companyId, boolean active,
990                    OrderByComparator<LayoutSetPrototype> orderByComparator)
991                    throws com.liferay.portal.exception.NoSuchLayoutSetPrototypeException {
992                    return getPersistence()
993                                       .findByC_A_PrevAndNext(layoutSetPrototypeId, companyId,
994                            active, orderByComparator);
995            }
996    
997            /**
998            * Returns all the layout set prototypes that the user has permission to view where companyId = &#63; and active = &#63;.
999            *
1000            * @param companyId the company ID
1001            * @param active the active
1002            * @return the matching layout set prototypes that the user has permission to view
1003            */
1004            public static List<LayoutSetPrototype> filterFindByC_A(long companyId,
1005                    boolean active) {
1006                    return getPersistence().filterFindByC_A(companyId, active);
1007            }
1008    
1009            /**
1010            * Returns a range of all the layout set prototypes that the user has permission to view where companyId = &#63; and active = &#63;.
1011            *
1012            * <p>
1013            * 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.
1014            * </p>
1015            *
1016            * @param companyId the company ID
1017            * @param active the active
1018            * @param start the lower bound of the range of layout set prototypes
1019            * @param end the upper bound of the range of layout set prototypes (not inclusive)
1020            * @return the range of matching layout set prototypes that the user has permission to view
1021            */
1022            public static List<LayoutSetPrototype> filterFindByC_A(long companyId,
1023                    boolean active, int start, int end) {
1024                    return getPersistence().filterFindByC_A(companyId, active, start, end);
1025            }
1026    
1027            /**
1028            * Returns an ordered range of all the layout set prototypes that the user has permissions to view where companyId = &#63; and active = &#63;.
1029            *
1030            * <p>
1031            * 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.
1032            * </p>
1033            *
1034            * @param companyId the company ID
1035            * @param active the active
1036            * @param start the lower bound of the range of layout set prototypes
1037            * @param end the upper bound of the range of layout set prototypes (not inclusive)
1038            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1039            * @return the ordered range of matching layout set prototypes that the user has permission to view
1040            */
1041            public static List<LayoutSetPrototype> filterFindByC_A(long companyId,
1042                    boolean active, int start, int end,
1043                    OrderByComparator<LayoutSetPrototype> orderByComparator) {
1044                    return getPersistence()
1045                                       .filterFindByC_A(companyId, active, start, end,
1046                            orderByComparator);
1047            }
1048    
1049            /**
1050            * 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;.
1051            *
1052            * @param layoutSetPrototypeId the primary key of the current layout set prototype
1053            * @param companyId the company ID
1054            * @param active the active
1055            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1056            * @return the previous, current, and next layout set prototype
1057            * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found
1058            */
1059            public static LayoutSetPrototype[] filterFindByC_A_PrevAndNext(
1060                    long layoutSetPrototypeId, long companyId, boolean active,
1061                    OrderByComparator<LayoutSetPrototype> orderByComparator)
1062                    throws com.liferay.portal.exception.NoSuchLayoutSetPrototypeException {
1063                    return getPersistence()
1064                                       .filterFindByC_A_PrevAndNext(layoutSetPrototypeId,
1065                            companyId, active, orderByComparator);
1066            }
1067    
1068            /**
1069            * Removes all the layout set prototypes where companyId = &#63; and active = &#63; from the database.
1070            *
1071            * @param companyId the company ID
1072            * @param active the active
1073            */
1074            public static void removeByC_A(long companyId, boolean active) {
1075                    getPersistence().removeByC_A(companyId, active);
1076            }
1077    
1078            /**
1079            * Returns the number of layout set prototypes where companyId = &#63; and active = &#63;.
1080            *
1081            * @param companyId the company ID
1082            * @param active the active
1083            * @return the number of matching layout set prototypes
1084            */
1085            public static int countByC_A(long companyId, boolean active) {
1086                    return getPersistence().countByC_A(companyId, active);
1087            }
1088    
1089            /**
1090            * Returns the number of layout set prototypes that the user has permission to view where companyId = &#63; and active = &#63;.
1091            *
1092            * @param companyId the company ID
1093            * @param active the active
1094            * @return the number of matching layout set prototypes that the user has permission to view
1095            */
1096            public static int filterCountByC_A(long companyId, boolean active) {
1097                    return getPersistence().filterCountByC_A(companyId, active);
1098            }
1099    
1100            /**
1101            * Caches the layout set prototype in the entity cache if it is enabled.
1102            *
1103            * @param layoutSetPrototype the layout set prototype
1104            */
1105            public static void cacheResult(LayoutSetPrototype layoutSetPrototype) {
1106                    getPersistence().cacheResult(layoutSetPrototype);
1107            }
1108    
1109            /**
1110            * Caches the layout set prototypes in the entity cache if it is enabled.
1111            *
1112            * @param layoutSetPrototypes the layout set prototypes
1113            */
1114            public static void cacheResult(List<LayoutSetPrototype> layoutSetPrototypes) {
1115                    getPersistence().cacheResult(layoutSetPrototypes);
1116            }
1117    
1118            /**
1119            * Creates a new layout set prototype with the primary key. Does not add the layout set prototype to the database.
1120            *
1121            * @param layoutSetPrototypeId the primary key for the new layout set prototype
1122            * @return the new layout set prototype
1123            */
1124            public static LayoutSetPrototype create(long layoutSetPrototypeId) {
1125                    return getPersistence().create(layoutSetPrototypeId);
1126            }
1127    
1128            /**
1129            * Removes the layout set prototype with the primary key from the database. Also notifies the appropriate model listeners.
1130            *
1131            * @param layoutSetPrototypeId the primary key of the layout set prototype
1132            * @return the layout set prototype that was removed
1133            * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found
1134            */
1135            public static LayoutSetPrototype remove(long layoutSetPrototypeId)
1136                    throws com.liferay.portal.exception.NoSuchLayoutSetPrototypeException {
1137                    return getPersistence().remove(layoutSetPrototypeId);
1138            }
1139    
1140            public static LayoutSetPrototype updateImpl(
1141                    LayoutSetPrototype layoutSetPrototype) {
1142                    return getPersistence().updateImpl(layoutSetPrototype);
1143            }
1144    
1145            /**
1146            * Returns the layout set prototype with the primary key or throws a {@link NoSuchLayoutSetPrototypeException} if it could not be found.
1147            *
1148            * @param layoutSetPrototypeId the primary key of the layout set prototype
1149            * @return the layout set prototype
1150            * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found
1151            */
1152            public static LayoutSetPrototype findByPrimaryKey(long layoutSetPrototypeId)
1153                    throws com.liferay.portal.exception.NoSuchLayoutSetPrototypeException {
1154                    return getPersistence().findByPrimaryKey(layoutSetPrototypeId);
1155            }
1156    
1157            /**
1158            * Returns the layout set prototype with the primary key or returns <code>null</code> if it could not be found.
1159            *
1160            * @param layoutSetPrototypeId the primary key of the layout set prototype
1161            * @return the layout set prototype, or <code>null</code> if a layout set prototype with the primary key could not be found
1162            */
1163            public static LayoutSetPrototype fetchByPrimaryKey(
1164                    long layoutSetPrototypeId) {
1165                    return getPersistence().fetchByPrimaryKey(layoutSetPrototypeId);
1166            }
1167    
1168            public static java.util.Map<java.io.Serializable, LayoutSetPrototype> fetchByPrimaryKeys(
1169                    java.util.Set<java.io.Serializable> primaryKeys) {
1170                    return getPersistence().fetchByPrimaryKeys(primaryKeys);
1171            }
1172    
1173            /**
1174            * Returns all the layout set prototypes.
1175            *
1176            * @return the layout set prototypes
1177            */
1178            public static List<LayoutSetPrototype> findAll() {
1179                    return getPersistence().findAll();
1180            }
1181    
1182            /**
1183            * Returns a range of all the layout set prototypes.
1184            *
1185            * <p>
1186            * 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.
1187            * </p>
1188            *
1189            * @param start the lower bound of the range of layout set prototypes
1190            * @param end the upper bound of the range of layout set prototypes (not inclusive)
1191            * @return the range of layout set prototypes
1192            */
1193            public static List<LayoutSetPrototype> findAll(int start, int end) {
1194                    return getPersistence().findAll(start, end);
1195            }
1196    
1197            /**
1198            * Returns an ordered range of all the layout set prototypes.
1199            *
1200            * <p>
1201            * 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.
1202            * </p>
1203            *
1204            * @param start the lower bound of the range of layout set prototypes
1205            * @param end the upper bound of the range of layout set prototypes (not inclusive)
1206            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1207            * @return the ordered range of layout set prototypes
1208            */
1209            public static List<LayoutSetPrototype> findAll(int start, int end,
1210                    OrderByComparator<LayoutSetPrototype> orderByComparator) {
1211                    return getPersistence().findAll(start, end, orderByComparator);
1212            }
1213    
1214            /**
1215            * Returns an ordered range of all the layout set prototypes.
1216            *
1217            * <p>
1218            * 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.
1219            * </p>
1220            *
1221            * @param start the lower bound of the range of layout set prototypes
1222            * @param end the upper bound of the range of layout set prototypes (not inclusive)
1223            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1224            * @param retrieveFromCache whether to retrieve from the finder cache
1225            * @return the ordered range of layout set prototypes
1226            */
1227            public static List<LayoutSetPrototype> findAll(int start, int end,
1228                    OrderByComparator<LayoutSetPrototype> orderByComparator,
1229                    boolean retrieveFromCache) {
1230                    return getPersistence()
1231                                       .findAll(start, end, orderByComparator, retrieveFromCache);
1232            }
1233    
1234            /**
1235            * Removes all the layout set prototypes from the database.
1236            */
1237            public static void removeAll() {
1238                    getPersistence().removeAll();
1239            }
1240    
1241            /**
1242            * Returns the number of layout set prototypes.
1243            *
1244            * @return the number of layout set prototypes
1245            */
1246            public static int countAll() {
1247                    return getPersistence().countAll();
1248            }
1249    
1250            public static java.util.Set<java.lang.String> getBadColumnNames() {
1251                    return getPersistence().getBadColumnNames();
1252            }
1253    
1254            public static LayoutSetPrototypePersistence getPersistence() {
1255                    if (_persistence == null) {
1256                            _persistence = (LayoutSetPrototypePersistence)PortalBeanLocatorUtil.locate(LayoutSetPrototypePersistence.class.getName());
1257    
1258                            ReferenceRegistry.registerReference(LayoutSetPrototypeUtil.class,
1259                                    "_persistence");
1260                    }
1261    
1262                    return _persistence;
1263            }
1264    
1265            private static LayoutSetPrototypePersistence _persistence;
1266    }