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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63; 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 = &#63;.
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 = &#63; and groupId = &#63; 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 = &#63; and groupId = &#63; 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 = &#63; and groupId = &#63; 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 = &#63; and groupId = &#63; 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 = &#63; and groupId = &#63;.
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 = &#63; and companyId = &#63;.
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 = &#63; and companyId = &#63;.
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 = &#63; and companyId = &#63;.
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 = &#63; and companyId = &#63;.
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 = &#63; and companyId = &#63;.
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 = &#63; and companyId = &#63;.
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 = &#63; and companyId = &#63;.
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 = &#63; and companyId = &#63;.
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 = &#63; and companyId = &#63; 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 = &#63; and companyId = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 &#63;.
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 &#63;.
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 &#63;.
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 &#63;.
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 &#63;.
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 &#63;.
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 = &#63; 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 = &#63;.
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 &#63;.
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 = &#63;.
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 &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63; 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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63; 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 = &#63;.
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 = &#63; and structureId = &#63; 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 = &#63; and structureId = &#63; 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 = &#63; and structureId = &#63; 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 = &#63; and structureId = &#63; 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 = &#63; and structureId = &#63;.
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 = &#63; and parentStructureId = &#63;.
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 = &#63; and parentStructureId = &#63;.
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 = &#63; and parentStructureId = &#63;.
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 = &#63; and parentStructureId = &#63;.
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 = &#63; and parentStructureId = &#63;.
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 = &#63; and parentStructureId = &#63;.
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 = &#63; and parentStructureId = &#63;.
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 = &#63; and parentStructureId = &#63;.
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 = &#63; and parentStructureId = &#63;.
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 = &#63; and parentStructureId = &#63;.
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 = &#63; and parentStructureId = &#63;.
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 = &#63; and parentStructureId = &#63;.
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 = &#63; and parentStructureId = &#63; 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 = &#63; and parentStructureId = &#63;.
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 = &#63; and parentStructureId = &#63;.
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    }