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 com.liferay.portlet.messageboards.service.persistence.impl.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 com.liferay.portlet.messageboards.service.persistence.impl.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 List<MBThreadFlag> findByUuid(java.lang.String uuid) { 119 return getPersistence().findByUuid(uuid); 120 } 121 122 /** 123 * Returns a range of all the message boards thread flags where uuid = ?. 124 * 125 * <p> 126 * 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 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. 127 * </p> 128 * 129 * @param uuid the uuid 130 * @param start the lower bound of the range of message boards thread flags 131 * @param end the upper bound of the range of message boards thread flags (not inclusive) 132 * @return the range of matching message boards thread flags 133 */ 134 public static List<MBThreadFlag> findByUuid(java.lang.String uuid, 135 int start, int end) { 136 return getPersistence().findByUuid(uuid, start, end); 137 } 138 139 /** 140 * Returns an ordered range of all the message boards thread flags where uuid = ?. 141 * 142 * <p> 143 * 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 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. 144 * </p> 145 * 146 * @param uuid the uuid 147 * @param start the lower bound of the range of message boards thread flags 148 * @param end the upper bound of the range of message boards thread flags (not inclusive) 149 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 150 * @return the ordered range of matching message boards thread flags 151 */ 152 public static List<MBThreadFlag> findByUuid(java.lang.String uuid, 153 int start, int end, OrderByComparator<MBThreadFlag> orderByComparator) { 154 return getPersistence().findByUuid(uuid, start, end, orderByComparator); 155 } 156 157 /** 158 * Returns an ordered range of all the message boards thread flags where uuid = ?. 159 * 160 * <p> 161 * 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 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. 162 * </p> 163 * 164 * @param uuid the uuid 165 * @param start the lower bound of the range of message boards thread flags 166 * @param end the upper bound of the range of message boards thread flags (not inclusive) 167 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 168 * @param retrieveFromCache whether to retrieve from the finder cache 169 * @return the ordered range of matching message boards thread flags 170 */ 171 public static List<MBThreadFlag> findByUuid(java.lang.String uuid, 172 int start, int end, OrderByComparator<MBThreadFlag> orderByComparator, 173 boolean retrieveFromCache) { 174 return getPersistence() 175 .findByUuid(uuid, start, end, orderByComparator, 176 retrieveFromCache); 177 } 178 179 /** 180 * Returns the first message boards thread flag in the ordered set where uuid = ?. 181 * 182 * @param uuid the uuid 183 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 184 * @return the first matching message boards thread flag 185 * @throws NoSuchThreadFlagException if a matching message boards thread flag could not be found 186 */ 187 public static MBThreadFlag findByUuid_First(java.lang.String uuid, 188 OrderByComparator<MBThreadFlag> orderByComparator) 189 throws com.liferay.portlet.messageboards.exception.NoSuchThreadFlagException { 190 return getPersistence().findByUuid_First(uuid, orderByComparator); 191 } 192 193 /** 194 * Returns the first message boards thread flag in the ordered set where uuid = ?. 195 * 196 * @param uuid the uuid 197 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 198 * @return the first matching message boards thread flag, or <code>null</code> if a matching message boards thread flag could not be found 199 */ 200 public static MBThreadFlag fetchByUuid_First(java.lang.String uuid, 201 OrderByComparator<MBThreadFlag> orderByComparator) { 202 return getPersistence().fetchByUuid_First(uuid, orderByComparator); 203 } 204 205 /** 206 * Returns the last message boards thread flag in the ordered set where uuid = ?. 207 * 208 * @param uuid the uuid 209 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 210 * @return the last matching message boards thread flag 211 * @throws NoSuchThreadFlagException if a matching message boards thread flag could not be found 212 */ 213 public static MBThreadFlag findByUuid_Last(java.lang.String uuid, 214 OrderByComparator<MBThreadFlag> orderByComparator) 215 throws com.liferay.portlet.messageboards.exception.NoSuchThreadFlagException { 216 return getPersistence().findByUuid_Last(uuid, orderByComparator); 217 } 218 219 /** 220 * Returns the last message boards thread flag in the ordered set where uuid = ?. 221 * 222 * @param uuid the uuid 223 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 224 * @return the last matching message boards thread flag, or <code>null</code> if a matching message boards thread flag could not be found 225 */ 226 public static MBThreadFlag fetchByUuid_Last(java.lang.String uuid, 227 OrderByComparator<MBThreadFlag> orderByComparator) { 228 return getPersistence().fetchByUuid_Last(uuid, orderByComparator); 229 } 230 231 /** 232 * Returns the message boards thread flags before and after the current message boards thread flag in the ordered set where uuid = ?. 233 * 234 * @param threadFlagId the primary key of the current message boards thread flag 235 * @param uuid the uuid 236 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 237 * @return the previous, current, and next message boards thread flag 238 * @throws NoSuchThreadFlagException if a message boards thread flag with the primary key could not be found 239 */ 240 public static MBThreadFlag[] findByUuid_PrevAndNext(long threadFlagId, 241 java.lang.String uuid, OrderByComparator<MBThreadFlag> orderByComparator) 242 throws com.liferay.portlet.messageboards.exception.NoSuchThreadFlagException { 243 return getPersistence() 244 .findByUuid_PrevAndNext(threadFlagId, uuid, orderByComparator); 245 } 246 247 /** 248 * Removes all the message boards thread flags where uuid = ? from the database. 249 * 250 * @param uuid the uuid 251 */ 252 public static void removeByUuid(java.lang.String uuid) { 253 getPersistence().removeByUuid(uuid); 254 } 255 256 /** 257 * Returns the number of message boards thread flags where uuid = ?. 258 * 259 * @param uuid the uuid 260 * @return the number of matching message boards thread flags 261 */ 262 public static int countByUuid(java.lang.String uuid) { 263 return getPersistence().countByUuid(uuid); 264 } 265 266 /** 267 * Returns the message boards thread flag where uuid = ? and groupId = ? or throws a {@link NoSuchThreadFlagException} if it could not be found. 268 * 269 * @param uuid the uuid 270 * @param groupId the group ID 271 * @return the matching message boards thread flag 272 * @throws NoSuchThreadFlagException if a matching message boards thread flag could not be found 273 */ 274 public static MBThreadFlag findByUUID_G(java.lang.String uuid, long groupId) 275 throws com.liferay.portlet.messageboards.exception.NoSuchThreadFlagException { 276 return getPersistence().findByUUID_G(uuid, groupId); 277 } 278 279 /** 280 * 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. 281 * 282 * @param uuid the uuid 283 * @param groupId the group ID 284 * @return the matching message boards thread flag, or <code>null</code> if a matching message boards thread flag could not be found 285 */ 286 public static MBThreadFlag fetchByUUID_G(java.lang.String uuid, long groupId) { 287 return getPersistence().fetchByUUID_G(uuid, groupId); 288 } 289 290 /** 291 * 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. 292 * 293 * @param uuid the uuid 294 * @param groupId the group ID 295 * @param retrieveFromCache whether to retrieve from the finder cache 296 * @return the matching message boards thread flag, or <code>null</code> if a matching message boards thread flag could not be found 297 */ 298 public static MBThreadFlag fetchByUUID_G(java.lang.String uuid, 299 long groupId, boolean retrieveFromCache) { 300 return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache); 301 } 302 303 /** 304 * Removes the message boards thread flag where uuid = ? and groupId = ? from the database. 305 * 306 * @param uuid the uuid 307 * @param groupId the group ID 308 * @return the message boards thread flag that was removed 309 */ 310 public static MBThreadFlag removeByUUID_G(java.lang.String uuid, 311 long groupId) 312 throws com.liferay.portlet.messageboards.exception.NoSuchThreadFlagException { 313 return getPersistence().removeByUUID_G(uuid, groupId); 314 } 315 316 /** 317 * Returns the number of message boards thread flags where uuid = ? and groupId = ?. 318 * 319 * @param uuid the uuid 320 * @param groupId the group ID 321 * @return the number of matching message boards thread flags 322 */ 323 public static int countByUUID_G(java.lang.String uuid, long groupId) { 324 return getPersistence().countByUUID_G(uuid, groupId); 325 } 326 327 /** 328 * Returns all the message boards thread flags where uuid = ? and companyId = ?. 329 * 330 * @param uuid the uuid 331 * @param companyId the company ID 332 * @return the matching message boards thread flags 333 */ 334 public static List<MBThreadFlag> findByUuid_C(java.lang.String uuid, 335 long companyId) { 336 return getPersistence().findByUuid_C(uuid, companyId); 337 } 338 339 /** 340 * Returns a range of all the message boards thread flags where uuid = ? and companyId = ?. 341 * 342 * <p> 343 * 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 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. 344 * </p> 345 * 346 * @param uuid the uuid 347 * @param companyId the company ID 348 * @param start the lower bound of the range of message boards thread flags 349 * @param end the upper bound of the range of message boards thread flags (not inclusive) 350 * @return the range of matching message boards thread flags 351 */ 352 public static List<MBThreadFlag> findByUuid_C(java.lang.String uuid, 353 long companyId, int start, int end) { 354 return getPersistence().findByUuid_C(uuid, companyId, start, end); 355 } 356 357 /** 358 * Returns an ordered range of all the message boards thread flags where uuid = ? and companyId = ?. 359 * 360 * <p> 361 * 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 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. 362 * </p> 363 * 364 * @param uuid the uuid 365 * @param companyId the company ID 366 * @param start the lower bound of the range of message boards thread flags 367 * @param end the upper bound of the range of message boards thread flags (not inclusive) 368 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 369 * @return the ordered range of matching message boards thread flags 370 */ 371 public static List<MBThreadFlag> findByUuid_C(java.lang.String uuid, 372 long companyId, int start, int end, 373 OrderByComparator<MBThreadFlag> orderByComparator) { 374 return getPersistence() 375 .findByUuid_C(uuid, companyId, start, end, orderByComparator); 376 } 377 378 /** 379 * Returns an ordered range of all the message boards thread flags where uuid = ? and companyId = ?. 380 * 381 * <p> 382 * 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 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. 383 * </p> 384 * 385 * @param uuid the uuid 386 * @param companyId the company ID 387 * @param start the lower bound of the range of message boards thread flags 388 * @param end the upper bound of the range of message boards thread flags (not inclusive) 389 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 390 * @param retrieveFromCache whether to retrieve from the finder cache 391 * @return the ordered range of matching message boards thread flags 392 */ 393 public static List<MBThreadFlag> findByUuid_C(java.lang.String uuid, 394 long companyId, int start, int end, 395 OrderByComparator<MBThreadFlag> orderByComparator, 396 boolean retrieveFromCache) { 397 return getPersistence() 398 .findByUuid_C(uuid, companyId, start, end, 399 orderByComparator, retrieveFromCache); 400 } 401 402 /** 403 * Returns the first message boards thread flag in the ordered set where uuid = ? and companyId = ?. 404 * 405 * @param uuid the uuid 406 * @param companyId the company ID 407 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 408 * @return the first matching message boards thread flag 409 * @throws NoSuchThreadFlagException if a matching message boards thread flag could not be found 410 */ 411 public static MBThreadFlag findByUuid_C_First(java.lang.String uuid, 412 long companyId, OrderByComparator<MBThreadFlag> orderByComparator) 413 throws com.liferay.portlet.messageboards.exception.NoSuchThreadFlagException { 414 return getPersistence() 415 .findByUuid_C_First(uuid, companyId, orderByComparator); 416 } 417 418 /** 419 * Returns the first message boards thread flag in the ordered set where uuid = ? and companyId = ?. 420 * 421 * @param uuid the uuid 422 * @param companyId the company ID 423 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 424 * @return the first matching message boards thread flag, or <code>null</code> if a matching message boards thread flag could not be found 425 */ 426 public static MBThreadFlag fetchByUuid_C_First(java.lang.String uuid, 427 long companyId, OrderByComparator<MBThreadFlag> orderByComparator) { 428 return getPersistence() 429 .fetchByUuid_C_First(uuid, companyId, orderByComparator); 430 } 431 432 /** 433 * Returns the last message boards thread flag in the ordered set where uuid = ? and companyId = ?. 434 * 435 * @param uuid the uuid 436 * @param companyId the company ID 437 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 438 * @return the last matching message boards thread flag 439 * @throws NoSuchThreadFlagException if a matching message boards thread flag could not be found 440 */ 441 public static MBThreadFlag findByUuid_C_Last(java.lang.String uuid, 442 long companyId, OrderByComparator<MBThreadFlag> orderByComparator) 443 throws com.liferay.portlet.messageboards.exception.NoSuchThreadFlagException { 444 return getPersistence() 445 .findByUuid_C_Last(uuid, companyId, orderByComparator); 446 } 447 448 /** 449 * Returns the last message boards thread flag in the ordered set where uuid = ? and companyId = ?. 450 * 451 * @param uuid the uuid 452 * @param companyId the company ID 453 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 454 * @return the last matching message boards thread flag, or <code>null</code> if a matching message boards thread flag could not be found 455 */ 456 public static MBThreadFlag fetchByUuid_C_Last(java.lang.String uuid, 457 long companyId, OrderByComparator<MBThreadFlag> orderByComparator) { 458 return getPersistence() 459 .fetchByUuid_C_Last(uuid, companyId, orderByComparator); 460 } 461 462 /** 463 * Returns the message boards thread flags before and after the current message boards thread flag in the ordered set where uuid = ? and companyId = ?. 464 * 465 * @param threadFlagId the primary key of the current message boards thread flag 466 * @param uuid the uuid 467 * @param companyId the company ID 468 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 469 * @return the previous, current, and next message boards thread flag 470 * @throws NoSuchThreadFlagException if a message boards thread flag with the primary key could not be found 471 */ 472 public static MBThreadFlag[] findByUuid_C_PrevAndNext(long threadFlagId, 473 java.lang.String uuid, long companyId, 474 OrderByComparator<MBThreadFlag> orderByComparator) 475 throws com.liferay.portlet.messageboards.exception.NoSuchThreadFlagException { 476 return getPersistence() 477 .findByUuid_C_PrevAndNext(threadFlagId, uuid, companyId, 478 orderByComparator); 479 } 480 481 /** 482 * Removes all the message boards thread flags where uuid = ? and companyId = ? from the database. 483 * 484 * @param uuid the uuid 485 * @param companyId the company ID 486 */ 487 public static void removeByUuid_C(java.lang.String uuid, long companyId) { 488 getPersistence().removeByUuid_C(uuid, companyId); 489 } 490 491 /** 492 * Returns the number of message boards thread flags where uuid = ? and companyId = ?. 493 * 494 * @param uuid the uuid 495 * @param companyId the company ID 496 * @return the number of matching message boards thread flags 497 */ 498 public static int countByUuid_C(java.lang.String uuid, long companyId) { 499 return getPersistence().countByUuid_C(uuid, companyId); 500 } 501 502 /** 503 * Returns all the message boards thread flags where userId = ?. 504 * 505 * @param userId the user ID 506 * @return the matching message boards thread flags 507 */ 508 public static List<MBThreadFlag> findByUserId(long userId) { 509 return getPersistence().findByUserId(userId); 510 } 511 512 /** 513 * Returns a range of all the message boards thread flags where userId = ?. 514 * 515 * <p> 516 * 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 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. 517 * </p> 518 * 519 * @param userId the user ID 520 * @param start the lower bound of the range of message boards thread flags 521 * @param end the upper bound of the range of message boards thread flags (not inclusive) 522 * @return the range of matching message boards thread flags 523 */ 524 public static List<MBThreadFlag> findByUserId(long userId, int start, 525 int end) { 526 return getPersistence().findByUserId(userId, start, end); 527 } 528 529 /** 530 * Returns an ordered range of all the message boards thread flags where userId = ?. 531 * 532 * <p> 533 * 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 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. 534 * </p> 535 * 536 * @param userId the user ID 537 * @param start the lower bound of the range of message boards thread flags 538 * @param end the upper bound of the range of message boards thread flags (not inclusive) 539 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 540 * @return the ordered range of matching message boards thread flags 541 */ 542 public static List<MBThreadFlag> findByUserId(long userId, int start, 543 int end, OrderByComparator<MBThreadFlag> orderByComparator) { 544 return getPersistence() 545 .findByUserId(userId, start, end, orderByComparator); 546 } 547 548 /** 549 * Returns an ordered range of all the message boards thread flags where userId = ?. 550 * 551 * <p> 552 * 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 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. 553 * </p> 554 * 555 * @param userId the user ID 556 * @param start the lower bound of the range of message boards thread flags 557 * @param end the upper bound of the range of message boards thread flags (not inclusive) 558 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 559 * @param retrieveFromCache whether to retrieve from the finder cache 560 * @return the ordered range of matching message boards thread flags 561 */ 562 public static List<MBThreadFlag> findByUserId(long userId, int start, 563 int end, OrderByComparator<MBThreadFlag> orderByComparator, 564 boolean retrieveFromCache) { 565 return getPersistence() 566 .findByUserId(userId, start, end, orderByComparator, 567 retrieveFromCache); 568 } 569 570 /** 571 * Returns the first message boards thread flag in the ordered set where userId = ?. 572 * 573 * @param userId the user ID 574 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 575 * @return the first matching message boards thread flag 576 * @throws NoSuchThreadFlagException if a matching message boards thread flag could not be found 577 */ 578 public static MBThreadFlag findByUserId_First(long userId, 579 OrderByComparator<MBThreadFlag> orderByComparator) 580 throws com.liferay.portlet.messageboards.exception.NoSuchThreadFlagException { 581 return getPersistence().findByUserId_First(userId, orderByComparator); 582 } 583 584 /** 585 * Returns the first message boards thread flag in the ordered set where userId = ?. 586 * 587 * @param userId the user ID 588 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 589 * @return the first matching message boards thread flag, or <code>null</code> if a matching message boards thread flag could not be found 590 */ 591 public static MBThreadFlag fetchByUserId_First(long userId, 592 OrderByComparator<MBThreadFlag> orderByComparator) { 593 return getPersistence().fetchByUserId_First(userId, orderByComparator); 594 } 595 596 /** 597 * Returns the last message boards thread flag in the ordered set where userId = ?. 598 * 599 * @param userId the user ID 600 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 601 * @return the last matching message boards thread flag 602 * @throws NoSuchThreadFlagException if a matching message boards thread flag could not be found 603 */ 604 public static MBThreadFlag findByUserId_Last(long userId, 605 OrderByComparator<MBThreadFlag> orderByComparator) 606 throws com.liferay.portlet.messageboards.exception.NoSuchThreadFlagException { 607 return getPersistence().findByUserId_Last(userId, orderByComparator); 608 } 609 610 /** 611 * Returns the last message boards thread flag in the ordered set where userId = ?. 612 * 613 * @param userId the user ID 614 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 615 * @return the last matching message boards thread flag, or <code>null</code> if a matching message boards thread flag could not be found 616 */ 617 public static MBThreadFlag fetchByUserId_Last(long userId, 618 OrderByComparator<MBThreadFlag> orderByComparator) { 619 return getPersistence().fetchByUserId_Last(userId, orderByComparator); 620 } 621 622 /** 623 * Returns the message boards thread flags before and after the current message boards thread flag in the ordered set where userId = ?. 624 * 625 * @param threadFlagId the primary key of the current message boards thread flag 626 * @param userId the user ID 627 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 628 * @return the previous, current, and next message boards thread flag 629 * @throws NoSuchThreadFlagException if a message boards thread flag with the primary key could not be found 630 */ 631 public static MBThreadFlag[] findByUserId_PrevAndNext(long threadFlagId, 632 long userId, OrderByComparator<MBThreadFlag> orderByComparator) 633 throws com.liferay.portlet.messageboards.exception.NoSuchThreadFlagException { 634 return getPersistence() 635 .findByUserId_PrevAndNext(threadFlagId, userId, 636 orderByComparator); 637 } 638 639 /** 640 * Removes all the message boards thread flags where userId = ? from the database. 641 * 642 * @param userId the user ID 643 */ 644 public static void removeByUserId(long userId) { 645 getPersistence().removeByUserId(userId); 646 } 647 648 /** 649 * Returns the number of message boards thread flags where userId = ?. 650 * 651 * @param userId the user ID 652 * @return the number of matching message boards thread flags 653 */ 654 public static int countByUserId(long userId) { 655 return getPersistence().countByUserId(userId); 656 } 657 658 /** 659 * Returns all the message boards thread flags where threadId = ?. 660 * 661 * @param threadId the thread ID 662 * @return the matching message boards thread flags 663 */ 664 public static List<MBThreadFlag> findByThreadId(long threadId) { 665 return getPersistence().findByThreadId(threadId); 666 } 667 668 /** 669 * Returns a range of all the message boards thread flags where threadId = ?. 670 * 671 * <p> 672 * 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 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. 673 * </p> 674 * 675 * @param threadId the thread ID 676 * @param start the lower bound of the range of message boards thread flags 677 * @param end the upper bound of the range of message boards thread flags (not inclusive) 678 * @return the range of matching message boards thread flags 679 */ 680 public static List<MBThreadFlag> findByThreadId(long threadId, int start, 681 int end) { 682 return getPersistence().findByThreadId(threadId, start, end); 683 } 684 685 /** 686 * Returns an ordered range of all the message boards thread flags where threadId = ?. 687 * 688 * <p> 689 * 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 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. 690 * </p> 691 * 692 * @param threadId the thread ID 693 * @param start the lower bound of the range of message boards thread flags 694 * @param end the upper bound of the range of message boards thread flags (not inclusive) 695 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 696 * @return the ordered range of matching message boards thread flags 697 */ 698 public static List<MBThreadFlag> findByThreadId(long threadId, int start, 699 int end, OrderByComparator<MBThreadFlag> orderByComparator) { 700 return getPersistence() 701 .findByThreadId(threadId, start, end, orderByComparator); 702 } 703 704 /** 705 * Returns an ordered range of all the message boards thread flags where threadId = ?. 706 * 707 * <p> 708 * 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 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. 709 * </p> 710 * 711 * @param threadId the thread ID 712 * @param start the lower bound of the range of message boards thread flags 713 * @param end the upper bound of the range of message boards thread flags (not inclusive) 714 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 715 * @param retrieveFromCache whether to retrieve from the finder cache 716 * @return the ordered range of matching message boards thread flags 717 */ 718 public static List<MBThreadFlag> findByThreadId(long threadId, int start, 719 int end, OrderByComparator<MBThreadFlag> orderByComparator, 720 boolean retrieveFromCache) { 721 return getPersistence() 722 .findByThreadId(threadId, start, end, orderByComparator, 723 retrieveFromCache); 724 } 725 726 /** 727 * Returns the first message boards thread flag in the ordered set where threadId = ?. 728 * 729 * @param threadId the thread ID 730 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 731 * @return the first matching message boards thread flag 732 * @throws NoSuchThreadFlagException if a matching message boards thread flag could not be found 733 */ 734 public static MBThreadFlag findByThreadId_First(long threadId, 735 OrderByComparator<MBThreadFlag> orderByComparator) 736 throws com.liferay.portlet.messageboards.exception.NoSuchThreadFlagException { 737 return getPersistence().findByThreadId_First(threadId, orderByComparator); 738 } 739 740 /** 741 * Returns the first message boards thread flag in the ordered set where threadId = ?. 742 * 743 * @param threadId the thread ID 744 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 745 * @return the first matching message boards thread flag, or <code>null</code> if a matching message boards thread flag could not be found 746 */ 747 public static MBThreadFlag fetchByThreadId_First(long threadId, 748 OrderByComparator<MBThreadFlag> orderByComparator) { 749 return getPersistence() 750 .fetchByThreadId_First(threadId, orderByComparator); 751 } 752 753 /** 754 * Returns the last message boards thread flag in the ordered set where threadId = ?. 755 * 756 * @param threadId the thread ID 757 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 758 * @return the last matching message boards thread flag 759 * @throws NoSuchThreadFlagException if a matching message boards thread flag could not be found 760 */ 761 public static MBThreadFlag findByThreadId_Last(long threadId, 762 OrderByComparator<MBThreadFlag> orderByComparator) 763 throws com.liferay.portlet.messageboards.exception.NoSuchThreadFlagException { 764 return getPersistence().findByThreadId_Last(threadId, orderByComparator); 765 } 766 767 /** 768 * Returns the last message boards thread flag in the ordered set where threadId = ?. 769 * 770 * @param threadId the thread ID 771 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 772 * @return the last matching message boards thread flag, or <code>null</code> if a matching message boards thread flag could not be found 773 */ 774 public static MBThreadFlag fetchByThreadId_Last(long threadId, 775 OrderByComparator<MBThreadFlag> orderByComparator) { 776 return getPersistence().fetchByThreadId_Last(threadId, orderByComparator); 777 } 778 779 /** 780 * Returns the message boards thread flags before and after the current message boards thread flag in the ordered set where threadId = ?. 781 * 782 * @param threadFlagId the primary key of the current message boards thread flag 783 * @param threadId the thread ID 784 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 785 * @return the previous, current, and next message boards thread flag 786 * @throws NoSuchThreadFlagException if a message boards thread flag with the primary key could not be found 787 */ 788 public static MBThreadFlag[] findByThreadId_PrevAndNext(long threadFlagId, 789 long threadId, OrderByComparator<MBThreadFlag> orderByComparator) 790 throws com.liferay.portlet.messageboards.exception.NoSuchThreadFlagException { 791 return getPersistence() 792 .findByThreadId_PrevAndNext(threadFlagId, threadId, 793 orderByComparator); 794 } 795 796 /** 797 * Removes all the message boards thread flags where threadId = ? from the database. 798 * 799 * @param threadId the thread ID 800 */ 801 public static void removeByThreadId(long threadId) { 802 getPersistence().removeByThreadId(threadId); 803 } 804 805 /** 806 * Returns the number of message boards thread flags where threadId = ?. 807 * 808 * @param threadId the thread ID 809 * @return the number of matching message boards thread flags 810 */ 811 public static int countByThreadId(long threadId) { 812 return getPersistence().countByThreadId(threadId); 813 } 814 815 /** 816 * Returns the message boards thread flag where userId = ? and threadId = ? or throws a {@link NoSuchThreadFlagException} if it could not be found. 817 * 818 * @param userId the user ID 819 * @param threadId the thread ID 820 * @return the matching message boards thread flag 821 * @throws NoSuchThreadFlagException if a matching message boards thread flag could not be found 822 */ 823 public static MBThreadFlag findByU_T(long userId, long threadId) 824 throws com.liferay.portlet.messageboards.exception.NoSuchThreadFlagException { 825 return getPersistence().findByU_T(userId, threadId); 826 } 827 828 /** 829 * 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. 830 * 831 * @param userId the user ID 832 * @param threadId the thread ID 833 * @return the matching message boards thread flag, or <code>null</code> if a matching message boards thread flag could not be found 834 */ 835 public static MBThreadFlag fetchByU_T(long userId, long threadId) { 836 return getPersistence().fetchByU_T(userId, threadId); 837 } 838 839 /** 840 * 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. 841 * 842 * @param userId the user ID 843 * @param threadId the thread ID 844 * @param retrieveFromCache whether to retrieve from the finder cache 845 * @return the matching message boards thread flag, or <code>null</code> if a matching message boards thread flag could not be found 846 */ 847 public static MBThreadFlag fetchByU_T(long userId, long threadId, 848 boolean retrieveFromCache) { 849 return getPersistence().fetchByU_T(userId, threadId, retrieveFromCache); 850 } 851 852 /** 853 * Removes the message boards thread flag where userId = ? and threadId = ? from the database. 854 * 855 * @param userId the user ID 856 * @param threadId the thread ID 857 * @return the message boards thread flag that was removed 858 */ 859 public static MBThreadFlag removeByU_T(long userId, long threadId) 860 throws com.liferay.portlet.messageboards.exception.NoSuchThreadFlagException { 861 return getPersistence().removeByU_T(userId, threadId); 862 } 863 864 /** 865 * Returns the number of message boards thread flags where userId = ? and threadId = ?. 866 * 867 * @param userId the user ID 868 * @param threadId the thread ID 869 * @return the number of matching message boards thread flags 870 */ 871 public static int countByU_T(long userId, long threadId) { 872 return getPersistence().countByU_T(userId, threadId); 873 } 874 875 /** 876 * Caches the message boards thread flag in the entity cache if it is enabled. 877 * 878 * @param mbThreadFlag the message boards thread flag 879 */ 880 public static void cacheResult(MBThreadFlag mbThreadFlag) { 881 getPersistence().cacheResult(mbThreadFlag); 882 } 883 884 /** 885 * Caches the message boards thread flags in the entity cache if it is enabled. 886 * 887 * @param mbThreadFlags the message boards thread flags 888 */ 889 public static void cacheResult(List<MBThreadFlag> mbThreadFlags) { 890 getPersistence().cacheResult(mbThreadFlags); 891 } 892 893 /** 894 * Creates a new message boards thread flag with the primary key. Does not add the message boards thread flag to the database. 895 * 896 * @param threadFlagId the primary key for the new message boards thread flag 897 * @return the new message boards thread flag 898 */ 899 public static MBThreadFlag create(long threadFlagId) { 900 return getPersistence().create(threadFlagId); 901 } 902 903 /** 904 * Removes the message boards thread flag with the primary key from the database. Also notifies the appropriate model listeners. 905 * 906 * @param threadFlagId the primary key of the message boards thread flag 907 * @return the message boards thread flag that was removed 908 * @throws NoSuchThreadFlagException if a message boards thread flag with the primary key could not be found 909 */ 910 public static MBThreadFlag remove(long threadFlagId) 911 throws com.liferay.portlet.messageboards.exception.NoSuchThreadFlagException { 912 return getPersistence().remove(threadFlagId); 913 } 914 915 public static MBThreadFlag updateImpl(MBThreadFlag mbThreadFlag) { 916 return getPersistence().updateImpl(mbThreadFlag); 917 } 918 919 /** 920 * Returns the message boards thread flag with the primary key or throws a {@link NoSuchThreadFlagException} if it could not be found. 921 * 922 * @param threadFlagId the primary key of the message boards thread flag 923 * @return the message boards thread flag 924 * @throws NoSuchThreadFlagException if a message boards thread flag with the primary key could not be found 925 */ 926 public static MBThreadFlag findByPrimaryKey(long threadFlagId) 927 throws com.liferay.portlet.messageboards.exception.NoSuchThreadFlagException { 928 return getPersistence().findByPrimaryKey(threadFlagId); 929 } 930 931 /** 932 * Returns the message boards thread flag with the primary key or returns <code>null</code> if it could not be found. 933 * 934 * @param threadFlagId the primary key of the message boards thread flag 935 * @return the message boards thread flag, or <code>null</code> if a message boards thread flag with the primary key could not be found 936 */ 937 public static MBThreadFlag fetchByPrimaryKey(long threadFlagId) { 938 return getPersistence().fetchByPrimaryKey(threadFlagId); 939 } 940 941 public static java.util.Map<java.io.Serializable, MBThreadFlag> fetchByPrimaryKeys( 942 java.util.Set<java.io.Serializable> primaryKeys) { 943 return getPersistence().fetchByPrimaryKeys(primaryKeys); 944 } 945 946 /** 947 * Returns all the message boards thread flags. 948 * 949 * @return the message boards thread flags 950 */ 951 public static List<MBThreadFlag> findAll() { 952 return getPersistence().findAll(); 953 } 954 955 /** 956 * Returns a range of all the message boards thread flags. 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 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. 960 * </p> 961 * 962 * @param start the lower bound of the range of message boards thread flags 963 * @param end the upper bound of the range of message boards thread flags (not inclusive) 964 * @return the range of message boards thread flags 965 */ 966 public static List<MBThreadFlag> findAll(int start, int end) { 967 return getPersistence().findAll(start, end); 968 } 969 970 /** 971 * Returns an ordered range of all the message boards thread flags. 972 * 973 * <p> 974 * 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 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. 975 * </p> 976 * 977 * @param start the lower bound of the range of message boards thread flags 978 * @param end the upper bound of the range of message boards thread flags (not inclusive) 979 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 980 * @return the ordered range of message boards thread flags 981 */ 982 public static List<MBThreadFlag> findAll(int start, int end, 983 OrderByComparator<MBThreadFlag> orderByComparator) { 984 return getPersistence().findAll(start, end, orderByComparator); 985 } 986 987 /** 988 * Returns an ordered range of all the message boards thread flags. 989 * 990 * <p> 991 * 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 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. 992 * </p> 993 * 994 * @param start the lower bound of the range of message boards thread flags 995 * @param end the upper bound of the range of message boards thread flags (not inclusive) 996 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 997 * @param retrieveFromCache whether to retrieve from the finder cache 998 * @return the ordered range of message boards thread flags 999 */ 1000 public static List<MBThreadFlag> findAll(int start, int end, 1001 OrderByComparator<MBThreadFlag> orderByComparator, 1002 boolean retrieveFromCache) { 1003 return getPersistence() 1004 .findAll(start, end, orderByComparator, retrieveFromCache); 1005 } 1006 1007 /** 1008 * Removes all the message boards thread flags from the database. 1009 */ 1010 public static void removeAll() { 1011 getPersistence().removeAll(); 1012 } 1013 1014 /** 1015 * Returns the number of message boards thread flags. 1016 * 1017 * @return the number of message boards thread flags 1018 */ 1019 public static int countAll() { 1020 return getPersistence().countAll(); 1021 } 1022 1023 public static java.util.Set<java.lang.String> getBadColumnNames() { 1024 return getPersistence().getBadColumnNames(); 1025 } 1026 1027 public static MBThreadFlagPersistence getPersistence() { 1028 if (_persistence == null) { 1029 _persistence = (MBThreadFlagPersistence)PortalBeanLocatorUtil.locate(MBThreadFlagPersistence.class.getName()); 1030 1031 ReferenceRegistry.registerReference(MBThreadFlagUtil.class, 1032 "_persistence"); 1033 } 1034 1035 return _persistence; 1036 } 1037 1038 private static MBThreadFlagPersistence _persistence; 1039 }