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