1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
|
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
* 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 .
*/
#ifndef INCLUDED_OOX_HELPER_REFVECTOR_HXX
#define INCLUDED_OOX_HELPER_REFVECTOR_HXX
#include <algorithm>
#include <functional>
#include <memory>
#include <vector>
#include <sal/types.h>
namespace oox {
/** Template for a vector of ref-counted objects with additional accessor functions.
An instance of the class RefVector< Type > stores elements of the type
std::shared_ptr< Type >. The new accessor functions has() and get()
work correctly for indexes out of the current range, there is no need to
check the passed index before.
*/
template< typename ObjType >
class RefVector : public ::std::vector< std::shared_ptr< ObjType > >
{
public:
typedef ::std::vector< std::shared_ptr< ObjType > > container_type;
typedef typename container_type::value_type value_type;
typedef typename container_type::size_type size_type;
public:
/** Returns a reference to the object with the passed index, or 0 on error. */
value_type get( sal_Int32 nIndex ) const
{
if( const value_type* pxRef = getRef( nIndex ) ) return *pxRef;
return value_type();
}
/** Calls the passed functor for every contained object, automatically
skips all elements that are empty references. */
template< typename FunctorType >
void forEach( FunctorType aFunctor ) const
{
::std::for_each( this->begin(), this->end(), ForEachFunctor< FunctorType >( aFunctor ) );
}
/** Calls the passed member function of ObjType on every contained object,
automatically skips all elements that are empty references. */
template< typename FuncType >
void forEachMem( FuncType pFunc ) const
{
forEach( ::std::bind( pFunc, std::placeholders::_1 ) );
}
/** Calls the passed member function of ObjType on every contained object,
automatically skips all elements that are empty references. */
template< typename FuncType, typename ParamType >
void forEachMem( FuncType pFunc, ParamType aParam ) const
{
forEach( ::std::bind( pFunc, std::placeholders::_1, aParam ) );
}
/** Calls the passed member function of ObjType on every contained object,
automatically skips all elements that are empty references. */
template< typename FuncType, typename ParamType1, typename ParamType2 >
void forEachMem( FuncType pFunc, ParamType1 aParam1, ParamType2 aParam2 ) const
{
forEach( ::std::bind( pFunc, std::placeholders::_1, aParam1, aParam2 ) );
}
/** Calls the passed member function of ObjType on every contained object,
automatically skips all elements that are empty references. */
template< typename FuncType, typename ParamType1, typename ParamType2, typename ParamType3 >
void forEachMem( FuncType pFunc, ParamType1 aParam1, ParamType2 aParam2, ParamType3 aParam3 ) const
{
forEach( ::std::bind( pFunc, std::placeholders::_1, aParam1, aParam2, aParam3 ) );
}
/** Calls the passed functor for every contained object. Passes the index as
first argument and the object reference as second argument to rFunctor. */
template< typename FunctorType >
void forEachWithIndex( const FunctorType& rFunctor ) const
{
::std::for_each( this->begin(), this->end(), ForEachFunctorWithIndex< FunctorType >( rFunctor ) );
}
/** Calls the passed member function of ObjType on every contained object.
Passes the vector index as first argument to the member function. */
template< typename FuncType, typename ParamType1, typename ParamType2 >
void forEachMemWithIndex( FuncType pFunc, ParamType1 aParam1, ParamType2 aParam2 ) const
{
forEachWithIndex( ::std::bind( pFunc, std::placeholders::_2, std::placeholders::_1, aParam1, aParam2 ) );
}
/** Searches for an element by using the passed functor that takes a
constant reference of the object type (const ObjType&). */
template< typename FunctorType >
value_type findIf( const FunctorType& rFunctor ) const
{
typename container_type::const_iterator aIt = ::std::find_if( this->begin(), this->end(), FindFunctor< FunctorType >( rFunctor ) );
return (aIt == this->end()) ? value_type() : *aIt;
}
private:
template< typename FunctorType >
struct ForEachFunctor
{
FunctorType maFunctor;
explicit ForEachFunctor( const FunctorType& rFunctor ) : maFunctor( rFunctor ) {}
void operator()( const value_type& rxValue ) { if( rxValue.get() ) maFunctor( *rxValue ); }
};
template< typename FunctorType >
struct ForEachFunctorWithIndex
{
FunctorType maFunctor;
sal_Int32 mnIndex;
explicit ForEachFunctorWithIndex( const FunctorType& rFunctor ) : maFunctor( rFunctor ), mnIndex( 0 ) {}
void operator()( const value_type& rxValue ) {
if( rxValue.get() ) maFunctor( mnIndex, *rxValue );
++mnIndex;
}
};
template< typename FunctorType >
struct FindFunctor
{
FunctorType maFunctor;
explicit FindFunctor( const FunctorType& rFunctor ) : maFunctor( rFunctor ) {}
bool operator()( const value_type& rxValue ) { return rxValue.get() && maFunctor( *rxValue ); }
};
const value_type* getRef( sal_Int32 nIndex ) const
{
return ((0 <= nIndex) && (static_cast< size_type >( nIndex ) < this->size())) ?
&(*this)[ static_cast< size_type >( nIndex ) ] : nullptr;
}
};
} // namespace oox
#endif
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
