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