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