196 lines
6.6 KiB
C++
196 lines
6.6 KiB
C++
/**
|
|
* 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.
|
|
*/
|
|
#ifndef _COLLECTION_UTIL_H_
|
|
#define _COLLECTION_UTIL_H_
|
|
|
|
/**
|
|
* \file
|
|
* CollectionBuilder and DictionaryBuilder classes and collection utility functions
|
|
*/
|
|
|
|
namespace Util
|
|
{
|
|
|
|
// *********************************************************
|
|
/** A shortcut to use for building collections.
|
|
* This class is a wrapper around standard STL collection containers such as vector.
|
|
* It allows one to conveniently build collections at the variable initialization time:
|
|
* \code
|
|
* #include "CollectionUtil.h"
|
|
* #include "Vector.h" // for ostream << operator overload for STL vector
|
|
* using Util;
|
|
*
|
|
* int main()
|
|
* {
|
|
* typedef vector<string> MyVector;
|
|
* MyVector myVector=CollectionBuilder<MyVector>()("str1")("str2")("str3");
|
|
* cout<<myVector;
|
|
* // the following output will be produced:
|
|
* // [str1,str2,str3]
|
|
* }
|
|
* \endcode
|
|
*/
|
|
template <class CONT>
|
|
class CollectionBuilder
|
|
{
|
|
public:
|
|
/// Type of the collection container.
|
|
typedef CONT CollectionType;
|
|
/// Container's value type.
|
|
typedef typename CollectionType::value_type value_type;
|
|
/// Container's constant iterator type.
|
|
typedef typename CollectionType::const_iterator const_iterator;
|
|
/// Container's size type.
|
|
typedef typename CollectionType::size_type size_type;
|
|
|
|
/** Operator function call overload to allow call chaining.
|
|
* \param value the value to be inserted into the container
|
|
*/
|
|
CollectionBuilder<CONT>& operator()(const value_type& value){
|
|
return push_back(value);
|
|
}
|
|
/** Same as regular STL push_back() but allows call chaining.
|
|
* \param value the value to be inserted into the container
|
|
*/
|
|
CollectionBuilder<CONT>& push_back(const value_type& value){
|
|
collection_.push_back(value);
|
|
return *this;
|
|
}
|
|
/// \name Standard STL container interface
|
|
/// @{
|
|
const_iterator begin() const{return collection_.begin();}
|
|
const_iterator end() const{return collection_.end();}
|
|
size_type size() const{return collection_.size();}
|
|
void clear() {collection_.clear();}
|
|
///@}
|
|
/// Explicit typecast operator.
|
|
operator const CollectionType&() const {return collection_;}
|
|
private:
|
|
/// \cond PRIVATE
|
|
CollectionType collection_;
|
|
/// \endcond
|
|
};
|
|
|
|
|
|
// *********************************************************
|
|
/** A shortcut to use for building dictionaries.
|
|
* This class is a wrapper around standard STL associative containers such as map.
|
|
* It allows one to conveniently build dictionaries at the variable initialization time:
|
|
* \code
|
|
* #include "CollectionUtil.h"
|
|
* #include "Map.h" // for ostream << operator overload for STL map
|
|
* using Util;
|
|
*
|
|
* int main()
|
|
* {
|
|
* typedef map<string,int> MyMap;
|
|
* MyMap myMap=DictionaryBuilder<MyMap>()("str1",1)("str2",2)("str3",3);
|
|
* cout<<myMap;
|
|
* // the following output will be produced:
|
|
* // [str1=1,str2=2,str3=3]
|
|
* }
|
|
* \endcode
|
|
*/
|
|
template <class CONT>
|
|
class DictionaryBuilder
|
|
{
|
|
public:
|
|
/// The type of the associative container
|
|
typedef CONT DictionaryType;
|
|
/// Container's element type (usually a pair<key_type,mapped_type>)
|
|
typedef typename DictionaryType::value_type value_type;
|
|
/// Container's key type
|
|
typedef typename DictionaryType::key_type key_type;
|
|
/// Container's value type
|
|
typedef typename DictionaryType::mapped_type mapped_type;
|
|
/// Container's constant iterator type
|
|
typedef typename DictionaryType::const_iterator const_iterator;
|
|
/// Container's writable iterator type
|
|
typedef typename DictionaryType::iterator iterator;
|
|
/// Container's size type
|
|
typedef typename DictionaryType::size_type size_type;
|
|
|
|
/** Operator function call overload to allow call chaining.
|
|
* \param key the value key to be inserted
|
|
* \param value the value to be inserted into the container
|
|
* \return a non-const reference to self
|
|
*/
|
|
DictionaryBuilder<CONT>& operator()(const key_type& key,const mapped_type& value){
|
|
dict_.insert(value_type(key,value));
|
|
return *this;
|
|
}
|
|
/** Lookup value by key.
|
|
* \param key the key associated with the value.
|
|
* \return a non-const iterator pointing to the element whose key matched the \a key parameter
|
|
*/
|
|
iterator find(const key_type& key){
|
|
return dict_.find(key);
|
|
}
|
|
/** Lookup value by key.
|
|
* \param key the key associated with the value.
|
|
* \return a const iterator pointing to the element whose key matched the \a key parameter
|
|
*/
|
|
const_iterator find(const key_type& key) const{
|
|
return dict_.find(key);
|
|
}
|
|
|
|
/// \name Standard STL container interface
|
|
/// @{
|
|
const_iterator begin() const{return dict_.begin();}
|
|
const_iterator end() const{return dict_.end();}
|
|
size_type size() const{return dict_.size();}
|
|
void clear() {dict_.clear();}
|
|
///@}
|
|
/// Explicit typecast operator.
|
|
operator const DictionaryType&() const {return dict_;}
|
|
private:
|
|
DictionaryType dict_;
|
|
};
|
|
|
|
|
|
// ***********************************************************
|
|
/** Deletes all dynamically allocated elements of a collection.
|
|
* C::value_type is expected to be a pointer to a dynamically allocated object, or it won't compile.
|
|
* The function will iterate over all container elements and call delete for each of them.
|
|
* \param c a collection (vector,set) whose elements are being deleted.
|
|
*/
|
|
template <class C>
|
|
void clearCollection(C& c){
|
|
for(typename C::const_iterator it=c.begin();it!=c.end();++it)
|
|
delete *it;
|
|
c.clear();
|
|
}
|
|
|
|
/** Deletes all dynamically allocated values of the assotiative container.
|
|
* The function expects the M::value_type to be a pair<..., ptr_to_type>, or it won't compile.
|
|
* It first deletes the objects pointed to by ptr_to_type
|
|
* and then clears (calls m.clear()) the container.
|
|
* \param m an associative container (map,hash_map) whose elements are being deleted.
|
|
*/
|
|
template <class M>
|
|
void clearMap(M& m){
|
|
for(typename M::const_iterator it=m.begin();it!=m.end();++it)
|
|
delete it->second;
|
|
m.clear();
|
|
}
|
|
|
|
} // namespace Util
|
|
|
|
|
|
#endif // _COLLECTION_UTIL_H_
|