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