001    /**
002     * Copyright (c) 2000-2010 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.service.ServiceContext;
022    
023    import com.liferay.portlet.journal.model.JournalStructure;
024    
025    import java.util.List;
026    
027    /**
028     * 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.
029     *
030     * <p>
031     * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
032     * </p>
033     *
034     * <p>
035     * Caching information and settings can be found in <code>portal.properties</code>
036     * </p>
037     *
038     * @author Brian Wing Shun Chan
039     * @see JournalStructurePersistence
040     * @see JournalStructurePersistenceImpl
041     * @generated
042     */
043    public class JournalStructureUtil {
044            /**
045             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
046             */
047            public static void clearCache() {
048                    getPersistence().clearCache();
049            }
050    
051            /**
052             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
053             */
054            public static void clearCache(JournalStructure journalStructure) {
055                    getPersistence().clearCache(journalStructure);
056            }
057    
058            /**
059             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
060             */
061            public long countWithDynamicQuery(DynamicQuery dynamicQuery)
062                    throws SystemException {
063                    return getPersistence().countWithDynamicQuery(dynamicQuery);
064            }
065    
066            /**
067             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
068             */
069            public static List<JournalStructure> findWithDynamicQuery(
070                    DynamicQuery dynamicQuery) throws SystemException {
071                    return getPersistence().findWithDynamicQuery(dynamicQuery);
072            }
073    
074            /**
075             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
076             */
077            public static List<JournalStructure> findWithDynamicQuery(
078                    DynamicQuery dynamicQuery, int start, int end)
079                    throws SystemException {
080                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
081            }
082    
083            /**
084             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
085             */
086            public static List<JournalStructure> findWithDynamicQuery(
087                    DynamicQuery dynamicQuery, int start, int end,
088                    OrderByComparator orderByComparator) throws SystemException {
089                    return getPersistence()
090                                       .findWithDynamicQuery(dynamicQuery, start, end,
091                            orderByComparator);
092            }
093    
094            /**
095             * @see com.liferay.portal.service.persistence.BasePersistence#remove(com.liferay.portal.model.BaseModel)
096             */
097            public static JournalStructure remove(JournalStructure journalStructure)
098                    throws SystemException {
099                    return getPersistence().remove(journalStructure);
100            }
101    
102            /**
103             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean)
104             */
105            public static JournalStructure update(JournalStructure journalStructure,
106                    boolean merge) throws SystemException {
107                    return getPersistence().update(journalStructure, merge);
108            }
109    
110            /**
111             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean, ServiceContext)
112             */
113            public static JournalStructure update(JournalStructure journalStructure,
114                    boolean merge, ServiceContext serviceContext) throws SystemException {
115                    return getPersistence().update(journalStructure, merge, serviceContext);
116            }
117    
118            /**
119            * Caches the journal structure in the entity cache if it is enabled.
120            *
121            * @param journalStructure the journal structure to cache
122            */
123            public static void cacheResult(
124                    com.liferay.portlet.journal.model.JournalStructure journalStructure) {
125                    getPersistence().cacheResult(journalStructure);
126            }
127    
128            /**
129            * Caches the journal structures in the entity cache if it is enabled.
130            *
131            * @param journalStructures the journal structures to cache
132            */
133            public static void cacheResult(
134                    java.util.List<com.liferay.portlet.journal.model.JournalStructure> journalStructures) {
135                    getPersistence().cacheResult(journalStructures);
136            }
137    
138            /**
139            * Creates a new journal structure with the primary key. Does not add the journal structure to the database.
140            *
141            * @param id the primary key for the new journal structure
142            * @return the new journal structure
143            */
144            public static com.liferay.portlet.journal.model.JournalStructure create(
145                    long id) {
146                    return getPersistence().create(id);
147            }
148    
149            /**
150            * Removes the journal structure with the primary key from the database. Also notifies the appropriate model listeners.
151            *
152            * @param id the primary key of the journal structure to remove
153            * @return the journal structure that was removed
154            * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found
155            * @throws SystemException if a system exception occurred
156            */
157            public static com.liferay.portlet.journal.model.JournalStructure remove(
158                    long id)
159                    throws com.liferay.portal.kernel.exception.SystemException,
160                            com.liferay.portlet.journal.NoSuchStructureException {
161                    return getPersistence().remove(id);
162            }
163    
164            public static com.liferay.portlet.journal.model.JournalStructure updateImpl(
165                    com.liferay.portlet.journal.model.JournalStructure journalStructure,
166                    boolean merge)
167                    throws com.liferay.portal.kernel.exception.SystemException {
168                    return getPersistence().updateImpl(journalStructure, merge);
169            }
170    
171            /**
172            * Finds the journal structure with the primary key or throws a {@link com.liferay.portlet.journal.NoSuchStructureException} if it could not be found.
173            *
174            * @param id the primary key of the journal structure to find
175            * @return the journal structure
176            * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found
177            * @throws SystemException if a system exception occurred
178            */
179            public static com.liferay.portlet.journal.model.JournalStructure findByPrimaryKey(
180                    long id)
181                    throws com.liferay.portal.kernel.exception.SystemException,
182                            com.liferay.portlet.journal.NoSuchStructureException {
183                    return getPersistence().findByPrimaryKey(id);
184            }
185    
186            /**
187            * Finds the journal structure with the primary key or returns <code>null</code> if it could not be found.
188            *
189            * @param id the primary key of the journal structure to find
190            * @return the journal structure, or <code>null</code> if a journal structure with the primary key could not be found
191            * @throws SystemException if a system exception occurred
192            */
193            public static com.liferay.portlet.journal.model.JournalStructure fetchByPrimaryKey(
194                    long id) throws com.liferay.portal.kernel.exception.SystemException {
195                    return getPersistence().fetchByPrimaryKey(id);
196            }
197    
198            /**
199            * Finds all the journal structures where uuid = &#63;.
200            *
201            * @param uuid the uuid to search with
202            * @return the matching journal structures
203            * @throws SystemException if a system exception occurred
204            */
205            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByUuid(
206                    java.lang.String uuid)
207                    throws com.liferay.portal.kernel.exception.SystemException {
208                    return getPersistence().findByUuid(uuid);
209            }
210    
211            /**
212            * Finds a range of all the journal structures where uuid = &#63;.
213            *
214            * <p>
215            * 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.
216            * </p>
217            *
218            * @param uuid the uuid to search with
219            * @param start the lower bound of the range of journal structures to return
220            * @param end the upper bound of the range of journal structures to return (not inclusive)
221            * @return the range of matching journal structures
222            * @throws SystemException if a system exception occurred
223            */
224            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByUuid(
225                    java.lang.String uuid, int start, int end)
226                    throws com.liferay.portal.kernel.exception.SystemException {
227                    return getPersistence().findByUuid(uuid, start, end);
228            }
229    
230            /**
231            * Finds an ordered range of all the journal structures where uuid = &#63;.
232            *
233            * <p>
234            * 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.
235            * </p>
236            *
237            * @param uuid the uuid to search with
238            * @param start the lower bound of the range of journal structures to return
239            * @param end the upper bound of the range of journal structures to return (not inclusive)
240            * @param orderByComparator the comparator to order the results by
241            * @return the ordered range of matching journal structures
242            * @throws SystemException if a system exception occurred
243            */
244            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByUuid(
245                    java.lang.String uuid, int start, int end,
246                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
247                    throws com.liferay.portal.kernel.exception.SystemException {
248                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
249            }
250    
251            /**
252            * Finds the first journal structure in the ordered set where uuid = &#63;.
253            *
254            * <p>
255            * 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.
256            * </p>
257            *
258            * @param uuid the uuid to search with
259            * @param orderByComparator the comparator to order the set by
260            * @return the first matching journal structure
261            * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found
262            * @throws SystemException if a system exception occurred
263            */
264            public static com.liferay.portlet.journal.model.JournalStructure findByUuid_First(
265                    java.lang.String uuid,
266                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
267                    throws com.liferay.portal.kernel.exception.SystemException,
268                            com.liferay.portlet.journal.NoSuchStructureException {
269                    return getPersistence().findByUuid_First(uuid, orderByComparator);
270            }
271    
272            /**
273            * Finds the last journal structure in the ordered set where uuid = &#63;.
274            *
275            * <p>
276            * 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.
277            * </p>
278            *
279            * @param uuid the uuid to search with
280            * @param orderByComparator the comparator to order the set by
281            * @return the last matching journal structure
282            * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found
283            * @throws SystemException if a system exception occurred
284            */
285            public static com.liferay.portlet.journal.model.JournalStructure findByUuid_Last(
286                    java.lang.String uuid,
287                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
288                    throws com.liferay.portal.kernel.exception.SystemException,
289                            com.liferay.portlet.journal.NoSuchStructureException {
290                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
291            }
292    
293            /**
294            * Finds the journal structures before and after the current journal structure in the ordered set where uuid = &#63;.
295            *
296            * <p>
297            * 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.
298            * </p>
299            *
300            * @param id the primary key of the current journal structure
301            * @param uuid the uuid to search with
302            * @param orderByComparator the comparator to order the set by
303            * @return the previous, current, and next journal structure
304            * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found
305            * @throws SystemException if a system exception occurred
306            */
307            public static com.liferay.portlet.journal.model.JournalStructure[] findByUuid_PrevAndNext(
308                    long id, java.lang.String uuid,
309                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
310                    throws com.liferay.portal.kernel.exception.SystemException,
311                            com.liferay.portlet.journal.NoSuchStructureException {
312                    return getPersistence()
313                                       .findByUuid_PrevAndNext(id, uuid, orderByComparator);
314            }
315    
316            /**
317            * Finds the journal structure where uuid = &#63; and groupId = &#63; or throws a {@link com.liferay.portlet.journal.NoSuchStructureException} if it could not be found.
318            *
319            * @param uuid the uuid to search with
320            * @param groupId the group id to search with
321            * @return the matching journal structure
322            * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found
323            * @throws SystemException if a system exception occurred
324            */
325            public static com.liferay.portlet.journal.model.JournalStructure findByUUID_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().findByUUID_G(uuid, groupId);
330            }
331    
332            /**
333            * Finds the journal structure where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
334            *
335            * @param uuid the uuid to search with
336            * @param groupId the group id to search with
337            * @return the matching journal structure, or <code>null</code> if a matching journal structure could not be found
338            * @throws SystemException if a system exception occurred
339            */
340            public static com.liferay.portlet.journal.model.JournalStructure fetchByUUID_G(
341                    java.lang.String uuid, long groupId)
342                    throws com.liferay.portal.kernel.exception.SystemException {
343                    return getPersistence().fetchByUUID_G(uuid, groupId);
344            }
345    
346            /**
347            * Finds 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.
348            *
349            * @param uuid the uuid to search with
350            * @param groupId the group id to search with
351            * @return the matching journal structure, or <code>null</code> if a matching journal structure could not be found
352            * @throws SystemException if a system exception occurred
353            */
354            public static com.liferay.portlet.journal.model.JournalStructure fetchByUUID_G(
355                    java.lang.String uuid, long groupId, boolean retrieveFromCache)
356                    throws com.liferay.portal.kernel.exception.SystemException {
357                    return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache);
358            }
359    
360            /**
361            * Finds all the journal structures where groupId = &#63;.
362            *
363            * @param groupId the group id to search with
364            * @return the matching journal structures
365            * @throws SystemException if a system exception occurred
366            */
367            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByGroupId(
368                    long groupId)
369                    throws com.liferay.portal.kernel.exception.SystemException {
370                    return getPersistence().findByGroupId(groupId);
371            }
372    
373            /**
374            * Finds a range of all the journal structures where groupId = &#63;.
375            *
376            * <p>
377            * 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.
378            * </p>
379            *
380            * @param groupId the group id to search with
381            * @param start the lower bound of the range of journal structures to return
382            * @param end the upper bound of the range of journal structures to return (not inclusive)
383            * @return the range of matching journal structures
384            * @throws SystemException if a system exception occurred
385            */
386            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByGroupId(
387                    long groupId, int start, int end)
388                    throws com.liferay.portal.kernel.exception.SystemException {
389                    return getPersistence().findByGroupId(groupId, start, end);
390            }
391    
392            /**
393            * Finds an ordered range of all the journal structures where groupId = &#63;.
394            *
395            * <p>
396            * 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.
397            * </p>
398            *
399            * @param groupId the group id to search with
400            * @param start the lower bound of the range of journal structures to return
401            * @param end the upper bound of the range of journal structures to return (not inclusive)
402            * @param orderByComparator the comparator to order the results by
403            * @return the ordered range of matching journal structures
404            * @throws SystemException if a system exception occurred
405            */
406            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByGroupId(
407                    long groupId, int start, int end,
408                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
409                    throws com.liferay.portal.kernel.exception.SystemException {
410                    return getPersistence()
411                                       .findByGroupId(groupId, start, end, orderByComparator);
412            }
413    
414            /**
415            * Finds the first journal structure in the ordered set where groupId = &#63;.
416            *
417            * <p>
418            * 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.
419            * </p>
420            *
421            * @param groupId the group id to search with
422            * @param orderByComparator the comparator to order the set by
423            * @return the first matching journal structure
424            * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found
425            * @throws SystemException if a system exception occurred
426            */
427            public static com.liferay.portlet.journal.model.JournalStructure findByGroupId_First(
428                    long groupId,
429                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
430                    throws com.liferay.portal.kernel.exception.SystemException,
431                            com.liferay.portlet.journal.NoSuchStructureException {
432                    return getPersistence().findByGroupId_First(groupId, orderByComparator);
433            }
434    
435            /**
436            * Finds the last journal structure in the ordered set where groupId = &#63;.
437            *
438            * <p>
439            * 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.
440            * </p>
441            *
442            * @param groupId the group id to search with
443            * @param orderByComparator the comparator to order the set by
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 findByGroupId_Last(
449                    long groupId,
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().findByGroupId_Last(groupId, orderByComparator);
454            }
455    
456            /**
457            * Finds the journal structures before and after the current journal structure in the ordered set where groupId = &#63;.
458            *
459            * <p>
460            * 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.
461            * </p>
462            *
463            * @param id the primary key of the current journal structure
464            * @param groupId the group id to search with
465            * @param orderByComparator the comparator to order the set by
466            * @return the previous, current, and next journal structure
467            * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found
468            * @throws SystemException if a system exception occurred
469            */
470            public static com.liferay.portlet.journal.model.JournalStructure[] findByGroupId_PrevAndNext(
471                    long id, long groupId,
472                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
473                    throws com.liferay.portal.kernel.exception.SystemException,
474                            com.liferay.portlet.journal.NoSuchStructureException {
475                    return getPersistence()
476                                       .findByGroupId_PrevAndNext(id, groupId, orderByComparator);
477            }
478    
479            /**
480            * Filters by the user's permissions and finds all the journal structures where groupId = &#63;.
481            *
482            * @param groupId the group id to search with
483            * @return the matching journal structures that the user has permission to view
484            * @throws SystemException if a system exception occurred
485            */
486            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByGroupId(
487                    long groupId)
488                    throws com.liferay.portal.kernel.exception.SystemException {
489                    return getPersistence().filterFindByGroupId(groupId);
490            }
491    
492            /**
493            * Filters by the user's permissions and finds a range of all the journal structures where groupId = &#63;.
494            *
495            * <p>
496            * 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.
497            * </p>
498            *
499            * @param groupId the group id to search with
500            * @param start the lower bound of the range of journal structures to return
501            * @param end the upper bound of the range of journal structures to return (not inclusive)
502            * @return the range of matching journal structures that the user has permission to view
503            * @throws SystemException if a system exception occurred
504            */
505            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByGroupId(
506                    long groupId, int start, int end)
507                    throws com.liferay.portal.kernel.exception.SystemException {
508                    return getPersistence().filterFindByGroupId(groupId, start, end);
509            }
510    
511            /**
512            * Filters by the user's permissions and finds an ordered range of all the journal structures where groupId = &#63;.
513            *
514            * <p>
515            * 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.
516            * </p>
517            *
518            * @param groupId the group id to search with
519            * @param start the lower bound of the range of journal structures to return
520            * @param end the upper bound of the range of journal structures to return (not inclusive)
521            * @param orderByComparator the comparator to order the results by
522            * @return the ordered range of matching journal structures that the user has permission to view
523            * @throws SystemException if a system exception occurred
524            */
525            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByGroupId(
526                    long groupId, int start, int end,
527                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
528                    throws com.liferay.portal.kernel.exception.SystemException {
529                    return getPersistence()
530                                       .filterFindByGroupId(groupId, start, end, orderByComparator);
531            }
532    
533            /**
534            * Finds all the journal structures where structureId = &#63;.
535            *
536            * @param structureId the structure id to search with
537            * @return the matching journal structures
538            * @throws SystemException if a system exception occurred
539            */
540            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByStructureId(
541                    java.lang.String structureId)
542                    throws com.liferay.portal.kernel.exception.SystemException {
543                    return getPersistence().findByStructureId(structureId);
544            }
545    
546            /**
547            * Finds a range of all the journal structures where structureId = &#63;.
548            *
549            * <p>
550            * 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.
551            * </p>
552            *
553            * @param structureId the structure id to search with
554            * @param start the lower bound of the range of journal structures to return
555            * @param end the upper bound of the range of journal structures to return (not inclusive)
556            * @return the range of matching journal structures
557            * @throws SystemException if a system exception occurred
558            */
559            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByStructureId(
560                    java.lang.String structureId, int start, int end)
561                    throws com.liferay.portal.kernel.exception.SystemException {
562                    return getPersistence().findByStructureId(structureId, start, end);
563            }
564    
565            /**
566            * Finds an ordered range of all the journal structures where structureId = &#63;.
567            *
568            * <p>
569            * 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.
570            * </p>
571            *
572            * @param structureId the structure id to search with
573            * @param start the lower bound of the range of journal structures to return
574            * @param end the upper bound of the range of journal structures to return (not inclusive)
575            * @param orderByComparator the comparator to order the results by
576            * @return the ordered range of matching journal structures
577            * @throws SystemException if a system exception occurred
578            */
579            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByStructureId(
580                    java.lang.String structureId, int start, int end,
581                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
582                    throws com.liferay.portal.kernel.exception.SystemException {
583                    return getPersistence()
584                                       .findByStructureId(structureId, start, end, orderByComparator);
585            }
586    
587            /**
588            * Finds the first journal structure in the ordered set where structureId = &#63;.
589            *
590            * <p>
591            * 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.
592            * </p>
593            *
594            * @param structureId the structure id to search with
595            * @param orderByComparator the comparator to order the set by
596            * @return the first matching journal structure
597            * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found
598            * @throws SystemException if a system exception occurred
599            */
600            public static com.liferay.portlet.journal.model.JournalStructure findByStructureId_First(
601                    java.lang.String structureId,
602                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
603                    throws com.liferay.portal.kernel.exception.SystemException,
604                            com.liferay.portlet.journal.NoSuchStructureException {
605                    return getPersistence()
606                                       .findByStructureId_First(structureId, orderByComparator);
607            }
608    
609            /**
610            * Finds the last journal structure in the ordered set where structureId = &#63;.
611            *
612            * <p>
613            * 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.
614            * </p>
615            *
616            * @param structureId the structure id to search with
617            * @param orderByComparator the comparator to order the set by
618            * @return the last matching journal structure
619            * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found
620            * @throws SystemException if a system exception occurred
621            */
622            public static com.liferay.portlet.journal.model.JournalStructure findByStructureId_Last(
623                    java.lang.String structureId,
624                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
625                    throws com.liferay.portal.kernel.exception.SystemException,
626                            com.liferay.portlet.journal.NoSuchStructureException {
627                    return getPersistence()
628                                       .findByStructureId_Last(structureId, orderByComparator);
629            }
630    
631            /**
632            * Finds the journal structures before and after the current journal structure in the ordered set where structureId = &#63;.
633            *
634            * <p>
635            * 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.
636            * </p>
637            *
638            * @param id the primary key of the current journal structure
639            * @param structureId the structure id to search with
640            * @param orderByComparator the comparator to order the set by
641            * @return the previous, current, and next journal structure
642            * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found
643            * @throws SystemException if a system exception occurred
644            */
645            public static com.liferay.portlet.journal.model.JournalStructure[] findByStructureId_PrevAndNext(
646                    long id, java.lang.String structureId,
647                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
648                    throws com.liferay.portal.kernel.exception.SystemException,
649                            com.liferay.portlet.journal.NoSuchStructureException {
650                    return getPersistence()
651                                       .findByStructureId_PrevAndNext(id, structureId,
652                            orderByComparator);
653            }
654    
655            /**
656            * Finds the journal structure where groupId = &#63; and structureId = &#63; or throws a {@link com.liferay.portlet.journal.NoSuchStructureException} if it could not be found.
657            *
658            * @param groupId the group id to search with
659            * @param structureId the structure id to search with
660            * @return the matching journal structure
661            * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found
662            * @throws SystemException if a system exception occurred
663            */
664            public static com.liferay.portlet.journal.model.JournalStructure findByG_S(
665                    long groupId, java.lang.String structureId)
666                    throws com.liferay.portal.kernel.exception.SystemException,
667                            com.liferay.portlet.journal.NoSuchStructureException {
668                    return getPersistence().findByG_S(groupId, structureId);
669            }
670    
671            /**
672            * Finds the journal structure where groupId = &#63; and structureId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
673            *
674            * @param groupId the group id to search with
675            * @param structureId the structure id to search with
676            * @return the matching journal structure, or <code>null</code> if a matching journal structure could not be found
677            * @throws SystemException if a system exception occurred
678            */
679            public static com.liferay.portlet.journal.model.JournalStructure fetchByG_S(
680                    long groupId, java.lang.String structureId)
681                    throws com.liferay.portal.kernel.exception.SystemException {
682                    return getPersistence().fetchByG_S(groupId, structureId);
683            }
684    
685            /**
686            * Finds 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.
687            *
688            * @param groupId the group id to search with
689            * @param structureId the structure id to search with
690            * @return the matching journal structure, or <code>null</code> if a matching journal structure could not be found
691            * @throws SystemException if a system exception occurred
692            */
693            public static com.liferay.portlet.journal.model.JournalStructure fetchByG_S(
694                    long groupId, java.lang.String structureId, boolean retrieveFromCache)
695                    throws com.liferay.portal.kernel.exception.SystemException {
696                    return getPersistence()
697                                       .fetchByG_S(groupId, structureId, retrieveFromCache);
698            }
699    
700            /**
701            * Finds all the journal structures where groupId = &#63; and parentStructureId = &#63;.
702            *
703            * @param groupId the group id to search with
704            * @param parentStructureId the parent structure id to search with
705            * @return the matching journal structures
706            * @throws SystemException if a system exception occurred
707            */
708            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByG_P(
709                    long groupId, java.lang.String parentStructureId)
710                    throws com.liferay.portal.kernel.exception.SystemException {
711                    return getPersistence().findByG_P(groupId, parentStructureId);
712            }
713    
714            /**
715            * Finds a range of all the journal structures where groupId = &#63; and parentStructureId = &#63;.
716            *
717            * <p>
718            * 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.
719            * </p>
720            *
721            * @param groupId the group id to search with
722            * @param parentStructureId the parent structure id to search with
723            * @param start the lower bound of the range of journal structures to return
724            * @param end the upper bound of the range of journal structures to return (not inclusive)
725            * @return the range of matching journal structures
726            * @throws SystemException if a system exception occurred
727            */
728            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByG_P(
729                    long groupId, java.lang.String parentStructureId, int start, int end)
730                    throws com.liferay.portal.kernel.exception.SystemException {
731                    return getPersistence().findByG_P(groupId, parentStructureId, start, end);
732            }
733    
734            /**
735            * Finds an ordered range of all the journal structures where groupId = &#63; and parentStructureId = &#63;.
736            *
737            * <p>
738            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
739            * </p>
740            *
741            * @param groupId the group id to search with
742            * @param parentStructureId the parent structure id to search with
743            * @param start the lower bound of the range of journal structures to return
744            * @param end the upper bound of the range of journal structures to return (not inclusive)
745            * @param orderByComparator the comparator to order the results by
746            * @return the ordered range of matching journal structures
747            * @throws SystemException if a system exception occurred
748            */
749            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByG_P(
750                    long groupId, java.lang.String parentStructureId, int start, int end,
751                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
752                    throws com.liferay.portal.kernel.exception.SystemException {
753                    return getPersistence()
754                                       .findByG_P(groupId, parentStructureId, start, end,
755                            orderByComparator);
756            }
757    
758            /**
759            * Finds the first journal structure in the ordered set where groupId = &#63; and parentStructureId = &#63;.
760            *
761            * <p>
762            * 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.
763            * </p>
764            *
765            * @param groupId the group id to search with
766            * @param parentStructureId the parent structure id to search with
767            * @param orderByComparator the comparator to order the set by
768            * @return the first matching journal structure
769            * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found
770            * @throws SystemException if a system exception occurred
771            */
772            public static com.liferay.portlet.journal.model.JournalStructure findByG_P_First(
773                    long groupId, java.lang.String parentStructureId,
774                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
775                    throws com.liferay.portal.kernel.exception.SystemException,
776                            com.liferay.portlet.journal.NoSuchStructureException {
777                    return getPersistence()
778                                       .findByG_P_First(groupId, parentStructureId,
779                            orderByComparator);
780            }
781    
782            /**
783            * Finds the last journal structure in the ordered set where groupId = &#63; and parentStructureId = &#63;.
784            *
785            * <p>
786            * 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.
787            * </p>
788            *
789            * @param groupId the group id to search with
790            * @param parentStructureId the parent structure id to search with
791            * @param orderByComparator the comparator to order the set by
792            * @return the last matching journal structure
793            * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found
794            * @throws SystemException if a system exception occurred
795            */
796            public static com.liferay.portlet.journal.model.JournalStructure findByG_P_Last(
797                    long groupId, java.lang.String parentStructureId,
798                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
799                    throws com.liferay.portal.kernel.exception.SystemException,
800                            com.liferay.portlet.journal.NoSuchStructureException {
801                    return getPersistence()
802                                       .findByG_P_Last(groupId, parentStructureId, orderByComparator);
803            }
804    
805            /**
806            * Finds the journal structures before and after the current journal structure in the ordered set where groupId = &#63; and parentStructureId = &#63;.
807            *
808            * <p>
809            * 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.
810            * </p>
811            *
812            * @param id the primary key of the current journal structure
813            * @param groupId the group id to search with
814            * @param parentStructureId the parent structure id to search with
815            * @param orderByComparator the comparator to order the set by
816            * @return the previous, current, and next journal structure
817            * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found
818            * @throws SystemException if a system exception occurred
819            */
820            public static com.liferay.portlet.journal.model.JournalStructure[] findByG_P_PrevAndNext(
821                    long id, long groupId, java.lang.String parentStructureId,
822                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
823                    throws com.liferay.portal.kernel.exception.SystemException,
824                            com.liferay.portlet.journal.NoSuchStructureException {
825                    return getPersistence()
826                                       .findByG_P_PrevAndNext(id, groupId, parentStructureId,
827                            orderByComparator);
828            }
829    
830            /**
831            * Filters by the user's permissions and finds all the journal structures where groupId = &#63; and parentStructureId = &#63;.
832            *
833            * @param groupId the group id to search with
834            * @param parentStructureId the parent structure id to search with
835            * @return the matching journal structures that the user has permission to view
836            * @throws SystemException if a system exception occurred
837            */
838            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByG_P(
839                    long groupId, java.lang.String parentStructureId)
840                    throws com.liferay.portal.kernel.exception.SystemException {
841                    return getPersistence().filterFindByG_P(groupId, parentStructureId);
842            }
843    
844            /**
845            * Filters by the user's permissions and finds a range of all the journal structures where groupId = &#63; and parentStructureId = &#63;.
846            *
847            * <p>
848            * 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.
849            * </p>
850            *
851            * @param groupId the group id to search with
852            * @param parentStructureId the parent structure id to search with
853            * @param start the lower bound of the range of journal structures to return
854            * @param end the upper bound of the range of journal structures to return (not inclusive)
855            * @return the range of matching journal structures that the user has permission to view
856            * @throws SystemException if a system exception occurred
857            */
858            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByG_P(
859                    long groupId, java.lang.String parentStructureId, int start, int end)
860                    throws com.liferay.portal.kernel.exception.SystemException {
861                    return getPersistence()
862                                       .filterFindByG_P(groupId, parentStructureId, start, end);
863            }
864    
865            /**
866            * Filters by the user's permissions and finds an ordered range of all the journal structures where groupId = &#63; and parentStructureId = &#63;.
867            *
868            * <p>
869            * 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.
870            * </p>
871            *
872            * @param groupId the group id to search with
873            * @param parentStructureId the parent structure id to search with
874            * @param start the lower bound of the range of journal structures to return
875            * @param end the upper bound of the range of journal structures to return (not inclusive)
876            * @param orderByComparator the comparator to order the results by
877            * @return the ordered range of matching journal structures that the user has permission to view
878            * @throws SystemException if a system exception occurred
879            */
880            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByG_P(
881                    long groupId, java.lang.String parentStructureId, int start, int end,
882                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
883                    throws com.liferay.portal.kernel.exception.SystemException {
884                    return getPersistence()
885                                       .filterFindByG_P(groupId, parentStructureId, start, end,
886                            orderByComparator);
887            }
888    
889            /**
890            * Finds all the journal structures.
891            *
892            * @return the journal structures
893            * @throws SystemException if a system exception occurred
894            */
895            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findAll()
896                    throws com.liferay.portal.kernel.exception.SystemException {
897                    return getPersistence().findAll();
898            }
899    
900            /**
901            * Finds a range of all the journal structures.
902            *
903            * <p>
904            * 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.
905            * </p>
906            *
907            * @param start the lower bound of the range of journal structures to return
908            * @param end the upper bound of the range of journal structures to return (not inclusive)
909            * @return the range of journal structures
910            * @throws SystemException if a system exception occurred
911            */
912            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findAll(
913                    int start, int end)
914                    throws com.liferay.portal.kernel.exception.SystemException {
915                    return getPersistence().findAll(start, end);
916            }
917    
918            /**
919            * Finds an ordered range of all the journal structures.
920            *
921            * <p>
922            * 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.
923            * </p>
924            *
925            * @param start the lower bound of the range of journal structures to return
926            * @param end the upper bound of the range of journal structures to return (not inclusive)
927            * @param orderByComparator the comparator to order the results by
928            * @return the ordered range of journal structures
929            * @throws SystemException if a system exception occurred
930            */
931            public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findAll(
932                    int start, int end,
933                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
934                    throws com.liferay.portal.kernel.exception.SystemException {
935                    return getPersistence().findAll(start, end, orderByComparator);
936            }
937    
938            /**
939            * Removes all the journal structures where uuid = &#63; from the database.
940            *
941            * @param uuid the uuid to search with
942            * @throws SystemException if a system exception occurred
943            */
944            public static void removeByUuid(java.lang.String uuid)
945                    throws com.liferay.portal.kernel.exception.SystemException {
946                    getPersistence().removeByUuid(uuid);
947            }
948    
949            /**
950            * Removes the journal structure where uuid = &#63; and groupId = &#63; from the database.
951            *
952            * @param uuid the uuid to search with
953            * @param groupId the group id to search with
954            * @throws SystemException if a system exception occurred
955            */
956            public static void removeByUUID_G(java.lang.String uuid, long groupId)
957                    throws com.liferay.portal.kernel.exception.SystemException,
958                            com.liferay.portlet.journal.NoSuchStructureException {
959                    getPersistence().removeByUUID_G(uuid, groupId);
960            }
961    
962            /**
963            * Removes all the journal structures where groupId = &#63; from the database.
964            *
965            * @param groupId the group id to search with
966            * @throws SystemException if a system exception occurred
967            */
968            public static void removeByGroupId(long groupId)
969                    throws com.liferay.portal.kernel.exception.SystemException {
970                    getPersistence().removeByGroupId(groupId);
971            }
972    
973            /**
974            * Removes all the journal structures where structureId = &#63; from the database.
975            *
976            * @param structureId the structure id to search with
977            * @throws SystemException if a system exception occurred
978            */
979            public static void removeByStructureId(java.lang.String structureId)
980                    throws com.liferay.portal.kernel.exception.SystemException {
981                    getPersistence().removeByStructureId(structureId);
982            }
983    
984            /**
985            * Removes the journal structure where groupId = &#63; and structureId = &#63; from the database.
986            *
987            * @param groupId the group id to search with
988            * @param structureId the structure id to search with
989            * @throws SystemException if a system exception occurred
990            */
991            public static void removeByG_S(long groupId, java.lang.String structureId)
992                    throws com.liferay.portal.kernel.exception.SystemException,
993                            com.liferay.portlet.journal.NoSuchStructureException {
994                    getPersistence().removeByG_S(groupId, structureId);
995            }
996    
997            /**
998            * Removes all the journal structures where groupId = &#63; and parentStructureId = &#63; from the database.
999            *
1000            * @param groupId the group id to search with
1001            * @param parentStructureId the parent structure id to search with
1002            * @throws SystemException if a system exception occurred
1003            */
1004            public static void removeByG_P(long groupId,
1005                    java.lang.String parentStructureId)
1006                    throws com.liferay.portal.kernel.exception.SystemException {
1007                    getPersistence().removeByG_P(groupId, parentStructureId);
1008            }
1009    
1010            /**
1011            * Removes all the journal structures from the database.
1012            *
1013            * @throws SystemException if a system exception occurred
1014            */
1015            public static void removeAll()
1016                    throws com.liferay.portal.kernel.exception.SystemException {
1017                    getPersistence().removeAll();
1018            }
1019    
1020            /**
1021            * Counts all the journal structures where uuid = &#63;.
1022            *
1023            * @param uuid the uuid to search with
1024            * @return the number of matching journal structures
1025            * @throws SystemException if a system exception occurred
1026            */
1027            public static int countByUuid(java.lang.String uuid)
1028                    throws com.liferay.portal.kernel.exception.SystemException {
1029                    return getPersistence().countByUuid(uuid);
1030            }
1031    
1032            /**
1033            * Counts all the journal structures where uuid = &#63; and groupId = &#63;.
1034            *
1035            * @param uuid the uuid to search with
1036            * @param groupId the group id to search with
1037            * @return the number of matching journal structures
1038            * @throws SystemException if a system exception occurred
1039            */
1040            public static int countByUUID_G(java.lang.String uuid, long groupId)
1041                    throws com.liferay.portal.kernel.exception.SystemException {
1042                    return getPersistence().countByUUID_G(uuid, groupId);
1043            }
1044    
1045            /**
1046            * Counts all the journal structures where groupId = &#63;.
1047            *
1048            * @param groupId the group id to search with
1049            * @return the number of matching journal structures
1050            * @throws SystemException if a system exception occurred
1051            */
1052            public static int countByGroupId(long groupId)
1053                    throws com.liferay.portal.kernel.exception.SystemException {
1054                    return getPersistence().countByGroupId(groupId);
1055            }
1056    
1057            /**
1058            * Filters by the user's permissions and counts all the journal structures where groupId = &#63;.
1059            *
1060            * @param groupId the group id to search with
1061            * @return the number of matching journal structures that the user has permission to view
1062            * @throws SystemException if a system exception occurred
1063            */
1064            public static int filterCountByGroupId(long groupId)
1065                    throws com.liferay.portal.kernel.exception.SystemException {
1066                    return getPersistence().filterCountByGroupId(groupId);
1067            }
1068    
1069            /**
1070            * Counts all the journal structures where structureId = &#63;.
1071            *
1072            * @param structureId the structure id to search with
1073            * @return the number of matching journal structures
1074            * @throws SystemException if a system exception occurred
1075            */
1076            public static int countByStructureId(java.lang.String structureId)
1077                    throws com.liferay.portal.kernel.exception.SystemException {
1078                    return getPersistence().countByStructureId(structureId);
1079            }
1080    
1081            /**
1082            * Counts all the journal structures where groupId = &#63; and structureId = &#63;.
1083            *
1084            * @param groupId the group id to search with
1085            * @param structureId the structure id to search with
1086            * @return the number of matching journal structures
1087            * @throws SystemException if a system exception occurred
1088            */
1089            public static int countByG_S(long groupId, java.lang.String structureId)
1090                    throws com.liferay.portal.kernel.exception.SystemException {
1091                    return getPersistence().countByG_S(groupId, structureId);
1092            }
1093    
1094            /**
1095            * Filters by the user's permissions and counts all the journal structures where groupId = &#63; and structureId = &#63;.
1096            *
1097            * @param groupId the group id to search with
1098            * @param structureId the structure id to search with
1099            * @return the number of matching journal structures that the user has permission to view
1100            * @throws SystemException if a system exception occurred
1101            */
1102            public static int filterCountByG_S(long groupId,
1103                    java.lang.String structureId)
1104                    throws com.liferay.portal.kernel.exception.SystemException {
1105                    return getPersistence().filterCountByG_S(groupId, structureId);
1106            }
1107    
1108            /**
1109            * Counts all the journal structures where groupId = &#63; and parentStructureId = &#63;.
1110            *
1111            * @param groupId the group id to search with
1112            * @param parentStructureId the parent structure id to search with
1113            * @return the number of matching journal structures
1114            * @throws SystemException if a system exception occurred
1115            */
1116            public static int countByG_P(long groupId,
1117                    java.lang.String parentStructureId)
1118                    throws com.liferay.portal.kernel.exception.SystemException {
1119                    return getPersistence().countByG_P(groupId, parentStructureId);
1120            }
1121    
1122            /**
1123            * Filters by the user's permissions and counts all the journal structures where groupId = &#63; and parentStructureId = &#63;.
1124            *
1125            * @param groupId the group id to search with
1126            * @param parentStructureId the parent structure id to search with
1127            * @return the number of matching journal structures that the user has permission to view
1128            * @throws SystemException if a system exception occurred
1129            */
1130            public static int filterCountByG_P(long groupId,
1131                    java.lang.String parentStructureId)
1132                    throws com.liferay.portal.kernel.exception.SystemException {
1133                    return getPersistence().filterCountByG_P(groupId, parentStructureId);
1134            }
1135    
1136            /**
1137            * Counts all the journal structures.
1138            *
1139            * @return the number of journal structures
1140            * @throws SystemException if a system exception occurred
1141            */
1142            public static int countAll()
1143                    throws com.liferay.portal.kernel.exception.SystemException {
1144                    return getPersistence().countAll();
1145            }
1146    
1147            public static JournalStructurePersistence getPersistence() {
1148                    if (_persistence == null) {
1149                            _persistence = (JournalStructurePersistence)PortalBeanLocatorUtil.locate(JournalStructurePersistence.class.getName());
1150                    }
1151    
1152                    return _persistence;
1153            }
1154    
1155            public void setPersistence(JournalStructurePersistence persistence) {
1156                    _persistence = persistence;
1157            }
1158    
1159            private static JournalStructurePersistence _persistence;
1160    }