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.User;
024    import com.liferay.portal.service.ServiceContext;
025    
026    import java.util.List;
027    
028    /**
029     * The persistence utility for the user service. This utility wraps {@link com.liferay.portal.service.persistence.impl.UserPersistenceImpl} 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 UserPersistence
037     * @see com.liferay.portal.service.persistence.impl.UserPersistenceImpl
038     * @generated
039     */
040    @ProviderType
041    public class UserUtil {
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(User user) {
059                    getPersistence().clearCache(user);
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<User> 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<User> findWithDynamicQuery(DynamicQuery dynamicQuery,
080                    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<User> findWithDynamicQuery(DynamicQuery dynamicQuery,
088                    int start, int end, OrderByComparator<User> orderByComparator) {
089                    return getPersistence()
090                                       .findWithDynamicQuery(dynamicQuery, start, end,
091                            orderByComparator);
092            }
093    
094            /**
095             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel)
096             */
097            public static User update(User user) {
098                    return getPersistence().update(user);
099            }
100    
101            /**
102             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
103             */
104            public static User update(User user, ServiceContext serviceContext) {
105                    return getPersistence().update(user, serviceContext);
106            }
107    
108            /**
109            * Returns all the users where uuid = &#63;.
110            *
111            * @param uuid the uuid
112            * @return the matching users
113            */
114            public static List<User> findByUuid(java.lang.String uuid) {
115                    return getPersistence().findByUuid(uuid);
116            }
117    
118            /**
119            * Returns a range of all the users where uuid = &#63;.
120            *
121            * <p>
122            * 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 UserModelImpl}. 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.
123            * </p>
124            *
125            * @param uuid the uuid
126            * @param start the lower bound of the range of users
127            * @param end the upper bound of the range of users (not inclusive)
128            * @return the range of matching users
129            */
130            public static List<User> findByUuid(java.lang.String uuid, int start,
131                    int end) {
132                    return getPersistence().findByUuid(uuid, start, end);
133            }
134    
135            /**
136            * Returns an ordered range of all the users where uuid = &#63;.
137            *
138            * <p>
139            * 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 UserModelImpl}. 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.
140            * </p>
141            *
142            * @param uuid the uuid
143            * @param start the lower bound of the range of users
144            * @param end the upper bound of the range of users (not inclusive)
145            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
146            * @return the ordered range of matching users
147            */
148            public static List<User> findByUuid(java.lang.String uuid, int start,
149                    int end, OrderByComparator<User> orderByComparator) {
150                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
151            }
152    
153            /**
154            * Returns an ordered range of all the users where uuid = &#63;.
155            *
156            * <p>
157            * 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 UserModelImpl}. 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.
158            * </p>
159            *
160            * @param uuid the uuid
161            * @param start the lower bound of the range of users
162            * @param end the upper bound of the range of users (not inclusive)
163            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
164            * @param retrieveFromCache whether to retrieve from the finder cache
165            * @return the ordered range of matching users
166            */
167            public static List<User> findByUuid(java.lang.String uuid, int start,
168                    int end, OrderByComparator<User> orderByComparator,
169                    boolean retrieveFromCache) {
170                    return getPersistence()
171                                       .findByUuid(uuid, start, end, orderByComparator,
172                            retrieveFromCache);
173            }
174    
175            /**
176            * Returns the first user in the ordered set where uuid = &#63;.
177            *
178            * @param uuid the uuid
179            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
180            * @return the first matching user
181            * @throws NoSuchUserException if a matching user could not be found
182            */
183            public static User findByUuid_First(java.lang.String uuid,
184                    OrderByComparator<User> orderByComparator)
185                    throws com.liferay.portal.exception.NoSuchUserException {
186                    return getPersistence().findByUuid_First(uuid, orderByComparator);
187            }
188    
189            /**
190            * Returns the first user in the ordered set where uuid = &#63;.
191            *
192            * @param uuid the uuid
193            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
194            * @return the first matching user, or <code>null</code> if a matching user could not be found
195            */
196            public static User fetchByUuid_First(java.lang.String uuid,
197                    OrderByComparator<User> orderByComparator) {
198                    return getPersistence().fetchByUuid_First(uuid, orderByComparator);
199            }
200    
201            /**
202            * Returns the last user in the ordered set where uuid = &#63;.
203            *
204            * @param uuid the uuid
205            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
206            * @return the last matching user
207            * @throws NoSuchUserException if a matching user could not be found
208            */
209            public static User findByUuid_Last(java.lang.String uuid,
210                    OrderByComparator<User> orderByComparator)
211                    throws com.liferay.portal.exception.NoSuchUserException {
212                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
213            }
214    
215            /**
216            * Returns the last user in the ordered set where uuid = &#63;.
217            *
218            * @param uuid the uuid
219            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
220            * @return the last matching user, or <code>null</code> if a matching user could not be found
221            */
222            public static User fetchByUuid_Last(java.lang.String uuid,
223                    OrderByComparator<User> orderByComparator) {
224                    return getPersistence().fetchByUuid_Last(uuid, orderByComparator);
225            }
226    
227            /**
228            * Returns the users before and after the current user in the ordered set where uuid = &#63;.
229            *
230            * @param userId the primary key of the current user
231            * @param uuid the uuid
232            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
233            * @return the previous, current, and next user
234            * @throws NoSuchUserException if a user with the primary key could not be found
235            */
236            public static User[] findByUuid_PrevAndNext(long userId,
237                    java.lang.String uuid, OrderByComparator<User> orderByComparator)
238                    throws com.liferay.portal.exception.NoSuchUserException {
239                    return getPersistence()
240                                       .findByUuid_PrevAndNext(userId, uuid, orderByComparator);
241            }
242    
243            /**
244            * Removes all the users where uuid = &#63; from the database.
245            *
246            * @param uuid the uuid
247            */
248            public static void removeByUuid(java.lang.String uuid) {
249                    getPersistence().removeByUuid(uuid);
250            }
251    
252            /**
253            * Returns the number of users where uuid = &#63;.
254            *
255            * @param uuid the uuid
256            * @return the number of matching users
257            */
258            public static int countByUuid(java.lang.String uuid) {
259                    return getPersistence().countByUuid(uuid);
260            }
261    
262            /**
263            * Returns all the users where uuid = &#63; and companyId = &#63;.
264            *
265            * @param uuid the uuid
266            * @param companyId the company ID
267            * @return the matching users
268            */
269            public static List<User> findByUuid_C(java.lang.String uuid, long companyId) {
270                    return getPersistence().findByUuid_C(uuid, companyId);
271            }
272    
273            /**
274            * Returns a range of all the users where uuid = &#63; and companyId = &#63;.
275            *
276            * <p>
277            * 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 UserModelImpl}. 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.
278            * </p>
279            *
280            * @param uuid the uuid
281            * @param companyId the company ID
282            * @param start the lower bound of the range of users
283            * @param end the upper bound of the range of users (not inclusive)
284            * @return the range of matching users
285            */
286            public static List<User> findByUuid_C(java.lang.String uuid,
287                    long companyId, int start, int end) {
288                    return getPersistence().findByUuid_C(uuid, companyId, start, end);
289            }
290    
291            /**
292            * Returns an ordered range of all the users where uuid = &#63; and companyId = &#63;.
293            *
294            * <p>
295            * 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 UserModelImpl}. 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.
296            * </p>
297            *
298            * @param uuid the uuid
299            * @param companyId the company ID
300            * @param start the lower bound of the range of users
301            * @param end the upper bound of the range of users (not inclusive)
302            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
303            * @return the ordered range of matching users
304            */
305            public static List<User> findByUuid_C(java.lang.String uuid,
306                    long companyId, int start, int end,
307                    OrderByComparator<User> orderByComparator) {
308                    return getPersistence()
309                                       .findByUuid_C(uuid, companyId, start, end, orderByComparator);
310            }
311    
312            /**
313            * Returns an ordered range of all the users where uuid = &#63; and companyId = &#63;.
314            *
315            * <p>
316            * 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 UserModelImpl}. 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.
317            * </p>
318            *
319            * @param uuid the uuid
320            * @param companyId the company ID
321            * @param start the lower bound of the range of users
322            * @param end the upper bound of the range of users (not inclusive)
323            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
324            * @param retrieveFromCache whether to retrieve from the finder cache
325            * @return the ordered range of matching users
326            */
327            public static List<User> findByUuid_C(java.lang.String uuid,
328                    long companyId, int start, int end,
329                    OrderByComparator<User> orderByComparator, boolean retrieveFromCache) {
330                    return getPersistence()
331                                       .findByUuid_C(uuid, companyId, start, end,
332                            orderByComparator, retrieveFromCache);
333            }
334    
335            /**
336            * Returns the first user in the ordered set where uuid = &#63; and companyId = &#63;.
337            *
338            * @param uuid the uuid
339            * @param companyId the company ID
340            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
341            * @return the first matching user
342            * @throws NoSuchUserException if a matching user could not be found
343            */
344            public static User findByUuid_C_First(java.lang.String uuid,
345                    long companyId, OrderByComparator<User> orderByComparator)
346                    throws com.liferay.portal.exception.NoSuchUserException {
347                    return getPersistence()
348                                       .findByUuid_C_First(uuid, companyId, orderByComparator);
349            }
350    
351            /**
352            * Returns the first user in the ordered set where uuid = &#63; and companyId = &#63;.
353            *
354            * @param uuid the uuid
355            * @param companyId the company ID
356            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
357            * @return the first matching user, or <code>null</code> if a matching user could not be found
358            */
359            public static User fetchByUuid_C_First(java.lang.String uuid,
360                    long companyId, OrderByComparator<User> orderByComparator) {
361                    return getPersistence()
362                                       .fetchByUuid_C_First(uuid, companyId, orderByComparator);
363            }
364    
365            /**
366            * Returns the last user in the ordered set where uuid = &#63; and companyId = &#63;.
367            *
368            * @param uuid the uuid
369            * @param companyId the company ID
370            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
371            * @return the last matching user
372            * @throws NoSuchUserException if a matching user could not be found
373            */
374            public static User findByUuid_C_Last(java.lang.String uuid, long companyId,
375                    OrderByComparator<User> orderByComparator)
376                    throws com.liferay.portal.exception.NoSuchUserException {
377                    return getPersistence()
378                                       .findByUuid_C_Last(uuid, companyId, orderByComparator);
379            }
380    
381            /**
382            * Returns the last user in the ordered set where uuid = &#63; and companyId = &#63;.
383            *
384            * @param uuid the uuid
385            * @param companyId the company ID
386            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
387            * @return the last matching user, or <code>null</code> if a matching user could not be found
388            */
389            public static User fetchByUuid_C_Last(java.lang.String uuid,
390                    long companyId, OrderByComparator<User> orderByComparator) {
391                    return getPersistence()
392                                       .fetchByUuid_C_Last(uuid, companyId, orderByComparator);
393            }
394    
395            /**
396            * Returns the users before and after the current user in the ordered set where uuid = &#63; and companyId = &#63;.
397            *
398            * @param userId the primary key of the current user
399            * @param uuid the uuid
400            * @param companyId the company ID
401            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
402            * @return the previous, current, and next user
403            * @throws NoSuchUserException if a user with the primary key could not be found
404            */
405            public static User[] findByUuid_C_PrevAndNext(long userId,
406                    java.lang.String uuid, long companyId,
407                    OrderByComparator<User> orderByComparator)
408                    throws com.liferay.portal.exception.NoSuchUserException {
409                    return getPersistence()
410                                       .findByUuid_C_PrevAndNext(userId, uuid, companyId,
411                            orderByComparator);
412            }
413    
414            /**
415            * Removes all the users where uuid = &#63; and companyId = &#63; from the database.
416            *
417            * @param uuid the uuid
418            * @param companyId the company ID
419            */
420            public static void removeByUuid_C(java.lang.String uuid, long companyId) {
421                    getPersistence().removeByUuid_C(uuid, companyId);
422            }
423    
424            /**
425            * Returns the number of users where uuid = &#63; and companyId = &#63;.
426            *
427            * @param uuid the uuid
428            * @param companyId the company ID
429            * @return the number of matching users
430            */
431            public static int countByUuid_C(java.lang.String uuid, long companyId) {
432                    return getPersistence().countByUuid_C(uuid, companyId);
433            }
434    
435            /**
436            * Returns all the users where companyId = &#63;.
437            *
438            * @param companyId the company ID
439            * @return the matching users
440            */
441            public static List<User> findByCompanyId(long companyId) {
442                    return getPersistence().findByCompanyId(companyId);
443            }
444    
445            /**
446            * Returns a range of all the users where companyId = &#63;.
447            *
448            * <p>
449            * 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 UserModelImpl}. 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.
450            * </p>
451            *
452            * @param companyId the company ID
453            * @param start the lower bound of the range of users
454            * @param end the upper bound of the range of users (not inclusive)
455            * @return the range of matching users
456            */
457            public static List<User> findByCompanyId(long companyId, int start, int end) {
458                    return getPersistence().findByCompanyId(companyId, start, end);
459            }
460    
461            /**
462            * Returns an ordered range of all the users where companyId = &#63;.
463            *
464            * <p>
465            * 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 UserModelImpl}. 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.
466            * </p>
467            *
468            * @param companyId the company ID
469            * @param start the lower bound of the range of users
470            * @param end the upper bound of the range of users (not inclusive)
471            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
472            * @return the ordered range of matching users
473            */
474            public static List<User> findByCompanyId(long companyId, int start,
475                    int end, OrderByComparator<User> orderByComparator) {
476                    return getPersistence()
477                                       .findByCompanyId(companyId, start, end, orderByComparator);
478            }
479    
480            /**
481            * Returns an ordered range of all the users where companyId = &#63;.
482            *
483            * <p>
484            * 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 UserModelImpl}. 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.
485            * </p>
486            *
487            * @param companyId the company ID
488            * @param start the lower bound of the range of users
489            * @param end the upper bound of the range of users (not inclusive)
490            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
491            * @param retrieveFromCache whether to retrieve from the finder cache
492            * @return the ordered range of matching users
493            */
494            public static List<User> findByCompanyId(long companyId, int start,
495                    int end, OrderByComparator<User> orderByComparator,
496                    boolean retrieveFromCache) {
497                    return getPersistence()
498                                       .findByCompanyId(companyId, start, end, orderByComparator,
499                            retrieveFromCache);
500            }
501    
502            /**
503            * Returns the first user in the ordered set where companyId = &#63;.
504            *
505            * @param companyId the company ID
506            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
507            * @return the first matching user
508            * @throws NoSuchUserException if a matching user could not be found
509            */
510            public static User findByCompanyId_First(long companyId,
511                    OrderByComparator<User> orderByComparator)
512                    throws com.liferay.portal.exception.NoSuchUserException {
513                    return getPersistence()
514                                       .findByCompanyId_First(companyId, orderByComparator);
515            }
516    
517            /**
518            * Returns the first user in the ordered set where companyId = &#63;.
519            *
520            * @param companyId the company ID
521            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
522            * @return the first matching user, or <code>null</code> if a matching user could not be found
523            */
524            public static User fetchByCompanyId_First(long companyId,
525                    OrderByComparator<User> orderByComparator) {
526                    return getPersistence()
527                                       .fetchByCompanyId_First(companyId, orderByComparator);
528            }
529    
530            /**
531            * Returns the last user in the ordered set where companyId = &#63;.
532            *
533            * @param companyId the company ID
534            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
535            * @return the last matching user
536            * @throws NoSuchUserException if a matching user could not be found
537            */
538            public static User findByCompanyId_Last(long companyId,
539                    OrderByComparator<User> orderByComparator)
540                    throws com.liferay.portal.exception.NoSuchUserException {
541                    return getPersistence()
542                                       .findByCompanyId_Last(companyId, orderByComparator);
543            }
544    
545            /**
546            * Returns the last user in the ordered set where companyId = &#63;.
547            *
548            * @param companyId the company ID
549            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
550            * @return the last matching user, or <code>null</code> if a matching user could not be found
551            */
552            public static User fetchByCompanyId_Last(long companyId,
553                    OrderByComparator<User> orderByComparator) {
554                    return getPersistence()
555                                       .fetchByCompanyId_Last(companyId, orderByComparator);
556            }
557    
558            /**
559            * Returns the users before and after the current user in the ordered set where companyId = &#63;.
560            *
561            * @param userId the primary key of the current user
562            * @param companyId the company ID
563            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
564            * @return the previous, current, and next user
565            * @throws NoSuchUserException if a user with the primary key could not be found
566            */
567            public static User[] findByCompanyId_PrevAndNext(long userId,
568                    long companyId, OrderByComparator<User> orderByComparator)
569                    throws com.liferay.portal.exception.NoSuchUserException {
570                    return getPersistence()
571                                       .findByCompanyId_PrevAndNext(userId, companyId,
572                            orderByComparator);
573            }
574    
575            /**
576            * Removes all the users where companyId = &#63; from the database.
577            *
578            * @param companyId the company ID
579            */
580            public static void removeByCompanyId(long companyId) {
581                    getPersistence().removeByCompanyId(companyId);
582            }
583    
584            /**
585            * Returns the number of users where companyId = &#63;.
586            *
587            * @param companyId the company ID
588            * @return the number of matching users
589            */
590            public static int countByCompanyId(long companyId) {
591                    return getPersistence().countByCompanyId(companyId);
592            }
593    
594            /**
595            * Returns the user where contactId = &#63; or throws a {@link NoSuchUserException} if it could not be found.
596            *
597            * @param contactId the contact ID
598            * @return the matching user
599            * @throws NoSuchUserException if a matching user could not be found
600            */
601            public static User findByContactId(long contactId)
602                    throws com.liferay.portal.exception.NoSuchUserException {
603                    return getPersistence().findByContactId(contactId);
604            }
605    
606            /**
607            * Returns the user where contactId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
608            *
609            * @param contactId the contact ID
610            * @return the matching user, or <code>null</code> if a matching user could not be found
611            */
612            public static User fetchByContactId(long contactId) {
613                    return getPersistence().fetchByContactId(contactId);
614            }
615    
616            /**
617            * Returns the user where contactId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
618            *
619            * @param contactId the contact ID
620            * @param retrieveFromCache whether to retrieve from the finder cache
621            * @return the matching user, or <code>null</code> if a matching user could not be found
622            */
623            public static User fetchByContactId(long contactId,
624                    boolean retrieveFromCache) {
625                    return getPersistence().fetchByContactId(contactId, retrieveFromCache);
626            }
627    
628            /**
629            * Removes the user where contactId = &#63; from the database.
630            *
631            * @param contactId the contact ID
632            * @return the user that was removed
633            */
634            public static User removeByContactId(long contactId)
635                    throws com.liferay.portal.exception.NoSuchUserException {
636                    return getPersistence().removeByContactId(contactId);
637            }
638    
639            /**
640            * Returns the number of users where contactId = &#63;.
641            *
642            * @param contactId the contact ID
643            * @return the number of matching users
644            */
645            public static int countByContactId(long contactId) {
646                    return getPersistence().countByContactId(contactId);
647            }
648    
649            /**
650            * Returns all the users where emailAddress = &#63;.
651            *
652            * @param emailAddress the email address
653            * @return the matching users
654            */
655            public static List<User> findByEmailAddress(java.lang.String emailAddress) {
656                    return getPersistence().findByEmailAddress(emailAddress);
657            }
658    
659            /**
660            * Returns a range of all the users where emailAddress = &#63;.
661            *
662            * <p>
663            * 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 UserModelImpl}. 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.
664            * </p>
665            *
666            * @param emailAddress the email address
667            * @param start the lower bound of the range of users
668            * @param end the upper bound of the range of users (not inclusive)
669            * @return the range of matching users
670            */
671            public static List<User> findByEmailAddress(java.lang.String emailAddress,
672                    int start, int end) {
673                    return getPersistence().findByEmailAddress(emailAddress, start, end);
674            }
675    
676            /**
677            * Returns an ordered range of all the users where emailAddress = &#63;.
678            *
679            * <p>
680            * 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 UserModelImpl}. 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.
681            * </p>
682            *
683            * @param emailAddress the email address
684            * @param start the lower bound of the range of users
685            * @param end the upper bound of the range of users (not inclusive)
686            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
687            * @return the ordered range of matching users
688            */
689            public static List<User> findByEmailAddress(java.lang.String emailAddress,
690                    int start, int end, OrderByComparator<User> orderByComparator) {
691                    return getPersistence()
692                                       .findByEmailAddress(emailAddress, start, end,
693                            orderByComparator);
694            }
695    
696            /**
697            * Returns an ordered range of all the users where emailAddress = &#63;.
698            *
699            * <p>
700            * 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 UserModelImpl}. 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.
701            * </p>
702            *
703            * @param emailAddress the email address
704            * @param start the lower bound of the range of users
705            * @param end the upper bound of the range of users (not inclusive)
706            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
707            * @param retrieveFromCache whether to retrieve from the finder cache
708            * @return the ordered range of matching users
709            */
710            public static List<User> findByEmailAddress(java.lang.String emailAddress,
711                    int start, int end, OrderByComparator<User> orderByComparator,
712                    boolean retrieveFromCache) {
713                    return getPersistence()
714                                       .findByEmailAddress(emailAddress, start, end,
715                            orderByComparator, retrieveFromCache);
716            }
717    
718            /**
719            * Returns the first user in the ordered set where emailAddress = &#63;.
720            *
721            * @param emailAddress the email address
722            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
723            * @return the first matching user
724            * @throws NoSuchUserException if a matching user could not be found
725            */
726            public static User findByEmailAddress_First(java.lang.String emailAddress,
727                    OrderByComparator<User> orderByComparator)
728                    throws com.liferay.portal.exception.NoSuchUserException {
729                    return getPersistence()
730                                       .findByEmailAddress_First(emailAddress, orderByComparator);
731            }
732    
733            /**
734            * Returns the first user in the ordered set where emailAddress = &#63;.
735            *
736            * @param emailAddress the email address
737            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
738            * @return the first matching user, or <code>null</code> if a matching user could not be found
739            */
740            public static User fetchByEmailAddress_First(
741                    java.lang.String emailAddress, OrderByComparator<User> orderByComparator) {
742                    return getPersistence()
743                                       .fetchByEmailAddress_First(emailAddress, orderByComparator);
744            }
745    
746            /**
747            * Returns the last user in the ordered set where emailAddress = &#63;.
748            *
749            * @param emailAddress the email address
750            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
751            * @return the last matching user
752            * @throws NoSuchUserException if a matching user could not be found
753            */
754            public static User findByEmailAddress_Last(java.lang.String emailAddress,
755                    OrderByComparator<User> orderByComparator)
756                    throws com.liferay.portal.exception.NoSuchUserException {
757                    return getPersistence()
758                                       .findByEmailAddress_Last(emailAddress, orderByComparator);
759            }
760    
761            /**
762            * Returns the last user in the ordered set where emailAddress = &#63;.
763            *
764            * @param emailAddress the email address
765            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
766            * @return the last matching user, or <code>null</code> if a matching user could not be found
767            */
768            public static User fetchByEmailAddress_Last(java.lang.String emailAddress,
769                    OrderByComparator<User> orderByComparator) {
770                    return getPersistence()
771                                       .fetchByEmailAddress_Last(emailAddress, orderByComparator);
772            }
773    
774            /**
775            * Returns the users before and after the current user in the ordered set where emailAddress = &#63;.
776            *
777            * @param userId the primary key of the current user
778            * @param emailAddress the email address
779            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
780            * @return the previous, current, and next user
781            * @throws NoSuchUserException if a user with the primary key could not be found
782            */
783            public static User[] findByEmailAddress_PrevAndNext(long userId,
784                    java.lang.String emailAddress, OrderByComparator<User> orderByComparator)
785                    throws com.liferay.portal.exception.NoSuchUserException {
786                    return getPersistence()
787                                       .findByEmailAddress_PrevAndNext(userId, emailAddress,
788                            orderByComparator);
789            }
790    
791            /**
792            * Removes all the users where emailAddress = &#63; from the database.
793            *
794            * @param emailAddress the email address
795            */
796            public static void removeByEmailAddress(java.lang.String emailAddress) {
797                    getPersistence().removeByEmailAddress(emailAddress);
798            }
799    
800            /**
801            * Returns the number of users where emailAddress = &#63;.
802            *
803            * @param emailAddress the email address
804            * @return the number of matching users
805            */
806            public static int countByEmailAddress(java.lang.String emailAddress) {
807                    return getPersistence().countByEmailAddress(emailAddress);
808            }
809    
810            /**
811            * Returns the user where portraitId = &#63; or throws a {@link NoSuchUserException} if it could not be found.
812            *
813            * @param portraitId the portrait ID
814            * @return the matching user
815            * @throws NoSuchUserException if a matching user could not be found
816            */
817            public static User findByPortraitId(long portraitId)
818                    throws com.liferay.portal.exception.NoSuchUserException {
819                    return getPersistence().findByPortraitId(portraitId);
820            }
821    
822            /**
823            * Returns the user where portraitId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
824            *
825            * @param portraitId the portrait ID
826            * @return the matching user, or <code>null</code> if a matching user could not be found
827            */
828            public static User fetchByPortraitId(long portraitId) {
829                    return getPersistence().fetchByPortraitId(portraitId);
830            }
831    
832            /**
833            * Returns the user where portraitId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
834            *
835            * @param portraitId the portrait ID
836            * @param retrieveFromCache whether to retrieve from the finder cache
837            * @return the matching user, or <code>null</code> if a matching user could not be found
838            */
839            public static User fetchByPortraitId(long portraitId,
840                    boolean retrieveFromCache) {
841                    return getPersistence().fetchByPortraitId(portraitId, retrieveFromCache);
842            }
843    
844            /**
845            * Removes the user where portraitId = &#63; from the database.
846            *
847            * @param portraitId the portrait ID
848            * @return the user that was removed
849            */
850            public static User removeByPortraitId(long portraitId)
851                    throws com.liferay.portal.exception.NoSuchUserException {
852                    return getPersistence().removeByPortraitId(portraitId);
853            }
854    
855            /**
856            * Returns the number of users where portraitId = &#63;.
857            *
858            * @param portraitId the portrait ID
859            * @return the number of matching users
860            */
861            public static int countByPortraitId(long portraitId) {
862                    return getPersistence().countByPortraitId(portraitId);
863            }
864    
865            /**
866            * Returns the user where companyId = &#63; and userId = &#63; or throws a {@link NoSuchUserException} if it could not be found.
867            *
868            * @param companyId the company ID
869            * @param userId the user ID
870            * @return the matching user
871            * @throws NoSuchUserException if a matching user could not be found
872            */
873            public static User findByC_U(long companyId, long userId)
874                    throws com.liferay.portal.exception.NoSuchUserException {
875                    return getPersistence().findByC_U(companyId, userId);
876            }
877    
878            /**
879            * Returns the user where companyId = &#63; and userId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
880            *
881            * @param companyId the company ID
882            * @param userId the user ID
883            * @return the matching user, or <code>null</code> if a matching user could not be found
884            */
885            public static User fetchByC_U(long companyId, long userId) {
886                    return getPersistence().fetchByC_U(companyId, userId);
887            }
888    
889            /**
890            * Returns the user where companyId = &#63; and userId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
891            *
892            * @param companyId the company ID
893            * @param userId the user ID
894            * @param retrieveFromCache whether to retrieve from the finder cache
895            * @return the matching user, or <code>null</code> if a matching user could not be found
896            */
897            public static User fetchByC_U(long companyId, long userId,
898                    boolean retrieveFromCache) {
899                    return getPersistence().fetchByC_U(companyId, userId, retrieveFromCache);
900            }
901    
902            /**
903            * Removes the user where companyId = &#63; and userId = &#63; from the database.
904            *
905            * @param companyId the company ID
906            * @param userId the user ID
907            * @return the user that was removed
908            */
909            public static User removeByC_U(long companyId, long userId)
910                    throws com.liferay.portal.exception.NoSuchUserException {
911                    return getPersistence().removeByC_U(companyId, userId);
912            }
913    
914            /**
915            * Returns the number of users where companyId = &#63; and userId = &#63;.
916            *
917            * @param companyId the company ID
918            * @param userId the user ID
919            * @return the number of matching users
920            */
921            public static int countByC_U(long companyId, long userId) {
922                    return getPersistence().countByC_U(companyId, userId);
923            }
924    
925            /**
926            * Returns all the users where companyId = &#63; and createDate = &#63;.
927            *
928            * @param companyId the company ID
929            * @param createDate the create date
930            * @return the matching users
931            */
932            public static List<User> findByC_CD(long companyId,
933                    java.util.Date createDate) {
934                    return getPersistence().findByC_CD(companyId, createDate);
935            }
936    
937            /**
938            * Returns a range of all the users where companyId = &#63; and createDate = &#63;.
939            *
940            * <p>
941            * 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 UserModelImpl}. 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.
942            * </p>
943            *
944            * @param companyId the company ID
945            * @param createDate the create date
946            * @param start the lower bound of the range of users
947            * @param end the upper bound of the range of users (not inclusive)
948            * @return the range of matching users
949            */
950            public static List<User> findByC_CD(long companyId,
951                    java.util.Date createDate, int start, int end) {
952                    return getPersistence().findByC_CD(companyId, createDate, start, end);
953            }
954    
955            /**
956            * Returns an ordered range of all the users where companyId = &#63; and createDate = &#63;.
957            *
958            * <p>
959            * 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 UserModelImpl}. 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.
960            * </p>
961            *
962            * @param companyId the company ID
963            * @param createDate the create date
964            * @param start the lower bound of the range of users
965            * @param end the upper bound of the range of users (not inclusive)
966            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
967            * @return the ordered range of matching users
968            */
969            public static List<User> findByC_CD(long companyId,
970                    java.util.Date createDate, int start, int end,
971                    OrderByComparator<User> orderByComparator) {
972                    return getPersistence()
973                                       .findByC_CD(companyId, createDate, start, end,
974                            orderByComparator);
975            }
976    
977            /**
978            * Returns an ordered range of all the users where companyId = &#63; and createDate = &#63;.
979            *
980            * <p>
981            * 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 UserModelImpl}. 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.
982            * </p>
983            *
984            * @param companyId the company ID
985            * @param createDate the create date
986            * @param start the lower bound of the range of users
987            * @param end the upper bound of the range of users (not inclusive)
988            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
989            * @param retrieveFromCache whether to retrieve from the finder cache
990            * @return the ordered range of matching users
991            */
992            public static List<User> findByC_CD(long companyId,
993                    java.util.Date createDate, int start, int end,
994                    OrderByComparator<User> orderByComparator, boolean retrieveFromCache) {
995                    return getPersistence()
996                                       .findByC_CD(companyId, createDate, start, end,
997                            orderByComparator, retrieveFromCache);
998            }
999    
1000            /**
1001            * Returns the first user in the ordered set where companyId = &#63; and createDate = &#63;.
1002            *
1003            * @param companyId the company ID
1004            * @param createDate the create date
1005            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1006            * @return the first matching user
1007            * @throws NoSuchUserException if a matching user could not be found
1008            */
1009            public static User findByC_CD_First(long companyId,
1010                    java.util.Date createDate, OrderByComparator<User> orderByComparator)
1011                    throws com.liferay.portal.exception.NoSuchUserException {
1012                    return getPersistence()
1013                                       .findByC_CD_First(companyId, createDate, orderByComparator);
1014            }
1015    
1016            /**
1017            * Returns the first user in the ordered set where companyId = &#63; and createDate = &#63;.
1018            *
1019            * @param companyId the company ID
1020            * @param createDate the create date
1021            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1022            * @return the first matching user, or <code>null</code> if a matching user could not be found
1023            */
1024            public static User fetchByC_CD_First(long companyId,
1025                    java.util.Date createDate, OrderByComparator<User> orderByComparator) {
1026                    return getPersistence()
1027                                       .fetchByC_CD_First(companyId, createDate, orderByComparator);
1028            }
1029    
1030            /**
1031            * Returns the last user in the ordered set where companyId = &#63; and createDate = &#63;.
1032            *
1033            * @param companyId the company ID
1034            * @param createDate the create date
1035            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1036            * @return the last matching user
1037            * @throws NoSuchUserException if a matching user could not be found
1038            */
1039            public static User findByC_CD_Last(long companyId,
1040                    java.util.Date createDate, OrderByComparator<User> orderByComparator)
1041                    throws com.liferay.portal.exception.NoSuchUserException {
1042                    return getPersistence()
1043                                       .findByC_CD_Last(companyId, createDate, orderByComparator);
1044            }
1045    
1046            /**
1047            * Returns the last user in the ordered set where companyId = &#63; and createDate = &#63;.
1048            *
1049            * @param companyId the company ID
1050            * @param createDate the create date
1051            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1052            * @return the last matching user, or <code>null</code> if a matching user could not be found
1053            */
1054            public static User fetchByC_CD_Last(long companyId,
1055                    java.util.Date createDate, OrderByComparator<User> orderByComparator) {
1056                    return getPersistence()
1057                                       .fetchByC_CD_Last(companyId, createDate, orderByComparator);
1058            }
1059    
1060            /**
1061            * Returns the users before and after the current user in the ordered set where companyId = &#63; and createDate = &#63;.
1062            *
1063            * @param userId the primary key of the current user
1064            * @param companyId the company ID
1065            * @param createDate the create date
1066            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1067            * @return the previous, current, and next user
1068            * @throws NoSuchUserException if a user with the primary key could not be found
1069            */
1070            public static User[] findByC_CD_PrevAndNext(long userId, long companyId,
1071                    java.util.Date createDate, OrderByComparator<User> orderByComparator)
1072                    throws com.liferay.portal.exception.NoSuchUserException {
1073                    return getPersistence()
1074                                       .findByC_CD_PrevAndNext(userId, companyId, createDate,
1075                            orderByComparator);
1076            }
1077    
1078            /**
1079            * Removes all the users where companyId = &#63; and createDate = &#63; from the database.
1080            *
1081            * @param companyId the company ID
1082            * @param createDate the create date
1083            */
1084            public static void removeByC_CD(long companyId, java.util.Date createDate) {
1085                    getPersistence().removeByC_CD(companyId, createDate);
1086            }
1087    
1088            /**
1089            * Returns the number of users where companyId = &#63; and createDate = &#63;.
1090            *
1091            * @param companyId the company ID
1092            * @param createDate the create date
1093            * @return the number of matching users
1094            */
1095            public static int countByC_CD(long companyId, java.util.Date createDate) {
1096                    return getPersistence().countByC_CD(companyId, createDate);
1097            }
1098    
1099            /**
1100            * Returns all the users where companyId = &#63; and modifiedDate = &#63;.
1101            *
1102            * @param companyId the company ID
1103            * @param modifiedDate the modified date
1104            * @return the matching users
1105            */
1106            public static List<User> findByC_MD(long companyId,
1107                    java.util.Date modifiedDate) {
1108                    return getPersistence().findByC_MD(companyId, modifiedDate);
1109            }
1110    
1111            /**
1112            * Returns a range of all the users where companyId = &#63; and modifiedDate = &#63;.
1113            *
1114            * <p>
1115            * 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 UserModelImpl}. 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.
1116            * </p>
1117            *
1118            * @param companyId the company ID
1119            * @param modifiedDate the modified date
1120            * @param start the lower bound of the range of users
1121            * @param end the upper bound of the range of users (not inclusive)
1122            * @return the range of matching users
1123            */
1124            public static List<User> findByC_MD(long companyId,
1125                    java.util.Date modifiedDate, int start, int end) {
1126                    return getPersistence().findByC_MD(companyId, modifiedDate, start, end);
1127            }
1128    
1129            /**
1130            * Returns an ordered range of all the users where companyId = &#63; and modifiedDate = &#63;.
1131            *
1132            * <p>
1133            * 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 UserModelImpl}. 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.
1134            * </p>
1135            *
1136            * @param companyId the company ID
1137            * @param modifiedDate the modified date
1138            * @param start the lower bound of the range of users
1139            * @param end the upper bound of the range of users (not inclusive)
1140            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1141            * @return the ordered range of matching users
1142            */
1143            public static List<User> findByC_MD(long companyId,
1144                    java.util.Date modifiedDate, int start, int end,
1145                    OrderByComparator<User> orderByComparator) {
1146                    return getPersistence()
1147                                       .findByC_MD(companyId, modifiedDate, start, end,
1148                            orderByComparator);
1149            }
1150    
1151            /**
1152            * Returns an ordered range of all the users where companyId = &#63; and modifiedDate = &#63;.
1153            *
1154            * <p>
1155            * 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 UserModelImpl}. 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.
1156            * </p>
1157            *
1158            * @param companyId the company ID
1159            * @param modifiedDate the modified date
1160            * @param start the lower bound of the range of users
1161            * @param end the upper bound of the range of users (not inclusive)
1162            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1163            * @param retrieveFromCache whether to retrieve from the finder cache
1164            * @return the ordered range of matching users
1165            */
1166            public static List<User> findByC_MD(long companyId,
1167                    java.util.Date modifiedDate, int start, int end,
1168                    OrderByComparator<User> orderByComparator, boolean retrieveFromCache) {
1169                    return getPersistence()
1170                                       .findByC_MD(companyId, modifiedDate, start, end,
1171                            orderByComparator, retrieveFromCache);
1172            }
1173    
1174            /**
1175            * Returns the first user in the ordered set where companyId = &#63; and modifiedDate = &#63;.
1176            *
1177            * @param companyId the company ID
1178            * @param modifiedDate the modified date
1179            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1180            * @return the first matching user
1181            * @throws NoSuchUserException if a matching user could not be found
1182            */
1183            public static User findByC_MD_First(long companyId,
1184                    java.util.Date modifiedDate, OrderByComparator<User> orderByComparator)
1185                    throws com.liferay.portal.exception.NoSuchUserException {
1186                    return getPersistence()
1187                                       .findByC_MD_First(companyId, modifiedDate, orderByComparator);
1188            }
1189    
1190            /**
1191            * Returns the first user in the ordered set where companyId = &#63; and modifiedDate = &#63;.
1192            *
1193            * @param companyId the company ID
1194            * @param modifiedDate the modified date
1195            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1196            * @return the first matching user, or <code>null</code> if a matching user could not be found
1197            */
1198            public static User fetchByC_MD_First(long companyId,
1199                    java.util.Date modifiedDate, OrderByComparator<User> orderByComparator) {
1200                    return getPersistence()
1201                                       .fetchByC_MD_First(companyId, modifiedDate, orderByComparator);
1202            }
1203    
1204            /**
1205            * Returns the last user in the ordered set where companyId = &#63; and modifiedDate = &#63;.
1206            *
1207            * @param companyId the company ID
1208            * @param modifiedDate the modified date
1209            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1210            * @return the last matching user
1211            * @throws NoSuchUserException if a matching user could not be found
1212            */
1213            public static User findByC_MD_Last(long companyId,
1214                    java.util.Date modifiedDate, OrderByComparator<User> orderByComparator)
1215                    throws com.liferay.portal.exception.NoSuchUserException {
1216                    return getPersistence()
1217                                       .findByC_MD_Last(companyId, modifiedDate, orderByComparator);
1218            }
1219    
1220            /**
1221            * Returns the last user in the ordered set where companyId = &#63; and modifiedDate = &#63;.
1222            *
1223            * @param companyId the company ID
1224            * @param modifiedDate the modified date
1225            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1226            * @return the last matching user, or <code>null</code> if a matching user could not be found
1227            */
1228            public static User fetchByC_MD_Last(long companyId,
1229                    java.util.Date modifiedDate, OrderByComparator<User> orderByComparator) {
1230                    return getPersistence()
1231                                       .fetchByC_MD_Last(companyId, modifiedDate, orderByComparator);
1232            }
1233    
1234            /**
1235            * Returns the users before and after the current user in the ordered set where companyId = &#63; and modifiedDate = &#63;.
1236            *
1237            * @param userId the primary key of the current user
1238            * @param companyId the company ID
1239            * @param modifiedDate the modified date
1240            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1241            * @return the previous, current, and next user
1242            * @throws NoSuchUserException if a user with the primary key could not be found
1243            */
1244            public static User[] findByC_MD_PrevAndNext(long userId, long companyId,
1245                    java.util.Date modifiedDate, OrderByComparator<User> orderByComparator)
1246                    throws com.liferay.portal.exception.NoSuchUserException {
1247                    return getPersistence()
1248                                       .findByC_MD_PrevAndNext(userId, companyId, modifiedDate,
1249                            orderByComparator);
1250            }
1251    
1252            /**
1253            * Removes all the users where companyId = &#63; and modifiedDate = &#63; from the database.
1254            *
1255            * @param companyId the company ID
1256            * @param modifiedDate the modified date
1257            */
1258            public static void removeByC_MD(long companyId, java.util.Date modifiedDate) {
1259                    getPersistence().removeByC_MD(companyId, modifiedDate);
1260            }
1261    
1262            /**
1263            * Returns the number of users where companyId = &#63; and modifiedDate = &#63;.
1264            *
1265            * @param companyId the company ID
1266            * @param modifiedDate the modified date
1267            * @return the number of matching users
1268            */
1269            public static int countByC_MD(long companyId, java.util.Date modifiedDate) {
1270                    return getPersistence().countByC_MD(companyId, modifiedDate);
1271            }
1272    
1273            /**
1274            * Returns the user where companyId = &#63; and defaultUser = &#63; or throws a {@link NoSuchUserException} if it could not be found.
1275            *
1276            * @param companyId the company ID
1277            * @param defaultUser the default user
1278            * @return the matching user
1279            * @throws NoSuchUserException if a matching user could not be found
1280            */
1281            public static User findByC_DU(long companyId, boolean defaultUser)
1282                    throws com.liferay.portal.exception.NoSuchUserException {
1283                    return getPersistence().findByC_DU(companyId, defaultUser);
1284            }
1285    
1286            /**
1287            * Returns the user where companyId = &#63; and defaultUser = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
1288            *
1289            * @param companyId the company ID
1290            * @param defaultUser the default user
1291            * @return the matching user, or <code>null</code> if a matching user could not be found
1292            */
1293            public static User fetchByC_DU(long companyId, boolean defaultUser) {
1294                    return getPersistence().fetchByC_DU(companyId, defaultUser);
1295            }
1296    
1297            /**
1298            * Returns the user where companyId = &#63; and defaultUser = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
1299            *
1300            * @param companyId the company ID
1301            * @param defaultUser the default user
1302            * @param retrieveFromCache whether to retrieve from the finder cache
1303            * @return the matching user, or <code>null</code> if a matching user could not be found
1304            */
1305            public static User fetchByC_DU(long companyId, boolean defaultUser,
1306                    boolean retrieveFromCache) {
1307                    return getPersistence()
1308                                       .fetchByC_DU(companyId, defaultUser, retrieveFromCache);
1309            }
1310    
1311            /**
1312            * Removes the user where companyId = &#63; and defaultUser = &#63; from the database.
1313            *
1314            * @param companyId the company ID
1315            * @param defaultUser the default user
1316            * @return the user that was removed
1317            */
1318            public static User removeByC_DU(long companyId, boolean defaultUser)
1319                    throws com.liferay.portal.exception.NoSuchUserException {
1320                    return getPersistence().removeByC_DU(companyId, defaultUser);
1321            }
1322    
1323            /**
1324            * Returns the number of users where companyId = &#63; and defaultUser = &#63;.
1325            *
1326            * @param companyId the company ID
1327            * @param defaultUser the default user
1328            * @return the number of matching users
1329            */
1330            public static int countByC_DU(long companyId, boolean defaultUser) {
1331                    return getPersistence().countByC_DU(companyId, defaultUser);
1332            }
1333    
1334            /**
1335            * Returns the user where companyId = &#63; and screenName = &#63; or throws a {@link NoSuchUserException} if it could not be found.
1336            *
1337            * @param companyId the company ID
1338            * @param screenName the screen name
1339            * @return the matching user
1340            * @throws NoSuchUserException if a matching user could not be found
1341            */
1342            public static User findByC_SN(long companyId, java.lang.String screenName)
1343                    throws com.liferay.portal.exception.NoSuchUserException {
1344                    return getPersistence().findByC_SN(companyId, screenName);
1345            }
1346    
1347            /**
1348            * Returns the user where companyId = &#63; and screenName = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
1349            *
1350            * @param companyId the company ID
1351            * @param screenName the screen name
1352            * @return the matching user, or <code>null</code> if a matching user could not be found
1353            */
1354            public static User fetchByC_SN(long companyId, java.lang.String screenName) {
1355                    return getPersistence().fetchByC_SN(companyId, screenName);
1356            }
1357    
1358            /**
1359            * Returns the user where companyId = &#63; and screenName = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
1360            *
1361            * @param companyId the company ID
1362            * @param screenName the screen name
1363            * @param retrieveFromCache whether to retrieve from the finder cache
1364            * @return the matching user, or <code>null</code> if a matching user could not be found
1365            */
1366            public static User fetchByC_SN(long companyId, java.lang.String screenName,
1367                    boolean retrieveFromCache) {
1368                    return getPersistence()
1369                                       .fetchByC_SN(companyId, screenName, retrieveFromCache);
1370            }
1371    
1372            /**
1373            * Removes the user where companyId = &#63; and screenName = &#63; from the database.
1374            *
1375            * @param companyId the company ID
1376            * @param screenName the screen name
1377            * @return the user that was removed
1378            */
1379            public static User removeByC_SN(long companyId, java.lang.String screenName)
1380                    throws com.liferay.portal.exception.NoSuchUserException {
1381                    return getPersistence().removeByC_SN(companyId, screenName);
1382            }
1383    
1384            /**
1385            * Returns the number of users where companyId = &#63; and screenName = &#63;.
1386            *
1387            * @param companyId the company ID
1388            * @param screenName the screen name
1389            * @return the number of matching users
1390            */
1391            public static int countByC_SN(long companyId, java.lang.String screenName) {
1392                    return getPersistence().countByC_SN(companyId, screenName);
1393            }
1394    
1395            /**
1396            * Returns the user where companyId = &#63; and emailAddress = &#63; or throws a {@link NoSuchUserException} if it could not be found.
1397            *
1398            * @param companyId the company ID
1399            * @param emailAddress the email address
1400            * @return the matching user
1401            * @throws NoSuchUserException if a matching user could not be found
1402            */
1403            public static User findByC_EA(long companyId, java.lang.String emailAddress)
1404                    throws com.liferay.portal.exception.NoSuchUserException {
1405                    return getPersistence().findByC_EA(companyId, emailAddress);
1406            }
1407    
1408            /**
1409            * Returns the user where companyId = &#63; and emailAddress = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
1410            *
1411            * @param companyId the company ID
1412            * @param emailAddress the email address
1413            * @return the matching user, or <code>null</code> if a matching user could not be found
1414            */
1415            public static User fetchByC_EA(long companyId, java.lang.String emailAddress) {
1416                    return getPersistence().fetchByC_EA(companyId, emailAddress);
1417            }
1418    
1419            /**
1420            * Returns the user where companyId = &#63; and emailAddress = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
1421            *
1422            * @param companyId the company ID
1423            * @param emailAddress the email address
1424            * @param retrieveFromCache whether to retrieve from the finder cache
1425            * @return the matching user, or <code>null</code> if a matching user could not be found
1426            */
1427            public static User fetchByC_EA(long companyId,
1428                    java.lang.String emailAddress, boolean retrieveFromCache) {
1429                    return getPersistence()
1430                                       .fetchByC_EA(companyId, emailAddress, retrieveFromCache);
1431            }
1432    
1433            /**
1434            * Removes the user where companyId = &#63; and emailAddress = &#63; from the database.
1435            *
1436            * @param companyId the company ID
1437            * @param emailAddress the email address
1438            * @return the user that was removed
1439            */
1440            public static User removeByC_EA(long companyId,
1441                    java.lang.String emailAddress)
1442                    throws com.liferay.portal.exception.NoSuchUserException {
1443                    return getPersistence().removeByC_EA(companyId, emailAddress);
1444            }
1445    
1446            /**
1447            * Returns the number of users where companyId = &#63; and emailAddress = &#63;.
1448            *
1449            * @param companyId the company ID
1450            * @param emailAddress the email address
1451            * @return the number of matching users
1452            */
1453            public static int countByC_EA(long companyId, java.lang.String emailAddress) {
1454                    return getPersistence().countByC_EA(companyId, emailAddress);
1455            }
1456    
1457            /**
1458            * Returns the user where companyId = &#63; and facebookId = &#63; or throws a {@link NoSuchUserException} if it could not be found.
1459            *
1460            * @param companyId the company ID
1461            * @param facebookId the facebook ID
1462            * @return the matching user
1463            * @throws NoSuchUserException if a matching user could not be found
1464            */
1465            public static User findByC_FID(long companyId, long facebookId)
1466                    throws com.liferay.portal.exception.NoSuchUserException {
1467                    return getPersistence().findByC_FID(companyId, facebookId);
1468            }
1469    
1470            /**
1471            * Returns the user where companyId = &#63; and facebookId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
1472            *
1473            * @param companyId the company ID
1474            * @param facebookId the facebook ID
1475            * @return the matching user, or <code>null</code> if a matching user could not be found
1476            */
1477            public static User fetchByC_FID(long companyId, long facebookId) {
1478                    return getPersistence().fetchByC_FID(companyId, facebookId);
1479            }
1480    
1481            /**
1482            * Returns the user where companyId = &#63; and facebookId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
1483            *
1484            * @param companyId the company ID
1485            * @param facebookId the facebook ID
1486            * @param retrieveFromCache whether to retrieve from the finder cache
1487            * @return the matching user, or <code>null</code> if a matching user could not be found
1488            */
1489            public static User fetchByC_FID(long companyId, long facebookId,
1490                    boolean retrieveFromCache) {
1491                    return getPersistence()
1492                                       .fetchByC_FID(companyId, facebookId, retrieveFromCache);
1493            }
1494    
1495            /**
1496            * Removes the user where companyId = &#63; and facebookId = &#63; from the database.
1497            *
1498            * @param companyId the company ID
1499            * @param facebookId the facebook ID
1500            * @return the user that was removed
1501            */
1502            public static User removeByC_FID(long companyId, long facebookId)
1503                    throws com.liferay.portal.exception.NoSuchUserException {
1504                    return getPersistence().removeByC_FID(companyId, facebookId);
1505            }
1506    
1507            /**
1508            * Returns the number of users where companyId = &#63; and facebookId = &#63;.
1509            *
1510            * @param companyId the company ID
1511            * @param facebookId the facebook ID
1512            * @return the number of matching users
1513            */
1514            public static int countByC_FID(long companyId, long facebookId) {
1515                    return getPersistence().countByC_FID(companyId, facebookId);
1516            }
1517    
1518            /**
1519            * Returns the user where companyId = &#63; and openId = &#63; or throws a {@link NoSuchUserException} if it could not be found.
1520            *
1521            * @param companyId the company ID
1522            * @param openId the open ID
1523            * @return the matching user
1524            * @throws NoSuchUserException if a matching user could not be found
1525            */
1526            public static User findByC_O(long companyId, java.lang.String openId)
1527                    throws com.liferay.portal.exception.NoSuchUserException {
1528                    return getPersistence().findByC_O(companyId, openId);
1529            }
1530    
1531            /**
1532            * Returns the user where companyId = &#63; and openId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
1533            *
1534            * @param companyId the company ID
1535            * @param openId the open ID
1536            * @return the matching user, or <code>null</code> if a matching user could not be found
1537            */
1538            public static User fetchByC_O(long companyId, java.lang.String openId) {
1539                    return getPersistence().fetchByC_O(companyId, openId);
1540            }
1541    
1542            /**
1543            * Returns the user where companyId = &#63; and openId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
1544            *
1545            * @param companyId the company ID
1546            * @param openId the open ID
1547            * @param retrieveFromCache whether to retrieve from the finder cache
1548            * @return the matching user, or <code>null</code> if a matching user could not be found
1549            */
1550            public static User fetchByC_O(long companyId, java.lang.String openId,
1551                    boolean retrieveFromCache) {
1552                    return getPersistence().fetchByC_O(companyId, openId, retrieveFromCache);
1553            }
1554    
1555            /**
1556            * Removes the user where companyId = &#63; and openId = &#63; from the database.
1557            *
1558            * @param companyId the company ID
1559            * @param openId the open ID
1560            * @return the user that was removed
1561            */
1562            public static User removeByC_O(long companyId, java.lang.String openId)
1563                    throws com.liferay.portal.exception.NoSuchUserException {
1564                    return getPersistence().removeByC_O(companyId, openId);
1565            }
1566    
1567            /**
1568            * Returns the number of users where companyId = &#63; and openId = &#63;.
1569            *
1570            * @param companyId the company ID
1571            * @param openId the open ID
1572            * @return the number of matching users
1573            */
1574            public static int countByC_O(long companyId, java.lang.String openId) {
1575                    return getPersistence().countByC_O(companyId, openId);
1576            }
1577    
1578            /**
1579            * Returns all the users where companyId = &#63; and status = &#63;.
1580            *
1581            * @param companyId the company ID
1582            * @param status the status
1583            * @return the matching users
1584            */
1585            public static List<User> findByC_S(long companyId, int status) {
1586                    return getPersistence().findByC_S(companyId, status);
1587            }
1588    
1589            /**
1590            * Returns a range of all the users where companyId = &#63; and status = &#63;.
1591            *
1592            * <p>
1593            * 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 UserModelImpl}. 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.
1594            * </p>
1595            *
1596            * @param companyId the company ID
1597            * @param status the status
1598            * @param start the lower bound of the range of users
1599            * @param end the upper bound of the range of users (not inclusive)
1600            * @return the range of matching users
1601            */
1602            public static List<User> findByC_S(long companyId, int status, int start,
1603                    int end) {
1604                    return getPersistence().findByC_S(companyId, status, start, end);
1605            }
1606    
1607            /**
1608            * Returns an ordered range of all the users where companyId = &#63; and status = &#63;.
1609            *
1610            * <p>
1611            * 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 UserModelImpl}. 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.
1612            * </p>
1613            *
1614            * @param companyId the company ID
1615            * @param status the status
1616            * @param start the lower bound of the range of users
1617            * @param end the upper bound of the range of users (not inclusive)
1618            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1619            * @return the ordered range of matching users
1620            */
1621            public static List<User> findByC_S(long companyId, int status, int start,
1622                    int end, OrderByComparator<User> orderByComparator) {
1623                    return getPersistence()
1624                                       .findByC_S(companyId, status, start, end, orderByComparator);
1625            }
1626    
1627            /**
1628            * Returns an ordered range of all the users where companyId = &#63; and status = &#63;.
1629            *
1630            * <p>
1631            * 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 UserModelImpl}. 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.
1632            * </p>
1633            *
1634            * @param companyId the company ID
1635            * @param status the status
1636            * @param start the lower bound of the range of users
1637            * @param end the upper bound of the range of users (not inclusive)
1638            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1639            * @param retrieveFromCache whether to retrieve from the finder cache
1640            * @return the ordered range of matching users
1641            */
1642            public static List<User> findByC_S(long companyId, int status, int start,
1643                    int end, OrderByComparator<User> orderByComparator,
1644                    boolean retrieveFromCache) {
1645                    return getPersistence()
1646                                       .findByC_S(companyId, status, start, end, orderByComparator,
1647                            retrieveFromCache);
1648            }
1649    
1650            /**
1651            * Returns the first user in the ordered set where companyId = &#63; and status = &#63;.
1652            *
1653            * @param companyId the company ID
1654            * @param status the status
1655            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1656            * @return the first matching user
1657            * @throws NoSuchUserException if a matching user could not be found
1658            */
1659            public static User findByC_S_First(long companyId, int status,
1660                    OrderByComparator<User> orderByComparator)
1661                    throws com.liferay.portal.exception.NoSuchUserException {
1662                    return getPersistence()
1663                                       .findByC_S_First(companyId, status, orderByComparator);
1664            }
1665    
1666            /**
1667            * Returns the first user in the ordered set where companyId = &#63; and status = &#63;.
1668            *
1669            * @param companyId the company ID
1670            * @param status the status
1671            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1672            * @return the first matching user, or <code>null</code> if a matching user could not be found
1673            */
1674            public static User fetchByC_S_First(long companyId, int status,
1675                    OrderByComparator<User> orderByComparator) {
1676                    return getPersistence()
1677                                       .fetchByC_S_First(companyId, status, orderByComparator);
1678            }
1679    
1680            /**
1681            * Returns the last user in the ordered set where companyId = &#63; and status = &#63;.
1682            *
1683            * @param companyId the company ID
1684            * @param status the status
1685            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1686            * @return the last matching user
1687            * @throws NoSuchUserException if a matching user could not be found
1688            */
1689            public static User findByC_S_Last(long companyId, int status,
1690                    OrderByComparator<User> orderByComparator)
1691                    throws com.liferay.portal.exception.NoSuchUserException {
1692                    return getPersistence()
1693                                       .findByC_S_Last(companyId, status, orderByComparator);
1694            }
1695    
1696            /**
1697            * Returns the last user in the ordered set where companyId = &#63; and status = &#63;.
1698            *
1699            * @param companyId the company ID
1700            * @param status the status
1701            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1702            * @return the last matching user, or <code>null</code> if a matching user could not be found
1703            */
1704            public static User fetchByC_S_Last(long companyId, int status,
1705                    OrderByComparator<User> orderByComparator) {
1706                    return getPersistence()
1707                                       .fetchByC_S_Last(companyId, status, orderByComparator);
1708            }
1709    
1710            /**
1711            * Returns the users before and after the current user in the ordered set where companyId = &#63; and status = &#63;.
1712            *
1713            * @param userId the primary key of the current user
1714            * @param companyId the company ID
1715            * @param status the status
1716            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1717            * @return the previous, current, and next user
1718            * @throws NoSuchUserException if a user with the primary key could not be found
1719            */
1720            public static User[] findByC_S_PrevAndNext(long userId, long companyId,
1721                    int status, OrderByComparator<User> orderByComparator)
1722                    throws com.liferay.portal.exception.NoSuchUserException {
1723                    return getPersistence()
1724                                       .findByC_S_PrevAndNext(userId, companyId, status,
1725                            orderByComparator);
1726            }
1727    
1728            /**
1729            * Removes all the users where companyId = &#63; and status = &#63; from the database.
1730            *
1731            * @param companyId the company ID
1732            * @param status the status
1733            */
1734            public static void removeByC_S(long companyId, int status) {
1735                    getPersistence().removeByC_S(companyId, status);
1736            }
1737    
1738            /**
1739            * Returns the number of users where companyId = &#63; and status = &#63;.
1740            *
1741            * @param companyId the company ID
1742            * @param status the status
1743            * @return the number of matching users
1744            */
1745            public static int countByC_S(long companyId, int status) {
1746                    return getPersistence().countByC_S(companyId, status);
1747            }
1748    
1749            /**
1750            * Returns all the users where companyId = &#63; and createDate = &#63; and modifiedDate = &#63;.
1751            *
1752            * @param companyId the company ID
1753            * @param createDate the create date
1754            * @param modifiedDate the modified date
1755            * @return the matching users
1756            */
1757            public static List<User> findByC_CD_MD(long companyId,
1758                    java.util.Date createDate, java.util.Date modifiedDate) {
1759                    return getPersistence()
1760                                       .findByC_CD_MD(companyId, createDate, modifiedDate);
1761            }
1762    
1763            /**
1764            * Returns a range of all the users where companyId = &#63; and createDate = &#63; and modifiedDate = &#63;.
1765            *
1766            * <p>
1767            * 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 UserModelImpl}. 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.
1768            * </p>
1769            *
1770            * @param companyId the company ID
1771            * @param createDate the create date
1772            * @param modifiedDate the modified date
1773            * @param start the lower bound of the range of users
1774            * @param end the upper bound of the range of users (not inclusive)
1775            * @return the range of matching users
1776            */
1777            public static List<User> findByC_CD_MD(long companyId,
1778                    java.util.Date createDate, java.util.Date modifiedDate, int start,
1779                    int end) {
1780                    return getPersistence()
1781                                       .findByC_CD_MD(companyId, createDate, modifiedDate, start,
1782                            end);
1783            }
1784    
1785            /**
1786            * Returns an ordered range of all the users where companyId = &#63; and createDate = &#63; and modifiedDate = &#63;.
1787            *
1788            * <p>
1789            * 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 UserModelImpl}. 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.
1790            * </p>
1791            *
1792            * @param companyId the company ID
1793            * @param createDate the create date
1794            * @param modifiedDate the modified date
1795            * @param start the lower bound of the range of users
1796            * @param end the upper bound of the range of users (not inclusive)
1797            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1798            * @return the ordered range of matching users
1799            */
1800            public static List<User> findByC_CD_MD(long companyId,
1801                    java.util.Date createDate, java.util.Date modifiedDate, int start,
1802                    int end, OrderByComparator<User> orderByComparator) {
1803                    return getPersistence()
1804                                       .findByC_CD_MD(companyId, createDate, modifiedDate, start,
1805                            end, orderByComparator);
1806            }
1807    
1808            /**
1809            * Returns an ordered range of all the users where companyId = &#63; and createDate = &#63; and modifiedDate = &#63;.
1810            *
1811            * <p>
1812            * 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 UserModelImpl}. 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.
1813            * </p>
1814            *
1815            * @param companyId the company ID
1816            * @param createDate the create date
1817            * @param modifiedDate the modified date
1818            * @param start the lower bound of the range of users
1819            * @param end the upper bound of the range of users (not inclusive)
1820            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1821            * @param retrieveFromCache whether to retrieve from the finder cache
1822            * @return the ordered range of matching users
1823            */
1824            public static List<User> findByC_CD_MD(long companyId,
1825                    java.util.Date createDate, java.util.Date modifiedDate, int start,
1826                    int end, OrderByComparator<User> orderByComparator,
1827                    boolean retrieveFromCache) {
1828                    return getPersistence()
1829                                       .findByC_CD_MD(companyId, createDate, modifiedDate, start,
1830                            end, orderByComparator, retrieveFromCache);
1831            }
1832    
1833            /**
1834            * Returns the first user in the ordered set where companyId = &#63; and createDate = &#63; and modifiedDate = &#63;.
1835            *
1836            * @param companyId the company ID
1837            * @param createDate the create date
1838            * @param modifiedDate the modified date
1839            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1840            * @return the first matching user
1841            * @throws NoSuchUserException if a matching user could not be found
1842            */
1843            public static User findByC_CD_MD_First(long companyId,
1844                    java.util.Date createDate, java.util.Date modifiedDate,
1845                    OrderByComparator<User> orderByComparator)
1846                    throws com.liferay.portal.exception.NoSuchUserException {
1847                    return getPersistence()
1848                                       .findByC_CD_MD_First(companyId, createDate, modifiedDate,
1849                            orderByComparator);
1850            }
1851    
1852            /**
1853            * Returns the first user in the ordered set where companyId = &#63; and createDate = &#63; and modifiedDate = &#63;.
1854            *
1855            * @param companyId the company ID
1856            * @param createDate the create date
1857            * @param modifiedDate the modified date
1858            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1859            * @return the first matching user, or <code>null</code> if a matching user could not be found
1860            */
1861            public static User fetchByC_CD_MD_First(long companyId,
1862                    java.util.Date createDate, java.util.Date modifiedDate,
1863                    OrderByComparator<User> orderByComparator) {
1864                    return getPersistence()
1865                                       .fetchByC_CD_MD_First(companyId, createDate, modifiedDate,
1866                            orderByComparator);
1867            }
1868    
1869            /**
1870            * Returns the last user in the ordered set where companyId = &#63; and createDate = &#63; and modifiedDate = &#63;.
1871            *
1872            * @param companyId the company ID
1873            * @param createDate the create date
1874            * @param modifiedDate the modified date
1875            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1876            * @return the last matching user
1877            * @throws NoSuchUserException if a matching user could not be found
1878            */
1879            public static User findByC_CD_MD_Last(long companyId,
1880                    java.util.Date createDate, java.util.Date modifiedDate,
1881                    OrderByComparator<User> orderByComparator)
1882                    throws com.liferay.portal.exception.NoSuchUserException {
1883                    return getPersistence()
1884                                       .findByC_CD_MD_Last(companyId, createDate, modifiedDate,
1885                            orderByComparator);
1886            }
1887    
1888            /**
1889            * Returns the last user in the ordered set where companyId = &#63; and createDate = &#63; and modifiedDate = &#63;.
1890            *
1891            * @param companyId the company ID
1892            * @param createDate the create date
1893            * @param modifiedDate the modified date
1894            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1895            * @return the last matching user, or <code>null</code> if a matching user could not be found
1896            */
1897            public static User fetchByC_CD_MD_Last(long companyId,
1898                    java.util.Date createDate, java.util.Date modifiedDate,
1899                    OrderByComparator<User> orderByComparator) {
1900                    return getPersistence()
1901                                       .fetchByC_CD_MD_Last(companyId, createDate, modifiedDate,
1902                            orderByComparator);
1903            }
1904    
1905            /**
1906            * Returns the users before and after the current user in the ordered set where companyId = &#63; and createDate = &#63; and modifiedDate = &#63;.
1907            *
1908            * @param userId the primary key of the current user
1909            * @param companyId the company ID
1910            * @param createDate the create date
1911            * @param modifiedDate the modified date
1912            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1913            * @return the previous, current, and next user
1914            * @throws NoSuchUserException if a user with the primary key could not be found
1915            */
1916            public static User[] findByC_CD_MD_PrevAndNext(long userId, long companyId,
1917                    java.util.Date createDate, java.util.Date modifiedDate,
1918                    OrderByComparator<User> orderByComparator)
1919                    throws com.liferay.portal.exception.NoSuchUserException {
1920                    return getPersistence()
1921                                       .findByC_CD_MD_PrevAndNext(userId, companyId, createDate,
1922                            modifiedDate, orderByComparator);
1923            }
1924    
1925            /**
1926            * Removes all the users where companyId = &#63; and createDate = &#63; and modifiedDate = &#63; from the database.
1927            *
1928            * @param companyId the company ID
1929            * @param createDate the create date
1930            * @param modifiedDate the modified date
1931            */
1932            public static void removeByC_CD_MD(long companyId,
1933                    java.util.Date createDate, java.util.Date modifiedDate) {
1934                    getPersistence().removeByC_CD_MD(companyId, createDate, modifiedDate);
1935            }
1936    
1937            /**
1938            * Returns the number of users where companyId = &#63; and createDate = &#63; and modifiedDate = &#63;.
1939            *
1940            * @param companyId the company ID
1941            * @param createDate the create date
1942            * @param modifiedDate the modified date
1943            * @return the number of matching users
1944            */
1945            public static int countByC_CD_MD(long companyId, java.util.Date createDate,
1946                    java.util.Date modifiedDate) {
1947                    return getPersistence()
1948                                       .countByC_CD_MD(companyId, createDate, modifiedDate);
1949            }
1950    
1951            /**
1952            * Returns all the users where companyId = &#63; and defaultUser = &#63; and status = &#63;.
1953            *
1954            * @param companyId the company ID
1955            * @param defaultUser the default user
1956            * @param status the status
1957            * @return the matching users
1958            */
1959            public static List<User> findByC_DU_S(long companyId, boolean defaultUser,
1960                    int status) {
1961                    return getPersistence().findByC_DU_S(companyId, defaultUser, status);
1962            }
1963    
1964            /**
1965            * Returns a range of all the users where companyId = &#63; and defaultUser = &#63; and status = &#63;.
1966            *
1967            * <p>
1968            * 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 UserModelImpl}. 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.
1969            * </p>
1970            *
1971            * @param companyId the company ID
1972            * @param defaultUser the default user
1973            * @param status the status
1974            * @param start the lower bound of the range of users
1975            * @param end the upper bound of the range of users (not inclusive)
1976            * @return the range of matching users
1977            */
1978            public static List<User> findByC_DU_S(long companyId, boolean defaultUser,
1979                    int status, int start, int end) {
1980                    return getPersistence()
1981                                       .findByC_DU_S(companyId, defaultUser, status, start, end);
1982            }
1983    
1984            /**
1985            * Returns an ordered range of all the users where companyId = &#63; and defaultUser = &#63; and status = &#63;.
1986            *
1987            * <p>
1988            * 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 UserModelImpl}. 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.
1989            * </p>
1990            *
1991            * @param companyId the company ID
1992            * @param defaultUser the default user
1993            * @param status the status
1994            * @param start the lower bound of the range of users
1995            * @param end the upper bound of the range of users (not inclusive)
1996            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1997            * @return the ordered range of matching users
1998            */
1999            public static List<User> findByC_DU_S(long companyId, boolean defaultUser,
2000                    int status, int start, int end,
2001                    OrderByComparator<User> orderByComparator) {
2002                    return getPersistence()
2003                                       .findByC_DU_S(companyId, defaultUser, status, start, end,
2004                            orderByComparator);
2005            }
2006    
2007            /**
2008            * Returns an ordered range of all the users where companyId = &#63; and defaultUser = &#63; and status = &#63;.
2009            *
2010            * <p>
2011            * 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 UserModelImpl}. 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.
2012            * </p>
2013            *
2014            * @param companyId the company ID
2015            * @param defaultUser the default user
2016            * @param status the status
2017            * @param start the lower bound of the range of users
2018            * @param end the upper bound of the range of users (not inclusive)
2019            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2020            * @param retrieveFromCache whether to retrieve from the finder cache
2021            * @return the ordered range of matching users
2022            */
2023            public static List<User> findByC_DU_S(long companyId, boolean defaultUser,
2024                    int status, int start, int end,
2025                    OrderByComparator<User> orderByComparator, boolean retrieveFromCache) {
2026                    return getPersistence()
2027                                       .findByC_DU_S(companyId, defaultUser, status, start, end,
2028                            orderByComparator, retrieveFromCache);
2029            }
2030    
2031            /**
2032            * Returns the first user in the ordered set where companyId = &#63; and defaultUser = &#63; and status = &#63;.
2033            *
2034            * @param companyId the company ID
2035            * @param defaultUser the default user
2036            * @param status the status
2037            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2038            * @return the first matching user
2039            * @throws NoSuchUserException if a matching user could not be found
2040            */
2041            public static User findByC_DU_S_First(long companyId, boolean defaultUser,
2042                    int status, OrderByComparator<User> orderByComparator)
2043                    throws com.liferay.portal.exception.NoSuchUserException {
2044                    return getPersistence()
2045                                       .findByC_DU_S_First(companyId, defaultUser, status,
2046                            orderByComparator);
2047            }
2048    
2049            /**
2050            * Returns the first user in the ordered set where companyId = &#63; and defaultUser = &#63; and status = &#63;.
2051            *
2052            * @param companyId the company ID
2053            * @param defaultUser the default user
2054            * @param status the status
2055            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2056            * @return the first matching user, or <code>null</code> if a matching user could not be found
2057            */
2058            public static User fetchByC_DU_S_First(long companyId, boolean defaultUser,
2059                    int status, OrderByComparator<User> orderByComparator) {
2060                    return getPersistence()
2061                                       .fetchByC_DU_S_First(companyId, defaultUser, status,
2062                            orderByComparator);
2063            }
2064    
2065            /**
2066            * Returns the last user in the ordered set where companyId = &#63; and defaultUser = &#63; and status = &#63;.
2067            *
2068            * @param companyId the company ID
2069            * @param defaultUser the default user
2070            * @param status the status
2071            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2072            * @return the last matching user
2073            * @throws NoSuchUserException if a matching user could not be found
2074            */
2075            public static User findByC_DU_S_Last(long companyId, boolean defaultUser,
2076                    int status, OrderByComparator<User> orderByComparator)
2077                    throws com.liferay.portal.exception.NoSuchUserException {
2078                    return getPersistence()
2079                                       .findByC_DU_S_Last(companyId, defaultUser, status,
2080                            orderByComparator);
2081            }
2082    
2083            /**
2084            * Returns the last user in the ordered set where companyId = &#63; and defaultUser = &#63; and status = &#63;.
2085            *
2086            * @param companyId the company ID
2087            * @param defaultUser the default user
2088            * @param status the status
2089            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2090            * @return the last matching user, or <code>null</code> if a matching user could not be found
2091            */
2092            public static User fetchByC_DU_S_Last(long companyId, boolean defaultUser,
2093                    int status, OrderByComparator<User> orderByComparator) {
2094                    return getPersistence()
2095                                       .fetchByC_DU_S_Last(companyId, defaultUser, status,
2096                            orderByComparator);
2097            }
2098    
2099            /**
2100            * Returns the users before and after the current user in the ordered set where companyId = &#63; and defaultUser = &#63; and status = &#63;.
2101            *
2102            * @param userId the primary key of the current user
2103            * @param companyId the company ID
2104            * @param defaultUser the default user
2105            * @param status the status
2106            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2107            * @return the previous, current, and next user
2108            * @throws NoSuchUserException if a user with the primary key could not be found
2109            */
2110            public static User[] findByC_DU_S_PrevAndNext(long userId, long companyId,
2111                    boolean defaultUser, int status,
2112                    OrderByComparator<User> orderByComparator)
2113                    throws com.liferay.portal.exception.NoSuchUserException {
2114                    return getPersistence()
2115                                       .findByC_DU_S_PrevAndNext(userId, companyId, defaultUser,
2116                            status, orderByComparator);
2117            }
2118    
2119            /**
2120            * Removes all the users where companyId = &#63; and defaultUser = &#63; and status = &#63; from the database.
2121            *
2122            * @param companyId the company ID
2123            * @param defaultUser the default user
2124            * @param status the status
2125            */
2126            public static void removeByC_DU_S(long companyId, boolean defaultUser,
2127                    int status) {
2128                    getPersistence().removeByC_DU_S(companyId, defaultUser, status);
2129            }
2130    
2131            /**
2132            * Returns the number of users where companyId = &#63; and defaultUser = &#63; and status = &#63;.
2133            *
2134            * @param companyId the company ID
2135            * @param defaultUser the default user
2136            * @param status the status
2137            * @return the number of matching users
2138            */
2139            public static int countByC_DU_S(long companyId, boolean defaultUser,
2140                    int status) {
2141                    return getPersistence().countByC_DU_S(companyId, defaultUser, status);
2142            }
2143    
2144            /**
2145            * Caches the user in the entity cache if it is enabled.
2146            *
2147            * @param user the user
2148            */
2149            public static void cacheResult(User user) {
2150                    getPersistence().cacheResult(user);
2151            }
2152    
2153            /**
2154            * Caches the users in the entity cache if it is enabled.
2155            *
2156            * @param users the users
2157            */
2158            public static void cacheResult(List<User> users) {
2159                    getPersistence().cacheResult(users);
2160            }
2161    
2162            /**
2163            * Creates a new user with the primary key. Does not add the user to the database.
2164            *
2165            * @param userId the primary key for the new user
2166            * @return the new user
2167            */
2168            public static User create(long userId) {
2169                    return getPersistence().create(userId);
2170            }
2171    
2172            /**
2173            * Removes the user with the primary key from the database. Also notifies the appropriate model listeners.
2174            *
2175            * @param userId the primary key of the user
2176            * @return the user that was removed
2177            * @throws NoSuchUserException if a user with the primary key could not be found
2178            */
2179            public static User remove(long userId)
2180                    throws com.liferay.portal.exception.NoSuchUserException {
2181                    return getPersistence().remove(userId);
2182            }
2183    
2184            public static User updateImpl(User user) {
2185                    return getPersistence().updateImpl(user);
2186            }
2187    
2188            /**
2189            * Returns the user with the primary key or throws a {@link NoSuchUserException} if it could not be found.
2190            *
2191            * @param userId the primary key of the user
2192            * @return the user
2193            * @throws NoSuchUserException if a user with the primary key could not be found
2194            */
2195            public static User findByPrimaryKey(long userId)
2196                    throws com.liferay.portal.exception.NoSuchUserException {
2197                    return getPersistence().findByPrimaryKey(userId);
2198            }
2199    
2200            /**
2201            * Returns the user with the primary key or returns <code>null</code> if it could not be found.
2202            *
2203            * @param userId the primary key of the user
2204            * @return the user, or <code>null</code> if a user with the primary key could not be found
2205            */
2206            public static User fetchByPrimaryKey(long userId) {
2207                    return getPersistence().fetchByPrimaryKey(userId);
2208            }
2209    
2210            public static java.util.Map<java.io.Serializable, User> fetchByPrimaryKeys(
2211                    java.util.Set<java.io.Serializable> primaryKeys) {
2212                    return getPersistence().fetchByPrimaryKeys(primaryKeys);
2213            }
2214    
2215            /**
2216            * Returns all the users.
2217            *
2218            * @return the users
2219            */
2220            public static List<User> findAll() {
2221                    return getPersistence().findAll();
2222            }
2223    
2224            /**
2225            * Returns a range of all the users.
2226            *
2227            * <p>
2228            * 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 UserModelImpl}. 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.
2229            * </p>
2230            *
2231            * @param start the lower bound of the range of users
2232            * @param end the upper bound of the range of users (not inclusive)
2233            * @return the range of users
2234            */
2235            public static List<User> findAll(int start, int end) {
2236                    return getPersistence().findAll(start, end);
2237            }
2238    
2239            /**
2240            * Returns an ordered range of all the users.
2241            *
2242            * <p>
2243            * 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 UserModelImpl}. 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.
2244            * </p>
2245            *
2246            * @param start the lower bound of the range of users
2247            * @param end the upper bound of the range of users (not inclusive)
2248            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2249            * @return the ordered range of users
2250            */
2251            public static List<User> findAll(int start, int end,
2252                    OrderByComparator<User> orderByComparator) {
2253                    return getPersistence().findAll(start, end, orderByComparator);
2254            }
2255    
2256            /**
2257            * Returns an ordered range of all the users.
2258            *
2259            * <p>
2260            * 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 UserModelImpl}. 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.
2261            * </p>
2262            *
2263            * @param start the lower bound of the range of users
2264            * @param end the upper bound of the range of users (not inclusive)
2265            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2266            * @param retrieveFromCache whether to retrieve from the finder cache
2267            * @return the ordered range of users
2268            */
2269            public static List<User> findAll(int start, int end,
2270                    OrderByComparator<User> orderByComparator, boolean retrieveFromCache) {
2271                    return getPersistence()
2272                                       .findAll(start, end, orderByComparator, retrieveFromCache);
2273            }
2274    
2275            /**
2276            * Removes all the users from the database.
2277            */
2278            public static void removeAll() {
2279                    getPersistence().removeAll();
2280            }
2281    
2282            /**
2283            * Returns the number of users.
2284            *
2285            * @return the number of users
2286            */
2287            public static int countAll() {
2288                    return getPersistence().countAll();
2289            }
2290    
2291            /**
2292            * Returns the primaryKeys of groups associated with the user.
2293            *
2294            * @param pk the primary key of the user
2295            * @return long[] of the primaryKeys of groups associated with the user
2296            */
2297            public static long[] getGroupPrimaryKeys(long pk) {
2298                    return getPersistence().getGroupPrimaryKeys(pk);
2299            }
2300    
2301            /**
2302            * Returns all the groups associated with the user.
2303            *
2304            * @param pk the primary key of the user
2305            * @return the groups associated with the user
2306            */
2307            public static List<com.liferay.portal.model.Group> getGroups(long pk) {
2308                    return getPersistence().getGroups(pk);
2309            }
2310    
2311            /**
2312            * Returns a range of all the groups associated with the user.
2313            *
2314            * <p>
2315            * 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 UserModelImpl}. 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.
2316            * </p>
2317            *
2318            * @param pk the primary key of the user
2319            * @param start the lower bound of the range of users
2320            * @param end the upper bound of the range of users (not inclusive)
2321            * @return the range of groups associated with the user
2322            */
2323            public static List<com.liferay.portal.model.Group> getGroups(long pk,
2324                    int start, int end) {
2325                    return getPersistence().getGroups(pk, start, end);
2326            }
2327    
2328            /**
2329            * Returns an ordered range of all the groups associated with the user.
2330            *
2331            * <p>
2332            * 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 UserModelImpl}. 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.
2333            * </p>
2334            *
2335            * @param pk the primary key of the user
2336            * @param start the lower bound of the range of users
2337            * @param end the upper bound of the range of users (not inclusive)
2338            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2339            * @return the ordered range of groups associated with the user
2340            */
2341            public static List<com.liferay.portal.model.Group> getGroups(long pk,
2342                    int start, int end,
2343                    OrderByComparator<com.liferay.portal.model.Group> orderByComparator) {
2344                    return getPersistence().getGroups(pk, start, end, orderByComparator);
2345            }
2346    
2347            /**
2348            * Returns the number of groups associated with the user.
2349            *
2350            * @param pk the primary key of the user
2351            * @return the number of groups associated with the user
2352            */
2353            public static int getGroupsSize(long pk) {
2354                    return getPersistence().getGroupsSize(pk);
2355            }
2356    
2357            /**
2358            * Returns <code>true</code> if the group is associated with the user.
2359            *
2360            * @param pk the primary key of the user
2361            * @param groupPK the primary key of the group
2362            * @return <code>true</code> if the group is associated with the user; <code>false</code> otherwise
2363            */
2364            public static boolean containsGroup(long pk, long groupPK) {
2365                    return getPersistence().containsGroup(pk, groupPK);
2366            }
2367    
2368            /**
2369            * Returns <code>true</code> if the user has any groups associated with it.
2370            *
2371            * @param pk the primary key of the user to check for associations with groups
2372            * @return <code>true</code> if the user has any groups associated with it; <code>false</code> otherwise
2373            */
2374            public static boolean containsGroups(long pk) {
2375                    return getPersistence().containsGroups(pk);
2376            }
2377    
2378            /**
2379            * Adds an association between the user and the group. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2380            *
2381            * @param pk the primary key of the user
2382            * @param groupPK the primary key of the group
2383            */
2384            public static void addGroup(long pk, long groupPK) {
2385                    getPersistence().addGroup(pk, groupPK);
2386            }
2387    
2388            /**
2389            * Adds an association between the user and the group. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2390            *
2391            * @param pk the primary key of the user
2392            * @param group the group
2393            */
2394            public static void addGroup(long pk, com.liferay.portal.model.Group group) {
2395                    getPersistence().addGroup(pk, group);
2396            }
2397    
2398            /**
2399            * Adds an association between the user and the groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2400            *
2401            * @param pk the primary key of the user
2402            * @param groupPKs the primary keys of the groups
2403            */
2404            public static void addGroups(long pk, long[] groupPKs) {
2405                    getPersistence().addGroups(pk, groupPKs);
2406            }
2407    
2408            /**
2409            * Adds an association between the user and the groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2410            *
2411            * @param pk the primary key of the user
2412            * @param groups the groups
2413            */
2414            public static void addGroups(long pk,
2415                    List<com.liferay.portal.model.Group> groups) {
2416                    getPersistence().addGroups(pk, groups);
2417            }
2418    
2419            /**
2420            * Clears all associations between the user and its groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2421            *
2422            * @param pk the primary key of the user to clear the associated groups from
2423            */
2424            public static void clearGroups(long pk) {
2425                    getPersistence().clearGroups(pk);
2426            }
2427    
2428            /**
2429            * Removes the association between the user and the group. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2430            *
2431            * @param pk the primary key of the user
2432            * @param groupPK the primary key of the group
2433            */
2434            public static void removeGroup(long pk, long groupPK) {
2435                    getPersistence().removeGroup(pk, groupPK);
2436            }
2437    
2438            /**
2439            * Removes the association between the user and the group. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2440            *
2441            * @param pk the primary key of the user
2442            * @param group the group
2443            */
2444            public static void removeGroup(long pk, com.liferay.portal.model.Group group) {
2445                    getPersistence().removeGroup(pk, group);
2446            }
2447    
2448            /**
2449            * Removes the association between the user and the groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2450            *
2451            * @param pk the primary key of the user
2452            * @param groupPKs the primary keys of the groups
2453            */
2454            public static void removeGroups(long pk, long[] groupPKs) {
2455                    getPersistence().removeGroups(pk, groupPKs);
2456            }
2457    
2458            /**
2459            * Removes the association between the user and the groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2460            *
2461            * @param pk the primary key of the user
2462            * @param groups the groups
2463            */
2464            public static void removeGroups(long pk,
2465                    List<com.liferay.portal.model.Group> groups) {
2466                    getPersistence().removeGroups(pk, groups);
2467            }
2468    
2469            /**
2470            * Sets the groups associated with the user, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2471            *
2472            * @param pk the primary key of the user
2473            * @param groupPKs the primary keys of the groups to be associated with the user
2474            */
2475            public static void setGroups(long pk, long[] groupPKs) {
2476                    getPersistence().setGroups(pk, groupPKs);
2477            }
2478    
2479            /**
2480            * Sets the groups associated with the user, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2481            *
2482            * @param pk the primary key of the user
2483            * @param groups the groups to be associated with the user
2484            */
2485            public static void setGroups(long pk,
2486                    List<com.liferay.portal.model.Group> groups) {
2487                    getPersistence().setGroups(pk, groups);
2488            }
2489    
2490            /**
2491            * Returns the primaryKeys of organizations associated with the user.
2492            *
2493            * @param pk the primary key of the user
2494            * @return long[] of the primaryKeys of organizations associated with the user
2495            */
2496            public static long[] getOrganizationPrimaryKeys(long pk) {
2497                    return getPersistence().getOrganizationPrimaryKeys(pk);
2498            }
2499    
2500            /**
2501            * Returns all the organizations associated with the user.
2502            *
2503            * @param pk the primary key of the user
2504            * @return the organizations associated with the user
2505            */
2506            public static List<com.liferay.portal.model.Organization> getOrganizations(
2507                    long pk) {
2508                    return getPersistence().getOrganizations(pk);
2509            }
2510    
2511            /**
2512            * Returns a range of all the organizations associated with the user.
2513            *
2514            * <p>
2515            * 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 UserModelImpl}. 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.
2516            * </p>
2517            *
2518            * @param pk the primary key of the user
2519            * @param start the lower bound of the range of users
2520            * @param end the upper bound of the range of users (not inclusive)
2521            * @return the range of organizations associated with the user
2522            */
2523            public static List<com.liferay.portal.model.Organization> getOrganizations(
2524                    long pk, int start, int end) {
2525                    return getPersistence().getOrganizations(pk, start, end);
2526            }
2527    
2528            /**
2529            * Returns an ordered range of all the organizations associated with the user.
2530            *
2531            * <p>
2532            * 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 UserModelImpl}. 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.
2533            * </p>
2534            *
2535            * @param pk the primary key of the user
2536            * @param start the lower bound of the range of users
2537            * @param end the upper bound of the range of users (not inclusive)
2538            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2539            * @return the ordered range of organizations associated with the user
2540            */
2541            public static List<com.liferay.portal.model.Organization> getOrganizations(
2542                    long pk, int start, int end,
2543                    OrderByComparator<com.liferay.portal.model.Organization> orderByComparator) {
2544                    return getPersistence()
2545                                       .getOrganizations(pk, start, end, orderByComparator);
2546            }
2547    
2548            /**
2549            * Returns the number of organizations associated with the user.
2550            *
2551            * @param pk the primary key of the user
2552            * @return the number of organizations associated with the user
2553            */
2554            public static int getOrganizationsSize(long pk) {
2555                    return getPersistence().getOrganizationsSize(pk);
2556            }
2557    
2558            /**
2559            * Returns <code>true</code> if the organization is associated with the user.
2560            *
2561            * @param pk the primary key of the user
2562            * @param organizationPK the primary key of the organization
2563            * @return <code>true</code> if the organization is associated with the user; <code>false</code> otherwise
2564            */
2565            public static boolean containsOrganization(long pk, long organizationPK) {
2566                    return getPersistence().containsOrganization(pk, organizationPK);
2567            }
2568    
2569            /**
2570            * Returns <code>true</code> if the user has any organizations associated with it.
2571            *
2572            * @param pk the primary key of the user to check for associations with organizations
2573            * @return <code>true</code> if the user has any organizations associated with it; <code>false</code> otherwise
2574            */
2575            public static boolean containsOrganizations(long pk) {
2576                    return getPersistence().containsOrganizations(pk);
2577            }
2578    
2579            /**
2580            * Adds an association between the user and the organization. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2581            *
2582            * @param pk the primary key of the user
2583            * @param organizationPK the primary key of the organization
2584            */
2585            public static void addOrganization(long pk, long organizationPK) {
2586                    getPersistence().addOrganization(pk, organizationPK);
2587            }
2588    
2589            /**
2590            * Adds an association between the user and the organization. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2591            *
2592            * @param pk the primary key of the user
2593            * @param organization the organization
2594            */
2595            public static void addOrganization(long pk,
2596                    com.liferay.portal.model.Organization organization) {
2597                    getPersistence().addOrganization(pk, organization);
2598            }
2599    
2600            /**
2601            * Adds an association between the user and the organizations. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2602            *
2603            * @param pk the primary key of the user
2604            * @param organizationPKs the primary keys of the organizations
2605            */
2606            public static void addOrganizations(long pk, long[] organizationPKs) {
2607                    getPersistence().addOrganizations(pk, organizationPKs);
2608            }
2609    
2610            /**
2611            * Adds an association between the user and the organizations. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2612            *
2613            * @param pk the primary key of the user
2614            * @param organizations the organizations
2615            */
2616            public static void addOrganizations(long pk,
2617                    List<com.liferay.portal.model.Organization> organizations) {
2618                    getPersistence().addOrganizations(pk, organizations);
2619            }
2620    
2621            /**
2622            * Clears all associations between the user and its organizations. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2623            *
2624            * @param pk the primary key of the user to clear the associated organizations from
2625            */
2626            public static void clearOrganizations(long pk) {
2627                    getPersistence().clearOrganizations(pk);
2628            }
2629    
2630            /**
2631            * Removes the association between the user and the organization. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2632            *
2633            * @param pk the primary key of the user
2634            * @param organizationPK the primary key of the organization
2635            */
2636            public static void removeOrganization(long pk, long organizationPK) {
2637                    getPersistence().removeOrganization(pk, organizationPK);
2638            }
2639    
2640            /**
2641            * Removes the association between the user and the organization. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2642            *
2643            * @param pk the primary key of the user
2644            * @param organization the organization
2645            */
2646            public static void removeOrganization(long pk,
2647                    com.liferay.portal.model.Organization organization) {
2648                    getPersistence().removeOrganization(pk, organization);
2649            }
2650    
2651            /**
2652            * Removes the association between the user and the organizations. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2653            *
2654            * @param pk the primary key of the user
2655            * @param organizationPKs the primary keys of the organizations
2656            */
2657            public static void removeOrganizations(long pk, long[] organizationPKs) {
2658                    getPersistence().removeOrganizations(pk, organizationPKs);
2659            }
2660    
2661            /**
2662            * Removes the association between the user and the organizations. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2663            *
2664            * @param pk the primary key of the user
2665            * @param organizations the organizations
2666            */
2667            public static void removeOrganizations(long pk,
2668                    List<com.liferay.portal.model.Organization> organizations) {
2669                    getPersistence().removeOrganizations(pk, organizations);
2670            }
2671    
2672            /**
2673            * Sets the organizations associated with the user, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2674            *
2675            * @param pk the primary key of the user
2676            * @param organizationPKs the primary keys of the organizations to be associated with the user
2677            */
2678            public static void setOrganizations(long pk, long[] organizationPKs) {
2679                    getPersistence().setOrganizations(pk, organizationPKs);
2680            }
2681    
2682            /**
2683            * Sets the organizations associated with the user, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2684            *
2685            * @param pk the primary key of the user
2686            * @param organizations the organizations to be associated with the user
2687            */
2688            public static void setOrganizations(long pk,
2689                    List<com.liferay.portal.model.Organization> organizations) {
2690                    getPersistence().setOrganizations(pk, organizations);
2691            }
2692    
2693            /**
2694            * Returns the primaryKeys of roles associated with the user.
2695            *
2696            * @param pk the primary key of the user
2697            * @return long[] of the primaryKeys of roles associated with the user
2698            */
2699            public static long[] getRolePrimaryKeys(long pk) {
2700                    return getPersistence().getRolePrimaryKeys(pk);
2701            }
2702    
2703            /**
2704            * Returns all the roles associated with the user.
2705            *
2706            * @param pk the primary key of the user
2707            * @return the roles associated with the user
2708            */
2709            public static List<com.liferay.portal.model.Role> getRoles(long pk) {
2710                    return getPersistence().getRoles(pk);
2711            }
2712    
2713            /**
2714            * Returns a range of all the roles associated with the user.
2715            *
2716            * <p>
2717            * 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 UserModelImpl}. 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.
2718            * </p>
2719            *
2720            * @param pk the primary key of the user
2721            * @param start the lower bound of the range of users
2722            * @param end the upper bound of the range of users (not inclusive)
2723            * @return the range of roles associated with the user
2724            */
2725            public static List<com.liferay.portal.model.Role> getRoles(long pk,
2726                    int start, int end) {
2727                    return getPersistence().getRoles(pk, start, end);
2728            }
2729    
2730            /**
2731            * Returns an ordered range of all the roles associated with the user.
2732            *
2733            * <p>
2734            * 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 UserModelImpl}. 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.
2735            * </p>
2736            *
2737            * @param pk the primary key of the user
2738            * @param start the lower bound of the range of users
2739            * @param end the upper bound of the range of users (not inclusive)
2740            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2741            * @return the ordered range of roles associated with the user
2742            */
2743            public static List<com.liferay.portal.model.Role> getRoles(long pk,
2744                    int start, int end,
2745                    OrderByComparator<com.liferay.portal.model.Role> orderByComparator) {
2746                    return getPersistence().getRoles(pk, start, end, orderByComparator);
2747            }
2748    
2749            /**
2750            * Returns the number of roles associated with the user.
2751            *
2752            * @param pk the primary key of the user
2753            * @return the number of roles associated with the user
2754            */
2755            public static int getRolesSize(long pk) {
2756                    return getPersistence().getRolesSize(pk);
2757            }
2758    
2759            /**
2760            * Returns <code>true</code> if the role is associated with the user.
2761            *
2762            * @param pk the primary key of the user
2763            * @param rolePK the primary key of the role
2764            * @return <code>true</code> if the role is associated with the user; <code>false</code> otherwise
2765            */
2766            public static boolean containsRole(long pk, long rolePK) {
2767                    return getPersistence().containsRole(pk, rolePK);
2768            }
2769    
2770            /**
2771            * Returns <code>true</code> if the user has any roles associated with it.
2772            *
2773            * @param pk the primary key of the user to check for associations with roles
2774            * @return <code>true</code> if the user has any roles associated with it; <code>false</code> otherwise
2775            */
2776            public static boolean containsRoles(long pk) {
2777                    return getPersistence().containsRoles(pk);
2778            }
2779    
2780            /**
2781            * Adds an association between the user and the role. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2782            *
2783            * @param pk the primary key of the user
2784            * @param rolePK the primary key of the role
2785            */
2786            public static void addRole(long pk, long rolePK) {
2787                    getPersistence().addRole(pk, rolePK);
2788            }
2789    
2790            /**
2791            * Adds an association between the user and the role. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2792            *
2793            * @param pk the primary key of the user
2794            * @param role the role
2795            */
2796            public static void addRole(long pk, com.liferay.portal.model.Role role) {
2797                    getPersistence().addRole(pk, role);
2798            }
2799    
2800            /**
2801            * Adds an association between the user and the roles. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2802            *
2803            * @param pk the primary key of the user
2804            * @param rolePKs the primary keys of the roles
2805            */
2806            public static void addRoles(long pk, long[] rolePKs) {
2807                    getPersistence().addRoles(pk, rolePKs);
2808            }
2809    
2810            /**
2811            * Adds an association between the user and the roles. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2812            *
2813            * @param pk the primary key of the user
2814            * @param roles the roles
2815            */
2816            public static void addRoles(long pk,
2817                    List<com.liferay.portal.model.Role> roles) {
2818                    getPersistence().addRoles(pk, roles);
2819            }
2820    
2821            /**
2822            * Clears all associations between the user and its roles. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2823            *
2824            * @param pk the primary key of the user to clear the associated roles from
2825            */
2826            public static void clearRoles(long pk) {
2827                    getPersistence().clearRoles(pk);
2828            }
2829    
2830            /**
2831            * Removes the association between the user and the role. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2832            *
2833            * @param pk the primary key of the user
2834            * @param rolePK the primary key of the role
2835            */
2836            public static void removeRole(long pk, long rolePK) {
2837                    getPersistence().removeRole(pk, rolePK);
2838            }
2839    
2840            /**
2841            * Removes the association between the user and the role. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2842            *
2843            * @param pk the primary key of the user
2844            * @param role the role
2845            */
2846            public static void removeRole(long pk, com.liferay.portal.model.Role role) {
2847                    getPersistence().removeRole(pk, role);
2848            }
2849    
2850            /**
2851            * Removes the association between the user and the roles. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2852            *
2853            * @param pk the primary key of the user
2854            * @param rolePKs the primary keys of the roles
2855            */
2856            public static void removeRoles(long pk, long[] rolePKs) {
2857                    getPersistence().removeRoles(pk, rolePKs);
2858            }
2859    
2860            /**
2861            * Removes the association between the user and the roles. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2862            *
2863            * @param pk the primary key of the user
2864            * @param roles the roles
2865            */
2866            public static void removeRoles(long pk,
2867                    List<com.liferay.portal.model.Role> roles) {
2868                    getPersistence().removeRoles(pk, roles);
2869            }
2870    
2871            /**
2872            * Sets the roles associated with the user, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2873            *
2874            * @param pk the primary key of the user
2875            * @param rolePKs the primary keys of the roles to be associated with the user
2876            */
2877            public static void setRoles(long pk, long[] rolePKs) {
2878                    getPersistence().setRoles(pk, rolePKs);
2879            }
2880    
2881            /**
2882            * Sets the roles associated with the user, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2883            *
2884            * @param pk the primary key of the user
2885            * @param roles the roles to be associated with the user
2886            */
2887            public static void setRoles(long pk,
2888                    List<com.liferay.portal.model.Role> roles) {
2889                    getPersistence().setRoles(pk, roles);
2890            }
2891    
2892            /**
2893            * Returns the primaryKeys of teams associated with the user.
2894            *
2895            * @param pk the primary key of the user
2896            * @return long[] of the primaryKeys of teams associated with the user
2897            */
2898            public static long[] getTeamPrimaryKeys(long pk) {
2899                    return getPersistence().getTeamPrimaryKeys(pk);
2900            }
2901    
2902            /**
2903            * Returns all the teams associated with the user.
2904            *
2905            * @param pk the primary key of the user
2906            * @return the teams associated with the user
2907            */
2908            public static List<com.liferay.portal.model.Team> getTeams(long pk) {
2909                    return getPersistence().getTeams(pk);
2910            }
2911    
2912            /**
2913            * Returns a range of all the teams associated with the user.
2914            *
2915            * <p>
2916            * 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 UserModelImpl}. 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.
2917            * </p>
2918            *
2919            * @param pk the primary key of the user
2920            * @param start the lower bound of the range of users
2921            * @param end the upper bound of the range of users (not inclusive)
2922            * @return the range of teams associated with the user
2923            */
2924            public static List<com.liferay.portal.model.Team> getTeams(long pk,
2925                    int start, int end) {
2926                    return getPersistence().getTeams(pk, start, end);
2927            }
2928    
2929            /**
2930            * Returns an ordered range of all the teams associated with the user.
2931            *
2932            * <p>
2933            * 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 UserModelImpl}. 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.
2934            * </p>
2935            *
2936            * @param pk the primary key of the user
2937            * @param start the lower bound of the range of users
2938            * @param end the upper bound of the range of users (not inclusive)
2939            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2940            * @return the ordered range of teams associated with the user
2941            */
2942            public static List<com.liferay.portal.model.Team> getTeams(long pk,
2943                    int start, int end,
2944                    OrderByComparator<com.liferay.portal.model.Team> orderByComparator) {
2945                    return getPersistence().getTeams(pk, start, end, orderByComparator);
2946            }
2947    
2948            /**
2949            * Returns the number of teams associated with the user.
2950            *
2951            * @param pk the primary key of the user
2952            * @return the number of teams associated with the user
2953            */
2954            public static int getTeamsSize(long pk) {
2955                    return getPersistence().getTeamsSize(pk);
2956            }
2957    
2958            /**
2959            * Returns <code>true</code> if the team is associated with the user.
2960            *
2961            * @param pk the primary key of the user
2962            * @param teamPK the primary key of the team
2963            * @return <code>true</code> if the team is associated with the user; <code>false</code> otherwise
2964            */
2965            public static boolean containsTeam(long pk, long teamPK) {
2966                    return getPersistence().containsTeam(pk, teamPK);
2967            }
2968    
2969            /**
2970            * Returns <code>true</code> if the user has any teams associated with it.
2971            *
2972            * @param pk the primary key of the user to check for associations with teams
2973            * @return <code>true</code> if the user has any teams associated with it; <code>false</code> otherwise
2974            */
2975            public static boolean containsTeams(long pk) {
2976                    return getPersistence().containsTeams(pk);
2977            }
2978    
2979            /**
2980            * Adds an association between the user and the team. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2981            *
2982            * @param pk the primary key of the user
2983            * @param teamPK the primary key of the team
2984            */
2985            public static void addTeam(long pk, long teamPK) {
2986                    getPersistence().addTeam(pk, teamPK);
2987            }
2988    
2989            /**
2990            * Adds an association between the user and the team. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2991            *
2992            * @param pk the primary key of the user
2993            * @param team the team
2994            */
2995            public static void addTeam(long pk, com.liferay.portal.model.Team team) {
2996                    getPersistence().addTeam(pk, team);
2997            }
2998    
2999            /**
3000            * Adds an association between the user and the teams. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3001            *
3002            * @param pk the primary key of the user
3003            * @param teamPKs the primary keys of the teams
3004            */
3005            public static void addTeams(long pk, long[] teamPKs) {
3006                    getPersistence().addTeams(pk, teamPKs);
3007            }
3008    
3009            /**
3010            * Adds an association between the user and the teams. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3011            *
3012            * @param pk the primary key of the user
3013            * @param teams the teams
3014            */
3015            public static void addTeams(long pk,
3016                    List<com.liferay.portal.model.Team> teams) {
3017                    getPersistence().addTeams(pk, teams);
3018            }
3019    
3020            /**
3021            * Clears all associations between the user and its teams. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3022            *
3023            * @param pk the primary key of the user to clear the associated teams from
3024            */
3025            public static void clearTeams(long pk) {
3026                    getPersistence().clearTeams(pk);
3027            }
3028    
3029            /**
3030            * Removes the association between the user and the team. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3031            *
3032            * @param pk the primary key of the user
3033            * @param teamPK the primary key of the team
3034            */
3035            public static void removeTeam(long pk, long teamPK) {
3036                    getPersistence().removeTeam(pk, teamPK);
3037            }
3038    
3039            /**
3040            * Removes the association between the user and the team. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3041            *
3042            * @param pk the primary key of the user
3043            * @param team the team
3044            */
3045            public static void removeTeam(long pk, com.liferay.portal.model.Team team) {
3046                    getPersistence().removeTeam(pk, team);
3047            }
3048    
3049            /**
3050            * Removes the association between the user and the teams. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3051            *
3052            * @param pk the primary key of the user
3053            * @param teamPKs the primary keys of the teams
3054            */
3055            public static void removeTeams(long pk, long[] teamPKs) {
3056                    getPersistence().removeTeams(pk, teamPKs);
3057            }
3058    
3059            /**
3060            * Removes the association between the user and the teams. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3061            *
3062            * @param pk the primary key of the user
3063            * @param teams the teams
3064            */
3065            public static void removeTeams(long pk,
3066                    List<com.liferay.portal.model.Team> teams) {
3067                    getPersistence().removeTeams(pk, teams);
3068            }
3069    
3070            /**
3071            * Sets the teams associated with the user, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3072            *
3073            * @param pk the primary key of the user
3074            * @param teamPKs the primary keys of the teams to be associated with the user
3075            */
3076            public static void setTeams(long pk, long[] teamPKs) {
3077                    getPersistence().setTeams(pk, teamPKs);
3078            }
3079    
3080            /**
3081            * Sets the teams associated with the user, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3082            *
3083            * @param pk the primary key of the user
3084            * @param teams the teams to be associated with the user
3085            */
3086            public static void setTeams(long pk,
3087                    List<com.liferay.portal.model.Team> teams) {
3088                    getPersistence().setTeams(pk, teams);
3089            }
3090    
3091            /**
3092            * Returns the primaryKeys of user groups associated with the user.
3093            *
3094            * @param pk the primary key of the user
3095            * @return long[] of the primaryKeys of user groups associated with the user
3096            */
3097            public static long[] getUserGroupPrimaryKeys(long pk) {
3098                    return getPersistence().getUserGroupPrimaryKeys(pk);
3099            }
3100    
3101            /**
3102            * Returns all the user groups associated with the user.
3103            *
3104            * @param pk the primary key of the user
3105            * @return the user groups associated with the user
3106            */
3107            public static List<com.liferay.portal.model.UserGroup> getUserGroups(
3108                    long pk) {
3109                    return getPersistence().getUserGroups(pk);
3110            }
3111    
3112            /**
3113            * Returns a range of all the user groups associated with the user.
3114            *
3115            * <p>
3116            * 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 UserModelImpl}. 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.
3117            * </p>
3118            *
3119            * @param pk the primary key of the user
3120            * @param start the lower bound of the range of users
3121            * @param end the upper bound of the range of users (not inclusive)
3122            * @return the range of user groups associated with the user
3123            */
3124            public static List<com.liferay.portal.model.UserGroup> getUserGroups(
3125                    long pk, int start, int end) {
3126                    return getPersistence().getUserGroups(pk, start, end);
3127            }
3128    
3129            /**
3130            * Returns an ordered range of all the user groups associated with the user.
3131            *
3132            * <p>
3133            * 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 UserModelImpl}. 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.
3134            * </p>
3135            *
3136            * @param pk the primary key of the user
3137            * @param start the lower bound of the range of users
3138            * @param end the upper bound of the range of users (not inclusive)
3139            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3140            * @return the ordered range of user groups associated with the user
3141            */
3142            public static List<com.liferay.portal.model.UserGroup> getUserGroups(
3143                    long pk, int start, int end,
3144                    OrderByComparator<com.liferay.portal.model.UserGroup> orderByComparator) {
3145                    return getPersistence().getUserGroups(pk, start, end, orderByComparator);
3146            }
3147    
3148            /**
3149            * Returns the number of user groups associated with the user.
3150            *
3151            * @param pk the primary key of the user
3152            * @return the number of user groups associated with the user
3153            */
3154            public static int getUserGroupsSize(long pk) {
3155                    return getPersistence().getUserGroupsSize(pk);
3156            }
3157    
3158            /**
3159            * Returns <code>true</code> if the user group is associated with the user.
3160            *
3161            * @param pk the primary key of the user
3162            * @param userGroupPK the primary key of the user group
3163            * @return <code>true</code> if the user group is associated with the user; <code>false</code> otherwise
3164            */
3165            public static boolean containsUserGroup(long pk, long userGroupPK) {
3166                    return getPersistence().containsUserGroup(pk, userGroupPK);
3167            }
3168    
3169            /**
3170            * Returns <code>true</code> if the user has any user groups associated with it.
3171            *
3172            * @param pk the primary key of the user to check for associations with user groups
3173            * @return <code>true</code> if the user has any user groups associated with it; <code>false</code> otherwise
3174            */
3175            public static boolean containsUserGroups(long pk) {
3176                    return getPersistence().containsUserGroups(pk);
3177            }
3178    
3179            /**
3180            * Adds an association between the user and the user group. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3181            *
3182            * @param pk the primary key of the user
3183            * @param userGroupPK the primary key of the user group
3184            */
3185            public static void addUserGroup(long pk, long userGroupPK) {
3186                    getPersistence().addUserGroup(pk, userGroupPK);
3187            }
3188    
3189            /**
3190            * Adds an association between the user and the user group. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3191            *
3192            * @param pk the primary key of the user
3193            * @param userGroup the user group
3194            */
3195            public static void addUserGroup(long pk,
3196                    com.liferay.portal.model.UserGroup userGroup) {
3197                    getPersistence().addUserGroup(pk, userGroup);
3198            }
3199    
3200            /**
3201            * Adds an association between the user and the user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3202            *
3203            * @param pk the primary key of the user
3204            * @param userGroupPKs the primary keys of the user groups
3205            */
3206            public static void addUserGroups(long pk, long[] userGroupPKs) {
3207                    getPersistence().addUserGroups(pk, userGroupPKs);
3208            }
3209    
3210            /**
3211            * Adds an association between the user and the user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3212            *
3213            * @param pk the primary key of the user
3214            * @param userGroups the user groups
3215            */
3216            public static void addUserGroups(long pk,
3217                    List<com.liferay.portal.model.UserGroup> userGroups) {
3218                    getPersistence().addUserGroups(pk, userGroups);
3219            }
3220    
3221            /**
3222            * Clears all associations between the user and its user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3223            *
3224            * @param pk the primary key of the user to clear the associated user groups from
3225            */
3226            public static void clearUserGroups(long pk) {
3227                    getPersistence().clearUserGroups(pk);
3228            }
3229    
3230            /**
3231            * Removes the association between the user and the user group. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3232            *
3233            * @param pk the primary key of the user
3234            * @param userGroupPK the primary key of the user group
3235            */
3236            public static void removeUserGroup(long pk, long userGroupPK) {
3237                    getPersistence().removeUserGroup(pk, userGroupPK);
3238            }
3239    
3240            /**
3241            * Removes the association between the user and the user group. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3242            *
3243            * @param pk the primary key of the user
3244            * @param userGroup the user group
3245            */
3246            public static void removeUserGroup(long pk,
3247                    com.liferay.portal.model.UserGroup userGroup) {
3248                    getPersistence().removeUserGroup(pk, userGroup);
3249            }
3250    
3251            /**
3252            * Removes the association between the user and the user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3253            *
3254            * @param pk the primary key of the user
3255            * @param userGroupPKs the primary keys of the user groups
3256            */
3257            public static void removeUserGroups(long pk, long[] userGroupPKs) {
3258                    getPersistence().removeUserGroups(pk, userGroupPKs);
3259            }
3260    
3261            /**
3262            * Removes the association between the user and the user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3263            *
3264            * @param pk the primary key of the user
3265            * @param userGroups the user groups
3266            */
3267            public static void removeUserGroups(long pk,
3268                    List<com.liferay.portal.model.UserGroup> userGroups) {
3269                    getPersistence().removeUserGroups(pk, userGroups);
3270            }
3271    
3272            /**
3273            * Sets the user groups associated with the user, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3274            *
3275            * @param pk the primary key of the user
3276            * @param userGroupPKs the primary keys of the user groups to be associated with the user
3277            */
3278            public static void setUserGroups(long pk, long[] userGroupPKs) {
3279                    getPersistence().setUserGroups(pk, userGroupPKs);
3280            }
3281    
3282            /**
3283            * Sets the user groups associated with the user, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3284            *
3285            * @param pk the primary key of the user
3286            * @param userGroups the user groups to be associated with the user
3287            */
3288            public static void setUserGroups(long pk,
3289                    List<com.liferay.portal.model.UserGroup> userGroups) {
3290                    getPersistence().setUserGroups(pk, userGroups);
3291            }
3292    
3293            public static java.util.Set<java.lang.String> getBadColumnNames() {
3294                    return getPersistence().getBadColumnNames();
3295            }
3296    
3297            public static UserPersistence getPersistence() {
3298                    if (_persistence == null) {
3299                            _persistence = (UserPersistence)PortalBeanLocatorUtil.locate(UserPersistence.class.getName());
3300    
3301                            ReferenceRegistry.registerReference(UserUtil.class, "_persistence");
3302                    }
3303    
3304                    return _persistence;
3305            }
3306    
3307            private static UserPersistence _persistence;
3308    }