001    /**
002     * Copyright (c) 2000-present Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portal.service.persistence;
016    
017    import aQute.bnd.annotation.ProviderType;
018    
019    import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil;
020    import com.liferay.portal.kernel.dao.orm.DynamicQuery;
021    import com.liferay.portal.kernel.util.OrderByComparator;
022    import com.liferay.portal.kernel.util.ReferenceRegistry;
023    import com.liferay.portal.model.LayoutSetBranch;
024    import com.liferay.portal.service.ServiceContext;
025    
026    import java.util.List;
027    
028    /**
029     * The persistence utility for the layout set branch service. This utility wraps {@link com.liferay.portal.service.persistence.impl.LayoutSetBranchPersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class.
030     *
031     * <p>
032     * Caching information and settings can be found in <code>portal.properties</code>
033     * </p>
034     *
035     * @author Brian Wing Shun Chan
036     * @see LayoutSetBranchPersistence
037     * @see com.liferay.portal.service.persistence.impl.LayoutSetBranchPersistenceImpl
038     * @generated
039     */
040    @ProviderType
041    public class LayoutSetBranchUtil {
042            /*
043             * NOTE FOR DEVELOPERS:
044             *
045             * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
046             */
047    
048            /**
049             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
050             */
051            public static void clearCache() {
052                    getPersistence().clearCache();
053            }
054    
055            /**
056             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
057             */
058            public static void clearCache(LayoutSetBranch layoutSetBranch) {
059                    getPersistence().clearCache(layoutSetBranch);
060            }
061    
062            /**
063             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
064             */
065            public static long countWithDynamicQuery(DynamicQuery dynamicQuery) {
066                    return getPersistence().countWithDynamicQuery(dynamicQuery);
067            }
068    
069            /**
070             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
071             */
072            public static List<LayoutSetBranch> findWithDynamicQuery(
073                    DynamicQuery dynamicQuery) {
074                    return getPersistence().findWithDynamicQuery(dynamicQuery);
075            }
076    
077            /**
078             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
079             */
080            public static List<LayoutSetBranch> findWithDynamicQuery(
081                    DynamicQuery dynamicQuery, int start, int end) {
082                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
083            }
084    
085            /**
086             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
087             */
088            public static List<LayoutSetBranch> findWithDynamicQuery(
089                    DynamicQuery dynamicQuery, int start, int end,
090                    OrderByComparator<LayoutSetBranch> orderByComparator) {
091                    return getPersistence()
092                                       .findWithDynamicQuery(dynamicQuery, start, end,
093                            orderByComparator);
094            }
095    
096            /**
097             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel)
098             */
099            public static LayoutSetBranch update(LayoutSetBranch layoutSetBranch) {
100                    return getPersistence().update(layoutSetBranch);
101            }
102    
103            /**
104             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
105             */
106            public static LayoutSetBranch update(LayoutSetBranch layoutSetBranch,
107                    ServiceContext serviceContext) {
108                    return getPersistence().update(layoutSetBranch, serviceContext);
109            }
110    
111            /**
112            * Returns all the layout set branchs where groupId = &#63;.
113            *
114            * @param groupId the group ID
115            * @return the matching layout set branchs
116            */
117            public static List<LayoutSetBranch> findByGroupId(long groupId) {
118                    return getPersistence().findByGroupId(groupId);
119            }
120    
121            /**
122            * Returns a range of all the layout set branchs where groupId = &#63;.
123            *
124            * <p>
125            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetBranchModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
126            * </p>
127            *
128            * @param groupId the group ID
129            * @param start the lower bound of the range of layout set branchs
130            * @param end the upper bound of the range of layout set branchs (not inclusive)
131            * @return the range of matching layout set branchs
132            */
133            public static List<LayoutSetBranch> findByGroupId(long groupId, int start,
134                    int end) {
135                    return getPersistence().findByGroupId(groupId, start, end);
136            }
137    
138            /**
139            * Returns an ordered range of all the layout set branchs where groupId = &#63;.
140            *
141            * <p>
142            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetBranchModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
143            * </p>
144            *
145            * @param groupId the group ID
146            * @param start the lower bound of the range of layout set branchs
147            * @param end the upper bound of the range of layout set branchs (not inclusive)
148            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
149            * @return the ordered range of matching layout set branchs
150            */
151            public static List<LayoutSetBranch> findByGroupId(long groupId, int start,
152                    int end, OrderByComparator<LayoutSetBranch> orderByComparator) {
153                    return getPersistence()
154                                       .findByGroupId(groupId, start, end, orderByComparator);
155            }
156    
157            /**
158            * Returns the first layout set branch in the ordered set where groupId = &#63;.
159            *
160            * @param groupId the group ID
161            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
162            * @return the first matching layout set branch
163            * @throws NoSuchLayoutSetBranchException if a matching layout set branch could not be found
164            */
165            public static LayoutSetBranch findByGroupId_First(long groupId,
166                    OrderByComparator<LayoutSetBranch> orderByComparator)
167                    throws com.liferay.portal.NoSuchLayoutSetBranchException {
168                    return getPersistence().findByGroupId_First(groupId, orderByComparator);
169            }
170    
171            /**
172            * Returns the first layout set branch in the ordered set where groupId = &#63;.
173            *
174            * @param groupId the group ID
175            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
176            * @return the first matching layout set branch, or <code>null</code> if a matching layout set branch could not be found
177            */
178            public static LayoutSetBranch fetchByGroupId_First(long groupId,
179                    OrderByComparator<LayoutSetBranch> orderByComparator) {
180                    return getPersistence().fetchByGroupId_First(groupId, orderByComparator);
181            }
182    
183            /**
184            * Returns the last layout set branch in the ordered set where groupId = &#63;.
185            *
186            * @param groupId the group ID
187            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
188            * @return the last matching layout set branch
189            * @throws NoSuchLayoutSetBranchException if a matching layout set branch could not be found
190            */
191            public static LayoutSetBranch findByGroupId_Last(long groupId,
192                    OrderByComparator<LayoutSetBranch> orderByComparator)
193                    throws com.liferay.portal.NoSuchLayoutSetBranchException {
194                    return getPersistence().findByGroupId_Last(groupId, orderByComparator);
195            }
196    
197            /**
198            * Returns the last layout set branch in the ordered set where groupId = &#63;.
199            *
200            * @param groupId the group ID
201            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
202            * @return the last matching layout set branch, or <code>null</code> if a matching layout set branch could not be found
203            */
204            public static LayoutSetBranch fetchByGroupId_Last(long groupId,
205                    OrderByComparator<LayoutSetBranch> orderByComparator) {
206                    return getPersistence().fetchByGroupId_Last(groupId, orderByComparator);
207            }
208    
209            /**
210            * Returns the layout set branchs before and after the current layout set branch in the ordered set where groupId = &#63;.
211            *
212            * @param layoutSetBranchId the primary key of the current layout set branch
213            * @param groupId the group ID
214            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
215            * @return the previous, current, and next layout set branch
216            * @throws NoSuchLayoutSetBranchException if a layout set branch with the primary key could not be found
217            */
218            public static LayoutSetBranch[] findByGroupId_PrevAndNext(
219                    long layoutSetBranchId, long groupId,
220                    OrderByComparator<LayoutSetBranch> orderByComparator)
221                    throws com.liferay.portal.NoSuchLayoutSetBranchException {
222                    return getPersistence()
223                                       .findByGroupId_PrevAndNext(layoutSetBranchId, groupId,
224                            orderByComparator);
225            }
226    
227            /**
228            * Returns all the layout set branchs that the user has permission to view where groupId = &#63;.
229            *
230            * @param groupId the group ID
231            * @return the matching layout set branchs that the user has permission to view
232            */
233            public static List<LayoutSetBranch> filterFindByGroupId(long groupId) {
234                    return getPersistence().filterFindByGroupId(groupId);
235            }
236    
237            /**
238            * Returns a range of all the layout set branchs that the user has permission to view where groupId = &#63;.
239            *
240            * <p>
241            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetBranchModelImpl}. 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.
242            * </p>
243            *
244            * @param groupId the group ID
245            * @param start the lower bound of the range of layout set branchs
246            * @param end the upper bound of the range of layout set branchs (not inclusive)
247            * @return the range of matching layout set branchs that the user has permission to view
248            */
249            public static List<LayoutSetBranch> filterFindByGroupId(long groupId,
250                    int start, int end) {
251                    return getPersistence().filterFindByGroupId(groupId, start, end);
252            }
253    
254            /**
255            * Returns an ordered range of all the layout set branchs that the user has permissions to view where groupId = &#63;.
256            *
257            * <p>
258            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetBranchModelImpl}. 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.
259            * </p>
260            *
261            * @param groupId the group ID
262            * @param start the lower bound of the range of layout set branchs
263            * @param end the upper bound of the range of layout set branchs (not inclusive)
264            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
265            * @return the ordered range of matching layout set branchs that the user has permission to view
266            */
267            public static List<LayoutSetBranch> filterFindByGroupId(long groupId,
268                    int start, int end, OrderByComparator<LayoutSetBranch> orderByComparator) {
269                    return getPersistence()
270                                       .filterFindByGroupId(groupId, start, end, orderByComparator);
271            }
272    
273            /**
274            * Returns the layout set branchs before and after the current layout set branch in the ordered set of layout set branchs that the user has permission to view where groupId = &#63;.
275            *
276            * @param layoutSetBranchId the primary key of the current layout set branch
277            * @param groupId the group ID
278            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
279            * @return the previous, current, and next layout set branch
280            * @throws NoSuchLayoutSetBranchException if a layout set branch with the primary key could not be found
281            */
282            public static LayoutSetBranch[] filterFindByGroupId_PrevAndNext(
283                    long layoutSetBranchId, long groupId,
284                    OrderByComparator<LayoutSetBranch> orderByComparator)
285                    throws com.liferay.portal.NoSuchLayoutSetBranchException {
286                    return getPersistence()
287                                       .filterFindByGroupId_PrevAndNext(layoutSetBranchId, groupId,
288                            orderByComparator);
289            }
290    
291            /**
292            * Removes all the layout set branchs where groupId = &#63; from the database.
293            *
294            * @param groupId the group ID
295            */
296            public static void removeByGroupId(long groupId) {
297                    getPersistence().removeByGroupId(groupId);
298            }
299    
300            /**
301            * Returns the number of layout set branchs where groupId = &#63;.
302            *
303            * @param groupId the group ID
304            * @return the number of matching layout set branchs
305            */
306            public static int countByGroupId(long groupId) {
307                    return getPersistence().countByGroupId(groupId);
308            }
309    
310            /**
311            * Returns the number of layout set branchs that the user has permission to view where groupId = &#63;.
312            *
313            * @param groupId the group ID
314            * @return the number of matching layout set branchs that the user has permission to view
315            */
316            public static int filterCountByGroupId(long groupId) {
317                    return getPersistence().filterCountByGroupId(groupId);
318            }
319    
320            /**
321            * Returns all the layout set branchs where groupId = &#63; and privateLayout = &#63;.
322            *
323            * @param groupId the group ID
324            * @param privateLayout the private layout
325            * @return the matching layout set branchs
326            */
327            public static List<LayoutSetBranch> findByG_P(long groupId,
328                    boolean privateLayout) {
329                    return getPersistence().findByG_P(groupId, privateLayout);
330            }
331    
332            /**
333            * Returns a range of all the layout set branchs where groupId = &#63; and privateLayout = &#63;.
334            *
335            * <p>
336            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetBranchModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
337            * </p>
338            *
339            * @param groupId the group ID
340            * @param privateLayout the private layout
341            * @param start the lower bound of the range of layout set branchs
342            * @param end the upper bound of the range of layout set branchs (not inclusive)
343            * @return the range of matching layout set branchs
344            */
345            public static List<LayoutSetBranch> findByG_P(long groupId,
346                    boolean privateLayout, int start, int end) {
347                    return getPersistence().findByG_P(groupId, privateLayout, start, end);
348            }
349    
350            /**
351            * Returns an ordered range of all the layout set branchs where groupId = &#63; and privateLayout = &#63;.
352            *
353            * <p>
354            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetBranchModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
355            * </p>
356            *
357            * @param groupId the group ID
358            * @param privateLayout the private layout
359            * @param start the lower bound of the range of layout set branchs
360            * @param end the upper bound of the range of layout set branchs (not inclusive)
361            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
362            * @return the ordered range of matching layout set branchs
363            */
364            public static List<LayoutSetBranch> findByG_P(long groupId,
365                    boolean privateLayout, int start, int end,
366                    OrderByComparator<LayoutSetBranch> orderByComparator) {
367                    return getPersistence()
368                                       .findByG_P(groupId, privateLayout, start, end,
369                            orderByComparator);
370            }
371    
372            /**
373            * Returns the first layout set branch in the ordered set where groupId = &#63; and privateLayout = &#63;.
374            *
375            * @param groupId the group ID
376            * @param privateLayout the private layout
377            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
378            * @return the first matching layout set branch
379            * @throws NoSuchLayoutSetBranchException if a matching layout set branch could not be found
380            */
381            public static LayoutSetBranch findByG_P_First(long groupId,
382                    boolean privateLayout,
383                    OrderByComparator<LayoutSetBranch> orderByComparator)
384                    throws com.liferay.portal.NoSuchLayoutSetBranchException {
385                    return getPersistence()
386                                       .findByG_P_First(groupId, privateLayout, orderByComparator);
387            }
388    
389            /**
390            * Returns the first layout set branch in the ordered set where groupId = &#63; and privateLayout = &#63;.
391            *
392            * @param groupId the group ID
393            * @param privateLayout the private layout
394            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
395            * @return the first matching layout set branch, or <code>null</code> if a matching layout set branch could not be found
396            */
397            public static LayoutSetBranch fetchByG_P_First(long groupId,
398                    boolean privateLayout,
399                    OrderByComparator<LayoutSetBranch> orderByComparator) {
400                    return getPersistence()
401                                       .fetchByG_P_First(groupId, privateLayout, orderByComparator);
402            }
403    
404            /**
405            * Returns the last layout set branch in the ordered set where groupId = &#63; and privateLayout = &#63;.
406            *
407            * @param groupId the group ID
408            * @param privateLayout the private layout
409            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
410            * @return the last matching layout set branch
411            * @throws NoSuchLayoutSetBranchException if a matching layout set branch could not be found
412            */
413            public static LayoutSetBranch findByG_P_Last(long groupId,
414                    boolean privateLayout,
415                    OrderByComparator<LayoutSetBranch> orderByComparator)
416                    throws com.liferay.portal.NoSuchLayoutSetBranchException {
417                    return getPersistence()
418                                       .findByG_P_Last(groupId, privateLayout, orderByComparator);
419            }
420    
421            /**
422            * Returns the last layout set branch in the ordered set where groupId = &#63; and privateLayout = &#63;.
423            *
424            * @param groupId the group ID
425            * @param privateLayout the private layout
426            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
427            * @return the last matching layout set branch, or <code>null</code> if a matching layout set branch could not be found
428            */
429            public static LayoutSetBranch fetchByG_P_Last(long groupId,
430                    boolean privateLayout,
431                    OrderByComparator<LayoutSetBranch> orderByComparator) {
432                    return getPersistence()
433                                       .fetchByG_P_Last(groupId, privateLayout, orderByComparator);
434            }
435    
436            /**
437            * Returns the layout set branchs before and after the current layout set branch in the ordered set where groupId = &#63; and privateLayout = &#63;.
438            *
439            * @param layoutSetBranchId the primary key of the current layout set branch
440            * @param groupId the group ID
441            * @param privateLayout the private layout
442            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
443            * @return the previous, current, and next layout set branch
444            * @throws NoSuchLayoutSetBranchException if a layout set branch with the primary key could not be found
445            */
446            public static LayoutSetBranch[] findByG_P_PrevAndNext(
447                    long layoutSetBranchId, long groupId, boolean privateLayout,
448                    OrderByComparator<LayoutSetBranch> orderByComparator)
449                    throws com.liferay.portal.NoSuchLayoutSetBranchException {
450                    return getPersistence()
451                                       .findByG_P_PrevAndNext(layoutSetBranchId, groupId,
452                            privateLayout, orderByComparator);
453            }
454    
455            /**
456            * Returns all the layout set branchs that the user has permission to view where groupId = &#63; and privateLayout = &#63;.
457            *
458            * @param groupId the group ID
459            * @param privateLayout the private layout
460            * @return the matching layout set branchs that the user has permission to view
461            */
462            public static List<LayoutSetBranch> filterFindByG_P(long groupId,
463                    boolean privateLayout) {
464                    return getPersistence().filterFindByG_P(groupId, privateLayout);
465            }
466    
467            /**
468            * Returns a range of all the layout set branchs that the user has permission to view where groupId = &#63; and privateLayout = &#63;.
469            *
470            * <p>
471            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetBranchModelImpl}. 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.
472            * </p>
473            *
474            * @param groupId the group ID
475            * @param privateLayout the private layout
476            * @param start the lower bound of the range of layout set branchs
477            * @param end the upper bound of the range of layout set branchs (not inclusive)
478            * @return the range of matching layout set branchs that the user has permission to view
479            */
480            public static List<LayoutSetBranch> filterFindByG_P(long groupId,
481                    boolean privateLayout, int start, int end) {
482                    return getPersistence()
483                                       .filterFindByG_P(groupId, privateLayout, start, end);
484            }
485    
486            /**
487            * Returns an ordered range of all the layout set branchs that the user has permissions to view where groupId = &#63; and privateLayout = &#63;.
488            *
489            * <p>
490            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetBranchModelImpl}. 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.
491            * </p>
492            *
493            * @param groupId the group ID
494            * @param privateLayout the private layout
495            * @param start the lower bound of the range of layout set branchs
496            * @param end the upper bound of the range of layout set branchs (not inclusive)
497            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
498            * @return the ordered range of matching layout set branchs that the user has permission to view
499            */
500            public static List<LayoutSetBranch> filterFindByG_P(long groupId,
501                    boolean privateLayout, int start, int end,
502                    OrderByComparator<LayoutSetBranch> orderByComparator) {
503                    return getPersistence()
504                                       .filterFindByG_P(groupId, privateLayout, start, end,
505                            orderByComparator);
506            }
507    
508            /**
509            * Returns the layout set branchs before and after the current layout set branch in the ordered set of layout set branchs that the user has permission to view where groupId = &#63; and privateLayout = &#63;.
510            *
511            * @param layoutSetBranchId the primary key of the current layout set branch
512            * @param groupId the group ID
513            * @param privateLayout the private layout
514            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
515            * @return the previous, current, and next layout set branch
516            * @throws NoSuchLayoutSetBranchException if a layout set branch with the primary key could not be found
517            */
518            public static LayoutSetBranch[] filterFindByG_P_PrevAndNext(
519                    long layoutSetBranchId, long groupId, boolean privateLayout,
520                    OrderByComparator<LayoutSetBranch> orderByComparator)
521                    throws com.liferay.portal.NoSuchLayoutSetBranchException {
522                    return getPersistence()
523                                       .filterFindByG_P_PrevAndNext(layoutSetBranchId, groupId,
524                            privateLayout, orderByComparator);
525            }
526    
527            /**
528            * Removes all the layout set branchs where groupId = &#63; and privateLayout = &#63; from the database.
529            *
530            * @param groupId the group ID
531            * @param privateLayout the private layout
532            */
533            public static void removeByG_P(long groupId, boolean privateLayout) {
534                    getPersistence().removeByG_P(groupId, privateLayout);
535            }
536    
537            /**
538            * Returns the number of layout set branchs where groupId = &#63; and privateLayout = &#63;.
539            *
540            * @param groupId the group ID
541            * @param privateLayout the private layout
542            * @return the number of matching layout set branchs
543            */
544            public static int countByG_P(long groupId, boolean privateLayout) {
545                    return getPersistence().countByG_P(groupId, privateLayout);
546            }
547    
548            /**
549            * Returns the number of layout set branchs that the user has permission to view where groupId = &#63; and privateLayout = &#63;.
550            *
551            * @param groupId the group ID
552            * @param privateLayout the private layout
553            * @return the number of matching layout set branchs that the user has permission to view
554            */
555            public static int filterCountByG_P(long groupId, boolean privateLayout) {
556                    return getPersistence().filterCountByG_P(groupId, privateLayout);
557            }
558    
559            /**
560            * Returns the layout set branch where groupId = &#63; and privateLayout = &#63; and name = &#63; or throws a {@link NoSuchLayoutSetBranchException} if it could not be found.
561            *
562            * @param groupId the group ID
563            * @param privateLayout the private layout
564            * @param name the name
565            * @return the matching layout set branch
566            * @throws NoSuchLayoutSetBranchException if a matching layout set branch could not be found
567            */
568            public static LayoutSetBranch findByG_P_N(long groupId,
569                    boolean privateLayout, java.lang.String name)
570                    throws com.liferay.portal.NoSuchLayoutSetBranchException {
571                    return getPersistence().findByG_P_N(groupId, privateLayout, name);
572            }
573    
574            /**
575            * Returns the layout set branch where groupId = &#63; and privateLayout = &#63; and name = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
576            *
577            * @param groupId the group ID
578            * @param privateLayout the private layout
579            * @param name the name
580            * @return the matching layout set branch, or <code>null</code> if a matching layout set branch could not be found
581            */
582            public static LayoutSetBranch fetchByG_P_N(long groupId,
583                    boolean privateLayout, java.lang.String name) {
584                    return getPersistence().fetchByG_P_N(groupId, privateLayout, name);
585            }
586    
587            /**
588            * Returns the layout set branch where groupId = &#63; and privateLayout = &#63; and name = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
589            *
590            * @param groupId the group ID
591            * @param privateLayout the private layout
592            * @param name the name
593            * @param retrieveFromCache whether to use the finder cache
594            * @return the matching layout set branch, or <code>null</code> if a matching layout set branch could not be found
595            */
596            public static LayoutSetBranch fetchByG_P_N(long groupId,
597                    boolean privateLayout, java.lang.String name, boolean retrieveFromCache) {
598                    return getPersistence()
599                                       .fetchByG_P_N(groupId, privateLayout, name, retrieveFromCache);
600            }
601    
602            /**
603            * Removes the layout set branch where groupId = &#63; and privateLayout = &#63; and name = &#63; from the database.
604            *
605            * @param groupId the group ID
606            * @param privateLayout the private layout
607            * @param name the name
608            * @return the layout set branch that was removed
609            */
610            public static LayoutSetBranch removeByG_P_N(long groupId,
611                    boolean privateLayout, java.lang.String name)
612                    throws com.liferay.portal.NoSuchLayoutSetBranchException {
613                    return getPersistence().removeByG_P_N(groupId, privateLayout, name);
614            }
615    
616            /**
617            * Returns the number of layout set branchs where groupId = &#63; and privateLayout = &#63; and name = &#63;.
618            *
619            * @param groupId the group ID
620            * @param privateLayout the private layout
621            * @param name the name
622            * @return the number of matching layout set branchs
623            */
624            public static int countByG_P_N(long groupId, boolean privateLayout,
625                    java.lang.String name) {
626                    return getPersistence().countByG_P_N(groupId, privateLayout, name);
627            }
628    
629            /**
630            * Returns all the layout set branchs where groupId = &#63; and privateLayout = &#63; and master = &#63;.
631            *
632            * @param groupId the group ID
633            * @param privateLayout the private layout
634            * @param master the master
635            * @return the matching layout set branchs
636            */
637            public static List<LayoutSetBranch> findByG_P_M(long groupId,
638                    boolean privateLayout, boolean master) {
639                    return getPersistence().findByG_P_M(groupId, privateLayout, master);
640            }
641    
642            /**
643            * Returns a range of all the layout set branchs where groupId = &#63; and privateLayout = &#63; and master = &#63;.
644            *
645            * <p>
646            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetBranchModelImpl}. 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.
647            * </p>
648            *
649            * @param groupId the group ID
650            * @param privateLayout the private layout
651            * @param master the master
652            * @param start the lower bound of the range of layout set branchs
653            * @param end the upper bound of the range of layout set branchs (not inclusive)
654            * @return the range of matching layout set branchs
655            */
656            public static List<LayoutSetBranch> findByG_P_M(long groupId,
657                    boolean privateLayout, boolean master, int start, int end) {
658                    return getPersistence()
659                                       .findByG_P_M(groupId, privateLayout, master, start, end);
660            }
661    
662            /**
663            * Returns an ordered range of all the layout set branchs where groupId = &#63; and privateLayout = &#63; and master = &#63;.
664            *
665            * <p>
666            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetBranchModelImpl}. 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.
667            * </p>
668            *
669            * @param groupId the group ID
670            * @param privateLayout the private layout
671            * @param master the master
672            * @param start the lower bound of the range of layout set branchs
673            * @param end the upper bound of the range of layout set branchs (not inclusive)
674            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
675            * @return the ordered range of matching layout set branchs
676            */
677            public static List<LayoutSetBranch> findByG_P_M(long groupId,
678                    boolean privateLayout, boolean master, int start, int end,
679                    OrderByComparator<LayoutSetBranch> orderByComparator) {
680                    return getPersistence()
681                                       .findByG_P_M(groupId, privateLayout, master, start, end,
682                            orderByComparator);
683            }
684    
685            /**
686            * Returns the first layout set branch in the ordered set where groupId = &#63; and privateLayout = &#63; and master = &#63;.
687            *
688            * @param groupId the group ID
689            * @param privateLayout the private layout
690            * @param master the master
691            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
692            * @return the first matching layout set branch
693            * @throws NoSuchLayoutSetBranchException if a matching layout set branch could not be found
694            */
695            public static LayoutSetBranch findByG_P_M_First(long groupId,
696                    boolean privateLayout, boolean master,
697                    OrderByComparator<LayoutSetBranch> orderByComparator)
698                    throws com.liferay.portal.NoSuchLayoutSetBranchException {
699                    return getPersistence()
700                                       .findByG_P_M_First(groupId, privateLayout, master,
701                            orderByComparator);
702            }
703    
704            /**
705            * Returns the first layout set branch in the ordered set where groupId = &#63; and privateLayout = &#63; and master = &#63;.
706            *
707            * @param groupId the group ID
708            * @param privateLayout the private layout
709            * @param master the master
710            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
711            * @return the first matching layout set branch, or <code>null</code> if a matching layout set branch could not be found
712            */
713            public static LayoutSetBranch fetchByG_P_M_First(long groupId,
714                    boolean privateLayout, boolean master,
715                    OrderByComparator<LayoutSetBranch> orderByComparator) {
716                    return getPersistence()
717                                       .fetchByG_P_M_First(groupId, privateLayout, master,
718                            orderByComparator);
719            }
720    
721            /**
722            * Returns the last layout set branch in the ordered set where groupId = &#63; and privateLayout = &#63; and master = &#63;.
723            *
724            * @param groupId the group ID
725            * @param privateLayout the private layout
726            * @param master the master
727            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
728            * @return the last matching layout set branch
729            * @throws NoSuchLayoutSetBranchException if a matching layout set branch could not be found
730            */
731            public static LayoutSetBranch findByG_P_M_Last(long groupId,
732                    boolean privateLayout, boolean master,
733                    OrderByComparator<LayoutSetBranch> orderByComparator)
734                    throws com.liferay.portal.NoSuchLayoutSetBranchException {
735                    return getPersistence()
736                                       .findByG_P_M_Last(groupId, privateLayout, master,
737                            orderByComparator);
738            }
739    
740            /**
741            * Returns the last layout set branch in the ordered set where groupId = &#63; and privateLayout = &#63; and master = &#63;.
742            *
743            * @param groupId the group ID
744            * @param privateLayout the private layout
745            * @param master the master
746            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
747            * @return the last matching layout set branch, or <code>null</code> if a matching layout set branch could not be found
748            */
749            public static LayoutSetBranch fetchByG_P_M_Last(long groupId,
750                    boolean privateLayout, boolean master,
751                    OrderByComparator<LayoutSetBranch> orderByComparator) {
752                    return getPersistence()
753                                       .fetchByG_P_M_Last(groupId, privateLayout, master,
754                            orderByComparator);
755            }
756    
757            /**
758            * Returns the layout set branchs before and after the current layout set branch in the ordered set where groupId = &#63; and privateLayout = &#63; and master = &#63;.
759            *
760            * @param layoutSetBranchId the primary key of the current layout set branch
761            * @param groupId the group ID
762            * @param privateLayout the private layout
763            * @param master the master
764            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
765            * @return the previous, current, and next layout set branch
766            * @throws NoSuchLayoutSetBranchException if a layout set branch with the primary key could not be found
767            */
768            public static LayoutSetBranch[] findByG_P_M_PrevAndNext(
769                    long layoutSetBranchId, long groupId, boolean privateLayout,
770                    boolean master, OrderByComparator<LayoutSetBranch> orderByComparator)
771                    throws com.liferay.portal.NoSuchLayoutSetBranchException {
772                    return getPersistence()
773                                       .findByG_P_M_PrevAndNext(layoutSetBranchId, groupId,
774                            privateLayout, master, orderByComparator);
775            }
776    
777            /**
778            * Returns all the layout set branchs that the user has permission to view where groupId = &#63; and privateLayout = &#63; and master = &#63;.
779            *
780            * @param groupId the group ID
781            * @param privateLayout the private layout
782            * @param master the master
783            * @return the matching layout set branchs that the user has permission to view
784            */
785            public static List<LayoutSetBranch> filterFindByG_P_M(long groupId,
786                    boolean privateLayout, boolean master) {
787                    return getPersistence().filterFindByG_P_M(groupId, privateLayout, master);
788            }
789    
790            /**
791            * Returns a range of all the layout set branchs that the user has permission to view where groupId = &#63; and privateLayout = &#63; and master = &#63;.
792            *
793            * <p>
794            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetBranchModelImpl}. 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.
795            * </p>
796            *
797            * @param groupId the group ID
798            * @param privateLayout the private layout
799            * @param master the master
800            * @param start the lower bound of the range of layout set branchs
801            * @param end the upper bound of the range of layout set branchs (not inclusive)
802            * @return the range of matching layout set branchs that the user has permission to view
803            */
804            public static List<LayoutSetBranch> filterFindByG_P_M(long groupId,
805                    boolean privateLayout, boolean master, int start, int end) {
806                    return getPersistence()
807                                       .filterFindByG_P_M(groupId, privateLayout, master, start, end);
808            }
809    
810            /**
811            * Returns an ordered range of all the layout set branchs that the user has permissions to view where groupId = &#63; and privateLayout = &#63; and master = &#63;.
812            *
813            * <p>
814            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetBranchModelImpl}. 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.
815            * </p>
816            *
817            * @param groupId the group ID
818            * @param privateLayout the private layout
819            * @param master the master
820            * @param start the lower bound of the range of layout set branchs
821            * @param end the upper bound of the range of layout set branchs (not inclusive)
822            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
823            * @return the ordered range of matching layout set branchs that the user has permission to view
824            */
825            public static List<LayoutSetBranch> filterFindByG_P_M(long groupId,
826                    boolean privateLayout, boolean master, int start, int end,
827                    OrderByComparator<LayoutSetBranch> orderByComparator) {
828                    return getPersistence()
829                                       .filterFindByG_P_M(groupId, privateLayout, master, start,
830                            end, orderByComparator);
831            }
832    
833            /**
834            * Returns the layout set branchs before and after the current layout set branch in the ordered set of layout set branchs that the user has permission to view where groupId = &#63; and privateLayout = &#63; and master = &#63;.
835            *
836            * @param layoutSetBranchId the primary key of the current layout set branch
837            * @param groupId the group ID
838            * @param privateLayout the private layout
839            * @param master the master
840            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
841            * @return the previous, current, and next layout set branch
842            * @throws NoSuchLayoutSetBranchException if a layout set branch with the primary key could not be found
843            */
844            public static LayoutSetBranch[] filterFindByG_P_M_PrevAndNext(
845                    long layoutSetBranchId, long groupId, boolean privateLayout,
846                    boolean master, OrderByComparator<LayoutSetBranch> orderByComparator)
847                    throws com.liferay.portal.NoSuchLayoutSetBranchException {
848                    return getPersistence()
849                                       .filterFindByG_P_M_PrevAndNext(layoutSetBranchId, groupId,
850                            privateLayout, master, orderByComparator);
851            }
852    
853            /**
854            * Removes all the layout set branchs where groupId = &#63; and privateLayout = &#63; and master = &#63; from the database.
855            *
856            * @param groupId the group ID
857            * @param privateLayout the private layout
858            * @param master the master
859            */
860            public static void removeByG_P_M(long groupId, boolean privateLayout,
861                    boolean master) {
862                    getPersistence().removeByG_P_M(groupId, privateLayout, master);
863            }
864    
865            /**
866            * Returns the number of layout set branchs where groupId = &#63; and privateLayout = &#63; and master = &#63;.
867            *
868            * @param groupId the group ID
869            * @param privateLayout the private layout
870            * @param master the master
871            * @return the number of matching layout set branchs
872            */
873            public static int countByG_P_M(long groupId, boolean privateLayout,
874                    boolean master) {
875                    return getPersistence().countByG_P_M(groupId, privateLayout, master);
876            }
877    
878            /**
879            * Returns the number of layout set branchs that the user has permission to view where groupId = &#63; and privateLayout = &#63; and master = &#63;.
880            *
881            * @param groupId the group ID
882            * @param privateLayout the private layout
883            * @param master the master
884            * @return the number of matching layout set branchs that the user has permission to view
885            */
886            public static int filterCountByG_P_M(long groupId, boolean privateLayout,
887                    boolean master) {
888                    return getPersistence()
889                                       .filterCountByG_P_M(groupId, privateLayout, master);
890            }
891    
892            /**
893            * Caches the layout set branch in the entity cache if it is enabled.
894            *
895            * @param layoutSetBranch the layout set branch
896            */
897            public static void cacheResult(LayoutSetBranch layoutSetBranch) {
898                    getPersistence().cacheResult(layoutSetBranch);
899            }
900    
901            /**
902            * Caches the layout set branchs in the entity cache if it is enabled.
903            *
904            * @param layoutSetBranchs the layout set branchs
905            */
906            public static void cacheResult(List<LayoutSetBranch> layoutSetBranchs) {
907                    getPersistence().cacheResult(layoutSetBranchs);
908            }
909    
910            /**
911            * Creates a new layout set branch with the primary key. Does not add the layout set branch to the database.
912            *
913            * @param layoutSetBranchId the primary key for the new layout set branch
914            * @return the new layout set branch
915            */
916            public static LayoutSetBranch create(long layoutSetBranchId) {
917                    return getPersistence().create(layoutSetBranchId);
918            }
919    
920            /**
921            * Removes the layout set branch with the primary key from the database. Also notifies the appropriate model listeners.
922            *
923            * @param layoutSetBranchId the primary key of the layout set branch
924            * @return the layout set branch that was removed
925            * @throws NoSuchLayoutSetBranchException if a layout set branch with the primary key could not be found
926            */
927            public static LayoutSetBranch remove(long layoutSetBranchId)
928                    throws com.liferay.portal.NoSuchLayoutSetBranchException {
929                    return getPersistence().remove(layoutSetBranchId);
930            }
931    
932            public static LayoutSetBranch updateImpl(LayoutSetBranch layoutSetBranch) {
933                    return getPersistence().updateImpl(layoutSetBranch);
934            }
935    
936            /**
937            * Returns the layout set branch with the primary key or throws a {@link NoSuchLayoutSetBranchException} if it could not be found.
938            *
939            * @param layoutSetBranchId the primary key of the layout set branch
940            * @return the layout set branch
941            * @throws NoSuchLayoutSetBranchException if a layout set branch with the primary key could not be found
942            */
943            public static LayoutSetBranch findByPrimaryKey(long layoutSetBranchId)
944                    throws com.liferay.portal.NoSuchLayoutSetBranchException {
945                    return getPersistence().findByPrimaryKey(layoutSetBranchId);
946            }
947    
948            /**
949            * Returns the layout set branch with the primary key or returns <code>null</code> if it could not be found.
950            *
951            * @param layoutSetBranchId the primary key of the layout set branch
952            * @return the layout set branch, or <code>null</code> if a layout set branch with the primary key could not be found
953            */
954            public static LayoutSetBranch fetchByPrimaryKey(long layoutSetBranchId) {
955                    return getPersistence().fetchByPrimaryKey(layoutSetBranchId);
956            }
957    
958            public static java.util.Map<java.io.Serializable, LayoutSetBranch> fetchByPrimaryKeys(
959                    java.util.Set<java.io.Serializable> primaryKeys) {
960                    return getPersistence().fetchByPrimaryKeys(primaryKeys);
961            }
962    
963            /**
964            * Returns all the layout set branchs.
965            *
966            * @return the layout set branchs
967            */
968            public static List<LayoutSetBranch> findAll() {
969                    return getPersistence().findAll();
970            }
971    
972            /**
973            * Returns a range of all the layout set branchs.
974            *
975            * <p>
976            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetBranchModelImpl}. 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.
977            * </p>
978            *
979            * @param start the lower bound of the range of layout set branchs
980            * @param end the upper bound of the range of layout set branchs (not inclusive)
981            * @return the range of layout set branchs
982            */
983            public static List<LayoutSetBranch> findAll(int start, int end) {
984                    return getPersistence().findAll(start, end);
985            }
986    
987            /**
988            * Returns an ordered range of all the layout set branchs.
989            *
990            * <p>
991            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetBranchModelImpl}. 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.
992            * </p>
993            *
994            * @param start the lower bound of the range of layout set branchs
995            * @param end the upper bound of the range of layout set branchs (not inclusive)
996            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
997            * @return the ordered range of layout set branchs
998            */
999            public static List<LayoutSetBranch> findAll(int start, int end,
1000                    OrderByComparator<LayoutSetBranch> orderByComparator) {
1001                    return getPersistence().findAll(start, end, orderByComparator);
1002            }
1003    
1004            /**
1005            * Removes all the layout set branchs from the database.
1006            */
1007            public static void removeAll() {
1008                    getPersistence().removeAll();
1009            }
1010    
1011            /**
1012            * Returns the number of layout set branchs.
1013            *
1014            * @return the number of layout set branchs
1015            */
1016            public static int countAll() {
1017                    return getPersistence().countAll();
1018            }
1019    
1020            public static LayoutSetBranchPersistence getPersistence() {
1021                    if (_persistence == null) {
1022                            _persistence = (LayoutSetBranchPersistence)PortalBeanLocatorUtil.locate(LayoutSetBranchPersistence.class.getName());
1023    
1024                            ReferenceRegistry.registerReference(LayoutSetBranchUtil.class,
1025                                    "_persistence");
1026                    }
1027    
1028                    return _persistence;
1029            }
1030    
1031            /**
1032             * @deprecated As of 6.2.0
1033             */
1034            @Deprecated
1035            public void setPersistence(LayoutSetBranchPersistence persistence) {
1036            }
1037    
1038            private static LayoutSetBranchPersistence _persistence;
1039    }