coherence/net/ConfigurableCacheFactory.hpp

/*
* ConfigurableCacheFactory.hpp
*
* Copyright (c) 2000, 2009, Oracle and/or its affiliates. All rights reserved.
*
* Oracle is a registered trademarks of Oracle Corporation and/or its
* affiliates.
*
* This software is the confidential and proprietary information of Oracle
* Corporation. You shall not disclose such confidential and proprietary
* information and shall use it only in accordance with the terms of the
* license agreement you entered into with Oracle.
*
* This notice may not be removed or altered.
*/
#ifndef COH_CONFIGURABLE_CACHE_FACTORY_HPP
#define COH_CONFIGURABLE_CACHE_FACTORY_HPP

#include "coherence/lang.ns"

#include "coherence/net/NamedCache.hpp"
#include "coherence/net/Service.hpp"
#include "coherence/run/xml/XmlConfigurable.hpp"
#include "coherence/util/Map.hpp"

COH_OPEN_NAMESPACE2(coherence,net)

using coherence::run::xml::XmlConfigurable;
using coherence::util::Map;

/**
* An interface for XML driven %cache factory.
*
* @see DefaultConfigurableCacheFactory
*/
class COH_EXPORT ConfigurableCacheFactory
    : public interface_spec<ConfigurableCacheFactory,
        implements<XmlConfigurable> >
    {
    // ----- ConfigurableCacheFactory interface -----------------------------

    public:
        /**
        * Ensure a %cache for the given name using the corresponding XML
        * configuration.
        *
        * @param vsCacheName the %cache name
        *
        * @return a handle to a NamedCache created according to the
        *         configuration XML
        */
        virtual NamedCache::Handle ensureCache(String::View vsCacheName) = 0;

        /**
        * Releases and destroys the specified NamedCache.
        *
        * <b>Warning:</b> This method is used to completely destroy the
        * specified %cache across the cluster. All references in the entire
        * cluster to this %cache will be invalidated, the cached data will be
        * cleared, and all resources will be released.
        *
        * @param hCache the NamedCache object to be destroyed
        *
        * @see releaseCache
        */
        virtual void destroyCache(NamedCache::Handle hCache) = 0;

        /**
        * Release local resources associated with the specified instance of
        * the %cache.
        *
        * Releasing a NamedCache reference makes it no longer usable, but
        * does not affect the content of the %cache. In other words, all other
        * references to the %cache will still be valid, and the %cache data is
        * not affected by releasing the reference.
        *
        * The reference that is released using this method can no longer be
        * used; any attempt to use the reference will result in an exception.
        *
        * @param hCache the NamedCache object to be released
        *
        * @see destroyCache
        */
        virtual void releaseCache(NamedCache::Handle hCache) = 0;

        /**
        * Ensure a service for the given name using the corresponding XML
        * configuration.
        *
        * @param vsServiceName the service name
        *
        * @return a handle to a service created according to the
        *         configuration XML
        */
        virtual Service::Handle ensureService(String::View vsServiceName) = 0;

        /**
        * Get the product edition.
        *
        * @return the product edition
        */
        virtual int32_t getEdition() const = 0;

        /**
        * Set the product edition.
        *
        * @param nEdition  the product edition
        */
        virtual void setEdition(int32_t nEdition) = 0;

        /**
        * Get the local member
        *
        * @return  the local member
        */
        virtual Member::View getLocalMember() const = 0;

        /**
        * Set the local member
        *
        * @param vMemberLocal  the local member
        */
        virtual void setLocalMember(Member::View vMemberLocal) = 0;

        /**
        * Get the filter config map.
        *
        * @return  the filter config map
        */
        virtual Map::View getFilterConfigMap() const = 0;

        /**
        * Set the filter config map.
        *
        * @param vMapFilterConfig  the filter config map
        */
        virtual void setFilterConfigMap(Map::View vMapFilterConfig) = 0;

        /**
        * Shutdown all services related to this ConfigurableCacheFactory.
        */
        virtual void shutdown() = 0;
    };

COH_CLOSE_NAMESPACE2

#endif // COH_CONFIGURABLE_CACHE_FACTORY_HPP

Copyright (c) 2000, 2009, Oracle and/or its affiliates. All rights reserved.