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