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