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