org.eclipse.collections.api.set.primitive.IntSet Java Examples

@Test
public void testQ5()
{
    IntSet testIds = IntSets.immutable.of(1, 2);
    CustomerList customers = new CustomerList(CustomerFinder.customerId().in(testIds));
    this.updateCountry(customers, "UK");

    MithraManager.getInstance().clearAllQueryCaches();
    Customer c1 = CustomerFinder.findOne(CustomerFinder.customerId().eq(1));
    Customer c2 = CustomerFinder.findOne(CustomerFinder.customerId().eq(2));

    //check that the two got updated
    Assert.assertEquals("UK", c1.getCountry());
    Assert.assertEquals("UK", c2.getCountry());

    //check that nobody else got updated.
    Verify.assertSize(2, new CustomerList(CustomerFinder.country().eq("UK")));
    Verify.assertSize(3, new CustomerList(CustomerFinder.country().notEq("UK")));
}
 

@Override
public Operation in(IntSet intSet)
{
    Operation op;
    switch (intSet.size())
    {
        case 0:
            op = new None(this);
            break;
        case 1:
            op = this.eq(intSet.intIterator().next());
            break;
        default:
            op = new IntegerInOperation(this, intSet);
            break;
    }

    return op;
}
 

@Override
public Operation notIn(IntSet intSet)
{
    Operation op;
    switch (intSet.size())
    {
        case 0:
            op = new All(this);
            break;
        case 1:
            op = this.notEq(intSet.intIterator().next());
            break;
        default:
            op = new IntegerNotInOperation(this, intSet);
            break;
    }

    return op;
}
 

@Test
    public void testQ5()
    {
        IntSet accountIds = IntSets.immutable.of(1, 2, 999);
        CustomerList customers = getCustomers(accountIds);
        Verify.assertSize(2, customers);

        int dbHitsBefore = MithraManagerProvider.getMithraManager().getDatabaseRetrieveCount();
        // Try un-commenting the following lines, running the test, and then
        // look at the debug messages output.
//        System.out.println("No more SQL SELECT after this point ...");
//        customers.getCustomerAt(0).getAccounts().size();
//        System.out.println("----====----");
//        customers.getCustomerAt(1).getAccounts().size();
//        System.out.println("----====****====----");
        Assert.assertEquals(dbHitsBefore, MithraManagerProvider.getMithraManager().getDatabaseRetrieveCount());
    }
 

@Override
public List get(int indexRef, IntSet intSetIndexValues)
{
    Index index = indices[indexRef - 1];
    MithraFastList result = new MithraFastList(this.getAverageReturnSize(index, intSetIndexValues.size()));
    IntIterator it = intSetIndexValues.intIterator();
    this.readWriteLock.acquireReadLock();
    try
    {
        while (it.hasNext())
        {
            addAllListToList(wrapObjectInList(index.get(it.next())), result);
        }
        return result;
    }
    finally
    {
        this.readWriteLock.release();
    }
}
 

@Override
public Operation notIn(IntSet set)
{
    Operation op;
    switch (set.size())
    {
        case 0:
            op = new All(this);
            break;
        case 1:
            op = this.notEq(set.intIterator().next());
            break;
        default:
            op = new IntegerNotInOperation(this, set);
            break;
    }

    return op;
}
 

@Override
public Operation in(IntSet set)
{
    Operation op;
    switch (set.size())
    {
        case 0:
            op = new None(this);
            break;
        case 1:
            op = this.eq(set.intIterator().next());
            break;
        default:
            op = new IntegerInOperation(this, set);
            break;
    }

    return op;
}
 

@Test
public void testQ11()
{
    int sizeBefore = CustomerFinder.findMany(CustomerFinder.all()).size();
    IntSet customerIds = IntSets.immutable.of(1, 2);
    deleteCustomers(customerIds);

    int sizeAfter = CustomerFinder.findMany(CustomerFinder.all()).size();
    Assert.assertEquals(-2, sizeAfter - sizeBefore);
}
 

@Override
public Operation in(final List objects, final Extractor extractor)
{
    final IntExtractor integerExtractor = (IntExtractor) extractor;
    final IntSet set = asSet(objects, integerExtractor);
    return this.in(set);
}
 

private IntSet asSet(List objects, IntExtractor integerExtractor)
{
    return this.asSet(objects, integerExtractor, new IntHashSet());
}
 

@Override
public Operation in(IntSet intSet)
{
    return new MappedOperation(this.mapper, this.wrappedAttribute.in(intSet));
}
 

@Override
public Operation notIn(IntSet intSet)
{
    return new MappedOperation(this.mapper, this.wrappedAttribute.notIn(intSet));
}
 

@Override
public List get(int indexRef, IntSet intSetIndexValues)
{
    throw new RuntimeException("not supported");
}
 

public void deleteCustomers(IntSet customers)
{
    Assert.fail("Implement this functionality to make the test pass");
}
 

@Override
public List get(int indexRef, IntSet intSetIndexValues)
{
    return this.filterByType(this.cache.get(indexRef, intSetIndexValues));
}
 

@Override
public abstract Operation notIn(IntSet intSet);
 

@Override
public IntSet select(IntPredicate predicate)
{
    return delegate.select(predicate);
}
 

@Override
public IntSet reject(IntPredicate predicate)
{
    return delegate.reject(predicate);
}
 

@Override
public IntSet freeze()
{
    return this;
}
 

public IntegerInOperation(IntegerAttribute attribute, IntSet intSet)
{
    super(attribute);
    this.set = intSet.freeze();
}
 

public IntegerNotInOperation(IntegerAttribute attribute, IntSet intSet)
{
    super(attribute);
    this.set = intSet.freeze();
}
 

public CustomerList getCustomers(IntSet customerIds)
{
    Assert.fail("Implement this functionality to make the test pass");
    return null;
}
 

@Override
public abstract Operation in(IntSet intSet);
 

List get(int indexRef, IntSet intSetIndexValues); 

Operation<Owner> in(IntSet intSet); 

Operation<Owner> notIn(IntSet intSet);