001 /** 002 * Copyright (c) 2000-2013 Liferay, Inc. All rights reserved. 003 * 004 * The contents of this file are subject to the terms of the Liferay Enterprise 005 * Subscription License ("License"). You may not use this file except in 006 * compliance with the License. You can obtain a copy of the License by 007 * contacting Liferay, Inc. See the License for the specific language governing 008 * permissions and limitations under the License, including but not limited to 009 * distribution rights of the Software. 010 * 011 * 012 * 013 */ 014 015 package com.liferay.portal.service.persistence; 016 017 import 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.exception.SystemException; 022 import com.liferay.portal.kernel.util.OrderByComparator; 023 import com.liferay.portal.kernel.util.ReferenceRegistry; 024 import com.liferay.portal.model.Layout; 025 import com.liferay.portal.service.ServiceContext; 026 027 import java.util.List; 028 029 /** 030 * 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. 031 * 032 * <p> 033 * Caching information and settings can be found in <code>portal.properties</code> 034 * </p> 035 * 036 * @author Brian Wing Shun Chan 037 * @see LayoutPersistence 038 * @see LayoutPersistenceImpl 039 * @generated 040 */ 041 @ProviderType 042 public class LayoutUtil { 043 /* 044 * NOTE FOR DEVELOPERS: 045 * 046 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. 047 */ 048 049 /** 050 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 051 */ 052 public static void clearCache() { 053 getPersistence().clearCache(); 054 } 055 056 /** 057 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 058 */ 059 public static void clearCache(Layout layout) { 060 getPersistence().clearCache(layout); 061 } 062 063 /** 064 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 065 */ 066 public static long countWithDynamicQuery(DynamicQuery dynamicQuery) 067 throws SystemException { 068 return getPersistence().countWithDynamicQuery(dynamicQuery); 069 } 070 071 /** 072 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 073 */ 074 public static List<Layout> findWithDynamicQuery(DynamicQuery dynamicQuery) 075 throws SystemException { 076 return getPersistence().findWithDynamicQuery(dynamicQuery); 077 } 078 079 /** 080 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 081 */ 082 public static List<Layout> findWithDynamicQuery(DynamicQuery dynamicQuery, 083 int start, int end) throws SystemException { 084 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 085 } 086 087 /** 088 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 089 */ 090 public static List<Layout> findWithDynamicQuery(DynamicQuery dynamicQuery, 091 int start, int end, OrderByComparator orderByComparator) 092 throws SystemException { 093 return getPersistence() 094 .findWithDynamicQuery(dynamicQuery, start, end, 095 orderByComparator); 096 } 097 098 /** 099 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel) 100 */ 101 public static Layout update(Layout layout) throws SystemException { 102 return getPersistence().update(layout); 103 } 104 105 /** 106 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 107 */ 108 public static Layout update(Layout layout, ServiceContext serviceContext) 109 throws SystemException { 110 return getPersistence().update(layout, serviceContext); 111 } 112 113 /** 114 * Returns all the layouts where uuid = ?. 115 * 116 * @param uuid the uuid 117 * @return the matching layouts 118 * @throws SystemException if a system exception occurred 119 */ 120 public static java.util.List<com.liferay.portal.model.Layout> findByUuid( 121 java.lang.String uuid) 122 throws com.liferay.portal.kernel.exception.SystemException { 123 return getPersistence().findByUuid(uuid); 124 } 125 126 /** 127 * Returns a range of all the layouts where uuid = ?. 128 * 129 * <p> 130 * 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. 131 * </p> 132 * 133 * @param uuid the uuid 134 * @param start the lower bound of the range of layouts 135 * @param end the upper bound of the range of layouts (not inclusive) 136 * @return the range of matching layouts 137 * @throws SystemException if a system exception occurred 138 */ 139 public static java.util.List<com.liferay.portal.model.Layout> findByUuid( 140 java.lang.String uuid, int start, int end) 141 throws com.liferay.portal.kernel.exception.SystemException { 142 return getPersistence().findByUuid(uuid, start, end); 143 } 144 145 /** 146 * Returns an ordered range of all the layouts where uuid = ?. 147 * 148 * <p> 149 * 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. 150 * </p> 151 * 152 * @param uuid the uuid 153 * @param start the lower bound of the range of layouts 154 * @param end the upper bound of the range of layouts (not inclusive) 155 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 156 * @return the ordered range of matching layouts 157 * @throws SystemException if a system exception occurred 158 */ 159 public static java.util.List<com.liferay.portal.model.Layout> findByUuid( 160 java.lang.String uuid, int start, int end, 161 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 162 throws com.liferay.portal.kernel.exception.SystemException { 163 return getPersistence().findByUuid(uuid, start, end, orderByComparator); 164 } 165 166 /** 167 * Returns the first layout in the ordered set where uuid = ?. 168 * 169 * @param uuid the uuid 170 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 171 * @return the first matching layout 172 * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found 173 * @throws SystemException if a system exception occurred 174 */ 175 public static com.liferay.portal.model.Layout findByUuid_First( 176 java.lang.String uuid, 177 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 178 throws com.liferay.portal.NoSuchLayoutException, 179 com.liferay.portal.kernel.exception.SystemException { 180 return getPersistence().findByUuid_First(uuid, orderByComparator); 181 } 182 183 /** 184 * Returns the first 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 first matching layout, or <code>null</code> if a matching layout could not be found 189 * @throws SystemException if a system exception occurred 190 */ 191 public static com.liferay.portal.model.Layout fetchByUuid_First( 192 java.lang.String uuid, 193 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 194 throws com.liferay.portal.kernel.exception.SystemException { 195 return getPersistence().fetchByUuid_First(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 204 * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found 205 * @throws SystemException if a system exception occurred 206 */ 207 public static com.liferay.portal.model.Layout findByUuid_Last( 208 java.lang.String uuid, 209 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 210 throws com.liferay.portal.NoSuchLayoutException, 211 com.liferay.portal.kernel.exception.SystemException { 212 return getPersistence().findByUuid_Last(uuid, orderByComparator); 213 } 214 215 /** 216 * Returns the last layout in the ordered set where uuid = ?. 217 * 218 * @param uuid the uuid 219 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 220 * @return the last matching layout, or <code>null</code> if a matching layout could not be found 221 * @throws SystemException if a system exception occurred 222 */ 223 public static com.liferay.portal.model.Layout fetchByUuid_Last( 224 java.lang.String uuid, 225 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 226 throws com.liferay.portal.kernel.exception.SystemException { 227 return getPersistence().fetchByUuid_Last(uuid, orderByComparator); 228 } 229 230 /** 231 * Returns the layouts before and after the current layout in the ordered set where uuid = ?. 232 * 233 * @param plid the primary key of the current layout 234 * @param uuid the uuid 235 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 236 * @return the previous, current, and next layout 237 * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found 238 * @throws SystemException if a system exception occurred 239 */ 240 public static com.liferay.portal.model.Layout[] findByUuid_PrevAndNext( 241 long plid, java.lang.String uuid, 242 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 243 throws com.liferay.portal.NoSuchLayoutException, 244 com.liferay.portal.kernel.exception.SystemException { 245 return getPersistence() 246 .findByUuid_PrevAndNext(plid, uuid, orderByComparator); 247 } 248 249 /** 250 * Removes all the layouts where uuid = ? from the database. 251 * 252 * @param uuid the uuid 253 * @throws SystemException if a system exception occurred 254 */ 255 public static void removeByUuid(java.lang.String uuid) 256 throws com.liferay.portal.kernel.exception.SystemException { 257 getPersistence().removeByUuid(uuid); 258 } 259 260 /** 261 * Returns the number of layouts where uuid = ?. 262 * 263 * @param uuid the uuid 264 * @return the number of matching layouts 265 * @throws SystemException if a system exception occurred 266 */ 267 public static int countByUuid(java.lang.String uuid) 268 throws com.liferay.portal.kernel.exception.SystemException { 269 return getPersistence().countByUuid(uuid); 270 } 271 272 /** 273 * Returns the layout where uuid = ? and groupId = ? and privateLayout = ? or throws a {@link com.liferay.portal.NoSuchLayoutException} if it could not be found. 274 * 275 * @param uuid the uuid 276 * @param groupId the group ID 277 * @param privateLayout the private layout 278 * @return the matching layout 279 * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found 280 * @throws SystemException if a system exception occurred 281 */ 282 public static com.liferay.portal.model.Layout findByUUID_G_P( 283 java.lang.String uuid, long groupId, boolean privateLayout) 284 throws com.liferay.portal.NoSuchLayoutException, 285 com.liferay.portal.kernel.exception.SystemException { 286 return getPersistence().findByUUID_G_P(uuid, groupId, privateLayout); 287 } 288 289 /** 290 * Returns the layout where uuid = ? and groupId = ? and privateLayout = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 291 * 292 * @param uuid the uuid 293 * @param groupId the group ID 294 * @param privateLayout the private layout 295 * @return the matching layout, or <code>null</code> if a matching layout could not be found 296 * @throws SystemException if a system exception occurred 297 */ 298 public static com.liferay.portal.model.Layout fetchByUUID_G_P( 299 java.lang.String uuid, long groupId, boolean privateLayout) 300 throws com.liferay.portal.kernel.exception.SystemException { 301 return getPersistence().fetchByUUID_G_P(uuid, groupId, privateLayout); 302 } 303 304 /** 305 * 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. 306 * 307 * @param uuid the uuid 308 * @param groupId the group ID 309 * @param privateLayout the private layout 310 * @param retrieveFromCache whether to use the finder cache 311 * @return the matching layout, or <code>null</code> if a matching layout could not be found 312 * @throws SystemException if a system exception occurred 313 */ 314 public static com.liferay.portal.model.Layout fetchByUUID_G_P( 315 java.lang.String uuid, long groupId, boolean privateLayout, 316 boolean retrieveFromCache) 317 throws com.liferay.portal.kernel.exception.SystemException { 318 return getPersistence() 319 .fetchByUUID_G_P(uuid, groupId, privateLayout, 320 retrieveFromCache); 321 } 322 323 /** 324 * Removes the layout where uuid = ? and groupId = ? and privateLayout = ? from the database. 325 * 326 * @param uuid the uuid 327 * @param groupId the group ID 328 * @param privateLayout the private layout 329 * @return the layout that was removed 330 * @throws SystemException if a system exception occurred 331 */ 332 public static com.liferay.portal.model.Layout removeByUUID_G_P( 333 java.lang.String uuid, long groupId, boolean privateLayout) 334 throws com.liferay.portal.NoSuchLayoutException, 335 com.liferay.portal.kernel.exception.SystemException { 336 return getPersistence().removeByUUID_G_P(uuid, groupId, privateLayout); 337 } 338 339 /** 340 * Returns the number of layouts where uuid = ? and groupId = ? and privateLayout = ?. 341 * 342 * @param uuid the uuid 343 * @param groupId the group ID 344 * @param privateLayout the private layout 345 * @return the number of matching layouts 346 * @throws SystemException if a system exception occurred 347 */ 348 public static int countByUUID_G_P(java.lang.String uuid, long groupId, 349 boolean privateLayout) 350 throws com.liferay.portal.kernel.exception.SystemException { 351 return getPersistence().countByUUID_G_P(uuid, groupId, privateLayout); 352 } 353 354 /** 355 * Returns all the layouts where uuid = ? and companyId = ?. 356 * 357 * @param uuid the uuid 358 * @param companyId the company ID 359 * @return the matching layouts 360 * @throws SystemException if a system exception occurred 361 */ 362 public static java.util.List<com.liferay.portal.model.Layout> findByUuid_C( 363 java.lang.String uuid, long companyId) 364 throws com.liferay.portal.kernel.exception.SystemException { 365 return getPersistence().findByUuid_C(uuid, companyId); 366 } 367 368 /** 369 * Returns a range of all the layouts where uuid = ? and companyId = ?. 370 * 371 * <p> 372 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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. 373 * </p> 374 * 375 * @param uuid the uuid 376 * @param companyId the company ID 377 * @param start the lower bound of the range of layouts 378 * @param end the upper bound of the range of layouts (not inclusive) 379 * @return the range of matching layouts 380 * @throws SystemException if a system exception occurred 381 */ 382 public static java.util.List<com.liferay.portal.model.Layout> findByUuid_C( 383 java.lang.String uuid, long companyId, int start, int end) 384 throws com.liferay.portal.kernel.exception.SystemException { 385 return getPersistence().findByUuid_C(uuid, companyId, start, end); 386 } 387 388 /** 389 * Returns an ordered range of all the layouts where uuid = ? and companyId = ?. 390 * 391 * <p> 392 * 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. 393 * </p> 394 * 395 * @param uuid the uuid 396 * @param companyId the company ID 397 * @param start the lower bound of the range of layouts 398 * @param end the upper bound of the range of layouts (not inclusive) 399 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 400 * @return the ordered range of matching layouts 401 * @throws SystemException if a system exception occurred 402 */ 403 public static java.util.List<com.liferay.portal.model.Layout> findByUuid_C( 404 java.lang.String uuid, long companyId, int start, int end, 405 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 406 throws com.liferay.portal.kernel.exception.SystemException { 407 return getPersistence() 408 .findByUuid_C(uuid, companyId, start, end, orderByComparator); 409 } 410 411 /** 412 * Returns the first layout in the ordered set where uuid = ? and companyId = ?. 413 * 414 * @param uuid the uuid 415 * @param companyId the company ID 416 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 417 * @return the first matching layout 418 * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found 419 * @throws SystemException if a system exception occurred 420 */ 421 public static com.liferay.portal.model.Layout findByUuid_C_First( 422 java.lang.String uuid, long companyId, 423 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 424 throws com.liferay.portal.NoSuchLayoutException, 425 com.liferay.portal.kernel.exception.SystemException { 426 return getPersistence() 427 .findByUuid_C_First(uuid, companyId, orderByComparator); 428 } 429 430 /** 431 * Returns the first layout in the ordered set where uuid = ? and companyId = ?. 432 * 433 * @param uuid the uuid 434 * @param companyId the company ID 435 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 436 * @return the first matching layout, or <code>null</code> if a matching layout could not be found 437 * @throws SystemException if a system exception occurred 438 */ 439 public static com.liferay.portal.model.Layout fetchByUuid_C_First( 440 java.lang.String uuid, long companyId, 441 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 442 throws com.liferay.portal.kernel.exception.SystemException { 443 return getPersistence() 444 .fetchByUuid_C_First(uuid, companyId, orderByComparator); 445 } 446 447 /** 448 * Returns the last layout in the ordered set where uuid = ? and companyId = ?. 449 * 450 * @param uuid the uuid 451 * @param companyId the company ID 452 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 453 * @return the last matching layout 454 * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found 455 * @throws SystemException if a system exception occurred 456 */ 457 public static com.liferay.portal.model.Layout findByUuid_C_Last( 458 java.lang.String uuid, long companyId, 459 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 460 throws com.liferay.portal.NoSuchLayoutException, 461 com.liferay.portal.kernel.exception.SystemException { 462 return getPersistence() 463 .findByUuid_C_Last(uuid, companyId, orderByComparator); 464 } 465 466 /** 467 * Returns the last layout in the ordered set where uuid = ? and companyId = ?. 468 * 469 * @param uuid the uuid 470 * @param companyId the company ID 471 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 472 * @return the last matching layout, or <code>null</code> if a matching layout could not be found 473 * @throws SystemException if a system exception occurred 474 */ 475 public static com.liferay.portal.model.Layout fetchByUuid_C_Last( 476 java.lang.String uuid, long companyId, 477 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 478 throws com.liferay.portal.kernel.exception.SystemException { 479 return getPersistence() 480 .fetchByUuid_C_Last(uuid, companyId, orderByComparator); 481 } 482 483 /** 484 * Returns the layouts before and after the current layout in the ordered set where uuid = ? and companyId = ?. 485 * 486 * @param plid the primary key of the current layout 487 * @param uuid the uuid 488 * @param companyId the company ID 489 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 490 * @return the previous, current, and next layout 491 * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found 492 * @throws SystemException if a system exception occurred 493 */ 494 public static com.liferay.portal.model.Layout[] findByUuid_C_PrevAndNext( 495 long plid, java.lang.String uuid, long companyId, 496 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 497 throws com.liferay.portal.NoSuchLayoutException, 498 com.liferay.portal.kernel.exception.SystemException { 499 return getPersistence() 500 .findByUuid_C_PrevAndNext(plid, uuid, companyId, 501 orderByComparator); 502 } 503 504 /** 505 * Removes all the layouts where uuid = ? and companyId = ? from the database. 506 * 507 * @param uuid the uuid 508 * @param companyId the company ID 509 * @throws SystemException if a system exception occurred 510 */ 511 public static void removeByUuid_C(java.lang.String uuid, long companyId) 512 throws com.liferay.portal.kernel.exception.SystemException { 513 getPersistence().removeByUuid_C(uuid, companyId); 514 } 515 516 /** 517 * Returns the number of layouts where uuid = ? and companyId = ?. 518 * 519 * @param uuid the uuid 520 * @param companyId the company ID 521 * @return the number of matching layouts 522 * @throws SystemException if a system exception occurred 523 */ 524 public static int countByUuid_C(java.lang.String uuid, long companyId) 525 throws com.liferay.portal.kernel.exception.SystemException { 526 return getPersistence().countByUuid_C(uuid, companyId); 527 } 528 529 /** 530 * Returns all the layouts where groupId = ?. 531 * 532 * @param groupId the group ID 533 * @return the matching layouts 534 * @throws SystemException if a system exception occurred 535 */ 536 public static java.util.List<com.liferay.portal.model.Layout> findByGroupId( 537 long groupId) 538 throws com.liferay.portal.kernel.exception.SystemException { 539 return getPersistence().findByGroupId(groupId); 540 } 541 542 /** 543 * Returns a range of all the layouts where groupId = ?. 544 * 545 * <p> 546 * 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. 547 * </p> 548 * 549 * @param groupId the group ID 550 * @param start the lower bound of the range of layouts 551 * @param end the upper bound of the range of layouts (not inclusive) 552 * @return the range of matching layouts 553 * @throws SystemException if a system exception occurred 554 */ 555 public static java.util.List<com.liferay.portal.model.Layout> findByGroupId( 556 long groupId, int start, int end) 557 throws com.liferay.portal.kernel.exception.SystemException { 558 return getPersistence().findByGroupId(groupId, start, end); 559 } 560 561 /** 562 * Returns an ordered range of all the layouts where groupId = ?. 563 * 564 * <p> 565 * 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. 566 * </p> 567 * 568 * @param groupId the group ID 569 * @param start the lower bound of the range of layouts 570 * @param end the upper bound of the range of layouts (not inclusive) 571 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 572 * @return the ordered range of matching layouts 573 * @throws SystemException if a system exception occurred 574 */ 575 public static java.util.List<com.liferay.portal.model.Layout> findByGroupId( 576 long groupId, int start, int end, 577 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 578 throws com.liferay.portal.kernel.exception.SystemException { 579 return getPersistence() 580 .findByGroupId(groupId, start, end, orderByComparator); 581 } 582 583 /** 584 * Returns the first layout in the ordered set where groupId = ?. 585 * 586 * @param groupId the group ID 587 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 588 * @return the first matching layout 589 * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found 590 * @throws SystemException if a system exception occurred 591 */ 592 public static com.liferay.portal.model.Layout findByGroupId_First( 593 long groupId, 594 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 595 throws com.liferay.portal.NoSuchLayoutException, 596 com.liferay.portal.kernel.exception.SystemException { 597 return getPersistence().findByGroupId_First(groupId, orderByComparator); 598 } 599 600 /** 601 * Returns the first layout in the ordered set where groupId = ?. 602 * 603 * @param groupId the group ID 604 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 605 * @return the first matching layout, or <code>null</code> if a matching layout could not be found 606 * @throws SystemException if a system exception occurred 607 */ 608 public static com.liferay.portal.model.Layout fetchByGroupId_First( 609 long groupId, 610 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 611 throws com.liferay.portal.kernel.exception.SystemException { 612 return getPersistence().fetchByGroupId_First(groupId, orderByComparator); 613 } 614 615 /** 616 * Returns the last layout in the ordered set where groupId = ?. 617 * 618 * @param groupId the group ID 619 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 620 * @return the last matching layout 621 * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found 622 * @throws SystemException if a system exception occurred 623 */ 624 public static com.liferay.portal.model.Layout findByGroupId_Last( 625 long groupId, 626 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 627 throws com.liferay.portal.NoSuchLayoutException, 628 com.liferay.portal.kernel.exception.SystemException { 629 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 630 } 631 632 /** 633 * Returns the last layout in the ordered set where groupId = ?. 634 * 635 * @param groupId the group ID 636 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 637 * @return the last matching layout, or <code>null</code> if a matching layout could not be found 638 * @throws SystemException if a system exception occurred 639 */ 640 public static com.liferay.portal.model.Layout fetchByGroupId_Last( 641 long groupId, 642 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 643 throws com.liferay.portal.kernel.exception.SystemException { 644 return getPersistence().fetchByGroupId_Last(groupId, orderByComparator); 645 } 646 647 /** 648 * Returns the layouts before and after the current layout in the ordered set where groupId = ?. 649 * 650 * @param plid the primary key of the current layout 651 * @param groupId the group ID 652 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 653 * @return the previous, current, and next layout 654 * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found 655 * @throws SystemException if a system exception occurred 656 */ 657 public static com.liferay.portal.model.Layout[] findByGroupId_PrevAndNext( 658 long plid, long groupId, 659 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 660 throws com.liferay.portal.NoSuchLayoutException, 661 com.liferay.portal.kernel.exception.SystemException { 662 return getPersistence() 663 .findByGroupId_PrevAndNext(plid, groupId, orderByComparator); 664 } 665 666 /** 667 * Returns all the layouts that the user has permission to view where groupId = ?. 668 * 669 * @param groupId the group ID 670 * @return the matching layouts that the user has permission to view 671 * @throws SystemException if a system exception occurred 672 */ 673 public static java.util.List<com.liferay.portal.model.Layout> filterFindByGroupId( 674 long groupId) 675 throws com.liferay.portal.kernel.exception.SystemException { 676 return getPersistence().filterFindByGroupId(groupId); 677 } 678 679 /** 680 * Returns a range of all the layouts that the user has permission to view where groupId = ?. 681 * 682 * <p> 683 * 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. 684 * </p> 685 * 686 * @param groupId the group ID 687 * @param start the lower bound of the range of layouts 688 * @param end the upper bound of the range of layouts (not inclusive) 689 * @return the range of matching layouts that the user has permission to view 690 * @throws SystemException if a system exception occurred 691 */ 692 public static java.util.List<com.liferay.portal.model.Layout> filterFindByGroupId( 693 long groupId, int start, int end) 694 throws com.liferay.portal.kernel.exception.SystemException { 695 return getPersistence().filterFindByGroupId(groupId, start, end); 696 } 697 698 /** 699 * Returns an ordered range of all the layouts that the user has permissions to view where groupId = ?. 700 * 701 * <p> 702 * 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. 703 * </p> 704 * 705 * @param groupId the group ID 706 * @param start the lower bound of the range of layouts 707 * @param end the upper bound of the range of layouts (not inclusive) 708 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 709 * @return the ordered range of matching layouts that the user has permission to view 710 * @throws SystemException if a system exception occurred 711 */ 712 public static java.util.List<com.liferay.portal.model.Layout> filterFindByGroupId( 713 long groupId, int start, int end, 714 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 715 throws com.liferay.portal.kernel.exception.SystemException { 716 return getPersistence() 717 .filterFindByGroupId(groupId, start, end, orderByComparator); 718 } 719 720 /** 721 * Returns the layouts before and after the current layout in the ordered set of layouts that the user has permission to view where groupId = ?. 722 * 723 * @param plid the primary key of the current layout 724 * @param groupId the group ID 725 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 726 * @return the previous, current, and next layout 727 * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found 728 * @throws SystemException if a system exception occurred 729 */ 730 public static com.liferay.portal.model.Layout[] filterFindByGroupId_PrevAndNext( 731 long plid, long groupId, 732 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 733 throws com.liferay.portal.NoSuchLayoutException, 734 com.liferay.portal.kernel.exception.SystemException { 735 return getPersistence() 736 .filterFindByGroupId_PrevAndNext(plid, groupId, 737 orderByComparator); 738 } 739 740 /** 741 * Removes all the layouts where groupId = ? from the database. 742 * 743 * @param groupId the group ID 744 * @throws SystemException if a system exception occurred 745 */ 746 public static void removeByGroupId(long groupId) 747 throws com.liferay.portal.kernel.exception.SystemException { 748 getPersistence().removeByGroupId(groupId); 749 } 750 751 /** 752 * Returns the number of layouts where groupId = ?. 753 * 754 * @param groupId the group ID 755 * @return the number of matching layouts 756 * @throws SystemException if a system exception occurred 757 */ 758 public static int countByGroupId(long groupId) 759 throws com.liferay.portal.kernel.exception.SystemException { 760 return getPersistence().countByGroupId(groupId); 761 } 762 763 /** 764 * Returns the number of layouts that the user has permission to view where groupId = ?. 765 * 766 * @param groupId the group ID 767 * @return the number of matching layouts that the user has permission to view 768 * @throws SystemException if a system exception occurred 769 */ 770 public static int filterCountByGroupId(long groupId) 771 throws com.liferay.portal.kernel.exception.SystemException { 772 return getPersistence().filterCountByGroupId(groupId); 773 } 774 775 /** 776 * Returns all the layouts where companyId = ?. 777 * 778 * @param companyId the company ID 779 * @return the matching layouts 780 * @throws SystemException if a system exception occurred 781 */ 782 public static java.util.List<com.liferay.portal.model.Layout> findByCompanyId( 783 long companyId) 784 throws com.liferay.portal.kernel.exception.SystemException { 785 return getPersistence().findByCompanyId(companyId); 786 } 787 788 /** 789 * Returns a range of all the layouts where companyId = ?. 790 * 791 * <p> 792 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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. 793 * </p> 794 * 795 * @param companyId the company ID 796 * @param start the lower bound of the range of layouts 797 * @param end the upper bound of the range of layouts (not inclusive) 798 * @return the range of matching layouts 799 * @throws SystemException if a system exception occurred 800 */ 801 public static java.util.List<com.liferay.portal.model.Layout> findByCompanyId( 802 long companyId, int start, int end) 803 throws com.liferay.portal.kernel.exception.SystemException { 804 return getPersistence().findByCompanyId(companyId, start, end); 805 } 806 807 /** 808 * Returns an ordered range of all the layouts where companyId = ?. 809 * 810 * <p> 811 * 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. 812 * </p> 813 * 814 * @param companyId the company ID 815 * @param start the lower bound of the range of layouts 816 * @param end the upper bound of the range of layouts (not inclusive) 817 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 818 * @return the ordered range of matching layouts 819 * @throws SystemException if a system exception occurred 820 */ 821 public static java.util.List<com.liferay.portal.model.Layout> findByCompanyId( 822 long companyId, int start, int end, 823 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 824 throws com.liferay.portal.kernel.exception.SystemException { 825 return getPersistence() 826 .findByCompanyId(companyId, start, end, orderByComparator); 827 } 828 829 /** 830 * Returns the first layout in the ordered set where companyId = ?. 831 * 832 * @param companyId the company ID 833 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 834 * @return the first matching layout 835 * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found 836 * @throws SystemException if a system exception occurred 837 */ 838 public static com.liferay.portal.model.Layout findByCompanyId_First( 839 long companyId, 840 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 841 throws com.liferay.portal.NoSuchLayoutException, 842 com.liferay.portal.kernel.exception.SystemException { 843 return getPersistence() 844 .findByCompanyId_First(companyId, orderByComparator); 845 } 846 847 /** 848 * Returns the first layout in the ordered set where companyId = ?. 849 * 850 * @param companyId the company ID 851 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 852 * @return the first matching layout, or <code>null</code> if a matching layout could not be found 853 * @throws SystemException if a system exception occurred 854 */ 855 public static com.liferay.portal.model.Layout fetchByCompanyId_First( 856 long companyId, 857 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 858 throws com.liferay.portal.kernel.exception.SystemException { 859 return getPersistence() 860 .fetchByCompanyId_First(companyId, orderByComparator); 861 } 862 863 /** 864 * Returns the last layout in the ordered set where companyId = ?. 865 * 866 * @param companyId the company ID 867 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 868 * @return the last matching layout 869 * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found 870 * @throws SystemException if a system exception occurred 871 */ 872 public static com.liferay.portal.model.Layout findByCompanyId_Last( 873 long companyId, 874 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 875 throws com.liferay.portal.NoSuchLayoutException, 876 com.liferay.portal.kernel.exception.SystemException { 877 return getPersistence() 878 .findByCompanyId_Last(companyId, orderByComparator); 879 } 880 881 /** 882 * Returns the last layout in the ordered set where companyId = ?. 883 * 884 * @param companyId the company ID 885 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 886 * @return the last matching layout, or <code>null</code> if a matching layout could not be found 887 * @throws SystemException if a system exception occurred 888 */ 889 public static com.liferay.portal.model.Layout fetchByCompanyId_Last( 890 long companyId, 891 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 892 throws com.liferay.portal.kernel.exception.SystemException { 893 return getPersistence() 894 .fetchByCompanyId_Last(companyId, orderByComparator); 895 } 896 897 /** 898 * Returns the layouts before and after the current layout in the ordered set where companyId = ?. 899 * 900 * @param plid the primary key of the current layout 901 * @param companyId the company ID 902 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 903 * @return the previous, current, and next layout 904 * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found 905 * @throws SystemException if a system exception occurred 906 */ 907 public static com.liferay.portal.model.Layout[] findByCompanyId_PrevAndNext( 908 long plid, long companyId, 909 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 910 throws com.liferay.portal.NoSuchLayoutException, 911 com.liferay.portal.kernel.exception.SystemException { 912 return getPersistence() 913 .findByCompanyId_PrevAndNext(plid, companyId, 914 orderByComparator); 915 } 916 917 /** 918 * Removes all the layouts where companyId = ? from the database. 919 * 920 * @param companyId the company ID 921 * @throws SystemException if a system exception occurred 922 */ 923 public static void removeByCompanyId(long companyId) 924 throws com.liferay.portal.kernel.exception.SystemException { 925 getPersistence().removeByCompanyId(companyId); 926 } 927 928 /** 929 * Returns the number of layouts where companyId = ?. 930 * 931 * @param companyId the company ID 932 * @return the number of matching layouts 933 * @throws SystemException if a system exception occurred 934 */ 935 public static int countByCompanyId(long companyId) 936 throws com.liferay.portal.kernel.exception.SystemException { 937 return getPersistence().countByCompanyId(companyId); 938 } 939 940 /** 941 * Returns the layout where iconImageId = ? or throws a {@link com.liferay.portal.NoSuchLayoutException} if it could not be found. 942 * 943 * @param iconImageId the icon image ID 944 * @return the matching layout 945 * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found 946 * @throws SystemException if a system exception occurred 947 */ 948 public static com.liferay.portal.model.Layout findByIconImageId( 949 long iconImageId) 950 throws com.liferay.portal.NoSuchLayoutException, 951 com.liferay.portal.kernel.exception.SystemException { 952 return getPersistence().findByIconImageId(iconImageId); 953 } 954 955 /** 956 * Returns the layout where iconImageId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 957 * 958 * @param iconImageId the icon image ID 959 * @return the matching layout, or <code>null</code> if a matching layout could not be found 960 * @throws SystemException if a system exception occurred 961 */ 962 public static com.liferay.portal.model.Layout fetchByIconImageId( 963 long iconImageId) 964 throws com.liferay.portal.kernel.exception.SystemException { 965 return getPersistence().fetchByIconImageId(iconImageId); 966 } 967 968 /** 969 * Returns the layout where iconImageId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 970 * 971 * @param iconImageId the icon image ID 972 * @param retrieveFromCache whether to use the finder cache 973 * @return the matching layout, or <code>null</code> if a matching layout could not be found 974 * @throws SystemException if a system exception occurred 975 */ 976 public static com.liferay.portal.model.Layout fetchByIconImageId( 977 long iconImageId, boolean retrieveFromCache) 978 throws com.liferay.portal.kernel.exception.SystemException { 979 return getPersistence() 980 .fetchByIconImageId(iconImageId, retrieveFromCache); 981 } 982 983 /** 984 * Removes the layout where iconImageId = ? from the database. 985 * 986 * @param iconImageId the icon image ID 987 * @return the layout that was removed 988 * @throws SystemException if a system exception occurred 989 */ 990 public static com.liferay.portal.model.Layout removeByIconImageId( 991 long iconImageId) 992 throws com.liferay.portal.NoSuchLayoutException, 993 com.liferay.portal.kernel.exception.SystemException { 994 return getPersistence().removeByIconImageId(iconImageId); 995 } 996 997 /** 998 * Returns the number of layouts where iconImageId = ?. 999 * 1000 * @param iconImageId the icon image ID 1001 * @return the number of matching layouts 1002 * @throws SystemException if a system exception occurred 1003 */ 1004 public static int countByIconImageId(long iconImageId) 1005 throws com.liferay.portal.kernel.exception.SystemException { 1006 return getPersistence().countByIconImageId(iconImageId); 1007 } 1008 1009 /** 1010 * Returns all the layouts where layoutPrototypeUuid = ?. 1011 * 1012 * @param layoutPrototypeUuid the layout prototype uuid 1013 * @return the matching layouts 1014 * @throws SystemException if a system exception occurred 1015 */ 1016 public static java.util.List<com.liferay.portal.model.Layout> findByLayoutPrototypeUuid( 1017 java.lang.String layoutPrototypeUuid) 1018 throws com.liferay.portal.kernel.exception.SystemException { 1019 return getPersistence().findByLayoutPrototypeUuid(layoutPrototypeUuid); 1020 } 1021 1022 /** 1023 * Returns a range of all the layouts where layoutPrototypeUuid = ?. 1024 * 1025 * <p> 1026 * 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. 1027 * </p> 1028 * 1029 * @param layoutPrototypeUuid the layout prototype uuid 1030 * @param start the lower bound of the range of layouts 1031 * @param end the upper bound of the range of layouts (not inclusive) 1032 * @return the range of matching layouts 1033 * @throws SystemException if a system exception occurred 1034 */ 1035 public static java.util.List<com.liferay.portal.model.Layout> findByLayoutPrototypeUuid( 1036 java.lang.String layoutPrototypeUuid, int start, int end) 1037 throws com.liferay.portal.kernel.exception.SystemException { 1038 return getPersistence() 1039 .findByLayoutPrototypeUuid(layoutPrototypeUuid, start, end); 1040 } 1041 1042 /** 1043 * Returns an ordered range of all the layouts where layoutPrototypeUuid = ?. 1044 * 1045 * <p> 1046 * 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. 1047 * </p> 1048 * 1049 * @param layoutPrototypeUuid the layout prototype uuid 1050 * @param start the lower bound of the range of layouts 1051 * @param end the upper bound of the range of layouts (not inclusive) 1052 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1053 * @return the ordered range of matching layouts 1054 * @throws SystemException if a system exception occurred 1055 */ 1056 public static java.util.List<com.liferay.portal.model.Layout> findByLayoutPrototypeUuid( 1057 java.lang.String layoutPrototypeUuid, int start, int end, 1058 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1059 throws com.liferay.portal.kernel.exception.SystemException { 1060 return getPersistence() 1061 .findByLayoutPrototypeUuid(layoutPrototypeUuid, start, end, 1062 orderByComparator); 1063 } 1064 1065 /** 1066 * Returns the first layout in the ordered set where layoutPrototypeUuid = ?. 1067 * 1068 * @param layoutPrototypeUuid the layout prototype uuid 1069 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1070 * @return the first matching layout 1071 * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found 1072 * @throws SystemException if a system exception occurred 1073 */ 1074 public static com.liferay.portal.model.Layout findByLayoutPrototypeUuid_First( 1075 java.lang.String layoutPrototypeUuid, 1076 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1077 throws com.liferay.portal.NoSuchLayoutException, 1078 com.liferay.portal.kernel.exception.SystemException { 1079 return getPersistence() 1080 .findByLayoutPrototypeUuid_First(layoutPrototypeUuid, 1081 orderByComparator); 1082 } 1083 1084 /** 1085 * Returns the first layout in the ordered set where layoutPrototypeUuid = ?. 1086 * 1087 * @param layoutPrototypeUuid the layout prototype uuid 1088 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1089 * @return the first matching layout, or <code>null</code> if a matching layout could not be found 1090 * @throws SystemException if a system exception occurred 1091 */ 1092 public static com.liferay.portal.model.Layout fetchByLayoutPrototypeUuid_First( 1093 java.lang.String layoutPrototypeUuid, 1094 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1095 throws com.liferay.portal.kernel.exception.SystemException { 1096 return getPersistence() 1097 .fetchByLayoutPrototypeUuid_First(layoutPrototypeUuid, 1098 orderByComparator); 1099 } 1100 1101 /** 1102 * Returns the last layout in the ordered set where layoutPrototypeUuid = ?. 1103 * 1104 * @param layoutPrototypeUuid the layout prototype uuid 1105 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1106 * @return the last matching layout 1107 * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found 1108 * @throws SystemException if a system exception occurred 1109 */ 1110 public static com.liferay.portal.model.Layout findByLayoutPrototypeUuid_Last( 1111 java.lang.String layoutPrototypeUuid, 1112 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1113 throws com.liferay.portal.NoSuchLayoutException, 1114 com.liferay.portal.kernel.exception.SystemException { 1115 return getPersistence() 1116 .findByLayoutPrototypeUuid_Last(layoutPrototypeUuid, 1117 orderByComparator); 1118 } 1119 1120 /** 1121 * Returns the last layout in the ordered set where layoutPrototypeUuid = ?. 1122 * 1123 * @param layoutPrototypeUuid the layout prototype uuid 1124 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1125 * @return the last matching layout, or <code>null</code> if a matching layout could not be found 1126 * @throws SystemException if a system exception occurred 1127 */ 1128 public static com.liferay.portal.model.Layout fetchByLayoutPrototypeUuid_Last( 1129 java.lang.String layoutPrototypeUuid, 1130 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1131 throws com.liferay.portal.kernel.exception.SystemException { 1132 return getPersistence() 1133 .fetchByLayoutPrototypeUuid_Last(layoutPrototypeUuid, 1134 orderByComparator); 1135 } 1136 1137 /** 1138 * Returns the layouts before and after the current layout in the ordered set where layoutPrototypeUuid = ?. 1139 * 1140 * @param plid the primary key of the current layout 1141 * @param layoutPrototypeUuid the layout prototype uuid 1142 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1143 * @return the previous, current, and next layout 1144 * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found 1145 * @throws SystemException if a system exception occurred 1146 */ 1147 public static com.liferay.portal.model.Layout[] findByLayoutPrototypeUuid_PrevAndNext( 1148 long plid, java.lang.String layoutPrototypeUuid, 1149 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1150 throws com.liferay.portal.NoSuchLayoutException, 1151 com.liferay.portal.kernel.exception.SystemException { 1152 return getPersistence() 1153 .findByLayoutPrototypeUuid_PrevAndNext(plid, 1154 layoutPrototypeUuid, orderByComparator); 1155 } 1156 1157 /** 1158 * Removes all the layouts where layoutPrototypeUuid = ? from the database. 1159 * 1160 * @param layoutPrototypeUuid the layout prototype uuid 1161 * @throws SystemException if a system exception occurred 1162 */ 1163 public static void removeByLayoutPrototypeUuid( 1164 java.lang.String layoutPrototypeUuid) 1165 throws com.liferay.portal.kernel.exception.SystemException { 1166 getPersistence().removeByLayoutPrototypeUuid(layoutPrototypeUuid); 1167 } 1168 1169 /** 1170 * Returns the number of layouts where layoutPrototypeUuid = ?. 1171 * 1172 * @param layoutPrototypeUuid the layout prototype uuid 1173 * @return the number of matching layouts 1174 * @throws SystemException if a system exception occurred 1175 */ 1176 public static int countByLayoutPrototypeUuid( 1177 java.lang.String layoutPrototypeUuid) 1178 throws com.liferay.portal.kernel.exception.SystemException { 1179 return getPersistence().countByLayoutPrototypeUuid(layoutPrototypeUuid); 1180 } 1181 1182 /** 1183 * Returns all the layouts where sourcePrototypeLayoutUuid = ?. 1184 * 1185 * @param sourcePrototypeLayoutUuid the source prototype layout uuid 1186 * @return the matching layouts 1187 * @throws SystemException if a system exception occurred 1188 */ 1189 public static java.util.List<com.liferay.portal.model.Layout> findBySourcePrototypeLayoutUuid( 1190 java.lang.String sourcePrototypeLayoutUuid) 1191 throws com.liferay.portal.kernel.exception.SystemException { 1192 return getPersistence() 1193 .findBySourcePrototypeLayoutUuid(sourcePrototypeLayoutUuid); 1194 } 1195 1196 /** 1197 * Returns a range of all the layouts where sourcePrototypeLayoutUuid = ?. 1198 * 1199 * <p> 1200 * 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. 1201 * </p> 1202 * 1203 * @param sourcePrototypeLayoutUuid the source prototype layout uuid 1204 * @param start the lower bound of the range of layouts 1205 * @param end the upper bound of the range of layouts (not inclusive) 1206 * @return the range of matching layouts 1207 * @throws SystemException if a system exception occurred 1208 */ 1209 public static java.util.List<com.liferay.portal.model.Layout> findBySourcePrototypeLayoutUuid( 1210 java.lang.String sourcePrototypeLayoutUuid, int start, int end) 1211 throws com.liferay.portal.kernel.exception.SystemException { 1212 return getPersistence() 1213 .findBySourcePrototypeLayoutUuid(sourcePrototypeLayoutUuid, 1214 start, end); 1215 } 1216 1217 /** 1218 * Returns an ordered range of all the layouts where sourcePrototypeLayoutUuid = ?. 1219 * 1220 * <p> 1221 * 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. 1222 * </p> 1223 * 1224 * @param sourcePrototypeLayoutUuid the source prototype layout uuid 1225 * @param start the lower bound of the range of layouts 1226 * @param end the upper bound of the range of layouts (not inclusive) 1227 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1228 * @return the ordered range of matching layouts 1229 * @throws SystemException if a system exception occurred 1230 */ 1231 public static java.util.List<com.liferay.portal.model.Layout> findBySourcePrototypeLayoutUuid( 1232 java.lang.String sourcePrototypeLayoutUuid, int start, int end, 1233 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1234 throws com.liferay.portal.kernel.exception.SystemException { 1235 return getPersistence() 1236 .findBySourcePrototypeLayoutUuid(sourcePrototypeLayoutUuid, 1237 start, end, orderByComparator); 1238 } 1239 1240 /** 1241 * Returns the first layout in the ordered set where sourcePrototypeLayoutUuid = ?. 1242 * 1243 * @param sourcePrototypeLayoutUuid the source prototype layout uuid 1244 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1245 * @return the first matching layout 1246 * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found 1247 * @throws SystemException if a system exception occurred 1248 */ 1249 public static com.liferay.portal.model.Layout findBySourcePrototypeLayoutUuid_First( 1250 java.lang.String sourcePrototypeLayoutUuid, 1251 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1252 throws com.liferay.portal.NoSuchLayoutException, 1253 com.liferay.portal.kernel.exception.SystemException { 1254 return getPersistence() 1255 .findBySourcePrototypeLayoutUuid_First(sourcePrototypeLayoutUuid, 1256 orderByComparator); 1257 } 1258 1259 /** 1260 * Returns the first layout in the ordered set where sourcePrototypeLayoutUuid = ?. 1261 * 1262 * @param sourcePrototypeLayoutUuid the source prototype layout uuid 1263 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1264 * @return the first matching layout, or <code>null</code> if a matching layout could not be found 1265 * @throws SystemException if a system exception occurred 1266 */ 1267 public static com.liferay.portal.model.Layout fetchBySourcePrototypeLayoutUuid_First( 1268 java.lang.String sourcePrototypeLayoutUuid, 1269 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1270 throws com.liferay.portal.kernel.exception.SystemException { 1271 return getPersistence() 1272 .fetchBySourcePrototypeLayoutUuid_First(sourcePrototypeLayoutUuid, 1273 orderByComparator); 1274 } 1275 1276 /** 1277 * Returns the last layout in the ordered set where sourcePrototypeLayoutUuid = ?. 1278 * 1279 * @param sourcePrototypeLayoutUuid the source prototype layout uuid 1280 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1281 * @return the last matching layout 1282 * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found 1283 * @throws SystemException if a system exception occurred 1284 */ 1285 public static com.liferay.portal.model.Layout findBySourcePrototypeLayoutUuid_Last( 1286 java.lang.String sourcePrototypeLayoutUuid, 1287 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1288 throws com.liferay.portal.NoSuchLayoutException, 1289 com.liferay.portal.kernel.exception.SystemException { 1290 return getPersistence() 1291 .findBySourcePrototypeLayoutUuid_Last(sourcePrototypeLayoutUuid, 1292 orderByComparator); 1293 } 1294 1295 /** 1296 * Returns the last layout in the ordered set where sourcePrototypeLayoutUuid = ?. 1297 * 1298 * @param sourcePrototypeLayoutUuid the source prototype layout uuid 1299 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1300 * @return the last matching layout, or <code>null</code> if a matching layout could not be found 1301 * @throws SystemException if a system exception occurred 1302 */ 1303 public static com.liferay.portal.model.Layout fetchBySourcePrototypeLayoutUuid_Last( 1304 java.lang.String sourcePrototypeLayoutUuid, 1305 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1306 throws com.liferay.portal.kernel.exception.SystemException { 1307 return getPersistence() 1308 .fetchBySourcePrototypeLayoutUuid_Last(sourcePrototypeLayoutUuid, 1309 orderByComparator); 1310 } 1311 1312 /** 1313 * Returns the layouts before and after the current layout in the ordered set where sourcePrototypeLayoutUuid = ?. 1314 * 1315 * @param plid the primary key of the current layout 1316 * @param sourcePrototypeLayoutUuid the source prototype layout uuid 1317 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1318 * @return the previous, current, and next layout 1319 * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found 1320 * @throws SystemException if a system exception occurred 1321 */ 1322 public static com.liferay.portal.model.Layout[] findBySourcePrototypeLayoutUuid_PrevAndNext( 1323 long plid, java.lang.String sourcePrototypeLayoutUuid, 1324 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1325 throws com.liferay.portal.NoSuchLayoutException, 1326 com.liferay.portal.kernel.exception.SystemException { 1327 return getPersistence() 1328 .findBySourcePrototypeLayoutUuid_PrevAndNext(plid, 1329 sourcePrototypeLayoutUuid, orderByComparator); 1330 } 1331 1332 /** 1333 * Removes all the layouts where sourcePrototypeLayoutUuid = ? from the database. 1334 * 1335 * @param sourcePrototypeLayoutUuid the source prototype layout uuid 1336 * @throws SystemException if a system exception occurred 1337 */ 1338 public static void removeBySourcePrototypeLayoutUuid( 1339 java.lang.String sourcePrototypeLayoutUuid) 1340 throws com.liferay.portal.kernel.exception.SystemException { 1341 getPersistence() 1342 .removeBySourcePrototypeLayoutUuid(sourcePrototypeLayoutUuid); 1343 } 1344 1345 /** 1346 * Returns the number of layouts where sourcePrototypeLayoutUuid = ?. 1347 * 1348 * @param sourcePrototypeLayoutUuid the source prototype layout uuid 1349 * @return the number of matching layouts 1350 * @throws SystemException if a system exception occurred 1351 */ 1352 public static int countBySourcePrototypeLayoutUuid( 1353 java.lang.String sourcePrototypeLayoutUuid) 1354 throws com.liferay.portal.kernel.exception.SystemException { 1355 return getPersistence() 1356 .countBySourcePrototypeLayoutUuid(sourcePrototypeLayoutUuid); 1357 } 1358 1359 /** 1360 * Returns all the layouts where groupId = ? and privateLayout = ?. 1361 * 1362 * @param groupId the group ID 1363 * @param privateLayout the private layout 1364 * @return the matching layouts 1365 * @throws SystemException if a system exception occurred 1366 */ 1367 public static java.util.List<com.liferay.portal.model.Layout> findByG_P( 1368 long groupId, boolean privateLayout) 1369 throws com.liferay.portal.kernel.exception.SystemException { 1370 return getPersistence().findByG_P(groupId, privateLayout); 1371 } 1372 1373 /** 1374 * Returns a range of all the layouts where groupId = ? and privateLayout = ?. 1375 * 1376 * <p> 1377 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link 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. 1378 * </p> 1379 * 1380 * @param groupId the group ID 1381 * @param privateLayout the private layout 1382 * @param start the lower bound of the range of layouts 1383 * @param end the upper bound of the range of layouts (not inclusive) 1384 * @return the range of matching layouts 1385 * @throws SystemException if a system exception occurred 1386 */ 1387 public static java.util.List<com.liferay.portal.model.Layout> findByG_P( 1388 long groupId, boolean privateLayout, int start, int end) 1389 throws com.liferay.portal.kernel.exception.SystemException { 1390 return getPersistence().findByG_P(groupId, privateLayout, start, end); 1391 } 1392 1393 /** 1394 * Returns an ordered range of all the layouts where groupId = ? and privateLayout = ?. 1395 * 1396 * <p> 1397 * 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. 1398 * </p> 1399 * 1400 * @param groupId the group ID 1401 * @param privateLayout the private layout 1402 * @param start the lower bound of the range of layouts 1403 * @param end the upper bound of the range of layouts (not inclusive) 1404 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1405 * @return the ordered range of matching layouts 1406 * @throws SystemException if a system exception occurred 1407 */ 1408 public static java.util.List<com.liferay.portal.model.Layout> findByG_P( 1409 long groupId, boolean privateLayout, int start, int end, 1410 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1411 throws com.liferay.portal.kernel.exception.SystemException { 1412 return getPersistence() 1413 .findByG_P(groupId, privateLayout, start, end, 1414 orderByComparator); 1415 } 1416 1417 /** 1418 * Returns the first layout in the ordered set where groupId = ? and privateLayout = ?. 1419 * 1420 * @param groupId the group ID 1421 * @param privateLayout the private layout 1422 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1423 * @return the first matching layout 1424 * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found 1425 * @throws SystemException if a system exception occurred 1426 */ 1427 public static com.liferay.portal.model.Layout findByG_P_First( 1428 long groupId, boolean privateLayout, 1429 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1430 throws com.liferay.portal.NoSuchLayoutException, 1431 com.liferay.portal.kernel.exception.SystemException { 1432 return getPersistence() 1433 .findByG_P_First(groupId, privateLayout, orderByComparator); 1434 } 1435 1436 /** 1437 * Returns the first layout in the ordered set where groupId = ? and privateLayout = ?. 1438 * 1439 * @param groupId the group ID 1440 * @param privateLayout the private layout 1441 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1442 * @return the first matching layout, or <code>null</code> if a matching layout could not be found 1443 * @throws SystemException if a system exception occurred 1444 */ 1445 public static com.liferay.portal.model.Layout fetchByG_P_First( 1446 long groupId, boolean privateLayout, 1447 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1448 throws com.liferay.portal.kernel.exception.SystemException { 1449 return getPersistence() 1450 .fetchByG_P_First(groupId, privateLayout, orderByComparator); 1451 } 1452 1453 /** 1454 * Returns the last layout in the ordered set where groupId = ? and privateLayout = ?. 1455 * 1456 * @param groupId the group ID 1457 * @param privateLayout the private layout 1458 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1459 * @return the last matching layout 1460 * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found 1461 * @throws SystemException if a system exception occurred 1462 */ 1463 public static com.liferay.portal.model.Layout findByG_P_Last(long groupId, 1464 boolean privateLayout, 1465 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1466 throws com.liferay.portal.NoSuchLayoutException, 1467 com.liferay.portal.kernel.exception.SystemException { 1468 return getPersistence() 1469 .findByG_P_Last(groupId, privateLayout, orderByComparator); 1470 } 1471 1472 /** 1473 * Returns the last layout in the ordered set where groupId = ? and privateLayout = ?. 1474 * 1475 * @param groupId the group ID 1476 * @param privateLayout the private layout 1477 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1478 * @return the last matching layout, or <code>null</code> if a matching layout could not be found 1479 * @throws SystemException if a system exception occurred 1480 */ 1481 public static com.liferay.portal.model.Layout fetchByG_P_Last( 1482 long groupId, boolean privateLayout, 1483 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1484 throws com.liferay.portal.kernel.exception.SystemException { 1485 return getPersistence() 1486 .fetchByG_P_Last(groupId, privateLayout, orderByComparator); 1487 } 1488 1489 /** 1490 * Returns the layouts before and after the current layout in the ordered set where groupId = ? and privateLayout = ?. 1491 * 1492 * @param plid the primary key of the current layout 1493 * @param groupId the group ID 1494 * @param privateLayout the private layout 1495 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1496 * @return the previous, current, and next layout 1497 * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found 1498 * @throws SystemException if a system exception occurred 1499 */ 1500 public static com.liferay.portal.model.Layout[] findByG_P_PrevAndNext( 1501 long plid, long groupId, boolean privateLayout, 1502 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1503 throws com.liferay.portal.NoSuchLayoutException, 1504 com.liferay.portal.kernel.exception.SystemException { 1505 return getPersistence() 1506 .findByG_P_PrevAndNext(plid, groupId, privateLayout, 1507 orderByComparator); 1508 } 1509 1510 /** 1511 * Returns all the layouts that the user has permission to view where groupId = ? and privateLayout = ?. 1512 * 1513 * @param groupId the group ID 1514 * @param privateLayout the private layout 1515 * @return the matching layouts that the user has permission to view 1516 * @throws SystemException if a system exception occurred 1517 */ 1518 public static java.util.List<com.liferay.portal.model.Layout> filterFindByG_P( 1519 long groupId, boolean privateLayout) 1520 throws com.liferay.portal.kernel.exception.SystemException { 1521 return getPersistence().filterFindByG_P(groupId, privateLayout); 1522 } 1523 1524 /** 1525 * Returns a range of all the layouts that the user has permission to view where groupId = ? and privateLayout = ?. 1526 * 1527 * <p> 1528 * 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. 1529 * </p> 1530 * 1531 * @param groupId the group ID 1532 * @param privateLayout the private layout 1533 * @param start the lower bound of the range of layouts 1534 * @param end the upper bound of the range of layouts (not inclusive) 1535 * @return the range of matching layouts that the user has permission to view 1536 * @throws SystemException if a system exception occurred 1537 */ 1538 public static java.util.List<com.liferay.portal.model.Layout> filterFindByG_P( 1539 long groupId, boolean privateLayout, int start, int end) 1540 throws com.liferay.portal.kernel.exception.SystemException { 1541 return getPersistence() 1542 .filterFindByG_P(groupId, privateLayout, start, end); 1543 } 1544 1545 /** 1546 * Returns an ordered range of all the layouts that the user has permissions to view where groupId = ? and privateLayout = ?. 1547 * 1548 * <p> 1549 * 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. 1550 * </p> 1551 * 1552 * @param groupId the group ID 1553 * @param privateLayout the private layout 1554 * @param start the lower bound of the range of layouts 1555 * @param end the upper bound of the range of layouts (not inclusive) 1556 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1557 * @return the ordered range of matching layouts that the user has permission to view 1558 * @throws SystemException if a system exception occurred 1559 */ 1560 public static java.util.List<com.liferay.portal.model.Layout> filterFindByG_P( 1561 long groupId, boolean privateLayout, int start, int end, 1562 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1563 throws com.liferay.portal.kernel.exception.SystemException { 1564 return getPersistence() 1565 .filterFindByG_P(groupId, privateLayout, start, end, 1566 orderByComparator); 1567 } 1568 1569 /** 1570 * 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 = ?. 1571 * 1572 * @param plid the primary key of the current layout 1573 * @param groupId the group ID 1574 * @param privateLayout the private layout 1575 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1576 * @return the previous, current, and next layout 1577 * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found 1578 * @throws SystemException if a system exception occurred 1579 */ 1580 public static com.liferay.portal.model.Layout[] filterFindByG_P_PrevAndNext( 1581 long plid, long groupId, boolean privateLayout, 1582 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1583 throws com.liferay.portal.NoSuchLayoutException, 1584 com.liferay.portal.kernel.exception.SystemException { 1585 return getPersistence() 1586 .filterFindByG_P_PrevAndNext(plid, groupId, privateLayout, 1587 orderByComparator); 1588 } 1589 1590 /** 1591 * Removes all the layouts where groupId = ? and privateLayout = ? from the database. 1592 * 1593 * @param groupId the group ID 1594 * @param privateLayout the private layout 1595 * @throws SystemException if a system exception occurred 1596 */ 1597 public static void removeByG_P(long groupId, boolean privateLayout) 1598 throws com.liferay.portal.kernel.exception.SystemException { 1599 getPersistence().removeByG_P(groupId, privateLayout); 1600 } 1601 1602 /** 1603 * Returns the number of layouts where groupId = ? and privateLayout = ?. 1604 * 1605 * @param groupId the group ID 1606 * @param privateLayout the private layout 1607 * @return the number of matching layouts 1608 * @throws SystemException if a system exception occurred 1609 */ 1610 public static int countByG_P(long groupId, boolean privateLayout) 1611 throws com.liferay.portal.kernel.exception.SystemException { 1612 return getPersistence().countByG_P(groupId, privateLayout); 1613 } 1614 1615 /** 1616 * Returns the number of layouts that the user has permission to view where groupId = ? and privateLayout = ?. 1617 * 1618 * @param groupId the group ID 1619 * @param privateLayout the private layout 1620 * @return the number of matching layouts that the user has permission to view 1621 * @throws SystemException if a system exception occurred 1622 */ 1623 public static int filterCountByG_P(long groupId, boolean privateLayout) 1624 throws com.liferay.portal.kernel.exception.SystemException { 1625 return getPersistence().filterCountByG_P(groupId, privateLayout); 1626 } 1627 1628 /** 1629 * Returns the layout where groupId = ? and privateLayout = ? and layoutId = ? or throws a {@link com.liferay.portal.NoSuchLayoutException} if it could not be found. 1630 * 1631 * @param groupId the group ID 1632 * @param privateLayout the private layout 1633 * @param layoutId the layout ID 1634 * @return the matching layout 1635 * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found 1636 * @throws SystemException if a system exception occurred 1637 */ 1638 public static com.liferay.portal.model.Layout findByG_P_L(long groupId, 1639 boolean privateLayout, long layoutId) 1640 throws com.liferay.portal.NoSuchLayoutException, 1641 com.liferay.portal.kernel.exception.SystemException { 1642 return getPersistence().findByG_P_L(groupId, privateLayout, layoutId); 1643 } 1644 1645 /** 1646 * Returns the layout where groupId = ? and privateLayout = ? and layoutId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 1647 * 1648 * @param groupId the group ID 1649 * @param privateLayout the private layout 1650 * @param layoutId the layout ID 1651 * @return the matching layout, or <code>null</code> if a matching layout could not be found 1652 * @throws SystemException if a system exception occurred 1653 */ 1654 public static com.liferay.portal.model.Layout fetchByG_P_L(long groupId, 1655 boolean privateLayout, long layoutId) 1656 throws com.liferay.portal.kernel.exception.SystemException { 1657 return getPersistence().fetchByG_P_L(groupId, privateLayout, layoutId); 1658 } 1659 1660 /** 1661 * 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. 1662 * 1663 * @param groupId the group ID 1664 * @param privateLayout the private layout 1665 * @param layoutId the layout ID 1666 * @param retrieveFromCache whether to use the finder cache 1667 * @return the matching layout, or <code>null</code> if a matching layout could not be found 1668 * @throws SystemException if a system exception occurred 1669 */ 1670 public static com.liferay.portal.model.Layout fetchByG_P_L(long groupId, 1671 boolean privateLayout, long layoutId, boolean retrieveFromCache) 1672 throws com.liferay.portal.kernel.exception.SystemException { 1673 return getPersistence() 1674 .fetchByG_P_L(groupId, privateLayout, layoutId, 1675 retrieveFromCache); 1676 } 1677 1678 /** 1679 * Removes the layout where groupId = ? and privateLayout = ? and layoutId = ? from the database. 1680 * 1681 * @param groupId the group ID 1682 * @param privateLayout the private layout 1683 * @param layoutId the layout ID 1684 * @return the layout that was removed 1685 * @throws SystemException if a system exception occurred 1686 */ 1687 public static com.liferay.portal.model.Layout removeByG_P_L(long groupId, 1688 boolean privateLayout, long layoutId) 1689 throws com.liferay.portal.NoSuchLayoutException, 1690 com.liferay.portal.kernel.exception.SystemException { 1691 return getPersistence().removeByG_P_L(groupId, privateLayout, layoutId); 1692 } 1693 1694 /** 1695 * Returns the number of layouts where groupId = ? and privateLayout = ? and layoutId = ?. 1696 * 1697 * @param groupId the group ID 1698 * @param privateLayout the private layout 1699 * @param layoutId the layout ID 1700 * @return the number of matching layouts 1701 * @throws SystemException if a system exception occurred 1702 */ 1703 public static int countByG_P_L(long groupId, boolean privateLayout, 1704 long layoutId) 1705 throws com.liferay.portal.kernel.exception.SystemException { 1706 return getPersistence().countByG_P_L(groupId, privateLayout, layoutId); 1707 } 1708 1709 /** 1710 * Returns the layout where groupId = ? and privateLayout = ? and friendlyURL = ? or throws a {@link com.liferay.portal.NoSuchLayoutException} if it could not be found. 1711 * 1712 * @param groupId the group ID 1713 * @param privateLayout the private layout 1714 * @param friendlyURL the friendly u r l 1715 * @return the matching layout 1716 * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found 1717 * @throws SystemException if a system exception occurred 1718 */ 1719 public static com.liferay.portal.model.Layout findByG_P_F(long groupId, 1720 boolean privateLayout, java.lang.String friendlyURL) 1721 throws com.liferay.portal.NoSuchLayoutException, 1722 com.liferay.portal.kernel.exception.SystemException { 1723 return getPersistence().findByG_P_F(groupId, privateLayout, friendlyURL); 1724 } 1725 1726 /** 1727 * Returns the layout where groupId = ? and privateLayout = ? and friendlyURL = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 1728 * 1729 * @param groupId the group ID 1730 * @param privateLayout the private layout 1731 * @param friendlyURL the friendly u r l 1732 * @return the matching layout, or <code>null</code> if a matching layout could not be found 1733 * @throws SystemException if a system exception occurred 1734 */ 1735 public static com.liferay.portal.model.Layout fetchByG_P_F(long groupId, 1736 boolean privateLayout, java.lang.String friendlyURL) 1737 throws com.liferay.portal.kernel.exception.SystemException { 1738 return getPersistence().fetchByG_P_F(groupId, privateLayout, friendlyURL); 1739 } 1740 1741 /** 1742 * 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. 1743 * 1744 * @param groupId the group ID 1745 * @param privateLayout the private layout 1746 * @param friendlyURL the friendly u r l 1747 * @param retrieveFromCache whether to use the finder cache 1748 * @return the matching layout, or <code>null</code> if a matching layout could not be found 1749 * @throws SystemException if a system exception occurred 1750 */ 1751 public static com.liferay.portal.model.Layout fetchByG_P_F(long groupId, 1752 boolean privateLayout, java.lang.String friendlyURL, 1753 boolean retrieveFromCache) 1754 throws com.liferay.portal.kernel.exception.SystemException { 1755 return getPersistence() 1756 .fetchByG_P_F(groupId, privateLayout, friendlyURL, 1757 retrieveFromCache); 1758 } 1759 1760 /** 1761 * Removes the layout where groupId = ? and privateLayout = ? and friendlyURL = ? from the database. 1762 * 1763 * @param groupId the group ID 1764 * @param privateLayout the private layout 1765 * @param friendlyURL the friendly u r l 1766 * @return the layout that was removed 1767 * @throws SystemException if a system exception occurred 1768 */ 1769 public static com.liferay.portal.model.Layout removeByG_P_F(long groupId, 1770 boolean privateLayout, java.lang.String friendlyURL) 1771 throws com.liferay.portal.NoSuchLayoutException, 1772 com.liferay.portal.kernel.exception.SystemException { 1773 return getPersistence() 1774 .removeByG_P_F(groupId, privateLayout, friendlyURL); 1775 } 1776 1777 /** 1778 * Returns the number of layouts where groupId = ? and privateLayout = ? and friendlyURL = ?. 1779 * 1780 * @param groupId the group ID 1781 * @param privateLayout the private layout 1782 * @param friendlyURL the friendly u r l 1783 * @return the number of matching layouts 1784 * @throws SystemException if a system exception occurred 1785 */ 1786 public static int countByG_P_F(long groupId, boolean privateLayout, 1787 java.lang.String friendlyURL) 1788 throws com.liferay.portal.kernel.exception.SystemException { 1789 return getPersistence().countByG_P_F(groupId, privateLayout, friendlyURL); 1790 } 1791 1792 /** 1793 * Returns all the layouts where groupId = ? and privateLayout = ? and parentLayoutId = ?. 1794 * 1795 * @param groupId the group ID 1796 * @param privateLayout the private layout 1797 * @param parentLayoutId the parent layout ID 1798 * @return the matching layouts 1799 * @throws SystemException if a system exception occurred 1800 */ 1801 public static java.util.List<com.liferay.portal.model.Layout> findByG_P_P( 1802 long groupId, boolean privateLayout, long parentLayoutId) 1803 throws com.liferay.portal.kernel.exception.SystemException { 1804 return getPersistence() 1805 .findByG_P_P(groupId, privateLayout, parentLayoutId); 1806 } 1807 1808 /** 1809 * Returns a range of all the layouts where groupId = ? and privateLayout = ? and parentLayoutId = ?. 1810 * 1811 * <p> 1812 * 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. 1813 * </p> 1814 * 1815 * @param groupId the group ID 1816 * @param privateLayout the private layout 1817 * @param parentLayoutId the parent layout ID 1818 * @param start the lower bound of the range of layouts 1819 * @param end the upper bound of the range of layouts (not inclusive) 1820 * @return the range of matching layouts 1821 * @throws SystemException if a system exception occurred 1822 */ 1823 public static java.util.List<com.liferay.portal.model.Layout> findByG_P_P( 1824 long groupId, boolean privateLayout, long parentLayoutId, int start, 1825 int end) throws com.liferay.portal.kernel.exception.SystemException { 1826 return getPersistence() 1827 .findByG_P_P(groupId, privateLayout, parentLayoutId, start, 1828 end); 1829 } 1830 1831 /** 1832 * Returns an ordered range of all the layouts where groupId = ? and privateLayout = ? and parentLayoutId = ?. 1833 * 1834 * <p> 1835 * 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. 1836 * </p> 1837 * 1838 * @param groupId the group ID 1839 * @param privateLayout the private layout 1840 * @param parentLayoutId the parent layout ID 1841 * @param start the lower bound of the range of layouts 1842 * @param end the upper bound of the range of layouts (not inclusive) 1843 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1844 * @return the ordered range of matching layouts 1845 * @throws SystemException if a system exception occurred 1846 */ 1847 public static java.util.List<com.liferay.portal.model.Layout> findByG_P_P( 1848 long groupId, boolean privateLayout, long parentLayoutId, int start, 1849 int end, 1850 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1851 throws com.liferay.portal.kernel.exception.SystemException { 1852 return getPersistence() 1853 .findByG_P_P(groupId, privateLayout, parentLayoutId, start, 1854 end, orderByComparator); 1855 } 1856 1857 /** 1858 * Returns the first layout in the ordered set where groupId = ? and privateLayout = ? and parentLayoutId = ?. 1859 * 1860 * @param groupId the group ID 1861 * @param privateLayout the private layout 1862 * @param parentLayoutId the parent layout ID 1863 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1864 * @return the first matching layout 1865 * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found 1866 * @throws SystemException if a system exception occurred 1867 */ 1868 public static com.liferay.portal.model.Layout findByG_P_P_First( 1869 long groupId, boolean privateLayout, long parentLayoutId, 1870 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1871 throws com.liferay.portal.NoSuchLayoutException, 1872 com.liferay.portal.kernel.exception.SystemException { 1873 return getPersistence() 1874 .findByG_P_P_First(groupId, privateLayout, parentLayoutId, 1875 orderByComparator); 1876 } 1877 1878 /** 1879 * Returns the first layout in the ordered set where groupId = ? and privateLayout = ? and parentLayoutId = ?. 1880 * 1881 * @param groupId the group ID 1882 * @param privateLayout the private layout 1883 * @param parentLayoutId the parent layout ID 1884 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1885 * @return the first matching layout, or <code>null</code> if a matching layout could not be found 1886 * @throws SystemException if a system exception occurred 1887 */ 1888 public static com.liferay.portal.model.Layout fetchByG_P_P_First( 1889 long groupId, boolean privateLayout, long parentLayoutId, 1890 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1891 throws com.liferay.portal.kernel.exception.SystemException { 1892 return getPersistence() 1893 .fetchByG_P_P_First(groupId, privateLayout, parentLayoutId, 1894 orderByComparator); 1895 } 1896 1897 /** 1898 * Returns the last layout in the ordered set where groupId = ? and privateLayout = ? and parentLayoutId = ?. 1899 * 1900 * @param groupId the group ID 1901 * @param privateLayout the private layout 1902 * @param parentLayoutId the parent layout ID 1903 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1904 * @return the last matching layout 1905 * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found 1906 * @throws SystemException if a system exception occurred 1907 */ 1908 public static com.liferay.portal.model.Layout findByG_P_P_Last( 1909 long groupId, boolean privateLayout, long parentLayoutId, 1910 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1911 throws com.liferay.portal.NoSuchLayoutException, 1912 com.liferay.portal.kernel.exception.SystemException { 1913 return getPersistence() 1914 .findByG_P_P_Last(groupId, privateLayout, parentLayoutId, 1915 orderByComparator); 1916 } 1917 1918 /** 1919 * Returns the last layout in the ordered set where groupId = ? and privateLayout = ? and parentLayoutId = ?. 1920 * 1921 * @param groupId the group ID 1922 * @param privateLayout the private layout 1923 * @param parentLayoutId the parent layout ID 1924 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1925 * @return the last matching layout, or <code>null</code> if a matching layout could not be found 1926 * @throws SystemException if a system exception occurred 1927 */ 1928 public static com.liferay.portal.model.Layout fetchByG_P_P_Last( 1929 long groupId, boolean privateLayout, long parentLayoutId, 1930 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1931 throws com.liferay.portal.kernel.exception.SystemException { 1932 return getPersistence() 1933 .fetchByG_P_P_Last(groupId, privateLayout, parentLayoutId, 1934 orderByComparator); 1935 } 1936 1937 /** 1938 * Returns the layouts before and after the current layout in the ordered set where groupId = ? and privateLayout = ? and parentLayoutId = ?. 1939 * 1940 * @param plid the primary key of the current layout 1941 * @param groupId the group ID 1942 * @param privateLayout the private layout 1943 * @param parentLayoutId the parent layout ID 1944 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1945 * @return the previous, current, and next layout 1946 * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found 1947 * @throws SystemException if a system exception occurred 1948 */ 1949 public static com.liferay.portal.model.Layout[] findByG_P_P_PrevAndNext( 1950 long plid, long groupId, boolean privateLayout, long parentLayoutId, 1951 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1952 throws com.liferay.portal.NoSuchLayoutException, 1953 com.liferay.portal.kernel.exception.SystemException { 1954 return getPersistence() 1955 .findByG_P_P_PrevAndNext(plid, groupId, privateLayout, 1956 parentLayoutId, orderByComparator); 1957 } 1958 1959 /** 1960 * Returns all the layouts that the user has permission to view where groupId = ? and privateLayout = ? and parentLayoutId = ?. 1961 * 1962 * @param groupId the group ID 1963 * @param privateLayout the private layout 1964 * @param parentLayoutId the parent layout ID 1965 * @return the matching layouts that the user has permission to view 1966 * @throws SystemException if a system exception occurred 1967 */ 1968 public static java.util.List<com.liferay.portal.model.Layout> filterFindByG_P_P( 1969 long groupId, boolean privateLayout, long parentLayoutId) 1970 throws com.liferay.portal.kernel.exception.SystemException { 1971 return getPersistence() 1972 .filterFindByG_P_P(groupId, privateLayout, parentLayoutId); 1973 } 1974 1975 /** 1976 * Returns a range of all the layouts that the user has permission to view where groupId = ? and privateLayout = ? and parentLayoutId = ?. 1977 * 1978 * <p> 1979 * 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. 1980 * </p> 1981 * 1982 * @param groupId the group ID 1983 * @param privateLayout the private layout 1984 * @param parentLayoutId the parent layout ID 1985 * @param start the lower bound of the range of layouts 1986 * @param end the upper bound of the range of layouts (not inclusive) 1987 * @return the range of matching layouts that the user has permission to view 1988 * @throws SystemException if a system exception occurred 1989 */ 1990 public static java.util.List<com.liferay.portal.model.Layout> filterFindByG_P_P( 1991 long groupId, boolean privateLayout, long parentLayoutId, int start, 1992 int end) throws com.liferay.portal.kernel.exception.SystemException { 1993 return getPersistence() 1994 .filterFindByG_P_P(groupId, privateLayout, parentLayoutId, 1995 start, end); 1996 } 1997 1998 /** 1999 * Returns an ordered range of all the layouts that the user has permissions to view where groupId = ? and privateLayout = ? and parentLayoutId = ?. 2000 * 2001 * <p> 2002 * 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. 2003 * </p> 2004 * 2005 * @param groupId the group ID 2006 * @param privateLayout the private layout 2007 * @param parentLayoutId the parent layout ID 2008 * @param start the lower bound of the range of layouts 2009 * @param end the upper bound of the range of layouts (not inclusive) 2010 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2011 * @return the ordered range of matching layouts that the user has permission to view 2012 * @throws SystemException if a system exception occurred 2013 */ 2014 public static java.util.List<com.liferay.portal.model.Layout> filterFindByG_P_P( 2015 long groupId, boolean privateLayout, long parentLayoutId, int start, 2016 int end, 2017 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2018 throws com.liferay.portal.kernel.exception.SystemException { 2019 return getPersistence() 2020 .filterFindByG_P_P(groupId, privateLayout, parentLayoutId, 2021 start, end, orderByComparator); 2022 } 2023 2024 /** 2025 * 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 = ?. 2026 * 2027 * @param plid the primary key of the current layout 2028 * @param groupId the group ID 2029 * @param privateLayout the private layout 2030 * @param parentLayoutId the parent layout ID 2031 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2032 * @return the previous, current, and next layout 2033 * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found 2034 * @throws SystemException if a system exception occurred 2035 */ 2036 public static com.liferay.portal.model.Layout[] filterFindByG_P_P_PrevAndNext( 2037 long plid, long groupId, boolean privateLayout, long parentLayoutId, 2038 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2039 throws com.liferay.portal.NoSuchLayoutException, 2040 com.liferay.portal.kernel.exception.SystemException { 2041 return getPersistence() 2042 .filterFindByG_P_P_PrevAndNext(plid, groupId, privateLayout, 2043 parentLayoutId, orderByComparator); 2044 } 2045 2046 /** 2047 * Removes all the layouts where groupId = ? and privateLayout = ? and parentLayoutId = ? from the database. 2048 * 2049 * @param groupId the group ID 2050 * @param privateLayout the private layout 2051 * @param parentLayoutId the parent layout ID 2052 * @throws SystemException if a system exception occurred 2053 */ 2054 public static void removeByG_P_P(long groupId, boolean privateLayout, 2055 long parentLayoutId) 2056 throws com.liferay.portal.kernel.exception.SystemException { 2057 getPersistence().removeByG_P_P(groupId, privateLayout, parentLayoutId); 2058 } 2059 2060 /** 2061 * Returns the number of layouts where groupId = ? and privateLayout = ? and parentLayoutId = ?. 2062 * 2063 * @param groupId the group ID 2064 * @param privateLayout the private layout 2065 * @param parentLayoutId the parent layout ID 2066 * @return the number of matching layouts 2067 * @throws SystemException if a system exception occurred 2068 */ 2069 public static int countByG_P_P(long groupId, boolean privateLayout, 2070 long parentLayoutId) 2071 throws com.liferay.portal.kernel.exception.SystemException { 2072 return getPersistence() 2073 .countByG_P_P(groupId, privateLayout, parentLayoutId); 2074 } 2075 2076 /** 2077 * Returns the number of layouts that the user has permission to view where groupId = ? and privateLayout = ? and parentLayoutId = ?. 2078 * 2079 * @param groupId the group ID 2080 * @param privateLayout the private layout 2081 * @param parentLayoutId the parent layout ID 2082 * @return the number of matching layouts that the user has permission to view 2083 * @throws SystemException if a system exception occurred 2084 */ 2085 public static int filterCountByG_P_P(long groupId, boolean privateLayout, 2086 long parentLayoutId) 2087 throws com.liferay.portal.kernel.exception.SystemException { 2088 return getPersistence() 2089 .filterCountByG_P_P(groupId, privateLayout, parentLayoutId); 2090 } 2091 2092 /** 2093 * Returns all the layouts where groupId = ? and privateLayout = ? and type = ?. 2094 * 2095 * @param groupId the group ID 2096 * @param privateLayout the private layout 2097 * @param type the type 2098 * @return the matching layouts 2099 * @throws SystemException if a system exception occurred 2100 */ 2101 public static java.util.List<com.liferay.portal.model.Layout> findByG_P_T( 2102 long groupId, boolean privateLayout, java.lang.String type) 2103 throws com.liferay.portal.kernel.exception.SystemException { 2104 return getPersistence().findByG_P_T(groupId, privateLayout, type); 2105 } 2106 2107 /** 2108 * Returns a range of all the layouts where groupId = ? and privateLayout = ? and type = ?. 2109 * 2110 * <p> 2111 * 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. 2112 * </p> 2113 * 2114 * @param groupId the group ID 2115 * @param privateLayout the private layout 2116 * @param type the type 2117 * @param start the lower bound of the range of layouts 2118 * @param end the upper bound of the range of layouts (not inclusive) 2119 * @return the range of matching layouts 2120 * @throws SystemException if a system exception occurred 2121 */ 2122 public static java.util.List<com.liferay.portal.model.Layout> findByG_P_T( 2123 long groupId, boolean privateLayout, java.lang.String type, int start, 2124 int end) throws com.liferay.portal.kernel.exception.SystemException { 2125 return getPersistence() 2126 .findByG_P_T(groupId, privateLayout, type, start, end); 2127 } 2128 2129 /** 2130 * Returns an ordered range of all the layouts where groupId = ? and privateLayout = ? and type = ?. 2131 * 2132 * <p> 2133 * 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. 2134 * </p> 2135 * 2136 * @param groupId the group ID 2137 * @param privateLayout the private layout 2138 * @param type the type 2139 * @param start the lower bound of the range of layouts 2140 * @param end the upper bound of the range of layouts (not inclusive) 2141 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2142 * @return the ordered range of matching layouts 2143 * @throws SystemException if a system exception occurred 2144 */ 2145 public static java.util.List<com.liferay.portal.model.Layout> findByG_P_T( 2146 long groupId, boolean privateLayout, java.lang.String type, int start, 2147 int end, 2148 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2149 throws com.liferay.portal.kernel.exception.SystemException { 2150 return getPersistence() 2151 .findByG_P_T(groupId, privateLayout, type, start, end, 2152 orderByComparator); 2153 } 2154 2155 /** 2156 * Returns the first layout in the ordered set where groupId = ? and privateLayout = ? and type = ?. 2157 * 2158 * @param groupId the group ID 2159 * @param privateLayout the private layout 2160 * @param type the type 2161 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2162 * @return the first matching layout 2163 * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found 2164 * @throws SystemException if a system exception occurred 2165 */ 2166 public static com.liferay.portal.model.Layout findByG_P_T_First( 2167 long groupId, boolean privateLayout, java.lang.String type, 2168 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2169 throws com.liferay.portal.NoSuchLayoutException, 2170 com.liferay.portal.kernel.exception.SystemException { 2171 return getPersistence() 2172 .findByG_P_T_First(groupId, privateLayout, type, 2173 orderByComparator); 2174 } 2175 2176 /** 2177 * Returns the first layout in the ordered set where groupId = ? and privateLayout = ? and type = ?. 2178 * 2179 * @param groupId the group ID 2180 * @param privateLayout the private layout 2181 * @param type the type 2182 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2183 * @return the first matching layout, or <code>null</code> if a matching layout could not be found 2184 * @throws SystemException if a system exception occurred 2185 */ 2186 public static com.liferay.portal.model.Layout fetchByG_P_T_First( 2187 long groupId, boolean privateLayout, java.lang.String type, 2188 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2189 throws com.liferay.portal.kernel.exception.SystemException { 2190 return getPersistence() 2191 .fetchByG_P_T_First(groupId, privateLayout, type, 2192 orderByComparator); 2193 } 2194 2195 /** 2196 * Returns the last layout in the ordered set where groupId = ? and privateLayout = ? and type = ?. 2197 * 2198 * @param groupId the group ID 2199 * @param privateLayout the private layout 2200 * @param type the type 2201 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2202 * @return the last matching layout 2203 * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found 2204 * @throws SystemException if a system exception occurred 2205 */ 2206 public static com.liferay.portal.model.Layout findByG_P_T_Last( 2207 long groupId, boolean privateLayout, java.lang.String type, 2208 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2209 throws com.liferay.portal.NoSuchLayoutException, 2210 com.liferay.portal.kernel.exception.SystemException { 2211 return getPersistence() 2212 .findByG_P_T_Last(groupId, privateLayout, type, 2213 orderByComparator); 2214 } 2215 2216 /** 2217 * Returns the last layout in the ordered set where groupId = ? and privateLayout = ? and type = ?. 2218 * 2219 * @param groupId the group ID 2220 * @param privateLayout the private layout 2221 * @param type the type 2222 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2223 * @return the last matching layout, or <code>null</code> if a matching layout could not be found 2224 * @throws SystemException if a system exception occurred 2225 */ 2226 public static com.liferay.portal.model.Layout fetchByG_P_T_Last( 2227 long groupId, boolean privateLayout, java.lang.String type, 2228 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2229 throws com.liferay.portal.kernel.exception.SystemException { 2230 return getPersistence() 2231 .fetchByG_P_T_Last(groupId, privateLayout, type, 2232 orderByComparator); 2233 } 2234 2235 /** 2236 * Returns the layouts before and after the current layout in the ordered set where groupId = ? and privateLayout = ? and type = ?. 2237 * 2238 * @param plid the primary key of the current layout 2239 * @param groupId the group ID 2240 * @param privateLayout the private layout 2241 * @param type the type 2242 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2243 * @return the previous, current, and next layout 2244 * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found 2245 * @throws SystemException if a system exception occurred 2246 */ 2247 public static com.liferay.portal.model.Layout[] findByG_P_T_PrevAndNext( 2248 long plid, long groupId, boolean privateLayout, java.lang.String type, 2249 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2250 throws com.liferay.portal.NoSuchLayoutException, 2251 com.liferay.portal.kernel.exception.SystemException { 2252 return getPersistence() 2253 .findByG_P_T_PrevAndNext(plid, groupId, privateLayout, type, 2254 orderByComparator); 2255 } 2256 2257 /** 2258 * Returns all the layouts that the user has permission to view where groupId = ? and privateLayout = ? and type = ?. 2259 * 2260 * @param groupId the group ID 2261 * @param privateLayout the private layout 2262 * @param type the type 2263 * @return the matching layouts that the user has permission to view 2264 * @throws SystemException if a system exception occurred 2265 */ 2266 public static java.util.List<com.liferay.portal.model.Layout> filterFindByG_P_T( 2267 long groupId, boolean privateLayout, java.lang.String type) 2268 throws com.liferay.portal.kernel.exception.SystemException { 2269 return getPersistence().filterFindByG_P_T(groupId, privateLayout, type); 2270 } 2271 2272 /** 2273 * Returns a range of all the layouts that the user has permission to view where groupId = ? and privateLayout = ? and type = ?. 2274 * 2275 * <p> 2276 * 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. 2277 * </p> 2278 * 2279 * @param groupId the group ID 2280 * @param privateLayout the private layout 2281 * @param type the type 2282 * @param start the lower bound of the range of layouts 2283 * @param end the upper bound of the range of layouts (not inclusive) 2284 * @return the range of matching layouts that the user has permission to view 2285 * @throws SystemException if a system exception occurred 2286 */ 2287 public static java.util.List<com.liferay.portal.model.Layout> filterFindByG_P_T( 2288 long groupId, boolean privateLayout, java.lang.String type, int start, 2289 int end) throws com.liferay.portal.kernel.exception.SystemException { 2290 return getPersistence() 2291 .filterFindByG_P_T(groupId, privateLayout, type, start, end); 2292 } 2293 2294 /** 2295 * Returns an ordered range of all the layouts that the user has permissions to view where groupId = ? and privateLayout = ? and type = ?. 2296 * 2297 * <p> 2298 * 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. 2299 * </p> 2300 * 2301 * @param groupId the group ID 2302 * @param privateLayout the private layout 2303 * @param type the type 2304 * @param start the lower bound of the range of layouts 2305 * @param end the upper bound of the range of layouts (not inclusive) 2306 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2307 * @return the ordered range of matching layouts that the user has permission to view 2308 * @throws SystemException if a system exception occurred 2309 */ 2310 public static java.util.List<com.liferay.portal.model.Layout> filterFindByG_P_T( 2311 long groupId, boolean privateLayout, java.lang.String type, int start, 2312 int end, 2313 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2314 throws com.liferay.portal.kernel.exception.SystemException { 2315 return getPersistence() 2316 .filterFindByG_P_T(groupId, privateLayout, type, start, end, 2317 orderByComparator); 2318 } 2319 2320 /** 2321 * 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 = ?. 2322 * 2323 * @param plid the primary key of the current layout 2324 * @param groupId the group ID 2325 * @param privateLayout the private layout 2326 * @param type the type 2327 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2328 * @return the previous, current, and next layout 2329 * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found 2330 * @throws SystemException if a system exception occurred 2331 */ 2332 public static com.liferay.portal.model.Layout[] filterFindByG_P_T_PrevAndNext( 2333 long plid, long groupId, boolean privateLayout, java.lang.String type, 2334 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2335 throws com.liferay.portal.NoSuchLayoutException, 2336 com.liferay.portal.kernel.exception.SystemException { 2337 return getPersistence() 2338 .filterFindByG_P_T_PrevAndNext(plid, groupId, privateLayout, 2339 type, orderByComparator); 2340 } 2341 2342 /** 2343 * Removes all the layouts where groupId = ? and privateLayout = ? and type = ? from the database. 2344 * 2345 * @param groupId the group ID 2346 * @param privateLayout the private layout 2347 * @param type the type 2348 * @throws SystemException if a system exception occurred 2349 */ 2350 public static void removeByG_P_T(long groupId, boolean privateLayout, 2351 java.lang.String type) 2352 throws com.liferay.portal.kernel.exception.SystemException { 2353 getPersistence().removeByG_P_T(groupId, privateLayout, type); 2354 } 2355 2356 /** 2357 * Returns the number of layouts where groupId = ? and privateLayout = ? and type = ?. 2358 * 2359 * @param groupId the group ID 2360 * @param privateLayout the private layout 2361 * @param type the type 2362 * @return the number of matching layouts 2363 * @throws SystemException if a system exception occurred 2364 */ 2365 public static int countByG_P_T(long groupId, boolean privateLayout, 2366 java.lang.String type) 2367 throws com.liferay.portal.kernel.exception.SystemException { 2368 return getPersistence().countByG_P_T(groupId, privateLayout, type); 2369 } 2370 2371 /** 2372 * Returns the number of layouts that the user has permission to view where groupId = ? and privateLayout = ? and type = ?. 2373 * 2374 * @param groupId the group ID 2375 * @param privateLayout the private layout 2376 * @param type the type 2377 * @return the number of matching layouts that the user has permission to view 2378 * @throws SystemException if a system exception occurred 2379 */ 2380 public static int filterCountByG_P_T(long groupId, boolean privateLayout, 2381 java.lang.String type) 2382 throws com.liferay.portal.kernel.exception.SystemException { 2383 return getPersistence().filterCountByG_P_T(groupId, privateLayout, type); 2384 } 2385 2386 /** 2387 * Returns the layout where groupId = ? and privateLayout = ? and sourcePrototypeLayoutUuid = ? or throws a {@link com.liferay.portal.NoSuchLayoutException} if it could not be found. 2388 * 2389 * @param groupId the group ID 2390 * @param privateLayout the private layout 2391 * @param sourcePrototypeLayoutUuid the source prototype layout uuid 2392 * @return the matching layout 2393 * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found 2394 * @throws SystemException if a system exception occurred 2395 */ 2396 public static com.liferay.portal.model.Layout findByG_P_SPLU(long groupId, 2397 boolean privateLayout, java.lang.String sourcePrototypeLayoutUuid) 2398 throws com.liferay.portal.NoSuchLayoutException, 2399 com.liferay.portal.kernel.exception.SystemException { 2400 return getPersistence() 2401 .findByG_P_SPLU(groupId, privateLayout, 2402 sourcePrototypeLayoutUuid); 2403 } 2404 2405 /** 2406 * Returns the layout where groupId = ? and privateLayout = ? and sourcePrototypeLayoutUuid = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 2407 * 2408 * @param groupId the group ID 2409 * @param privateLayout the private layout 2410 * @param sourcePrototypeLayoutUuid the source prototype layout uuid 2411 * @return the matching layout, or <code>null</code> if a matching layout could not be found 2412 * @throws SystemException if a system exception occurred 2413 */ 2414 public static com.liferay.portal.model.Layout fetchByG_P_SPLU( 2415 long groupId, boolean privateLayout, 2416 java.lang.String sourcePrototypeLayoutUuid) 2417 throws com.liferay.portal.kernel.exception.SystemException { 2418 return getPersistence() 2419 .fetchByG_P_SPLU(groupId, privateLayout, 2420 sourcePrototypeLayoutUuid); 2421 } 2422 2423 /** 2424 * 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. 2425 * 2426 * @param groupId the group ID 2427 * @param privateLayout the private layout 2428 * @param sourcePrototypeLayoutUuid the source prototype layout uuid 2429 * @param retrieveFromCache whether to use the finder cache 2430 * @return the matching layout, or <code>null</code> if a matching layout could not be found 2431 * @throws SystemException if a system exception occurred 2432 */ 2433 public static com.liferay.portal.model.Layout fetchByG_P_SPLU( 2434 long groupId, boolean privateLayout, 2435 java.lang.String sourcePrototypeLayoutUuid, boolean retrieveFromCache) 2436 throws com.liferay.portal.kernel.exception.SystemException { 2437 return getPersistence() 2438 .fetchByG_P_SPLU(groupId, privateLayout, 2439 sourcePrototypeLayoutUuid, retrieveFromCache); 2440 } 2441 2442 /** 2443 * Removes the layout where groupId = ? and privateLayout = ? and sourcePrototypeLayoutUuid = ? from the database. 2444 * 2445 * @param groupId the group ID 2446 * @param privateLayout the private layout 2447 * @param sourcePrototypeLayoutUuid the source prototype layout uuid 2448 * @return the layout that was removed 2449 * @throws SystemException if a system exception occurred 2450 */ 2451 public static com.liferay.portal.model.Layout removeByG_P_SPLU( 2452 long groupId, boolean privateLayout, 2453 java.lang.String sourcePrototypeLayoutUuid) 2454 throws com.liferay.portal.NoSuchLayoutException, 2455 com.liferay.portal.kernel.exception.SystemException { 2456 return getPersistence() 2457 .removeByG_P_SPLU(groupId, privateLayout, 2458 sourcePrototypeLayoutUuid); 2459 } 2460 2461 /** 2462 * Returns the number of layouts where groupId = ? and privateLayout = ? and sourcePrototypeLayoutUuid = ?. 2463 * 2464 * @param groupId the group ID 2465 * @param privateLayout the private layout 2466 * @param sourcePrototypeLayoutUuid the source prototype layout uuid 2467 * @return the number of matching layouts 2468 * @throws SystemException if a system exception occurred 2469 */ 2470 public static int countByG_P_SPLU(long groupId, boolean privateLayout, 2471 java.lang.String sourcePrototypeLayoutUuid) 2472 throws com.liferay.portal.kernel.exception.SystemException { 2473 return getPersistence() 2474 .countByG_P_SPLU(groupId, privateLayout, 2475 sourcePrototypeLayoutUuid); 2476 } 2477 2478 /** 2479 * Returns all the layouts where groupId = ? and privateLayout = ? and parentLayoutId = ? and priority ≤ ?. 2480 * 2481 * @param groupId the group ID 2482 * @param privateLayout the private layout 2483 * @param parentLayoutId the parent layout ID 2484 * @param priority the priority 2485 * @return the matching layouts 2486 * @throws SystemException if a system exception occurred 2487 */ 2488 public static java.util.List<com.liferay.portal.model.Layout> findByG_P_P_LtP( 2489 long groupId, boolean privateLayout, long parentLayoutId, int priority) 2490 throws com.liferay.portal.kernel.exception.SystemException { 2491 return getPersistence() 2492 .findByG_P_P_LtP(groupId, privateLayout, parentLayoutId, 2493 priority); 2494 } 2495 2496 /** 2497 * Returns a range of all the layouts where groupId = ? and privateLayout = ? and parentLayoutId = ? and priority ≤ ?. 2498 * 2499 * <p> 2500 * 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. 2501 * </p> 2502 * 2503 * @param groupId the group ID 2504 * @param privateLayout the private layout 2505 * @param parentLayoutId the parent layout ID 2506 * @param priority the priority 2507 * @param start the lower bound of the range of layouts 2508 * @param end the upper bound of the range of layouts (not inclusive) 2509 * @return the range of matching layouts 2510 * @throws SystemException if a system exception occurred 2511 */ 2512 public static java.util.List<com.liferay.portal.model.Layout> findByG_P_P_LtP( 2513 long groupId, boolean privateLayout, long parentLayoutId, int priority, 2514 int start, int end) 2515 throws com.liferay.portal.kernel.exception.SystemException { 2516 return getPersistence() 2517 .findByG_P_P_LtP(groupId, privateLayout, parentLayoutId, 2518 priority, start, end); 2519 } 2520 2521 /** 2522 * Returns an ordered range of all the layouts where groupId = ? and privateLayout = ? and parentLayoutId = ? and priority ≤ ?. 2523 * 2524 * <p> 2525 * 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. 2526 * </p> 2527 * 2528 * @param groupId the group ID 2529 * @param privateLayout the private layout 2530 * @param parentLayoutId the parent layout ID 2531 * @param priority the priority 2532 * @param start the lower bound of the range of layouts 2533 * @param end the upper bound of the range of layouts (not inclusive) 2534 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2535 * @return the ordered range of matching layouts 2536 * @throws SystemException if a system exception occurred 2537 */ 2538 public static java.util.List<com.liferay.portal.model.Layout> findByG_P_P_LtP( 2539 long groupId, boolean privateLayout, long parentLayoutId, int priority, 2540 int start, int end, 2541 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2542 throws com.liferay.portal.kernel.exception.SystemException { 2543 return getPersistence() 2544 .findByG_P_P_LtP(groupId, privateLayout, parentLayoutId, 2545 priority, start, end, orderByComparator); 2546 } 2547 2548 /** 2549 * Returns the first layout in the ordered set where groupId = ? and privateLayout = ? and parentLayoutId = ? and priority ≤ ?. 2550 * 2551 * @param groupId the group ID 2552 * @param privateLayout the private layout 2553 * @param parentLayoutId the parent layout ID 2554 * @param priority the priority 2555 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2556 * @return the first matching layout 2557 * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found 2558 * @throws SystemException if a system exception occurred 2559 */ 2560 public static com.liferay.portal.model.Layout findByG_P_P_LtP_First( 2561 long groupId, boolean privateLayout, long parentLayoutId, int priority, 2562 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2563 throws com.liferay.portal.NoSuchLayoutException, 2564 com.liferay.portal.kernel.exception.SystemException { 2565 return getPersistence() 2566 .findByG_P_P_LtP_First(groupId, privateLayout, 2567 parentLayoutId, priority, orderByComparator); 2568 } 2569 2570 /** 2571 * Returns the first layout in the ordered set where groupId = ? and privateLayout = ? and parentLayoutId = ? and priority ≤ ?. 2572 * 2573 * @param groupId the group ID 2574 * @param privateLayout the private layout 2575 * @param parentLayoutId the parent layout ID 2576 * @param priority the priority 2577 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2578 * @return the first matching layout, or <code>null</code> if a matching layout could not be found 2579 * @throws SystemException if a system exception occurred 2580 */ 2581 public static com.liferay.portal.model.Layout fetchByG_P_P_LtP_First( 2582 long groupId, boolean privateLayout, long parentLayoutId, int priority, 2583 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2584 throws com.liferay.portal.kernel.exception.SystemException { 2585 return getPersistence() 2586 .fetchByG_P_P_LtP_First(groupId, privateLayout, 2587 parentLayoutId, priority, orderByComparator); 2588 } 2589 2590 /** 2591 * Returns the last layout in the ordered set where groupId = ? and privateLayout = ? and parentLayoutId = ? and priority ≤ ?. 2592 * 2593 * @param groupId the group ID 2594 * @param privateLayout the private layout 2595 * @param parentLayoutId the parent layout ID 2596 * @param priority the priority 2597 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2598 * @return the last matching layout 2599 * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found 2600 * @throws SystemException if a system exception occurred 2601 */ 2602 public static com.liferay.portal.model.Layout findByG_P_P_LtP_Last( 2603 long groupId, boolean privateLayout, long parentLayoutId, int priority, 2604 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2605 throws com.liferay.portal.NoSuchLayoutException, 2606 com.liferay.portal.kernel.exception.SystemException { 2607 return getPersistence() 2608 .findByG_P_P_LtP_Last(groupId, privateLayout, 2609 parentLayoutId, priority, orderByComparator); 2610 } 2611 2612 /** 2613 * Returns the last layout in the ordered set where groupId = ? and privateLayout = ? and parentLayoutId = ? and priority ≤ ?. 2614 * 2615 * @param groupId the group ID 2616 * @param privateLayout the private layout 2617 * @param parentLayoutId the parent layout ID 2618 * @param priority the priority 2619 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2620 * @return the last matching layout, or <code>null</code> if a matching layout could not be found 2621 * @throws SystemException if a system exception occurred 2622 */ 2623 public static com.liferay.portal.model.Layout fetchByG_P_P_LtP_Last( 2624 long groupId, boolean privateLayout, long parentLayoutId, int priority, 2625 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2626 throws com.liferay.portal.kernel.exception.SystemException { 2627 return getPersistence() 2628 .fetchByG_P_P_LtP_Last(groupId, privateLayout, 2629 parentLayoutId, priority, orderByComparator); 2630 } 2631 2632 /** 2633 * Returns the layouts before and after the current layout in the ordered set where groupId = ? and privateLayout = ? and parentLayoutId = ? and priority ≤ ?. 2634 * 2635 * @param plid the primary key of the current layout 2636 * @param groupId the group ID 2637 * @param privateLayout the private layout 2638 * @param parentLayoutId the parent layout ID 2639 * @param priority the priority 2640 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2641 * @return the previous, current, and next layout 2642 * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found 2643 * @throws SystemException if a system exception occurred 2644 */ 2645 public static com.liferay.portal.model.Layout[] findByG_P_P_LtP_PrevAndNext( 2646 long plid, long groupId, boolean privateLayout, long parentLayoutId, 2647 int priority, 2648 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2649 throws com.liferay.portal.NoSuchLayoutException, 2650 com.liferay.portal.kernel.exception.SystemException { 2651 return getPersistence() 2652 .findByG_P_P_LtP_PrevAndNext(plid, groupId, privateLayout, 2653 parentLayoutId, priority, orderByComparator); 2654 } 2655 2656 /** 2657 * Returns all the layouts that the user has permission to view where groupId = ? and privateLayout = ? and parentLayoutId = ? and priority ≤ ?. 2658 * 2659 * @param groupId the group ID 2660 * @param privateLayout the private layout 2661 * @param parentLayoutId the parent layout ID 2662 * @param priority the priority 2663 * @return the matching layouts that the user has permission to view 2664 * @throws SystemException if a system exception occurred 2665 */ 2666 public static java.util.List<com.liferay.portal.model.Layout> filterFindByG_P_P_LtP( 2667 long groupId, boolean privateLayout, long parentLayoutId, int priority) 2668 throws com.liferay.portal.kernel.exception.SystemException { 2669 return getPersistence() 2670 .filterFindByG_P_P_LtP(groupId, privateLayout, 2671 parentLayoutId, priority); 2672 } 2673 2674 /** 2675 * Returns a range of all the layouts that the user has permission to view where groupId = ? and privateLayout = ? and parentLayoutId = ? and priority ≤ ?. 2676 * 2677 * <p> 2678 * 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. 2679 * </p> 2680 * 2681 * @param groupId the group ID 2682 * @param privateLayout the private layout 2683 * @param parentLayoutId the parent layout ID 2684 * @param priority the priority 2685 * @param start the lower bound of the range of layouts 2686 * @param end the upper bound of the range of layouts (not inclusive) 2687 * @return the range of matching layouts that the user has permission to view 2688 * @throws SystemException if a system exception occurred 2689 */ 2690 public static java.util.List<com.liferay.portal.model.Layout> filterFindByG_P_P_LtP( 2691 long groupId, boolean privateLayout, long parentLayoutId, int priority, 2692 int start, int end) 2693 throws com.liferay.portal.kernel.exception.SystemException { 2694 return getPersistence() 2695 .filterFindByG_P_P_LtP(groupId, privateLayout, 2696 parentLayoutId, priority, start, end); 2697 } 2698 2699 /** 2700 * Returns an ordered range of all the layouts that the user has permissions to view where groupId = ? and privateLayout = ? and parentLayoutId = ? and priority ≤ ?. 2701 * 2702 * <p> 2703 * 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. 2704 * </p> 2705 * 2706 * @param groupId the group ID 2707 * @param privateLayout the private layout 2708 * @param parentLayoutId the parent layout ID 2709 * @param priority the priority 2710 * @param start the lower bound of the range of layouts 2711 * @param end the upper bound of the range of layouts (not inclusive) 2712 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2713 * @return the ordered range of matching layouts that the user has permission to view 2714 * @throws SystemException if a system exception occurred 2715 */ 2716 public static java.util.List<com.liferay.portal.model.Layout> filterFindByG_P_P_LtP( 2717 long groupId, boolean privateLayout, long parentLayoutId, int priority, 2718 int start, int end, 2719 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2720 throws com.liferay.portal.kernel.exception.SystemException { 2721 return getPersistence() 2722 .filterFindByG_P_P_LtP(groupId, privateLayout, 2723 parentLayoutId, priority, start, end, orderByComparator); 2724 } 2725 2726 /** 2727 * 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 = ? and priority ≤ ?. 2728 * 2729 * @param plid the primary key of the current layout 2730 * @param groupId the group ID 2731 * @param privateLayout the private layout 2732 * @param parentLayoutId the parent layout ID 2733 * @param priority the priority 2734 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2735 * @return the previous, current, and next layout 2736 * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found 2737 * @throws SystemException if a system exception occurred 2738 */ 2739 public static com.liferay.portal.model.Layout[] filterFindByG_P_P_LtP_PrevAndNext( 2740 long plid, long groupId, boolean privateLayout, long parentLayoutId, 2741 int priority, 2742 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2743 throws com.liferay.portal.NoSuchLayoutException, 2744 com.liferay.portal.kernel.exception.SystemException { 2745 return getPersistence() 2746 .filterFindByG_P_P_LtP_PrevAndNext(plid, groupId, 2747 privateLayout, parentLayoutId, priority, orderByComparator); 2748 } 2749 2750 /** 2751 * Removes all the layouts where groupId = ? and privateLayout = ? and parentLayoutId = ? and priority ≤ ? from the database. 2752 * 2753 * @param groupId the group ID 2754 * @param privateLayout the private layout 2755 * @param parentLayoutId the parent layout ID 2756 * @param priority the priority 2757 * @throws SystemException if a system exception occurred 2758 */ 2759 public static void removeByG_P_P_LtP(long groupId, boolean privateLayout, 2760 long parentLayoutId, int priority) 2761 throws com.liferay.portal.kernel.exception.SystemException { 2762 getPersistence() 2763 .removeByG_P_P_LtP(groupId, privateLayout, parentLayoutId, priority); 2764 } 2765 2766 /** 2767 * Returns the number of layouts where groupId = ? and privateLayout = ? and parentLayoutId = ? and priority ≤ ?. 2768 * 2769 * @param groupId the group ID 2770 * @param privateLayout the private layout 2771 * @param parentLayoutId the parent layout ID 2772 * @param priority the priority 2773 * @return the number of matching layouts 2774 * @throws SystemException if a system exception occurred 2775 */ 2776 public static int countByG_P_P_LtP(long groupId, boolean privateLayout, 2777 long parentLayoutId, int priority) 2778 throws com.liferay.portal.kernel.exception.SystemException { 2779 return getPersistence() 2780 .countByG_P_P_LtP(groupId, privateLayout, parentLayoutId, 2781 priority); 2782 } 2783 2784 /** 2785 * Returns the number of layouts that the user has permission to view where groupId = ? and privateLayout = ? and parentLayoutId = ? and priority ≤ ?. 2786 * 2787 * @param groupId the group ID 2788 * @param privateLayout the private layout 2789 * @param parentLayoutId the parent layout ID 2790 * @param priority the priority 2791 * @return the number of matching layouts that the user has permission to view 2792 * @throws SystemException if a system exception occurred 2793 */ 2794 public static int filterCountByG_P_P_LtP(long groupId, 2795 boolean privateLayout, long parentLayoutId, int priority) 2796 throws com.liferay.portal.kernel.exception.SystemException { 2797 return getPersistence() 2798 .filterCountByG_P_P_LtP(groupId, privateLayout, 2799 parentLayoutId, priority); 2800 } 2801 2802 /** 2803 * Caches the layout in the entity cache if it is enabled. 2804 * 2805 * @param layout the layout 2806 */ 2807 public static void cacheResult(com.liferay.portal.model.Layout layout) { 2808 getPersistence().cacheResult(layout); 2809 } 2810 2811 /** 2812 * Caches the layouts in the entity cache if it is enabled. 2813 * 2814 * @param layouts the layouts 2815 */ 2816 public static void cacheResult( 2817 java.util.List<com.liferay.portal.model.Layout> layouts) { 2818 getPersistence().cacheResult(layouts); 2819 } 2820 2821 /** 2822 * Creates a new layout with the primary key. Does not add the layout to the database. 2823 * 2824 * @param plid the primary key for the new layout 2825 * @return the new layout 2826 */ 2827 public static com.liferay.portal.model.Layout create(long plid) { 2828 return getPersistence().create(plid); 2829 } 2830 2831 /** 2832 * Removes the layout with the primary key from the database. Also notifies the appropriate model listeners. 2833 * 2834 * @param plid the primary key of the layout 2835 * @return the layout that was removed 2836 * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found 2837 * @throws SystemException if a system exception occurred 2838 */ 2839 public static com.liferay.portal.model.Layout remove(long plid) 2840 throws com.liferay.portal.NoSuchLayoutException, 2841 com.liferay.portal.kernel.exception.SystemException { 2842 return getPersistence().remove(plid); 2843 } 2844 2845 public static com.liferay.portal.model.Layout updateImpl( 2846 com.liferay.portal.model.Layout layout) 2847 throws com.liferay.portal.kernel.exception.SystemException { 2848 return getPersistence().updateImpl(layout); 2849 } 2850 2851 /** 2852 * Returns the layout with the primary key or throws a {@link com.liferay.portal.NoSuchLayoutException} if it could not be found. 2853 * 2854 * @param plid the primary key of the layout 2855 * @return the layout 2856 * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found 2857 * @throws SystemException if a system exception occurred 2858 */ 2859 public static com.liferay.portal.model.Layout findByPrimaryKey(long plid) 2860 throws com.liferay.portal.NoSuchLayoutException, 2861 com.liferay.portal.kernel.exception.SystemException { 2862 return getPersistence().findByPrimaryKey(plid); 2863 } 2864 2865 /** 2866 * Returns the layout with the primary key or returns <code>null</code> if it could not be found. 2867 * 2868 * @param plid the primary key of the layout 2869 * @return the layout, or <code>null</code> if a layout with the primary key could not be found 2870 * @throws SystemException if a system exception occurred 2871 */ 2872 public static com.liferay.portal.model.Layout fetchByPrimaryKey(long plid) 2873 throws com.liferay.portal.kernel.exception.SystemException { 2874 return getPersistence().fetchByPrimaryKey(plid); 2875 } 2876 2877 /** 2878 * Returns all the layouts. 2879 * 2880 * @return the layouts 2881 * @throws SystemException if a system exception occurred 2882 */ 2883 public static java.util.List<com.liferay.portal.model.Layout> findAll() 2884 throws com.liferay.portal.kernel.exception.SystemException { 2885 return getPersistence().findAll(); 2886 } 2887 2888 /** 2889 * Returns a range of all the layouts. 2890 * 2891 * <p> 2892 * 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. 2893 * </p> 2894 * 2895 * @param start the lower bound of the range of layouts 2896 * @param end the upper bound of the range of layouts (not inclusive) 2897 * @return the range of layouts 2898 * @throws SystemException if a system exception occurred 2899 */ 2900 public static java.util.List<com.liferay.portal.model.Layout> findAll( 2901 int start, int end) 2902 throws com.liferay.portal.kernel.exception.SystemException { 2903 return getPersistence().findAll(start, end); 2904 } 2905 2906 /** 2907 * Returns an ordered range of all the layouts. 2908 * 2909 * <p> 2910 * 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. 2911 * </p> 2912 * 2913 * @param start the lower bound of the range of layouts 2914 * @param end the upper bound of the range of layouts (not inclusive) 2915 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2916 * @return the ordered range of layouts 2917 * @throws SystemException if a system exception occurred 2918 */ 2919 public static java.util.List<com.liferay.portal.model.Layout> findAll( 2920 int start, int end, 2921 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2922 throws com.liferay.portal.kernel.exception.SystemException { 2923 return getPersistence().findAll(start, end, orderByComparator); 2924 } 2925 2926 /** 2927 * Removes all the layouts from the database. 2928 * 2929 * @throws SystemException if a system exception occurred 2930 */ 2931 public static void removeAll() 2932 throws com.liferay.portal.kernel.exception.SystemException { 2933 getPersistence().removeAll(); 2934 } 2935 2936 /** 2937 * Returns the number of layouts. 2938 * 2939 * @return the number of layouts 2940 * @throws SystemException if a system exception occurred 2941 */ 2942 public static int countAll() 2943 throws com.liferay.portal.kernel.exception.SystemException { 2944 return getPersistence().countAll(); 2945 } 2946 2947 public static LayoutPersistence getPersistence() { 2948 if (_persistence == null) { 2949 _persistence = (LayoutPersistence)PortalBeanLocatorUtil.locate(LayoutPersistence.class.getName()); 2950 2951 ReferenceRegistry.registerReference(LayoutUtil.class, "_persistence"); 2952 } 2953 2954 return _persistence; 2955 } 2956 2957 /** 2958 * @deprecated As of 6.2.0 2959 */ 2960 public void setPersistence(LayoutPersistence persistence) { 2961 } 2962 2963 private static LayoutPersistence _persistence; 2964 }