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