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