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