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