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