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.RecentLayoutSetBranch; 024 import com.liferay.portal.service.ServiceContext; 025 026 import java.util.List; 027 028 /** 029 * The persistence utility for the recent layout set branch service. This utility wraps {@link com.liferay.portal.service.persistence.impl.RecentLayoutSetBranchPersistenceImpl} 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 RecentLayoutSetBranchPersistence 037 * @see com.liferay.portal.service.persistence.impl.RecentLayoutSetBranchPersistenceImpl 038 * @generated 039 */ 040 @ProviderType 041 public class RecentLayoutSetBranchUtil { 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(RecentLayoutSetBranch recentLayoutSetBranch) { 059 getPersistence().clearCache(recentLayoutSetBranch); 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<RecentLayoutSetBranch> 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<RecentLayoutSetBranch> 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<RecentLayoutSetBranch> findWithDynamicQuery( 089 DynamicQuery dynamicQuery, int start, int end, 090 OrderByComparator<RecentLayoutSetBranch> 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 RecentLayoutSetBranch update( 100 RecentLayoutSetBranch recentLayoutSetBranch) { 101 return getPersistence().update(recentLayoutSetBranch); 102 } 103 104 /** 105 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 106 */ 107 public static RecentLayoutSetBranch update( 108 RecentLayoutSetBranch recentLayoutSetBranch, 109 ServiceContext serviceContext) { 110 return getPersistence().update(recentLayoutSetBranch, serviceContext); 111 } 112 113 /** 114 * Returns all the recent layout set branchs where groupId = ?. 115 * 116 * @param groupId the group ID 117 * @return the matching recent layout set branchs 118 */ 119 public static List<RecentLayoutSetBranch> findByGroupId(long groupId) { 120 return getPersistence().findByGroupId(groupId); 121 } 122 123 /** 124 * Returns a range of all the recent layout set branchs where groupId = ?. 125 * 126 * <p> 127 * 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 RecentLayoutSetBranchModelImpl}. 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. 128 * </p> 129 * 130 * @param groupId the group ID 131 * @param start the lower bound of the range of recent layout set branchs 132 * @param end the upper bound of the range of recent layout set branchs (not inclusive) 133 * @return the range of matching recent layout set branchs 134 */ 135 public static List<RecentLayoutSetBranch> findByGroupId(long groupId, 136 int start, int end) { 137 return getPersistence().findByGroupId(groupId, start, end); 138 } 139 140 /** 141 * Returns an ordered range of all the recent layout set branchs where groupId = ?. 142 * 143 * <p> 144 * 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 RecentLayoutSetBranchModelImpl}. 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. 145 * </p> 146 * 147 * @param groupId the group ID 148 * @param start the lower bound of the range of recent layout set branchs 149 * @param end the upper bound of the range of recent layout set branchs (not inclusive) 150 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 151 * @return the ordered range of matching recent layout set branchs 152 */ 153 public static List<RecentLayoutSetBranch> findByGroupId(long groupId, 154 int start, int end, 155 OrderByComparator<RecentLayoutSetBranch> orderByComparator) { 156 return getPersistence() 157 .findByGroupId(groupId, start, end, orderByComparator); 158 } 159 160 /** 161 * Returns an ordered range of all the recent layout set branchs where groupId = ?. 162 * 163 * <p> 164 * 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 RecentLayoutSetBranchModelImpl}. 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. 165 * </p> 166 * 167 * @param groupId the group ID 168 * @param start the lower bound of the range of recent layout set branchs 169 * @param end the upper bound of the range of recent layout set branchs (not inclusive) 170 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 171 * @param retrieveFromCache whether to retrieve from the finder cache 172 * @return the ordered range of matching recent layout set branchs 173 */ 174 public static List<RecentLayoutSetBranch> findByGroupId(long groupId, 175 int start, int end, 176 OrderByComparator<RecentLayoutSetBranch> orderByComparator, 177 boolean retrieveFromCache) { 178 return getPersistence() 179 .findByGroupId(groupId, start, end, orderByComparator, 180 retrieveFromCache); 181 } 182 183 /** 184 * Returns the first recent layout set branch in the ordered set where groupId = ?. 185 * 186 * @param groupId the group ID 187 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 188 * @return the first matching recent layout set branch 189 * @throws NoSuchRecentLayoutSetBranchException if a matching recent layout set branch could not be found 190 */ 191 public static RecentLayoutSetBranch findByGroupId_First(long groupId, 192 OrderByComparator<RecentLayoutSetBranch> orderByComparator) 193 throws com.liferay.portal.exception.NoSuchRecentLayoutSetBranchException { 194 return getPersistence().findByGroupId_First(groupId, orderByComparator); 195 } 196 197 /** 198 * Returns the first recent layout set branch in the ordered set where groupId = ?. 199 * 200 * @param groupId the group ID 201 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 202 * @return the first matching recent layout set branch, or <code>null</code> if a matching recent layout set branch could not be found 203 */ 204 public static RecentLayoutSetBranch fetchByGroupId_First(long groupId, 205 OrderByComparator<RecentLayoutSetBranch> orderByComparator) { 206 return getPersistence().fetchByGroupId_First(groupId, orderByComparator); 207 } 208 209 /** 210 * Returns the last recent layout set branch in the ordered set where groupId = ?. 211 * 212 * @param groupId the group ID 213 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 214 * @return the last matching recent layout set branch 215 * @throws NoSuchRecentLayoutSetBranchException if a matching recent layout set branch could not be found 216 */ 217 public static RecentLayoutSetBranch findByGroupId_Last(long groupId, 218 OrderByComparator<RecentLayoutSetBranch> orderByComparator) 219 throws com.liferay.portal.exception.NoSuchRecentLayoutSetBranchException { 220 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 221 } 222 223 /** 224 * Returns the last recent layout set branch in the ordered set where groupId = ?. 225 * 226 * @param groupId the group ID 227 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 228 * @return the last matching recent layout set branch, or <code>null</code> if a matching recent layout set branch could not be found 229 */ 230 public static RecentLayoutSetBranch fetchByGroupId_Last(long groupId, 231 OrderByComparator<RecentLayoutSetBranch> orderByComparator) { 232 return getPersistence().fetchByGroupId_Last(groupId, orderByComparator); 233 } 234 235 /** 236 * Returns the recent layout set branchs before and after the current recent layout set branch in the ordered set where groupId = ?. 237 * 238 * @param recentLayoutSetBranchId the primary key of the current recent layout set branch 239 * @param groupId the group ID 240 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 241 * @return the previous, current, and next recent layout set branch 242 * @throws NoSuchRecentLayoutSetBranchException if a recent layout set branch with the primary key could not be found 243 */ 244 public static RecentLayoutSetBranch[] findByGroupId_PrevAndNext( 245 long recentLayoutSetBranchId, long groupId, 246 OrderByComparator<RecentLayoutSetBranch> orderByComparator) 247 throws com.liferay.portal.exception.NoSuchRecentLayoutSetBranchException { 248 return getPersistence() 249 .findByGroupId_PrevAndNext(recentLayoutSetBranchId, groupId, 250 orderByComparator); 251 } 252 253 /** 254 * Removes all the recent layout set branchs where groupId = ? from the database. 255 * 256 * @param groupId the group ID 257 */ 258 public static void removeByGroupId(long groupId) { 259 getPersistence().removeByGroupId(groupId); 260 } 261 262 /** 263 * Returns the number of recent layout set branchs where groupId = ?. 264 * 265 * @param groupId the group ID 266 * @return the number of matching recent layout set branchs 267 */ 268 public static int countByGroupId(long groupId) { 269 return getPersistence().countByGroupId(groupId); 270 } 271 272 /** 273 * Returns all the recent layout set branchs where userId = ?. 274 * 275 * @param userId the user ID 276 * @return the matching recent layout set branchs 277 */ 278 public static List<RecentLayoutSetBranch> findByUserId(long userId) { 279 return getPersistence().findByUserId(userId); 280 } 281 282 /** 283 * Returns a range of all the recent layout set branchs where userId = ?. 284 * 285 * <p> 286 * 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 RecentLayoutSetBranchModelImpl}. 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. 287 * </p> 288 * 289 * @param userId the user ID 290 * @param start the lower bound of the range of recent layout set branchs 291 * @param end the upper bound of the range of recent layout set branchs (not inclusive) 292 * @return the range of matching recent layout set branchs 293 */ 294 public static List<RecentLayoutSetBranch> findByUserId(long userId, 295 int start, int end) { 296 return getPersistence().findByUserId(userId, start, end); 297 } 298 299 /** 300 * Returns an ordered range of all the recent layout set branchs where userId = ?. 301 * 302 * <p> 303 * 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 RecentLayoutSetBranchModelImpl}. 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. 304 * </p> 305 * 306 * @param userId the user ID 307 * @param start the lower bound of the range of recent layout set branchs 308 * @param end the upper bound of the range of recent layout set branchs (not inclusive) 309 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 310 * @return the ordered range of matching recent layout set branchs 311 */ 312 public static List<RecentLayoutSetBranch> findByUserId(long userId, 313 int start, int end, 314 OrderByComparator<RecentLayoutSetBranch> orderByComparator) { 315 return getPersistence() 316 .findByUserId(userId, start, end, orderByComparator); 317 } 318 319 /** 320 * Returns an ordered range of all the recent layout set branchs where userId = ?. 321 * 322 * <p> 323 * 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 RecentLayoutSetBranchModelImpl}. 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. 324 * </p> 325 * 326 * @param userId the user ID 327 * @param start the lower bound of the range of recent layout set branchs 328 * @param end the upper bound of the range of recent layout set branchs (not inclusive) 329 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 330 * @param retrieveFromCache whether to retrieve from the finder cache 331 * @return the ordered range of matching recent layout set branchs 332 */ 333 public static List<RecentLayoutSetBranch> findByUserId(long userId, 334 int start, int end, 335 OrderByComparator<RecentLayoutSetBranch> orderByComparator, 336 boolean retrieveFromCache) { 337 return getPersistence() 338 .findByUserId(userId, start, end, orderByComparator, 339 retrieveFromCache); 340 } 341 342 /** 343 * Returns the first recent layout set branch in the ordered set where userId = ?. 344 * 345 * @param userId the user ID 346 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 347 * @return the first matching recent layout set branch 348 * @throws NoSuchRecentLayoutSetBranchException if a matching recent layout set branch could not be found 349 */ 350 public static RecentLayoutSetBranch findByUserId_First(long userId, 351 OrderByComparator<RecentLayoutSetBranch> orderByComparator) 352 throws com.liferay.portal.exception.NoSuchRecentLayoutSetBranchException { 353 return getPersistence().findByUserId_First(userId, orderByComparator); 354 } 355 356 /** 357 * Returns the first recent layout set branch in the ordered set where userId = ?. 358 * 359 * @param userId the user ID 360 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 361 * @return the first matching recent layout set branch, or <code>null</code> if a matching recent layout set branch could not be found 362 */ 363 public static RecentLayoutSetBranch fetchByUserId_First(long userId, 364 OrderByComparator<RecentLayoutSetBranch> orderByComparator) { 365 return getPersistence().fetchByUserId_First(userId, orderByComparator); 366 } 367 368 /** 369 * Returns the last recent layout set branch in the ordered set where userId = ?. 370 * 371 * @param userId the user ID 372 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 373 * @return the last matching recent layout set branch 374 * @throws NoSuchRecentLayoutSetBranchException if a matching recent layout set branch could not be found 375 */ 376 public static RecentLayoutSetBranch findByUserId_Last(long userId, 377 OrderByComparator<RecentLayoutSetBranch> orderByComparator) 378 throws com.liferay.portal.exception.NoSuchRecentLayoutSetBranchException { 379 return getPersistence().findByUserId_Last(userId, orderByComparator); 380 } 381 382 /** 383 * Returns the last recent layout set branch in the ordered set where userId = ?. 384 * 385 * @param userId the user ID 386 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 387 * @return the last matching recent layout set branch, or <code>null</code> if a matching recent layout set branch could not be found 388 */ 389 public static RecentLayoutSetBranch fetchByUserId_Last(long userId, 390 OrderByComparator<RecentLayoutSetBranch> orderByComparator) { 391 return getPersistence().fetchByUserId_Last(userId, orderByComparator); 392 } 393 394 /** 395 * Returns the recent layout set branchs before and after the current recent layout set branch in the ordered set where userId = ?. 396 * 397 * @param recentLayoutSetBranchId the primary key of the current recent layout set branch 398 * @param userId the user ID 399 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 400 * @return the previous, current, and next recent layout set branch 401 * @throws NoSuchRecentLayoutSetBranchException if a recent layout set branch with the primary key could not be found 402 */ 403 public static RecentLayoutSetBranch[] findByUserId_PrevAndNext( 404 long recentLayoutSetBranchId, long userId, 405 OrderByComparator<RecentLayoutSetBranch> orderByComparator) 406 throws com.liferay.portal.exception.NoSuchRecentLayoutSetBranchException { 407 return getPersistence() 408 .findByUserId_PrevAndNext(recentLayoutSetBranchId, userId, 409 orderByComparator); 410 } 411 412 /** 413 * Removes all the recent layout set branchs where userId = ? from the database. 414 * 415 * @param userId the user ID 416 */ 417 public static void removeByUserId(long userId) { 418 getPersistence().removeByUserId(userId); 419 } 420 421 /** 422 * Returns the number of recent layout set branchs where userId = ?. 423 * 424 * @param userId the user ID 425 * @return the number of matching recent layout set branchs 426 */ 427 public static int countByUserId(long userId) { 428 return getPersistence().countByUserId(userId); 429 } 430 431 /** 432 * Returns all the recent layout set branchs where layoutSetBranchId = ?. 433 * 434 * @param layoutSetBranchId the layout set branch ID 435 * @return the matching recent layout set branchs 436 */ 437 public static List<RecentLayoutSetBranch> findByLayoutSetBranchId( 438 long layoutSetBranchId) { 439 return getPersistence().findByLayoutSetBranchId(layoutSetBranchId); 440 } 441 442 /** 443 * Returns a range of all the recent layout set branchs where layoutSetBranchId = ?. 444 * 445 * <p> 446 * 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 RecentLayoutSetBranchModelImpl}. 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. 447 * </p> 448 * 449 * @param layoutSetBranchId the layout set branch ID 450 * @param start the lower bound of the range of recent layout set branchs 451 * @param end the upper bound of the range of recent layout set branchs (not inclusive) 452 * @return the range of matching recent layout set branchs 453 */ 454 public static List<RecentLayoutSetBranch> findByLayoutSetBranchId( 455 long layoutSetBranchId, int start, int end) { 456 return getPersistence() 457 .findByLayoutSetBranchId(layoutSetBranchId, start, end); 458 } 459 460 /** 461 * Returns an ordered range of all the recent layout set branchs where layoutSetBranchId = ?. 462 * 463 * <p> 464 * 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 RecentLayoutSetBranchModelImpl}. 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. 465 * </p> 466 * 467 * @param layoutSetBranchId the layout set branch ID 468 * @param start the lower bound of the range of recent layout set branchs 469 * @param end the upper bound of the range of recent layout set branchs (not inclusive) 470 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 471 * @return the ordered range of matching recent layout set branchs 472 */ 473 public static List<RecentLayoutSetBranch> findByLayoutSetBranchId( 474 long layoutSetBranchId, int start, int end, 475 OrderByComparator<RecentLayoutSetBranch> orderByComparator) { 476 return getPersistence() 477 .findByLayoutSetBranchId(layoutSetBranchId, start, end, 478 orderByComparator); 479 } 480 481 /** 482 * Returns an ordered range of all the recent layout set branchs where layoutSetBranchId = ?. 483 * 484 * <p> 485 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link 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 RecentLayoutSetBranchModelImpl}. 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. 486 * </p> 487 * 488 * @param layoutSetBranchId the layout set branch ID 489 * @param start the lower bound of the range of recent layout set branchs 490 * @param end the upper bound of the range of recent layout set branchs (not inclusive) 491 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 492 * @param retrieveFromCache whether to retrieve from the finder cache 493 * @return the ordered range of matching recent layout set branchs 494 */ 495 public static List<RecentLayoutSetBranch> findByLayoutSetBranchId( 496 long layoutSetBranchId, int start, int end, 497 OrderByComparator<RecentLayoutSetBranch> orderByComparator, 498 boolean retrieveFromCache) { 499 return getPersistence() 500 .findByLayoutSetBranchId(layoutSetBranchId, start, end, 501 orderByComparator, retrieveFromCache); 502 } 503 504 /** 505 * Returns the first recent layout set branch in the ordered set where layoutSetBranchId = ?. 506 * 507 * @param layoutSetBranchId the layout set branch ID 508 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 509 * @return the first matching recent layout set branch 510 * @throws NoSuchRecentLayoutSetBranchException if a matching recent layout set branch could not be found 511 */ 512 public static RecentLayoutSetBranch findByLayoutSetBranchId_First( 513 long layoutSetBranchId, 514 OrderByComparator<RecentLayoutSetBranch> orderByComparator) 515 throws com.liferay.portal.exception.NoSuchRecentLayoutSetBranchException { 516 return getPersistence() 517 .findByLayoutSetBranchId_First(layoutSetBranchId, 518 orderByComparator); 519 } 520 521 /** 522 * Returns the first recent layout set branch in the ordered set where layoutSetBranchId = ?. 523 * 524 * @param layoutSetBranchId the layout set branch ID 525 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 526 * @return the first matching recent layout set branch, or <code>null</code> if a matching recent layout set branch could not be found 527 */ 528 public static RecentLayoutSetBranch fetchByLayoutSetBranchId_First( 529 long layoutSetBranchId, 530 OrderByComparator<RecentLayoutSetBranch> orderByComparator) { 531 return getPersistence() 532 .fetchByLayoutSetBranchId_First(layoutSetBranchId, 533 orderByComparator); 534 } 535 536 /** 537 * Returns the last recent layout set branch in the ordered set where layoutSetBranchId = ?. 538 * 539 * @param layoutSetBranchId the layout set branch ID 540 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 541 * @return the last matching recent layout set branch 542 * @throws NoSuchRecentLayoutSetBranchException if a matching recent layout set branch could not be found 543 */ 544 public static RecentLayoutSetBranch findByLayoutSetBranchId_Last( 545 long layoutSetBranchId, 546 OrderByComparator<RecentLayoutSetBranch> orderByComparator) 547 throws com.liferay.portal.exception.NoSuchRecentLayoutSetBranchException { 548 return getPersistence() 549 .findByLayoutSetBranchId_Last(layoutSetBranchId, 550 orderByComparator); 551 } 552 553 /** 554 * Returns the last recent layout set branch in the ordered set where layoutSetBranchId = ?. 555 * 556 * @param layoutSetBranchId the layout set branch ID 557 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 558 * @return the last matching recent layout set branch, or <code>null</code> if a matching recent layout set branch could not be found 559 */ 560 public static RecentLayoutSetBranch fetchByLayoutSetBranchId_Last( 561 long layoutSetBranchId, 562 OrderByComparator<RecentLayoutSetBranch> orderByComparator) { 563 return getPersistence() 564 .fetchByLayoutSetBranchId_Last(layoutSetBranchId, 565 orderByComparator); 566 } 567 568 /** 569 * Returns the recent layout set branchs before and after the current recent layout set branch in the ordered set where layoutSetBranchId = ?. 570 * 571 * @param recentLayoutSetBranchId the primary key of the current recent layout set branch 572 * @param layoutSetBranchId the layout set branch ID 573 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 574 * @return the previous, current, and next recent layout set branch 575 * @throws NoSuchRecentLayoutSetBranchException if a recent layout set branch with the primary key could not be found 576 */ 577 public static RecentLayoutSetBranch[] findByLayoutSetBranchId_PrevAndNext( 578 long recentLayoutSetBranchId, long layoutSetBranchId, 579 OrderByComparator<RecentLayoutSetBranch> orderByComparator) 580 throws com.liferay.portal.exception.NoSuchRecentLayoutSetBranchException { 581 return getPersistence() 582 .findByLayoutSetBranchId_PrevAndNext(recentLayoutSetBranchId, 583 layoutSetBranchId, orderByComparator); 584 } 585 586 /** 587 * Removes all the recent layout set branchs where layoutSetBranchId = ? from the database. 588 * 589 * @param layoutSetBranchId the layout set branch ID 590 */ 591 public static void removeByLayoutSetBranchId(long layoutSetBranchId) { 592 getPersistence().removeByLayoutSetBranchId(layoutSetBranchId); 593 } 594 595 /** 596 * Returns the number of recent layout set branchs where layoutSetBranchId = ?. 597 * 598 * @param layoutSetBranchId the layout set branch ID 599 * @return the number of matching recent layout set branchs 600 */ 601 public static int countByLayoutSetBranchId(long layoutSetBranchId) { 602 return getPersistence().countByLayoutSetBranchId(layoutSetBranchId); 603 } 604 605 /** 606 * Returns the recent layout set branch where userId = ? and layoutSetId = ? or throws a {@link NoSuchRecentLayoutSetBranchException} if it could not be found. 607 * 608 * @param userId the user ID 609 * @param layoutSetId the layout set ID 610 * @return the matching recent layout set branch 611 * @throws NoSuchRecentLayoutSetBranchException if a matching recent layout set branch could not be found 612 */ 613 public static RecentLayoutSetBranch findByU_L(long userId, long layoutSetId) 614 throws com.liferay.portal.exception.NoSuchRecentLayoutSetBranchException { 615 return getPersistence().findByU_L(userId, layoutSetId); 616 } 617 618 /** 619 * Returns the recent layout set branch where userId = ? and layoutSetId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 620 * 621 * @param userId the user ID 622 * @param layoutSetId the layout set ID 623 * @return the matching recent layout set branch, or <code>null</code> if a matching recent layout set branch could not be found 624 */ 625 public static RecentLayoutSetBranch fetchByU_L(long userId, long layoutSetId) { 626 return getPersistence().fetchByU_L(userId, layoutSetId); 627 } 628 629 /** 630 * Returns the recent layout set branch where userId = ? and layoutSetId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 631 * 632 * @param userId the user ID 633 * @param layoutSetId the layout set ID 634 * @param retrieveFromCache whether to retrieve from the finder cache 635 * @return the matching recent layout set branch, or <code>null</code> if a matching recent layout set branch could not be found 636 */ 637 public static RecentLayoutSetBranch fetchByU_L(long userId, 638 long layoutSetId, boolean retrieveFromCache) { 639 return getPersistence() 640 .fetchByU_L(userId, layoutSetId, retrieveFromCache); 641 } 642 643 /** 644 * Removes the recent layout set branch where userId = ? and layoutSetId = ? from the database. 645 * 646 * @param userId the user ID 647 * @param layoutSetId the layout set ID 648 * @return the recent layout set branch that was removed 649 */ 650 public static RecentLayoutSetBranch removeByU_L(long userId, 651 long layoutSetId) 652 throws com.liferay.portal.exception.NoSuchRecentLayoutSetBranchException { 653 return getPersistence().removeByU_L(userId, layoutSetId); 654 } 655 656 /** 657 * Returns the number of recent layout set branchs where userId = ? and layoutSetId = ?. 658 * 659 * @param userId the user ID 660 * @param layoutSetId the layout set ID 661 * @return the number of matching recent layout set branchs 662 */ 663 public static int countByU_L(long userId, long layoutSetId) { 664 return getPersistence().countByU_L(userId, layoutSetId); 665 } 666 667 /** 668 * Caches the recent layout set branch in the entity cache if it is enabled. 669 * 670 * @param recentLayoutSetBranch the recent layout set branch 671 */ 672 public static void cacheResult(RecentLayoutSetBranch recentLayoutSetBranch) { 673 getPersistence().cacheResult(recentLayoutSetBranch); 674 } 675 676 /** 677 * Caches the recent layout set branchs in the entity cache if it is enabled. 678 * 679 * @param recentLayoutSetBranchs the recent layout set branchs 680 */ 681 public static void cacheResult( 682 List<RecentLayoutSetBranch> recentLayoutSetBranchs) { 683 getPersistence().cacheResult(recentLayoutSetBranchs); 684 } 685 686 /** 687 * Creates a new recent layout set branch with the primary key. Does not add the recent layout set branch to the database. 688 * 689 * @param recentLayoutSetBranchId the primary key for the new recent layout set branch 690 * @return the new recent layout set branch 691 */ 692 public static RecentLayoutSetBranch create(long recentLayoutSetBranchId) { 693 return getPersistence().create(recentLayoutSetBranchId); 694 } 695 696 /** 697 * Removes the recent layout set branch with the primary key from the database. Also notifies the appropriate model listeners. 698 * 699 * @param recentLayoutSetBranchId the primary key of the recent layout set branch 700 * @return the recent layout set branch that was removed 701 * @throws NoSuchRecentLayoutSetBranchException if a recent layout set branch with the primary key could not be found 702 */ 703 public static RecentLayoutSetBranch remove(long recentLayoutSetBranchId) 704 throws com.liferay.portal.exception.NoSuchRecentLayoutSetBranchException { 705 return getPersistence().remove(recentLayoutSetBranchId); 706 } 707 708 public static RecentLayoutSetBranch updateImpl( 709 RecentLayoutSetBranch recentLayoutSetBranch) { 710 return getPersistence().updateImpl(recentLayoutSetBranch); 711 } 712 713 /** 714 * Returns the recent layout set branch with the primary key or throws a {@link NoSuchRecentLayoutSetBranchException} if it could not be found. 715 * 716 * @param recentLayoutSetBranchId the primary key of the recent layout set branch 717 * @return the recent layout set branch 718 * @throws NoSuchRecentLayoutSetBranchException if a recent layout set branch with the primary key could not be found 719 */ 720 public static RecentLayoutSetBranch findByPrimaryKey( 721 long recentLayoutSetBranchId) 722 throws com.liferay.portal.exception.NoSuchRecentLayoutSetBranchException { 723 return getPersistence().findByPrimaryKey(recentLayoutSetBranchId); 724 } 725 726 /** 727 * Returns the recent layout set branch with the primary key or returns <code>null</code> if it could not be found. 728 * 729 * @param recentLayoutSetBranchId the primary key of the recent layout set branch 730 * @return the recent layout set branch, or <code>null</code> if a recent layout set branch with the primary key could not be found 731 */ 732 public static RecentLayoutSetBranch fetchByPrimaryKey( 733 long recentLayoutSetBranchId) { 734 return getPersistence().fetchByPrimaryKey(recentLayoutSetBranchId); 735 } 736 737 public static java.util.Map<java.io.Serializable, RecentLayoutSetBranch> fetchByPrimaryKeys( 738 java.util.Set<java.io.Serializable> primaryKeys) { 739 return getPersistence().fetchByPrimaryKeys(primaryKeys); 740 } 741 742 /** 743 * Returns all the recent layout set branchs. 744 * 745 * @return the recent layout set branchs 746 */ 747 public static List<RecentLayoutSetBranch> findAll() { 748 return getPersistence().findAll(); 749 } 750 751 /** 752 * Returns a range of all the recent layout set 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 RecentLayoutSetBranchModelImpl}. 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 set branchs 759 * @param end the upper bound of the range of recent layout set branchs (not inclusive) 760 * @return the range of recent layout set branchs 761 */ 762 public static List<RecentLayoutSetBranch> findAll(int start, int end) { 763 return getPersistence().findAll(start, end); 764 } 765 766 /** 767 * Returns an ordered range of all the recent layout set 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 RecentLayoutSetBranchModelImpl}. 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 set branchs 774 * @param end the upper bound of the range of recent layout set 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 set branchs 777 */ 778 public static List<RecentLayoutSetBranch> findAll(int start, int end, 779 OrderByComparator<RecentLayoutSetBranch> orderByComparator) { 780 return getPersistence().findAll(start, end, orderByComparator); 781 } 782 783 /** 784 * Returns an ordered range of all the recent layout set 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 RecentLayoutSetBranchModelImpl}. 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 set branchs 791 * @param end the upper bound of the range of recent layout set 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 set branchs 795 */ 796 public static List<RecentLayoutSetBranch> findAll(int start, int end, 797 OrderByComparator<RecentLayoutSetBranch> orderByComparator, 798 boolean retrieveFromCache) { 799 return getPersistence() 800 .findAll(start, end, orderByComparator, retrieveFromCache); 801 } 802 803 /** 804 * Removes all the recent layout set branchs from the database. 805 */ 806 public static void removeAll() { 807 getPersistence().removeAll(); 808 } 809 810 /** 811 * Returns the number of recent layout set branchs. 812 * 813 * @return the number of recent layout set branchs 814 */ 815 public static int countAll() { 816 return getPersistence().countAll(); 817 } 818 819 public static RecentLayoutSetBranchPersistence getPersistence() { 820 if (_persistence == null) { 821 _persistence = (RecentLayoutSetBranchPersistence)PortalBeanLocatorUtil.locate(RecentLayoutSetBranchPersistence.class.getName()); 822 823 ReferenceRegistry.registerReference(RecentLayoutSetBranchUtil.class, 824 "_persistence"); 825 } 826 827 return _persistence; 828 } 829 830 private static RecentLayoutSetBranchPersistence _persistence; 831 }