001 /** 002 * Copyright (c) 2000-2013 Liferay, Inc. All rights reserved. 003 * 004 * This library is free software; you can redistribute it and/or modify it under 005 * the terms of the GNU Lesser General Public License as published by the Free 006 * Software Foundation; either version 2.1 of the License, or (at your option) 007 * any later version. 008 * 009 * This library is distributed in the hope that it will be useful, but WITHOUT 010 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 011 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more 012 * details. 013 */ 014 015 package com.liferay.portlet.softwarecatalog.service.persistence; 016 017 import aQute.bnd.annotation.ProviderType; 018 019 import com.liferay.portal.service.persistence.BasePersistence; 020 021 import com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion; 022 023 /** 024 * The persistence interface for the s c framework version service. 025 * 026 * <p> 027 * Caching information and settings can be found in <code>portal.properties</code> 028 * </p> 029 * 030 * @author Brian Wing Shun Chan 031 * @see SCFrameworkVersionPersistenceImpl 032 * @see SCFrameworkVersionUtil 033 * @generated 034 */ 035 @ProviderType 036 public interface SCFrameworkVersionPersistence extends BasePersistence<SCFrameworkVersion> { 037 /* 038 * NOTE FOR DEVELOPERS: 039 * 040 * Never modify or reference this interface directly. Always use {@link SCFrameworkVersionUtil} to access the s c framework version persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this interface. 041 */ 042 043 /** 044 * Returns all the s c framework versions where groupId = ?. 045 * 046 * @param groupId the group ID 047 * @return the matching s c framework versions 048 * @throws SystemException if a system exception occurred 049 */ 050 public java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> findByGroupId( 051 long groupId) 052 throws com.liferay.portal.kernel.exception.SystemException; 053 054 /** 055 * Returns a range of all the s c framework versions where groupId = ?. 056 * 057 * <p> 058 * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.softwarecatalog.model.impl.SCFrameworkVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 059 * </p> 060 * 061 * @param groupId the group ID 062 * @param start the lower bound of the range of s c framework versions 063 * @param end the upper bound of the range of s c framework versions (not inclusive) 064 * @return the range of matching s c framework versions 065 * @throws SystemException if a system exception occurred 066 */ 067 public java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> findByGroupId( 068 long groupId, int start, int end) 069 throws com.liferay.portal.kernel.exception.SystemException; 070 071 /** 072 * Returns an ordered range of all the s c framework versions where groupId = ?. 073 * 074 * <p> 075 * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.softwarecatalog.model.impl.SCFrameworkVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 076 * </p> 077 * 078 * @param groupId the group ID 079 * @param start the lower bound of the range of s c framework versions 080 * @param end the upper bound of the range of s c framework versions (not inclusive) 081 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 082 * @return the ordered range of matching s c framework versions 083 * @throws SystemException if a system exception occurred 084 */ 085 public java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> findByGroupId( 086 long groupId, int start, int end, 087 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 088 throws com.liferay.portal.kernel.exception.SystemException; 089 090 /** 091 * Returns the first s c framework version in the ordered set where groupId = ?. 092 * 093 * @param groupId the group ID 094 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 095 * @return the first matching s c framework version 096 * @throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException if a matching s c framework version could not be found 097 * @throws SystemException if a system exception occurred 098 */ 099 public com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion findByGroupId_First( 100 long groupId, 101 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 102 throws com.liferay.portal.kernel.exception.SystemException, 103 com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException; 104 105 /** 106 * Returns the first s c framework version in the ordered set where groupId = ?. 107 * 108 * @param groupId the group ID 109 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 110 * @return the first matching s c framework version, or <code>null</code> if a matching s c framework version could not be found 111 * @throws SystemException if a system exception occurred 112 */ 113 public com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion fetchByGroupId_First( 114 long groupId, 115 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 116 throws com.liferay.portal.kernel.exception.SystemException; 117 118 /** 119 * Returns the last s c framework version in the ordered set where groupId = ?. 120 * 121 * @param groupId the group ID 122 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 123 * @return the last matching s c framework version 124 * @throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException if a matching s c framework version could not be found 125 * @throws SystemException if a system exception occurred 126 */ 127 public com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion findByGroupId_Last( 128 long groupId, 129 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 130 throws com.liferay.portal.kernel.exception.SystemException, 131 com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException; 132 133 /** 134 * Returns the last s c framework version in the ordered set where groupId = ?. 135 * 136 * @param groupId the group ID 137 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 138 * @return the last matching s c framework version, or <code>null</code> if a matching s c framework version could not be found 139 * @throws SystemException if a system exception occurred 140 */ 141 public com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion fetchByGroupId_Last( 142 long groupId, 143 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 144 throws com.liferay.portal.kernel.exception.SystemException; 145 146 /** 147 * Returns the s c framework versions before and after the current s c framework version in the ordered set where groupId = ?. 148 * 149 * @param frameworkVersionId the primary key of the current s c framework version 150 * @param groupId the group ID 151 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 152 * @return the previous, current, and next s c framework version 153 * @throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException if a s c framework version with the primary key could not be found 154 * @throws SystemException if a system exception occurred 155 */ 156 public com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion[] findByGroupId_PrevAndNext( 157 long frameworkVersionId, long groupId, 158 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 159 throws com.liferay.portal.kernel.exception.SystemException, 160 com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException; 161 162 /** 163 * Returns all the s c framework versions that the user has permission to view where groupId = ?. 164 * 165 * @param groupId the group ID 166 * @return the matching s c framework versions that the user has permission to view 167 * @throws SystemException if a system exception occurred 168 */ 169 public java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> filterFindByGroupId( 170 long groupId) 171 throws com.liferay.portal.kernel.exception.SystemException; 172 173 /** 174 * Returns a range of all the s c framework versions that the user has permission to view where groupId = ?. 175 * 176 * <p> 177 * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.softwarecatalog.model.impl.SCFrameworkVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 178 * </p> 179 * 180 * @param groupId the group ID 181 * @param start the lower bound of the range of s c framework versions 182 * @param end the upper bound of the range of s c framework versions (not inclusive) 183 * @return the range of matching s c framework versions that the user has permission to view 184 * @throws SystemException if a system exception occurred 185 */ 186 public java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> filterFindByGroupId( 187 long groupId, int start, int end) 188 throws com.liferay.portal.kernel.exception.SystemException; 189 190 /** 191 * Returns an ordered range of all the s c framework versions that the user has permissions to view where groupId = ?. 192 * 193 * <p> 194 * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.softwarecatalog.model.impl.SCFrameworkVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 195 * </p> 196 * 197 * @param groupId the group ID 198 * @param start the lower bound of the range of s c framework versions 199 * @param end the upper bound of the range of s c framework versions (not inclusive) 200 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 201 * @return the ordered range of matching s c framework versions that the user has permission to view 202 * @throws SystemException if a system exception occurred 203 */ 204 public java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> filterFindByGroupId( 205 long groupId, int start, int end, 206 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 207 throws com.liferay.portal.kernel.exception.SystemException; 208 209 /** 210 * 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 = ?. 211 * 212 * @param frameworkVersionId the primary key of the current s c framework version 213 * @param groupId the group ID 214 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 215 * @return the previous, current, and next s c framework version 216 * @throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException if a s c framework version with the primary key could not be found 217 * @throws SystemException if a system exception occurred 218 */ 219 public com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion[] filterFindByGroupId_PrevAndNext( 220 long frameworkVersionId, long groupId, 221 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 222 throws com.liferay.portal.kernel.exception.SystemException, 223 com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException; 224 225 /** 226 * Removes all the s c framework versions where groupId = ? from the database. 227 * 228 * @param groupId the group ID 229 * @throws SystemException if a system exception occurred 230 */ 231 public void removeByGroupId(long groupId) 232 throws com.liferay.portal.kernel.exception.SystemException; 233 234 /** 235 * Returns the number of s c framework versions where groupId = ?. 236 * 237 * @param groupId the group ID 238 * @return the number of matching s c framework versions 239 * @throws SystemException if a system exception occurred 240 */ 241 public int countByGroupId(long groupId) 242 throws com.liferay.portal.kernel.exception.SystemException; 243 244 /** 245 * Returns the number of s c framework versions that the user has permission to view where groupId = ?. 246 * 247 * @param groupId the group ID 248 * @return the number of matching s c framework versions that the user has permission to view 249 * @throws SystemException if a system exception occurred 250 */ 251 public int filterCountByGroupId(long groupId) 252 throws com.liferay.portal.kernel.exception.SystemException; 253 254 /** 255 * Returns all the s c framework versions where companyId = ?. 256 * 257 * @param companyId the company ID 258 * @return the matching s c framework versions 259 * @throws SystemException if a system exception occurred 260 */ 261 public java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> findByCompanyId( 262 long companyId) 263 throws com.liferay.portal.kernel.exception.SystemException; 264 265 /** 266 * Returns a range of all the s c framework versions where companyId = ?. 267 * 268 * <p> 269 * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.softwarecatalog.model.impl.SCFrameworkVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 270 * </p> 271 * 272 * @param companyId the company ID 273 * @param start the lower bound of the range of s c framework versions 274 * @param end the upper bound of the range of s c framework versions (not inclusive) 275 * @return the range of matching s c framework versions 276 * @throws SystemException if a system exception occurred 277 */ 278 public java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> findByCompanyId( 279 long companyId, int start, int end) 280 throws com.liferay.portal.kernel.exception.SystemException; 281 282 /** 283 * Returns an ordered range of all the s c framework versions where companyId = ?. 284 * 285 * <p> 286 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.softwarecatalog.model.impl.SCFrameworkVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 287 * </p> 288 * 289 * @param companyId the company ID 290 * @param start the lower bound of the range of s c framework versions 291 * @param end the upper bound of the range of s c framework versions (not inclusive) 292 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 293 * @return the ordered range of matching s c framework versions 294 * @throws SystemException if a system exception occurred 295 */ 296 public java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> findByCompanyId( 297 long companyId, int start, int end, 298 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 299 throws com.liferay.portal.kernel.exception.SystemException; 300 301 /** 302 * Returns the first s c framework version in the ordered set where companyId = ?. 303 * 304 * @param companyId the company ID 305 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 306 * @return the first matching s c framework version 307 * @throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException if a matching s c framework version could not be found 308 * @throws SystemException if a system exception occurred 309 */ 310 public com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion findByCompanyId_First( 311 long companyId, 312 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 313 throws com.liferay.portal.kernel.exception.SystemException, 314 com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException; 315 316 /** 317 * Returns the first s c framework version in the ordered set where companyId = ?. 318 * 319 * @param companyId the company ID 320 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 321 * @return the first matching s c framework version, or <code>null</code> if a matching s c framework version could not be found 322 * @throws SystemException if a system exception occurred 323 */ 324 public com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion fetchByCompanyId_First( 325 long companyId, 326 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 327 throws com.liferay.portal.kernel.exception.SystemException; 328 329 /** 330 * Returns the last s c framework version in the ordered set where companyId = ?. 331 * 332 * @param companyId the company ID 333 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 334 * @return the last matching s c framework version 335 * @throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException if a matching s c framework version could not be found 336 * @throws SystemException if a system exception occurred 337 */ 338 public com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion findByCompanyId_Last( 339 long companyId, 340 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 341 throws com.liferay.portal.kernel.exception.SystemException, 342 com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException; 343 344 /** 345 * Returns the last s c framework version in the ordered set where companyId = ?. 346 * 347 * @param companyId the company ID 348 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 349 * @return the last matching s c framework version, or <code>null</code> if a matching s c framework version could not be found 350 * @throws SystemException if a system exception occurred 351 */ 352 public com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion fetchByCompanyId_Last( 353 long companyId, 354 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 355 throws com.liferay.portal.kernel.exception.SystemException; 356 357 /** 358 * Returns the s c framework versions before and after the current s c framework version in the ordered set where companyId = ?. 359 * 360 * @param frameworkVersionId the primary key of the current s c framework version 361 * @param companyId the company ID 362 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 363 * @return the previous, current, and next s c framework version 364 * @throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException if a s c framework version with the primary key could not be found 365 * @throws SystemException if a system exception occurred 366 */ 367 public com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion[] findByCompanyId_PrevAndNext( 368 long frameworkVersionId, long companyId, 369 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 370 throws com.liferay.portal.kernel.exception.SystemException, 371 com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException; 372 373 /** 374 * Removes all the s c framework versions where companyId = ? from the database. 375 * 376 * @param companyId the company ID 377 * @throws SystemException if a system exception occurred 378 */ 379 public void removeByCompanyId(long companyId) 380 throws com.liferay.portal.kernel.exception.SystemException; 381 382 /** 383 * Returns the number of s c framework versions where companyId = ?. 384 * 385 * @param companyId the company ID 386 * @return the number of matching s c framework versions 387 * @throws SystemException if a system exception occurred 388 */ 389 public int countByCompanyId(long companyId) 390 throws com.liferay.portal.kernel.exception.SystemException; 391 392 /** 393 * Returns all the s c framework versions where groupId = ? and active = ?. 394 * 395 * @param groupId the group ID 396 * @param active the active 397 * @return the matching s c framework versions 398 * @throws SystemException if a system exception occurred 399 */ 400 public java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> findByG_A( 401 long groupId, boolean active) 402 throws com.liferay.portal.kernel.exception.SystemException; 403 404 /** 405 * Returns a range of all the s c framework versions where groupId = ? and active = ?. 406 * 407 * <p> 408 * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.softwarecatalog.model.impl.SCFrameworkVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 409 * </p> 410 * 411 * @param groupId the group ID 412 * @param active the active 413 * @param start the lower bound of the range of s c framework versions 414 * @param end the upper bound of the range of s c framework versions (not inclusive) 415 * @return the range of matching s c framework versions 416 * @throws SystemException if a system exception occurred 417 */ 418 public java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> findByG_A( 419 long groupId, boolean active, int start, int end) 420 throws com.liferay.portal.kernel.exception.SystemException; 421 422 /** 423 * Returns an ordered range of all the s c framework versions where groupId = ? and active = ?. 424 * 425 * <p> 426 * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.softwarecatalog.model.impl.SCFrameworkVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 427 * </p> 428 * 429 * @param groupId the group ID 430 * @param active the active 431 * @param start the lower bound of the range of s c framework versions 432 * @param end the upper bound of the range of s c framework versions (not inclusive) 433 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 434 * @return the ordered range of matching s c framework versions 435 * @throws SystemException if a system exception occurred 436 */ 437 public java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> findByG_A( 438 long groupId, boolean active, int start, int end, 439 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 440 throws com.liferay.portal.kernel.exception.SystemException; 441 442 /** 443 * Returns the first s c framework version in the ordered set where groupId = ? and active = ?. 444 * 445 * @param groupId the group ID 446 * @param active the active 447 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 448 * @return the first matching s c framework version 449 * @throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException if a matching s c framework version could not be found 450 * @throws SystemException if a system exception occurred 451 */ 452 public com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion findByG_A_First( 453 long groupId, boolean active, 454 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 455 throws com.liferay.portal.kernel.exception.SystemException, 456 com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException; 457 458 /** 459 * Returns the first s c framework version in the ordered set where groupId = ? and active = ?. 460 * 461 * @param groupId the group ID 462 * @param active the active 463 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 464 * @return the first matching s c framework version, or <code>null</code> if a matching s c framework version could not be found 465 * @throws SystemException if a system exception occurred 466 */ 467 public com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion fetchByG_A_First( 468 long groupId, boolean active, 469 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 470 throws com.liferay.portal.kernel.exception.SystemException; 471 472 /** 473 * Returns the last s c framework version in the ordered set where groupId = ? and active = ?. 474 * 475 * @param groupId the group ID 476 * @param active the active 477 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 478 * @return the last matching s c framework version 479 * @throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException if a matching s c framework version could not be found 480 * @throws SystemException if a system exception occurred 481 */ 482 public com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion findByG_A_Last( 483 long groupId, boolean active, 484 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 485 throws com.liferay.portal.kernel.exception.SystemException, 486 com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException; 487 488 /** 489 * Returns the last s c framework version in the ordered set where groupId = ? and active = ?. 490 * 491 * @param groupId the group ID 492 * @param active the active 493 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 494 * @return the last matching s c framework version, or <code>null</code> if a matching s c framework version could not be found 495 * @throws SystemException if a system exception occurred 496 */ 497 public com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion fetchByG_A_Last( 498 long groupId, boolean active, 499 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 500 throws com.liferay.portal.kernel.exception.SystemException; 501 502 /** 503 * Returns the s c framework versions before and after the current s c framework version in the ordered set where groupId = ? and active = ?. 504 * 505 * @param frameworkVersionId the primary key of the current s c framework version 506 * @param groupId the group ID 507 * @param active the active 508 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 509 * @return the previous, current, and next s c framework version 510 * @throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException if a s c framework version with the primary key could not be found 511 * @throws SystemException if a system exception occurred 512 */ 513 public com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion[] findByG_A_PrevAndNext( 514 long frameworkVersionId, long groupId, boolean active, 515 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 516 throws com.liferay.portal.kernel.exception.SystemException, 517 com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException; 518 519 /** 520 * Returns all the s c framework versions that the user has permission to view where groupId = ? and active = ?. 521 * 522 * @param groupId the group ID 523 * @param active the active 524 * @return the matching s c framework versions that the user has permission to view 525 * @throws SystemException if a system exception occurred 526 */ 527 public java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> filterFindByG_A( 528 long groupId, boolean active) 529 throws com.liferay.portal.kernel.exception.SystemException; 530 531 /** 532 * Returns a range of all the s c framework versions that the user has permission to view where groupId = ? and active = ?. 533 * 534 * <p> 535 * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.softwarecatalog.model.impl.SCFrameworkVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 536 * </p> 537 * 538 * @param groupId the group ID 539 * @param active the active 540 * @param start the lower bound of the range of s c framework versions 541 * @param end the upper bound of the range of s c framework versions (not inclusive) 542 * @return the range of matching s c framework versions that the user has permission to view 543 * @throws SystemException if a system exception occurred 544 */ 545 public java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> filterFindByG_A( 546 long groupId, boolean active, int start, int end) 547 throws com.liferay.portal.kernel.exception.SystemException; 548 549 /** 550 * Returns an ordered range of all the s c framework versions that the user has permissions to view where groupId = ? and active = ?. 551 * 552 * <p> 553 * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.softwarecatalog.model.impl.SCFrameworkVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 554 * </p> 555 * 556 * @param groupId the group ID 557 * @param active the active 558 * @param start the lower bound of the range of s c framework versions 559 * @param end the upper bound of the range of s c framework versions (not inclusive) 560 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 561 * @return the ordered range of matching s c framework versions that the user has permission to view 562 * @throws SystemException if a system exception occurred 563 */ 564 public java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> filterFindByG_A( 565 long groupId, boolean active, int start, int end, 566 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 567 throws com.liferay.portal.kernel.exception.SystemException; 568 569 /** 570 * 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 = ?. 571 * 572 * @param frameworkVersionId the primary key of the current s c framework version 573 * @param groupId the group ID 574 * @param active the active 575 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 576 * @return the previous, current, and next s c framework version 577 * @throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException if a s c framework version with the primary key could not be found 578 * @throws SystemException if a system exception occurred 579 */ 580 public com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion[] filterFindByG_A_PrevAndNext( 581 long frameworkVersionId, long groupId, boolean active, 582 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 583 throws com.liferay.portal.kernel.exception.SystemException, 584 com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException; 585 586 /** 587 * Removes all the s c framework versions where groupId = ? and active = ? from the database. 588 * 589 * @param groupId the group ID 590 * @param active the active 591 * @throws SystemException if a system exception occurred 592 */ 593 public void removeByG_A(long groupId, boolean active) 594 throws com.liferay.portal.kernel.exception.SystemException; 595 596 /** 597 * Returns the number of s c framework versions where groupId = ? and active = ?. 598 * 599 * @param groupId the group ID 600 * @param active the active 601 * @return the number of matching s c framework versions 602 * @throws SystemException if a system exception occurred 603 */ 604 public int countByG_A(long groupId, boolean active) 605 throws com.liferay.portal.kernel.exception.SystemException; 606 607 /** 608 * Returns the number of s c framework versions that the user has permission to view where groupId = ? and active = ?. 609 * 610 * @param groupId the group ID 611 * @param active the active 612 * @return the number of matching s c framework versions that the user has permission to view 613 * @throws SystemException if a system exception occurred 614 */ 615 public int filterCountByG_A(long groupId, boolean active) 616 throws com.liferay.portal.kernel.exception.SystemException; 617 618 /** 619 * Caches the s c framework version in the entity cache if it is enabled. 620 * 621 * @param scFrameworkVersion the s c framework version 622 */ 623 public void cacheResult( 624 com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion scFrameworkVersion); 625 626 /** 627 * Caches the s c framework versions in the entity cache if it is enabled. 628 * 629 * @param scFrameworkVersions the s c framework versions 630 */ 631 public void cacheResult( 632 java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> scFrameworkVersions); 633 634 /** 635 * Creates a new s c framework version with the primary key. Does not add the s c framework version to the database. 636 * 637 * @param frameworkVersionId the primary key for the new s c framework version 638 * @return the new s c framework version 639 */ 640 public com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion create( 641 long frameworkVersionId); 642 643 /** 644 * Removes the s c framework version with the primary key from the database. Also notifies the appropriate model listeners. 645 * 646 * @param frameworkVersionId the primary key of the s c framework version 647 * @return the s c framework version that was removed 648 * @throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException if a s c framework version with the primary key could not be found 649 * @throws SystemException if a system exception occurred 650 */ 651 public com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion remove( 652 long frameworkVersionId) 653 throws com.liferay.portal.kernel.exception.SystemException, 654 com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException; 655 656 public com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion updateImpl( 657 com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion scFrameworkVersion) 658 throws com.liferay.portal.kernel.exception.SystemException; 659 660 /** 661 * 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. 662 * 663 * @param frameworkVersionId the primary key of the s c framework version 664 * @return the s c framework version 665 * @throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException if a s c framework version with the primary key could not be found 666 * @throws SystemException if a system exception occurred 667 */ 668 public com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion findByPrimaryKey( 669 long frameworkVersionId) 670 throws com.liferay.portal.kernel.exception.SystemException, 671 com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException; 672 673 /** 674 * Returns the s c framework version with the primary key or returns <code>null</code> if it could not be found. 675 * 676 * @param frameworkVersionId the primary key of the s c framework version 677 * @return the s c framework version, or <code>null</code> if a s c framework version with the primary key could not be found 678 * @throws SystemException if a system exception occurred 679 */ 680 public com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion fetchByPrimaryKey( 681 long frameworkVersionId) 682 throws com.liferay.portal.kernel.exception.SystemException; 683 684 /** 685 * Returns all the s c framework versions. 686 * 687 * @return the s c framework versions 688 * @throws SystemException if a system exception occurred 689 */ 690 public java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> findAll() 691 throws com.liferay.portal.kernel.exception.SystemException; 692 693 /** 694 * Returns a range of all the s c framework versions. 695 * 696 * <p> 697 * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.softwarecatalog.model.impl.SCFrameworkVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 698 * </p> 699 * 700 * @param start the lower bound of the range of s c framework versions 701 * @param end the upper bound of the range of s c framework versions (not inclusive) 702 * @return the range of s c framework versions 703 * @throws SystemException if a system exception occurred 704 */ 705 public java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> findAll( 706 int start, int end) 707 throws com.liferay.portal.kernel.exception.SystemException; 708 709 /** 710 * Returns an ordered range of all the s c framework versions. 711 * 712 * <p> 713 * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.softwarecatalog.model.impl.SCFrameworkVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 714 * </p> 715 * 716 * @param start the lower bound of the range of s c framework versions 717 * @param end the upper bound of the range of s c framework versions (not inclusive) 718 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 719 * @return the ordered range of s c framework versions 720 * @throws SystemException if a system exception occurred 721 */ 722 public java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> findAll( 723 int start, int end, 724 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 725 throws com.liferay.portal.kernel.exception.SystemException; 726 727 /** 728 * Removes all the s c framework versions from the database. 729 * 730 * @throws SystemException if a system exception occurred 731 */ 732 public void removeAll() 733 throws com.liferay.portal.kernel.exception.SystemException; 734 735 /** 736 * Returns the number of s c framework versions. 737 * 738 * @return the number of s c framework versions 739 * @throws SystemException if a system exception occurred 740 */ 741 public int countAll() 742 throws com.liferay.portal.kernel.exception.SystemException; 743 744 /** 745 * Returns all the s c product versions associated with the s c framework version. 746 * 747 * @param pk the primary key of the s c framework version 748 * @return the s c product versions associated with the s c framework version 749 * @throws SystemException if a system exception occurred 750 */ 751 public java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> getSCProductVersions( 752 long pk) throws com.liferay.portal.kernel.exception.SystemException; 753 754 /** 755 * Returns a range of all the s c product versions associated with the s c framework version. 756 * 757 * <p> 758 * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.softwarecatalog.model.impl.SCFrameworkVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 759 * </p> 760 * 761 * @param pk the primary key of the s c framework version 762 * @param start the lower bound of the range of s c framework versions 763 * @param end the upper bound of the range of s c framework versions (not inclusive) 764 * @return the range of s c product versions associated with the s c framework version 765 * @throws SystemException if a system exception occurred 766 */ 767 public java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> getSCProductVersions( 768 long pk, int start, int end) 769 throws com.liferay.portal.kernel.exception.SystemException; 770 771 /** 772 * Returns an ordered range of all the s c product versions associated with the s c framework version. 773 * 774 * <p> 775 * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.softwarecatalog.model.impl.SCFrameworkVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 776 * </p> 777 * 778 * @param pk the primary key of the s c framework version 779 * @param start the lower bound of the range of s c framework versions 780 * @param end the upper bound of the range of s c framework versions (not inclusive) 781 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 782 * @return the ordered range of s c product versions associated with the s c framework version 783 * @throws SystemException if a system exception occurred 784 */ 785 public java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> getSCProductVersions( 786 long pk, int start, int end, 787 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 788 throws com.liferay.portal.kernel.exception.SystemException; 789 790 /** 791 * Returns the number of s c product versions associated with the s c framework version. 792 * 793 * @param pk the primary key of the s c framework version 794 * @return the number of s c product versions associated with the s c framework version 795 * @throws SystemException if a system exception occurred 796 */ 797 public int getSCProductVersionsSize(long pk) 798 throws com.liferay.portal.kernel.exception.SystemException; 799 800 /** 801 * Returns <code>true</code> if the s c product version is associated with the s c framework version. 802 * 803 * @param pk the primary key of the s c framework version 804 * @param scProductVersionPK the primary key of the s c product version 805 * @return <code>true</code> if the s c product version is associated with the s c framework version; <code>false</code> otherwise 806 * @throws SystemException if a system exception occurred 807 */ 808 public boolean containsSCProductVersion(long pk, long scProductVersionPK) 809 throws com.liferay.portal.kernel.exception.SystemException; 810 811 /** 812 * Returns <code>true</code> if the s c framework version has any s c product versions associated with it. 813 * 814 * @param pk the primary key of the s c framework version to check for associations with s c product versions 815 * @return <code>true</code> if the s c framework version has any s c product versions associated with it; <code>false</code> otherwise 816 * @throws SystemException if a system exception occurred 817 */ 818 public boolean containsSCProductVersions(long pk) 819 throws com.liferay.portal.kernel.exception.SystemException; 820 821 /** 822 * 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. 823 * 824 * @param pk the primary key of the s c framework version 825 * @param scProductVersionPK the primary key of the s c product version 826 * @throws SystemException if a system exception occurred 827 */ 828 public void addSCProductVersion(long pk, long scProductVersionPK) 829 throws com.liferay.portal.kernel.exception.SystemException; 830 831 /** 832 * 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. 833 * 834 * @param pk the primary key of the s c framework version 835 * @param scProductVersion the s c product version 836 * @throws SystemException if a system exception occurred 837 */ 838 public void addSCProductVersion(long pk, 839 com.liferay.portlet.softwarecatalog.model.SCProductVersion scProductVersion) 840 throws com.liferay.portal.kernel.exception.SystemException; 841 842 /** 843 * 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. 844 * 845 * @param pk the primary key of the s c framework version 846 * @param scProductVersionPKs the primary keys of the s c product versions 847 * @throws SystemException if a system exception occurred 848 */ 849 public void addSCProductVersions(long pk, long[] scProductVersionPKs) 850 throws com.liferay.portal.kernel.exception.SystemException; 851 852 /** 853 * 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. 854 * 855 * @param pk the primary key of the s c framework version 856 * @param scProductVersions the s c product versions 857 * @throws SystemException if a system exception occurred 858 */ 859 public void addSCProductVersions(long pk, 860 java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> scProductVersions) 861 throws com.liferay.portal.kernel.exception.SystemException; 862 863 /** 864 * 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. 865 * 866 * @param pk the primary key of the s c framework version to clear the associated s c product versions from 867 * @throws SystemException if a system exception occurred 868 */ 869 public void clearSCProductVersions(long pk) 870 throws com.liferay.portal.kernel.exception.SystemException; 871 872 /** 873 * 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. 874 * 875 * @param pk the primary key of the s c framework version 876 * @param scProductVersionPK the primary key of the s c product version 877 * @throws SystemException if a system exception occurred 878 */ 879 public void removeSCProductVersion(long pk, long scProductVersionPK) 880 throws com.liferay.portal.kernel.exception.SystemException; 881 882 /** 883 * 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. 884 * 885 * @param pk the primary key of the s c framework version 886 * @param scProductVersion the s c product version 887 * @throws SystemException if a system exception occurred 888 */ 889 public void removeSCProductVersion(long pk, 890 com.liferay.portlet.softwarecatalog.model.SCProductVersion scProductVersion) 891 throws com.liferay.portal.kernel.exception.SystemException; 892 893 /** 894 * 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. 895 * 896 * @param pk the primary key of the s c framework version 897 * @param scProductVersionPKs the primary keys of the s c product versions 898 * @throws SystemException if a system exception occurred 899 */ 900 public void removeSCProductVersions(long pk, long[] scProductVersionPKs) 901 throws com.liferay.portal.kernel.exception.SystemException; 902 903 /** 904 * 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. 905 * 906 * @param pk the primary key of the s c framework version 907 * @param scProductVersions the s c product versions 908 * @throws SystemException if a system exception occurred 909 */ 910 public void removeSCProductVersions(long pk, 911 java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> scProductVersions) 912 throws com.liferay.portal.kernel.exception.SystemException; 913 914 /** 915 * 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. 916 * 917 * @param pk the primary key of the s c framework version 918 * @param scProductVersionPKs the primary keys of the s c product versions to be associated with the s c framework version 919 * @throws SystemException if a system exception occurred 920 */ 921 public void setSCProductVersions(long pk, long[] scProductVersionPKs) 922 throws com.liferay.portal.kernel.exception.SystemException; 923 924 /** 925 * 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. 926 * 927 * @param pk the primary key of the s c framework version 928 * @param scProductVersions the s c product versions to be associated with the s c framework version 929 * @throws SystemException if a system exception occurred 930 */ 931 public void setSCProductVersions(long pk, 932 java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> scProductVersions) 933 throws com.liferay.portal.kernel.exception.SystemException; 934 }