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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ? 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 = ?. 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 = ? and plid = ?. 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 = ? and plid = ?. 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 = ? and plid = ?. 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 = ? and plid = ?. 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 = ? and plid = ?. 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 = ? and plid = ?. 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 = ? and plid = ?. 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 = ? and plid = ?. 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 = ? and plid = ? 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 = ? and plid = ?. 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 = ? and plid = ? and name = ? 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 = ? and plid = ? and name = ? 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 = ? and plid = ? and name = ? 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 = ? and plid = ? and name = ? 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 = ? and plid = ? and name = ?. 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 = ? and plid = ? and master = ?. 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 = ? and plid = ? and master = ?. 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 = ? and plid = ? and master = ?. 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 = ? and plid = ? and master = ?. 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 = ? and plid = ? and master = ?. 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 = ? and plid = ? and master = ?. 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 = ? and plid = ? and master = ?. 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 = ? and plid = ? and master = ?. 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 = ? and plid = ? and master = ? 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 = ? and plid = ? and master = ?. 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 }