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