/**
 *
 * @param limits
 *            the fixed limits to set
 */
public void setFixedLimitBySitePreset(final Map<String, Long> limits)
{
    ParameterCheck.mandatory("limits", limits);

    if (this.contentLimitProviderBySitePreset == null)
    {
        this.contentLimitProviderBySitePreset = new HashMap<>();
    }

    for (final Entry<String, Long> limitEntry : limits.entrySet())
    {
        final long limit = limitEntry.getValue().longValue();
        if (limit < 0 && limit != ContentLimitProvider.NO_LIMIT)
        {
            throw new IllegalArgumentException("fixedLimit must be non-negative");
        }
        this.contentLimitProviderBySitePreset.put(limitEntry.getKey(), new SimpleFixedLimitProvider(limit));
    }
}
 

/**
 *
 * @param limits
 *            the fixed limits to set
 */
public void setFixedLimitBySite(final Map<String, Long> limits)
{
    ParameterCheck.mandatory("limits", limits);

    if (this.contentLimitProviderBySite == null)
    {
        this.contentLimitProviderBySite = new HashMap<>();
    }

    for (final Entry<String, Long> limitEntry : limits.entrySet())
    {
        final long limit = limitEntry.getValue().longValue();
        if (limit < 0 && limit != ContentLimitProvider.NO_LIMIT)
        {
            throw new IllegalArgumentException("fixedLimit must be non-negative");
        }
        this.contentLimitProviderBySite.put(limitEntry.getKey(), new SimpleFixedLimitProvider(limit));
    }
}
 

/**
 * This method tests that writing content with a configured {@link ContentLimitProvider limit} fails with
 * the expected exception.
 * @since Thor
 */
@Test
public void testWriteFileWithSizeLimit() throws Exception
{
    ContentWriter writer = getWriter();
    assertEquals("Writer was of wrong type", FileContentWriter.class, writer.getClass());
    
    FileContentWriter fileContentWriter = (FileContentWriter)writer;
    
    // Set a maximum size limit for this writer. We use a limit of 3 bytes.
    ContentLimitProvider limitProvider = new SimpleFixedLimitProvider(3);
    fileContentWriter.setContentLimitProvider(limitProvider);
    
    // Attempt to write content that will exceed the limit.
    boolean expectedExceptionThrown = false;
    try
    {
        writer.putContent("This will exceed the short limit.");
    }
    catch (ContentLimitViolationException clvx)
    {
        expectedExceptionThrown = true;
    }
    
    assertTrue("Expected exception not thrown.", expectedExceptionThrown);
    assertTrue("Stream close not detected", writer.isClosed());
}
 

/**
 *
 * @param limit
 *            the fixed content limit to set
 */
public void setFixedLimit(final long limit)
{
    if (limit < 0 && limit != ContentLimitProvider.NO_LIMIT)
    {
        throw new IllegalArgumentException("fixedLimit must be non-negative");
    }
    this.setContentLimitProvider(new SimpleFixedLimitProvider(limit));
}
 

/**
 *
 * @param limit
 *            the fixed content limit to set
 */
public void setFixedLimit(final long limit)
{
    if (limit < 0 && limit != ContentLimitProvider.NO_LIMIT)
    {
        throw new IllegalArgumentException("fixedLimit must be non-negative");
    }
    this.setContentLimitProvider(new SimpleFixedLimitProvider(limit));
}
 

/**
 *
 * @param limit
 *            the fixed content limit to set
 */
public void setFixedLimit(final long limit)
{
    if (limit < 0 && limit != ContentLimitProvider.NO_LIMIT)
    {
        throw new IllegalArgumentException("fixedLimit must be non-negative");
    }
    this.setContentLimitProvider(new SimpleFixedLimitProvider(limit));
}
 

/**
 * Sets a new {@link ContentLimitProvider} which will provide a maximum filesize for content.
 */
public void setContentLimitProvider(ContentLimitProvider contentLimitProvider)
{
    this.contentLimitProvider = contentLimitProvider;
}
 

/**
 * @param contentLimitProviderBySitePreset
 *            the contentLimitProviderBySitePreset to set
 */
public void setContentLimitProviderBySitePreset(final Map<String, ContentLimitProvider> contentLimitProviderBySitePreset)
{
    this.contentLimitProviderBySitePreset = contentLimitProviderBySitePreset;
}
 

/**
 * @param contentLimitProviderBySite
 *            the contentLimitProviderBySite to set
 */
public void setContentLimitProviderBySite(final Map<String, ContentLimitProvider> contentLimitProviderBySite)
{
    this.contentLimitProviderBySite = contentLimitProviderBySite;
}
 

/**
 * @param contentLimitProvider
 *            the contentLimitProvider to set
 */
public void setContentLimitProvider(final ContentLimitProvider contentLimitProvider)
{
    this.contentLimitProvider = contentLimitProvider;
}
 

/**
 * @param contentLimitProvider
 *            the contentLimitProvider to set
 *
 */
public void setContentLimitProvider(final ContentLimitProvider contentLimitProvider)
{
    this.contentLimitProvider = contentLimitProvider;
}