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