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