001 /** 002 * Copyright (c) 2000-2011 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 com.liferay.portal.kernel.bean.PortalBeanLocatorUtil; 018 import com.liferay.portal.kernel.dao.orm.DynamicQuery; 019 import com.liferay.portal.kernel.exception.SystemException; 020 import com.liferay.portal.kernel.util.OrderByComparator; 021 import com.liferay.portal.kernel.util.ReferenceRegistry; 022 import com.liferay.portal.model.LayoutRevision; 023 import com.liferay.portal.service.ServiceContext; 024 025 import java.util.List; 026 027 /** 028 * The persistence utility for the layout revision service. This utility wraps {@link LayoutRevisionPersistenceImpl} 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. 029 * 030 * <p> 031 * Caching information and settings can be found in <code>portal.properties</code> 032 * </p> 033 * 034 * @author Brian Wing Shun Chan 035 * @see LayoutRevisionPersistence 036 * @see LayoutRevisionPersistenceImpl 037 * @generated 038 */ 039 public class LayoutRevisionUtil { 040 /* 041 * NOTE FOR DEVELOPERS: 042 * 043 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. 044 */ 045 046 /** 047 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 048 */ 049 public static void clearCache() { 050 getPersistence().clearCache(); 051 } 052 053 /** 054 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 055 */ 056 public static void clearCache(LayoutRevision layoutRevision) { 057 getPersistence().clearCache(layoutRevision); 058 } 059 060 /** 061 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 062 */ 063 public long countWithDynamicQuery(DynamicQuery dynamicQuery) 064 throws SystemException { 065 return getPersistence().countWithDynamicQuery(dynamicQuery); 066 } 067 068 /** 069 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 070 */ 071 public static List<LayoutRevision> findWithDynamicQuery( 072 DynamicQuery dynamicQuery) throws SystemException { 073 return getPersistence().findWithDynamicQuery(dynamicQuery); 074 } 075 076 /** 077 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 078 */ 079 public static List<LayoutRevision> findWithDynamicQuery( 080 DynamicQuery dynamicQuery, int start, int end) 081 throws SystemException { 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<LayoutRevision> findWithDynamicQuery( 089 DynamicQuery dynamicQuery, int start, int end, 090 OrderByComparator orderByComparator) throws SystemException { 091 return getPersistence() 092 .findWithDynamicQuery(dynamicQuery, start, end, 093 orderByComparator); 094 } 095 096 /** 097 * @see com.liferay.portal.service.persistence.BasePersistence#remove(com.liferay.portal.model.BaseModel) 098 */ 099 public static LayoutRevision remove(LayoutRevision layoutRevision) 100 throws SystemException { 101 return getPersistence().remove(layoutRevision); 102 } 103 104 /** 105 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean) 106 */ 107 public static LayoutRevision update(LayoutRevision layoutRevision, 108 boolean merge) throws SystemException { 109 return getPersistence().update(layoutRevision, merge); 110 } 111 112 /** 113 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean, ServiceContext) 114 */ 115 public static LayoutRevision update(LayoutRevision layoutRevision, 116 boolean merge, ServiceContext serviceContext) throws SystemException { 117 return getPersistence().update(layoutRevision, merge, serviceContext); 118 } 119 120 /** 121 * Caches the layout revision in the entity cache if it is enabled. 122 * 123 * @param layoutRevision the layout revision 124 */ 125 public static void cacheResult( 126 com.liferay.portal.model.LayoutRevision layoutRevision) { 127 getPersistence().cacheResult(layoutRevision); 128 } 129 130 /** 131 * Caches the layout revisions in the entity cache if it is enabled. 132 * 133 * @param layoutRevisions the layout revisions 134 */ 135 public static void cacheResult( 136 java.util.List<com.liferay.portal.model.LayoutRevision> layoutRevisions) { 137 getPersistence().cacheResult(layoutRevisions); 138 } 139 140 /** 141 * Creates a new layout revision with the primary key. Does not add the layout revision to the database. 142 * 143 * @param layoutRevisionId the primary key for the new layout revision 144 * @return the new layout revision 145 */ 146 public static com.liferay.portal.model.LayoutRevision create( 147 long layoutRevisionId) { 148 return getPersistence().create(layoutRevisionId); 149 } 150 151 /** 152 * Removes the layout revision with the primary key from the database. Also notifies the appropriate model listeners. 153 * 154 * @param layoutRevisionId the primary key of the layout revision 155 * @return the layout revision that was removed 156 * @throws com.liferay.portal.NoSuchLayoutRevisionException if a layout revision with the primary key could not be found 157 * @throws SystemException if a system exception occurred 158 */ 159 public static com.liferay.portal.model.LayoutRevision remove( 160 long layoutRevisionId) 161 throws com.liferay.portal.NoSuchLayoutRevisionException, 162 com.liferay.portal.kernel.exception.SystemException { 163 return getPersistence().remove(layoutRevisionId); 164 } 165 166 public static com.liferay.portal.model.LayoutRevision updateImpl( 167 com.liferay.portal.model.LayoutRevision layoutRevision, boolean merge) 168 throws com.liferay.portal.kernel.exception.SystemException { 169 return getPersistence().updateImpl(layoutRevision, merge); 170 } 171 172 /** 173 * Returns the layout revision with the primary key or throws a {@link com.liferay.portal.NoSuchLayoutRevisionException} if it could not be found. 174 * 175 * @param layoutRevisionId the primary key of the layout revision 176 * @return the layout revision 177 * @throws com.liferay.portal.NoSuchLayoutRevisionException if a layout revision with the primary key could not be found 178 * @throws SystemException if a system exception occurred 179 */ 180 public static com.liferay.portal.model.LayoutRevision findByPrimaryKey( 181 long layoutRevisionId) 182 throws com.liferay.portal.NoSuchLayoutRevisionException, 183 com.liferay.portal.kernel.exception.SystemException { 184 return getPersistence().findByPrimaryKey(layoutRevisionId); 185 } 186 187 /** 188 * Returns the layout revision with the primary key or returns <code>null</code> if it could not be found. 189 * 190 * @param layoutRevisionId the primary key of the layout revision 191 * @return the layout revision, or <code>null</code> if a layout revision with the primary key could not be found 192 * @throws SystemException if a system exception occurred 193 */ 194 public static com.liferay.portal.model.LayoutRevision fetchByPrimaryKey( 195 long layoutRevisionId) 196 throws com.liferay.portal.kernel.exception.SystemException { 197 return getPersistence().fetchByPrimaryKey(layoutRevisionId); 198 } 199 200 /** 201 * Returns all the layout revisions where layoutSetBranchId = ?. 202 * 203 * @param layoutSetBranchId the layout set branch ID 204 * @return the matching layout revisions 205 * @throws SystemException if a system exception occurred 206 */ 207 public static java.util.List<com.liferay.portal.model.LayoutRevision> findByLayoutSetBranchId( 208 long layoutSetBranchId) 209 throws com.liferay.portal.kernel.exception.SystemException { 210 return getPersistence().findByLayoutSetBranchId(layoutSetBranchId); 211 } 212 213 /** 214 * Returns a range of all the layout revisions where layoutSetBranchId = ?. 215 * 216 * <p> 217 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 218 * </p> 219 * 220 * @param layoutSetBranchId the layout set branch ID 221 * @param start the lower bound of the range of layout revisions 222 * @param end the upper bound of the range of layout revisions (not inclusive) 223 * @return the range of matching layout revisions 224 * @throws SystemException if a system exception occurred 225 */ 226 public static java.util.List<com.liferay.portal.model.LayoutRevision> findByLayoutSetBranchId( 227 long layoutSetBranchId, int start, int end) 228 throws com.liferay.portal.kernel.exception.SystemException { 229 return getPersistence() 230 .findByLayoutSetBranchId(layoutSetBranchId, start, end); 231 } 232 233 /** 234 * Returns an ordered range of all the layout revisions where layoutSetBranchId = ?. 235 * 236 * <p> 237 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 238 * </p> 239 * 240 * @param layoutSetBranchId the layout set branch ID 241 * @param start the lower bound of the range of layout revisions 242 * @param end the upper bound of the range of layout revisions (not inclusive) 243 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 244 * @return the ordered range of matching layout revisions 245 * @throws SystemException if a system exception occurred 246 */ 247 public static java.util.List<com.liferay.portal.model.LayoutRevision> findByLayoutSetBranchId( 248 long layoutSetBranchId, int start, int end, 249 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 250 throws com.liferay.portal.kernel.exception.SystemException { 251 return getPersistence() 252 .findByLayoutSetBranchId(layoutSetBranchId, start, end, 253 orderByComparator); 254 } 255 256 /** 257 * Returns the first layout revision in the ordered set where layoutSetBranchId = ?. 258 * 259 * <p> 260 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 261 * </p> 262 * 263 * @param layoutSetBranchId the layout set branch ID 264 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 265 * @return the first matching layout revision 266 * @throws com.liferay.portal.NoSuchLayoutRevisionException if a matching layout revision could not be found 267 * @throws SystemException if a system exception occurred 268 */ 269 public static com.liferay.portal.model.LayoutRevision findByLayoutSetBranchId_First( 270 long layoutSetBranchId, 271 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 272 throws com.liferay.portal.NoSuchLayoutRevisionException, 273 com.liferay.portal.kernel.exception.SystemException { 274 return getPersistence() 275 .findByLayoutSetBranchId_First(layoutSetBranchId, 276 orderByComparator); 277 } 278 279 /** 280 * Returns the last layout revision in the ordered set where layoutSetBranchId = ?. 281 * 282 * <p> 283 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 284 * </p> 285 * 286 * @param layoutSetBranchId the layout set branch ID 287 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 288 * @return the last matching layout revision 289 * @throws com.liferay.portal.NoSuchLayoutRevisionException if a matching layout revision could not be found 290 * @throws SystemException if a system exception occurred 291 */ 292 public static com.liferay.portal.model.LayoutRevision findByLayoutSetBranchId_Last( 293 long layoutSetBranchId, 294 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 295 throws com.liferay.portal.NoSuchLayoutRevisionException, 296 com.liferay.portal.kernel.exception.SystemException { 297 return getPersistence() 298 .findByLayoutSetBranchId_Last(layoutSetBranchId, 299 orderByComparator); 300 } 301 302 /** 303 * Returns the layout revisions before and after the current layout revision in the ordered set where layoutSetBranchId = ?. 304 * 305 * <p> 306 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 307 * </p> 308 * 309 * @param layoutRevisionId the primary key of the current layout revision 310 * @param layoutSetBranchId the layout set branch ID 311 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 312 * @return the previous, current, and next layout revision 313 * @throws com.liferay.portal.NoSuchLayoutRevisionException if a layout revision with the primary key could not be found 314 * @throws SystemException if a system exception occurred 315 */ 316 public static com.liferay.portal.model.LayoutRevision[] findByLayoutSetBranchId_PrevAndNext( 317 long layoutRevisionId, long layoutSetBranchId, 318 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 319 throws com.liferay.portal.NoSuchLayoutRevisionException, 320 com.liferay.portal.kernel.exception.SystemException { 321 return getPersistence() 322 .findByLayoutSetBranchId_PrevAndNext(layoutRevisionId, 323 layoutSetBranchId, orderByComparator); 324 } 325 326 /** 327 * Returns all the layout revisions where plid = ?. 328 * 329 * @param plid the plid 330 * @return the matching layout revisions 331 * @throws SystemException if a system exception occurred 332 */ 333 public static java.util.List<com.liferay.portal.model.LayoutRevision> findByPlid( 334 long plid) throws com.liferay.portal.kernel.exception.SystemException { 335 return getPersistence().findByPlid(plid); 336 } 337 338 /** 339 * Returns a range of all the layout revisions where plid = ?. 340 * 341 * <p> 342 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 343 * </p> 344 * 345 * @param plid the plid 346 * @param start the lower bound of the range of layout revisions 347 * @param end the upper bound of the range of layout revisions (not inclusive) 348 * @return the range of matching layout revisions 349 * @throws SystemException if a system exception occurred 350 */ 351 public static java.util.List<com.liferay.portal.model.LayoutRevision> findByPlid( 352 long plid, int start, int end) 353 throws com.liferay.portal.kernel.exception.SystemException { 354 return getPersistence().findByPlid(plid, start, end); 355 } 356 357 /** 358 * Returns an ordered range of all the layout revisions where plid = ?. 359 * 360 * <p> 361 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 362 * </p> 363 * 364 * @param plid the plid 365 * @param start the lower bound of the range of layout revisions 366 * @param end the upper bound of the range of layout revisions (not inclusive) 367 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 368 * @return the ordered range of matching layout revisions 369 * @throws SystemException if a system exception occurred 370 */ 371 public static java.util.List<com.liferay.portal.model.LayoutRevision> findByPlid( 372 long plid, int start, int end, 373 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 374 throws com.liferay.portal.kernel.exception.SystemException { 375 return getPersistence().findByPlid(plid, start, end, orderByComparator); 376 } 377 378 /** 379 * Returns the first layout revision in the ordered set where plid = ?. 380 * 381 * <p> 382 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 383 * </p> 384 * 385 * @param plid the plid 386 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 387 * @return the first matching layout revision 388 * @throws com.liferay.portal.NoSuchLayoutRevisionException if a matching layout revision could not be found 389 * @throws SystemException if a system exception occurred 390 */ 391 public static com.liferay.portal.model.LayoutRevision findByPlid_First( 392 long plid, 393 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 394 throws com.liferay.portal.NoSuchLayoutRevisionException, 395 com.liferay.portal.kernel.exception.SystemException { 396 return getPersistence().findByPlid_First(plid, orderByComparator); 397 } 398 399 /** 400 * Returns the last layout revision in the ordered set where plid = ?. 401 * 402 * <p> 403 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 404 * </p> 405 * 406 * @param plid the plid 407 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 408 * @return the last matching layout revision 409 * @throws com.liferay.portal.NoSuchLayoutRevisionException if a matching layout revision could not be found 410 * @throws SystemException if a system exception occurred 411 */ 412 public static com.liferay.portal.model.LayoutRevision findByPlid_Last( 413 long plid, 414 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 415 throws com.liferay.portal.NoSuchLayoutRevisionException, 416 com.liferay.portal.kernel.exception.SystemException { 417 return getPersistence().findByPlid_Last(plid, orderByComparator); 418 } 419 420 /** 421 * Returns the layout revisions before and after the current layout revision in the ordered set where plid = ?. 422 * 423 * <p> 424 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 425 * </p> 426 * 427 * @param layoutRevisionId the primary key of the current layout revision 428 * @param plid the plid 429 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 430 * @return the previous, current, and next layout revision 431 * @throws com.liferay.portal.NoSuchLayoutRevisionException if a layout revision with the primary key could not be found 432 * @throws SystemException if a system exception occurred 433 */ 434 public static com.liferay.portal.model.LayoutRevision[] findByPlid_PrevAndNext( 435 long layoutRevisionId, long plid, 436 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 437 throws com.liferay.portal.NoSuchLayoutRevisionException, 438 com.liferay.portal.kernel.exception.SystemException { 439 return getPersistence() 440 .findByPlid_PrevAndNext(layoutRevisionId, plid, 441 orderByComparator); 442 } 443 444 /** 445 * Returns all the layout revisions where layoutSetBranchId = ? and head = ?. 446 * 447 * @param layoutSetBranchId the layout set branch ID 448 * @param head the head 449 * @return the matching layout revisions 450 * @throws SystemException if a system exception occurred 451 */ 452 public static java.util.List<com.liferay.portal.model.LayoutRevision> findByL_H( 453 long layoutSetBranchId, boolean head) 454 throws com.liferay.portal.kernel.exception.SystemException { 455 return getPersistence().findByL_H(layoutSetBranchId, head); 456 } 457 458 /** 459 * Returns a range of all the layout revisions where layoutSetBranchId = ? and head = ?. 460 * 461 * <p> 462 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 463 * </p> 464 * 465 * @param layoutSetBranchId the layout set branch ID 466 * @param head the head 467 * @param start the lower bound of the range of layout revisions 468 * @param end the upper bound of the range of layout revisions (not inclusive) 469 * @return the range of matching layout revisions 470 * @throws SystemException if a system exception occurred 471 */ 472 public static java.util.List<com.liferay.portal.model.LayoutRevision> findByL_H( 473 long layoutSetBranchId, boolean head, int start, int end) 474 throws com.liferay.portal.kernel.exception.SystemException { 475 return getPersistence().findByL_H(layoutSetBranchId, head, start, end); 476 } 477 478 /** 479 * Returns an ordered range of all the layout revisions where layoutSetBranchId = ? and head = ?. 480 * 481 * <p> 482 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 483 * </p> 484 * 485 * @param layoutSetBranchId the layout set branch ID 486 * @param head the head 487 * @param start the lower bound of the range of layout revisions 488 * @param end the upper bound of the range of layout revisions (not inclusive) 489 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 490 * @return the ordered range of matching layout revisions 491 * @throws SystemException if a system exception occurred 492 */ 493 public static java.util.List<com.liferay.portal.model.LayoutRevision> findByL_H( 494 long layoutSetBranchId, boolean head, int start, int end, 495 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 496 throws com.liferay.portal.kernel.exception.SystemException { 497 return getPersistence() 498 .findByL_H(layoutSetBranchId, head, start, end, 499 orderByComparator); 500 } 501 502 /** 503 * Returns the first layout revision in the ordered set where layoutSetBranchId = ? and head = ?. 504 * 505 * <p> 506 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 507 * </p> 508 * 509 * @param layoutSetBranchId the layout set branch ID 510 * @param head the head 511 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 512 * @return the first matching layout revision 513 * @throws com.liferay.portal.NoSuchLayoutRevisionException if a matching layout revision could not be found 514 * @throws SystemException if a system exception occurred 515 */ 516 public static com.liferay.portal.model.LayoutRevision findByL_H_First( 517 long layoutSetBranchId, boolean head, 518 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 519 throws com.liferay.portal.NoSuchLayoutRevisionException, 520 com.liferay.portal.kernel.exception.SystemException { 521 return getPersistence() 522 .findByL_H_First(layoutSetBranchId, head, orderByComparator); 523 } 524 525 /** 526 * Returns the last layout revision in the ordered set where layoutSetBranchId = ? and head = ?. 527 * 528 * <p> 529 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 530 * </p> 531 * 532 * @param layoutSetBranchId the layout set branch ID 533 * @param head the head 534 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 535 * @return the last matching layout revision 536 * @throws com.liferay.portal.NoSuchLayoutRevisionException if a matching layout revision could not be found 537 * @throws SystemException if a system exception occurred 538 */ 539 public static com.liferay.portal.model.LayoutRevision findByL_H_Last( 540 long layoutSetBranchId, boolean head, 541 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 542 throws com.liferay.portal.NoSuchLayoutRevisionException, 543 com.liferay.portal.kernel.exception.SystemException { 544 return getPersistence() 545 .findByL_H_Last(layoutSetBranchId, head, orderByComparator); 546 } 547 548 /** 549 * Returns the layout revisions before and after the current layout revision in the ordered set where layoutSetBranchId = ? and head = ?. 550 * 551 * <p> 552 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 553 * </p> 554 * 555 * @param layoutRevisionId the primary key of the current layout revision 556 * @param layoutSetBranchId the layout set branch ID 557 * @param head the head 558 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 559 * @return the previous, current, and next layout revision 560 * @throws com.liferay.portal.NoSuchLayoutRevisionException if a layout revision with the primary key could not be found 561 * @throws SystemException if a system exception occurred 562 */ 563 public static com.liferay.portal.model.LayoutRevision[] findByL_H_PrevAndNext( 564 long layoutRevisionId, long layoutSetBranchId, boolean head, 565 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 566 throws com.liferay.portal.NoSuchLayoutRevisionException, 567 com.liferay.portal.kernel.exception.SystemException { 568 return getPersistence() 569 .findByL_H_PrevAndNext(layoutRevisionId, layoutSetBranchId, 570 head, orderByComparator); 571 } 572 573 /** 574 * Returns all the layout revisions where layoutSetBranchId = ? and plid = ?. 575 * 576 * @param layoutSetBranchId the layout set branch ID 577 * @param plid the plid 578 * @return the matching layout revisions 579 * @throws SystemException if a system exception occurred 580 */ 581 public static java.util.List<com.liferay.portal.model.LayoutRevision> findByL_P( 582 long layoutSetBranchId, long plid) 583 throws com.liferay.portal.kernel.exception.SystemException { 584 return getPersistence().findByL_P(layoutSetBranchId, plid); 585 } 586 587 /** 588 * Returns a range of all the layout revisions where layoutSetBranchId = ? and plid = ?. 589 * 590 * <p> 591 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 592 * </p> 593 * 594 * @param layoutSetBranchId the layout set branch ID 595 * @param plid the plid 596 * @param start the lower bound of the range of layout revisions 597 * @param end the upper bound of the range of layout revisions (not inclusive) 598 * @return the range of matching layout revisions 599 * @throws SystemException if a system exception occurred 600 */ 601 public static java.util.List<com.liferay.portal.model.LayoutRevision> findByL_P( 602 long layoutSetBranchId, long plid, int start, int end) 603 throws com.liferay.portal.kernel.exception.SystemException { 604 return getPersistence().findByL_P(layoutSetBranchId, plid, start, end); 605 } 606 607 /** 608 * Returns an ordered range of all the layout revisions where layoutSetBranchId = ? and plid = ?. 609 * 610 * <p> 611 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 612 * </p> 613 * 614 * @param layoutSetBranchId the layout set branch ID 615 * @param plid the plid 616 * @param start the lower bound of the range of layout revisions 617 * @param end the upper bound of the range of layout revisions (not inclusive) 618 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 619 * @return the ordered range of matching layout revisions 620 * @throws SystemException if a system exception occurred 621 */ 622 public static java.util.List<com.liferay.portal.model.LayoutRevision> findByL_P( 623 long layoutSetBranchId, long plid, int start, int end, 624 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 625 throws com.liferay.portal.kernel.exception.SystemException { 626 return getPersistence() 627 .findByL_P(layoutSetBranchId, plid, start, end, 628 orderByComparator); 629 } 630 631 /** 632 * Returns the first layout revision in the ordered set where layoutSetBranchId = ? and plid = ?. 633 * 634 * <p> 635 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 636 * </p> 637 * 638 * @param layoutSetBranchId the layout set branch ID 639 * @param plid the plid 640 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 641 * @return the first matching layout revision 642 * @throws com.liferay.portal.NoSuchLayoutRevisionException if a matching layout revision could not be found 643 * @throws SystemException if a system exception occurred 644 */ 645 public static com.liferay.portal.model.LayoutRevision findByL_P_First( 646 long layoutSetBranchId, long plid, 647 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 648 throws com.liferay.portal.NoSuchLayoutRevisionException, 649 com.liferay.portal.kernel.exception.SystemException { 650 return getPersistence() 651 .findByL_P_First(layoutSetBranchId, plid, orderByComparator); 652 } 653 654 /** 655 * Returns the last layout revision in the ordered set where layoutSetBranchId = ? and plid = ?. 656 * 657 * <p> 658 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 659 * </p> 660 * 661 * @param layoutSetBranchId the layout set branch ID 662 * @param plid the plid 663 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 664 * @return the last matching layout revision 665 * @throws com.liferay.portal.NoSuchLayoutRevisionException if a matching layout revision could not be found 666 * @throws SystemException if a system exception occurred 667 */ 668 public static com.liferay.portal.model.LayoutRevision findByL_P_Last( 669 long layoutSetBranchId, long plid, 670 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 671 throws com.liferay.portal.NoSuchLayoutRevisionException, 672 com.liferay.portal.kernel.exception.SystemException { 673 return getPersistence() 674 .findByL_P_Last(layoutSetBranchId, plid, orderByComparator); 675 } 676 677 /** 678 * Returns the layout revisions before and after the current layout revision in the ordered set where layoutSetBranchId = ? and plid = ?. 679 * 680 * <p> 681 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 682 * </p> 683 * 684 * @param layoutRevisionId the primary key of the current layout revision 685 * @param layoutSetBranchId the layout set branch ID 686 * @param plid the plid 687 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 688 * @return the previous, current, and next layout revision 689 * @throws com.liferay.portal.NoSuchLayoutRevisionException if a layout revision with the primary key could not be found 690 * @throws SystemException if a system exception occurred 691 */ 692 public static com.liferay.portal.model.LayoutRevision[] findByL_P_PrevAndNext( 693 long layoutRevisionId, long layoutSetBranchId, long plid, 694 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 695 throws com.liferay.portal.NoSuchLayoutRevisionException, 696 com.liferay.portal.kernel.exception.SystemException { 697 return getPersistence() 698 .findByL_P_PrevAndNext(layoutRevisionId, layoutSetBranchId, 699 plid, orderByComparator); 700 } 701 702 /** 703 * Returns all the layout revisions where layoutSetBranchId = ? and status = ?. 704 * 705 * @param layoutSetBranchId the layout set branch ID 706 * @param status the status 707 * @return the matching layout revisions 708 * @throws SystemException if a system exception occurred 709 */ 710 public static java.util.List<com.liferay.portal.model.LayoutRevision> findByL_S( 711 long layoutSetBranchId, int status) 712 throws com.liferay.portal.kernel.exception.SystemException { 713 return getPersistence().findByL_S(layoutSetBranchId, status); 714 } 715 716 /** 717 * Returns a range of all the layout revisions where layoutSetBranchId = ? and status = ?. 718 * 719 * <p> 720 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 721 * </p> 722 * 723 * @param layoutSetBranchId the layout set branch ID 724 * @param status the status 725 * @param start the lower bound of the range of layout revisions 726 * @param end the upper bound of the range of layout revisions (not inclusive) 727 * @return the range of matching layout revisions 728 * @throws SystemException if a system exception occurred 729 */ 730 public static java.util.List<com.liferay.portal.model.LayoutRevision> findByL_S( 731 long layoutSetBranchId, int status, int start, int end) 732 throws com.liferay.portal.kernel.exception.SystemException { 733 return getPersistence().findByL_S(layoutSetBranchId, status, start, end); 734 } 735 736 /** 737 * Returns an ordered range of all the layout revisions where layoutSetBranchId = ? and status = ?. 738 * 739 * <p> 740 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 741 * </p> 742 * 743 * @param layoutSetBranchId the layout set branch ID 744 * @param status the status 745 * @param start the lower bound of the range of layout revisions 746 * @param end the upper bound of the range of layout revisions (not inclusive) 747 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 748 * @return the ordered range of matching layout revisions 749 * @throws SystemException if a system exception occurred 750 */ 751 public static java.util.List<com.liferay.portal.model.LayoutRevision> findByL_S( 752 long layoutSetBranchId, int status, int start, int end, 753 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 754 throws com.liferay.portal.kernel.exception.SystemException { 755 return getPersistence() 756 .findByL_S(layoutSetBranchId, status, start, end, 757 orderByComparator); 758 } 759 760 /** 761 * Returns the first layout revision in the ordered set where layoutSetBranchId = ? and status = ?. 762 * 763 * <p> 764 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 765 * </p> 766 * 767 * @param layoutSetBranchId the layout set branch ID 768 * @param status the status 769 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 770 * @return the first matching layout revision 771 * @throws com.liferay.portal.NoSuchLayoutRevisionException if a matching layout revision could not be found 772 * @throws SystemException if a system exception occurred 773 */ 774 public static com.liferay.portal.model.LayoutRevision findByL_S_First( 775 long layoutSetBranchId, int status, 776 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 777 throws com.liferay.portal.NoSuchLayoutRevisionException, 778 com.liferay.portal.kernel.exception.SystemException { 779 return getPersistence() 780 .findByL_S_First(layoutSetBranchId, status, orderByComparator); 781 } 782 783 /** 784 * Returns the last layout revision in the ordered set where layoutSetBranchId = ? and status = ?. 785 * 786 * <p> 787 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 788 * </p> 789 * 790 * @param layoutSetBranchId the layout set branch ID 791 * @param status the status 792 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 793 * @return the last matching layout revision 794 * @throws com.liferay.portal.NoSuchLayoutRevisionException if a matching layout revision could not be found 795 * @throws SystemException if a system exception occurred 796 */ 797 public static com.liferay.portal.model.LayoutRevision findByL_S_Last( 798 long layoutSetBranchId, int status, 799 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 800 throws com.liferay.portal.NoSuchLayoutRevisionException, 801 com.liferay.portal.kernel.exception.SystemException { 802 return getPersistence() 803 .findByL_S_Last(layoutSetBranchId, status, orderByComparator); 804 } 805 806 /** 807 * Returns the layout revisions before and after the current layout revision in the ordered set where layoutSetBranchId = ? and status = ?. 808 * 809 * <p> 810 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 811 * </p> 812 * 813 * @param layoutRevisionId the primary key of the current layout revision 814 * @param layoutSetBranchId the layout set branch ID 815 * @param status the status 816 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 817 * @return the previous, current, and next layout revision 818 * @throws com.liferay.portal.NoSuchLayoutRevisionException if a layout revision with the primary key could not be found 819 * @throws SystemException if a system exception occurred 820 */ 821 public static com.liferay.portal.model.LayoutRevision[] findByL_S_PrevAndNext( 822 long layoutRevisionId, long layoutSetBranchId, int status, 823 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 824 throws com.liferay.portal.NoSuchLayoutRevisionException, 825 com.liferay.portal.kernel.exception.SystemException { 826 return getPersistence() 827 .findByL_S_PrevAndNext(layoutRevisionId, layoutSetBranchId, 828 status, orderByComparator); 829 } 830 831 /** 832 * Returns all the layout revisions where layoutSetBranchId = ? and layoutBranchId = ? and plid = ?. 833 * 834 * @param layoutSetBranchId the layout set branch ID 835 * @param layoutBranchId the layout branch ID 836 * @param plid the plid 837 * @return the matching layout revisions 838 * @throws SystemException if a system exception occurred 839 */ 840 public static java.util.List<com.liferay.portal.model.LayoutRevision> findByL_L_P( 841 long layoutSetBranchId, long layoutBranchId, long plid) 842 throws com.liferay.portal.kernel.exception.SystemException { 843 return getPersistence() 844 .findByL_L_P(layoutSetBranchId, layoutBranchId, plid); 845 } 846 847 /** 848 * Returns a range of all the layout revisions where layoutSetBranchId = ? and layoutBranchId = ? and plid = ?. 849 * 850 * <p> 851 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 852 * </p> 853 * 854 * @param layoutSetBranchId the layout set branch ID 855 * @param layoutBranchId the layout branch ID 856 * @param plid the plid 857 * @param start the lower bound of the range of layout revisions 858 * @param end the upper bound of the range of layout revisions (not inclusive) 859 * @return the range of matching layout revisions 860 * @throws SystemException if a system exception occurred 861 */ 862 public static java.util.List<com.liferay.portal.model.LayoutRevision> findByL_L_P( 863 long layoutSetBranchId, long layoutBranchId, long plid, int start, 864 int end) throws com.liferay.portal.kernel.exception.SystemException { 865 return getPersistence() 866 .findByL_L_P(layoutSetBranchId, layoutBranchId, plid, start, 867 end); 868 } 869 870 /** 871 * Returns an ordered range of all the layout revisions where layoutSetBranchId = ? and layoutBranchId = ? and plid = ?. 872 * 873 * <p> 874 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 875 * </p> 876 * 877 * @param layoutSetBranchId the layout set branch ID 878 * @param layoutBranchId the layout branch ID 879 * @param plid the plid 880 * @param start the lower bound of the range of layout revisions 881 * @param end the upper bound of the range of layout revisions (not inclusive) 882 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 883 * @return the ordered range of matching layout revisions 884 * @throws SystemException if a system exception occurred 885 */ 886 public static java.util.List<com.liferay.portal.model.LayoutRevision> findByL_L_P( 887 long layoutSetBranchId, long layoutBranchId, long plid, int start, 888 int end, 889 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 890 throws com.liferay.portal.kernel.exception.SystemException { 891 return getPersistence() 892 .findByL_L_P(layoutSetBranchId, layoutBranchId, plid, start, 893 end, orderByComparator); 894 } 895 896 /** 897 * Returns the first layout revision in the ordered set where layoutSetBranchId = ? and layoutBranchId = ? and plid = ?. 898 * 899 * <p> 900 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 901 * </p> 902 * 903 * @param layoutSetBranchId the layout set branch ID 904 * @param layoutBranchId the layout branch ID 905 * @param plid the plid 906 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 907 * @return the first matching layout revision 908 * @throws com.liferay.portal.NoSuchLayoutRevisionException if a matching layout revision could not be found 909 * @throws SystemException if a system exception occurred 910 */ 911 public static com.liferay.portal.model.LayoutRevision findByL_L_P_First( 912 long layoutSetBranchId, long layoutBranchId, long plid, 913 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 914 throws com.liferay.portal.NoSuchLayoutRevisionException, 915 com.liferay.portal.kernel.exception.SystemException { 916 return getPersistence() 917 .findByL_L_P_First(layoutSetBranchId, layoutBranchId, plid, 918 orderByComparator); 919 } 920 921 /** 922 * Returns the last layout revision in the ordered set where layoutSetBranchId = ? and layoutBranchId = ? and plid = ?. 923 * 924 * <p> 925 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 926 * </p> 927 * 928 * @param layoutSetBranchId the layout set branch ID 929 * @param layoutBranchId the layout branch ID 930 * @param plid the plid 931 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 932 * @return the last matching layout revision 933 * @throws com.liferay.portal.NoSuchLayoutRevisionException if a matching layout revision could not be found 934 * @throws SystemException if a system exception occurred 935 */ 936 public static com.liferay.portal.model.LayoutRevision findByL_L_P_Last( 937 long layoutSetBranchId, long layoutBranchId, long plid, 938 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 939 throws com.liferay.portal.NoSuchLayoutRevisionException, 940 com.liferay.portal.kernel.exception.SystemException { 941 return getPersistence() 942 .findByL_L_P_Last(layoutSetBranchId, layoutBranchId, plid, 943 orderByComparator); 944 } 945 946 /** 947 * Returns the layout revisions before and after the current layout revision in the ordered set where layoutSetBranchId = ? and layoutBranchId = ? and plid = ?. 948 * 949 * <p> 950 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 951 * </p> 952 * 953 * @param layoutRevisionId the primary key of the current layout revision 954 * @param layoutSetBranchId the layout set branch ID 955 * @param layoutBranchId the layout branch ID 956 * @param plid the plid 957 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 958 * @return the previous, current, and next layout revision 959 * @throws com.liferay.portal.NoSuchLayoutRevisionException if a layout revision with the primary key could not be found 960 * @throws SystemException if a system exception occurred 961 */ 962 public static com.liferay.portal.model.LayoutRevision[] findByL_L_P_PrevAndNext( 963 long layoutRevisionId, long layoutSetBranchId, long layoutBranchId, 964 long plid, 965 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 966 throws com.liferay.portal.NoSuchLayoutRevisionException, 967 com.liferay.portal.kernel.exception.SystemException { 968 return getPersistence() 969 .findByL_L_P_PrevAndNext(layoutRevisionId, 970 layoutSetBranchId, layoutBranchId, plid, orderByComparator); 971 } 972 973 /** 974 * Returns all the layout revisions where layoutSetBranchId = ? and parentLayoutRevisionId = ? and plid = ?. 975 * 976 * @param layoutSetBranchId the layout set branch ID 977 * @param parentLayoutRevisionId the parent layout revision ID 978 * @param plid the plid 979 * @return the matching layout revisions 980 * @throws SystemException if a system exception occurred 981 */ 982 public static java.util.List<com.liferay.portal.model.LayoutRevision> findByL_P_P( 983 long layoutSetBranchId, long parentLayoutRevisionId, long plid) 984 throws com.liferay.portal.kernel.exception.SystemException { 985 return getPersistence() 986 .findByL_P_P(layoutSetBranchId, parentLayoutRevisionId, plid); 987 } 988 989 /** 990 * Returns a range of all the layout revisions where layoutSetBranchId = ? and parentLayoutRevisionId = ? and plid = ?. 991 * 992 * <p> 993 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 994 * </p> 995 * 996 * @param layoutSetBranchId the layout set branch ID 997 * @param parentLayoutRevisionId the parent layout revision ID 998 * @param plid the plid 999 * @param start the lower bound of the range of layout revisions 1000 * @param end the upper bound of the range of layout revisions (not inclusive) 1001 * @return the range of matching layout revisions 1002 * @throws SystemException if a system exception occurred 1003 */ 1004 public static java.util.List<com.liferay.portal.model.LayoutRevision> findByL_P_P( 1005 long layoutSetBranchId, long parentLayoutRevisionId, long plid, 1006 int start, int end) 1007 throws com.liferay.portal.kernel.exception.SystemException { 1008 return getPersistence() 1009 .findByL_P_P(layoutSetBranchId, parentLayoutRevisionId, 1010 plid, start, end); 1011 } 1012 1013 /** 1014 * Returns an ordered range of all the layout revisions where layoutSetBranchId = ? and parentLayoutRevisionId = ? and plid = ?. 1015 * 1016 * <p> 1017 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1018 * </p> 1019 * 1020 * @param layoutSetBranchId the layout set branch ID 1021 * @param parentLayoutRevisionId the parent layout revision ID 1022 * @param plid the plid 1023 * @param start the lower bound of the range of layout revisions 1024 * @param end the upper bound of the range of layout revisions (not inclusive) 1025 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1026 * @return the ordered range of matching layout revisions 1027 * @throws SystemException if a system exception occurred 1028 */ 1029 public static java.util.List<com.liferay.portal.model.LayoutRevision> findByL_P_P( 1030 long layoutSetBranchId, long parentLayoutRevisionId, long plid, 1031 int start, int end, 1032 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1033 throws com.liferay.portal.kernel.exception.SystemException { 1034 return getPersistence() 1035 .findByL_P_P(layoutSetBranchId, parentLayoutRevisionId, 1036 plid, start, end, orderByComparator); 1037 } 1038 1039 /** 1040 * Returns the first layout revision in the ordered set where layoutSetBranchId = ? and parentLayoutRevisionId = ? and plid = ?. 1041 * 1042 * <p> 1043 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1044 * </p> 1045 * 1046 * @param layoutSetBranchId the layout set branch ID 1047 * @param parentLayoutRevisionId the parent layout revision ID 1048 * @param plid the plid 1049 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1050 * @return the first matching layout revision 1051 * @throws com.liferay.portal.NoSuchLayoutRevisionException if a matching layout revision could not be found 1052 * @throws SystemException if a system exception occurred 1053 */ 1054 public static com.liferay.portal.model.LayoutRevision findByL_P_P_First( 1055 long layoutSetBranchId, long parentLayoutRevisionId, long plid, 1056 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1057 throws com.liferay.portal.NoSuchLayoutRevisionException, 1058 com.liferay.portal.kernel.exception.SystemException { 1059 return getPersistence() 1060 .findByL_P_P_First(layoutSetBranchId, 1061 parentLayoutRevisionId, plid, orderByComparator); 1062 } 1063 1064 /** 1065 * Returns the last layout revision in the ordered set where layoutSetBranchId = ? and parentLayoutRevisionId = ? and plid = ?. 1066 * 1067 * <p> 1068 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1069 * </p> 1070 * 1071 * @param layoutSetBranchId the layout set branch ID 1072 * @param parentLayoutRevisionId the parent layout revision ID 1073 * @param plid the plid 1074 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1075 * @return the last matching layout revision 1076 * @throws com.liferay.portal.NoSuchLayoutRevisionException if a matching layout revision could not be found 1077 * @throws SystemException if a system exception occurred 1078 */ 1079 public static com.liferay.portal.model.LayoutRevision findByL_P_P_Last( 1080 long layoutSetBranchId, long parentLayoutRevisionId, long plid, 1081 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1082 throws com.liferay.portal.NoSuchLayoutRevisionException, 1083 com.liferay.portal.kernel.exception.SystemException { 1084 return getPersistence() 1085 .findByL_P_P_Last(layoutSetBranchId, parentLayoutRevisionId, 1086 plid, orderByComparator); 1087 } 1088 1089 /** 1090 * Returns the layout revisions before and after the current layout revision in the ordered set where layoutSetBranchId = ? and parentLayoutRevisionId = ? and plid = ?. 1091 * 1092 * <p> 1093 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1094 * </p> 1095 * 1096 * @param layoutRevisionId the primary key of the current layout revision 1097 * @param layoutSetBranchId the layout set branch ID 1098 * @param parentLayoutRevisionId the parent layout revision ID 1099 * @param plid the plid 1100 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1101 * @return the previous, current, and next layout revision 1102 * @throws com.liferay.portal.NoSuchLayoutRevisionException if a layout revision with the primary key could not be found 1103 * @throws SystemException if a system exception occurred 1104 */ 1105 public static com.liferay.portal.model.LayoutRevision[] findByL_P_P_PrevAndNext( 1106 long layoutRevisionId, long layoutSetBranchId, 1107 long parentLayoutRevisionId, long plid, 1108 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1109 throws com.liferay.portal.NoSuchLayoutRevisionException, 1110 com.liferay.portal.kernel.exception.SystemException { 1111 return getPersistence() 1112 .findByL_P_P_PrevAndNext(layoutRevisionId, 1113 layoutSetBranchId, parentLayoutRevisionId, plid, orderByComparator); 1114 } 1115 1116 /** 1117 * Returns the layout revision where layoutSetBranchId = ? and head = ? and plid = ? or throws a {@link com.liferay.portal.NoSuchLayoutRevisionException} if it could not be found. 1118 * 1119 * @param layoutSetBranchId the layout set branch ID 1120 * @param head the head 1121 * @param plid the plid 1122 * @return the matching layout revision 1123 * @throws com.liferay.portal.NoSuchLayoutRevisionException if a matching layout revision could not be found 1124 * @throws SystemException if a system exception occurred 1125 */ 1126 public static com.liferay.portal.model.LayoutRevision findByL_H_P( 1127 long layoutSetBranchId, boolean head, long plid) 1128 throws com.liferay.portal.NoSuchLayoutRevisionException, 1129 com.liferay.portal.kernel.exception.SystemException { 1130 return getPersistence().findByL_H_P(layoutSetBranchId, head, plid); 1131 } 1132 1133 /** 1134 * Returns the layout revision where layoutSetBranchId = ? and head = ? and plid = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 1135 * 1136 * @param layoutSetBranchId the layout set branch ID 1137 * @param head the head 1138 * @param plid the plid 1139 * @return the matching layout revision, or <code>null</code> if a matching layout revision could not be found 1140 * @throws SystemException if a system exception occurred 1141 */ 1142 public static com.liferay.portal.model.LayoutRevision fetchByL_H_P( 1143 long layoutSetBranchId, boolean head, long plid) 1144 throws com.liferay.portal.kernel.exception.SystemException { 1145 return getPersistence().fetchByL_H_P(layoutSetBranchId, head, plid); 1146 } 1147 1148 /** 1149 * Returns the layout revision where layoutSetBranchId = ? and head = ? and plid = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 1150 * 1151 * @param layoutSetBranchId the layout set branch ID 1152 * @param head the head 1153 * @param plid the plid 1154 * @param retrieveFromCache whether to use the finder cache 1155 * @return the matching layout revision, or <code>null</code> if a matching layout revision could not be found 1156 * @throws SystemException if a system exception occurred 1157 */ 1158 public static com.liferay.portal.model.LayoutRevision fetchByL_H_P( 1159 long layoutSetBranchId, boolean head, long plid, 1160 boolean retrieveFromCache) 1161 throws com.liferay.portal.kernel.exception.SystemException { 1162 return getPersistence() 1163 .fetchByL_H_P(layoutSetBranchId, head, plid, 1164 retrieveFromCache); 1165 } 1166 1167 /** 1168 * Returns all the layout revisions where layoutSetBranchId = ? and plid = ? and status = ?. 1169 * 1170 * @param layoutSetBranchId the layout set branch ID 1171 * @param plid the plid 1172 * @param status the status 1173 * @return the matching layout revisions 1174 * @throws SystemException if a system exception occurred 1175 */ 1176 public static java.util.List<com.liferay.portal.model.LayoutRevision> findByL_P_S( 1177 long layoutSetBranchId, long plid, int status) 1178 throws com.liferay.portal.kernel.exception.SystemException { 1179 return getPersistence().findByL_P_S(layoutSetBranchId, plid, status); 1180 } 1181 1182 /** 1183 * Returns a range of all the layout revisions where layoutSetBranchId = ? and plid = ? and status = ?. 1184 * 1185 * <p> 1186 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1187 * </p> 1188 * 1189 * @param layoutSetBranchId the layout set branch ID 1190 * @param plid the plid 1191 * @param status the status 1192 * @param start the lower bound of the range of layout revisions 1193 * @param end the upper bound of the range of layout revisions (not inclusive) 1194 * @return the range of matching layout revisions 1195 * @throws SystemException if a system exception occurred 1196 */ 1197 public static java.util.List<com.liferay.portal.model.LayoutRevision> findByL_P_S( 1198 long layoutSetBranchId, long plid, int status, int start, int end) 1199 throws com.liferay.portal.kernel.exception.SystemException { 1200 return getPersistence() 1201 .findByL_P_S(layoutSetBranchId, plid, status, start, end); 1202 } 1203 1204 /** 1205 * Returns an ordered range of all the layout revisions where layoutSetBranchId = ? and plid = ? and status = ?. 1206 * 1207 * <p> 1208 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1209 * </p> 1210 * 1211 * @param layoutSetBranchId the layout set branch ID 1212 * @param plid the plid 1213 * @param status the status 1214 * @param start the lower bound of the range of layout revisions 1215 * @param end the upper bound of the range of layout revisions (not inclusive) 1216 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1217 * @return the ordered range of matching layout revisions 1218 * @throws SystemException if a system exception occurred 1219 */ 1220 public static java.util.List<com.liferay.portal.model.LayoutRevision> findByL_P_S( 1221 long layoutSetBranchId, long plid, int status, int start, int end, 1222 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1223 throws com.liferay.portal.kernel.exception.SystemException { 1224 return getPersistence() 1225 .findByL_P_S(layoutSetBranchId, plid, status, start, end, 1226 orderByComparator); 1227 } 1228 1229 /** 1230 * Returns the first layout revision in the ordered set where layoutSetBranchId = ? and plid = ? and status = ?. 1231 * 1232 * <p> 1233 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1234 * </p> 1235 * 1236 * @param layoutSetBranchId the layout set branch ID 1237 * @param plid the plid 1238 * @param status the status 1239 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1240 * @return the first matching layout revision 1241 * @throws com.liferay.portal.NoSuchLayoutRevisionException if a matching layout revision could not be found 1242 * @throws SystemException if a system exception occurred 1243 */ 1244 public static com.liferay.portal.model.LayoutRevision findByL_P_S_First( 1245 long layoutSetBranchId, long plid, int status, 1246 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1247 throws com.liferay.portal.NoSuchLayoutRevisionException, 1248 com.liferay.portal.kernel.exception.SystemException { 1249 return getPersistence() 1250 .findByL_P_S_First(layoutSetBranchId, plid, status, 1251 orderByComparator); 1252 } 1253 1254 /** 1255 * Returns the last layout revision in the ordered set where layoutSetBranchId = ? and plid = ? and status = ?. 1256 * 1257 * <p> 1258 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1259 * </p> 1260 * 1261 * @param layoutSetBranchId the layout set branch ID 1262 * @param plid the plid 1263 * @param status the status 1264 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1265 * @return the last matching layout revision 1266 * @throws com.liferay.portal.NoSuchLayoutRevisionException if a matching layout revision could not be found 1267 * @throws SystemException if a system exception occurred 1268 */ 1269 public static com.liferay.portal.model.LayoutRevision findByL_P_S_Last( 1270 long layoutSetBranchId, long plid, int status, 1271 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1272 throws com.liferay.portal.NoSuchLayoutRevisionException, 1273 com.liferay.portal.kernel.exception.SystemException { 1274 return getPersistence() 1275 .findByL_P_S_Last(layoutSetBranchId, plid, status, 1276 orderByComparator); 1277 } 1278 1279 /** 1280 * Returns the layout revisions before and after the current layout revision in the ordered set where layoutSetBranchId = ? and plid = ? and status = ?. 1281 * 1282 * <p> 1283 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1284 * </p> 1285 * 1286 * @param layoutRevisionId the primary key of the current layout revision 1287 * @param layoutSetBranchId the layout set branch ID 1288 * @param plid the plid 1289 * @param status the status 1290 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1291 * @return the previous, current, and next layout revision 1292 * @throws com.liferay.portal.NoSuchLayoutRevisionException if a layout revision with the primary key could not be found 1293 * @throws SystemException if a system exception occurred 1294 */ 1295 public static com.liferay.portal.model.LayoutRevision[] findByL_P_S_PrevAndNext( 1296 long layoutRevisionId, long layoutSetBranchId, long plid, int status, 1297 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1298 throws com.liferay.portal.NoSuchLayoutRevisionException, 1299 com.liferay.portal.kernel.exception.SystemException { 1300 return getPersistence() 1301 .findByL_P_S_PrevAndNext(layoutRevisionId, 1302 layoutSetBranchId, plid, status, orderByComparator); 1303 } 1304 1305 /** 1306 * Returns all the layout revisions. 1307 * 1308 * @return the layout revisions 1309 * @throws SystemException if a system exception occurred 1310 */ 1311 public static java.util.List<com.liferay.portal.model.LayoutRevision> findAll() 1312 throws com.liferay.portal.kernel.exception.SystemException { 1313 return getPersistence().findAll(); 1314 } 1315 1316 /** 1317 * Returns a range of all the layout revisions. 1318 * 1319 * <p> 1320 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1321 * </p> 1322 * 1323 * @param start the lower bound of the range of layout revisions 1324 * @param end the upper bound of the range of layout revisions (not inclusive) 1325 * @return the range of layout revisions 1326 * @throws SystemException if a system exception occurred 1327 */ 1328 public static java.util.List<com.liferay.portal.model.LayoutRevision> findAll( 1329 int start, int end) 1330 throws com.liferay.portal.kernel.exception.SystemException { 1331 return getPersistence().findAll(start, end); 1332 } 1333 1334 /** 1335 * Returns an ordered range of all the layout revisions. 1336 * 1337 * <p> 1338 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1339 * </p> 1340 * 1341 * @param start the lower bound of the range of layout revisions 1342 * @param end the upper bound of the range of layout revisions (not inclusive) 1343 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1344 * @return the ordered range of layout revisions 1345 * @throws SystemException if a system exception occurred 1346 */ 1347 public static java.util.List<com.liferay.portal.model.LayoutRevision> findAll( 1348 int start, int end, 1349 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1350 throws com.liferay.portal.kernel.exception.SystemException { 1351 return getPersistence().findAll(start, end, orderByComparator); 1352 } 1353 1354 /** 1355 * Removes all the layout revisions where layoutSetBranchId = ? from the database. 1356 * 1357 * @param layoutSetBranchId the layout set branch ID 1358 * @throws SystemException if a system exception occurred 1359 */ 1360 public static void removeByLayoutSetBranchId(long layoutSetBranchId) 1361 throws com.liferay.portal.kernel.exception.SystemException { 1362 getPersistence().removeByLayoutSetBranchId(layoutSetBranchId); 1363 } 1364 1365 /** 1366 * Removes all the layout revisions where plid = ? from the database. 1367 * 1368 * @param plid the plid 1369 * @throws SystemException if a system exception occurred 1370 */ 1371 public static void removeByPlid(long plid) 1372 throws com.liferay.portal.kernel.exception.SystemException { 1373 getPersistence().removeByPlid(plid); 1374 } 1375 1376 /** 1377 * Removes all the layout revisions where layoutSetBranchId = ? and head = ? from the database. 1378 * 1379 * @param layoutSetBranchId the layout set branch ID 1380 * @param head the head 1381 * @throws SystemException if a system exception occurred 1382 */ 1383 public static void removeByL_H(long layoutSetBranchId, boolean head) 1384 throws com.liferay.portal.kernel.exception.SystemException { 1385 getPersistence().removeByL_H(layoutSetBranchId, head); 1386 } 1387 1388 /** 1389 * Removes all the layout revisions where layoutSetBranchId = ? and plid = ? from the database. 1390 * 1391 * @param layoutSetBranchId the layout set branch ID 1392 * @param plid the plid 1393 * @throws SystemException if a system exception occurred 1394 */ 1395 public static void removeByL_P(long layoutSetBranchId, long plid) 1396 throws com.liferay.portal.kernel.exception.SystemException { 1397 getPersistence().removeByL_P(layoutSetBranchId, plid); 1398 } 1399 1400 /** 1401 * Removes all the layout revisions where layoutSetBranchId = ? and status = ? from the database. 1402 * 1403 * @param layoutSetBranchId the layout set branch ID 1404 * @param status the status 1405 * @throws SystemException if a system exception occurred 1406 */ 1407 public static void removeByL_S(long layoutSetBranchId, int status) 1408 throws com.liferay.portal.kernel.exception.SystemException { 1409 getPersistence().removeByL_S(layoutSetBranchId, status); 1410 } 1411 1412 /** 1413 * Removes all the layout revisions where layoutSetBranchId = ? and layoutBranchId = ? and plid = ? from the database. 1414 * 1415 * @param layoutSetBranchId the layout set branch ID 1416 * @param layoutBranchId the layout branch ID 1417 * @param plid the plid 1418 * @throws SystemException if a system exception occurred 1419 */ 1420 public static void removeByL_L_P(long layoutSetBranchId, 1421 long layoutBranchId, long plid) 1422 throws com.liferay.portal.kernel.exception.SystemException { 1423 getPersistence().removeByL_L_P(layoutSetBranchId, layoutBranchId, plid); 1424 } 1425 1426 /** 1427 * Removes all the layout revisions where layoutSetBranchId = ? and parentLayoutRevisionId = ? and plid = ? from the database. 1428 * 1429 * @param layoutSetBranchId the layout set branch ID 1430 * @param parentLayoutRevisionId the parent layout revision ID 1431 * @param plid the plid 1432 * @throws SystemException if a system exception occurred 1433 */ 1434 public static void removeByL_P_P(long layoutSetBranchId, 1435 long parentLayoutRevisionId, long plid) 1436 throws com.liferay.portal.kernel.exception.SystemException { 1437 getPersistence() 1438 .removeByL_P_P(layoutSetBranchId, parentLayoutRevisionId, plid); 1439 } 1440 1441 /** 1442 * Removes the layout revision where layoutSetBranchId = ? and head = ? and plid = ? from the database. 1443 * 1444 * @param layoutSetBranchId the layout set branch ID 1445 * @param head the head 1446 * @param plid the plid 1447 * @throws SystemException if a system exception occurred 1448 */ 1449 public static void removeByL_H_P(long layoutSetBranchId, boolean head, 1450 long plid) 1451 throws com.liferay.portal.NoSuchLayoutRevisionException, 1452 com.liferay.portal.kernel.exception.SystemException { 1453 getPersistence().removeByL_H_P(layoutSetBranchId, head, plid); 1454 } 1455 1456 /** 1457 * Removes all the layout revisions where layoutSetBranchId = ? and plid = ? and status = ? from the database. 1458 * 1459 * @param layoutSetBranchId the layout set branch ID 1460 * @param plid the plid 1461 * @param status the status 1462 * @throws SystemException if a system exception occurred 1463 */ 1464 public static void removeByL_P_S(long layoutSetBranchId, long plid, 1465 int status) throws com.liferay.portal.kernel.exception.SystemException { 1466 getPersistence().removeByL_P_S(layoutSetBranchId, plid, status); 1467 } 1468 1469 /** 1470 * Removes all the layout revisions from the database. 1471 * 1472 * @throws SystemException if a system exception occurred 1473 */ 1474 public static void removeAll() 1475 throws com.liferay.portal.kernel.exception.SystemException { 1476 getPersistence().removeAll(); 1477 } 1478 1479 /** 1480 * Returns the number of layout revisions where layoutSetBranchId = ?. 1481 * 1482 * @param layoutSetBranchId the layout set branch ID 1483 * @return the number of matching layout revisions 1484 * @throws SystemException if a system exception occurred 1485 */ 1486 public static int countByLayoutSetBranchId(long layoutSetBranchId) 1487 throws com.liferay.portal.kernel.exception.SystemException { 1488 return getPersistence().countByLayoutSetBranchId(layoutSetBranchId); 1489 } 1490 1491 /** 1492 * Returns the number of layout revisions where plid = ?. 1493 * 1494 * @param plid the plid 1495 * @return the number of matching layout revisions 1496 * @throws SystemException if a system exception occurred 1497 */ 1498 public static int countByPlid(long plid) 1499 throws com.liferay.portal.kernel.exception.SystemException { 1500 return getPersistence().countByPlid(plid); 1501 } 1502 1503 /** 1504 * Returns the number of layout revisions where layoutSetBranchId = ? and head = ?. 1505 * 1506 * @param layoutSetBranchId the layout set branch ID 1507 * @param head the head 1508 * @return the number of matching layout revisions 1509 * @throws SystemException if a system exception occurred 1510 */ 1511 public static int countByL_H(long layoutSetBranchId, boolean head) 1512 throws com.liferay.portal.kernel.exception.SystemException { 1513 return getPersistence().countByL_H(layoutSetBranchId, head); 1514 } 1515 1516 /** 1517 * Returns the number of layout revisions where layoutSetBranchId = ? and plid = ?. 1518 * 1519 * @param layoutSetBranchId the layout set branch ID 1520 * @param plid the plid 1521 * @return the number of matching layout revisions 1522 * @throws SystemException if a system exception occurred 1523 */ 1524 public static int countByL_P(long layoutSetBranchId, long plid) 1525 throws com.liferay.portal.kernel.exception.SystemException { 1526 return getPersistence().countByL_P(layoutSetBranchId, plid); 1527 } 1528 1529 /** 1530 * Returns the number of layout revisions where layoutSetBranchId = ? and status = ?. 1531 * 1532 * @param layoutSetBranchId the layout set branch ID 1533 * @param status the status 1534 * @return the number of matching layout revisions 1535 * @throws SystemException if a system exception occurred 1536 */ 1537 public static int countByL_S(long layoutSetBranchId, int status) 1538 throws com.liferay.portal.kernel.exception.SystemException { 1539 return getPersistence().countByL_S(layoutSetBranchId, status); 1540 } 1541 1542 /** 1543 * Returns the number of layout revisions where layoutSetBranchId = ? and layoutBranchId = ? and plid = ?. 1544 * 1545 * @param layoutSetBranchId the layout set branch ID 1546 * @param layoutBranchId the layout branch ID 1547 * @param plid the plid 1548 * @return the number of matching layout revisions 1549 * @throws SystemException if a system exception occurred 1550 */ 1551 public static int countByL_L_P(long layoutSetBranchId, long layoutBranchId, 1552 long plid) throws com.liferay.portal.kernel.exception.SystemException { 1553 return getPersistence() 1554 .countByL_L_P(layoutSetBranchId, layoutBranchId, plid); 1555 } 1556 1557 /** 1558 * Returns the number of layout revisions where layoutSetBranchId = ? and parentLayoutRevisionId = ? and plid = ?. 1559 * 1560 * @param layoutSetBranchId the layout set branch ID 1561 * @param parentLayoutRevisionId the parent layout revision ID 1562 * @param plid the plid 1563 * @return the number of matching layout revisions 1564 * @throws SystemException if a system exception occurred 1565 */ 1566 public static int countByL_P_P(long layoutSetBranchId, 1567 long parentLayoutRevisionId, long plid) 1568 throws com.liferay.portal.kernel.exception.SystemException { 1569 return getPersistence() 1570 .countByL_P_P(layoutSetBranchId, parentLayoutRevisionId, plid); 1571 } 1572 1573 /** 1574 * Returns the number of layout revisions where layoutSetBranchId = ? and head = ? and plid = ?. 1575 * 1576 * @param layoutSetBranchId the layout set branch ID 1577 * @param head the head 1578 * @param plid the plid 1579 * @return the number of matching layout revisions 1580 * @throws SystemException if a system exception occurred 1581 */ 1582 public static int countByL_H_P(long layoutSetBranchId, boolean head, 1583 long plid) throws com.liferay.portal.kernel.exception.SystemException { 1584 return getPersistence().countByL_H_P(layoutSetBranchId, head, plid); 1585 } 1586 1587 /** 1588 * Returns the number of layout revisions where layoutSetBranchId = ? and plid = ? and status = ?. 1589 * 1590 * @param layoutSetBranchId the layout set branch ID 1591 * @param plid the plid 1592 * @param status the status 1593 * @return the number of matching layout revisions 1594 * @throws SystemException if a system exception occurred 1595 */ 1596 public static int countByL_P_S(long layoutSetBranchId, long plid, int status) 1597 throws com.liferay.portal.kernel.exception.SystemException { 1598 return getPersistence().countByL_P_S(layoutSetBranchId, plid, status); 1599 } 1600 1601 /** 1602 * Returns the number of layout revisions. 1603 * 1604 * @return the number of layout revisions 1605 * @throws SystemException if a system exception occurred 1606 */ 1607 public static int countAll() 1608 throws com.liferay.portal.kernel.exception.SystemException { 1609 return getPersistence().countAll(); 1610 } 1611 1612 public static LayoutRevisionPersistence getPersistence() { 1613 if (_persistence == null) { 1614 _persistence = (LayoutRevisionPersistence)PortalBeanLocatorUtil.locate(LayoutRevisionPersistence.class.getName()); 1615 1616 ReferenceRegistry.registerReference(LayoutRevisionUtil.class, 1617 "_persistence"); 1618 } 1619 1620 return _persistence; 1621 } 1622 1623 public void setPersistence(LayoutRevisionPersistence persistence) { 1624 _persistence = persistence; 1625 1626 ReferenceRegistry.registerReference(LayoutRevisionUtil.class, 1627 "_persistence"); 1628 } 1629 1630 private static LayoutRevisionPersistence _persistence; 1631 }