Oracle Coherence for C++ API
Release 3.6.0.0
E15728-01

- Main Page
- Namespaces
- Classes
- Files

# coherence/stl/boxing_map.hpp

    00001 /*
    00002 * boxing_map.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_BOXING_MAP_HPP
    00017 #define COH_BOXING_MAP_HPP
    00018
    00019 #include "coherence/lang.ns"
    00020
    00021 #include "coherence/stl/adapter_map.hpp"
    00022
    00023 #include <ostream>
    00024
    00025 COH_OPEN_NAMESPACE2(coherence,stl)
    00026
    00027
    00028 /**
    00029 * boxing_map provides an STL-like map adapter around a coherence::util::map,
    00030 * and additionally auto-boxes the keys and values to their corresponding
    00031 * non-managed types. The key and value template parameters specify the managed
    00032 * class which will be stored in the Map. Other then the definition, the access
    00033 * to the keys and values may use either the managed view type or the
    00034 * corresponding unmanaged type. This also allows for easy copying of mapped
    00035 * entries from a std::map to coherence maps and caches.
    00036 *
    00037 * @code
    00038 * boxing_map<Managed<Foo>, Managed<Bar> > mycache
    00039 *         (CacheFactory::getCache("mycache")); // declare boxing adapter
    00040 *
    00041 * Foo foo(...); // initialize non-managed object Foo
    00042 * Bar bar(...); // initialize non-managed object Bar
    00043 *
    00044 * mycache[foo] = bar;         // insert directly into cache via auto-boxing
    00045 * Bar barRead = mycache[foo]; // read from cache using auto-boxing
    00046 *
    00047 * std::map<Foo, Bar> mymap;
    00048 * mymap.insert(mycache.begin(), mycache.end()); // copy from coherence to STL
    00049 * mycache.insert(mymap.begin(), mymap.end());   // copy from STL to coherence
    00050 * @endcode
    00051 *
    00052 * @see coherence::util::TypedCollections::TypedMap for an Object based equivalent
    00053 *
    00054 * @author mf  2008.06.02
    00055 */
    00056 template<class K, class V>
    00057 class boxing_map
    00058         : public adapter_map<BoxHandle<const K, typename K::BoxedType, false>,
    00059                              BoxHandle<const V, typename V::BoxedType, false> >
    00060     {
    00061     // ----- typedefs -------------------------------------------------------
    00062
    00063     public:
    00064         /**
    00065         * Super type
    00066         */
    00067         typedef adapter_map<BoxHandle<const K, typename K::BoxedType, false>,
    00068                             BoxHandle<const V, typename V::BoxedType, false> >
    00069                 super;
    00070
    00071
    00072     // ----- constructor ----------------------------------------------------
    00073
    00074     public:
    00075         /**
    00076         * Create new boxing_map from the given Coherence Map.
    00077         *
    00078         * @param ohMap the Map to be delegated by the boxing_map.
    00079         */
    00080         boxing_map(Map::Holder ohMap = NULL)
    00081             : super(ohMap)
    00082             {
    00083             }
    00084
    00085         /**
    00086         * Create a boxing_map copy. The new boxing_map will reference the
    00087         * same Map, as the original boxing_map.
    00088         */
    00089         boxing_map(const boxing_map& that)
    00090             : super(that)
    00091             {
    00092             }
    00093
    00094
    00095     // ----- operators ------------------------------------------------------
    00096
    00097     public:
    00098         /**
    00099         * Reassign this boxing_map to reference the same Map as another
    00100         * boxing_map.
    00101         */
    00102         boxing_map& operator=(const boxing_map& that)
    00103             {
    00104             super::operator=(that);
    00105             return *this;
    00106             }
    00107
    00108         /**
    00109         * Reassign this boxing_map to reference another Map.
    00110         */
    00111         boxing_map& operator=(Map::Holder ohMap)
    00112             {
    00113             super::operator=(ohMap);
    00114             return *this;
    00115             }
    00116     };
    00117
    00118 COH_CLOSE_NAMESPACE2
    00119
    00120 #endif // COH_BOXING_MAP_HPP

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