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