directmemory-cache/src/main/java/org/apache/directmemory/DirectMemory.java

package org.apache.directmemory;

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

import static com.google.common.base.Preconditions.checkArgument;
import static java.lang.String.format;
import static org.apache.directmemory.measures.In.seconds;
import static org.apache.directmemory.serialization.SerializerFactory.createNewSerializer;

import java.util.concurrent.ConcurrentMap;

import org.apache.directmemory.cache.CacheService;
import org.apache.directmemory.cache.CacheServiceImpl;
import org.apache.directmemory.measures.Ram;
import org.apache.directmemory.memory.MemoryManagerService;
import org.apache.directmemory.memory.MemoryManagerServiceImpl;
import org.apache.directmemory.memory.Pointer;
import org.apache.directmemory.serialization.Serializer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.google.common.collect.MapMaker;

public final class DirectMemory<K, V>
{

    public static final int DEFAULT_CONCURRENCY_LEVEL = 4;

    public static final int DEFAULT_INITIAL_CAPACITY = 100000;

    public static final int DEFAULT_DISPOSAL_TIME = 10; // seconds

    private final Logger logger = LoggerFactory.getLogger( getClass() );

    private int numberOfBuffers;

    private int size;

    private int initialCapacity = DEFAULT_INITIAL_CAPACITY;

    private int concurrencyLevel = DEFAULT_CONCURRENCY_LEVEL;

    private long disposalTime = seconds( DEFAULT_DISPOSAL_TIME );

    private ConcurrentMap<K, Pointer<V>> map;

    private Serializer serializer;

    private MemoryManagerService<V> memoryManager;

    public DirectMemory()
    {
        // does nothing
    }

    public DirectMemory( DirectMemory<K, V> prototype )
    {
        checkArgument( prototype != null, "Impossible to create a DirectMemory instance from a null prototype" );

        numberOfBuffers = prototype.numberOfBuffers;
        size = prototype.size;
        initialCapacity = prototype.initialCapacity;
        concurrencyLevel = prototype.concurrencyLevel;
        disposalTime = prototype.disposalTime;

        map = prototype.map;
        serializer = prototype.serializer;
        memoryManager = prototype.memoryManager;
    }

    public DirectMemory<K, V> setNumberOfBuffers( int numberOfBuffers )
    {
        checkArgument( numberOfBuffers > 0, "Impossible to create a CacheService with a number of buffers lesser than 1" );
        this.numberOfBuffers = numberOfBuffers;
        return this;
    }

    public DirectMemory<K, V> setSize( int size )
    {
        checkArgument( size > 0, "Impossible to create a CacheService with a size lesser than 1" );
        this.size = size;
        return this;
    }

    public DirectMemory<K, V> setInitialCapacity( int initialCapacity )
    {
        checkArgument( initialCapacity > 0, "Impossible to create a CacheService with an initialCapacity lesser than 1" );
        this.initialCapacity = initialCapacity;
        return this;
    }

    public DirectMemory<K, V> setConcurrencyLevel( int concurrencyLevel )
    {
        checkArgument( concurrencyLevel > 0, "Impossible to create a CacheService with a concurrencyLevel lesser than 1" );
        this.concurrencyLevel = concurrencyLevel;
        return this;
    }

    public DirectMemory<K, V> setDisposalTime( long disposalTime )
    {
        checkArgument( disposalTime > 0, "Impossible to create a CacheService with a disposalTime lesser than 1" );
        this.disposalTime = disposalTime;
        return this;
    }

    public DirectMemory<K, V> setMap( ConcurrentMap<K, Pointer<V>> map )
    {
        checkArgument( map != null, "Impossible to create a CacheService with a null map" );
        this.map = map;
        return this;
    }

    public DirectMemory<K, V> setSerializer( Serializer serializer )
    {
        checkArgument( serializer != null, "Impossible to create a CacheService with a null serializer" );
        this.serializer = serializer;
        return this;
    }

    public DirectMemory<K, V> setMemoryManager( MemoryManagerService<V> memoryManager )
    {
        checkArgument( memoryManager != null, "Impossible to create a CacheService with a null memoryManager" );
        this.memoryManager = memoryManager;
        return this;
    }

    public CacheService<K, V> newCacheService()
    {
        if ( map == null )
        {
            map = new MapMaker().concurrencyLevel( concurrencyLevel ).initialCapacity( initialCapacity ).makeMap();
        }
        if ( memoryManager == null )
        {
            memoryManager = new MemoryManagerServiceImpl<V>();
        }
        if ( serializer == null )
        {
            serializer = createNewSerializer();
        }

        logger.info( "******************************** initializing *******************************" );
        logger.info( "         ____  _                 __  __  ___" );
        logger.info( "        / __ \\(_)________  _____/ /_/  |/  /___  ____ ___  ____  _______  __" );
        logger.info( "       / / / / // ___/ _ \\/ ___/ __/ /|_/ // _ \\/ __ `__ \\/ __ \\/ ___/ / / /" );
        logger.info( "      / /_/ / // /  /  __/ /__/ /_/ /  / //  __/ / / / / / /_/ / /  / /_/ / " );
        logger.info( "     /_____/_//_/   \\___/\\___/\\__/_/  /_/ \\___/_/ /_/ /_/\\____/_/   \\__, /" );
        logger.info( "                                                                   /____/   " );
        logger.info( "********************************************************************************" );

        memoryManager.init( numberOfBuffers, size );

        logger.info( "initialized" );
        logger.info( format( "number of buffer(s): \t%1d  with %2s each", numberOfBuffers, Ram.inMb( size ) ) );
        logger.info( format( "initial capacity: \t%1d", initialCapacity ) );
        logger.info( format( "concurrency level: \t%1d", concurrencyLevel ) );

        CacheService<K, V> cacheService = new CacheServiceImpl<K, V>( map, memoryManager, serializer );
        cacheService.scheduleDisposalEvery( disposalTime );
        return cacheService;
    }

}