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.portlet.softwarecatalog.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.service.ServiceContext; 024 025 import com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion; 026 027 import java.util.List; 028 029 /** 030 * The persistence utility for the s c framework version service. This utility wraps {@link com.liferay.portlet.softwarecatalog.service.persistence.impl.SCFrameworkVersionPersistenceImpl} 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 SCFrameworkVersionPersistence 038 * @see com.liferay.portlet.softwarecatalog.service.persistence.impl.SCFrameworkVersionPersistenceImpl 039 * @generated 040 */ 041 @ProviderType 042 public class SCFrameworkVersionUtil { 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(SCFrameworkVersion scFrameworkVersion) { 060 getPersistence().clearCache(scFrameworkVersion); 061 } 062 063 /** 064 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 065 */ 066 public static long countWithDynamicQuery(DynamicQuery dynamicQuery) { 067 return getPersistence().countWithDynamicQuery(dynamicQuery); 068 } 069 070 /** 071 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 072 */ 073 public static List<SCFrameworkVersion> findWithDynamicQuery( 074 DynamicQuery dynamicQuery) { 075 return getPersistence().findWithDynamicQuery(dynamicQuery); 076 } 077 078 /** 079 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 080 */ 081 public static List<SCFrameworkVersion> findWithDynamicQuery( 082 DynamicQuery dynamicQuery, int start, int end) { 083 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 084 } 085 086 /** 087 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 088 */ 089 public static List<SCFrameworkVersion> findWithDynamicQuery( 090 DynamicQuery dynamicQuery, int start, int end, 091 OrderByComparator<SCFrameworkVersion> orderByComparator) { 092 return getPersistence() 093 .findWithDynamicQuery(dynamicQuery, start, end, 094 orderByComparator); 095 } 096 097 /** 098 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel) 099 */ 100 public static SCFrameworkVersion update( 101 SCFrameworkVersion scFrameworkVersion) { 102 return getPersistence().update(scFrameworkVersion); 103 } 104 105 /** 106 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 107 */ 108 public static SCFrameworkVersion update( 109 SCFrameworkVersion scFrameworkVersion, ServiceContext serviceContext) { 110 return getPersistence().update(scFrameworkVersion, serviceContext); 111 } 112 113 /** 114 * Returns all the s c framework versions where groupId = ?. 115 * 116 * @param groupId the group ID 117 * @return the matching s c framework versions 118 */ 119 public static List<SCFrameworkVersion> findByGroupId(long groupId) { 120 return getPersistence().findByGroupId(groupId); 121 } 122 123 /** 124 * Returns a range of all the s c framework versions 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 SCFrameworkVersionModelImpl}. 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 s c framework versions 132 * @param end the upper bound of the range of s c framework versions (not inclusive) 133 * @return the range of matching s c framework versions 134 */ 135 public static List<SCFrameworkVersion> 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 s c framework versions 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 SCFrameworkVersionModelImpl}. 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 s c framework versions 149 * @param end the upper bound of the range of s c framework versions (not inclusive) 150 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 151 * @return the ordered range of matching s c framework versions 152 */ 153 public static List<SCFrameworkVersion> findByGroupId(long groupId, 154 int start, int end, 155 OrderByComparator<SCFrameworkVersion> orderByComparator) { 156 return getPersistence() 157 .findByGroupId(groupId, start, end, orderByComparator); 158 } 159 160 /** 161 * Returns the first s c framework version in the ordered set where groupId = ?. 162 * 163 * @param groupId the group ID 164 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 165 * @return the first matching s c framework version 166 * @throws NoSuchFrameworkVersionException if a matching s c framework version could not be found 167 */ 168 public static SCFrameworkVersion findByGroupId_First(long groupId, 169 OrderByComparator<SCFrameworkVersion> orderByComparator) 170 throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException { 171 return getPersistence().findByGroupId_First(groupId, orderByComparator); 172 } 173 174 /** 175 * Returns the first s c framework version in the ordered set where groupId = ?. 176 * 177 * @param groupId the group ID 178 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 179 * @return the first matching s c framework version, or <code>null</code> if a matching s c framework version could not be found 180 */ 181 public static SCFrameworkVersion fetchByGroupId_First(long groupId, 182 OrderByComparator<SCFrameworkVersion> orderByComparator) { 183 return getPersistence().fetchByGroupId_First(groupId, orderByComparator); 184 } 185 186 /** 187 * Returns the last s c framework version in the ordered set where groupId = ?. 188 * 189 * @param groupId the group ID 190 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 191 * @return the last matching s c framework version 192 * @throws NoSuchFrameworkVersionException if a matching s c framework version could not be found 193 */ 194 public static SCFrameworkVersion findByGroupId_Last(long groupId, 195 OrderByComparator<SCFrameworkVersion> orderByComparator) 196 throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException { 197 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 198 } 199 200 /** 201 * Returns the last s c framework version in the ordered set where groupId = ?. 202 * 203 * @param groupId the group ID 204 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 205 * @return the last matching s c framework version, or <code>null</code> if a matching s c framework version could not be found 206 */ 207 public static SCFrameworkVersion fetchByGroupId_Last(long groupId, 208 OrderByComparator<SCFrameworkVersion> orderByComparator) { 209 return getPersistence().fetchByGroupId_Last(groupId, orderByComparator); 210 } 211 212 /** 213 * Returns the s c framework versions before and after the current s c framework version in the ordered set where groupId = ?. 214 * 215 * @param frameworkVersionId the primary key of the current s c framework version 216 * @param groupId the group ID 217 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 218 * @return the previous, current, and next s c framework version 219 * @throws NoSuchFrameworkVersionException if a s c framework version with the primary key could not be found 220 */ 221 public static SCFrameworkVersion[] findByGroupId_PrevAndNext( 222 long frameworkVersionId, long groupId, 223 OrderByComparator<SCFrameworkVersion> orderByComparator) 224 throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException { 225 return getPersistence() 226 .findByGroupId_PrevAndNext(frameworkVersionId, groupId, 227 orderByComparator); 228 } 229 230 /** 231 * Returns all the s c framework versions that the user has permission to view where groupId = ?. 232 * 233 * @param groupId the group ID 234 * @return the matching s c framework versions that the user has permission to view 235 */ 236 public static List<SCFrameworkVersion> filterFindByGroupId(long groupId) { 237 return getPersistence().filterFindByGroupId(groupId); 238 } 239 240 /** 241 * Returns a range of all the s c framework versions that the user has permission to view where groupId = ?. 242 * 243 * <p> 244 * 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 SCFrameworkVersionModelImpl}. 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. 245 * </p> 246 * 247 * @param groupId the group ID 248 * @param start the lower bound of the range of s c framework versions 249 * @param end the upper bound of the range of s c framework versions (not inclusive) 250 * @return the range of matching s c framework versions that the user has permission to view 251 */ 252 public static List<SCFrameworkVersion> filterFindByGroupId(long groupId, 253 int start, int end) { 254 return getPersistence().filterFindByGroupId(groupId, start, end); 255 } 256 257 /** 258 * Returns an ordered range of all the s c framework versions that the user has permissions to view where groupId = ?. 259 * 260 * <p> 261 * 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 SCFrameworkVersionModelImpl}. 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. 262 * </p> 263 * 264 * @param groupId the group ID 265 * @param start the lower bound of the range of s c framework versions 266 * @param end the upper bound of the range of s c framework versions (not inclusive) 267 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 268 * @return the ordered range of matching s c framework versions that the user has permission to view 269 */ 270 public static List<SCFrameworkVersion> filterFindByGroupId(long groupId, 271 int start, int end, 272 OrderByComparator<SCFrameworkVersion> orderByComparator) { 273 return getPersistence() 274 .filterFindByGroupId(groupId, start, end, orderByComparator); 275 } 276 277 /** 278 * Returns the s c framework versions before and after the current s c framework version in the ordered set of s c framework versions that the user has permission to view where groupId = ?. 279 * 280 * @param frameworkVersionId the primary key of the current s c framework version 281 * @param groupId the group ID 282 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 283 * @return the previous, current, and next s c framework version 284 * @throws NoSuchFrameworkVersionException if a s c framework version with the primary key could not be found 285 */ 286 public static SCFrameworkVersion[] filterFindByGroupId_PrevAndNext( 287 long frameworkVersionId, long groupId, 288 OrderByComparator<SCFrameworkVersion> orderByComparator) 289 throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException { 290 return getPersistence() 291 .filterFindByGroupId_PrevAndNext(frameworkVersionId, 292 groupId, orderByComparator); 293 } 294 295 /** 296 * Removes all the s c framework versions where groupId = ? from the database. 297 * 298 * @param groupId the group ID 299 */ 300 public static void removeByGroupId(long groupId) { 301 getPersistence().removeByGroupId(groupId); 302 } 303 304 /** 305 * Returns the number of s c framework versions where groupId = ?. 306 * 307 * @param groupId the group ID 308 * @return the number of matching s c framework versions 309 */ 310 public static int countByGroupId(long groupId) { 311 return getPersistence().countByGroupId(groupId); 312 } 313 314 /** 315 * Returns the number of s c framework versions that the user has permission to view where groupId = ?. 316 * 317 * @param groupId the group ID 318 * @return the number of matching s c framework versions that the user has permission to view 319 */ 320 public static int filterCountByGroupId(long groupId) { 321 return getPersistence().filterCountByGroupId(groupId); 322 } 323 324 /** 325 * Returns all the s c framework versions where companyId = ?. 326 * 327 * @param companyId the company ID 328 * @return the matching s c framework versions 329 */ 330 public static List<SCFrameworkVersion> findByCompanyId(long companyId) { 331 return getPersistence().findByCompanyId(companyId); 332 } 333 334 /** 335 * Returns a range of all the s c framework versions where companyId = ?. 336 * 337 * <p> 338 * 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 SCFrameworkVersionModelImpl}. 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. 339 * </p> 340 * 341 * @param companyId the company ID 342 * @param start the lower bound of the range of s c framework versions 343 * @param end the upper bound of the range of s c framework versions (not inclusive) 344 * @return the range of matching s c framework versions 345 */ 346 public static List<SCFrameworkVersion> findByCompanyId(long companyId, 347 int start, int end) { 348 return getPersistence().findByCompanyId(companyId, start, end); 349 } 350 351 /** 352 * Returns an ordered range of all the s c framework versions where companyId = ?. 353 * 354 * <p> 355 * 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 SCFrameworkVersionModelImpl}. 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. 356 * </p> 357 * 358 * @param companyId the company ID 359 * @param start the lower bound of the range of s c framework versions 360 * @param end the upper bound of the range of s c framework versions (not inclusive) 361 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 362 * @return the ordered range of matching s c framework versions 363 */ 364 public static List<SCFrameworkVersion> findByCompanyId(long companyId, 365 int start, int end, 366 OrderByComparator<SCFrameworkVersion> orderByComparator) { 367 return getPersistence() 368 .findByCompanyId(companyId, start, end, orderByComparator); 369 } 370 371 /** 372 * Returns the first s c framework version in the ordered set where companyId = ?. 373 * 374 * @param companyId the company ID 375 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 376 * @return the first matching s c framework version 377 * @throws NoSuchFrameworkVersionException if a matching s c framework version could not be found 378 */ 379 public static SCFrameworkVersion findByCompanyId_First(long companyId, 380 OrderByComparator<SCFrameworkVersion> orderByComparator) 381 throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException { 382 return getPersistence() 383 .findByCompanyId_First(companyId, orderByComparator); 384 } 385 386 /** 387 * Returns the first s c framework version in the ordered set where companyId = ?. 388 * 389 * @param companyId the company ID 390 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 391 * @return the first matching s c framework version, or <code>null</code> if a matching s c framework version could not be found 392 */ 393 public static SCFrameworkVersion fetchByCompanyId_First(long companyId, 394 OrderByComparator<SCFrameworkVersion> orderByComparator) { 395 return getPersistence() 396 .fetchByCompanyId_First(companyId, orderByComparator); 397 } 398 399 /** 400 * Returns the last s c framework version in the ordered set where companyId = ?. 401 * 402 * @param companyId the company ID 403 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 404 * @return the last matching s c framework version 405 * @throws NoSuchFrameworkVersionException if a matching s c framework version could not be found 406 */ 407 public static SCFrameworkVersion findByCompanyId_Last(long companyId, 408 OrderByComparator<SCFrameworkVersion> orderByComparator) 409 throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException { 410 return getPersistence() 411 .findByCompanyId_Last(companyId, orderByComparator); 412 } 413 414 /** 415 * Returns the last s c framework version in the ordered set where companyId = ?. 416 * 417 * @param companyId the company ID 418 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 419 * @return the last matching s c framework version, or <code>null</code> if a matching s c framework version could not be found 420 */ 421 public static SCFrameworkVersion fetchByCompanyId_Last(long companyId, 422 OrderByComparator<SCFrameworkVersion> orderByComparator) { 423 return getPersistence() 424 .fetchByCompanyId_Last(companyId, orderByComparator); 425 } 426 427 /** 428 * Returns the s c framework versions before and after the current s c framework version in the ordered set where companyId = ?. 429 * 430 * @param frameworkVersionId the primary key of the current s c framework version 431 * @param companyId the company ID 432 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 433 * @return the previous, current, and next s c framework version 434 * @throws NoSuchFrameworkVersionException if a s c framework version with the primary key could not be found 435 */ 436 public static SCFrameworkVersion[] findByCompanyId_PrevAndNext( 437 long frameworkVersionId, long companyId, 438 OrderByComparator<SCFrameworkVersion> orderByComparator) 439 throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException { 440 return getPersistence() 441 .findByCompanyId_PrevAndNext(frameworkVersionId, companyId, 442 orderByComparator); 443 } 444 445 /** 446 * Removes all the s c framework versions where companyId = ? from the database. 447 * 448 * @param companyId the company ID 449 */ 450 public static void removeByCompanyId(long companyId) { 451 getPersistence().removeByCompanyId(companyId); 452 } 453 454 /** 455 * Returns the number of s c framework versions where companyId = ?. 456 * 457 * @param companyId the company ID 458 * @return the number of matching s c framework versions 459 */ 460 public static int countByCompanyId(long companyId) { 461 return getPersistence().countByCompanyId(companyId); 462 } 463 464 /** 465 * Returns all the s c framework versions where groupId = ? and active = ?. 466 * 467 * @param groupId the group ID 468 * @param active the active 469 * @return the matching s c framework versions 470 */ 471 public static List<SCFrameworkVersion> findByG_A(long groupId, 472 boolean active) { 473 return getPersistence().findByG_A(groupId, active); 474 } 475 476 /** 477 * Returns a range of all the s c framework versions where groupId = ? and active = ?. 478 * 479 * <p> 480 * 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 SCFrameworkVersionModelImpl}. 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. 481 * </p> 482 * 483 * @param groupId the group ID 484 * @param active the active 485 * @param start the lower bound of the range of s c framework versions 486 * @param end the upper bound of the range of s c framework versions (not inclusive) 487 * @return the range of matching s c framework versions 488 */ 489 public static List<SCFrameworkVersion> findByG_A(long groupId, 490 boolean active, int start, int end) { 491 return getPersistence().findByG_A(groupId, active, start, end); 492 } 493 494 /** 495 * Returns an ordered range of all the s c framework versions where groupId = ? and active = ?. 496 * 497 * <p> 498 * 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 SCFrameworkVersionModelImpl}. 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. 499 * </p> 500 * 501 * @param groupId the group ID 502 * @param active the active 503 * @param start the lower bound of the range of s c framework versions 504 * @param end the upper bound of the range of s c framework versions (not inclusive) 505 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 506 * @return the ordered range of matching s c framework versions 507 */ 508 public static List<SCFrameworkVersion> findByG_A(long groupId, 509 boolean active, int start, int end, 510 OrderByComparator<SCFrameworkVersion> orderByComparator) { 511 return getPersistence() 512 .findByG_A(groupId, active, start, end, orderByComparator); 513 } 514 515 /** 516 * Returns the first s c framework version in the ordered set where groupId = ? and active = ?. 517 * 518 * @param groupId the group ID 519 * @param active the active 520 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 521 * @return the first matching s c framework version 522 * @throws NoSuchFrameworkVersionException if a matching s c framework version could not be found 523 */ 524 public static SCFrameworkVersion findByG_A_First(long groupId, 525 boolean active, OrderByComparator<SCFrameworkVersion> orderByComparator) 526 throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException { 527 return getPersistence() 528 .findByG_A_First(groupId, active, orderByComparator); 529 } 530 531 /** 532 * Returns the first s c framework version in the ordered set where groupId = ? and active = ?. 533 * 534 * @param groupId the group ID 535 * @param active the active 536 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 537 * @return the first matching s c framework version, or <code>null</code> if a matching s c framework version could not be found 538 */ 539 public static SCFrameworkVersion fetchByG_A_First(long groupId, 540 boolean active, OrderByComparator<SCFrameworkVersion> orderByComparator) { 541 return getPersistence() 542 .fetchByG_A_First(groupId, active, orderByComparator); 543 } 544 545 /** 546 * Returns the last s c framework version in the ordered set where groupId = ? and active = ?. 547 * 548 * @param groupId the group ID 549 * @param active the active 550 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 551 * @return the last matching s c framework version 552 * @throws NoSuchFrameworkVersionException if a matching s c framework version could not be found 553 */ 554 public static SCFrameworkVersion findByG_A_Last(long groupId, 555 boolean active, OrderByComparator<SCFrameworkVersion> orderByComparator) 556 throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException { 557 return getPersistence() 558 .findByG_A_Last(groupId, active, orderByComparator); 559 } 560 561 /** 562 * Returns the last s c framework version in the ordered set where groupId = ? and active = ?. 563 * 564 * @param groupId the group ID 565 * @param active the active 566 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 567 * @return the last matching s c framework version, or <code>null</code> if a matching s c framework version could not be found 568 */ 569 public static SCFrameworkVersion fetchByG_A_Last(long groupId, 570 boolean active, OrderByComparator<SCFrameworkVersion> orderByComparator) { 571 return getPersistence() 572 .fetchByG_A_Last(groupId, active, orderByComparator); 573 } 574 575 /** 576 * Returns the s c framework versions before and after the current s c framework version in the ordered set where groupId = ? and active = ?. 577 * 578 * @param frameworkVersionId the primary key of the current s c framework version 579 * @param groupId the group ID 580 * @param active the active 581 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 582 * @return the previous, current, and next s c framework version 583 * @throws NoSuchFrameworkVersionException if a s c framework version with the primary key could not be found 584 */ 585 public static SCFrameworkVersion[] findByG_A_PrevAndNext( 586 long frameworkVersionId, long groupId, boolean active, 587 OrderByComparator<SCFrameworkVersion> orderByComparator) 588 throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException { 589 return getPersistence() 590 .findByG_A_PrevAndNext(frameworkVersionId, groupId, active, 591 orderByComparator); 592 } 593 594 /** 595 * Returns all the s c framework versions that the user has permission to view where groupId = ? and active = ?. 596 * 597 * @param groupId the group ID 598 * @param active the active 599 * @return the matching s c framework versions that the user has permission to view 600 */ 601 public static List<SCFrameworkVersion> filterFindByG_A(long groupId, 602 boolean active) { 603 return getPersistence().filterFindByG_A(groupId, active); 604 } 605 606 /** 607 * Returns a range of all the s c framework versions that the user has permission to view where groupId = ? and active = ?. 608 * 609 * <p> 610 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link 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 SCFrameworkVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 611 * </p> 612 * 613 * @param groupId the group ID 614 * @param active the active 615 * @param start the lower bound of the range of s c framework versions 616 * @param end the upper bound of the range of s c framework versions (not inclusive) 617 * @return the range of matching s c framework versions that the user has permission to view 618 */ 619 public static List<SCFrameworkVersion> filterFindByG_A(long groupId, 620 boolean active, int start, int end) { 621 return getPersistence().filterFindByG_A(groupId, active, start, end); 622 } 623 624 /** 625 * Returns an ordered range of all the s c framework versions that the user has permissions to view where groupId = ? and active = ?. 626 * 627 * <p> 628 * 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 SCFrameworkVersionModelImpl}. 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. 629 * </p> 630 * 631 * @param groupId the group ID 632 * @param active the active 633 * @param start the lower bound of the range of s c framework versions 634 * @param end the upper bound of the range of s c framework versions (not inclusive) 635 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 636 * @return the ordered range of matching s c framework versions that the user has permission to view 637 */ 638 public static List<SCFrameworkVersion> filterFindByG_A(long groupId, 639 boolean active, int start, int end, 640 OrderByComparator<SCFrameworkVersion> orderByComparator) { 641 return getPersistence() 642 .filterFindByG_A(groupId, active, start, end, 643 orderByComparator); 644 } 645 646 /** 647 * Returns the s c framework versions before and after the current s c framework version in the ordered set of s c framework versions that the user has permission to view where groupId = ? and active = ?. 648 * 649 * @param frameworkVersionId the primary key of the current s c framework version 650 * @param groupId the group ID 651 * @param active the active 652 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 653 * @return the previous, current, and next s c framework version 654 * @throws NoSuchFrameworkVersionException if a s c framework version with the primary key could not be found 655 */ 656 public static SCFrameworkVersion[] filterFindByG_A_PrevAndNext( 657 long frameworkVersionId, long groupId, boolean active, 658 OrderByComparator<SCFrameworkVersion> orderByComparator) 659 throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException { 660 return getPersistence() 661 .filterFindByG_A_PrevAndNext(frameworkVersionId, groupId, 662 active, orderByComparator); 663 } 664 665 /** 666 * Removes all the s c framework versions where groupId = ? and active = ? from the database. 667 * 668 * @param groupId the group ID 669 * @param active the active 670 */ 671 public static void removeByG_A(long groupId, boolean active) { 672 getPersistence().removeByG_A(groupId, active); 673 } 674 675 /** 676 * Returns the number of s c framework versions where groupId = ? and active = ?. 677 * 678 * @param groupId the group ID 679 * @param active the active 680 * @return the number of matching s c framework versions 681 */ 682 public static int countByG_A(long groupId, boolean active) { 683 return getPersistence().countByG_A(groupId, active); 684 } 685 686 /** 687 * Returns the number of s c framework versions that the user has permission to view where groupId = ? and active = ?. 688 * 689 * @param groupId the group ID 690 * @param active the active 691 * @return the number of matching s c framework versions that the user has permission to view 692 */ 693 public static int filterCountByG_A(long groupId, boolean active) { 694 return getPersistence().filterCountByG_A(groupId, active); 695 } 696 697 /** 698 * Caches the s c framework version in the entity cache if it is enabled. 699 * 700 * @param scFrameworkVersion the s c framework version 701 */ 702 public static void cacheResult(SCFrameworkVersion scFrameworkVersion) { 703 getPersistence().cacheResult(scFrameworkVersion); 704 } 705 706 /** 707 * Caches the s c framework versions in the entity cache if it is enabled. 708 * 709 * @param scFrameworkVersions the s c framework versions 710 */ 711 public static void cacheResult(List<SCFrameworkVersion> scFrameworkVersions) { 712 getPersistence().cacheResult(scFrameworkVersions); 713 } 714 715 /** 716 * Creates a new s c framework version with the primary key. Does not add the s c framework version to the database. 717 * 718 * @param frameworkVersionId the primary key for the new s c framework version 719 * @return the new s c framework version 720 */ 721 public static SCFrameworkVersion create(long frameworkVersionId) { 722 return getPersistence().create(frameworkVersionId); 723 } 724 725 /** 726 * Removes the s c framework version with the primary key from the database. Also notifies the appropriate model listeners. 727 * 728 * @param frameworkVersionId the primary key of the s c framework version 729 * @return the s c framework version that was removed 730 * @throws NoSuchFrameworkVersionException if a s c framework version with the primary key could not be found 731 */ 732 public static SCFrameworkVersion remove(long frameworkVersionId) 733 throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException { 734 return getPersistence().remove(frameworkVersionId); 735 } 736 737 public static SCFrameworkVersion updateImpl( 738 SCFrameworkVersion scFrameworkVersion) { 739 return getPersistence().updateImpl(scFrameworkVersion); 740 } 741 742 /** 743 * Returns the s c framework version with the primary key or throws a {@link NoSuchFrameworkVersionException} if it could not be found. 744 * 745 * @param frameworkVersionId the primary key of the s c framework version 746 * @return the s c framework version 747 * @throws NoSuchFrameworkVersionException if a s c framework version with the primary key could not be found 748 */ 749 public static SCFrameworkVersion findByPrimaryKey(long frameworkVersionId) 750 throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException { 751 return getPersistence().findByPrimaryKey(frameworkVersionId); 752 } 753 754 /** 755 * Returns the s c framework version with the primary key or returns <code>null</code> if it could not be found. 756 * 757 * @param frameworkVersionId the primary key of the s c framework version 758 * @return the s c framework version, or <code>null</code> if a s c framework version with the primary key could not be found 759 */ 760 public static SCFrameworkVersion fetchByPrimaryKey(long frameworkVersionId) { 761 return getPersistence().fetchByPrimaryKey(frameworkVersionId); 762 } 763 764 public static java.util.Map<java.io.Serializable, SCFrameworkVersion> fetchByPrimaryKeys( 765 java.util.Set<java.io.Serializable> primaryKeys) { 766 return getPersistence().fetchByPrimaryKeys(primaryKeys); 767 } 768 769 /** 770 * Returns all the s c framework versions. 771 * 772 * @return the s c framework versions 773 */ 774 public static List<SCFrameworkVersion> findAll() { 775 return getPersistence().findAll(); 776 } 777 778 /** 779 * Returns a range of all the s c framework versions. 780 * 781 * <p> 782 * 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 SCFrameworkVersionModelImpl}. 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. 783 * </p> 784 * 785 * @param start the lower bound of the range of s c framework versions 786 * @param end the upper bound of the range of s c framework versions (not inclusive) 787 * @return the range of s c framework versions 788 */ 789 public static List<SCFrameworkVersion> findAll(int start, int end) { 790 return getPersistence().findAll(start, end); 791 } 792 793 /** 794 * Returns an ordered range of all the s c framework versions. 795 * 796 * <p> 797 * 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 SCFrameworkVersionModelImpl}. 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. 798 * </p> 799 * 800 * @param start the lower bound of the range of s c framework versions 801 * @param end the upper bound of the range of s c framework versions (not inclusive) 802 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 803 * @return the ordered range of s c framework versions 804 */ 805 public static List<SCFrameworkVersion> findAll(int start, int end, 806 OrderByComparator<SCFrameworkVersion> orderByComparator) { 807 return getPersistence().findAll(start, end, orderByComparator); 808 } 809 810 /** 811 * Removes all the s c framework versions from the database. 812 */ 813 public static void removeAll() { 814 getPersistence().removeAll(); 815 } 816 817 /** 818 * Returns the number of s c framework versions. 819 * 820 * @return the number of s c framework versions 821 */ 822 public static int countAll() { 823 return getPersistence().countAll(); 824 } 825 826 /** 827 * Returns the primaryKeys of s c product versions associated with the s c framework version. 828 * 829 * @param pk the primary key of the s c framework version 830 * @return long[] of the primaryKeys of s c product versions associated with the s c framework version 831 */ 832 public static long[] getSCProductVersionPrimaryKeys(long pk) { 833 return getPersistence().getSCProductVersionPrimaryKeys(pk); 834 } 835 836 /** 837 * Returns all the s c product versions associated with the s c framework version. 838 * 839 * @param pk the primary key of the s c framework version 840 * @return the s c product versions associated with the s c framework version 841 */ 842 public static List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> getSCProductVersions( 843 long pk) { 844 return getPersistence().getSCProductVersions(pk); 845 } 846 847 /** 848 * Returns a range of all the s c product versions associated with the s c framework version. 849 * 850 * <p> 851 * 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 SCFrameworkVersionModelImpl}. 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. 852 * </p> 853 * 854 * @param pk the primary key of the s c framework version 855 * @param start the lower bound of the range of s c framework versions 856 * @param end the upper bound of the range of s c framework versions (not inclusive) 857 * @return the range of s c product versions associated with the s c framework version 858 */ 859 public static List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> getSCProductVersions( 860 long pk, int start, int end) { 861 return getPersistence().getSCProductVersions(pk, start, end); 862 } 863 864 /** 865 * Returns an ordered range of all the s c product versions associated with the s c framework version. 866 * 867 * <p> 868 * 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 SCFrameworkVersionModelImpl}. 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. 869 * </p> 870 * 871 * @param pk the primary key of the s c framework version 872 * @param start the lower bound of the range of s c framework versions 873 * @param end the upper bound of the range of s c framework versions (not inclusive) 874 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 875 * @return the ordered range of s c product versions associated with the s c framework version 876 */ 877 public static List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> getSCProductVersions( 878 long pk, int start, int end, 879 OrderByComparator<com.liferay.portlet.softwarecatalog.model.SCProductVersion> orderByComparator) { 880 return getPersistence() 881 .getSCProductVersions(pk, start, end, orderByComparator); 882 } 883 884 /** 885 * Returns the number of s c product versions associated with the s c framework version. 886 * 887 * @param pk the primary key of the s c framework version 888 * @return the number of s c product versions associated with the s c framework version 889 */ 890 public static int getSCProductVersionsSize(long pk) { 891 return getPersistence().getSCProductVersionsSize(pk); 892 } 893 894 /** 895 * Returns <code>true</code> if the s c product version is associated with the s c framework version. 896 * 897 * @param pk the primary key of the s c framework version 898 * @param scProductVersionPK the primary key of the s c product version 899 * @return <code>true</code> if the s c product version is associated with the s c framework version; <code>false</code> otherwise 900 */ 901 public static boolean containsSCProductVersion(long pk, 902 long scProductVersionPK) { 903 return getPersistence().containsSCProductVersion(pk, scProductVersionPK); 904 } 905 906 /** 907 * Returns <code>true</code> if the s c framework version has any s c product versions associated with it. 908 * 909 * @param pk the primary key of the s c framework version to check for associations with s c product versions 910 * @return <code>true</code> if the s c framework version has any s c product versions associated with it; <code>false</code> otherwise 911 */ 912 public static boolean containsSCProductVersions(long pk) { 913 return getPersistence().containsSCProductVersions(pk); 914 } 915 916 /** 917 * Adds an association between the s c framework version and the s c product version. Also notifies the appropriate model listeners and clears the mapping table finder cache. 918 * 919 * @param pk the primary key of the s c framework version 920 * @param scProductVersionPK the primary key of the s c product version 921 */ 922 public static void addSCProductVersion(long pk, long scProductVersionPK) { 923 getPersistence().addSCProductVersion(pk, scProductVersionPK); 924 } 925 926 /** 927 * Adds an association between the s c framework version and the s c product version. Also notifies the appropriate model listeners and clears the mapping table finder cache. 928 * 929 * @param pk the primary key of the s c framework version 930 * @param scProductVersion the s c product version 931 */ 932 public static void addSCProductVersion(long pk, 933 com.liferay.portlet.softwarecatalog.model.SCProductVersion scProductVersion) { 934 getPersistence().addSCProductVersion(pk, scProductVersion); 935 } 936 937 /** 938 * Adds an association between the s c framework version and the s c product versions. Also notifies the appropriate model listeners and clears the mapping table finder cache. 939 * 940 * @param pk the primary key of the s c framework version 941 * @param scProductVersionPKs the primary keys of the s c product versions 942 */ 943 public static void addSCProductVersions(long pk, long[] scProductVersionPKs) { 944 getPersistence().addSCProductVersions(pk, scProductVersionPKs); 945 } 946 947 /** 948 * Adds an association between the s c framework version and the s c product versions. Also notifies the appropriate model listeners and clears the mapping table finder cache. 949 * 950 * @param pk the primary key of the s c framework version 951 * @param scProductVersions the s c product versions 952 */ 953 public static void addSCProductVersions(long pk, 954 List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> scProductVersions) { 955 getPersistence().addSCProductVersions(pk, scProductVersions); 956 } 957 958 /** 959 * Clears all associations between the s c framework version and its s c product versions. Also notifies the appropriate model listeners and clears the mapping table finder cache. 960 * 961 * @param pk the primary key of the s c framework version to clear the associated s c product versions from 962 */ 963 public static void clearSCProductVersions(long pk) { 964 getPersistence().clearSCProductVersions(pk); 965 } 966 967 /** 968 * Removes the association between the s c framework version and the s c product version. Also notifies the appropriate model listeners and clears the mapping table finder cache. 969 * 970 * @param pk the primary key of the s c framework version 971 * @param scProductVersionPK the primary key of the s c product version 972 */ 973 public static void removeSCProductVersion(long pk, long scProductVersionPK) { 974 getPersistence().removeSCProductVersion(pk, scProductVersionPK); 975 } 976 977 /** 978 * Removes the association between the s c framework version and the s c product version. Also notifies the appropriate model listeners and clears the mapping table finder cache. 979 * 980 * @param pk the primary key of the s c framework version 981 * @param scProductVersion the s c product version 982 */ 983 public static void removeSCProductVersion(long pk, 984 com.liferay.portlet.softwarecatalog.model.SCProductVersion scProductVersion) { 985 getPersistence().removeSCProductVersion(pk, scProductVersion); 986 } 987 988 /** 989 * Removes the association between the s c framework version and the s c product versions. Also notifies the appropriate model listeners and clears the mapping table finder cache. 990 * 991 * @param pk the primary key of the s c framework version 992 * @param scProductVersionPKs the primary keys of the s c product versions 993 */ 994 public static void removeSCProductVersions(long pk, 995 long[] scProductVersionPKs) { 996 getPersistence().removeSCProductVersions(pk, scProductVersionPKs); 997 } 998 999 /** 1000 * Removes the association between the s c framework version and the s c product versions. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1001 * 1002 * @param pk the primary key of the s c framework version 1003 * @param scProductVersions the s c product versions 1004 */ 1005 public static void removeSCProductVersions(long pk, 1006 List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> scProductVersions) { 1007 getPersistence().removeSCProductVersions(pk, scProductVersions); 1008 } 1009 1010 /** 1011 * Sets the s c product versions associated with the s c framework version, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1012 * 1013 * @param pk the primary key of the s c framework version 1014 * @param scProductVersionPKs the primary keys of the s c product versions to be associated with the s c framework version 1015 */ 1016 public static void setSCProductVersions(long pk, long[] scProductVersionPKs) { 1017 getPersistence().setSCProductVersions(pk, scProductVersionPKs); 1018 } 1019 1020 /** 1021 * Sets the s c product versions associated with the s c framework version, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1022 * 1023 * @param pk the primary key of the s c framework version 1024 * @param scProductVersions the s c product versions to be associated with the s c framework version 1025 */ 1026 public static void setSCProductVersions(long pk, 1027 List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> scProductVersions) { 1028 getPersistence().setSCProductVersions(pk, scProductVersions); 1029 } 1030 1031 public static SCFrameworkVersionPersistence getPersistence() { 1032 if (_persistence == null) { 1033 _persistence = (SCFrameworkVersionPersistence)PortalBeanLocatorUtil.locate(SCFrameworkVersionPersistence.class.getName()); 1034 1035 ReferenceRegistry.registerReference(SCFrameworkVersionUtil.class, 1036 "_persistence"); 1037 } 1038 1039 return _persistence; 1040 } 1041 1042 /** 1043 * @deprecated As of 6.2.0 1044 */ 1045 @Deprecated 1046 public void setPersistence(SCFrameworkVersionPersistence persistence) { 1047 } 1048 1049 private static SCFrameworkVersionPersistence _persistence; 1050 }