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