001 /** 002 * Copyright (c) 2000-present Liferay, Inc. All rights reserved. 003 * 004 * This library is free software; you can redistribute it and/or modify it under 005 * the terms of the GNU Lesser General Public License as published by the Free 006 * Software Foundation; either version 2.1 of the License, or (at your option) 007 * any later version. 008 * 009 * This library is distributed in the hope that it will be useful, but WITHOUT 010 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 011 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more 012 * details. 013 */ 014 015 package com.liferay.portal.service.persistence; 016 017 import aQute.bnd.annotation.ProviderType; 018 019 import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil; 020 import com.liferay.portal.kernel.dao.orm.DynamicQuery; 021 import com.liferay.portal.kernel.util.OrderByComparator; 022 import com.liferay.portal.kernel.util.ReferenceRegistry; 023 import com.liferay.portal.model.RecentLayoutBranch; 024 import com.liferay.portal.service.ServiceContext; 025 026 import java.util.List; 027 028 /** 029 * The persistence utility for the recent layout branch service. This utility wraps {@link com.liferay.portal.service.persistence.impl.RecentLayoutBranchPersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class. 030 * 031 * <p> 032 * Caching information and settings can be found in <code>portal.properties</code> 033 * </p> 034 * 035 * @author Brian Wing Shun Chan 036 * @see RecentLayoutBranchPersistence 037 * @see com.liferay.portal.service.persistence.impl.RecentLayoutBranchPersistenceImpl 038 * @generated 039 */ 040 @ProviderType 041 public class RecentLayoutBranchUtil { 042 /* 043 * NOTE FOR DEVELOPERS: 044 * 045 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. 046 */ 047 048 /** 049 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 050 */ 051 public static void clearCache() { 052 getPersistence().clearCache(); 053 } 054 055 /** 056 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 057 */ 058 public static void clearCache(RecentLayoutBranch recentLayoutBranch) { 059 getPersistence().clearCache(recentLayoutBranch); 060 } 061 062 /** 063 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 064 */ 065 public static long countWithDynamicQuery(DynamicQuery dynamicQuery) { 066 return getPersistence().countWithDynamicQuery(dynamicQuery); 067 } 068 069 /** 070 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 071 */ 072 public static List<RecentLayoutBranch> findWithDynamicQuery( 073 DynamicQuery dynamicQuery) { 074 return getPersistence().findWithDynamicQuery(dynamicQuery); 075 } 076 077 /** 078 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 079 */ 080 public static List<RecentLayoutBranch> findWithDynamicQuery( 081 DynamicQuery dynamicQuery, int start, int end) { 082 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 083 } 084 085 /** 086 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 087 */ 088 public static List<RecentLayoutBranch> findWithDynamicQuery( 089 DynamicQuery dynamicQuery, int start, int end, 090 OrderByComparator<RecentLayoutBranch> orderByComparator) { 091 return getPersistence() 092 .findWithDynamicQuery(dynamicQuery, start, end, 093 orderByComparator); 094 } 095 096 /** 097 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel) 098 */ 099 public static RecentLayoutBranch update( 100 RecentLayoutBranch recentLayoutBranch) { 101 return getPersistence().update(recentLayoutBranch); 102 } 103 104 /** 105 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 106 */ 107 public static RecentLayoutBranch update( 108 RecentLayoutBranch recentLayoutBranch, ServiceContext serviceContext) { 109 return getPersistence().update(recentLayoutBranch, serviceContext); 110 } 111 112 /** 113 * Returns all the recent layout branchs where groupId = ?. 114 * 115 * @param groupId the group ID 116 * @return the matching recent layout branchs 117 */ 118 public static List<RecentLayoutBranch> findByGroupId(long groupId) { 119 return getPersistence().findByGroupId(groupId); 120 } 121 122 /** 123 * Returns a range of all the recent layout branchs where groupId = ?. 124 * 125 * <p> 126 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link RecentLayoutBranchModelImpl}. 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. 127 * </p> 128 * 129 * @param groupId the group ID 130 * @param start the lower bound of the range of recent layout branchs 131 * @param end the upper bound of the range of recent layout branchs (not inclusive) 132 * @return the range of matching recent layout branchs 133 */ 134 public static List<RecentLayoutBranch> findByGroupId(long groupId, 135 int start, int end) { 136 return getPersistence().findByGroupId(groupId, start, end); 137 } 138 139 /** 140 * Returns an ordered range of all the recent layout branchs where groupId = ?. 141 * 142 * <p> 143 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link RecentLayoutBranchModelImpl}. 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. 144 * </p> 145 * 146 * @param groupId the group ID 147 * @param start the lower bound of the range of recent layout branchs 148 * @param end the upper bound of the range of recent layout branchs (not inclusive) 149 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 150 * @return the ordered range of matching recent layout branchs 151 */ 152 public static List<RecentLayoutBranch> findByGroupId(long groupId, 153 int start, int end, 154 OrderByComparator<RecentLayoutBranch> orderByComparator) { 155 return getPersistence() 156 .findByGroupId(groupId, start, end, orderByComparator); 157 } 158 159 /** 160 * Returns an ordered range of all the recent layout branchs where groupId = ?. 161 * 162 * <p> 163 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link RecentLayoutBranchModelImpl}. 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. 164 * </p> 165 * 166 * @param groupId the group ID 167 * @param start the lower bound of the range of recent layout branchs 168 * @param end the upper bound of the range of recent layout branchs (not inclusive) 169 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 170 * @param retrieveFromCache whether to retrieve from the finder cache 171 * @return the ordered range of matching recent layout branchs 172 */ 173 public static List<RecentLayoutBranch> findByGroupId(long groupId, 174 int start, int end, 175 OrderByComparator<RecentLayoutBranch> orderByComparator, 176 boolean retrieveFromCache) { 177 return getPersistence() 178 .findByGroupId(groupId, start, end, orderByComparator, 179 retrieveFromCache); 180 } 181 182 /** 183 * Returns the first recent layout branch in the ordered set where groupId = ?. 184 * 185 * @param groupId the group ID 186 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 187 * @return the first matching recent layout branch 188 * @throws NoSuchRecentLayoutBranchException if a matching recent layout branch could not be found 189 */ 190 public static RecentLayoutBranch findByGroupId_First(long groupId, 191 OrderByComparator<RecentLayoutBranch> orderByComparator) 192 throws com.liferay.portal.exception.NoSuchRecentLayoutBranchException { 193 return getPersistence().findByGroupId_First(groupId, orderByComparator); 194 } 195 196 /** 197 * Returns the first recent layout branch in the ordered set where groupId = ?. 198 * 199 * @param groupId the group ID 200 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 201 * @return the first matching recent layout branch, or <code>null</code> if a matching recent layout branch could not be found 202 */ 203 public static RecentLayoutBranch fetchByGroupId_First(long groupId, 204 OrderByComparator<RecentLayoutBranch> orderByComparator) { 205 return getPersistence().fetchByGroupId_First(groupId, orderByComparator); 206 } 207 208 /** 209 * Returns the last recent layout branch in the ordered set where groupId = ?. 210 * 211 * @param groupId the group ID 212 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 213 * @return the last matching recent layout branch 214 * @throws NoSuchRecentLayoutBranchException if a matching recent layout branch could not be found 215 */ 216 public static RecentLayoutBranch findByGroupId_Last(long groupId, 217 OrderByComparator<RecentLayoutBranch> orderByComparator) 218 throws com.liferay.portal.exception.NoSuchRecentLayoutBranchException { 219 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 220 } 221 222 /** 223 * Returns the last recent layout branch in the ordered set where groupId = ?. 224 * 225 * @param groupId the group ID 226 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 227 * @return the last matching recent layout branch, or <code>null</code> if a matching recent layout branch could not be found 228 */ 229 public static RecentLayoutBranch fetchByGroupId_Last(long groupId, 230 OrderByComparator<RecentLayoutBranch> orderByComparator) { 231 return getPersistence().fetchByGroupId_Last(groupId, orderByComparator); 232 } 233 234 /** 235 * Returns the recent layout branchs before and after the current recent layout branch in the ordered set where groupId = ?. 236 * 237 * @param recentLayoutBranchId the primary key of the current recent layout branch 238 * @param groupId the group ID 239 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 240 * @return the previous, current, and next recent layout branch 241 * @throws NoSuchRecentLayoutBranchException if a recent layout branch with the primary key could not be found 242 */ 243 public static RecentLayoutBranch[] findByGroupId_PrevAndNext( 244 long recentLayoutBranchId, long groupId, 245 OrderByComparator<RecentLayoutBranch> orderByComparator) 246 throws com.liferay.portal.exception.NoSuchRecentLayoutBranchException { 247 return getPersistence() 248 .findByGroupId_PrevAndNext(recentLayoutBranchId, groupId, 249 orderByComparator); 250 } 251 252 /** 253 * Removes all the recent layout branchs where groupId = ? from the database. 254 * 255 * @param groupId the group ID 256 */ 257 public static void removeByGroupId(long groupId) { 258 getPersistence().removeByGroupId(groupId); 259 } 260 261 /** 262 * Returns the number of recent layout branchs where groupId = ?. 263 * 264 * @param groupId the group ID 265 * @return the number of matching recent layout branchs 266 */ 267 public static int countByGroupId(long groupId) { 268 return getPersistence().countByGroupId(groupId); 269 } 270 271 /** 272 * Returns all the recent layout branchs where userId = ?. 273 * 274 * @param userId the user ID 275 * @return the matching recent layout branchs 276 */ 277 public static List<RecentLayoutBranch> findByUserId(long userId) { 278 return getPersistence().findByUserId(userId); 279 } 280 281 /** 282 * Returns a range of all the recent layout branchs where userId = ?. 283 * 284 * <p> 285 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link RecentLayoutBranchModelImpl}. 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. 286 * </p> 287 * 288 * @param userId the user ID 289 * @param start the lower bound of the range of recent layout branchs 290 * @param end the upper bound of the range of recent layout branchs (not inclusive) 291 * @return the range of matching recent layout branchs 292 */ 293 public static List<RecentLayoutBranch> findByUserId(long userId, int start, 294 int end) { 295 return getPersistence().findByUserId(userId, start, end); 296 } 297 298 /** 299 * Returns an ordered range of all the recent layout branchs where userId = ?. 300 * 301 * <p> 302 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link RecentLayoutBranchModelImpl}. 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. 303 * </p> 304 * 305 * @param userId the user ID 306 * @param start the lower bound of the range of recent layout branchs 307 * @param end the upper bound of the range of recent layout branchs (not inclusive) 308 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 309 * @return the ordered range of matching recent layout branchs 310 */ 311 public static List<RecentLayoutBranch> findByUserId(long userId, int start, 312 int end, OrderByComparator<RecentLayoutBranch> orderByComparator) { 313 return getPersistence() 314 .findByUserId(userId, start, end, orderByComparator); 315 } 316 317 /** 318 * Returns an ordered range of all the recent layout branchs where userId = ?. 319 * 320 * <p> 321 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link RecentLayoutBranchModelImpl}. 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. 322 * </p> 323 * 324 * @param userId the user ID 325 * @param start the lower bound of the range of recent layout branchs 326 * @param end the upper bound of the range of recent layout branchs (not inclusive) 327 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 328 * @param retrieveFromCache whether to retrieve from the finder cache 329 * @return the ordered range of matching recent layout branchs 330 */ 331 public static List<RecentLayoutBranch> findByUserId(long userId, int start, 332 int end, OrderByComparator<RecentLayoutBranch> orderByComparator, 333 boolean retrieveFromCache) { 334 return getPersistence() 335 .findByUserId(userId, start, end, orderByComparator, 336 retrieveFromCache); 337 } 338 339 /** 340 * Returns the first recent layout branch in the ordered set where userId = ?. 341 * 342 * @param userId the user ID 343 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 344 * @return the first matching recent layout branch 345 * @throws NoSuchRecentLayoutBranchException if a matching recent layout branch could not be found 346 */ 347 public static RecentLayoutBranch findByUserId_First(long userId, 348 OrderByComparator<RecentLayoutBranch> orderByComparator) 349 throws com.liferay.portal.exception.NoSuchRecentLayoutBranchException { 350 return getPersistence().findByUserId_First(userId, orderByComparator); 351 } 352 353 /** 354 * Returns the first recent layout branch in the ordered set where userId = ?. 355 * 356 * @param userId the user ID 357 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 358 * @return the first matching recent layout branch, or <code>null</code> if a matching recent layout branch could not be found 359 */ 360 public static RecentLayoutBranch fetchByUserId_First(long userId, 361 OrderByComparator<RecentLayoutBranch> orderByComparator) { 362 return getPersistence().fetchByUserId_First(userId, orderByComparator); 363 } 364 365 /** 366 * Returns the last recent layout branch in the ordered set where userId = ?. 367 * 368 * @param userId the user ID 369 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 370 * @return the last matching recent layout branch 371 * @throws NoSuchRecentLayoutBranchException if a matching recent layout branch could not be found 372 */ 373 public static RecentLayoutBranch findByUserId_Last(long userId, 374 OrderByComparator<RecentLayoutBranch> orderByComparator) 375 throws com.liferay.portal.exception.NoSuchRecentLayoutBranchException { 376 return getPersistence().findByUserId_Last(userId, orderByComparator); 377 } 378 379 /** 380 * Returns the last recent layout branch in the ordered set where userId = ?. 381 * 382 * @param userId the user ID 383 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 384 * @return the last matching recent layout branch, or <code>null</code> if a matching recent layout branch could not be found 385 */ 386 public static RecentLayoutBranch fetchByUserId_Last(long userId, 387 OrderByComparator<RecentLayoutBranch> orderByComparator) { 388 return getPersistence().fetchByUserId_Last(userId, orderByComparator); 389 } 390 391 /** 392 * Returns the recent layout branchs before and after the current recent layout branch in the ordered set where userId = ?. 393 * 394 * @param recentLayoutBranchId the primary key of the current recent layout branch 395 * @param userId the user ID 396 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 397 * @return the previous, current, and next recent layout branch 398 * @throws NoSuchRecentLayoutBranchException if a recent layout branch with the primary key could not be found 399 */ 400 public static RecentLayoutBranch[] findByUserId_PrevAndNext( 401 long recentLayoutBranchId, long userId, 402 OrderByComparator<RecentLayoutBranch> orderByComparator) 403 throws com.liferay.portal.exception.NoSuchRecentLayoutBranchException { 404 return getPersistence() 405 .findByUserId_PrevAndNext(recentLayoutBranchId, userId, 406 orderByComparator); 407 } 408 409 /** 410 * Removes all the recent layout branchs where userId = ? from the database. 411 * 412 * @param userId the user ID 413 */ 414 public static void removeByUserId(long userId) { 415 getPersistence().removeByUserId(userId); 416 } 417 418 /** 419 * Returns the number of recent layout branchs where userId = ?. 420 * 421 * @param userId the user ID 422 * @return the number of matching recent layout branchs 423 */ 424 public static int countByUserId(long userId) { 425 return getPersistence().countByUserId(userId); 426 } 427 428 /** 429 * Returns all the recent layout branchs where layoutBranchId = ?. 430 * 431 * @param layoutBranchId the layout branch ID 432 * @return the matching recent layout branchs 433 */ 434 public static List<RecentLayoutBranch> findByLayoutBranchId( 435 long layoutBranchId) { 436 return getPersistence().findByLayoutBranchId(layoutBranchId); 437 } 438 439 /** 440 * Returns a range of all the recent layout branchs where layoutBranchId = ?. 441 * 442 * <p> 443 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link RecentLayoutBranchModelImpl}. 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. 444 * </p> 445 * 446 * @param layoutBranchId the layout branch ID 447 * @param start the lower bound of the range of recent layout branchs 448 * @param end the upper bound of the range of recent layout branchs (not inclusive) 449 * @return the range of matching recent layout branchs 450 */ 451 public static List<RecentLayoutBranch> findByLayoutBranchId( 452 long layoutBranchId, int start, int end) { 453 return getPersistence().findByLayoutBranchId(layoutBranchId, start, end); 454 } 455 456 /** 457 * Returns an ordered range of all the recent layout branchs where layoutBranchId = ?. 458 * 459 * <p> 460 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link RecentLayoutBranchModelImpl}. 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. 461 * </p> 462 * 463 * @param layoutBranchId the layout branch ID 464 * @param start the lower bound of the range of recent layout branchs 465 * @param end the upper bound of the range of recent layout branchs (not inclusive) 466 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 467 * @return the ordered range of matching recent layout branchs 468 */ 469 public static List<RecentLayoutBranch> findByLayoutBranchId( 470 long layoutBranchId, int start, int end, 471 OrderByComparator<RecentLayoutBranch> orderByComparator) { 472 return getPersistence() 473 .findByLayoutBranchId(layoutBranchId, start, end, 474 orderByComparator); 475 } 476 477 /** 478 * Returns an ordered range of all the recent layout branchs where layoutBranchId = ?. 479 * 480 * <p> 481 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link RecentLayoutBranchModelImpl}. 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. 482 * </p> 483 * 484 * @param layoutBranchId the layout branch ID 485 * @param start the lower bound of the range of recent layout branchs 486 * @param end the upper bound of the range of recent layout branchs (not inclusive) 487 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 488 * @param retrieveFromCache whether to retrieve from the finder cache 489 * @return the ordered range of matching recent layout branchs 490 */ 491 public static List<RecentLayoutBranch> findByLayoutBranchId( 492 long layoutBranchId, int start, int end, 493 OrderByComparator<RecentLayoutBranch> orderByComparator, 494 boolean retrieveFromCache) { 495 return getPersistence() 496 .findByLayoutBranchId(layoutBranchId, start, end, 497 orderByComparator, retrieveFromCache); 498 } 499 500 /** 501 * Returns the first recent layout branch in the ordered set where layoutBranchId = ?. 502 * 503 * @param layoutBranchId the layout branch ID 504 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 505 * @return the first matching recent layout branch 506 * @throws NoSuchRecentLayoutBranchException if a matching recent layout branch could not be found 507 */ 508 public static RecentLayoutBranch findByLayoutBranchId_First( 509 long layoutBranchId, 510 OrderByComparator<RecentLayoutBranch> orderByComparator) 511 throws com.liferay.portal.exception.NoSuchRecentLayoutBranchException { 512 return getPersistence() 513 .findByLayoutBranchId_First(layoutBranchId, orderByComparator); 514 } 515 516 /** 517 * Returns the first recent layout branch in the ordered set where layoutBranchId = ?. 518 * 519 * @param layoutBranchId the layout branch ID 520 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 521 * @return the first matching recent layout branch, or <code>null</code> if a matching recent layout branch could not be found 522 */ 523 public static RecentLayoutBranch fetchByLayoutBranchId_First( 524 long layoutBranchId, 525 OrderByComparator<RecentLayoutBranch> orderByComparator) { 526 return getPersistence() 527 .fetchByLayoutBranchId_First(layoutBranchId, 528 orderByComparator); 529 } 530 531 /** 532 * Returns the last recent layout branch in the ordered set where layoutBranchId = ?. 533 * 534 * @param layoutBranchId the layout branch ID 535 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 536 * @return the last matching recent layout branch 537 * @throws NoSuchRecentLayoutBranchException if a matching recent layout branch could not be found 538 */ 539 public static RecentLayoutBranch findByLayoutBranchId_Last( 540 long layoutBranchId, 541 OrderByComparator<RecentLayoutBranch> orderByComparator) 542 throws com.liferay.portal.exception.NoSuchRecentLayoutBranchException { 543 return getPersistence() 544 .findByLayoutBranchId_Last(layoutBranchId, orderByComparator); 545 } 546 547 /** 548 * Returns the last recent layout branch in the ordered set where layoutBranchId = ?. 549 * 550 * @param layoutBranchId the layout branch ID 551 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 552 * @return the last matching recent layout branch, or <code>null</code> if a matching recent layout branch could not be found 553 */ 554 public static RecentLayoutBranch fetchByLayoutBranchId_Last( 555 long layoutBranchId, 556 OrderByComparator<RecentLayoutBranch> orderByComparator) { 557 return getPersistence() 558 .fetchByLayoutBranchId_Last(layoutBranchId, orderByComparator); 559 } 560 561 /** 562 * Returns the recent layout branchs before and after the current recent layout branch in the ordered set where layoutBranchId = ?. 563 * 564 * @param recentLayoutBranchId the primary key of the current recent layout branch 565 * @param layoutBranchId the layout branch ID 566 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 567 * @return the previous, current, and next recent layout branch 568 * @throws NoSuchRecentLayoutBranchException if a recent layout branch with the primary key could not be found 569 */ 570 public static RecentLayoutBranch[] findByLayoutBranchId_PrevAndNext( 571 long recentLayoutBranchId, long layoutBranchId, 572 OrderByComparator<RecentLayoutBranch> orderByComparator) 573 throws com.liferay.portal.exception.NoSuchRecentLayoutBranchException { 574 return getPersistence() 575 .findByLayoutBranchId_PrevAndNext(recentLayoutBranchId, 576 layoutBranchId, orderByComparator); 577 } 578 579 /** 580 * Removes all the recent layout branchs where layoutBranchId = ? from the database. 581 * 582 * @param layoutBranchId the layout branch ID 583 */ 584 public static void removeByLayoutBranchId(long layoutBranchId) { 585 getPersistence().removeByLayoutBranchId(layoutBranchId); 586 } 587 588 /** 589 * Returns the number of recent layout branchs where layoutBranchId = ?. 590 * 591 * @param layoutBranchId the layout branch ID 592 * @return the number of matching recent layout branchs 593 */ 594 public static int countByLayoutBranchId(long layoutBranchId) { 595 return getPersistence().countByLayoutBranchId(layoutBranchId); 596 } 597 598 /** 599 * Returns the recent layout branch where userId = ? and layoutSetBranchId = ? and plid = ? or throws a {@link NoSuchRecentLayoutBranchException} if it could not be found. 600 * 601 * @param userId the user ID 602 * @param layoutSetBranchId the layout set branch ID 603 * @param plid the plid 604 * @return the matching recent layout branch 605 * @throws NoSuchRecentLayoutBranchException if a matching recent layout branch could not be found 606 */ 607 public static RecentLayoutBranch findByU_L_P(long userId, 608 long layoutSetBranchId, long plid) 609 throws com.liferay.portal.exception.NoSuchRecentLayoutBranchException { 610 return getPersistence().findByU_L_P(userId, layoutSetBranchId, plid); 611 } 612 613 /** 614 * Returns the recent layout branch where userId = ? and layoutSetBranchId = ? and plid = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 615 * 616 * @param userId the user ID 617 * @param layoutSetBranchId the layout set branch ID 618 * @param plid the plid 619 * @return the matching recent layout branch, or <code>null</code> if a matching recent layout branch could not be found 620 */ 621 public static RecentLayoutBranch fetchByU_L_P(long userId, 622 long layoutSetBranchId, long plid) { 623 return getPersistence().fetchByU_L_P(userId, layoutSetBranchId, plid); 624 } 625 626 /** 627 * Returns the recent layout branch where userId = ? and layoutSetBranchId = ? and plid = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 628 * 629 * @param userId the user ID 630 * @param layoutSetBranchId the layout set branch ID 631 * @param plid the plid 632 * @param retrieveFromCache whether to retrieve from the finder cache 633 * @return the matching recent layout branch, or <code>null</code> if a matching recent layout branch could not be found 634 */ 635 public static RecentLayoutBranch fetchByU_L_P(long userId, 636 long layoutSetBranchId, long plid, boolean retrieveFromCache) { 637 return getPersistence() 638 .fetchByU_L_P(userId, layoutSetBranchId, plid, 639 retrieveFromCache); 640 } 641 642 /** 643 * Removes the recent layout branch where userId = ? and layoutSetBranchId = ? and plid = ? from the database. 644 * 645 * @param userId the user ID 646 * @param layoutSetBranchId the layout set branch ID 647 * @param plid the plid 648 * @return the recent layout branch that was removed 649 */ 650 public static RecentLayoutBranch removeByU_L_P(long userId, 651 long layoutSetBranchId, long plid) 652 throws com.liferay.portal.exception.NoSuchRecentLayoutBranchException { 653 return getPersistence().removeByU_L_P(userId, layoutSetBranchId, plid); 654 } 655 656 /** 657 * Returns the number of recent layout branchs where userId = ? and layoutSetBranchId = ? and plid = ?. 658 * 659 * @param userId the user ID 660 * @param layoutSetBranchId the layout set branch ID 661 * @param plid the plid 662 * @return the number of matching recent layout branchs 663 */ 664 public static int countByU_L_P(long userId, long layoutSetBranchId, 665 long plid) { 666 return getPersistence().countByU_L_P(userId, layoutSetBranchId, plid); 667 } 668 669 /** 670 * Caches the recent layout branch in the entity cache if it is enabled. 671 * 672 * @param recentLayoutBranch the recent layout branch 673 */ 674 public static void cacheResult(RecentLayoutBranch recentLayoutBranch) { 675 getPersistence().cacheResult(recentLayoutBranch); 676 } 677 678 /** 679 * Caches the recent layout branchs in the entity cache if it is enabled. 680 * 681 * @param recentLayoutBranchs the recent layout branchs 682 */ 683 public static void cacheResult(List<RecentLayoutBranch> recentLayoutBranchs) { 684 getPersistence().cacheResult(recentLayoutBranchs); 685 } 686 687 /** 688 * Creates a new recent layout branch with the primary key. Does not add the recent layout branch to the database. 689 * 690 * @param recentLayoutBranchId the primary key for the new recent layout branch 691 * @return the new recent layout branch 692 */ 693 public static RecentLayoutBranch create(long recentLayoutBranchId) { 694 return getPersistence().create(recentLayoutBranchId); 695 } 696 697 /** 698 * Removes the recent layout branch with the primary key from the database. Also notifies the appropriate model listeners. 699 * 700 * @param recentLayoutBranchId the primary key of the recent layout branch 701 * @return the recent layout branch that was removed 702 * @throws NoSuchRecentLayoutBranchException if a recent layout branch with the primary key could not be found 703 */ 704 public static RecentLayoutBranch remove(long recentLayoutBranchId) 705 throws com.liferay.portal.exception.NoSuchRecentLayoutBranchException { 706 return getPersistence().remove(recentLayoutBranchId); 707 } 708 709 public static RecentLayoutBranch updateImpl( 710 RecentLayoutBranch recentLayoutBranch) { 711 return getPersistence().updateImpl(recentLayoutBranch); 712 } 713 714 /** 715 * Returns the recent layout branch with the primary key or throws a {@link NoSuchRecentLayoutBranchException} if it could not be found. 716 * 717 * @param recentLayoutBranchId the primary key of the recent layout branch 718 * @return the recent layout branch 719 * @throws NoSuchRecentLayoutBranchException if a recent layout branch with the primary key could not be found 720 */ 721 public static RecentLayoutBranch findByPrimaryKey(long recentLayoutBranchId) 722 throws com.liferay.portal.exception.NoSuchRecentLayoutBranchException { 723 return getPersistence().findByPrimaryKey(recentLayoutBranchId); 724 } 725 726 /** 727 * Returns the recent layout branch with the primary key or returns <code>null</code> if it could not be found. 728 * 729 * @param recentLayoutBranchId the primary key of the recent layout branch 730 * @return the recent layout branch, or <code>null</code> if a recent layout branch with the primary key could not be found 731 */ 732 public static RecentLayoutBranch fetchByPrimaryKey( 733 long recentLayoutBranchId) { 734 return getPersistence().fetchByPrimaryKey(recentLayoutBranchId); 735 } 736 737 public static java.util.Map<java.io.Serializable, RecentLayoutBranch> fetchByPrimaryKeys( 738 java.util.Set<java.io.Serializable> primaryKeys) { 739 return getPersistence().fetchByPrimaryKeys(primaryKeys); 740 } 741 742 /** 743 * Returns all the recent layout branchs. 744 * 745 * @return the recent layout branchs 746 */ 747 public static List<RecentLayoutBranch> findAll() { 748 return getPersistence().findAll(); 749 } 750 751 /** 752 * Returns a range of all the recent layout branchs. 753 * 754 * <p> 755 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link RecentLayoutBranchModelImpl}. 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. 756 * </p> 757 * 758 * @param start the lower bound of the range of recent layout branchs 759 * @param end the upper bound of the range of recent layout branchs (not inclusive) 760 * @return the range of recent layout branchs 761 */ 762 public static List<RecentLayoutBranch> findAll(int start, int end) { 763 return getPersistence().findAll(start, end); 764 } 765 766 /** 767 * Returns an ordered range of all the recent layout branchs. 768 * 769 * <p> 770 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link RecentLayoutBranchModelImpl}. 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. 771 * </p> 772 * 773 * @param start the lower bound of the range of recent layout branchs 774 * @param end the upper bound of the range of recent layout branchs (not inclusive) 775 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 776 * @return the ordered range of recent layout branchs 777 */ 778 public static List<RecentLayoutBranch> findAll(int start, int end, 779 OrderByComparator<RecentLayoutBranch> orderByComparator) { 780 return getPersistence().findAll(start, end, orderByComparator); 781 } 782 783 /** 784 * Returns an ordered range of all the recent layout branchs. 785 * 786 * <p> 787 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link RecentLayoutBranchModelImpl}. 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. 788 * </p> 789 * 790 * @param start the lower bound of the range of recent layout branchs 791 * @param end the upper bound of the range of recent layout branchs (not inclusive) 792 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 793 * @param retrieveFromCache whether to retrieve from the finder cache 794 * @return the ordered range of recent layout branchs 795 */ 796 public static List<RecentLayoutBranch> findAll(int start, int end, 797 OrderByComparator<RecentLayoutBranch> orderByComparator, 798 boolean retrieveFromCache) { 799 return getPersistence() 800 .findAll(start, end, orderByComparator, retrieveFromCache); 801 } 802 803 /** 804 * Removes all the recent layout branchs from the database. 805 */ 806 public static void removeAll() { 807 getPersistence().removeAll(); 808 } 809 810 /** 811 * Returns the number of recent layout branchs. 812 * 813 * @return the number of recent layout branchs 814 */ 815 public static int countAll() { 816 return getPersistence().countAll(); 817 } 818 819 public static RecentLayoutBranchPersistence getPersistence() { 820 if (_persistence == null) { 821 _persistence = (RecentLayoutBranchPersistence)PortalBeanLocatorUtil.locate(RecentLayoutBranchPersistence.class.getName()); 822 823 ReferenceRegistry.registerReference(RecentLayoutBranchUtil.class, 824 "_persistence"); 825 } 826 827 return _persistence; 828 } 829 830 private static RecentLayoutBranchPersistence _persistence; 831 }