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