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.portlet.messageboards.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.service.ServiceContext; 024 025 import com.liferay.portlet.messageboards.model.MBThreadFlag; 026 027 import java.util.List; 028 029 /** 030 * The persistence utility for the message boards thread flag service. This utility wraps {@link MBThreadFlagPersistenceImpl} 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. 031 * 032 * <p> 033 * Caching information and settings can be found in <code>portal.properties</code> 034 * </p> 035 * 036 * @author Brian Wing Shun Chan 037 * @see MBThreadFlagPersistence 038 * @see MBThreadFlagPersistenceImpl 039 * @generated 040 */ 041 @ProviderType 042 public class MBThreadFlagUtil { 043 /* 044 * NOTE FOR DEVELOPERS: 045 * 046 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. 047 */ 048 049 /** 050 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 051 */ 052 public static void clearCache() { 053 getPersistence().clearCache(); 054 } 055 056 /** 057 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 058 */ 059 public static void clearCache(MBThreadFlag mbThreadFlag) { 060 getPersistence().clearCache(mbThreadFlag); 061 } 062 063 /** 064 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 065 */ 066 public static long countWithDynamicQuery(DynamicQuery dynamicQuery) { 067 return getPersistence().countWithDynamicQuery(dynamicQuery); 068 } 069 070 /** 071 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 072 */ 073 public static List<MBThreadFlag> findWithDynamicQuery( 074 DynamicQuery dynamicQuery) { 075 return getPersistence().findWithDynamicQuery(dynamicQuery); 076 } 077 078 /** 079 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 080 */ 081 public static List<MBThreadFlag> findWithDynamicQuery( 082 DynamicQuery dynamicQuery, int start, int end) { 083 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 084 } 085 086 /** 087 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 088 */ 089 public static List<MBThreadFlag> findWithDynamicQuery( 090 DynamicQuery dynamicQuery, int start, int end, 091 OrderByComparator<MBThreadFlag> orderByComparator) { 092 return getPersistence() 093 .findWithDynamicQuery(dynamicQuery, start, end, 094 orderByComparator); 095 } 096 097 /** 098 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel) 099 */ 100 public static MBThreadFlag update(MBThreadFlag mbThreadFlag) { 101 return getPersistence().update(mbThreadFlag); 102 } 103 104 /** 105 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 106 */ 107 public static MBThreadFlag update(MBThreadFlag mbThreadFlag, 108 ServiceContext serviceContext) { 109 return getPersistence().update(mbThreadFlag, serviceContext); 110 } 111 112 /** 113 * Returns all the message boards thread flags where uuid = ?. 114 * 115 * @param uuid the uuid 116 * @return the matching message boards thread flags 117 */ 118 public static java.util.List<com.liferay.portlet.messageboards.model.MBThreadFlag> findByUuid( 119 java.lang.String uuid) { 120 return getPersistence().findByUuid(uuid); 121 } 122 123 /** 124 * Returns a range of all the message boards thread flags where uuid = ?. 125 * 126 * <p> 127 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadFlagModelImpl}. 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. 128 * </p> 129 * 130 * @param uuid the uuid 131 * @param start the lower bound of the range of message boards thread flags 132 * @param end the upper bound of the range of message boards thread flags (not inclusive) 133 * @return the range of matching message boards thread flags 134 */ 135 public static java.util.List<com.liferay.portlet.messageboards.model.MBThreadFlag> findByUuid( 136 java.lang.String uuid, int start, int end) { 137 return getPersistence().findByUuid(uuid, start, end); 138 } 139 140 /** 141 * Returns an ordered range of all the message boards thread flags where uuid = ?. 142 * 143 * <p> 144 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadFlagModelImpl}. 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. 145 * </p> 146 * 147 * @param uuid the uuid 148 * @param start the lower bound of the range of message boards thread flags 149 * @param end the upper bound of the range of message boards thread flags (not inclusive) 150 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 151 * @return the ordered range of matching message boards thread flags 152 */ 153 public static java.util.List<com.liferay.portlet.messageboards.model.MBThreadFlag> findByUuid( 154 java.lang.String uuid, int start, int end, 155 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBThreadFlag> orderByComparator) { 156 return getPersistence().findByUuid(uuid, start, end, orderByComparator); 157 } 158 159 /** 160 * Returns the first message boards thread flag in the ordered set where uuid = ?. 161 * 162 * @param uuid the uuid 163 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 164 * @return the first matching message boards thread flag 165 * @throws com.liferay.portlet.messageboards.NoSuchThreadFlagException if a matching message boards thread flag could not be found 166 */ 167 public static com.liferay.portlet.messageboards.model.MBThreadFlag findByUuid_First( 168 java.lang.String uuid, 169 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBThreadFlag> orderByComparator) 170 throws com.liferay.portlet.messageboards.NoSuchThreadFlagException { 171 return getPersistence().findByUuid_First(uuid, orderByComparator); 172 } 173 174 /** 175 * Returns the first message boards thread flag in the ordered set where uuid = ?. 176 * 177 * @param uuid the uuid 178 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 179 * @return the first matching message boards thread flag, or <code>null</code> if a matching message boards thread flag could not be found 180 */ 181 public static com.liferay.portlet.messageboards.model.MBThreadFlag fetchByUuid_First( 182 java.lang.String uuid, 183 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBThreadFlag> orderByComparator) { 184 return getPersistence().fetchByUuid_First(uuid, orderByComparator); 185 } 186 187 /** 188 * Returns the last message boards thread flag in the ordered set where uuid = ?. 189 * 190 * @param uuid the uuid 191 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 192 * @return the last matching message boards thread flag 193 * @throws com.liferay.portlet.messageboards.NoSuchThreadFlagException if a matching message boards thread flag could not be found 194 */ 195 public static com.liferay.portlet.messageboards.model.MBThreadFlag findByUuid_Last( 196 java.lang.String uuid, 197 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBThreadFlag> orderByComparator) 198 throws com.liferay.portlet.messageboards.NoSuchThreadFlagException { 199 return getPersistence().findByUuid_Last(uuid, orderByComparator); 200 } 201 202 /** 203 * Returns the last message boards thread flag in the ordered set where uuid = ?. 204 * 205 * @param uuid the uuid 206 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 207 * @return the last matching message boards thread flag, or <code>null</code> if a matching message boards thread flag could not be found 208 */ 209 public static com.liferay.portlet.messageboards.model.MBThreadFlag fetchByUuid_Last( 210 java.lang.String uuid, 211 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBThreadFlag> orderByComparator) { 212 return getPersistence().fetchByUuid_Last(uuid, orderByComparator); 213 } 214 215 /** 216 * Returns the message boards thread flags before and after the current message boards thread flag in the ordered set where uuid = ?. 217 * 218 * @param threadFlagId the primary key of the current message boards thread flag 219 * @param uuid the uuid 220 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 221 * @return the previous, current, and next message boards thread flag 222 * @throws com.liferay.portlet.messageboards.NoSuchThreadFlagException if a message boards thread flag with the primary key could not be found 223 */ 224 public static com.liferay.portlet.messageboards.model.MBThreadFlag[] findByUuid_PrevAndNext( 225 long threadFlagId, java.lang.String uuid, 226 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBThreadFlag> orderByComparator) 227 throws com.liferay.portlet.messageboards.NoSuchThreadFlagException { 228 return getPersistence() 229 .findByUuid_PrevAndNext(threadFlagId, uuid, orderByComparator); 230 } 231 232 /** 233 * Removes all the message boards thread flags where uuid = ? from the database. 234 * 235 * @param uuid the uuid 236 */ 237 public static void removeByUuid(java.lang.String uuid) { 238 getPersistence().removeByUuid(uuid); 239 } 240 241 /** 242 * Returns the number of message boards thread flags where uuid = ?. 243 * 244 * @param uuid the uuid 245 * @return the number of matching message boards thread flags 246 */ 247 public static int countByUuid(java.lang.String uuid) { 248 return getPersistence().countByUuid(uuid); 249 } 250 251 /** 252 * Returns the message boards thread flag where uuid = ? and groupId = ? or throws a {@link com.liferay.portlet.messageboards.NoSuchThreadFlagException} if it could not be found. 253 * 254 * @param uuid the uuid 255 * @param groupId the group ID 256 * @return the matching message boards thread flag 257 * @throws com.liferay.portlet.messageboards.NoSuchThreadFlagException if a matching message boards thread flag could not be found 258 */ 259 public static com.liferay.portlet.messageboards.model.MBThreadFlag findByUUID_G( 260 java.lang.String uuid, long groupId) 261 throws com.liferay.portlet.messageboards.NoSuchThreadFlagException { 262 return getPersistence().findByUUID_G(uuid, groupId); 263 } 264 265 /** 266 * Returns the message boards thread flag where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 267 * 268 * @param uuid the uuid 269 * @param groupId the group ID 270 * @return the matching message boards thread flag, or <code>null</code> if a matching message boards thread flag could not be found 271 */ 272 public static com.liferay.portlet.messageboards.model.MBThreadFlag fetchByUUID_G( 273 java.lang.String uuid, long groupId) { 274 return getPersistence().fetchByUUID_G(uuid, groupId); 275 } 276 277 /** 278 * Returns the message boards thread flag where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 279 * 280 * @param uuid the uuid 281 * @param groupId the group ID 282 * @param retrieveFromCache whether to use the finder cache 283 * @return the matching message boards thread flag, or <code>null</code> if a matching message boards thread flag could not be found 284 */ 285 public static com.liferay.portlet.messageboards.model.MBThreadFlag fetchByUUID_G( 286 java.lang.String uuid, long groupId, boolean retrieveFromCache) { 287 return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache); 288 } 289 290 /** 291 * Removes the message boards thread flag where uuid = ? and groupId = ? from the database. 292 * 293 * @param uuid the uuid 294 * @param groupId the group ID 295 * @return the message boards thread flag that was removed 296 */ 297 public static com.liferay.portlet.messageboards.model.MBThreadFlag removeByUUID_G( 298 java.lang.String uuid, long groupId) 299 throws com.liferay.portlet.messageboards.NoSuchThreadFlagException { 300 return getPersistence().removeByUUID_G(uuid, groupId); 301 } 302 303 /** 304 * Returns the number of message boards thread flags where uuid = ? and groupId = ?. 305 * 306 * @param uuid the uuid 307 * @param groupId the group ID 308 * @return the number of matching message boards thread flags 309 */ 310 public static int countByUUID_G(java.lang.String uuid, long groupId) { 311 return getPersistence().countByUUID_G(uuid, groupId); 312 } 313 314 /** 315 * Returns all the message boards thread flags where uuid = ? and companyId = ?. 316 * 317 * @param uuid the uuid 318 * @param companyId the company ID 319 * @return the matching message boards thread flags 320 */ 321 public static java.util.List<com.liferay.portlet.messageboards.model.MBThreadFlag> findByUuid_C( 322 java.lang.String uuid, long companyId) { 323 return getPersistence().findByUuid_C(uuid, companyId); 324 } 325 326 /** 327 * Returns a range of all the message boards thread flags where uuid = ? and companyId = ?. 328 * 329 * <p> 330 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadFlagModelImpl}. 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. 331 * </p> 332 * 333 * @param uuid the uuid 334 * @param companyId the company ID 335 * @param start the lower bound of the range of message boards thread flags 336 * @param end the upper bound of the range of message boards thread flags (not inclusive) 337 * @return the range of matching message boards thread flags 338 */ 339 public static java.util.List<com.liferay.portlet.messageboards.model.MBThreadFlag> findByUuid_C( 340 java.lang.String uuid, long companyId, int start, int end) { 341 return getPersistence().findByUuid_C(uuid, companyId, start, end); 342 } 343 344 /** 345 * Returns an ordered range of all the message boards thread flags where uuid = ? and companyId = ?. 346 * 347 * <p> 348 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadFlagModelImpl}. 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. 349 * </p> 350 * 351 * @param uuid the uuid 352 * @param companyId the company ID 353 * @param start the lower bound of the range of message boards thread flags 354 * @param end the upper bound of the range of message boards thread flags (not inclusive) 355 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 356 * @return the ordered range of matching message boards thread flags 357 */ 358 public static java.util.List<com.liferay.portlet.messageboards.model.MBThreadFlag> findByUuid_C( 359 java.lang.String uuid, long companyId, int start, int end, 360 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBThreadFlag> orderByComparator) { 361 return getPersistence() 362 .findByUuid_C(uuid, companyId, start, end, orderByComparator); 363 } 364 365 /** 366 * Returns the first message boards thread flag in the ordered set where uuid = ? and companyId = ?. 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 first matching message boards thread flag 372 * @throws com.liferay.portlet.messageboards.NoSuchThreadFlagException if a matching message boards thread flag could not be found 373 */ 374 public static com.liferay.portlet.messageboards.model.MBThreadFlag findByUuid_C_First( 375 java.lang.String uuid, long companyId, 376 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBThreadFlag> orderByComparator) 377 throws com.liferay.portlet.messageboards.NoSuchThreadFlagException { 378 return getPersistence() 379 .findByUuid_C_First(uuid, companyId, orderByComparator); 380 } 381 382 /** 383 * Returns the first message boards thread flag in the ordered set where uuid = ? and companyId = ?. 384 * 385 * @param uuid the uuid 386 * @param companyId the company ID 387 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 388 * @return the first matching message boards thread flag, or <code>null</code> if a matching message boards thread flag could not be found 389 */ 390 public static com.liferay.portlet.messageboards.model.MBThreadFlag fetchByUuid_C_First( 391 java.lang.String uuid, long companyId, 392 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBThreadFlag> orderByComparator) { 393 return getPersistence() 394 .fetchByUuid_C_First(uuid, companyId, orderByComparator); 395 } 396 397 /** 398 * Returns the last message boards thread flag in the ordered set where uuid = ? and companyId = ?. 399 * 400 * @param uuid the uuid 401 * @param companyId the company ID 402 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 403 * @return the last matching message boards thread flag 404 * @throws com.liferay.portlet.messageboards.NoSuchThreadFlagException if a matching message boards thread flag could not be found 405 */ 406 public static com.liferay.portlet.messageboards.model.MBThreadFlag findByUuid_C_Last( 407 java.lang.String uuid, long companyId, 408 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBThreadFlag> orderByComparator) 409 throws com.liferay.portlet.messageboards.NoSuchThreadFlagException { 410 return getPersistence() 411 .findByUuid_C_Last(uuid, companyId, orderByComparator); 412 } 413 414 /** 415 * Returns the last message boards thread flag in the ordered set where uuid = ? and companyId = ?. 416 * 417 * @param uuid the uuid 418 * @param companyId the company ID 419 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 420 * @return the last matching message boards thread flag, or <code>null</code> if a matching message boards thread flag could not be found 421 */ 422 public static com.liferay.portlet.messageboards.model.MBThreadFlag fetchByUuid_C_Last( 423 java.lang.String uuid, long companyId, 424 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBThreadFlag> orderByComparator) { 425 return getPersistence() 426 .fetchByUuid_C_Last(uuid, companyId, orderByComparator); 427 } 428 429 /** 430 * Returns the message boards thread flags before and after the current message boards thread flag in the ordered set where uuid = ? and companyId = ?. 431 * 432 * @param threadFlagId the primary key of the current message boards thread flag 433 * @param uuid the uuid 434 * @param companyId the company ID 435 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 436 * @return the previous, current, and next message boards thread flag 437 * @throws com.liferay.portlet.messageboards.NoSuchThreadFlagException if a message boards thread flag with the primary key could not be found 438 */ 439 public static com.liferay.portlet.messageboards.model.MBThreadFlag[] findByUuid_C_PrevAndNext( 440 long threadFlagId, java.lang.String uuid, long companyId, 441 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBThreadFlag> orderByComparator) 442 throws com.liferay.portlet.messageboards.NoSuchThreadFlagException { 443 return getPersistence() 444 .findByUuid_C_PrevAndNext(threadFlagId, uuid, companyId, 445 orderByComparator); 446 } 447 448 /** 449 * Removes all the message boards thread flags where uuid = ? and companyId = ? from the database. 450 * 451 * @param uuid the uuid 452 * @param companyId the company ID 453 */ 454 public static void removeByUuid_C(java.lang.String uuid, long companyId) { 455 getPersistence().removeByUuid_C(uuid, companyId); 456 } 457 458 /** 459 * Returns the number of message boards thread flags where uuid = ? and companyId = ?. 460 * 461 * @param uuid the uuid 462 * @param companyId the company ID 463 * @return the number of matching message boards thread flags 464 */ 465 public static int countByUuid_C(java.lang.String uuid, long companyId) { 466 return getPersistence().countByUuid_C(uuid, companyId); 467 } 468 469 /** 470 * Returns all the message boards thread flags where userId = ?. 471 * 472 * @param userId the user ID 473 * @return the matching message boards thread flags 474 */ 475 public static java.util.List<com.liferay.portlet.messageboards.model.MBThreadFlag> findByUserId( 476 long userId) { 477 return getPersistence().findByUserId(userId); 478 } 479 480 /** 481 * Returns a range of all the message boards thread flags where userId = ?. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadFlagModelImpl}. 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 userId the user ID 488 * @param start the lower bound of the range of message boards thread flags 489 * @param end the upper bound of the range of message boards thread flags (not inclusive) 490 * @return the range of matching message boards thread flags 491 */ 492 public static java.util.List<com.liferay.portlet.messageboards.model.MBThreadFlag> findByUserId( 493 long userId, int start, int end) { 494 return getPersistence().findByUserId(userId, start, end); 495 } 496 497 /** 498 * Returns an ordered range of all the message boards thread flags where userId = ?. 499 * 500 * <p> 501 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadFlagModelImpl}. 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. 502 * </p> 503 * 504 * @param userId the user ID 505 * @param start the lower bound of the range of message boards thread flags 506 * @param end the upper bound of the range of message boards thread flags (not inclusive) 507 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 508 * @return the ordered range of matching message boards thread flags 509 */ 510 public static java.util.List<com.liferay.portlet.messageboards.model.MBThreadFlag> findByUserId( 511 long userId, int start, int end, 512 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBThreadFlag> orderByComparator) { 513 return getPersistence() 514 .findByUserId(userId, start, end, orderByComparator); 515 } 516 517 /** 518 * Returns the first message boards thread flag in the ordered set where userId = ?. 519 * 520 * @param userId the user ID 521 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 522 * @return the first matching message boards thread flag 523 * @throws com.liferay.portlet.messageboards.NoSuchThreadFlagException if a matching message boards thread flag could not be found 524 */ 525 public static com.liferay.portlet.messageboards.model.MBThreadFlag findByUserId_First( 526 long userId, 527 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBThreadFlag> orderByComparator) 528 throws com.liferay.portlet.messageboards.NoSuchThreadFlagException { 529 return getPersistence().findByUserId_First(userId, orderByComparator); 530 } 531 532 /** 533 * Returns the first message boards thread flag in the ordered set where userId = ?. 534 * 535 * @param userId the user ID 536 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 537 * @return the first matching message boards thread flag, or <code>null</code> if a matching message boards thread flag could not be found 538 */ 539 public static com.liferay.portlet.messageboards.model.MBThreadFlag fetchByUserId_First( 540 long userId, 541 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBThreadFlag> orderByComparator) { 542 return getPersistence().fetchByUserId_First(userId, orderByComparator); 543 } 544 545 /** 546 * Returns the last message boards thread flag in the ordered set where userId = ?. 547 * 548 * @param userId the user ID 549 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 550 * @return the last matching message boards thread flag 551 * @throws com.liferay.portlet.messageboards.NoSuchThreadFlagException if a matching message boards thread flag could not be found 552 */ 553 public static com.liferay.portlet.messageboards.model.MBThreadFlag findByUserId_Last( 554 long userId, 555 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBThreadFlag> orderByComparator) 556 throws com.liferay.portlet.messageboards.NoSuchThreadFlagException { 557 return getPersistence().findByUserId_Last(userId, orderByComparator); 558 } 559 560 /** 561 * Returns the last message boards thread flag in the ordered set where userId = ?. 562 * 563 * @param userId the user ID 564 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 565 * @return the last matching message boards thread flag, or <code>null</code> if a matching message boards thread flag could not be found 566 */ 567 public static com.liferay.portlet.messageboards.model.MBThreadFlag fetchByUserId_Last( 568 long userId, 569 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBThreadFlag> orderByComparator) { 570 return getPersistence().fetchByUserId_Last(userId, orderByComparator); 571 } 572 573 /** 574 * Returns the message boards thread flags before and after the current message boards thread flag in the ordered set where userId = ?. 575 * 576 * @param threadFlagId the primary key of the current message boards thread flag 577 * @param userId the user ID 578 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 579 * @return the previous, current, and next message boards thread flag 580 * @throws com.liferay.portlet.messageboards.NoSuchThreadFlagException if a message boards thread flag with the primary key could not be found 581 */ 582 public static com.liferay.portlet.messageboards.model.MBThreadFlag[] findByUserId_PrevAndNext( 583 long threadFlagId, long userId, 584 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBThreadFlag> orderByComparator) 585 throws com.liferay.portlet.messageboards.NoSuchThreadFlagException { 586 return getPersistence() 587 .findByUserId_PrevAndNext(threadFlagId, userId, 588 orderByComparator); 589 } 590 591 /** 592 * Removes all the message boards thread flags where userId = ? from the database. 593 * 594 * @param userId the user ID 595 */ 596 public static void removeByUserId(long userId) { 597 getPersistence().removeByUserId(userId); 598 } 599 600 /** 601 * Returns the number of message boards thread flags where userId = ?. 602 * 603 * @param userId the user ID 604 * @return the number of matching message boards thread flags 605 */ 606 public static int countByUserId(long userId) { 607 return getPersistence().countByUserId(userId); 608 } 609 610 /** 611 * Returns all the message boards thread flags where threadId = ?. 612 * 613 * @param threadId the thread ID 614 * @return the matching message boards thread flags 615 */ 616 public static java.util.List<com.liferay.portlet.messageboards.model.MBThreadFlag> findByThreadId( 617 long threadId) { 618 return getPersistence().findByThreadId(threadId); 619 } 620 621 /** 622 * Returns a range of all the message boards thread flags where threadId = ?. 623 * 624 * <p> 625 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadFlagModelImpl}. 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. 626 * </p> 627 * 628 * @param threadId the thread ID 629 * @param start the lower bound of the range of message boards thread flags 630 * @param end the upper bound of the range of message boards thread flags (not inclusive) 631 * @return the range of matching message boards thread flags 632 */ 633 public static java.util.List<com.liferay.portlet.messageboards.model.MBThreadFlag> findByThreadId( 634 long threadId, int start, int end) { 635 return getPersistence().findByThreadId(threadId, start, end); 636 } 637 638 /** 639 * Returns an ordered range of all the message boards thread flags where threadId = ?. 640 * 641 * <p> 642 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadFlagModelImpl}. 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. 643 * </p> 644 * 645 * @param threadId the thread ID 646 * @param start the lower bound of the range of message boards thread flags 647 * @param end the upper bound of the range of message boards thread flags (not inclusive) 648 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 649 * @return the ordered range of matching message boards thread flags 650 */ 651 public static java.util.List<com.liferay.portlet.messageboards.model.MBThreadFlag> findByThreadId( 652 long threadId, int start, int end, 653 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBThreadFlag> orderByComparator) { 654 return getPersistence() 655 .findByThreadId(threadId, start, end, orderByComparator); 656 } 657 658 /** 659 * Returns the first message boards thread flag in the ordered set where threadId = ?. 660 * 661 * @param threadId the thread ID 662 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 663 * @return the first matching message boards thread flag 664 * @throws com.liferay.portlet.messageboards.NoSuchThreadFlagException if a matching message boards thread flag could not be found 665 */ 666 public static com.liferay.portlet.messageboards.model.MBThreadFlag findByThreadId_First( 667 long threadId, 668 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBThreadFlag> orderByComparator) 669 throws com.liferay.portlet.messageboards.NoSuchThreadFlagException { 670 return getPersistence().findByThreadId_First(threadId, orderByComparator); 671 } 672 673 /** 674 * Returns the first message boards thread flag in the ordered set where threadId = ?. 675 * 676 * @param threadId the thread ID 677 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 678 * @return the first matching message boards thread flag, or <code>null</code> if a matching message boards thread flag could not be found 679 */ 680 public static com.liferay.portlet.messageboards.model.MBThreadFlag fetchByThreadId_First( 681 long threadId, 682 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBThreadFlag> orderByComparator) { 683 return getPersistence() 684 .fetchByThreadId_First(threadId, orderByComparator); 685 } 686 687 /** 688 * Returns the last message boards thread flag in the ordered set where threadId = ?. 689 * 690 * @param threadId the thread ID 691 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 692 * @return the last matching message boards thread flag 693 * @throws com.liferay.portlet.messageboards.NoSuchThreadFlagException if a matching message boards thread flag could not be found 694 */ 695 public static com.liferay.portlet.messageboards.model.MBThreadFlag findByThreadId_Last( 696 long threadId, 697 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBThreadFlag> orderByComparator) 698 throws com.liferay.portlet.messageboards.NoSuchThreadFlagException { 699 return getPersistence().findByThreadId_Last(threadId, orderByComparator); 700 } 701 702 /** 703 * Returns the last message boards thread flag in the ordered set where threadId = ?. 704 * 705 * @param threadId the thread ID 706 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 707 * @return the last matching message boards thread flag, or <code>null</code> if a matching message boards thread flag could not be found 708 */ 709 public static com.liferay.portlet.messageboards.model.MBThreadFlag fetchByThreadId_Last( 710 long threadId, 711 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBThreadFlag> orderByComparator) { 712 return getPersistence().fetchByThreadId_Last(threadId, orderByComparator); 713 } 714 715 /** 716 * Returns the message boards thread flags before and after the current message boards thread flag in the ordered set where threadId = ?. 717 * 718 * @param threadFlagId the primary key of the current message boards thread flag 719 * @param threadId the thread ID 720 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 721 * @return the previous, current, and next message boards thread flag 722 * @throws com.liferay.portlet.messageboards.NoSuchThreadFlagException if a message boards thread flag with the primary key could not be found 723 */ 724 public static com.liferay.portlet.messageboards.model.MBThreadFlag[] findByThreadId_PrevAndNext( 725 long threadFlagId, long threadId, 726 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBThreadFlag> orderByComparator) 727 throws com.liferay.portlet.messageboards.NoSuchThreadFlagException { 728 return getPersistence() 729 .findByThreadId_PrevAndNext(threadFlagId, threadId, 730 orderByComparator); 731 } 732 733 /** 734 * Removes all the message boards thread flags where threadId = ? from the database. 735 * 736 * @param threadId the thread ID 737 */ 738 public static void removeByThreadId(long threadId) { 739 getPersistence().removeByThreadId(threadId); 740 } 741 742 /** 743 * Returns the number of message boards thread flags where threadId = ?. 744 * 745 * @param threadId the thread ID 746 * @return the number of matching message boards thread flags 747 */ 748 public static int countByThreadId(long threadId) { 749 return getPersistence().countByThreadId(threadId); 750 } 751 752 /** 753 * Returns the message boards thread flag where userId = ? and threadId = ? or throws a {@link com.liferay.portlet.messageboards.NoSuchThreadFlagException} if it could not be found. 754 * 755 * @param userId the user ID 756 * @param threadId the thread ID 757 * @return the matching message boards thread flag 758 * @throws com.liferay.portlet.messageboards.NoSuchThreadFlagException if a matching message boards thread flag could not be found 759 */ 760 public static com.liferay.portlet.messageboards.model.MBThreadFlag findByU_T( 761 long userId, long threadId) 762 throws com.liferay.portlet.messageboards.NoSuchThreadFlagException { 763 return getPersistence().findByU_T(userId, threadId); 764 } 765 766 /** 767 * Returns the message boards thread flag where userId = ? and threadId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 768 * 769 * @param userId the user ID 770 * @param threadId the thread ID 771 * @return the matching message boards thread flag, or <code>null</code> if a matching message boards thread flag could not be found 772 */ 773 public static com.liferay.portlet.messageboards.model.MBThreadFlag fetchByU_T( 774 long userId, long threadId) { 775 return getPersistence().fetchByU_T(userId, threadId); 776 } 777 778 /** 779 * Returns the message boards thread flag where userId = ? and threadId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 780 * 781 * @param userId the user ID 782 * @param threadId the thread ID 783 * @param retrieveFromCache whether to use the finder cache 784 * @return the matching message boards thread flag, or <code>null</code> if a matching message boards thread flag could not be found 785 */ 786 public static com.liferay.portlet.messageboards.model.MBThreadFlag fetchByU_T( 787 long userId, long threadId, boolean retrieveFromCache) { 788 return getPersistence().fetchByU_T(userId, threadId, retrieveFromCache); 789 } 790 791 /** 792 * Removes the message boards thread flag where userId = ? and threadId = ? from the database. 793 * 794 * @param userId the user ID 795 * @param threadId the thread ID 796 * @return the message boards thread flag that was removed 797 */ 798 public static com.liferay.portlet.messageboards.model.MBThreadFlag removeByU_T( 799 long userId, long threadId) 800 throws com.liferay.portlet.messageboards.NoSuchThreadFlagException { 801 return getPersistence().removeByU_T(userId, threadId); 802 } 803 804 /** 805 * Returns the number of message boards thread flags where userId = ? and threadId = ?. 806 * 807 * @param userId the user ID 808 * @param threadId the thread ID 809 * @return the number of matching message boards thread flags 810 */ 811 public static int countByU_T(long userId, long threadId) { 812 return getPersistence().countByU_T(userId, threadId); 813 } 814 815 /** 816 * Caches the message boards thread flag in the entity cache if it is enabled. 817 * 818 * @param mbThreadFlag the message boards thread flag 819 */ 820 public static void cacheResult( 821 com.liferay.portlet.messageboards.model.MBThreadFlag mbThreadFlag) { 822 getPersistence().cacheResult(mbThreadFlag); 823 } 824 825 /** 826 * Caches the message boards thread flags in the entity cache if it is enabled. 827 * 828 * @param mbThreadFlags the message boards thread flags 829 */ 830 public static void cacheResult( 831 java.util.List<com.liferay.portlet.messageboards.model.MBThreadFlag> mbThreadFlags) { 832 getPersistence().cacheResult(mbThreadFlags); 833 } 834 835 /** 836 * Creates a new message boards thread flag with the primary key. Does not add the message boards thread flag to the database. 837 * 838 * @param threadFlagId the primary key for the new message boards thread flag 839 * @return the new message boards thread flag 840 */ 841 public static com.liferay.portlet.messageboards.model.MBThreadFlag create( 842 long threadFlagId) { 843 return getPersistence().create(threadFlagId); 844 } 845 846 /** 847 * Removes the message boards thread flag with the primary key from the database. Also notifies the appropriate model listeners. 848 * 849 * @param threadFlagId the primary key of the message boards thread flag 850 * @return the message boards thread flag that was removed 851 * @throws com.liferay.portlet.messageboards.NoSuchThreadFlagException if a message boards thread flag with the primary key could not be found 852 */ 853 public static com.liferay.portlet.messageboards.model.MBThreadFlag remove( 854 long threadFlagId) 855 throws com.liferay.portlet.messageboards.NoSuchThreadFlagException { 856 return getPersistence().remove(threadFlagId); 857 } 858 859 public static com.liferay.portlet.messageboards.model.MBThreadFlag updateImpl( 860 com.liferay.portlet.messageboards.model.MBThreadFlag mbThreadFlag) { 861 return getPersistence().updateImpl(mbThreadFlag); 862 } 863 864 /** 865 * Returns the message boards thread flag with the primary key or throws a {@link com.liferay.portlet.messageboards.NoSuchThreadFlagException} if it could not be found. 866 * 867 * @param threadFlagId the primary key of the message boards thread flag 868 * @return the message boards thread flag 869 * @throws com.liferay.portlet.messageboards.NoSuchThreadFlagException if a message boards thread flag with the primary key could not be found 870 */ 871 public static com.liferay.portlet.messageboards.model.MBThreadFlag findByPrimaryKey( 872 long threadFlagId) 873 throws com.liferay.portlet.messageboards.NoSuchThreadFlagException { 874 return getPersistence().findByPrimaryKey(threadFlagId); 875 } 876 877 /** 878 * Returns the message boards thread flag with the primary key or returns <code>null</code> if it could not be found. 879 * 880 * @param threadFlagId the primary key of the message boards thread flag 881 * @return the message boards thread flag, or <code>null</code> if a message boards thread flag with the primary key could not be found 882 */ 883 public static com.liferay.portlet.messageboards.model.MBThreadFlag fetchByPrimaryKey( 884 long threadFlagId) { 885 return getPersistence().fetchByPrimaryKey(threadFlagId); 886 } 887 888 public static java.util.Map<java.io.Serializable, com.liferay.portlet.messageboards.model.MBThreadFlag> fetchByPrimaryKeys( 889 java.util.Set<java.io.Serializable> primaryKeys) { 890 return getPersistence().fetchByPrimaryKeys(primaryKeys); 891 } 892 893 /** 894 * Returns all the message boards thread flags. 895 * 896 * @return the message boards thread flags 897 */ 898 public static java.util.List<com.liferay.portlet.messageboards.model.MBThreadFlag> findAll() { 899 return getPersistence().findAll(); 900 } 901 902 /** 903 * Returns a range of all the message boards thread flags. 904 * 905 * <p> 906 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadFlagModelImpl}. 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. 907 * </p> 908 * 909 * @param start the lower bound of the range of message boards thread flags 910 * @param end the upper bound of the range of message boards thread flags (not inclusive) 911 * @return the range of message boards thread flags 912 */ 913 public static java.util.List<com.liferay.portlet.messageboards.model.MBThreadFlag> findAll( 914 int start, int end) { 915 return getPersistence().findAll(start, end); 916 } 917 918 /** 919 * Returns an ordered range of all the message boards thread flags. 920 * 921 * <p> 922 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadFlagModelImpl}. 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. 923 * </p> 924 * 925 * @param start the lower bound of the range of message boards thread flags 926 * @param end the upper bound of the range of message boards thread flags (not inclusive) 927 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 928 * @return the ordered range of message boards thread flags 929 */ 930 public static java.util.List<com.liferay.portlet.messageboards.model.MBThreadFlag> findAll( 931 int start, int end, 932 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBThreadFlag> orderByComparator) { 933 return getPersistence().findAll(start, end, orderByComparator); 934 } 935 936 /** 937 * Removes all the message boards thread flags from the database. 938 */ 939 public static void removeAll() { 940 getPersistence().removeAll(); 941 } 942 943 /** 944 * Returns the number of message boards thread flags. 945 * 946 * @return the number of message boards thread flags 947 */ 948 public static int countAll() { 949 return getPersistence().countAll(); 950 } 951 952 public static MBThreadFlagPersistence getPersistence() { 953 if (_persistence == null) { 954 _persistence = (MBThreadFlagPersistence)PortalBeanLocatorUtil.locate(MBThreadFlagPersistence.class.getName()); 955 956 ReferenceRegistry.registerReference(MBThreadFlagUtil.class, 957 "_persistence"); 958 } 959 960 return _persistence; 961 } 962 963 /** 964 * @deprecated As of 6.2.0 965 */ 966 @Deprecated 967 public void setPersistence(MBThreadFlagPersistence persistence) { 968 } 969 970 private static MBThreadFlagPersistence _persistence; 971 }