001 /** 002 * Copyright (c) 2000-2013 Liferay, Inc. All rights reserved. 003 * 004 * This library is free software; you can redistribute it and/or modify it under 005 * the terms of the GNU Lesser General Public License as published by the Free 006 * Software Foundation; either version 2.1 of the License, or (at your option) 007 * any later version. 008 * 009 * This library is distributed in the hope that it will be useful, but WITHOUT 010 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 011 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more 012 * details. 013 */ 014 015 package com.liferay.portlet.journal.service.persistence; 016 017 import com.liferay.portal.service.persistence.BasePersistence; 018 019 import com.liferay.portlet.journal.model.JournalStructure; 020 021 /** 022 * The persistence interface for the journal structure service. 023 * 024 * <p> 025 * Caching information and settings can be found in <code>portal.properties</code> 026 * </p> 027 * 028 * @author Brian Wing Shun Chan 029 * @see JournalStructurePersistenceImpl 030 * @see JournalStructureUtil 031 * @generated 032 */ 033 public interface JournalStructurePersistence extends BasePersistence<JournalStructure> { 034 /* 035 * NOTE FOR DEVELOPERS: 036 * 037 * Never modify or reference this interface directly. Always use {@link JournalStructureUtil} to access the journal structure persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this interface. 038 */ 039 040 /** 041 * Returns all the journal structures where uuid = ?. 042 * 043 * @param uuid the uuid 044 * @return the matching journal structures 045 * @throws SystemException if a system exception occurred 046 */ 047 public java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByUuid( 048 java.lang.String uuid) 049 throws com.liferay.portal.kernel.exception.SystemException; 050 051 /** 052 * Returns a range of all the journal structures where uuid = ?. 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 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.journal.model.impl.JournalStructureModelImpl}. 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 uuid the uuid 059 * @param start the lower bound of the range of journal structures 060 * @param end the upper bound of the range of journal structures (not inclusive) 061 * @return the range of matching journal structures 062 * @throws SystemException if a system exception occurred 063 */ 064 public java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByUuid( 065 java.lang.String uuid, int start, int end) 066 throws com.liferay.portal.kernel.exception.SystemException; 067 068 /** 069 * Returns an ordered range of all the journal structures where uuid = ?. 070 * 071 * <p> 072 * 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.journal.model.impl.JournalStructureModelImpl}. 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. 073 * </p> 074 * 075 * @param uuid the uuid 076 * @param start the lower bound of the range of journal structures 077 * @param end the upper bound of the range of journal structures (not inclusive) 078 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 079 * @return the ordered range of matching journal structures 080 * @throws SystemException if a system exception occurred 081 */ 082 public java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByUuid( 083 java.lang.String uuid, int start, int end, 084 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 085 throws com.liferay.portal.kernel.exception.SystemException; 086 087 /** 088 * Returns the first journal structure in the ordered set where uuid = ?. 089 * 090 * @param uuid the uuid 091 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 092 * @return the first matching journal structure 093 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 094 * @throws SystemException if a system exception occurred 095 */ 096 public com.liferay.portlet.journal.model.JournalStructure findByUuid_First( 097 java.lang.String uuid, 098 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 099 throws com.liferay.portal.kernel.exception.SystemException, 100 com.liferay.portlet.journal.NoSuchStructureException; 101 102 /** 103 * Returns the first journal structure in the ordered set where uuid = ?. 104 * 105 * @param uuid the uuid 106 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 107 * @return the first matching journal structure, or <code>null</code> if a matching journal structure could not be found 108 * @throws SystemException if a system exception occurred 109 */ 110 public com.liferay.portlet.journal.model.JournalStructure fetchByUuid_First( 111 java.lang.String uuid, 112 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 113 throws com.liferay.portal.kernel.exception.SystemException; 114 115 /** 116 * Returns the last journal structure in the ordered set where uuid = ?. 117 * 118 * @param uuid the uuid 119 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 120 * @return the last matching journal structure 121 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 122 * @throws SystemException if a system exception occurred 123 */ 124 public com.liferay.portlet.journal.model.JournalStructure findByUuid_Last( 125 java.lang.String uuid, 126 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 127 throws com.liferay.portal.kernel.exception.SystemException, 128 com.liferay.portlet.journal.NoSuchStructureException; 129 130 /** 131 * Returns the last journal structure in the ordered set where uuid = ?. 132 * 133 * @param uuid the uuid 134 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 135 * @return the last matching journal structure, or <code>null</code> if a matching journal structure could not be found 136 * @throws SystemException if a system exception occurred 137 */ 138 public com.liferay.portlet.journal.model.JournalStructure fetchByUuid_Last( 139 java.lang.String uuid, 140 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 141 throws com.liferay.portal.kernel.exception.SystemException; 142 143 /** 144 * Returns the journal structures before and after the current journal structure in the ordered set where uuid = ?. 145 * 146 * @param id the primary key of the current journal structure 147 * @param uuid the uuid 148 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 149 * @return the previous, current, and next journal structure 150 * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found 151 * @throws SystemException if a system exception occurred 152 */ 153 public com.liferay.portlet.journal.model.JournalStructure[] findByUuid_PrevAndNext( 154 long id, java.lang.String uuid, 155 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 156 throws com.liferay.portal.kernel.exception.SystemException, 157 com.liferay.portlet.journal.NoSuchStructureException; 158 159 /** 160 * Removes all the journal structures where uuid = ? from the database. 161 * 162 * @param uuid the uuid 163 * @throws SystemException if a system exception occurred 164 */ 165 public void removeByUuid(java.lang.String uuid) 166 throws com.liferay.portal.kernel.exception.SystemException; 167 168 /** 169 * Returns the number of journal structures where uuid = ?. 170 * 171 * @param uuid the uuid 172 * @return the number of matching journal structures 173 * @throws SystemException if a system exception occurred 174 */ 175 public int countByUuid(java.lang.String uuid) 176 throws com.liferay.portal.kernel.exception.SystemException; 177 178 /** 179 * Returns the journal structure where uuid = ? and groupId = ? or throws a {@link com.liferay.portlet.journal.NoSuchStructureException} if it could not be found. 180 * 181 * @param uuid the uuid 182 * @param groupId the group ID 183 * @return the matching journal structure 184 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 185 * @throws SystemException if a system exception occurred 186 */ 187 public com.liferay.portlet.journal.model.JournalStructure findByUUID_G( 188 java.lang.String uuid, long groupId) 189 throws com.liferay.portal.kernel.exception.SystemException, 190 com.liferay.portlet.journal.NoSuchStructureException; 191 192 /** 193 * Returns the journal structure where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 194 * 195 * @param uuid the uuid 196 * @param groupId the group ID 197 * @return the matching journal structure, or <code>null</code> if a matching journal structure could not be found 198 * @throws SystemException if a system exception occurred 199 */ 200 public com.liferay.portlet.journal.model.JournalStructure fetchByUUID_G( 201 java.lang.String uuid, long groupId) 202 throws com.liferay.portal.kernel.exception.SystemException; 203 204 /** 205 * Returns the journal structure where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 206 * 207 * @param uuid the uuid 208 * @param groupId the group ID 209 * @param retrieveFromCache whether to use the finder cache 210 * @return the matching journal structure, or <code>null</code> if a matching journal structure could not be found 211 * @throws SystemException if a system exception occurred 212 */ 213 public com.liferay.portlet.journal.model.JournalStructure fetchByUUID_G( 214 java.lang.String uuid, long groupId, boolean retrieveFromCache) 215 throws com.liferay.portal.kernel.exception.SystemException; 216 217 /** 218 * Removes the journal structure where uuid = ? and groupId = ? from the database. 219 * 220 * @param uuid the uuid 221 * @param groupId the group ID 222 * @return the journal structure that was removed 223 * @throws SystemException if a system exception occurred 224 */ 225 public com.liferay.portlet.journal.model.JournalStructure removeByUUID_G( 226 java.lang.String uuid, long groupId) 227 throws com.liferay.portal.kernel.exception.SystemException, 228 com.liferay.portlet.journal.NoSuchStructureException; 229 230 /** 231 * Returns the number of journal structures where uuid = ? and groupId = ?. 232 * 233 * @param uuid the uuid 234 * @param groupId the group ID 235 * @return the number of matching journal structures 236 * @throws SystemException if a system exception occurred 237 */ 238 public int countByUUID_G(java.lang.String uuid, long groupId) 239 throws com.liferay.portal.kernel.exception.SystemException; 240 241 /** 242 * Returns all the journal structures where uuid = ? and companyId = ?. 243 * 244 * @param uuid the uuid 245 * @param companyId the company ID 246 * @return the matching journal structures 247 * @throws SystemException if a system exception occurred 248 */ 249 public java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByUuid_C( 250 java.lang.String uuid, long companyId) 251 throws com.liferay.portal.kernel.exception.SystemException; 252 253 /** 254 * Returns a range of all the journal structures where uuid = ? and companyId = ?. 255 * 256 * <p> 257 * 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.journal.model.impl.JournalStructureModelImpl}. 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. 258 * </p> 259 * 260 * @param uuid the uuid 261 * @param companyId the company ID 262 * @param start the lower bound of the range of journal structures 263 * @param end the upper bound of the range of journal structures (not inclusive) 264 * @return the range of matching journal structures 265 * @throws SystemException if a system exception occurred 266 */ 267 public java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByUuid_C( 268 java.lang.String uuid, long companyId, int start, int end) 269 throws com.liferay.portal.kernel.exception.SystemException; 270 271 /** 272 * Returns an ordered range of all the journal structures where uuid = ? and companyId = ?. 273 * 274 * <p> 275 * 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.journal.model.impl.JournalStructureModelImpl}. 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. 276 * </p> 277 * 278 * @param uuid the uuid 279 * @param companyId the company ID 280 * @param start the lower bound of the range of journal structures 281 * @param end the upper bound of the range of journal structures (not inclusive) 282 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 283 * @return the ordered range of matching journal structures 284 * @throws SystemException if a system exception occurred 285 */ 286 public java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByUuid_C( 287 java.lang.String uuid, long companyId, int start, int end, 288 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 289 throws com.liferay.portal.kernel.exception.SystemException; 290 291 /** 292 * Returns the first journal structure in the ordered set where uuid = ? and companyId = ?. 293 * 294 * @param uuid the uuid 295 * @param companyId the company ID 296 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 297 * @return the first matching journal structure 298 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 299 * @throws SystemException if a system exception occurred 300 */ 301 public com.liferay.portlet.journal.model.JournalStructure findByUuid_C_First( 302 java.lang.String uuid, long companyId, 303 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 304 throws com.liferay.portal.kernel.exception.SystemException, 305 com.liferay.portlet.journal.NoSuchStructureException; 306 307 /** 308 * Returns the first journal structure in the ordered set where uuid = ? and companyId = ?. 309 * 310 * @param uuid the uuid 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 journal structure, or <code>null</code> if a matching journal structure could not be found 314 * @throws SystemException if a system exception occurred 315 */ 316 public com.liferay.portlet.journal.model.JournalStructure fetchByUuid_C_First( 317 java.lang.String uuid, long companyId, 318 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 319 throws com.liferay.portal.kernel.exception.SystemException; 320 321 /** 322 * Returns the last journal structure in the ordered set where uuid = ? and companyId = ?. 323 * 324 * @param uuid the uuid 325 * @param companyId the company ID 326 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 327 * @return the last matching journal structure 328 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 329 * @throws SystemException if a system exception occurred 330 */ 331 public com.liferay.portlet.journal.model.JournalStructure findByUuid_C_Last( 332 java.lang.String uuid, long companyId, 333 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 334 throws com.liferay.portal.kernel.exception.SystemException, 335 com.liferay.portlet.journal.NoSuchStructureException; 336 337 /** 338 * Returns the last journal structure in the ordered set where uuid = ? and companyId = ?. 339 * 340 * @param uuid the uuid 341 * @param companyId the company ID 342 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 343 * @return the last matching journal structure, or <code>null</code> if a matching journal structure could not be found 344 * @throws SystemException if a system exception occurred 345 */ 346 public com.liferay.portlet.journal.model.JournalStructure fetchByUuid_C_Last( 347 java.lang.String uuid, long companyId, 348 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 349 throws com.liferay.portal.kernel.exception.SystemException; 350 351 /** 352 * Returns the journal structures before and after the current journal structure in the ordered set where uuid = ? and companyId = ?. 353 * 354 * @param id the primary key of the current journal structure 355 * @param uuid the uuid 356 * @param companyId the company ID 357 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 358 * @return the previous, current, and next journal structure 359 * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found 360 * @throws SystemException if a system exception occurred 361 */ 362 public com.liferay.portlet.journal.model.JournalStructure[] findByUuid_C_PrevAndNext( 363 long id, java.lang.String uuid, long companyId, 364 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 365 throws com.liferay.portal.kernel.exception.SystemException, 366 com.liferay.portlet.journal.NoSuchStructureException; 367 368 /** 369 * Removes all the journal structures where uuid = ? and companyId = ? from the database. 370 * 371 * @param uuid the uuid 372 * @param companyId the company ID 373 * @throws SystemException if a system exception occurred 374 */ 375 public void removeByUuid_C(java.lang.String uuid, long companyId) 376 throws com.liferay.portal.kernel.exception.SystemException; 377 378 /** 379 * Returns the number of journal structures where uuid = ? and companyId = ?. 380 * 381 * @param uuid the uuid 382 * @param companyId the company ID 383 * @return the number of matching journal structures 384 * @throws SystemException if a system exception occurred 385 */ 386 public int countByUuid_C(java.lang.String uuid, long companyId) 387 throws com.liferay.portal.kernel.exception.SystemException; 388 389 /** 390 * Returns all the journal structures where groupId = ?. 391 * 392 * @param groupId the group ID 393 * @return the matching journal structures 394 * @throws SystemException if a system exception occurred 395 */ 396 public java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByGroupId( 397 long groupId) 398 throws com.liferay.portal.kernel.exception.SystemException; 399 400 /** 401 * Returns a range of all the journal structures where groupId = ?. 402 * 403 * <p> 404 * 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.journal.model.impl.JournalStructureModelImpl}. 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. 405 * </p> 406 * 407 * @param groupId the group ID 408 * @param start the lower bound of the range of journal structures 409 * @param end the upper bound of the range of journal structures (not inclusive) 410 * @return the range of matching journal structures 411 * @throws SystemException if a system exception occurred 412 */ 413 public java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByGroupId( 414 long groupId, int start, int end) 415 throws com.liferay.portal.kernel.exception.SystemException; 416 417 /** 418 * Returns an ordered range of all the journal structures where groupId = ?. 419 * 420 * <p> 421 * 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.journal.model.impl.JournalStructureModelImpl}. 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. 422 * </p> 423 * 424 * @param groupId the group ID 425 * @param start the lower bound of the range of journal structures 426 * @param end the upper bound of the range of journal structures (not inclusive) 427 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 428 * @return the ordered range of matching journal structures 429 * @throws SystemException if a system exception occurred 430 */ 431 public java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByGroupId( 432 long groupId, int start, int end, 433 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 434 throws com.liferay.portal.kernel.exception.SystemException; 435 436 /** 437 * Returns the first journal structure in the ordered set where groupId = ?. 438 * 439 * @param groupId the group ID 440 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 441 * @return the first matching journal structure 442 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 443 * @throws SystemException if a system exception occurred 444 */ 445 public com.liferay.portlet.journal.model.JournalStructure findByGroupId_First( 446 long groupId, 447 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 448 throws com.liferay.portal.kernel.exception.SystemException, 449 com.liferay.portlet.journal.NoSuchStructureException; 450 451 /** 452 * Returns the first journal structure in the ordered set where groupId = ?. 453 * 454 * @param groupId the group ID 455 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 456 * @return the first matching journal structure, or <code>null</code> if a matching journal structure could not be found 457 * @throws SystemException if a system exception occurred 458 */ 459 public com.liferay.portlet.journal.model.JournalStructure fetchByGroupId_First( 460 long groupId, 461 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 462 throws com.liferay.portal.kernel.exception.SystemException; 463 464 /** 465 * Returns the last journal structure in the ordered set where groupId = ?. 466 * 467 * @param groupId the group ID 468 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 469 * @return the last matching journal structure 470 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 471 * @throws SystemException if a system exception occurred 472 */ 473 public com.liferay.portlet.journal.model.JournalStructure findByGroupId_Last( 474 long groupId, 475 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 476 throws com.liferay.portal.kernel.exception.SystemException, 477 com.liferay.portlet.journal.NoSuchStructureException; 478 479 /** 480 * Returns the last journal structure in the ordered set where groupId = ?. 481 * 482 * @param groupId the group ID 483 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 484 * @return the last matching journal structure, or <code>null</code> if a matching journal structure could not be found 485 * @throws SystemException if a system exception occurred 486 */ 487 public com.liferay.portlet.journal.model.JournalStructure fetchByGroupId_Last( 488 long groupId, 489 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 490 throws com.liferay.portal.kernel.exception.SystemException; 491 492 /** 493 * Returns the journal structures before and after the current journal structure in the ordered set where groupId = ?. 494 * 495 * @param id the primary key of the current journal structure 496 * @param groupId the group ID 497 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 498 * @return the previous, current, and next journal structure 499 * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found 500 * @throws SystemException if a system exception occurred 501 */ 502 public com.liferay.portlet.journal.model.JournalStructure[] findByGroupId_PrevAndNext( 503 long id, long groupId, 504 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 505 throws com.liferay.portal.kernel.exception.SystemException, 506 com.liferay.portlet.journal.NoSuchStructureException; 507 508 /** 509 * Returns all the journal structures that the user has permission to view where groupId = ?. 510 * 511 * @param groupId the group ID 512 * @return the matching journal structures that the user has permission to view 513 * @throws SystemException if a system exception occurred 514 */ 515 public java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByGroupId( 516 long groupId) 517 throws com.liferay.portal.kernel.exception.SystemException; 518 519 /** 520 * Returns a range of all the journal structures that the user has permission to view where groupId = ?. 521 * 522 * <p> 523 * 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.journal.model.impl.JournalStructureModelImpl}. 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. 524 * </p> 525 * 526 * @param groupId the group ID 527 * @param start the lower bound of the range of journal structures 528 * @param end the upper bound of the range of journal structures (not inclusive) 529 * @return the range of matching journal structures that the user has permission to view 530 * @throws SystemException if a system exception occurred 531 */ 532 public java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByGroupId( 533 long groupId, int start, int end) 534 throws com.liferay.portal.kernel.exception.SystemException; 535 536 /** 537 * Returns an ordered range of all the journal structures that the user has permissions to view where groupId = ?. 538 * 539 * <p> 540 * 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.journal.model.impl.JournalStructureModelImpl}. 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. 541 * </p> 542 * 543 * @param groupId the group ID 544 * @param start the lower bound of the range of journal structures 545 * @param end the upper bound of the range of journal structures (not inclusive) 546 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 547 * @return the ordered range of matching journal structures that the user has permission to view 548 * @throws SystemException if a system exception occurred 549 */ 550 public java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByGroupId( 551 long groupId, int start, int end, 552 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 553 throws com.liferay.portal.kernel.exception.SystemException; 554 555 /** 556 * Returns the journal structures before and after the current journal structure in the ordered set of journal structures that the user has permission to view where groupId = ?. 557 * 558 * @param id the primary key of the current journal structure 559 * @param groupId the group ID 560 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 561 * @return the previous, current, and next journal structure 562 * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found 563 * @throws SystemException if a system exception occurred 564 */ 565 public com.liferay.portlet.journal.model.JournalStructure[] filterFindByGroupId_PrevAndNext( 566 long id, long groupId, 567 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 568 throws com.liferay.portal.kernel.exception.SystemException, 569 com.liferay.portlet.journal.NoSuchStructureException; 570 571 /** 572 * Returns all the journal structures that the user has permission to view where groupId = any ?. 573 * 574 * @param groupIds the group IDs 575 * @return the matching journal structures that the user has permission to view 576 * @throws SystemException if a system exception occurred 577 */ 578 public java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByGroupId( 579 long[] groupIds) 580 throws com.liferay.portal.kernel.exception.SystemException; 581 582 /** 583 * Returns a range of all the journal structures that the user has permission to view where groupId = any ?. 584 * 585 * <p> 586 * 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.journal.model.impl.JournalStructureModelImpl}. 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. 587 * </p> 588 * 589 * @param groupIds the group IDs 590 * @param start the lower bound of the range of journal structures 591 * @param end the upper bound of the range of journal structures (not inclusive) 592 * @return the range of matching journal structures that the user has permission to view 593 * @throws SystemException if a system exception occurred 594 */ 595 public java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByGroupId( 596 long[] groupIds, int start, int end) 597 throws com.liferay.portal.kernel.exception.SystemException; 598 599 /** 600 * Returns an ordered range of all the journal structures that the user has permission to view where groupId = any ?. 601 * 602 * <p> 603 * 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.journal.model.impl.JournalStructureModelImpl}. 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. 604 * </p> 605 * 606 * @param groupIds the group IDs 607 * @param start the lower bound of the range of journal structures 608 * @param end the upper bound of the range of journal structures (not inclusive) 609 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 610 * @return the ordered range of matching journal structures that the user has permission to view 611 * @throws SystemException if a system exception occurred 612 */ 613 public java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByGroupId( 614 long[] groupIds, int start, int end, 615 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 616 throws com.liferay.portal.kernel.exception.SystemException; 617 618 /** 619 * Returns all the journal structures where groupId = any ?. 620 * 621 * <p> 622 * 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.journal.model.impl.JournalStructureModelImpl}. 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. 623 * </p> 624 * 625 * @param groupIds the group IDs 626 * @return the matching journal structures 627 * @throws SystemException if a system exception occurred 628 */ 629 public java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByGroupId( 630 long[] groupIds) 631 throws com.liferay.portal.kernel.exception.SystemException; 632 633 /** 634 * Returns a range of all the journal structures where groupId = any ?. 635 * 636 * <p> 637 * 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.journal.model.impl.JournalStructureModelImpl}. 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. 638 * </p> 639 * 640 * @param groupIds the group IDs 641 * @param start the lower bound of the range of journal structures 642 * @param end the upper bound of the range of journal structures (not inclusive) 643 * @return the range of matching journal structures 644 * @throws SystemException if a system exception occurred 645 */ 646 public java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByGroupId( 647 long[] groupIds, int start, int end) 648 throws com.liferay.portal.kernel.exception.SystemException; 649 650 /** 651 * Returns an ordered range of all the journal structures where groupId = any ?. 652 * 653 * <p> 654 * 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.journal.model.impl.JournalStructureModelImpl}. 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. 655 * </p> 656 * 657 * @param groupIds the group IDs 658 * @param start the lower bound of the range of journal structures 659 * @param end the upper bound of the range of journal structures (not inclusive) 660 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 661 * @return the ordered range of matching journal structures 662 * @throws SystemException if a system exception occurred 663 */ 664 public java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByGroupId( 665 long[] groupIds, int start, int end, 666 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 667 throws com.liferay.portal.kernel.exception.SystemException; 668 669 /** 670 * Removes all the journal structures where groupId = ? from the database. 671 * 672 * @param groupId the group ID 673 * @throws SystemException if a system exception occurred 674 */ 675 public void removeByGroupId(long groupId) 676 throws com.liferay.portal.kernel.exception.SystemException; 677 678 /** 679 * Returns the number of journal structures where groupId = ?. 680 * 681 * @param groupId the group ID 682 * @return the number of matching journal structures 683 * @throws SystemException if a system exception occurred 684 */ 685 public int countByGroupId(long groupId) 686 throws com.liferay.portal.kernel.exception.SystemException; 687 688 /** 689 * Returns the number of journal structures where groupId = any ?. 690 * 691 * @param groupIds the group IDs 692 * @return the number of matching journal structures 693 * @throws SystemException if a system exception occurred 694 */ 695 public int countByGroupId(long[] groupIds) 696 throws com.liferay.portal.kernel.exception.SystemException; 697 698 /** 699 * Returns the number of journal structures that the user has permission to view where groupId = ?. 700 * 701 * @param groupId the group ID 702 * @return the number of matching journal structures that the user has permission to view 703 * @throws SystemException if a system exception occurred 704 */ 705 public int filterCountByGroupId(long groupId) 706 throws com.liferay.portal.kernel.exception.SystemException; 707 708 /** 709 * Returns the number of journal structures that the user has permission to view where groupId = any ?. 710 * 711 * @param groupIds the group IDs 712 * @return the number of matching journal structures that the user has permission to view 713 * @throws SystemException if a system exception occurred 714 */ 715 public int filterCountByGroupId(long[] groupIds) 716 throws com.liferay.portal.kernel.exception.SystemException; 717 718 /** 719 * Returns all the journal structures where structureId = ?. 720 * 721 * @param structureId the structure ID 722 * @return the matching journal structures 723 * @throws SystemException if a system exception occurred 724 */ 725 public java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByStructureId( 726 java.lang.String structureId) 727 throws com.liferay.portal.kernel.exception.SystemException; 728 729 /** 730 * Returns a range of all the journal structures where structureId = ?. 731 * 732 * <p> 733 * 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.journal.model.impl.JournalStructureModelImpl}. 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. 734 * </p> 735 * 736 * @param structureId the structure ID 737 * @param start the lower bound of the range of journal structures 738 * @param end the upper bound of the range of journal structures (not inclusive) 739 * @return the range of matching journal structures 740 * @throws SystemException if a system exception occurred 741 */ 742 public java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByStructureId( 743 java.lang.String structureId, int start, int end) 744 throws com.liferay.portal.kernel.exception.SystemException; 745 746 /** 747 * Returns an ordered range of all the journal structures where structureId = ?. 748 * 749 * <p> 750 * 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.journal.model.impl.JournalStructureModelImpl}. 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. 751 * </p> 752 * 753 * @param structureId the structure ID 754 * @param start the lower bound of the range of journal structures 755 * @param end the upper bound of the range of journal structures (not inclusive) 756 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 757 * @return the ordered range of matching journal structures 758 * @throws SystemException if a system exception occurred 759 */ 760 public java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByStructureId( 761 java.lang.String structureId, int start, int end, 762 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 763 throws com.liferay.portal.kernel.exception.SystemException; 764 765 /** 766 * Returns the first journal structure in the ordered set where structureId = ?. 767 * 768 * @param structureId the structure ID 769 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 770 * @return the first matching journal structure 771 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 772 * @throws SystemException if a system exception occurred 773 */ 774 public com.liferay.portlet.journal.model.JournalStructure findByStructureId_First( 775 java.lang.String structureId, 776 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 777 throws com.liferay.portal.kernel.exception.SystemException, 778 com.liferay.portlet.journal.NoSuchStructureException; 779 780 /** 781 * Returns the first journal structure in the ordered set where structureId = ?. 782 * 783 * @param structureId the structure ID 784 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 785 * @return the first matching journal structure, or <code>null</code> if a matching journal structure could not be found 786 * @throws SystemException if a system exception occurred 787 */ 788 public com.liferay.portlet.journal.model.JournalStructure fetchByStructureId_First( 789 java.lang.String structureId, 790 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 791 throws com.liferay.portal.kernel.exception.SystemException; 792 793 /** 794 * Returns the last journal structure in the ordered set where structureId = ?. 795 * 796 * @param structureId the structure ID 797 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 798 * @return the last matching journal structure 799 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 800 * @throws SystemException if a system exception occurred 801 */ 802 public com.liferay.portlet.journal.model.JournalStructure findByStructureId_Last( 803 java.lang.String structureId, 804 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 805 throws com.liferay.portal.kernel.exception.SystemException, 806 com.liferay.portlet.journal.NoSuchStructureException; 807 808 /** 809 * Returns the last journal structure in the ordered set where structureId = ?. 810 * 811 * @param structureId the structure ID 812 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 813 * @return the last matching journal structure, or <code>null</code> if a matching journal structure could not be found 814 * @throws SystemException if a system exception occurred 815 */ 816 public com.liferay.portlet.journal.model.JournalStructure fetchByStructureId_Last( 817 java.lang.String structureId, 818 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 819 throws com.liferay.portal.kernel.exception.SystemException; 820 821 /** 822 * Returns the journal structures before and after the current journal structure in the ordered set where structureId = ?. 823 * 824 * @param id the primary key of the current journal structure 825 * @param structureId the structure ID 826 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 827 * @return the previous, current, and next journal structure 828 * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found 829 * @throws SystemException if a system exception occurred 830 */ 831 public com.liferay.portlet.journal.model.JournalStructure[] findByStructureId_PrevAndNext( 832 long id, java.lang.String structureId, 833 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 834 throws com.liferay.portal.kernel.exception.SystemException, 835 com.liferay.portlet.journal.NoSuchStructureException; 836 837 /** 838 * Removes all the journal structures where structureId = ? from the database. 839 * 840 * @param structureId the structure ID 841 * @throws SystemException if a system exception occurred 842 */ 843 public void removeByStructureId(java.lang.String structureId) 844 throws com.liferay.portal.kernel.exception.SystemException; 845 846 /** 847 * Returns the number of journal structures where structureId = ?. 848 * 849 * @param structureId the structure ID 850 * @return the number of matching journal structures 851 * @throws SystemException if a system exception occurred 852 */ 853 public int countByStructureId(java.lang.String structureId) 854 throws com.liferay.portal.kernel.exception.SystemException; 855 856 /** 857 * Returns all the journal structures where parentStructureId = ?. 858 * 859 * @param parentStructureId the parent structure ID 860 * @return the matching journal structures 861 * @throws SystemException if a system exception occurred 862 */ 863 public java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByParentStructureId( 864 java.lang.String parentStructureId) 865 throws com.liferay.portal.kernel.exception.SystemException; 866 867 /** 868 * Returns a range of all the journal structures where parentStructureId = ?. 869 * 870 * <p> 871 * 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.journal.model.impl.JournalStructureModelImpl}. 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. 872 * </p> 873 * 874 * @param parentStructureId the parent structure ID 875 * @param start the lower bound of the range of journal structures 876 * @param end the upper bound of the range of journal structures (not inclusive) 877 * @return the range of matching journal structures 878 * @throws SystemException if a system exception occurred 879 */ 880 public java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByParentStructureId( 881 java.lang.String parentStructureId, int start, int end) 882 throws com.liferay.portal.kernel.exception.SystemException; 883 884 /** 885 * Returns an ordered range of all the journal structures where parentStructureId = ?. 886 * 887 * <p> 888 * 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.journal.model.impl.JournalStructureModelImpl}. 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. 889 * </p> 890 * 891 * @param parentStructureId the parent structure ID 892 * @param start the lower bound of the range of journal structures 893 * @param end the upper bound of the range of journal structures (not inclusive) 894 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 895 * @return the ordered range of matching journal structures 896 * @throws SystemException if a system exception occurred 897 */ 898 public java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByParentStructureId( 899 java.lang.String parentStructureId, int start, int end, 900 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 901 throws com.liferay.portal.kernel.exception.SystemException; 902 903 /** 904 * Returns the first journal structure in the ordered set where parentStructureId = ?. 905 * 906 * @param parentStructureId the parent structure ID 907 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 908 * @return the first matching journal structure 909 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 910 * @throws SystemException if a system exception occurred 911 */ 912 public com.liferay.portlet.journal.model.JournalStructure findByParentStructureId_First( 913 java.lang.String parentStructureId, 914 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 915 throws com.liferay.portal.kernel.exception.SystemException, 916 com.liferay.portlet.journal.NoSuchStructureException; 917 918 /** 919 * Returns the first journal structure in the ordered set where parentStructureId = ?. 920 * 921 * @param parentStructureId the parent structure ID 922 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 923 * @return the first matching journal structure, or <code>null</code> if a matching journal structure could not be found 924 * @throws SystemException if a system exception occurred 925 */ 926 public com.liferay.portlet.journal.model.JournalStructure fetchByParentStructureId_First( 927 java.lang.String parentStructureId, 928 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 929 throws com.liferay.portal.kernel.exception.SystemException; 930 931 /** 932 * Returns the last journal structure in the ordered set where parentStructureId = ?. 933 * 934 * @param parentStructureId the parent structure ID 935 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 936 * @return the last matching journal structure 937 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 938 * @throws SystemException if a system exception occurred 939 */ 940 public com.liferay.portlet.journal.model.JournalStructure findByParentStructureId_Last( 941 java.lang.String parentStructureId, 942 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 943 throws com.liferay.portal.kernel.exception.SystemException, 944 com.liferay.portlet.journal.NoSuchStructureException; 945 946 /** 947 * Returns the last journal structure in the ordered set where parentStructureId = ?. 948 * 949 * @param parentStructureId the parent structure ID 950 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 951 * @return the last matching journal structure, or <code>null</code> if a matching journal structure could not be found 952 * @throws SystemException if a system exception occurred 953 */ 954 public com.liferay.portlet.journal.model.JournalStructure fetchByParentStructureId_Last( 955 java.lang.String parentStructureId, 956 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 957 throws com.liferay.portal.kernel.exception.SystemException; 958 959 /** 960 * Returns the journal structures before and after the current journal structure in the ordered set where parentStructureId = ?. 961 * 962 * @param id the primary key of the current journal structure 963 * @param parentStructureId the parent structure ID 964 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 965 * @return the previous, current, and next journal structure 966 * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found 967 * @throws SystemException if a system exception occurred 968 */ 969 public com.liferay.portlet.journal.model.JournalStructure[] findByParentStructureId_PrevAndNext( 970 long id, java.lang.String parentStructureId, 971 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 972 throws com.liferay.portal.kernel.exception.SystemException, 973 com.liferay.portlet.journal.NoSuchStructureException; 974 975 /** 976 * Removes all the journal structures where parentStructureId = ? from the database. 977 * 978 * @param parentStructureId the parent structure ID 979 * @throws SystemException if a system exception occurred 980 */ 981 public void removeByParentStructureId(java.lang.String parentStructureId) 982 throws com.liferay.portal.kernel.exception.SystemException; 983 984 /** 985 * Returns the number of journal structures where parentStructureId = ?. 986 * 987 * @param parentStructureId the parent structure ID 988 * @return the number of matching journal structures 989 * @throws SystemException if a system exception occurred 990 */ 991 public int countByParentStructureId(java.lang.String parentStructureId) 992 throws com.liferay.portal.kernel.exception.SystemException; 993 994 /** 995 * Returns the journal structure where groupId = ? and structureId = ? or throws a {@link com.liferay.portlet.journal.NoSuchStructureException} if it could not be found. 996 * 997 * @param groupId the group ID 998 * @param structureId the structure ID 999 * @return the matching journal structure 1000 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 1001 * @throws SystemException if a system exception occurred 1002 */ 1003 public com.liferay.portlet.journal.model.JournalStructure findByG_S( 1004 long groupId, java.lang.String structureId) 1005 throws com.liferay.portal.kernel.exception.SystemException, 1006 com.liferay.portlet.journal.NoSuchStructureException; 1007 1008 /** 1009 * Returns the journal structure where groupId = ? and structureId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 1010 * 1011 * @param groupId the group ID 1012 * @param structureId the structure ID 1013 * @return the matching journal structure, or <code>null</code> if a matching journal structure could not be found 1014 * @throws SystemException if a system exception occurred 1015 */ 1016 public com.liferay.portlet.journal.model.JournalStructure fetchByG_S( 1017 long groupId, java.lang.String structureId) 1018 throws com.liferay.portal.kernel.exception.SystemException; 1019 1020 /** 1021 * Returns the journal structure where groupId = ? and structureId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 1022 * 1023 * @param groupId the group ID 1024 * @param structureId the structure ID 1025 * @param retrieveFromCache whether to use the finder cache 1026 * @return the matching journal structure, or <code>null</code> if a matching journal structure could not be found 1027 * @throws SystemException if a system exception occurred 1028 */ 1029 public com.liferay.portlet.journal.model.JournalStructure fetchByG_S( 1030 long groupId, java.lang.String structureId, boolean retrieveFromCache) 1031 throws com.liferay.portal.kernel.exception.SystemException; 1032 1033 /** 1034 * Removes the journal structure where groupId = ? and structureId = ? from the database. 1035 * 1036 * @param groupId the group ID 1037 * @param structureId the structure ID 1038 * @return the journal structure that was removed 1039 * @throws SystemException if a system exception occurred 1040 */ 1041 public com.liferay.portlet.journal.model.JournalStructure removeByG_S( 1042 long groupId, java.lang.String structureId) 1043 throws com.liferay.portal.kernel.exception.SystemException, 1044 com.liferay.portlet.journal.NoSuchStructureException; 1045 1046 /** 1047 * Returns the number of journal structures where groupId = ? and structureId = ?. 1048 * 1049 * @param groupId the group ID 1050 * @param structureId the structure ID 1051 * @return the number of matching journal structures 1052 * @throws SystemException if a system exception occurred 1053 */ 1054 public int countByG_S(long groupId, java.lang.String structureId) 1055 throws com.liferay.portal.kernel.exception.SystemException; 1056 1057 /** 1058 * Returns all the journal structures where groupId = ? and parentStructureId = ?. 1059 * 1060 * @param groupId the group ID 1061 * @param parentStructureId the parent structure ID 1062 * @return the matching journal structures 1063 * @throws SystemException if a system exception occurred 1064 */ 1065 public java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByG_P( 1066 long groupId, java.lang.String parentStructureId) 1067 throws com.liferay.portal.kernel.exception.SystemException; 1068 1069 /** 1070 * Returns a range of all the journal structures where groupId = ? and parentStructureId = ?. 1071 * 1072 * <p> 1073 * 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.journal.model.impl.JournalStructureModelImpl}. 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. 1074 * </p> 1075 * 1076 * @param groupId the group ID 1077 * @param parentStructureId the parent structure ID 1078 * @param start the lower bound of the range of journal structures 1079 * @param end the upper bound of the range of journal structures (not inclusive) 1080 * @return the range of matching journal structures 1081 * @throws SystemException if a system exception occurred 1082 */ 1083 public java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByG_P( 1084 long groupId, java.lang.String parentStructureId, int start, int end) 1085 throws com.liferay.portal.kernel.exception.SystemException; 1086 1087 /** 1088 * Returns an ordered range of all the journal structures where groupId = ? and parentStructureId = ?. 1089 * 1090 * <p> 1091 * 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.journal.model.impl.JournalStructureModelImpl}. 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. 1092 * </p> 1093 * 1094 * @param groupId the group ID 1095 * @param parentStructureId the parent structure ID 1096 * @param start the lower bound of the range of journal structures 1097 * @param end the upper bound of the range of journal structures (not inclusive) 1098 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1099 * @return the ordered range of matching journal structures 1100 * @throws SystemException if a system exception occurred 1101 */ 1102 public java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByG_P( 1103 long groupId, java.lang.String parentStructureId, int start, int end, 1104 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1105 throws com.liferay.portal.kernel.exception.SystemException; 1106 1107 /** 1108 * Returns the first journal structure in the ordered set where groupId = ? and parentStructureId = ?. 1109 * 1110 * @param groupId the group ID 1111 * @param parentStructureId the parent structure ID 1112 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1113 * @return the first matching journal structure 1114 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 1115 * @throws SystemException if a system exception occurred 1116 */ 1117 public com.liferay.portlet.journal.model.JournalStructure findByG_P_First( 1118 long groupId, java.lang.String parentStructureId, 1119 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1120 throws com.liferay.portal.kernel.exception.SystemException, 1121 com.liferay.portlet.journal.NoSuchStructureException; 1122 1123 /** 1124 * Returns the first journal structure in the ordered set where groupId = ? and parentStructureId = ?. 1125 * 1126 * @param groupId the group ID 1127 * @param parentStructureId the parent structure ID 1128 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1129 * @return the first matching journal structure, or <code>null</code> if a matching journal structure could not be found 1130 * @throws SystemException if a system exception occurred 1131 */ 1132 public com.liferay.portlet.journal.model.JournalStructure fetchByG_P_First( 1133 long groupId, java.lang.String parentStructureId, 1134 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1135 throws com.liferay.portal.kernel.exception.SystemException; 1136 1137 /** 1138 * Returns the last journal structure in the ordered set where groupId = ? and parentStructureId = ?. 1139 * 1140 * @param groupId the group ID 1141 * @param parentStructureId the parent structure ID 1142 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1143 * @return the last matching journal structure 1144 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 1145 * @throws SystemException if a system exception occurred 1146 */ 1147 public com.liferay.portlet.journal.model.JournalStructure findByG_P_Last( 1148 long groupId, java.lang.String parentStructureId, 1149 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1150 throws com.liferay.portal.kernel.exception.SystemException, 1151 com.liferay.portlet.journal.NoSuchStructureException; 1152 1153 /** 1154 * Returns the last journal structure in the ordered set where groupId = ? and parentStructureId = ?. 1155 * 1156 * @param groupId the group ID 1157 * @param parentStructureId the parent structure ID 1158 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1159 * @return the last matching journal structure, or <code>null</code> if a matching journal structure could not be found 1160 * @throws SystemException if a system exception occurred 1161 */ 1162 public com.liferay.portlet.journal.model.JournalStructure fetchByG_P_Last( 1163 long groupId, java.lang.String parentStructureId, 1164 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1165 throws com.liferay.portal.kernel.exception.SystemException; 1166 1167 /** 1168 * Returns the journal structures before and after the current journal structure in the ordered set where groupId = ? and parentStructureId = ?. 1169 * 1170 * @param id the primary key of the current journal structure 1171 * @param groupId the group ID 1172 * @param parentStructureId the parent structure ID 1173 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1174 * @return the previous, current, and next journal structure 1175 * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found 1176 * @throws SystemException if a system exception occurred 1177 */ 1178 public com.liferay.portlet.journal.model.JournalStructure[] findByG_P_PrevAndNext( 1179 long id, long groupId, java.lang.String parentStructureId, 1180 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1181 throws com.liferay.portal.kernel.exception.SystemException, 1182 com.liferay.portlet.journal.NoSuchStructureException; 1183 1184 /** 1185 * Returns all the journal structures that the user has permission to view where groupId = ? and parentStructureId = ?. 1186 * 1187 * @param groupId the group ID 1188 * @param parentStructureId the parent structure ID 1189 * @return the matching journal structures that the user has permission to view 1190 * @throws SystemException if a system exception occurred 1191 */ 1192 public java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByG_P( 1193 long groupId, java.lang.String parentStructureId) 1194 throws com.liferay.portal.kernel.exception.SystemException; 1195 1196 /** 1197 * Returns a range of all the journal structures that the user has permission to view where groupId = ? and parentStructureId = ?. 1198 * 1199 * <p> 1200 * 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.journal.model.impl.JournalStructureModelImpl}. 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. 1201 * </p> 1202 * 1203 * @param groupId the group ID 1204 * @param parentStructureId the parent structure ID 1205 * @param start the lower bound of the range of journal structures 1206 * @param end the upper bound of the range of journal structures (not inclusive) 1207 * @return the range of matching journal structures that the user has permission to view 1208 * @throws SystemException if a system exception occurred 1209 */ 1210 public java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByG_P( 1211 long groupId, java.lang.String parentStructureId, int start, int end) 1212 throws com.liferay.portal.kernel.exception.SystemException; 1213 1214 /** 1215 * Returns an ordered range of all the journal structures that the user has permissions to view where groupId = ? and parentStructureId = ?. 1216 * 1217 * <p> 1218 * 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.journal.model.impl.JournalStructureModelImpl}. 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. 1219 * </p> 1220 * 1221 * @param groupId the group ID 1222 * @param parentStructureId the parent structure ID 1223 * @param start the lower bound of the range of journal structures 1224 * @param end the upper bound of the range of journal structures (not inclusive) 1225 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1226 * @return the ordered range of matching journal structures that the user has permission to view 1227 * @throws SystemException if a system exception occurred 1228 */ 1229 public java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByG_P( 1230 long groupId, java.lang.String parentStructureId, int start, int end, 1231 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1232 throws com.liferay.portal.kernel.exception.SystemException; 1233 1234 /** 1235 * Returns the journal structures before and after the current journal structure in the ordered set of journal structures that the user has permission to view where groupId = ? and parentStructureId = ?. 1236 * 1237 * @param id the primary key of the current journal structure 1238 * @param groupId the group ID 1239 * @param parentStructureId the parent structure ID 1240 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1241 * @return the previous, current, and next journal structure 1242 * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found 1243 * @throws SystemException if a system exception occurred 1244 */ 1245 public com.liferay.portlet.journal.model.JournalStructure[] filterFindByG_P_PrevAndNext( 1246 long id, long groupId, java.lang.String parentStructureId, 1247 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1248 throws com.liferay.portal.kernel.exception.SystemException, 1249 com.liferay.portlet.journal.NoSuchStructureException; 1250 1251 /** 1252 * Removes all the journal structures where groupId = ? and parentStructureId = ? from the database. 1253 * 1254 * @param groupId the group ID 1255 * @param parentStructureId the parent structure ID 1256 * @throws SystemException if a system exception occurred 1257 */ 1258 public void removeByG_P(long groupId, java.lang.String parentStructureId) 1259 throws com.liferay.portal.kernel.exception.SystemException; 1260 1261 /** 1262 * Returns the number of journal structures where groupId = ? and parentStructureId = ?. 1263 * 1264 * @param groupId the group ID 1265 * @param parentStructureId the parent structure ID 1266 * @return the number of matching journal structures 1267 * @throws SystemException if a system exception occurred 1268 */ 1269 public int countByG_P(long groupId, java.lang.String parentStructureId) 1270 throws com.liferay.portal.kernel.exception.SystemException; 1271 1272 /** 1273 * Returns the number of journal structures that the user has permission to view where groupId = ? and parentStructureId = ?. 1274 * 1275 * @param groupId the group ID 1276 * @param parentStructureId the parent structure ID 1277 * @return the number of matching journal structures that the user has permission to view 1278 * @throws SystemException if a system exception occurred 1279 */ 1280 public int filterCountByG_P(long groupId, java.lang.String parentStructureId) 1281 throws com.liferay.portal.kernel.exception.SystemException; 1282 1283 /** 1284 * Caches the journal structure in the entity cache if it is enabled. 1285 * 1286 * @param journalStructure the journal structure 1287 */ 1288 public void cacheResult( 1289 com.liferay.portlet.journal.model.JournalStructure journalStructure); 1290 1291 /** 1292 * Caches the journal structures in the entity cache if it is enabled. 1293 * 1294 * @param journalStructures the journal structures 1295 */ 1296 public void cacheResult( 1297 java.util.List<com.liferay.portlet.journal.model.JournalStructure> journalStructures); 1298 1299 /** 1300 * Creates a new journal structure with the primary key. Does not add the journal structure to the database. 1301 * 1302 * @param id the primary key for the new journal structure 1303 * @return the new journal structure 1304 */ 1305 public com.liferay.portlet.journal.model.JournalStructure create(long id); 1306 1307 /** 1308 * Removes the journal structure with the primary key from the database. Also notifies the appropriate model listeners. 1309 * 1310 * @param id the primary key of the journal structure 1311 * @return the journal structure that was removed 1312 * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found 1313 * @throws SystemException if a system exception occurred 1314 */ 1315 public com.liferay.portlet.journal.model.JournalStructure remove(long id) 1316 throws com.liferay.portal.kernel.exception.SystemException, 1317 com.liferay.portlet.journal.NoSuchStructureException; 1318 1319 public com.liferay.portlet.journal.model.JournalStructure updateImpl( 1320 com.liferay.portlet.journal.model.JournalStructure journalStructure) 1321 throws com.liferay.portal.kernel.exception.SystemException; 1322 1323 /** 1324 * Returns the journal structure with the primary key or throws a {@link com.liferay.portlet.journal.NoSuchStructureException} if it could not be found. 1325 * 1326 * @param id the primary key of the journal structure 1327 * @return the journal structure 1328 * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found 1329 * @throws SystemException if a system exception occurred 1330 */ 1331 public com.liferay.portlet.journal.model.JournalStructure findByPrimaryKey( 1332 long id) 1333 throws com.liferay.portal.kernel.exception.SystemException, 1334 com.liferay.portlet.journal.NoSuchStructureException; 1335 1336 /** 1337 * Returns the journal structure with the primary key or returns <code>null</code> if it could not be found. 1338 * 1339 * @param id the primary key of the journal structure 1340 * @return the journal structure, or <code>null</code> if a journal structure with the primary key could not be found 1341 * @throws SystemException if a system exception occurred 1342 */ 1343 public com.liferay.portlet.journal.model.JournalStructure fetchByPrimaryKey( 1344 long id) throws com.liferay.portal.kernel.exception.SystemException; 1345 1346 /** 1347 * Returns all the journal structures. 1348 * 1349 * @return the journal structures 1350 * @throws SystemException if a system exception occurred 1351 */ 1352 public java.util.List<com.liferay.portlet.journal.model.JournalStructure> findAll() 1353 throws com.liferay.portal.kernel.exception.SystemException; 1354 1355 /** 1356 * Returns a range of all the journal structures. 1357 * 1358 * <p> 1359 * 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.journal.model.impl.JournalStructureModelImpl}. 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. 1360 * </p> 1361 * 1362 * @param start the lower bound of the range of journal structures 1363 * @param end the upper bound of the range of journal structures (not inclusive) 1364 * @return the range of journal structures 1365 * @throws SystemException if a system exception occurred 1366 */ 1367 public java.util.List<com.liferay.portlet.journal.model.JournalStructure> findAll( 1368 int start, int end) 1369 throws com.liferay.portal.kernel.exception.SystemException; 1370 1371 /** 1372 * Returns an ordered range of all the journal structures. 1373 * 1374 * <p> 1375 * 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.journal.model.impl.JournalStructureModelImpl}. 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. 1376 * </p> 1377 * 1378 * @param start the lower bound of the range of journal structures 1379 * @param end the upper bound of the range of journal structures (not inclusive) 1380 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1381 * @return the ordered range of journal structures 1382 * @throws SystemException if a system exception occurred 1383 */ 1384 public java.util.List<com.liferay.portlet.journal.model.JournalStructure> findAll( 1385 int start, int end, 1386 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1387 throws com.liferay.portal.kernel.exception.SystemException; 1388 1389 /** 1390 * Removes all the journal structures from the database. 1391 * 1392 * @throws SystemException if a system exception occurred 1393 */ 1394 public void removeAll() 1395 throws com.liferay.portal.kernel.exception.SystemException; 1396 1397 /** 1398 * Returns the number of journal structures. 1399 * 1400 * @return the number of journal structures 1401 * @throws SystemException if a system exception occurred 1402 */ 1403 public int countAll() 1404 throws com.liferay.portal.kernel.exception.SystemException; 1405 }