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