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.LayoutBranch;
024    import com.liferay.portal.service.ServiceContext;
025    
026    import java.util.List;
027    
028    /**
029     * The persistence utility for the layout branch service. This utility wraps {@link com.liferay.portal.service.persistence.impl.LayoutBranchPersistenceImpl} 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 LayoutBranchPersistence
037     * @see com.liferay.portal.service.persistence.impl.LayoutBranchPersistenceImpl
038     * @generated
039     */
040    @ProviderType
041    public class LayoutBranchUtil {
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(LayoutBranch layoutBranch) {
059                    getPersistence().clearCache(layoutBranch);
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<LayoutBranch> 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<LayoutBranch> 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<LayoutBranch> findWithDynamicQuery(
089                    DynamicQuery dynamicQuery, int start, int end,
090                    OrderByComparator<LayoutBranch> 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 LayoutBranch update(LayoutBranch layoutBranch) {
100                    return getPersistence().update(layoutBranch);
101            }
102    
103            /**
104             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
105             */
106            public static LayoutBranch update(LayoutBranch layoutBranch,
107                    ServiceContext serviceContext) {
108                    return getPersistence().update(layoutBranch, serviceContext);
109            }
110    
111            /**
112            * Returns all the layout branchs where layoutSetBranchId = &#63;.
113            *
114            * @param layoutSetBranchId the layout set branch ID
115            * @return the matching layout branchs
116            */
117            public static List<LayoutBranch> findByLayoutSetBranchId(
118                    long layoutSetBranchId) {
119                    return getPersistence().findByLayoutSetBranchId(layoutSetBranchId);
120            }
121    
122            /**
123            * Returns a range of all the layout branchs where layoutSetBranchId = &#63;.
124            *
125            * <p>
126            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link 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 LayoutBranchModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
127            * </p>
128            *
129            * @param layoutSetBranchId the layout set branch ID
130            * @param start the lower bound of the range of layout branchs
131            * @param end the upper bound of the range of layout branchs (not inclusive)
132            * @return the range of matching layout branchs
133            */
134            public static List<LayoutBranch> findByLayoutSetBranchId(
135                    long layoutSetBranchId, int start, int end) {
136                    return getPersistence()
137                                       .findByLayoutSetBranchId(layoutSetBranchId, start, end);
138            }
139    
140            /**
141            * Returns an ordered range of all the layout branchs where layoutSetBranchId = &#63;.
142            *
143            * <p>
144            * 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 LayoutBranchModelImpl}. 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.
145            * </p>
146            *
147            * @param layoutSetBranchId the layout set branch ID
148            * @param start the lower bound of the range of layout branchs
149            * @param end the upper bound of the range of layout branchs (not inclusive)
150            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
151            * @return the ordered range of matching layout branchs
152            */
153            public static List<LayoutBranch> findByLayoutSetBranchId(
154                    long layoutSetBranchId, int start, int end,
155                    OrderByComparator<LayoutBranch> orderByComparator) {
156                    return getPersistence()
157                                       .findByLayoutSetBranchId(layoutSetBranchId, start, end,
158                            orderByComparator);
159            }
160    
161            /**
162            * Returns the first layout branch in the ordered set where layoutSetBranchId = &#63;.
163            *
164            * @param layoutSetBranchId the layout set branch ID
165            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
166            * @return the first matching layout branch
167            * @throws NoSuchLayoutBranchException if a matching layout branch could not be found
168            */
169            public static LayoutBranch findByLayoutSetBranchId_First(
170                    long layoutSetBranchId,
171                    OrderByComparator<LayoutBranch> orderByComparator)
172                    throws com.liferay.portal.NoSuchLayoutBranchException {
173                    return getPersistence()
174                                       .findByLayoutSetBranchId_First(layoutSetBranchId,
175                            orderByComparator);
176            }
177    
178            /**
179            * Returns the first layout branch in the ordered set where layoutSetBranchId = &#63;.
180            *
181            * @param layoutSetBranchId the layout set branch ID
182            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
183            * @return the first matching layout branch, or <code>null</code> if a matching layout branch could not be found
184            */
185            public static LayoutBranch fetchByLayoutSetBranchId_First(
186                    long layoutSetBranchId,
187                    OrderByComparator<LayoutBranch> orderByComparator) {
188                    return getPersistence()
189                                       .fetchByLayoutSetBranchId_First(layoutSetBranchId,
190                            orderByComparator);
191            }
192    
193            /**
194            * Returns the last layout branch in the ordered set where layoutSetBranchId = &#63;.
195            *
196            * @param layoutSetBranchId the layout set branch ID
197            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
198            * @return the last matching layout branch
199            * @throws NoSuchLayoutBranchException if a matching layout branch could not be found
200            */
201            public static LayoutBranch findByLayoutSetBranchId_Last(
202                    long layoutSetBranchId,
203                    OrderByComparator<LayoutBranch> orderByComparator)
204                    throws com.liferay.portal.NoSuchLayoutBranchException {
205                    return getPersistence()
206                                       .findByLayoutSetBranchId_Last(layoutSetBranchId,
207                            orderByComparator);
208            }
209    
210            /**
211            * Returns the last layout branch in the ordered set where layoutSetBranchId = &#63;.
212            *
213            * @param layoutSetBranchId the layout set branch ID
214            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
215            * @return the last matching layout branch, or <code>null</code> if a matching layout branch could not be found
216            */
217            public static LayoutBranch fetchByLayoutSetBranchId_Last(
218                    long layoutSetBranchId,
219                    OrderByComparator<LayoutBranch> orderByComparator) {
220                    return getPersistence()
221                                       .fetchByLayoutSetBranchId_Last(layoutSetBranchId,
222                            orderByComparator);
223            }
224    
225            /**
226            * Returns the layout branchs before and after the current layout branch in the ordered set where layoutSetBranchId = &#63;.
227            *
228            * @param layoutBranchId the primary key of the current layout branch
229            * @param layoutSetBranchId the layout set branch ID
230            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
231            * @return the previous, current, and next layout branch
232            * @throws NoSuchLayoutBranchException if a layout branch with the primary key could not be found
233            */
234            public static LayoutBranch[] findByLayoutSetBranchId_PrevAndNext(
235                    long layoutBranchId, long layoutSetBranchId,
236                    OrderByComparator<LayoutBranch> orderByComparator)
237                    throws com.liferay.portal.NoSuchLayoutBranchException {
238                    return getPersistence()
239                                       .findByLayoutSetBranchId_PrevAndNext(layoutBranchId,
240                            layoutSetBranchId, orderByComparator);
241            }
242    
243            /**
244            * Removes all the layout branchs where layoutSetBranchId = &#63; from the database.
245            *
246            * @param layoutSetBranchId the layout set branch ID
247            */
248            public static void removeByLayoutSetBranchId(long layoutSetBranchId) {
249                    getPersistence().removeByLayoutSetBranchId(layoutSetBranchId);
250            }
251    
252            /**
253            * Returns the number of layout branchs where layoutSetBranchId = &#63;.
254            *
255            * @param layoutSetBranchId the layout set branch ID
256            * @return the number of matching layout branchs
257            */
258            public static int countByLayoutSetBranchId(long layoutSetBranchId) {
259                    return getPersistence().countByLayoutSetBranchId(layoutSetBranchId);
260            }
261    
262            /**
263            * Returns all the layout branchs where layoutSetBranchId = &#63; and plid = &#63;.
264            *
265            * @param layoutSetBranchId the layout set branch ID
266            * @param plid the plid
267            * @return the matching layout branchs
268            */
269            public static List<LayoutBranch> findByL_P(long layoutSetBranchId, long plid) {
270                    return getPersistence().findByL_P(layoutSetBranchId, plid);
271            }
272    
273            /**
274            * Returns a range of all the layout branchs where layoutSetBranchId = &#63; and plid = &#63;.
275            *
276            * <p>
277            * 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 LayoutBranchModelImpl}. 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.
278            * </p>
279            *
280            * @param layoutSetBranchId the layout set branch ID
281            * @param plid the plid
282            * @param start the lower bound of the range of layout branchs
283            * @param end the upper bound of the range of layout branchs (not inclusive)
284            * @return the range of matching layout branchs
285            */
286            public static List<LayoutBranch> findByL_P(long layoutSetBranchId,
287                    long plid, int start, int end) {
288                    return getPersistence().findByL_P(layoutSetBranchId, plid, start, end);
289            }
290    
291            /**
292            * Returns an ordered range of all the layout branchs where layoutSetBranchId = &#63; and plid = &#63;.
293            *
294            * <p>
295            * 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 LayoutBranchModelImpl}. 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.
296            * </p>
297            *
298            * @param layoutSetBranchId the layout set branch ID
299            * @param plid the plid
300            * @param start the lower bound of the range of layout branchs
301            * @param end the upper bound of the range of layout branchs (not inclusive)
302            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
303            * @return the ordered range of matching layout branchs
304            */
305            public static List<LayoutBranch> findByL_P(long layoutSetBranchId,
306                    long plid, int start, int end,
307                    OrderByComparator<LayoutBranch> orderByComparator) {
308                    return getPersistence()
309                                       .findByL_P(layoutSetBranchId, plid, start, end,
310                            orderByComparator);
311            }
312    
313            /**
314            * Returns the first layout branch in the ordered set where layoutSetBranchId = &#63; and plid = &#63;.
315            *
316            * @param layoutSetBranchId the layout set branch ID
317            * @param plid the plid
318            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
319            * @return the first matching layout branch
320            * @throws NoSuchLayoutBranchException if a matching layout branch could not be found
321            */
322            public static LayoutBranch findByL_P_First(long layoutSetBranchId,
323                    long plid, OrderByComparator<LayoutBranch> orderByComparator)
324                    throws com.liferay.portal.NoSuchLayoutBranchException {
325                    return getPersistence()
326                                       .findByL_P_First(layoutSetBranchId, plid, orderByComparator);
327            }
328    
329            /**
330            * Returns the first layout branch in the ordered set where layoutSetBranchId = &#63; and plid = &#63;.
331            *
332            * @param layoutSetBranchId the layout set branch ID
333            * @param plid the plid
334            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
335            * @return the first matching layout branch, or <code>null</code> if a matching layout branch could not be found
336            */
337            public static LayoutBranch fetchByL_P_First(long layoutSetBranchId,
338                    long plid, OrderByComparator<LayoutBranch> orderByComparator) {
339                    return getPersistence()
340                                       .fetchByL_P_First(layoutSetBranchId, plid, orderByComparator);
341            }
342    
343            /**
344            * Returns the last layout branch in the ordered set where layoutSetBranchId = &#63; and plid = &#63;.
345            *
346            * @param layoutSetBranchId the layout set branch ID
347            * @param plid the plid
348            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
349            * @return the last matching layout branch
350            * @throws NoSuchLayoutBranchException if a matching layout branch could not be found
351            */
352            public static LayoutBranch findByL_P_Last(long layoutSetBranchId,
353                    long plid, OrderByComparator<LayoutBranch> orderByComparator)
354                    throws com.liferay.portal.NoSuchLayoutBranchException {
355                    return getPersistence()
356                                       .findByL_P_Last(layoutSetBranchId, plid, orderByComparator);
357            }
358    
359            /**
360            * Returns the last layout branch in the ordered set where layoutSetBranchId = &#63; and plid = &#63;.
361            *
362            * @param layoutSetBranchId the layout set branch ID
363            * @param plid the plid
364            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
365            * @return the last matching layout branch, or <code>null</code> if a matching layout branch could not be found
366            */
367            public static LayoutBranch fetchByL_P_Last(long layoutSetBranchId,
368                    long plid, OrderByComparator<LayoutBranch> orderByComparator) {
369                    return getPersistence()
370                                       .fetchByL_P_Last(layoutSetBranchId, plid, orderByComparator);
371            }
372    
373            /**
374            * Returns the layout branchs before and after the current layout branch in the ordered set where layoutSetBranchId = &#63; and plid = &#63;.
375            *
376            * @param layoutBranchId the primary key of the current layout branch
377            * @param layoutSetBranchId the layout set branch ID
378            * @param plid the plid
379            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
380            * @return the previous, current, and next layout branch
381            * @throws NoSuchLayoutBranchException if a layout branch with the primary key could not be found
382            */
383            public static LayoutBranch[] findByL_P_PrevAndNext(long layoutBranchId,
384                    long layoutSetBranchId, long plid,
385                    OrderByComparator<LayoutBranch> orderByComparator)
386                    throws com.liferay.portal.NoSuchLayoutBranchException {
387                    return getPersistence()
388                                       .findByL_P_PrevAndNext(layoutBranchId, layoutSetBranchId,
389                            plid, orderByComparator);
390            }
391    
392            /**
393            * Removes all the layout branchs where layoutSetBranchId = &#63; and plid = &#63; from the database.
394            *
395            * @param layoutSetBranchId the layout set branch ID
396            * @param plid the plid
397            */
398            public static void removeByL_P(long layoutSetBranchId, long plid) {
399                    getPersistence().removeByL_P(layoutSetBranchId, plid);
400            }
401    
402            /**
403            * Returns the number of layout branchs where layoutSetBranchId = &#63; and plid = &#63;.
404            *
405            * @param layoutSetBranchId the layout set branch ID
406            * @param plid the plid
407            * @return the number of matching layout branchs
408            */
409            public static int countByL_P(long layoutSetBranchId, long plid) {
410                    return getPersistence().countByL_P(layoutSetBranchId, plid);
411            }
412    
413            /**
414            * Returns the layout branch where layoutSetBranchId = &#63; and plid = &#63; and name = &#63; or throws a {@link NoSuchLayoutBranchException} if it could not be found.
415            *
416            * @param layoutSetBranchId the layout set branch ID
417            * @param plid the plid
418            * @param name the name
419            * @return the matching layout branch
420            * @throws NoSuchLayoutBranchException if a matching layout branch could not be found
421            */
422            public static LayoutBranch findByL_P_N(long layoutSetBranchId, long plid,
423                    java.lang.String name)
424                    throws com.liferay.portal.NoSuchLayoutBranchException {
425                    return getPersistence().findByL_P_N(layoutSetBranchId, plid, name);
426            }
427    
428            /**
429            * Returns the layout branch where layoutSetBranchId = &#63; and plid = &#63; and name = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
430            *
431            * @param layoutSetBranchId the layout set branch ID
432            * @param plid the plid
433            * @param name the name
434            * @return the matching layout branch, or <code>null</code> if a matching layout branch could not be found
435            */
436            public static LayoutBranch fetchByL_P_N(long layoutSetBranchId, long plid,
437                    java.lang.String name) {
438                    return getPersistence().fetchByL_P_N(layoutSetBranchId, plid, name);
439            }
440    
441            /**
442            * Returns the layout branch where layoutSetBranchId = &#63; and plid = &#63; and name = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
443            *
444            * @param layoutSetBranchId the layout set branch ID
445            * @param plid the plid
446            * @param name the name
447            * @param retrieveFromCache whether to use the finder cache
448            * @return the matching layout branch, or <code>null</code> if a matching layout branch could not be found
449            */
450            public static LayoutBranch fetchByL_P_N(long layoutSetBranchId, long plid,
451                    java.lang.String name, boolean retrieveFromCache) {
452                    return getPersistence()
453                                       .fetchByL_P_N(layoutSetBranchId, plid, name,
454                            retrieveFromCache);
455            }
456    
457            /**
458            * Removes the layout branch where layoutSetBranchId = &#63; and plid = &#63; and name = &#63; from the database.
459            *
460            * @param layoutSetBranchId the layout set branch ID
461            * @param plid the plid
462            * @param name the name
463            * @return the layout branch that was removed
464            */
465            public static LayoutBranch removeByL_P_N(long layoutSetBranchId, long plid,
466                    java.lang.String name)
467                    throws com.liferay.portal.NoSuchLayoutBranchException {
468                    return getPersistence().removeByL_P_N(layoutSetBranchId, plid, name);
469            }
470    
471            /**
472            * Returns the number of layout branchs where layoutSetBranchId = &#63; and plid = &#63; and name = &#63;.
473            *
474            * @param layoutSetBranchId the layout set branch ID
475            * @param plid the plid
476            * @param name the name
477            * @return the number of matching layout branchs
478            */
479            public static int countByL_P_N(long layoutSetBranchId, long plid,
480                    java.lang.String name) {
481                    return getPersistence().countByL_P_N(layoutSetBranchId, plid, name);
482            }
483    
484            /**
485            * Returns all the layout branchs where layoutSetBranchId = &#63; and plid = &#63; and master = &#63;.
486            *
487            * @param layoutSetBranchId the layout set branch ID
488            * @param plid the plid
489            * @param master the master
490            * @return the matching layout branchs
491            */
492            public static List<LayoutBranch> findByL_P_M(long layoutSetBranchId,
493                    long plid, boolean master) {
494                    return getPersistence().findByL_P_M(layoutSetBranchId, plid, master);
495            }
496    
497            /**
498            * Returns a range of all the layout branchs where layoutSetBranchId = &#63; and plid = &#63; and master = &#63;.
499            *
500            * <p>
501            * 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 LayoutBranchModelImpl}. 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.
502            * </p>
503            *
504            * @param layoutSetBranchId the layout set branch ID
505            * @param plid the plid
506            * @param master the master
507            * @param start the lower bound of the range of layout branchs
508            * @param end the upper bound of the range of layout branchs (not inclusive)
509            * @return the range of matching layout branchs
510            */
511            public static List<LayoutBranch> findByL_P_M(long layoutSetBranchId,
512                    long plid, boolean master, int start, int end) {
513                    return getPersistence()
514                                       .findByL_P_M(layoutSetBranchId, plid, master, start, end);
515            }
516    
517            /**
518            * Returns an ordered range of all the layout branchs where layoutSetBranchId = &#63; and plid = &#63; and master = &#63;.
519            *
520            * <p>
521            * 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 LayoutBranchModelImpl}. 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.
522            * </p>
523            *
524            * @param layoutSetBranchId the layout set branch ID
525            * @param plid the plid
526            * @param master the master
527            * @param start the lower bound of the range of layout branchs
528            * @param end the upper bound of the range of layout branchs (not inclusive)
529            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
530            * @return the ordered range of matching layout branchs
531            */
532            public static List<LayoutBranch> findByL_P_M(long layoutSetBranchId,
533                    long plid, boolean master, int start, int end,
534                    OrderByComparator<LayoutBranch> orderByComparator) {
535                    return getPersistence()
536                                       .findByL_P_M(layoutSetBranchId, plid, master, start, end,
537                            orderByComparator);
538            }
539    
540            /**
541            * Returns the first layout branch in the ordered set where layoutSetBranchId = &#63; and plid = &#63; and master = &#63;.
542            *
543            * @param layoutSetBranchId the layout set branch ID
544            * @param plid the plid
545            * @param master the master
546            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
547            * @return the first matching layout branch
548            * @throws NoSuchLayoutBranchException if a matching layout branch could not be found
549            */
550            public static LayoutBranch findByL_P_M_First(long layoutSetBranchId,
551                    long plid, boolean master,
552                    OrderByComparator<LayoutBranch> orderByComparator)
553                    throws com.liferay.portal.NoSuchLayoutBranchException {
554                    return getPersistence()
555                                       .findByL_P_M_First(layoutSetBranchId, plid, master,
556                            orderByComparator);
557            }
558    
559            /**
560            * Returns the first layout branch in the ordered set where layoutSetBranchId = &#63; and plid = &#63; and master = &#63;.
561            *
562            * @param layoutSetBranchId the layout set branch ID
563            * @param plid the plid
564            * @param master the master
565            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
566            * @return the first matching layout branch, or <code>null</code> if a matching layout branch could not be found
567            */
568            public static LayoutBranch fetchByL_P_M_First(long layoutSetBranchId,
569                    long plid, boolean master,
570                    OrderByComparator<LayoutBranch> orderByComparator) {
571                    return getPersistence()
572                                       .fetchByL_P_M_First(layoutSetBranchId, plid, master,
573                            orderByComparator);
574            }
575    
576            /**
577            * Returns the last layout branch in the ordered set where layoutSetBranchId = &#63; and plid = &#63; and master = &#63;.
578            *
579            * @param layoutSetBranchId the layout set branch ID
580            * @param plid the plid
581            * @param master the master
582            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
583            * @return the last matching layout branch
584            * @throws NoSuchLayoutBranchException if a matching layout branch could not be found
585            */
586            public static LayoutBranch findByL_P_M_Last(long layoutSetBranchId,
587                    long plid, boolean master,
588                    OrderByComparator<LayoutBranch> orderByComparator)
589                    throws com.liferay.portal.NoSuchLayoutBranchException {
590                    return getPersistence()
591                                       .findByL_P_M_Last(layoutSetBranchId, plid, master,
592                            orderByComparator);
593            }
594    
595            /**
596            * Returns the last layout branch in the ordered set where layoutSetBranchId = &#63; and plid = &#63; and master = &#63;.
597            *
598            * @param layoutSetBranchId the layout set branch ID
599            * @param plid the plid
600            * @param master the master
601            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
602            * @return the last matching layout branch, or <code>null</code> if a matching layout branch could not be found
603            */
604            public static LayoutBranch fetchByL_P_M_Last(long layoutSetBranchId,
605                    long plid, boolean master,
606                    OrderByComparator<LayoutBranch> orderByComparator) {
607                    return getPersistence()
608                                       .fetchByL_P_M_Last(layoutSetBranchId, plid, master,
609                            orderByComparator);
610            }
611    
612            /**
613            * Returns the layout branchs before and after the current layout branch in the ordered set where layoutSetBranchId = &#63; and plid = &#63; and master = &#63;.
614            *
615            * @param layoutBranchId the primary key of the current layout branch
616            * @param layoutSetBranchId the layout set branch ID
617            * @param plid the plid
618            * @param master the master
619            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
620            * @return the previous, current, and next layout branch
621            * @throws NoSuchLayoutBranchException if a layout branch with the primary key could not be found
622            */
623            public static LayoutBranch[] findByL_P_M_PrevAndNext(long layoutBranchId,
624                    long layoutSetBranchId, long plid, boolean master,
625                    OrderByComparator<LayoutBranch> orderByComparator)
626                    throws com.liferay.portal.NoSuchLayoutBranchException {
627                    return getPersistence()
628                                       .findByL_P_M_PrevAndNext(layoutBranchId, layoutSetBranchId,
629                            plid, master, orderByComparator);
630            }
631    
632            /**
633            * Removes all the layout branchs where layoutSetBranchId = &#63; and plid = &#63; and master = &#63; from the database.
634            *
635            * @param layoutSetBranchId the layout set branch ID
636            * @param plid the plid
637            * @param master the master
638            */
639            public static void removeByL_P_M(long layoutSetBranchId, long plid,
640                    boolean master) {
641                    getPersistence().removeByL_P_M(layoutSetBranchId, plid, master);
642            }
643    
644            /**
645            * Returns the number of layout branchs where layoutSetBranchId = &#63; and plid = &#63; and master = &#63;.
646            *
647            * @param layoutSetBranchId the layout set branch ID
648            * @param plid the plid
649            * @param master the master
650            * @return the number of matching layout branchs
651            */
652            public static int countByL_P_M(long layoutSetBranchId, long plid,
653                    boolean master) {
654                    return getPersistence().countByL_P_M(layoutSetBranchId, plid, master);
655            }
656    
657            /**
658            * Caches the layout branch in the entity cache if it is enabled.
659            *
660            * @param layoutBranch the layout branch
661            */
662            public static void cacheResult(LayoutBranch layoutBranch) {
663                    getPersistence().cacheResult(layoutBranch);
664            }
665    
666            /**
667            * Caches the layout branchs in the entity cache if it is enabled.
668            *
669            * @param layoutBranchs the layout branchs
670            */
671            public static void cacheResult(List<LayoutBranch> layoutBranchs) {
672                    getPersistence().cacheResult(layoutBranchs);
673            }
674    
675            /**
676            * Creates a new layout branch with the primary key. Does not add the layout branch to the database.
677            *
678            * @param layoutBranchId the primary key for the new layout branch
679            * @return the new layout branch
680            */
681            public static LayoutBranch create(long layoutBranchId) {
682                    return getPersistence().create(layoutBranchId);
683            }
684    
685            /**
686            * Removes the layout branch with the primary key from the database. Also notifies the appropriate model listeners.
687            *
688            * @param layoutBranchId the primary key of the layout branch
689            * @return the layout branch that was removed
690            * @throws NoSuchLayoutBranchException if a layout branch with the primary key could not be found
691            */
692            public static LayoutBranch remove(long layoutBranchId)
693                    throws com.liferay.portal.NoSuchLayoutBranchException {
694                    return getPersistence().remove(layoutBranchId);
695            }
696    
697            public static LayoutBranch updateImpl(LayoutBranch layoutBranch) {
698                    return getPersistence().updateImpl(layoutBranch);
699            }
700    
701            /**
702            * Returns the layout branch with the primary key or throws a {@link NoSuchLayoutBranchException} if it could not be found.
703            *
704            * @param layoutBranchId the primary key of the layout branch
705            * @return the layout branch
706            * @throws NoSuchLayoutBranchException if a layout branch with the primary key could not be found
707            */
708            public static LayoutBranch findByPrimaryKey(long layoutBranchId)
709                    throws com.liferay.portal.NoSuchLayoutBranchException {
710                    return getPersistence().findByPrimaryKey(layoutBranchId);
711            }
712    
713            /**
714            * Returns the layout branch with the primary key or returns <code>null</code> if it could not be found.
715            *
716            * @param layoutBranchId the primary key of the layout branch
717            * @return the layout branch, or <code>null</code> if a layout branch with the primary key could not be found
718            */
719            public static LayoutBranch fetchByPrimaryKey(long layoutBranchId) {
720                    return getPersistence().fetchByPrimaryKey(layoutBranchId);
721            }
722    
723            public static java.util.Map<java.io.Serializable, LayoutBranch> fetchByPrimaryKeys(
724                    java.util.Set<java.io.Serializable> primaryKeys) {
725                    return getPersistence().fetchByPrimaryKeys(primaryKeys);
726            }
727    
728            /**
729            * Returns all the layout branchs.
730            *
731            * @return the layout branchs
732            */
733            public static List<LayoutBranch> findAll() {
734                    return getPersistence().findAll();
735            }
736    
737            /**
738            * Returns a range of all the layout branchs.
739            *
740            * <p>
741            * 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 LayoutBranchModelImpl}. 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.
742            * </p>
743            *
744            * @param start the lower bound of the range of layout branchs
745            * @param end the upper bound of the range of layout branchs (not inclusive)
746            * @return the range of layout branchs
747            */
748            public static List<LayoutBranch> findAll(int start, int end) {
749                    return getPersistence().findAll(start, end);
750            }
751    
752            /**
753            * Returns an ordered range of all the layout branchs.
754            *
755            * <p>
756            * 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 LayoutBranchModelImpl}. 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.
757            * </p>
758            *
759            * @param start the lower bound of the range of layout branchs
760            * @param end the upper bound of the range of layout branchs (not inclusive)
761            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
762            * @return the ordered range of layout branchs
763            */
764            public static List<LayoutBranch> findAll(int start, int end,
765                    OrderByComparator<LayoutBranch> orderByComparator) {
766                    return getPersistence().findAll(start, end, orderByComparator);
767            }
768    
769            /**
770            * Removes all the layout branchs from the database.
771            */
772            public static void removeAll() {
773                    getPersistence().removeAll();
774            }
775    
776            /**
777            * Returns the number of layout branchs.
778            *
779            * @return the number of layout branchs
780            */
781            public static int countAll() {
782                    return getPersistence().countAll();
783            }
784    
785            public static LayoutBranchPersistence getPersistence() {
786                    if (_persistence == null) {
787                            _persistence = (LayoutBranchPersistence)PortalBeanLocatorUtil.locate(LayoutBranchPersistence.class.getName());
788    
789                            ReferenceRegistry.registerReference(LayoutBranchUtil.class,
790                                    "_persistence");
791                    }
792    
793                    return _persistence;
794            }
795    
796            /**
797             * @deprecated As of 6.2.0
798             */
799            @Deprecated
800            public void setPersistence(LayoutBranchPersistence persistence) {
801            }
802    
803            private static LayoutBranchPersistence _persistence;
804    }