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