001 /** 002 * Copyright (c) 2000-2011 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 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 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 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 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 * Returns 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 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 * Returns 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 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 * Returns all the s c framework versions where groupId = ?. 206 * 207 * @param groupId the group ID 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 * Returns 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 225 * @param start the lower bound of the range of s c framework versions 226 * @param end the upper bound of the range of s c framework versions (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 * Returns 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 244 * @param start the lower bound of the range of s c framework versions 245 * @param end the upper bound of the range of s c framework versions (not inclusive) 246 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 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 * Returns 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 266 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 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 * Returns 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 287 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 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 * Returns 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 309 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 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 * Returns all the s c framework versions that the user has permission to view where groupId = ?. 326 * 327 * @param groupId the group ID 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 * Returns a range of all the s c framework versions that the user has permission to view 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 345 * @param start the lower bound of the range of s c framework versions 346 * @param end the upper bound of the range of s c framework versions (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 * Returns an ordered range of all the s c framework versions that the user has permissions to view 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 364 * @param start the lower bound of the range of s c framework versions 365 * @param end the upper bound of the range of s c framework versions (not inclusive) 366 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 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 * 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 = ?. 380 * 381 * @param frameworkVersionId the primary key of the current s c framework version 382 * @param groupId the group ID 383 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 384 * @return the previous, current, and next s c framework version 385 * @throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException if a s c framework version with the primary key could not be found 386 * @throws SystemException if a system exception occurred 387 */ 388 public static com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion[] filterFindByGroupId_PrevAndNext( 389 long frameworkVersionId, long groupId, 390 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 391 throws com.liferay.portal.kernel.exception.SystemException, 392 com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException { 393 return getPersistence() 394 .filterFindByGroupId_PrevAndNext(frameworkVersionId, 395 groupId, orderByComparator); 396 } 397 398 /** 399 * Returns all the s c framework versions where companyId = ?. 400 * 401 * @param companyId the company ID 402 * @return the matching s c framework versions 403 * @throws SystemException if a system exception occurred 404 */ 405 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> findByCompanyId( 406 long companyId) 407 throws com.liferay.portal.kernel.exception.SystemException { 408 return getPersistence().findByCompanyId(companyId); 409 } 410 411 /** 412 * Returns a range of all the s c framework versions where companyId = ?. 413 * 414 * <p> 415 * 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. 416 * </p> 417 * 418 * @param companyId the company ID 419 * @param start the lower bound of the range of s c framework versions 420 * @param end the upper bound of the range of s c framework versions (not inclusive) 421 * @return the range of matching s c framework versions 422 * @throws SystemException if a system exception occurred 423 */ 424 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> findByCompanyId( 425 long companyId, int start, int end) 426 throws com.liferay.portal.kernel.exception.SystemException { 427 return getPersistence().findByCompanyId(companyId, start, end); 428 } 429 430 /** 431 * Returns an ordered range of all the s c framework versions where companyId = ?. 432 * 433 * <p> 434 * 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. 435 * </p> 436 * 437 * @param companyId the company ID 438 * @param start the lower bound of the range of s c framework versions 439 * @param end the upper bound of the range of s c framework versions (not inclusive) 440 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 441 * @return the ordered range of matching s c framework versions 442 * @throws SystemException if a system exception occurred 443 */ 444 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> findByCompanyId( 445 long companyId, int start, int end, 446 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 447 throws com.liferay.portal.kernel.exception.SystemException { 448 return getPersistence() 449 .findByCompanyId(companyId, start, end, orderByComparator); 450 } 451 452 /** 453 * Returns the first s c framework version in the ordered set where companyId = ?. 454 * 455 * <p> 456 * 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. 457 * </p> 458 * 459 * @param companyId the company ID 460 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 461 * @return the first matching s c framework version 462 * @throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException if a matching s c framework version could not be found 463 * @throws SystemException if a system exception occurred 464 */ 465 public static com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion findByCompanyId_First( 466 long companyId, 467 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 468 throws com.liferay.portal.kernel.exception.SystemException, 469 com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException { 470 return getPersistence() 471 .findByCompanyId_First(companyId, orderByComparator); 472 } 473 474 /** 475 * Returns the last s c framework version in the ordered set where companyId = ?. 476 * 477 * <p> 478 * 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. 479 * </p> 480 * 481 * @param companyId the company ID 482 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 483 * @return the last matching s c framework version 484 * @throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException if a matching s c framework version could not be found 485 * @throws SystemException if a system exception occurred 486 */ 487 public static com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion findByCompanyId_Last( 488 long companyId, 489 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 490 throws com.liferay.portal.kernel.exception.SystemException, 491 com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException { 492 return getPersistence() 493 .findByCompanyId_Last(companyId, orderByComparator); 494 } 495 496 /** 497 * Returns the s c framework versions before and after the current s c framework version in the ordered set where companyId = ?. 498 * 499 * <p> 500 * 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. 501 * </p> 502 * 503 * @param frameworkVersionId the primary key of the current s c framework version 504 * @param companyId the company ID 505 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 506 * @return the previous, current, and next s c framework version 507 * @throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException if a s c framework version with the primary key could not be found 508 * @throws SystemException if a system exception occurred 509 */ 510 public static com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion[] findByCompanyId_PrevAndNext( 511 long frameworkVersionId, long companyId, 512 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 513 throws com.liferay.portal.kernel.exception.SystemException, 514 com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException { 515 return getPersistence() 516 .findByCompanyId_PrevAndNext(frameworkVersionId, companyId, 517 orderByComparator); 518 } 519 520 /** 521 * Returns all the s c framework versions where groupId = ? and active = ?. 522 * 523 * @param groupId the group ID 524 * @param active the active 525 * @return the matching s c framework versions 526 * @throws SystemException if a system exception occurred 527 */ 528 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> findByG_A( 529 long groupId, boolean active) 530 throws com.liferay.portal.kernel.exception.SystemException { 531 return getPersistence().findByG_A(groupId, active); 532 } 533 534 /** 535 * Returns a range of all the s c framework versions where groupId = ? and active = ?. 536 * 537 * <p> 538 * 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. 539 * </p> 540 * 541 * @param groupId the group ID 542 * @param active the active 543 * @param start the lower bound of the range of s c framework versions 544 * @param end the upper bound of the range of s c framework versions (not inclusive) 545 * @return the range of matching s c framework versions 546 * @throws SystemException if a system exception occurred 547 */ 548 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> findByG_A( 549 long groupId, boolean active, int start, int end) 550 throws com.liferay.portal.kernel.exception.SystemException { 551 return getPersistence().findByG_A(groupId, active, start, end); 552 } 553 554 /** 555 * Returns an ordered range of all the s c framework versions where groupId = ? and active = ?. 556 * 557 * <p> 558 * 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. 559 * </p> 560 * 561 * @param groupId the group ID 562 * @param active the active 563 * @param start the lower bound of the range of s c framework versions 564 * @param end the upper bound of the range of s c framework versions (not inclusive) 565 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 566 * @return the ordered range of matching s c framework versions 567 * @throws SystemException if a system exception occurred 568 */ 569 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> findByG_A( 570 long groupId, boolean active, int start, int end, 571 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 572 throws com.liferay.portal.kernel.exception.SystemException { 573 return getPersistence() 574 .findByG_A(groupId, active, start, end, orderByComparator); 575 } 576 577 /** 578 * Returns the first s c framework version in the ordered set where groupId = ? and active = ?. 579 * 580 * <p> 581 * 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. 582 * </p> 583 * 584 * @param groupId the group ID 585 * @param active the active 586 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 587 * @return the first matching s c framework version 588 * @throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException if a matching s c framework version could not be found 589 * @throws SystemException if a system exception occurred 590 */ 591 public static com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion findByG_A_First( 592 long groupId, boolean active, 593 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 594 throws com.liferay.portal.kernel.exception.SystemException, 595 com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException { 596 return getPersistence() 597 .findByG_A_First(groupId, active, orderByComparator); 598 } 599 600 /** 601 * Returns the last s c framework version in the ordered set where groupId = ? and active = ?. 602 * 603 * <p> 604 * 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. 605 * </p> 606 * 607 * @param groupId the group ID 608 * @param active the active 609 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 610 * @return the last matching s c framework version 611 * @throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException if a matching s c framework version could not be found 612 * @throws SystemException if a system exception occurred 613 */ 614 public static com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion findByG_A_Last( 615 long groupId, boolean active, 616 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 617 throws com.liferay.portal.kernel.exception.SystemException, 618 com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException { 619 return getPersistence() 620 .findByG_A_Last(groupId, active, orderByComparator); 621 } 622 623 /** 624 * Returns the s c framework versions before and after the current s c framework version in the ordered set where groupId = ? and active = ?. 625 * 626 * <p> 627 * 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. 628 * </p> 629 * 630 * @param frameworkVersionId the primary key of the current s c framework version 631 * @param groupId the group ID 632 * @param active the active 633 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 634 * @return the previous, current, and next s c framework version 635 * @throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException if a s c framework version with the primary key could not be found 636 * @throws SystemException if a system exception occurred 637 */ 638 public static com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion[] findByG_A_PrevAndNext( 639 long frameworkVersionId, long groupId, boolean active, 640 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 641 throws com.liferay.portal.kernel.exception.SystemException, 642 com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException { 643 return getPersistence() 644 .findByG_A_PrevAndNext(frameworkVersionId, groupId, active, 645 orderByComparator); 646 } 647 648 /** 649 * Returns all the s c framework versions that the user has permission to view where groupId = ? and active = ?. 650 * 651 * @param groupId the group ID 652 * @param active the active 653 * @return the matching s c framework versions that the user has permission to view 654 * @throws SystemException if a system exception occurred 655 */ 656 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> filterFindByG_A( 657 long groupId, boolean active) 658 throws com.liferay.portal.kernel.exception.SystemException { 659 return getPersistence().filterFindByG_A(groupId, active); 660 } 661 662 /** 663 * Returns a range of all the s c framework versions that the user has permission to view where groupId = ? and active = ?. 664 * 665 * <p> 666 * 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. 667 * </p> 668 * 669 * @param groupId the group ID 670 * @param active the active 671 * @param start the lower bound of the range of s c framework versions 672 * @param end the upper bound of the range of s c framework versions (not inclusive) 673 * @return the range of matching s c framework versions that the user has permission to view 674 * @throws SystemException if a system exception occurred 675 */ 676 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> filterFindByG_A( 677 long groupId, boolean active, int start, int end) 678 throws com.liferay.portal.kernel.exception.SystemException { 679 return getPersistence().filterFindByG_A(groupId, active, start, end); 680 } 681 682 /** 683 * Returns an ordered range of all the s c framework versions that the user has permissions to view where groupId = ? and active = ?. 684 * 685 * <p> 686 * 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. 687 * </p> 688 * 689 * @param groupId the group ID 690 * @param active the active 691 * @param start the lower bound of the range of s c framework versions 692 * @param end the upper bound of the range of s c framework versions (not inclusive) 693 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 694 * @return the ordered range of matching s c framework versions that the user has permission to view 695 * @throws SystemException if a system exception occurred 696 */ 697 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> filterFindByG_A( 698 long groupId, boolean active, int start, int end, 699 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 700 throws com.liferay.portal.kernel.exception.SystemException { 701 return getPersistence() 702 .filterFindByG_A(groupId, active, start, end, 703 orderByComparator); 704 } 705 706 /** 707 * 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 = ?. 708 * 709 * @param frameworkVersionId the primary key of the current s c framework version 710 * @param groupId the group ID 711 * @param active the active 712 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 713 * @return the previous, current, and next s c framework version 714 * @throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException if a s c framework version with the primary key could not be found 715 * @throws SystemException if a system exception occurred 716 */ 717 public static com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion[] filterFindByG_A_PrevAndNext( 718 long frameworkVersionId, long groupId, boolean active, 719 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 720 throws com.liferay.portal.kernel.exception.SystemException, 721 com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException { 722 return getPersistence() 723 .filterFindByG_A_PrevAndNext(frameworkVersionId, groupId, 724 active, orderByComparator); 725 } 726 727 /** 728 * Returns all the s c framework versions. 729 * 730 * @return the s c framework versions 731 * @throws SystemException if a system exception occurred 732 */ 733 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> findAll() 734 throws com.liferay.portal.kernel.exception.SystemException { 735 return getPersistence().findAll(); 736 } 737 738 /** 739 * Returns a range of all the s c framework versions. 740 * 741 * <p> 742 * 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. 743 * </p> 744 * 745 * @param start the lower bound of the range of s c framework versions 746 * @param end the upper bound of the range of s c framework versions (not inclusive) 747 * @return the range of s c framework versions 748 * @throws SystemException if a system exception occurred 749 */ 750 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> findAll( 751 int start, int end) 752 throws com.liferay.portal.kernel.exception.SystemException { 753 return getPersistence().findAll(start, end); 754 } 755 756 /** 757 * Returns an ordered range of all the s c framework versions. 758 * 759 * <p> 760 * 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. 761 * </p> 762 * 763 * @param start the lower bound of the range of s c framework versions 764 * @param end the upper bound of the range of s c framework versions (not inclusive) 765 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 766 * @return the ordered range of s c framework versions 767 * @throws SystemException if a system exception occurred 768 */ 769 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> findAll( 770 int start, int end, 771 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 772 throws com.liferay.portal.kernel.exception.SystemException { 773 return getPersistence().findAll(start, end, orderByComparator); 774 } 775 776 /** 777 * Removes all the s c framework versions where groupId = ? from the database. 778 * 779 * @param groupId the group ID 780 * @throws SystemException if a system exception occurred 781 */ 782 public static void removeByGroupId(long groupId) 783 throws com.liferay.portal.kernel.exception.SystemException { 784 getPersistence().removeByGroupId(groupId); 785 } 786 787 /** 788 * Removes all the s c framework versions where companyId = ? from the database. 789 * 790 * @param companyId the company ID 791 * @throws SystemException if a system exception occurred 792 */ 793 public static void removeByCompanyId(long companyId) 794 throws com.liferay.portal.kernel.exception.SystemException { 795 getPersistence().removeByCompanyId(companyId); 796 } 797 798 /** 799 * Removes all the s c framework versions where groupId = ? and active = ? from the database. 800 * 801 * @param groupId the group ID 802 * @param active the active 803 * @throws SystemException if a system exception occurred 804 */ 805 public static void removeByG_A(long groupId, boolean active) 806 throws com.liferay.portal.kernel.exception.SystemException { 807 getPersistence().removeByG_A(groupId, active); 808 } 809 810 /** 811 * Removes all the s c framework versions from the database. 812 * 813 * @throws SystemException if a system exception occurred 814 */ 815 public static void removeAll() 816 throws com.liferay.portal.kernel.exception.SystemException { 817 getPersistence().removeAll(); 818 } 819 820 /** 821 * Returns the number of s c framework versions where groupId = ?. 822 * 823 * @param groupId the group ID 824 * @return the number of matching s c framework versions 825 * @throws SystemException if a system exception occurred 826 */ 827 public static int countByGroupId(long groupId) 828 throws com.liferay.portal.kernel.exception.SystemException { 829 return getPersistence().countByGroupId(groupId); 830 } 831 832 /** 833 * Returns the number of s c framework versions that the user has permission to view where groupId = ?. 834 * 835 * @param groupId the group ID 836 * @return the number of matching s c framework versions that the user has permission to view 837 * @throws SystemException if a system exception occurred 838 */ 839 public static int filterCountByGroupId(long groupId) 840 throws com.liferay.portal.kernel.exception.SystemException { 841 return getPersistence().filterCountByGroupId(groupId); 842 } 843 844 /** 845 * Returns the number of s c framework versions where companyId = ?. 846 * 847 * @param companyId the company ID 848 * @return the number of matching s c framework versions 849 * @throws SystemException if a system exception occurred 850 */ 851 public static int countByCompanyId(long companyId) 852 throws com.liferay.portal.kernel.exception.SystemException { 853 return getPersistence().countByCompanyId(companyId); 854 } 855 856 /** 857 * Returns the number of s c framework versions where groupId = ? and active = ?. 858 * 859 * @param groupId the group ID 860 * @param active the active 861 * @return the number of matching s c framework versions 862 * @throws SystemException if a system exception occurred 863 */ 864 public static int countByG_A(long groupId, boolean active) 865 throws com.liferay.portal.kernel.exception.SystemException { 866 return getPersistence().countByG_A(groupId, active); 867 } 868 869 /** 870 * Returns the number of s c framework versions that the user has permission to view where groupId = ? and active = ?. 871 * 872 * @param groupId the group ID 873 * @param active the active 874 * @return the number of matching s c framework versions that the user has permission to view 875 * @throws SystemException if a system exception occurred 876 */ 877 public static int filterCountByG_A(long groupId, boolean active) 878 throws com.liferay.portal.kernel.exception.SystemException { 879 return getPersistence().filterCountByG_A(groupId, active); 880 } 881 882 /** 883 * Returns the number of s c framework versions. 884 * 885 * @return the number of s c framework versions 886 * @throws SystemException if a system exception occurred 887 */ 888 public static int countAll() 889 throws com.liferay.portal.kernel.exception.SystemException { 890 return getPersistence().countAll(); 891 } 892 893 /** 894 * Returns all the s c product versions associated with the s c framework version. 895 * 896 * @param pk the primary key of the s c framework version 897 * @return the s c product versions associated with the s c framework version 898 * @throws SystemException if a system exception occurred 899 */ 900 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> getSCProductVersions( 901 long pk) throws com.liferay.portal.kernel.exception.SystemException { 902 return getPersistence().getSCProductVersions(pk); 903 } 904 905 /** 906 * Returns a range of all the s c product versions associated with the s c framework version. 907 * 908 * <p> 909 * 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. 910 * </p> 911 * 912 * @param pk the primary key of the s c framework version 913 * @param start the lower bound of the range of s c framework versions 914 * @param end the upper bound of the range of s c framework versions (not inclusive) 915 * @return the range of s c product versions associated with the s c framework version 916 * @throws SystemException if a system exception occurred 917 */ 918 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> getSCProductVersions( 919 long pk, int start, int end) 920 throws com.liferay.portal.kernel.exception.SystemException { 921 return getPersistence().getSCProductVersions(pk, start, end); 922 } 923 924 /** 925 * Returns an ordered range of all the s c product versions associated with the s c framework version. 926 * 927 * <p> 928 * 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. 929 * </p> 930 * 931 * @param pk the primary key of the s c framework version 932 * @param start the lower bound of the range of s c framework versions 933 * @param end the upper bound of the range of s c framework versions (not inclusive) 934 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 935 * @return the ordered range of s c product versions associated with the s c framework version 936 * @throws SystemException if a system exception occurred 937 */ 938 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> getSCProductVersions( 939 long pk, int start, int end, 940 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 941 throws com.liferay.portal.kernel.exception.SystemException { 942 return getPersistence() 943 .getSCProductVersions(pk, start, end, orderByComparator); 944 } 945 946 /** 947 * Returns the number of s c product versions associated with the s c framework version. 948 * 949 * @param pk the primary key of the s c framework version 950 * @return the number of s c product versions associated with the s c framework version 951 * @throws SystemException if a system exception occurred 952 */ 953 public static int getSCProductVersionsSize(long pk) 954 throws com.liferay.portal.kernel.exception.SystemException { 955 return getPersistence().getSCProductVersionsSize(pk); 956 } 957 958 /** 959 * Returns <code>true</code> if the s c product version is associated with the s c framework version. 960 * 961 * @param pk the primary key of the s c framework version 962 * @param scProductVersionPK the primary key of the s c product version 963 * @return <code>true</code> if the s c product version is associated with the s c framework version; <code>false</code> otherwise 964 * @throws SystemException if a system exception occurred 965 */ 966 public static boolean containsSCProductVersion(long pk, 967 long scProductVersionPK) 968 throws com.liferay.portal.kernel.exception.SystemException { 969 return getPersistence().containsSCProductVersion(pk, scProductVersionPK); 970 } 971 972 /** 973 * Returns <code>true</code> if the s c framework version has any s c product versions associated with it. 974 * 975 * @param pk the primary key of the s c framework version to check for associations with s c product versions 976 * @return <code>true</code> if the s c framework version has any s c product versions associated with it; <code>false</code> otherwise 977 * @throws SystemException if a system exception occurred 978 */ 979 public static boolean containsSCProductVersions(long pk) 980 throws com.liferay.portal.kernel.exception.SystemException { 981 return getPersistence().containsSCProductVersions(pk); 982 } 983 984 /** 985 * 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. 986 * 987 * @param pk the primary key of the s c framework version 988 * @param scProductVersionPK the primary key of the s c product version 989 * @throws SystemException if a system exception occurred 990 */ 991 public static void addSCProductVersion(long pk, long scProductVersionPK) 992 throws com.liferay.portal.kernel.exception.SystemException { 993 getPersistence().addSCProductVersion(pk, scProductVersionPK); 994 } 995 996 /** 997 * 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. 998 * 999 * @param pk the primary key of the s c framework version 1000 * @param scProductVersion the s c product version 1001 * @throws SystemException if a system exception occurred 1002 */ 1003 public static void addSCProductVersion(long pk, 1004 com.liferay.portlet.softwarecatalog.model.SCProductVersion scProductVersion) 1005 throws com.liferay.portal.kernel.exception.SystemException { 1006 getPersistence().addSCProductVersion(pk, scProductVersion); 1007 } 1008 1009 /** 1010 * 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. 1011 * 1012 * @param pk the primary key of the s c framework version 1013 * @param scProductVersionPKs the primary keys of the s c product versions 1014 * @throws SystemException if a system exception occurred 1015 */ 1016 public static void addSCProductVersions(long pk, long[] scProductVersionPKs) 1017 throws com.liferay.portal.kernel.exception.SystemException { 1018 getPersistence().addSCProductVersions(pk, scProductVersionPKs); 1019 } 1020 1021 /** 1022 * 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. 1023 * 1024 * @param pk the primary key of the s c framework version 1025 * @param scProductVersions the s c product versions 1026 * @throws SystemException if a system exception occurred 1027 */ 1028 public static void addSCProductVersions(long pk, 1029 java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> scProductVersions) 1030 throws com.liferay.portal.kernel.exception.SystemException { 1031 getPersistence().addSCProductVersions(pk, scProductVersions); 1032 } 1033 1034 /** 1035 * 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. 1036 * 1037 * @param pk the primary key of the s c framework version to clear the associated s c product versions from 1038 * @throws SystemException if a system exception occurred 1039 */ 1040 public static void clearSCProductVersions(long pk) 1041 throws com.liferay.portal.kernel.exception.SystemException { 1042 getPersistence().clearSCProductVersions(pk); 1043 } 1044 1045 /** 1046 * 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. 1047 * 1048 * @param pk the primary key of the s c framework version 1049 * @param scProductVersionPK the primary key of the s c product version 1050 * @throws SystemException if a system exception occurred 1051 */ 1052 public static void removeSCProductVersion(long pk, long scProductVersionPK) 1053 throws com.liferay.portal.kernel.exception.SystemException { 1054 getPersistence().removeSCProductVersion(pk, scProductVersionPK); 1055 } 1056 1057 /** 1058 * 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. 1059 * 1060 * @param pk the primary key of the s c framework version 1061 * @param scProductVersion the s c product version 1062 * @throws SystemException if a system exception occurred 1063 */ 1064 public static void removeSCProductVersion(long pk, 1065 com.liferay.portlet.softwarecatalog.model.SCProductVersion scProductVersion) 1066 throws com.liferay.portal.kernel.exception.SystemException { 1067 getPersistence().removeSCProductVersion(pk, scProductVersion); 1068 } 1069 1070 /** 1071 * 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. 1072 * 1073 * @param pk the primary key of the s c framework version 1074 * @param scProductVersionPKs the primary keys of the s c product versions 1075 * @throws SystemException if a system exception occurred 1076 */ 1077 public static void removeSCProductVersions(long pk, 1078 long[] scProductVersionPKs) 1079 throws com.liferay.portal.kernel.exception.SystemException { 1080 getPersistence().removeSCProductVersions(pk, scProductVersionPKs); 1081 } 1082 1083 /** 1084 * 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. 1085 * 1086 * @param pk the primary key of the s c framework version 1087 * @param scProductVersions the s c product versions 1088 * @throws SystemException if a system exception occurred 1089 */ 1090 public static void removeSCProductVersions(long pk, 1091 java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> scProductVersions) 1092 throws com.liferay.portal.kernel.exception.SystemException { 1093 getPersistence().removeSCProductVersions(pk, scProductVersions); 1094 } 1095 1096 /** 1097 * 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. 1098 * 1099 * @param pk the primary key of the s c framework version 1100 * @param scProductVersionPKs the primary keys of the s c product versions to be associated with the s c framework version 1101 * @throws SystemException if a system exception occurred 1102 */ 1103 public static void setSCProductVersions(long pk, long[] scProductVersionPKs) 1104 throws com.liferay.portal.kernel.exception.SystemException { 1105 getPersistence().setSCProductVersions(pk, scProductVersionPKs); 1106 } 1107 1108 /** 1109 * 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. 1110 * 1111 * @param pk the primary key of the s c framework version 1112 * @param scProductVersions the s c product versions to be associated with the s c framework version 1113 * @throws SystemException if a system exception occurred 1114 */ 1115 public static void setSCProductVersions(long pk, 1116 java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> scProductVersions) 1117 throws com.liferay.portal.kernel.exception.SystemException { 1118 getPersistence().setSCProductVersions(pk, scProductVersions); 1119 } 1120 1121 public static SCFrameworkVersionPersistence getPersistence() { 1122 if (_persistence == null) { 1123 _persistence = (SCFrameworkVersionPersistence)PortalBeanLocatorUtil.locate(SCFrameworkVersionPersistence.class.getName()); 1124 1125 ReferenceRegistry.registerReference(SCFrameworkVersionUtil.class, 1126 "_persistence"); 1127 } 1128 1129 return _persistence; 1130 } 1131 1132 public void setPersistence(SCFrameworkVersionPersistence persistence) { 1133 _persistence = persistence; 1134 1135 ReferenceRegistry.registerReference(SCFrameworkVersionUtil.class, 1136 "_persistence"); 1137 } 1138 1139 private static SCFrameworkVersionPersistence _persistence; 1140 }