Oracle Coherence for C++ API
Release 3.6.1.0
E18813-01

- Main Page
- Namespaces
- Classes
- Files

# coherence/net/CacheService.hpp

    00001 /*
    00002 * CacheService.hpp
    00003 *
    00004 * Copyright (c) 2000, 2010, Oracle and/or its affiliates. All rights reserved.
    00005 *
    00006 * Oracle is a registered trademarks of Oracle Corporation and/or its
    00007 * affiliates.
    00008 *
    00009 * This software is the confidential and proprietary information of Oracle
    00010 * Corporation. You shall not disclose such confidential and proprietary
    00011 * information and shall use it only in accordance with the terms of the
    00012 * license agreement you entered into with Oracle.
    00013 *
    00014 * This notice may not be removed or altered.
    00015 */
    00016 #ifndef COH_CACHE_SERVICE_HPP
    00017 #define COH_CACHE_SERVICE_HPP
    00018
    00019 #include "coherence/lang.ns"
    00020
    00021 #include "coherence/net/NamedCache.hpp"
    00022 #include "coherence/net/Service.hpp"
    00023 #include "coherence/util/Collection.hpp"
    00024
    00025 COH_OPEN_NAMESPACE2(coherence,net)
    00026
    00027 using coherence::util::Collection;
    00028
    00029
    00030 /**
    00031 * A CacheService is a clustered service providing a collection of named Maps
    00032 * that hold resources shared among members of a cluster. These resources are
    00033 * expected to be managed in memory, and are typically composed of data that
    00034 * are also stored persistently in a database, or data that have been
    00035 * assembled or calculated at some significant cost, thus these resources are
    00036 * referred to as <i>cached</i>.
    00037 *
    00038 * @author jh  2007.12.21
    00039 */
    00040 class COH_EXPORT CacheService
    00041     : public interface_spec<CacheService,
    00042         implements<Service> >
    00043     {
    00044     // ----- CacheService interface -----------------------------------------
    00045
    00046     public:
    00047         /**
    00048         * Obtain a NamedCache interface that provides a view of resources
    00049         * shared among members of a cluster. The view is identified by name
    00050         * within this CacheService. Typically, repeated calls to this method
    00051         * with the same view name and class loader instance will result in
    00052         * the same view reference being returned.
    00053         *
    00054         * @param vsName  the name, within this CacheService, that uniquely
    00055         *                identifies a view; null is legal, and may imply a
    00056         *                default name
    00057         *
    00058         * @return a NamedCache interface which can be used to access the
    00059         *         resources of the specified view
    00060         *
    00061         * @throws IllegalStateException thrown if the service is not
    00062         *                                  running
    00063         */
    00064         virtual NamedCache::Handle ensureCache(String::View vsName) = 0;
    00065
    00066         /**
    00067         * Returns a Collection of String objects, one for each cache name
    00068         * that has been previously registered with this CacheService.
    00069         *
    00070         * @return a Collection of cache names
    00071         *
    00072         * @throws IllegalStateException thrown if the CacheService
    00073         *            is not running or has stopped
    00074         */
    00075         virtual Collection::View getCacheNames() const = 0;
    00076
    00077         /**
    00078         * Release local resources associated with the specified instance of
    00079         * the cache. This invalidates a reference obtained by using the
    00080         * {@link #ensureCache(String::View)} method.
    00081         *
    00082         * Releasing a Map reference to a cache makes the Map reference no
    00083         * longer usable, but does not affect the cache itself. In other
    00084         * words, all other references to the cache will still be valid, and
    00085         * the cache data is not affected by releasing the reference.
    00086         *
    00087         * The reference that is released using this method can no longer be
    00088         * used; any attempt to use the reference will result in an exception.
    00089         *
    00090         * The purpose for releasing a cache reference is to allow the cache
    00091         * implementation to release resources.
    00092         *
    00093         * @param hMap  the cache object to be released
    00094         *
    00095         * @see NamedCache#release()
    00096         */
    00097         virtual void releaseCache(NamedCache::Handle hMap) = 0;
    00098
    00099         /**
    00100         * Release and destroy the specified cache.
    00101         *
    00102         * <b>Warning:</b> This method is used to completely destroy the
    00103         * specified cache across the cluster. All references in the entire
    00104         * cluster to this cache will be invalidated, the cached data will be
    00105         * cleared, and all resources will be released.
    00106         *
    00107         * @param hMap  the cache object to be released
    00108         *
    00109         * @see NamedCache#destroy()
    00110         */
    00111         virtual void destroyCache(NamedCache::Handle hMap) = 0;
    00112     };
    00113
    00114 COH_CLOSE_NAMESPACE2
    00115
    00116 #endif // COH_CACHE_SERVICE_HPP

Copyright © 2000, 2010, Oracle and/or its affiliates. All rights reserved.