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