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