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