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.kernel.bean.PortalBeanLocatorUtil; 018 import com.liferay.portal.kernel.dao.orm.DynamicQuery; 019 import com.liferay.portal.kernel.exception.SystemException; 020 import com.liferay.portal.kernel.util.OrderByComparator; 021 import com.liferay.portal.kernel.util.ReferenceRegistry; 022 import com.liferay.portal.service.ServiceContext; 023 024 import com.liferay.portlet.journal.model.JournalStructure; 025 026 import java.util.List; 027 028 /** 029 * The persistence utility for the journal structure service. This utility wraps {@link JournalStructurePersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class. 030 * 031 * <p> 032 * Caching information and settings can be found in <code>portal.properties</code> 033 * </p> 034 * 035 * @author Brian Wing Shun Chan 036 * @see JournalStructurePersistence 037 * @see JournalStructurePersistenceImpl 038 * @generated 039 */ 040 public class JournalStructureUtil { 041 /* 042 * NOTE FOR DEVELOPERS: 043 * 044 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. 045 */ 046 047 /** 048 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 049 */ 050 public static void clearCache() { 051 getPersistence().clearCache(); 052 } 053 054 /** 055 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 056 */ 057 public static void clearCache(JournalStructure journalStructure) { 058 getPersistence().clearCache(journalStructure); 059 } 060 061 /** 062 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 063 */ 064 public long countWithDynamicQuery(DynamicQuery dynamicQuery) 065 throws SystemException { 066 return getPersistence().countWithDynamicQuery(dynamicQuery); 067 } 068 069 /** 070 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 071 */ 072 public static List<JournalStructure> findWithDynamicQuery( 073 DynamicQuery dynamicQuery) throws SystemException { 074 return getPersistence().findWithDynamicQuery(dynamicQuery); 075 } 076 077 /** 078 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 079 */ 080 public static List<JournalStructure> findWithDynamicQuery( 081 DynamicQuery dynamicQuery, int start, int end) 082 throws SystemException { 083 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 084 } 085 086 /** 087 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 088 */ 089 public static List<JournalStructure> findWithDynamicQuery( 090 DynamicQuery dynamicQuery, int start, int end, 091 OrderByComparator orderByComparator) throws SystemException { 092 return getPersistence() 093 .findWithDynamicQuery(dynamicQuery, start, end, 094 orderByComparator); 095 } 096 097 /** 098 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel) 099 */ 100 public static JournalStructure update(JournalStructure journalStructure) 101 throws SystemException { 102 return getPersistence().update(journalStructure); 103 } 104 105 /** 106 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 107 */ 108 public static JournalStructure update(JournalStructure journalStructure, 109 ServiceContext serviceContext) throws SystemException { 110 return getPersistence().update(journalStructure, serviceContext); 111 } 112 113 /** 114 * Returns all the journal structures where uuid = ?. 115 * 116 * @param uuid the uuid 117 * @return the matching journal structures 118 * @throws SystemException if a system exception occurred 119 */ 120 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByUuid( 121 java.lang.String uuid) 122 throws com.liferay.portal.kernel.exception.SystemException { 123 return getPersistence().findByUuid(uuid); 124 } 125 126 /** 127 * Returns a range of all the journal structures where uuid = ?. 128 * 129 * <p> 130 * 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. 131 * </p> 132 * 133 * @param uuid the uuid 134 * @param start the lower bound of the range of journal structures 135 * @param end the upper bound of the range of journal structures (not inclusive) 136 * @return the range of matching journal structures 137 * @throws SystemException if a system exception occurred 138 */ 139 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByUuid( 140 java.lang.String uuid, int start, int end) 141 throws com.liferay.portal.kernel.exception.SystemException { 142 return getPersistence().findByUuid(uuid, start, end); 143 } 144 145 /** 146 * Returns an ordered range of all the journal structures where uuid = ?. 147 * 148 * <p> 149 * 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. 150 * </p> 151 * 152 * @param uuid the uuid 153 * @param start the lower bound of the range of journal structures 154 * @param end the upper bound of the range of journal structures (not inclusive) 155 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 156 * @return the ordered range of matching journal structures 157 * @throws SystemException if a system exception occurred 158 */ 159 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByUuid( 160 java.lang.String uuid, int start, int end, 161 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 162 throws com.liferay.portal.kernel.exception.SystemException { 163 return getPersistence().findByUuid(uuid, start, end, orderByComparator); 164 } 165 166 /** 167 * Returns the first journal structure in the ordered set where uuid = ?. 168 * 169 * @param uuid the uuid 170 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 171 * @return the first matching journal structure 172 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 173 * @throws SystemException if a system exception occurred 174 */ 175 public static com.liferay.portlet.journal.model.JournalStructure findByUuid_First( 176 java.lang.String uuid, 177 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 178 throws com.liferay.portal.kernel.exception.SystemException, 179 com.liferay.portlet.journal.NoSuchStructureException { 180 return getPersistence().findByUuid_First(uuid, orderByComparator); 181 } 182 183 /** 184 * Returns the first journal structure in the ordered set where uuid = ?. 185 * 186 * @param uuid the uuid 187 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 188 * @return the first matching journal structure, or <code>null</code> if a matching journal structure could not be found 189 * @throws SystemException if a system exception occurred 190 */ 191 public static com.liferay.portlet.journal.model.JournalStructure fetchByUuid_First( 192 java.lang.String uuid, 193 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 194 throws com.liferay.portal.kernel.exception.SystemException { 195 return getPersistence().fetchByUuid_First(uuid, orderByComparator); 196 } 197 198 /** 199 * Returns the last journal structure in the ordered set where uuid = ?. 200 * 201 * @param uuid the uuid 202 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 203 * @return the last matching journal structure 204 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 205 * @throws SystemException if a system exception occurred 206 */ 207 public static com.liferay.portlet.journal.model.JournalStructure findByUuid_Last( 208 java.lang.String uuid, 209 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 210 throws com.liferay.portal.kernel.exception.SystemException, 211 com.liferay.portlet.journal.NoSuchStructureException { 212 return getPersistence().findByUuid_Last(uuid, orderByComparator); 213 } 214 215 /** 216 * Returns the last journal structure in the ordered set where uuid = ?. 217 * 218 * @param uuid the uuid 219 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 220 * @return the last matching journal structure, or <code>null</code> if a matching journal structure could not be found 221 * @throws SystemException if a system exception occurred 222 */ 223 public static com.liferay.portlet.journal.model.JournalStructure fetchByUuid_Last( 224 java.lang.String uuid, 225 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 226 throws com.liferay.portal.kernel.exception.SystemException { 227 return getPersistence().fetchByUuid_Last(uuid, orderByComparator); 228 } 229 230 /** 231 * Returns the journal structures before and after the current journal structure in the ordered set where uuid = ?. 232 * 233 * @param id the primary key of the current journal structure 234 * @param uuid the uuid 235 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 236 * @return the previous, current, and next journal structure 237 * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found 238 * @throws SystemException if a system exception occurred 239 */ 240 public static com.liferay.portlet.journal.model.JournalStructure[] findByUuid_PrevAndNext( 241 long id, java.lang.String uuid, 242 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 243 throws com.liferay.portal.kernel.exception.SystemException, 244 com.liferay.portlet.journal.NoSuchStructureException { 245 return getPersistence() 246 .findByUuid_PrevAndNext(id, uuid, orderByComparator); 247 } 248 249 /** 250 * Removes all the journal structures where uuid = ? from the database. 251 * 252 * @param uuid the uuid 253 * @throws SystemException if a system exception occurred 254 */ 255 public static void removeByUuid(java.lang.String uuid) 256 throws com.liferay.portal.kernel.exception.SystemException { 257 getPersistence().removeByUuid(uuid); 258 } 259 260 /** 261 * Returns the number of journal structures where uuid = ?. 262 * 263 * @param uuid the uuid 264 * @return the number of matching journal structures 265 * @throws SystemException if a system exception occurred 266 */ 267 public static int countByUuid(java.lang.String uuid) 268 throws com.liferay.portal.kernel.exception.SystemException { 269 return getPersistence().countByUuid(uuid); 270 } 271 272 /** 273 * Returns the journal structure where uuid = ? and groupId = ? or throws a {@link com.liferay.portlet.journal.NoSuchStructureException} if it could not be found. 274 * 275 * @param uuid the uuid 276 * @param groupId the group ID 277 * @return the matching journal structure 278 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 279 * @throws SystemException if a system exception occurred 280 */ 281 public static com.liferay.portlet.journal.model.JournalStructure findByUUID_G( 282 java.lang.String uuid, long groupId) 283 throws com.liferay.portal.kernel.exception.SystemException, 284 com.liferay.portlet.journal.NoSuchStructureException { 285 return getPersistence().findByUUID_G(uuid, groupId); 286 } 287 288 /** 289 * Returns the journal structure where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 290 * 291 * @param uuid the uuid 292 * @param groupId the group ID 293 * @return the matching journal structure, or <code>null</code> if a matching journal structure could not be found 294 * @throws SystemException if a system exception occurred 295 */ 296 public static com.liferay.portlet.journal.model.JournalStructure fetchByUUID_G( 297 java.lang.String uuid, long groupId) 298 throws com.liferay.portal.kernel.exception.SystemException { 299 return getPersistence().fetchByUUID_G(uuid, groupId); 300 } 301 302 /** 303 * Returns the journal structure where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 304 * 305 * @param uuid the uuid 306 * @param groupId the group ID 307 * @param retrieveFromCache whether to use the finder cache 308 * @return the matching journal structure, or <code>null</code> if a matching journal structure could not be found 309 * @throws SystemException if a system exception occurred 310 */ 311 public static com.liferay.portlet.journal.model.JournalStructure fetchByUUID_G( 312 java.lang.String uuid, long groupId, boolean retrieveFromCache) 313 throws com.liferay.portal.kernel.exception.SystemException { 314 return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache); 315 } 316 317 /** 318 * Removes the journal structure where uuid = ? and groupId = ? from the database. 319 * 320 * @param uuid the uuid 321 * @param groupId the group ID 322 * @return the journal structure that was removed 323 * @throws SystemException if a system exception occurred 324 */ 325 public static com.liferay.portlet.journal.model.JournalStructure removeByUUID_G( 326 java.lang.String uuid, long groupId) 327 throws com.liferay.portal.kernel.exception.SystemException, 328 com.liferay.portlet.journal.NoSuchStructureException { 329 return getPersistence().removeByUUID_G(uuid, groupId); 330 } 331 332 /** 333 * Returns the number of journal structures where uuid = ? and groupId = ?. 334 * 335 * @param uuid the uuid 336 * @param groupId the group ID 337 * @return the number of matching journal structures 338 * @throws SystemException if a system exception occurred 339 */ 340 public static int countByUUID_G(java.lang.String uuid, long groupId) 341 throws com.liferay.portal.kernel.exception.SystemException { 342 return getPersistence().countByUUID_G(uuid, groupId); 343 } 344 345 /** 346 * Returns all the journal structures where uuid = ? and companyId = ?. 347 * 348 * @param uuid the uuid 349 * @param companyId the company ID 350 * @return the matching journal structures 351 * @throws SystemException if a system exception occurred 352 */ 353 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByUuid_C( 354 java.lang.String uuid, long companyId) 355 throws com.liferay.portal.kernel.exception.SystemException { 356 return getPersistence().findByUuid_C(uuid, companyId); 357 } 358 359 /** 360 * Returns a range of all the journal structures where uuid = ? and companyId = ?. 361 * 362 * <p> 363 * 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. 364 * </p> 365 * 366 * @param uuid the uuid 367 * @param companyId the company ID 368 * @param start the lower bound of the range of journal structures 369 * @param end the upper bound of the range of journal structures (not inclusive) 370 * @return the range of matching journal structures 371 * @throws SystemException if a system exception occurred 372 */ 373 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByUuid_C( 374 java.lang.String uuid, long companyId, int start, int end) 375 throws com.liferay.portal.kernel.exception.SystemException { 376 return getPersistence().findByUuid_C(uuid, companyId, start, end); 377 } 378 379 /** 380 * Returns an ordered range of all the journal structures where uuid = ? and companyId = ?. 381 * 382 * <p> 383 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link 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. 384 * </p> 385 * 386 * @param uuid the uuid 387 * @param companyId the company ID 388 * @param start the lower bound of the range of journal structures 389 * @param end the upper bound of the range of journal structures (not inclusive) 390 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 391 * @return the ordered range of matching journal structures 392 * @throws SystemException if a system exception occurred 393 */ 394 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByUuid_C( 395 java.lang.String uuid, long companyId, int start, int end, 396 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 397 throws com.liferay.portal.kernel.exception.SystemException { 398 return getPersistence() 399 .findByUuid_C(uuid, companyId, start, end, orderByComparator); 400 } 401 402 /** 403 * Returns the first journal structure in the ordered set where uuid = ? and companyId = ?. 404 * 405 * @param uuid the uuid 406 * @param companyId the company ID 407 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 408 * @return the first matching journal structure 409 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 410 * @throws SystemException if a system exception occurred 411 */ 412 public static com.liferay.portlet.journal.model.JournalStructure findByUuid_C_First( 413 java.lang.String uuid, long companyId, 414 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 415 throws com.liferay.portal.kernel.exception.SystemException, 416 com.liferay.portlet.journal.NoSuchStructureException { 417 return getPersistence() 418 .findByUuid_C_First(uuid, companyId, orderByComparator); 419 } 420 421 /** 422 * Returns the first journal structure in the ordered set where uuid = ? and companyId = ?. 423 * 424 * @param uuid the uuid 425 * @param companyId the company ID 426 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 427 * @return the first matching journal structure, or <code>null</code> if a matching journal structure could not be found 428 * @throws SystemException if a system exception occurred 429 */ 430 public static com.liferay.portlet.journal.model.JournalStructure fetchByUuid_C_First( 431 java.lang.String uuid, long companyId, 432 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 433 throws com.liferay.portal.kernel.exception.SystemException { 434 return getPersistence() 435 .fetchByUuid_C_First(uuid, companyId, orderByComparator); 436 } 437 438 /** 439 * Returns the last journal structure in the ordered set where uuid = ? and companyId = ?. 440 * 441 * @param uuid the uuid 442 * @param companyId the company ID 443 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 444 * @return the last matching journal structure 445 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 446 * @throws SystemException if a system exception occurred 447 */ 448 public static com.liferay.portlet.journal.model.JournalStructure findByUuid_C_Last( 449 java.lang.String uuid, long companyId, 450 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 451 throws com.liferay.portal.kernel.exception.SystemException, 452 com.liferay.portlet.journal.NoSuchStructureException { 453 return getPersistence() 454 .findByUuid_C_Last(uuid, companyId, orderByComparator); 455 } 456 457 /** 458 * Returns the last journal structure in the ordered set where uuid = ? and companyId = ?. 459 * 460 * @param uuid the uuid 461 * @param companyId the company ID 462 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 463 * @return the last matching journal structure, or <code>null</code> if a matching journal structure could not be found 464 * @throws SystemException if a system exception occurred 465 */ 466 public static com.liferay.portlet.journal.model.JournalStructure fetchByUuid_C_Last( 467 java.lang.String uuid, long companyId, 468 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 469 throws com.liferay.portal.kernel.exception.SystemException { 470 return getPersistence() 471 .fetchByUuid_C_Last(uuid, companyId, orderByComparator); 472 } 473 474 /** 475 * Returns the journal structures before and after the current journal structure in the ordered set where uuid = ? and companyId = ?. 476 * 477 * @param id the primary key of the current journal structure 478 * @param uuid the uuid 479 * @param companyId the company ID 480 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 481 * @return the previous, current, and next journal structure 482 * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found 483 * @throws SystemException if a system exception occurred 484 */ 485 public static com.liferay.portlet.journal.model.JournalStructure[] findByUuid_C_PrevAndNext( 486 long id, java.lang.String uuid, long companyId, 487 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 488 throws com.liferay.portal.kernel.exception.SystemException, 489 com.liferay.portlet.journal.NoSuchStructureException { 490 return getPersistence() 491 .findByUuid_C_PrevAndNext(id, uuid, companyId, 492 orderByComparator); 493 } 494 495 /** 496 * Removes all the journal structures where uuid = ? and companyId = ? from the database. 497 * 498 * @param uuid the uuid 499 * @param companyId the company ID 500 * @throws SystemException if a system exception occurred 501 */ 502 public static void removeByUuid_C(java.lang.String uuid, long companyId) 503 throws com.liferay.portal.kernel.exception.SystemException { 504 getPersistence().removeByUuid_C(uuid, companyId); 505 } 506 507 /** 508 * Returns the number of journal structures where uuid = ? and companyId = ?. 509 * 510 * @param uuid the uuid 511 * @param companyId the company ID 512 * @return the number of matching journal structures 513 * @throws SystemException if a system exception occurred 514 */ 515 public static int countByUuid_C(java.lang.String uuid, long companyId) 516 throws com.liferay.portal.kernel.exception.SystemException { 517 return getPersistence().countByUuid_C(uuid, companyId); 518 } 519 520 /** 521 * Returns all the journal structures where groupId = ?. 522 * 523 * @param groupId the group ID 524 * @return the matching journal structures 525 * @throws SystemException if a system exception occurred 526 */ 527 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByGroupId( 528 long groupId) 529 throws com.liferay.portal.kernel.exception.SystemException { 530 return getPersistence().findByGroupId(groupId); 531 } 532 533 /** 534 * Returns a range of all the journal structures where groupId = ?. 535 * 536 * <p> 537 * 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. 538 * </p> 539 * 540 * @param groupId the group ID 541 * @param start the lower bound of the range of journal structures 542 * @param end the upper bound of the range of journal structures (not inclusive) 543 * @return the range of matching journal structures 544 * @throws SystemException if a system exception occurred 545 */ 546 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByGroupId( 547 long groupId, int start, int end) 548 throws com.liferay.portal.kernel.exception.SystemException { 549 return getPersistence().findByGroupId(groupId, start, end); 550 } 551 552 /** 553 * Returns an ordered range of all the journal structures where groupId = ?. 554 * 555 * <p> 556 * 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. 557 * </p> 558 * 559 * @param groupId the group ID 560 * @param start the lower bound of the range of journal structures 561 * @param end the upper bound of the range of journal structures (not inclusive) 562 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 563 * @return the ordered range of matching journal structures 564 * @throws SystemException if a system exception occurred 565 */ 566 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByGroupId( 567 long groupId, int start, int end, 568 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 569 throws com.liferay.portal.kernel.exception.SystemException { 570 return getPersistence() 571 .findByGroupId(groupId, start, end, orderByComparator); 572 } 573 574 /** 575 * Returns the first journal structure in the ordered set where groupId = ?. 576 * 577 * @param groupId the group ID 578 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 579 * @return the first matching journal structure 580 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 581 * @throws SystemException if a system exception occurred 582 */ 583 public static com.liferay.portlet.journal.model.JournalStructure findByGroupId_First( 584 long groupId, 585 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 586 throws com.liferay.portal.kernel.exception.SystemException, 587 com.liferay.portlet.journal.NoSuchStructureException { 588 return getPersistence().findByGroupId_First(groupId, orderByComparator); 589 } 590 591 /** 592 * Returns the first journal structure in the ordered set where groupId = ?. 593 * 594 * @param groupId the group ID 595 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 596 * @return the first matching journal structure, or <code>null</code> if a matching journal structure could not be found 597 * @throws SystemException if a system exception occurred 598 */ 599 public static com.liferay.portlet.journal.model.JournalStructure fetchByGroupId_First( 600 long groupId, 601 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 602 throws com.liferay.portal.kernel.exception.SystemException { 603 return getPersistence().fetchByGroupId_First(groupId, orderByComparator); 604 } 605 606 /** 607 * Returns the last journal structure in the ordered set where groupId = ?. 608 * 609 * @param groupId the group ID 610 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 611 * @return the last matching journal structure 612 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 613 * @throws SystemException if a system exception occurred 614 */ 615 public static com.liferay.portlet.journal.model.JournalStructure findByGroupId_Last( 616 long groupId, 617 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 618 throws com.liferay.portal.kernel.exception.SystemException, 619 com.liferay.portlet.journal.NoSuchStructureException { 620 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 621 } 622 623 /** 624 * Returns the last journal structure in the ordered set where groupId = ?. 625 * 626 * @param groupId the group ID 627 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 628 * @return the last matching journal structure, or <code>null</code> if a matching journal structure could not be found 629 * @throws SystemException if a system exception occurred 630 */ 631 public static com.liferay.portlet.journal.model.JournalStructure fetchByGroupId_Last( 632 long groupId, 633 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 634 throws com.liferay.portal.kernel.exception.SystemException { 635 return getPersistence().fetchByGroupId_Last(groupId, orderByComparator); 636 } 637 638 /** 639 * Returns the journal structures before and after the current journal structure in the ordered set where groupId = ?. 640 * 641 * @param id the primary key of the current journal structure 642 * @param groupId the group ID 643 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 644 * @return the previous, current, and next journal structure 645 * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found 646 * @throws SystemException if a system exception occurred 647 */ 648 public static com.liferay.portlet.journal.model.JournalStructure[] findByGroupId_PrevAndNext( 649 long id, long groupId, 650 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 651 throws com.liferay.portal.kernel.exception.SystemException, 652 com.liferay.portlet.journal.NoSuchStructureException { 653 return getPersistence() 654 .findByGroupId_PrevAndNext(id, groupId, orderByComparator); 655 } 656 657 /** 658 * Returns all the journal structures that the user has permission to view where groupId = ?. 659 * 660 * @param groupId the group ID 661 * @return the matching journal structures that the user has permission to view 662 * @throws SystemException if a system exception occurred 663 */ 664 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByGroupId( 665 long groupId) 666 throws com.liferay.portal.kernel.exception.SystemException { 667 return getPersistence().filterFindByGroupId(groupId); 668 } 669 670 /** 671 * Returns a range of all the journal structures that the user has permission to view where groupId = ?. 672 * 673 * <p> 674 * 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. 675 * </p> 676 * 677 * @param groupId the group ID 678 * @param start the lower bound of the range of journal structures 679 * @param end the upper bound of the range of journal structures (not inclusive) 680 * @return the range of matching journal structures that the user has permission to view 681 * @throws SystemException if a system exception occurred 682 */ 683 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByGroupId( 684 long groupId, int start, int end) 685 throws com.liferay.portal.kernel.exception.SystemException { 686 return getPersistence().filterFindByGroupId(groupId, start, end); 687 } 688 689 /** 690 * Returns an ordered range of all the journal structures that the user has permissions to view where groupId = ?. 691 * 692 * <p> 693 * 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. 694 * </p> 695 * 696 * @param groupId the group ID 697 * @param start the lower bound of the range of journal structures 698 * @param end the upper bound of the range of journal structures (not inclusive) 699 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 700 * @return the ordered range of matching journal structures that the user has permission to view 701 * @throws SystemException if a system exception occurred 702 */ 703 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByGroupId( 704 long groupId, int start, int end, 705 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 706 throws com.liferay.portal.kernel.exception.SystemException { 707 return getPersistence() 708 .filterFindByGroupId(groupId, start, end, orderByComparator); 709 } 710 711 /** 712 * 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 = ?. 713 * 714 * @param id the primary key of the current journal structure 715 * @param groupId the group ID 716 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 717 * @return the previous, current, and next journal structure 718 * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found 719 * @throws SystemException if a system exception occurred 720 */ 721 public static com.liferay.portlet.journal.model.JournalStructure[] filterFindByGroupId_PrevAndNext( 722 long id, long groupId, 723 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 724 throws com.liferay.portal.kernel.exception.SystemException, 725 com.liferay.portlet.journal.NoSuchStructureException { 726 return getPersistence() 727 .filterFindByGroupId_PrevAndNext(id, groupId, 728 orderByComparator); 729 } 730 731 /** 732 * Returns all the journal structures that the user has permission to view where groupId = any ?. 733 * 734 * @param groupIds the group IDs 735 * @return the matching journal structures that the user has permission to view 736 * @throws SystemException if a system exception occurred 737 */ 738 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByGroupId( 739 long[] groupIds) 740 throws com.liferay.portal.kernel.exception.SystemException { 741 return getPersistence().filterFindByGroupId(groupIds); 742 } 743 744 /** 745 * Returns a range of all the journal structures that the user has permission to view where groupId = any ?. 746 * 747 * <p> 748 * 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. 749 * </p> 750 * 751 * @param groupIds the group IDs 752 * @param start the lower bound of the range of journal structures 753 * @param end the upper bound of the range of journal structures (not inclusive) 754 * @return the range of matching journal structures that the user has permission to view 755 * @throws SystemException if a system exception occurred 756 */ 757 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByGroupId( 758 long[] groupIds, int start, int end) 759 throws com.liferay.portal.kernel.exception.SystemException { 760 return getPersistence().filterFindByGroupId(groupIds, start, end); 761 } 762 763 /** 764 * Returns an ordered range of all the journal structures that the user has permission to view where groupId = any ?. 765 * 766 * <p> 767 * 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. 768 * </p> 769 * 770 * @param groupIds the group IDs 771 * @param start the lower bound of the range of journal structures 772 * @param end the upper bound of the range of journal structures (not inclusive) 773 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 774 * @return the ordered range of matching journal structures that the user has permission to view 775 * @throws SystemException if a system exception occurred 776 */ 777 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByGroupId( 778 long[] groupIds, int start, int end, 779 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 780 throws com.liferay.portal.kernel.exception.SystemException { 781 return getPersistence() 782 .filterFindByGroupId(groupIds, start, end, orderByComparator); 783 } 784 785 /** 786 * Returns all the journal structures where groupId = any ?. 787 * 788 * <p> 789 * 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. 790 * </p> 791 * 792 * @param groupIds the group IDs 793 * @return the matching journal structures 794 * @throws SystemException if a system exception occurred 795 */ 796 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByGroupId( 797 long[] groupIds) 798 throws com.liferay.portal.kernel.exception.SystemException { 799 return getPersistence().findByGroupId(groupIds); 800 } 801 802 /** 803 * Returns a range of all the journal structures where groupId = any ?. 804 * 805 * <p> 806 * 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. 807 * </p> 808 * 809 * @param groupIds the group IDs 810 * @param start the lower bound of the range of journal structures 811 * @param end the upper bound of the range of journal structures (not inclusive) 812 * @return the range of matching journal structures 813 * @throws SystemException if a system exception occurred 814 */ 815 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByGroupId( 816 long[] groupIds, int start, int end) 817 throws com.liferay.portal.kernel.exception.SystemException { 818 return getPersistence().findByGroupId(groupIds, start, end); 819 } 820 821 /** 822 * Returns an ordered range of all the journal structures where groupId = any ?. 823 * 824 * <p> 825 * 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. 826 * </p> 827 * 828 * @param groupIds the group IDs 829 * @param start the lower bound of the range of journal structures 830 * @param end the upper bound of the range of journal structures (not inclusive) 831 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 832 * @return the ordered range of matching journal structures 833 * @throws SystemException if a system exception occurred 834 */ 835 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByGroupId( 836 long[] groupIds, int start, int end, 837 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 838 throws com.liferay.portal.kernel.exception.SystemException { 839 return getPersistence() 840 .findByGroupId(groupIds, start, end, orderByComparator); 841 } 842 843 /** 844 * Removes all the journal structures where groupId = ? from the database. 845 * 846 * @param groupId the group ID 847 * @throws SystemException if a system exception occurred 848 */ 849 public static void removeByGroupId(long groupId) 850 throws com.liferay.portal.kernel.exception.SystemException { 851 getPersistence().removeByGroupId(groupId); 852 } 853 854 /** 855 * Returns the number of journal structures where groupId = ?. 856 * 857 * @param groupId the group ID 858 * @return the number of matching journal structures 859 * @throws SystemException if a system exception occurred 860 */ 861 public static int countByGroupId(long groupId) 862 throws com.liferay.portal.kernel.exception.SystemException { 863 return getPersistence().countByGroupId(groupId); 864 } 865 866 /** 867 * Returns the number of journal structures where groupId = any ?. 868 * 869 * @param groupIds the group IDs 870 * @return the number of matching journal structures 871 * @throws SystemException if a system exception occurred 872 */ 873 public static int countByGroupId(long[] groupIds) 874 throws com.liferay.portal.kernel.exception.SystemException { 875 return getPersistence().countByGroupId(groupIds); 876 } 877 878 /** 879 * Returns the number of journal structures that the user has permission to view where groupId = ?. 880 * 881 * @param groupId the group ID 882 * @return the number of matching journal structures that the user has permission to view 883 * @throws SystemException if a system exception occurred 884 */ 885 public static int filterCountByGroupId(long groupId) 886 throws com.liferay.portal.kernel.exception.SystemException { 887 return getPersistence().filterCountByGroupId(groupId); 888 } 889 890 /** 891 * Returns the number of journal structures that the user has permission to view where groupId = any ?. 892 * 893 * @param groupIds the group IDs 894 * @return the number of matching journal structures that the user has permission to view 895 * @throws SystemException if a system exception occurred 896 */ 897 public static int filterCountByGroupId(long[] groupIds) 898 throws com.liferay.portal.kernel.exception.SystemException { 899 return getPersistence().filterCountByGroupId(groupIds); 900 } 901 902 /** 903 * Returns all the journal structures where structureId = ?. 904 * 905 * @param structureId the structure ID 906 * @return the matching journal structures 907 * @throws SystemException if a system exception occurred 908 */ 909 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByStructureId( 910 java.lang.String structureId) 911 throws com.liferay.portal.kernel.exception.SystemException { 912 return getPersistence().findByStructureId(structureId); 913 } 914 915 /** 916 * Returns a range of all the journal structures where structureId = ?. 917 * 918 * <p> 919 * 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. 920 * </p> 921 * 922 * @param structureId the structure ID 923 * @param start the lower bound of the range of journal structures 924 * @param end the upper bound of the range of journal structures (not inclusive) 925 * @return the range of matching journal structures 926 * @throws SystemException if a system exception occurred 927 */ 928 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByStructureId( 929 java.lang.String structureId, int start, int end) 930 throws com.liferay.portal.kernel.exception.SystemException { 931 return getPersistence().findByStructureId(structureId, start, end); 932 } 933 934 /** 935 * Returns an ordered range of all the journal structures where structureId = ?. 936 * 937 * <p> 938 * 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. 939 * </p> 940 * 941 * @param structureId the structure ID 942 * @param start the lower bound of the range of journal structures 943 * @param end the upper bound of the range of journal structures (not inclusive) 944 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 945 * @return the ordered range of matching journal structures 946 * @throws SystemException if a system exception occurred 947 */ 948 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByStructureId( 949 java.lang.String structureId, int start, int end, 950 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 951 throws com.liferay.portal.kernel.exception.SystemException { 952 return getPersistence() 953 .findByStructureId(structureId, start, end, orderByComparator); 954 } 955 956 /** 957 * Returns the first journal structure in the ordered set where structureId = ?. 958 * 959 * @param structureId the structure ID 960 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 961 * @return the first matching journal structure 962 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 963 * @throws SystemException if a system exception occurred 964 */ 965 public static com.liferay.portlet.journal.model.JournalStructure findByStructureId_First( 966 java.lang.String structureId, 967 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 968 throws com.liferay.portal.kernel.exception.SystemException, 969 com.liferay.portlet.journal.NoSuchStructureException { 970 return getPersistence() 971 .findByStructureId_First(structureId, orderByComparator); 972 } 973 974 /** 975 * Returns the first journal structure in the ordered set where structureId = ?. 976 * 977 * @param structureId the structure ID 978 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 979 * @return the first matching journal structure, or <code>null</code> if a matching journal structure could not be found 980 * @throws SystemException if a system exception occurred 981 */ 982 public static com.liferay.portlet.journal.model.JournalStructure fetchByStructureId_First( 983 java.lang.String structureId, 984 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 985 throws com.liferay.portal.kernel.exception.SystemException { 986 return getPersistence() 987 .fetchByStructureId_First(structureId, orderByComparator); 988 } 989 990 /** 991 * Returns the last journal structure in the ordered set where structureId = ?. 992 * 993 * @param structureId the structure ID 994 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 995 * @return the last matching journal structure 996 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 997 * @throws SystemException if a system exception occurred 998 */ 999 public static com.liferay.portlet.journal.model.JournalStructure findByStructureId_Last( 1000 java.lang.String structureId, 1001 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1002 throws com.liferay.portal.kernel.exception.SystemException, 1003 com.liferay.portlet.journal.NoSuchStructureException { 1004 return getPersistence() 1005 .findByStructureId_Last(structureId, orderByComparator); 1006 } 1007 1008 /** 1009 * Returns the last journal structure in the ordered set where structureId = ?. 1010 * 1011 * @param structureId the structure ID 1012 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1013 * @return the last 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 static com.liferay.portlet.journal.model.JournalStructure fetchByStructureId_Last( 1017 java.lang.String structureId, 1018 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1019 throws com.liferay.portal.kernel.exception.SystemException { 1020 return getPersistence() 1021 .fetchByStructureId_Last(structureId, orderByComparator); 1022 } 1023 1024 /** 1025 * Returns the journal structures before and after the current journal structure in the ordered set where structureId = ?. 1026 * 1027 * @param id the primary key of the current journal structure 1028 * @param structureId the structure ID 1029 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1030 * @return the previous, current, and next journal structure 1031 * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found 1032 * @throws SystemException if a system exception occurred 1033 */ 1034 public static com.liferay.portlet.journal.model.JournalStructure[] findByStructureId_PrevAndNext( 1035 long id, java.lang.String structureId, 1036 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1037 throws com.liferay.portal.kernel.exception.SystemException, 1038 com.liferay.portlet.journal.NoSuchStructureException { 1039 return getPersistence() 1040 .findByStructureId_PrevAndNext(id, structureId, 1041 orderByComparator); 1042 } 1043 1044 /** 1045 * Removes all the journal structures where structureId = ? from the database. 1046 * 1047 * @param structureId the structure ID 1048 * @throws SystemException if a system exception occurred 1049 */ 1050 public static void removeByStructureId(java.lang.String structureId) 1051 throws com.liferay.portal.kernel.exception.SystemException { 1052 getPersistence().removeByStructureId(structureId); 1053 } 1054 1055 /** 1056 * Returns the number of journal structures where structureId = ?. 1057 * 1058 * @param structureId the structure ID 1059 * @return the number of matching journal structures 1060 * @throws SystemException if a system exception occurred 1061 */ 1062 public static int countByStructureId(java.lang.String structureId) 1063 throws com.liferay.portal.kernel.exception.SystemException { 1064 return getPersistence().countByStructureId(structureId); 1065 } 1066 1067 /** 1068 * Returns all the journal structures where parentStructureId = ?. 1069 * 1070 * @param parentStructureId the parent structure ID 1071 * @return the matching journal structures 1072 * @throws SystemException if a system exception occurred 1073 */ 1074 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByParentStructureId( 1075 java.lang.String parentStructureId) 1076 throws com.liferay.portal.kernel.exception.SystemException { 1077 return getPersistence().findByParentStructureId(parentStructureId); 1078 } 1079 1080 /** 1081 * Returns a range of all the journal structures where parentStructureId = ?. 1082 * 1083 * <p> 1084 * 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. 1085 * </p> 1086 * 1087 * @param parentStructureId the parent structure ID 1088 * @param start the lower bound of the range of journal structures 1089 * @param end the upper bound of the range of journal structures (not inclusive) 1090 * @return the range of matching journal structures 1091 * @throws SystemException if a system exception occurred 1092 */ 1093 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByParentStructureId( 1094 java.lang.String parentStructureId, int start, int end) 1095 throws com.liferay.portal.kernel.exception.SystemException { 1096 return getPersistence() 1097 .findByParentStructureId(parentStructureId, start, end); 1098 } 1099 1100 /** 1101 * Returns an ordered range of all the journal structures where parentStructureId = ?. 1102 * 1103 * <p> 1104 * 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. 1105 * </p> 1106 * 1107 * @param parentStructureId the parent structure ID 1108 * @param start the lower bound of the range of journal structures 1109 * @param end the upper bound of the range of journal structures (not inclusive) 1110 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1111 * @return the ordered range of matching journal structures 1112 * @throws SystemException if a system exception occurred 1113 */ 1114 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByParentStructureId( 1115 java.lang.String parentStructureId, int start, int end, 1116 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1117 throws com.liferay.portal.kernel.exception.SystemException { 1118 return getPersistence() 1119 .findByParentStructureId(parentStructureId, start, end, 1120 orderByComparator); 1121 } 1122 1123 /** 1124 * Returns the first journal structure in the ordered set where parentStructureId = ?. 1125 * 1126 * @param parentStructureId the parent structure ID 1127 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1128 * @return the first matching journal structure 1129 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 1130 * @throws SystemException if a system exception occurred 1131 */ 1132 public static com.liferay.portlet.journal.model.JournalStructure findByParentStructureId_First( 1133 java.lang.String parentStructureId, 1134 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1135 throws com.liferay.portal.kernel.exception.SystemException, 1136 com.liferay.portlet.journal.NoSuchStructureException { 1137 return getPersistence() 1138 .findByParentStructureId_First(parentStructureId, 1139 orderByComparator); 1140 } 1141 1142 /** 1143 * Returns the first journal structure in the ordered set where parentStructureId = ?. 1144 * 1145 * @param parentStructureId the parent structure ID 1146 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1147 * @return the first matching journal structure, or <code>null</code> if a matching journal structure could not be found 1148 * @throws SystemException if a system exception occurred 1149 */ 1150 public static com.liferay.portlet.journal.model.JournalStructure fetchByParentStructureId_First( 1151 java.lang.String parentStructureId, 1152 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1153 throws com.liferay.portal.kernel.exception.SystemException { 1154 return getPersistence() 1155 .fetchByParentStructureId_First(parentStructureId, 1156 orderByComparator); 1157 } 1158 1159 /** 1160 * Returns the last journal structure in the ordered set where parentStructureId = ?. 1161 * 1162 * @param parentStructureId the parent structure ID 1163 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1164 * @return the last matching journal structure 1165 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 1166 * @throws SystemException if a system exception occurred 1167 */ 1168 public static com.liferay.portlet.journal.model.JournalStructure findByParentStructureId_Last( 1169 java.lang.String parentStructureId, 1170 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1171 throws com.liferay.portal.kernel.exception.SystemException, 1172 com.liferay.portlet.journal.NoSuchStructureException { 1173 return getPersistence() 1174 .findByParentStructureId_Last(parentStructureId, 1175 orderByComparator); 1176 } 1177 1178 /** 1179 * Returns the last journal structure in the ordered set where parentStructureId = ?. 1180 * 1181 * @param parentStructureId the parent structure ID 1182 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1183 * @return the last matching journal structure, or <code>null</code> if a matching journal structure could not be found 1184 * @throws SystemException if a system exception occurred 1185 */ 1186 public static com.liferay.portlet.journal.model.JournalStructure fetchByParentStructureId_Last( 1187 java.lang.String parentStructureId, 1188 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1189 throws com.liferay.portal.kernel.exception.SystemException { 1190 return getPersistence() 1191 .fetchByParentStructureId_Last(parentStructureId, 1192 orderByComparator); 1193 } 1194 1195 /** 1196 * Returns the journal structures before and after the current journal structure in the ordered set where parentStructureId = ?. 1197 * 1198 * @param id the primary key of the current journal structure 1199 * @param parentStructureId the parent structure ID 1200 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1201 * @return the previous, current, and next journal structure 1202 * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found 1203 * @throws SystemException if a system exception occurred 1204 */ 1205 public static com.liferay.portlet.journal.model.JournalStructure[] findByParentStructureId_PrevAndNext( 1206 long id, java.lang.String parentStructureId, 1207 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1208 throws com.liferay.portal.kernel.exception.SystemException, 1209 com.liferay.portlet.journal.NoSuchStructureException { 1210 return getPersistence() 1211 .findByParentStructureId_PrevAndNext(id, parentStructureId, 1212 orderByComparator); 1213 } 1214 1215 /** 1216 * Removes all the journal structures where parentStructureId = ? from the database. 1217 * 1218 * @param parentStructureId the parent structure ID 1219 * @throws SystemException if a system exception occurred 1220 */ 1221 public static void removeByParentStructureId( 1222 java.lang.String parentStructureId) 1223 throws com.liferay.portal.kernel.exception.SystemException { 1224 getPersistence().removeByParentStructureId(parentStructureId); 1225 } 1226 1227 /** 1228 * Returns the number of journal structures where parentStructureId = ?. 1229 * 1230 * @param parentStructureId the parent structure ID 1231 * @return the number of matching journal structures 1232 * @throws SystemException if a system exception occurred 1233 */ 1234 public static int countByParentStructureId( 1235 java.lang.String parentStructureId) 1236 throws com.liferay.portal.kernel.exception.SystemException { 1237 return getPersistence().countByParentStructureId(parentStructureId); 1238 } 1239 1240 /** 1241 * Returns the journal structure where groupId = ? and structureId = ? or throws a {@link com.liferay.portlet.journal.NoSuchStructureException} if it could not be found. 1242 * 1243 * @param groupId the group ID 1244 * @param structureId the structure ID 1245 * @return the matching journal structure 1246 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 1247 * @throws SystemException if a system exception occurred 1248 */ 1249 public static com.liferay.portlet.journal.model.JournalStructure findByG_S( 1250 long groupId, java.lang.String structureId) 1251 throws com.liferay.portal.kernel.exception.SystemException, 1252 com.liferay.portlet.journal.NoSuchStructureException { 1253 return getPersistence().findByG_S(groupId, structureId); 1254 } 1255 1256 /** 1257 * Returns the journal structure where groupId = ? and structureId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 1258 * 1259 * @param groupId the group ID 1260 * @param structureId the structure ID 1261 * @return the matching journal structure, or <code>null</code> if a matching journal structure could not be found 1262 * @throws SystemException if a system exception occurred 1263 */ 1264 public static com.liferay.portlet.journal.model.JournalStructure fetchByG_S( 1265 long groupId, java.lang.String structureId) 1266 throws com.liferay.portal.kernel.exception.SystemException { 1267 return getPersistence().fetchByG_S(groupId, structureId); 1268 } 1269 1270 /** 1271 * Returns the journal structure where groupId = ? and structureId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 1272 * 1273 * @param groupId the group ID 1274 * @param structureId the structure ID 1275 * @param retrieveFromCache whether to use the finder cache 1276 * @return the matching journal structure, or <code>null</code> if a matching journal structure could not be found 1277 * @throws SystemException if a system exception occurred 1278 */ 1279 public static com.liferay.portlet.journal.model.JournalStructure fetchByG_S( 1280 long groupId, java.lang.String structureId, boolean retrieveFromCache) 1281 throws com.liferay.portal.kernel.exception.SystemException { 1282 return getPersistence() 1283 .fetchByG_S(groupId, structureId, retrieveFromCache); 1284 } 1285 1286 /** 1287 * Removes the journal structure where groupId = ? and structureId = ? from the database. 1288 * 1289 * @param groupId the group ID 1290 * @param structureId the structure ID 1291 * @return the journal structure that was removed 1292 * @throws SystemException if a system exception occurred 1293 */ 1294 public static com.liferay.portlet.journal.model.JournalStructure removeByG_S( 1295 long groupId, java.lang.String structureId) 1296 throws com.liferay.portal.kernel.exception.SystemException, 1297 com.liferay.portlet.journal.NoSuchStructureException { 1298 return getPersistence().removeByG_S(groupId, structureId); 1299 } 1300 1301 /** 1302 * Returns the number of journal structures where groupId = ? and structureId = ?. 1303 * 1304 * @param groupId the group ID 1305 * @param structureId the structure ID 1306 * @return the number of matching journal structures 1307 * @throws SystemException if a system exception occurred 1308 */ 1309 public static int countByG_S(long groupId, java.lang.String structureId) 1310 throws com.liferay.portal.kernel.exception.SystemException { 1311 return getPersistence().countByG_S(groupId, structureId); 1312 } 1313 1314 /** 1315 * Returns all the journal structures where groupId = ? and parentStructureId = ?. 1316 * 1317 * @param groupId the group ID 1318 * @param parentStructureId the parent structure ID 1319 * @return the matching journal structures 1320 * @throws SystemException if a system exception occurred 1321 */ 1322 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByG_P( 1323 long groupId, java.lang.String parentStructureId) 1324 throws com.liferay.portal.kernel.exception.SystemException { 1325 return getPersistence().findByG_P(groupId, parentStructureId); 1326 } 1327 1328 /** 1329 * Returns a range of all the journal structures where groupId = ? and parentStructureId = ?. 1330 * 1331 * <p> 1332 * 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. 1333 * </p> 1334 * 1335 * @param groupId the group ID 1336 * @param parentStructureId the parent structure ID 1337 * @param start the lower bound of the range of journal structures 1338 * @param end the upper bound of the range of journal structures (not inclusive) 1339 * @return the range of matching journal structures 1340 * @throws SystemException if a system exception occurred 1341 */ 1342 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByG_P( 1343 long groupId, java.lang.String parentStructureId, int start, int end) 1344 throws com.liferay.portal.kernel.exception.SystemException { 1345 return getPersistence().findByG_P(groupId, parentStructureId, start, end); 1346 } 1347 1348 /** 1349 * Returns an ordered range of all the journal structures where groupId = ? and parentStructureId = ?. 1350 * 1351 * <p> 1352 * 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. 1353 * </p> 1354 * 1355 * @param groupId the group ID 1356 * @param parentStructureId the parent structure ID 1357 * @param start the lower bound of the range of journal structures 1358 * @param end the upper bound of the range of journal structures (not inclusive) 1359 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1360 * @return the ordered range of matching journal structures 1361 * @throws SystemException if a system exception occurred 1362 */ 1363 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByG_P( 1364 long groupId, java.lang.String parentStructureId, int start, int end, 1365 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1366 throws com.liferay.portal.kernel.exception.SystemException { 1367 return getPersistence() 1368 .findByG_P(groupId, parentStructureId, start, end, 1369 orderByComparator); 1370 } 1371 1372 /** 1373 * Returns the first journal structure in the ordered set where groupId = ? and parentStructureId = ?. 1374 * 1375 * @param groupId the group ID 1376 * @param parentStructureId the parent structure ID 1377 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1378 * @return the first matching journal structure 1379 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 1380 * @throws SystemException if a system exception occurred 1381 */ 1382 public static com.liferay.portlet.journal.model.JournalStructure findByG_P_First( 1383 long groupId, java.lang.String parentStructureId, 1384 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1385 throws com.liferay.portal.kernel.exception.SystemException, 1386 com.liferay.portlet.journal.NoSuchStructureException { 1387 return getPersistence() 1388 .findByG_P_First(groupId, parentStructureId, 1389 orderByComparator); 1390 } 1391 1392 /** 1393 * Returns the first journal structure in the ordered set where groupId = ? and parentStructureId = ?. 1394 * 1395 * @param groupId the group ID 1396 * @param parentStructureId the parent structure ID 1397 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1398 * @return the first matching journal structure, or <code>null</code> if a matching journal structure could not be found 1399 * @throws SystemException if a system exception occurred 1400 */ 1401 public static com.liferay.portlet.journal.model.JournalStructure fetchByG_P_First( 1402 long groupId, java.lang.String parentStructureId, 1403 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1404 throws com.liferay.portal.kernel.exception.SystemException { 1405 return getPersistence() 1406 .fetchByG_P_First(groupId, parentStructureId, 1407 orderByComparator); 1408 } 1409 1410 /** 1411 * Returns the last journal structure in the ordered set where groupId = ? and parentStructureId = ?. 1412 * 1413 * @param groupId the group ID 1414 * @param parentStructureId the parent structure ID 1415 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1416 * @return the last matching journal structure 1417 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 1418 * @throws SystemException if a system exception occurred 1419 */ 1420 public static com.liferay.portlet.journal.model.JournalStructure findByG_P_Last( 1421 long groupId, java.lang.String parentStructureId, 1422 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1423 throws com.liferay.portal.kernel.exception.SystemException, 1424 com.liferay.portlet.journal.NoSuchStructureException { 1425 return getPersistence() 1426 .findByG_P_Last(groupId, parentStructureId, orderByComparator); 1427 } 1428 1429 /** 1430 * Returns the last journal structure in the ordered set where groupId = ? and parentStructureId = ?. 1431 * 1432 * @param groupId the group ID 1433 * @param parentStructureId the parent structure ID 1434 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1435 * @return the last matching journal structure, or <code>null</code> if a matching journal structure could not be found 1436 * @throws SystemException if a system exception occurred 1437 */ 1438 public static com.liferay.portlet.journal.model.JournalStructure fetchByG_P_Last( 1439 long groupId, java.lang.String parentStructureId, 1440 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1441 throws com.liferay.portal.kernel.exception.SystemException { 1442 return getPersistence() 1443 .fetchByG_P_Last(groupId, parentStructureId, 1444 orderByComparator); 1445 } 1446 1447 /** 1448 * Returns the journal structures before and after the current journal structure in the ordered set where groupId = ? and parentStructureId = ?. 1449 * 1450 * @param id the primary key of the current journal structure 1451 * @param groupId the group ID 1452 * @param parentStructureId the parent structure ID 1453 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1454 * @return the previous, current, and next journal structure 1455 * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found 1456 * @throws SystemException if a system exception occurred 1457 */ 1458 public static com.liferay.portlet.journal.model.JournalStructure[] findByG_P_PrevAndNext( 1459 long id, long groupId, java.lang.String parentStructureId, 1460 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1461 throws com.liferay.portal.kernel.exception.SystemException, 1462 com.liferay.portlet.journal.NoSuchStructureException { 1463 return getPersistence() 1464 .findByG_P_PrevAndNext(id, groupId, parentStructureId, 1465 orderByComparator); 1466 } 1467 1468 /** 1469 * Returns all the journal structures that the user has permission to view where groupId = ? and parentStructureId = ?. 1470 * 1471 * @param groupId the group ID 1472 * @param parentStructureId the parent structure ID 1473 * @return the matching journal structures that the user has permission to view 1474 * @throws SystemException if a system exception occurred 1475 */ 1476 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByG_P( 1477 long groupId, java.lang.String parentStructureId) 1478 throws com.liferay.portal.kernel.exception.SystemException { 1479 return getPersistence().filterFindByG_P(groupId, parentStructureId); 1480 } 1481 1482 /** 1483 * Returns a range of all the journal structures that the user has permission to view where groupId = ? and parentStructureId = ?. 1484 * 1485 * <p> 1486 * 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. 1487 * </p> 1488 * 1489 * @param groupId the group ID 1490 * @param parentStructureId the parent structure ID 1491 * @param start the lower bound of the range of journal structures 1492 * @param end the upper bound of the range of journal structures (not inclusive) 1493 * @return the range of matching journal structures that the user has permission to view 1494 * @throws SystemException if a system exception occurred 1495 */ 1496 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByG_P( 1497 long groupId, java.lang.String parentStructureId, int start, int end) 1498 throws com.liferay.portal.kernel.exception.SystemException { 1499 return getPersistence() 1500 .filterFindByG_P(groupId, parentStructureId, start, end); 1501 } 1502 1503 /** 1504 * Returns an ordered range of all the journal structures that the user has permissions to view where groupId = ? and parentStructureId = ?. 1505 * 1506 * <p> 1507 * 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. 1508 * </p> 1509 * 1510 * @param groupId the group ID 1511 * @param parentStructureId the parent structure ID 1512 * @param start the lower bound of the range of journal structures 1513 * @param end the upper bound of the range of journal structures (not inclusive) 1514 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1515 * @return the ordered range of matching journal structures that the user has permission to view 1516 * @throws SystemException if a system exception occurred 1517 */ 1518 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByG_P( 1519 long groupId, java.lang.String parentStructureId, int start, int end, 1520 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1521 throws com.liferay.portal.kernel.exception.SystemException { 1522 return getPersistence() 1523 .filterFindByG_P(groupId, parentStructureId, start, end, 1524 orderByComparator); 1525 } 1526 1527 /** 1528 * 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 = ?. 1529 * 1530 * @param id the primary key of the current journal structure 1531 * @param groupId the group ID 1532 * @param parentStructureId the parent structure ID 1533 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1534 * @return the previous, current, and next journal structure 1535 * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found 1536 * @throws SystemException if a system exception occurred 1537 */ 1538 public static com.liferay.portlet.journal.model.JournalStructure[] filterFindByG_P_PrevAndNext( 1539 long id, long groupId, java.lang.String parentStructureId, 1540 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1541 throws com.liferay.portal.kernel.exception.SystemException, 1542 com.liferay.portlet.journal.NoSuchStructureException { 1543 return getPersistence() 1544 .filterFindByG_P_PrevAndNext(id, groupId, parentStructureId, 1545 orderByComparator); 1546 } 1547 1548 /** 1549 * Removes all the journal structures where groupId = ? and parentStructureId = ? from the database. 1550 * 1551 * @param groupId the group ID 1552 * @param parentStructureId the parent structure ID 1553 * @throws SystemException if a system exception occurred 1554 */ 1555 public static void removeByG_P(long groupId, 1556 java.lang.String parentStructureId) 1557 throws com.liferay.portal.kernel.exception.SystemException { 1558 getPersistence().removeByG_P(groupId, parentStructureId); 1559 } 1560 1561 /** 1562 * Returns the number of journal structures where groupId = ? and parentStructureId = ?. 1563 * 1564 * @param groupId the group ID 1565 * @param parentStructureId the parent structure ID 1566 * @return the number of matching journal structures 1567 * @throws SystemException if a system exception occurred 1568 */ 1569 public static int countByG_P(long groupId, 1570 java.lang.String parentStructureId) 1571 throws com.liferay.portal.kernel.exception.SystemException { 1572 return getPersistence().countByG_P(groupId, parentStructureId); 1573 } 1574 1575 /** 1576 * Returns the number of journal structures that the user has permission to view where groupId = ? and parentStructureId = ?. 1577 * 1578 * @param groupId the group ID 1579 * @param parentStructureId the parent structure ID 1580 * @return the number of matching journal structures that the user has permission to view 1581 * @throws SystemException if a system exception occurred 1582 */ 1583 public static int filterCountByG_P(long groupId, 1584 java.lang.String parentStructureId) 1585 throws com.liferay.portal.kernel.exception.SystemException { 1586 return getPersistence().filterCountByG_P(groupId, parentStructureId); 1587 } 1588 1589 /** 1590 * Caches the journal structure in the entity cache if it is enabled. 1591 * 1592 * @param journalStructure the journal structure 1593 */ 1594 public static void cacheResult( 1595 com.liferay.portlet.journal.model.JournalStructure journalStructure) { 1596 getPersistence().cacheResult(journalStructure); 1597 } 1598 1599 /** 1600 * Caches the journal structures in the entity cache if it is enabled. 1601 * 1602 * @param journalStructures the journal structures 1603 */ 1604 public static void cacheResult( 1605 java.util.List<com.liferay.portlet.journal.model.JournalStructure> journalStructures) { 1606 getPersistence().cacheResult(journalStructures); 1607 } 1608 1609 /** 1610 * Creates a new journal structure with the primary key. Does not add the journal structure to the database. 1611 * 1612 * @param id the primary key for the new journal structure 1613 * @return the new journal structure 1614 */ 1615 public static com.liferay.portlet.journal.model.JournalStructure create( 1616 long id) { 1617 return getPersistence().create(id); 1618 } 1619 1620 /** 1621 * Removes the journal structure with the primary key from the database. Also notifies the appropriate model listeners. 1622 * 1623 * @param id the primary key of the journal structure 1624 * @return the journal structure that was removed 1625 * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found 1626 * @throws SystemException if a system exception occurred 1627 */ 1628 public static com.liferay.portlet.journal.model.JournalStructure remove( 1629 long id) 1630 throws com.liferay.portal.kernel.exception.SystemException, 1631 com.liferay.portlet.journal.NoSuchStructureException { 1632 return getPersistence().remove(id); 1633 } 1634 1635 public static com.liferay.portlet.journal.model.JournalStructure updateImpl( 1636 com.liferay.portlet.journal.model.JournalStructure journalStructure) 1637 throws com.liferay.portal.kernel.exception.SystemException { 1638 return getPersistence().updateImpl(journalStructure); 1639 } 1640 1641 /** 1642 * Returns the journal structure with the primary key or throws a {@link com.liferay.portlet.journal.NoSuchStructureException} if it could not be found. 1643 * 1644 * @param id the primary key of the journal structure 1645 * @return the journal structure 1646 * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found 1647 * @throws SystemException if a system exception occurred 1648 */ 1649 public static com.liferay.portlet.journal.model.JournalStructure findByPrimaryKey( 1650 long id) 1651 throws com.liferay.portal.kernel.exception.SystemException, 1652 com.liferay.portlet.journal.NoSuchStructureException { 1653 return getPersistence().findByPrimaryKey(id); 1654 } 1655 1656 /** 1657 * Returns the journal structure with the primary key or returns <code>null</code> if it could not be found. 1658 * 1659 * @param id the primary key of the journal structure 1660 * @return the journal structure, or <code>null</code> if a journal structure with the primary key could not be found 1661 * @throws SystemException if a system exception occurred 1662 */ 1663 public static com.liferay.portlet.journal.model.JournalStructure fetchByPrimaryKey( 1664 long id) throws com.liferay.portal.kernel.exception.SystemException { 1665 return getPersistence().fetchByPrimaryKey(id); 1666 } 1667 1668 /** 1669 * Returns all the journal structures. 1670 * 1671 * @return the journal structures 1672 * @throws SystemException if a system exception occurred 1673 */ 1674 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findAll() 1675 throws com.liferay.portal.kernel.exception.SystemException { 1676 return getPersistence().findAll(); 1677 } 1678 1679 /** 1680 * Returns a range of all the journal structures. 1681 * 1682 * <p> 1683 * 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. 1684 * </p> 1685 * 1686 * @param start the lower bound of the range of journal structures 1687 * @param end the upper bound of the range of journal structures (not inclusive) 1688 * @return the range of journal structures 1689 * @throws SystemException if a system exception occurred 1690 */ 1691 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findAll( 1692 int start, int end) 1693 throws com.liferay.portal.kernel.exception.SystemException { 1694 return getPersistence().findAll(start, end); 1695 } 1696 1697 /** 1698 * Returns an ordered range of all the journal structures. 1699 * 1700 * <p> 1701 * 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. 1702 * </p> 1703 * 1704 * @param start the lower bound of the range of journal structures 1705 * @param end the upper bound of the range of journal structures (not inclusive) 1706 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1707 * @return the ordered range of journal structures 1708 * @throws SystemException if a system exception occurred 1709 */ 1710 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findAll( 1711 int start, int end, 1712 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1713 throws com.liferay.portal.kernel.exception.SystemException { 1714 return getPersistence().findAll(start, end, orderByComparator); 1715 } 1716 1717 /** 1718 * Removes all the journal structures from the database. 1719 * 1720 * @throws SystemException if a system exception occurred 1721 */ 1722 public static void removeAll() 1723 throws com.liferay.portal.kernel.exception.SystemException { 1724 getPersistence().removeAll(); 1725 } 1726 1727 /** 1728 * Returns the number of journal structures. 1729 * 1730 * @return the number of journal structures 1731 * @throws SystemException if a system exception occurred 1732 */ 1733 public static int countAll() 1734 throws com.liferay.portal.kernel.exception.SystemException { 1735 return getPersistence().countAll(); 1736 } 1737 1738 public static JournalStructurePersistence getPersistence() { 1739 if (_persistence == null) { 1740 _persistence = (JournalStructurePersistence)PortalBeanLocatorUtil.locate(JournalStructurePersistence.class.getName()); 1741 1742 ReferenceRegistry.registerReference(JournalStructureUtil.class, 1743 "_persistence"); 1744 } 1745 1746 return _persistence; 1747 } 1748 1749 /** 1750 * @deprecated As of 6.2.0 1751 */ 1752 public void setPersistence(JournalStructurePersistence persistence) { 1753 } 1754 1755 private static JournalStructurePersistence _persistence; 1756 }