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