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