sc/inc/fstalgorithm.hxx | 74 ++++-----
sc/inc/matrixoperators.hxx | 6
sc/inc/mtvcellfunc.hxx | 96 ++++++------
sc/inc/mtvfunctions.hxx | 270 ++++++++++++++++++------------------
sc/inc/sharedformula.hxx | 6
sc/inc/stlalgorithm.hxx | 12 -
sc/qa/unit/helper/qahelper.hxx | 4
sc/qa/unit/ucalc.cxx | 4
sc/qa/unit/ucalc.hxx | 8 -
sc/qa/unit/ucalc_formula.cxx | 28 +--
sc/qa/unit/ucalc_pivottable.cxx | 10 -
sc/source/core/data/cellvalue.cxx | 12 -
sc/source/core/data/column2.cxx | 8 -
sc/source/core/data/dociter.cxx | 8 -
sc/source/core/data/segmenttree.cxx | 60 ++++----
sc/source/core/data/table3.cxx | 6
sc/source/core/tool/interpr5.cxx | 4
sc/source/core/tool/scmatrix.cxx | 46 +++---
sc/source/filter/excel/excform.cxx | 2
sc/source/filter/excel/excform8.cxx | 2
sc/source/filter/excel/exctools.cxx | 4
sc/source/filter/excel/frmbase.cxx | 14 -
sc/source/filter/excel/xiroot.cxx | 4
sc/source/filter/inc/excform.hxx | 4
sc/source/filter/inc/formel.hxx | 8 -
sc/source/filter/inc/lotimpop.hxx | 2
sc/source/filter/inc/root.hxx | 6
sc/source/filter/inc/xiroot.hxx | 6
sc/source/filter/lotus/lotimpop.cxx | 4
sc/source/filter/lotus/lotread.cxx | 2
sc/source/ui/unoobj/shapeuno.cxx | 4
sc/source/ui/unoobj/viewuno.cxx | 8 -
sc/source/ui/vba/vbaformat.hxx | 2
sc/source/ui/view/output2.cxx | 8 -
34 files changed, 371 insertions(+), 371 deletions(-)
New commits:
commit 046dc22ce15d363ee28d8ad1710c16e76e75a139
Author: Stephan Bergmann <sberg...@redhat.com>
Date: Fri Apr 22 09:43:40 2016 +0200
Avoid reserved identifiers
Change-Id: I782784f34975d708fdf179d098ce6654aad7a976
diff --git a/sc/inc/fstalgorithm.hxx b/sc/inc/fstalgorithm.hxx
index aae070c..73a4c5c 100644
--- a/sc/inc/fstalgorithm.hxx
+++ b/sc/inc/fstalgorithm.hxx
@@ -15,28 +15,28 @@
namespace sc {
-template<typename _Key, typename _Span>
+template<typename Key, typename Span>
void buildSpan(
- std::vector<_Span>& rSpans,
- typename mdds::flat_segment_tree<_Key,bool>::const_iterator it,
- typename mdds::flat_segment_tree<_Key,bool>::const_iterator itEnd, const
_Key* pStart )
+ std::vector<Span>& rSpans,
+ typename mdds::flat_segment_tree<Key,bool>::const_iterator it,
+ typename mdds::flat_segment_tree<Key,bool>::const_iterator itEnd, const
Key* pStart )
{
- _Key nLastPos = it->first;
+ Key nLastPos = it->first;
bool bLastVal = it->second;
for (++it; it != itEnd; ++it)
{
- _Key nThisPos = it->first;
+ Key nThisPos = it->first;
bool bThisVal = it->second;
if (bLastVal)
{
- _Key nIndex1 = nLastPos;
- _Key nIndex2 = nThisPos-1;
+ Key nIndex1 = nLastPos;
+ Key nIndex2 = nThisPos-1;
if (!pStart || *pStart < nIndex1)
- rSpans.push_back(_Span(nIndex1, nIndex2));
+ rSpans.push_back(Span(nIndex1, nIndex2));
else if (*pStart <= nIndex2)
- rSpans.push_back(_Span(*pStart, nIndex2));
+ rSpans.push_back(Span(*pStart, nIndex2));
}
nLastPos = nThisPos;
@@ -44,28 +44,28 @@ void buildSpan(
}
}
-template<typename _Key, typename _Val, typename _Span>
+template<typename Key, typename Val, typename Span>
void buildSpanWithValue(
- std::vector<_Span>& rSpans,
- typename mdds::flat_segment_tree<_Key,_Val>::const_iterator it,
- typename mdds::flat_segment_tree<_Key,_Val>::const_iterator itEnd, const
_Key* pStart )
+ std::vector<Span>& rSpans,
+ typename mdds::flat_segment_tree<Key,Val>::const_iterator it,
+ typename mdds::flat_segment_tree<Key,Val>::const_iterator itEnd, const
Key* pStart )
{
- _Key nLastPos = it->first;
- _Val nLastVal = it->second;
+ Key nLastPos = it->first;
+ Val nLastVal = it->second;
for (++it; it != itEnd; ++it)
{
- _Key nThisPos = it->first;
- _Val nThisVal = it->second;
+ Key nThisPos = it->first;
+ Val nThisVal = it->second;
if (nLastVal)
{
- _Key nIndex1 = nLastPos;
- _Key nIndex2 = nThisPos-1;
+ Key nIndex1 = nLastPos;
+ Key nIndex2 = nThisPos-1;
if (!pStart || *pStart < nIndex1)
- rSpans.push_back(_Span(nIndex1, nIndex2, nLastVal));
+ rSpans.push_back(Span(nIndex1, nIndex2, nLastVal));
else if (*pStart <= nIndex2)
- rSpans.push_back(_Span(*pStart, nIndex2, nLastVal));
+ rSpans.push_back(Span(*pStart, nIndex2, nLastVal));
}
nLastPos = nThisPos;
@@ -78,15 +78,15 @@ void buildSpanWithValue(
* an array of ranges that corresponds with the segments that have a 'true'
* value.
*/
-template<typename _Key, typename _Span>
-std::vector<_Span> toSpanArray( const mdds::flat_segment_tree<_Key,bool>&
rTree )
+template<typename Key, typename Span>
+std::vector<Span> toSpanArray( const mdds::flat_segment_tree<Key,bool>& rTree )
{
- typedef mdds::flat_segment_tree<_Key,bool> FstType;
+ typedef mdds::flat_segment_tree<Key,bool> FstType;
- std::vector<_Span> aSpans;
+ std::vector<Span> aSpans;
typename FstType::const_iterator it = rTree.begin(), itEnd = rTree.end();
- buildSpan<_Key,_Span>(aSpans, it, itEnd, nullptr);
+ buildSpan<Key,Span>(aSpans, it, itEnd, nullptr);
return aSpans;
}
@@ -97,24 +97,24 @@ std::vector<_Span> toSpanArray( const
mdds::flat_segment_tree<_Key,bool>& rTree
* The span type must support a constructor that takes a start key, an end
* key and a value in this order.
*/
-template<typename _Key, typename _Val, typename _Span>
-std::vector<_Span> toSpanArrayWithValue( const
mdds::flat_segment_tree<_Key,_Val>& rTree )
+template<typename Key, typename Val, typename Span>
+std::vector<Span> toSpanArrayWithValue( const
mdds::flat_segment_tree<Key,Val>& rTree )
{
- typedef mdds::flat_segment_tree<_Key,_Val> FstType;
+ typedef mdds::flat_segment_tree<Key,Val> FstType;
- std::vector<_Span> aSpans;
+ std::vector<Span> aSpans;
typename FstType::const_iterator it = rTree.begin(), itEnd = rTree.end();
- buildSpanWithValue<_Key,_Val,_Span>(aSpans, it, itEnd, nullptr);
+ buildSpanWithValue<Key,Val,Span>(aSpans, it, itEnd, nullptr);
return aSpans;
}
-template<typename _Key, typename _Span>
-std::vector<_Span> toSpanArray( const mdds::flat_segment_tree<_Key,bool>&
rTree, _Key nStartPos )
+template<typename Key, typename Span>
+std::vector<Span> toSpanArray( const mdds::flat_segment_tree<Key,bool>& rTree,
Key nStartPos )
{
- typedef mdds::flat_segment_tree<_Key,bool> FstType;
+ typedef mdds::flat_segment_tree<Key,bool> FstType;
- std::vector<_Span> aSpans;
+ std::vector<Span> aSpans;
if (!rTree.is_tree_valid())
return aSpans;
@@ -127,7 +127,7 @@ std::vector<_Span> toSpanArray( const
mdds::flat_segment_tree<_Key,bool>& rTree,
return aSpans;
typename FstType::const_iterator it = r.first, itEnd = rTree.end();
- buildSpan<_Key,_Span>(aSpans, it, itEnd, &nStartPos);
+ buildSpan<Key,Span>(aSpans, it, itEnd, &nStartPos);
return aSpans;
}
diff --git a/sc/inc/matrixoperators.hxx b/sc/inc/matrixoperators.hxx
index f3e5fac..25ecf63 100644
--- a/sc/inc/matrixoperators.hxx
+++ b/sc/inc/matrixoperators.hxx
@@ -17,11 +17,11 @@ namespace op {
template<typename T>
-struct _Op
+struct Op_
{
const double mInitVal;
const T maOp;
- _Op(double InitVal, T aOp):
+ Op_(double InitVal, T aOp):
mInitVal(InitVal), maOp(aOp)
{
}
@@ -31,7 +31,7 @@ struct _Op
}
};
-using Op = _Op<std::function<void(double&, double)>>;
+using Op = Op_<std::function<void(double&, double)>>;
struct Sum
{
diff --git a/sc/inc/mtvcellfunc.hxx b/sc/inc/mtvcellfunc.hxx
index d0fd9a1..db72fd4 100644
--- a/sc/inc/mtvcellfunc.hxx
+++ b/sc/inc/mtvcellfunc.hxx
@@ -15,156 +15,156 @@
namespace sc {
-template<typename _Func>
-void ProcessFormula(CellStoreType& rStore, _Func& rFunc)
+template<typename Func>
+void ProcessFormula(CellStoreType& rStore, Func& rFunc)
{
FuncElseNoOp<size_t> aElse;
- ProcessElements1<CellStoreType, formula_block, _Func, FuncElseNoOp<size_t>
>(rStore, rFunc, aElse);
+ ProcessElements1<CellStoreType, formula_block, Func, FuncElseNoOp<size_t>
>(rStore, rFunc, aElse);
}
-template<typename _FuncElem>
+template<typename FuncElem>
typename CellStoreType::iterator
ProcessFormula(
- const CellStoreType::iterator& it, CellStoreType& rStore, SCROW nRow1,
SCROW nRow2, _FuncElem& rFuncElem)
+ const CellStoreType::iterator& it, CellStoreType& rStore, SCROW nRow1,
SCROW nRow2, FuncElem& rFuncElem)
{
FuncElseNoOp<size_t> aElse;
return ProcessElements1<
- CellStoreType, formula_block, _FuncElem, FuncElseNoOp<size_t> >(it,
rStore, nRow1, nRow2, rFuncElem, aElse);
+ CellStoreType, formula_block, FuncElem, FuncElseNoOp<size_t> >(it,
rStore, nRow1, nRow2, rFuncElem, aElse);
}
-template<typename _FuncElem, typename _FuncElse>
+template<typename FuncElem, typename FuncElse>
typename CellStoreType::iterator
ProcessFormula(
- const CellStoreType::iterator& it, CellStoreType& rStore, SCROW nRow1,
SCROW nRow2, _FuncElem& rFuncElem, _FuncElse& rFuncElse)
+ const CellStoreType::iterator& it, CellStoreType& rStore, SCROW nRow1,
SCROW nRow2, FuncElem& rFuncElem, FuncElse& rFuncElse)
{
return ProcessElements1<
- CellStoreType, formula_block, _FuncElem, _FuncElse>(it, rStore, nRow1,
nRow2, rFuncElem, rFuncElse);
+ CellStoreType, formula_block, FuncElem, FuncElse>(it, rStore, nRow1,
nRow2, rFuncElem, rFuncElse);
}
-template<typename _Func>
+template<typename Func>
CellStoreType::iterator
-ProcessEditText(const CellStoreType::iterator& itPos, CellStoreType& rStore,
SCROW nRow1, SCROW nRow2, _Func& rFunc)
+ProcessEditText(const CellStoreType::iterator& itPos, CellStoreType& rStore,
SCROW nRow1, SCROW nRow2, Func& rFunc)
{
FuncElseNoOp<size_t> aElse;
- return ProcessElements1<CellStoreType, edittext_block, _Func,
FuncElseNoOp<size_t> >(
+ return ProcessElements1<CellStoreType, edittext_block, Func,
FuncElseNoOp<size_t> >(
itPos, rStore, nRow1, nRow2, rFunc, aElse);
}
-template<typename _Func>
+template<typename Func>
void ParseFormula(
- const CellStoreType& rStore, _Func& rFunc)
+ const CellStoreType& rStore, Func& rFunc)
{
FuncElseNoOp<size_t> aElse;
- ParseElements1<CellStoreType, formula_block, _Func, FuncElseNoOp<size_t>
>(rStore, rFunc, aElse);
+ ParseElements1<CellStoreType, formula_block, Func, FuncElseNoOp<size_t>
>(rStore, rFunc, aElse);
}
-template<typename _Func>
+template<typename Func>
typename CellStoreType::const_iterator
ParseFormula(
const CellStoreType::const_iterator& itPos, const CellStoreType& rStore,
- SCROW nStart, SCROW nEnd, _Func& rFunc)
+ SCROW nStart, SCROW nEnd, Func& rFunc)
{
FuncElseNoOp<size_t> aElse;
- return ParseElements1<CellStoreType, formula_block, _Func,
FuncElseNoOp<size_t> >(
+ return ParseElements1<CellStoreType, formula_block, Func,
FuncElseNoOp<size_t> >(
itPos, rStore, nStart, nEnd, rFunc, aElse);
}
-template<typename _FuncElem, typename _FuncElse>
+template<typename FuncElem, typename FuncElse>
typename CellStoreType::const_iterator
ParseAll(
const typename CellStoreType::const_iterator& itPos, const CellStoreType&
rCells,
- SCROW nRow1, SCROW nRow2, _FuncElem& rFuncElem, _FuncElse& rFuncElse)
+ SCROW nRow1, SCROW nRow2, FuncElem& rFuncElem, FuncElse& rFuncElse)
{
return ParseElements4<CellStoreType,
numeric_block, string_block, edittext_block, formula_block,
- _FuncElem, _FuncElse>(
+ FuncElem, FuncElse>(
itPos, rCells, nRow1, nRow2, rFuncElem, rFuncElse);
}
-template<typename _Func>
+template<typename Func>
typename CellStoreType::const_iterator
ParseAllNonEmpty(
const typename CellStoreType::const_iterator& itPos, const CellStoreType&
rCells,
- SCROW nRow1, SCROW nRow2, _Func& rFunc)
+ SCROW nRow1, SCROW nRow2, Func& rFunc)
{
FuncElseNoOp<size_t> aElse;
return ParseElements4<CellStoreType,
numeric_block, string_block, edittext_block, formula_block,
- _Func, FuncElseNoOp<size_t> >(
+ Func, FuncElseNoOp<size_t> >(
itPos, rCells, nRow1, nRow2, rFunc, aElse);
}
-template<typename _Func>
+template<typename Func>
typename CellStoreType::const_iterator
ParseFormulaNumeric(
const CellStoreType::const_iterator& itPos, const CellStoreType& rCells,
- SCROW nRow1, SCROW nRow2, _Func& rFunc)
+ SCROW nRow1, SCROW nRow2, Func& rFunc)
{
FuncElseNoOp<size_t> aElse;
return ParseElements2<CellStoreType,
- numeric_block, formula_block, _Func, FuncElseNoOp<size_t> >(
+ numeric_block, formula_block, Func, FuncElseNoOp<size_t> >(
itPos, rCells, nRow1, nRow2, rFunc, aElse);
}
-template<typename _Func>
-void ProcessFormulaEditText(CellStoreType& rStore, _Func& rFunc)
+template<typename Func>
+void ProcessFormulaEditText(CellStoreType& rStore, Func& rFunc)
{
FuncElseNoOp<size_t> aElse;
- ProcessElements2<CellStoreType, edittext_block, formula_block, _Func,
FuncElseNoOp<size_t> >(rStore, rFunc, aElse);
+ ProcessElements2<CellStoreType, edittext_block, formula_block, Func,
FuncElseNoOp<size_t> >(rStore, rFunc, aElse);
}
-template<typename _Func>
+template<typename Func>
std::pair<CellStoreType::const_iterator, size_t>
-FindFormula(const CellStoreType& rStore, SCROW nRow1, SCROW nRow2, _Func&
rFunc)
+FindFormula(const CellStoreType& rStore, SCROW nRow1, SCROW nRow2, Func& rFunc)
{
typedef std::pair<size_t,bool> ElseRetType;
FuncElseNoOp<size_t, ElseRetType> aElse;
- return FindElement1<CellStoreType, formula_block, _Func,
FuncElseNoOp<size_t, ElseRetType> >(rStore, nRow1, nRow2, rFunc, aElse);
+ return FindElement1<CellStoreType, formula_block, Func,
FuncElseNoOp<size_t, ElseRetType> >(rStore, nRow1, nRow2, rFunc, aElse);
}
-template<typename _Func>
+template<typename Func>
std::pair<CellStoreType::const_iterator, size_t>
-FindFormulaEditText(const CellStoreType& rStore, SCROW nRow1, SCROW nRow2,
_Func& rFunc)
+FindFormulaEditText(const CellStoreType& rStore, SCROW nRow1, SCROW nRow2,
Func& rFunc)
{
- return FindElement2<CellStoreType, edittext_block, formula_block, _Func,
_Func>(rStore, nRow1, nRow2, rFunc, rFunc);
+ return FindElement2<CellStoreType, edittext_block, formula_block, Func,
Func>(rStore, nRow1, nRow2, rFunc, rFunc);
}
-template<typename _Func>
-void ProcessNote(CellNoteStoreType& rStore, _Func& rFunc)
+template<typename Func>
+void ProcessNote(CellNoteStoreType& rStore, Func& rFunc)
{
FuncElseNoOp<size_t> aElse;
- ProcessElements1<CellNoteStoreType, cellnote_block, _Func,
FuncElseNoOp<size_t> >(rStore, rFunc, aElse);
+ ProcessElements1<CellNoteStoreType, cellnote_block, Func,
FuncElseNoOp<size_t> >(rStore, rFunc, aElse);
}
-template<typename _Func>
+template<typename Func>
typename CellNoteStoreType::const_iterator
ParseNote(
const CellNoteStoreType::const_iterator& itPos, const CellNoteStoreType&
rStore,
- SCROW nStart, SCROW nEnd, _Func& rFunc)
+ SCROW nStart, SCROW nEnd, Func& rFunc)
{
FuncElseNoOp<size_t> aElse;
- return ParseElements1<CellNoteStoreType, cellnote_block, _Func,
FuncElseNoOp<size_t> >(
+ return ParseElements1<CellNoteStoreType, cellnote_block, Func,
FuncElseNoOp<size_t> >(
itPos, rStore, nStart, nEnd, rFunc, aElse);
}
-template<typename _FuncElem>
+template<typename FuncElem>
typename CellNoteStoreType::iterator
ProcessNote(
- const CellNoteStoreType::iterator& it, CellNoteStoreType& rStore, SCROW
nRow1, SCROW nRow2, _FuncElem& rFuncElem)
+ const CellNoteStoreType::iterator& it, CellNoteStoreType& rStore, SCROW
nRow1, SCROW nRow2, FuncElem& rFuncElem)
{
FuncElseNoOp<size_t> aElse;
return ProcessElements1<
- CellNoteStoreType, cellnote_block, _FuncElem, FuncElseNoOp<size_t>
>(it, rStore, nRow1, nRow2, rFuncElem, aElse);
+ CellNoteStoreType, cellnote_block, FuncElem, FuncElseNoOp<size_t>
>(it, rStore, nRow1, nRow2, rFuncElem, aElse);
}
-template<typename _FuncElem>
+template<typename FuncElem>
typename BroadcasterStoreType::iterator
ProcessBroadcaster(
- const BroadcasterStoreType::iterator& it, BroadcasterStoreType& rStore,
SCROW nRow1, SCROW nRow2, _FuncElem& rFuncElem)
+ const BroadcasterStoreType::iterator& it, BroadcasterStoreType& rStore,
SCROW nRow1, SCROW nRow2, FuncElem& rFuncElem)
{
FuncElseNoOp<size_t> aElse;
return ProcessElements1<
- BroadcasterStoreType, broadcaster_block, _FuncElem,
FuncElseNoOp<size_t> >(it, rStore, nRow1, nRow2, rFuncElem, aElse);
+ BroadcasterStoreType, broadcaster_block, FuncElem,
FuncElseNoOp<size_t> >(it, rStore, nRow1, nRow2, rFuncElem, aElse);
}
}
diff --git a/sc/inc/mtvfunctions.hxx b/sc/inc/mtvfunctions.hxx
index 028e73c..f9052ed 100644
--- a/sc/inc/mtvfunctions.hxx
+++ b/sc/inc/mtvfunctions.hxx
@@ -15,12 +15,12 @@
namespace sc {
-template<typename _SizeT, typename _Ret = bool>
+template<typename SizeT, typename Ret = bool>
struct FuncElseNoOp
{
- _Ret operator() (mdds::mtv::element_t, _SizeT, _SizeT) const
+ Ret operator() (mdds::mtv::element_t, SizeT, SizeT) const
{
- return _Ret();
+ return Ret();
}
};
@@ -28,19 +28,19 @@ struct FuncElseNoOp
* Generic algorithm to parse blocks of multi_type_vector either partially
* or fully.
*/
-template<typename _StoreT, typename _Func>
-typename _StoreT::const_iterator
+template<typename StoreT, typename Func>
+typename StoreT::const_iterator
ParseBlock(
- const typename _StoreT::const_iterator& itPos, const _StoreT& rStore,
_Func& rFunc,
- typename _StoreT::size_type nStart, typename _StoreT::size_type nEnd)
+ const typename StoreT::const_iterator& itPos, const StoreT& rStore, Func&
rFunc,
+ typename StoreT::size_type nStart, typename StoreT::size_type nEnd)
{
- typedef std::pair<typename _StoreT::const_iterator, typename
_StoreT::size_type> PositionType;
+ typedef std::pair<typename StoreT::const_iterator, typename
StoreT::size_type> PositionType;
PositionType aPos = rStore.position(itPos, nStart);
- typename _StoreT::const_iterator it = aPos.first;
- typename _StoreT::size_type nOffset = aPos.second;
- typename _StoreT::size_type nDataSize = 0;
- typename _StoreT::size_type nTopRow = nStart;
+ typename StoreT::const_iterator it = aPos.first;
+ typename StoreT::size_type nOffset = aPos.second;
+ typename StoreT::size_type nDataSize = 0;
+ typename StoreT::size_type nTopRow = nStart;
for (; it != rStore.end() && nTopRow <= nEnd; ++it, nOffset = 0, nTopRow
+= nDataSize)
{
@@ -66,17 +66,17 @@ ParseBlock(
* Non-const variant of the above function. TODO: Find a way to merge these
* two in an elegant way.
*/
-template<typename _StoreT, typename _Func>
-typename _StoreT::iterator
-ProcessBlock(const typename _StoreT::iterator& itPos, _StoreT& rStore, _Func&
rFunc, typename _StoreT::size_type nStart, typename _StoreT::size_type nEnd)
+template<typename StoreT, typename Func>
+typename StoreT::iterator
+ProcessBlock(const typename StoreT::iterator& itPos, StoreT& rStore, Func&
rFunc, typename StoreT::size_type nStart, typename StoreT::size_type nEnd)
{
- typedef std::pair<typename _StoreT::iterator, typename _StoreT::size_type>
PositionType;
+ typedef std::pair<typename StoreT::iterator, typename StoreT::size_type>
PositionType;
PositionType aPos = rStore.position(itPos, nStart);
- typename _StoreT::iterator it = aPos.first;
- typename _StoreT::size_type nOffset = aPos.second;
- typename _StoreT::size_type nDataSize = 0;
- typename _StoreT::size_type nCurRow = nStart;
+ typename StoreT::iterator it = aPos.first;
+ typename StoreT::size_type nOffset = aPos.second;
+ typename StoreT::size_type nDataSize = 0;
+ typename StoreT::size_type nCurRow = nStart;
for (; it != rStore.end() && nCurRow <= nEnd; ++it, nOffset = 0, nCurRow
+= nDataSize)
{
@@ -98,39 +98,39 @@ ProcessBlock(const typename _StoreT::iterator& itPos,
_StoreT& rStore, _Func& rF
return it;
}
-template<typename _BlkT, typename _ItrT, typename _NodeT, typename _FuncElem>
-void EachElem(_NodeT& rNode, size_t nOffset, size_t nDataSize, _FuncElem&
rFuncElem)
+template<typename BlkT, typename ItrT, typename NodeT, typename FuncElem>
+void EachElem(NodeT& rNode, size_t nOffset, size_t nDataSize, FuncElem&
rFuncElem)
{
- _ItrT it = _BlkT::begin(*rNode.data);
+ ItrT it = BlkT::begin(*rNode.data);
std::advance(it, nOffset);
- _ItrT itEnd = it;
+ ItrT itEnd = it;
std::advance(itEnd, nDataSize);
size_t nRow = rNode.position + nOffset;
for (; it != itEnd; ++it, ++nRow)
rFuncElem(nRow, *it);
}
-template<typename _BlkT, typename _ItrT, typename _NodeT, typename _FuncElem>
-void EachElem(_NodeT& rNode, _FuncElem& rFuncElem)
+template<typename BlkT, typename ItrT, typename NodeT, typename FuncElem>
+void EachElem(NodeT& rNode, FuncElem& rFuncElem)
{
- _ItrT it = _BlkT::begin(*rNode.data);
- _ItrT itEnd = _BlkT::end(*rNode.data);
+ ItrT it = BlkT::begin(*rNode.data);
+ ItrT itEnd = BlkT::end(*rNode.data);
size_t nRow = rNode.position;
for (; it != itEnd; ++it, ++nRow)
rFuncElem(nRow, *it);
}
-template<typename _BlkT, typename _StoreT, typename _FuncElem>
-std::pair<typename _StoreT::const_iterator, size_t>
+template<typename BlkT, typename StoreT, typename FuncElem>
+std::pair<typename StoreT::const_iterator, size_t>
CheckElem(
- const _StoreT& rStore, const typename _StoreT::const_iterator& it, size_t
nOffset, size_t nDataSize,
- _FuncElem& rFuncElem)
+ const StoreT& rStore, const typename StoreT::const_iterator& it, size_t
nOffset, size_t nDataSize,
+ FuncElem& rFuncElem)
{
- typedef std::pair<typename _StoreT::const_iterator, size_t> PositionType;
+ typedef std::pair<typename StoreT::const_iterator, size_t> PositionType;
- typename _BlkT::const_iterator itData = _BlkT::begin(*it->data);
+ typename BlkT::const_iterator itData = BlkT::begin(*it->data);
std::advance(itData, nOffset);
- typename _BlkT::const_iterator itDataEnd = itData;
+ typename BlkT::const_iterator itDataEnd = itData;
std::advance(itDataEnd, nDataSize);
size_t nTopRow = it->position + nOffset;
size_t nRow = nTopRow;
@@ -143,38 +143,38 @@ CheckElem(
return PositionType(rStore.end(), 0);
}
-template<typename _StoreT, typename _BlkT, typename _FuncElem, typename
_FuncElse>
-void ParseElements1(const _StoreT& rStore, _FuncElem& rFuncElem, _FuncElse&
rFuncElse)
+template<typename StoreT, typename BlkT, typename FuncElem, typename FuncElse>
+void ParseElements1(const StoreT& rStore, FuncElem& rFuncElem, FuncElse&
rFuncElse)
{
- typename _StoreT::size_type nTopRow = 0, nDataSize = 0;
- typename _StoreT::const_iterator it = rStore.begin(), itEnd = rStore.end();
+ typename StoreT::size_type nTopRow = 0, nDataSize = 0;
+ typename StoreT::const_iterator it = rStore.begin(), itEnd = rStore.end();
for (; it != itEnd; ++it, nTopRow += nDataSize)
{
nDataSize = it->size;
- if (it->type != _BlkT::block_type)
+ if (it->type != BlkT::block_type)
{
rFuncElse(it->type, nTopRow, nDataSize);
continue;
}
- EachElem<_BlkT, typename _BlkT::const_iterator>(*it, rFuncElem);
+ EachElem<BlkT, typename BlkT::const_iterator>(*it, rFuncElem);
}
}
-template<typename _StoreT, typename _BlkT, typename _FuncElem, typename
_FuncElse>
-typename _StoreT::const_iterator
+template<typename StoreT, typename BlkT, typename FuncElem, typename FuncElse>
+typename StoreT::const_iterator
ParseElements1(
- const typename _StoreT::const_iterator& itPos, const _StoreT& rStore,
- typename _StoreT::size_type nStart, typename _StoreT::size_type nEnd,
- _FuncElem& rFuncElem, _FuncElse& rFuncElse)
+ const typename StoreT::const_iterator& itPos, const StoreT& rStore,
+ typename StoreT::size_type nStart, typename StoreT::size_type nEnd,
+ FuncElem& rFuncElem, FuncElse& rFuncElse)
{
- typedef std::pair<typename _StoreT::const_iterator, typename
_StoreT::size_type> PositionType;
+ typedef std::pair<typename StoreT::const_iterator, typename
StoreT::size_type> PositionType;
PositionType aPos = rStore.position(itPos, nStart);
- typename _StoreT::const_iterator it = aPos.first;
- typename _StoreT::size_type nOffset = aPos.second;
- typename _StoreT::size_type nDataSize = 0;
- typename _StoreT::size_type nTopRow = nStart;
+ typename StoreT::const_iterator it = aPos.first;
+ typename StoreT::size_type nOffset = aPos.second;
+ typename StoreT::size_type nDataSize = 0;
+ typename StoreT::size_type nTopRow = nStart;
for (; it != rStore.end() && nTopRow <= nEnd; ++it, nOffset = 0, nTopRow
+= nDataSize)
{
@@ -187,8 +187,8 @@ ParseElements1(
bLastBlock = true;
}
- if (it->type == _BlkT::block_type)
- EachElem<_BlkT, typename _BlkT::const_iterator>(*it, nOffset,
nDataSize, rFuncElem);
+ if (it->type == BlkT::block_type)
+ EachElem<BlkT, typename BlkT::const_iterator>(*it, nOffset,
nDataSize, rFuncElem);
else
rFuncElse(it->type, nTopRow, nDataSize);
@@ -199,19 +199,19 @@ ParseElements1(
return it;
};
-template<typename _StoreT, typename _Blk1, typename _Blk2, typename _FuncElem,
typename _FuncElse>
-typename _StoreT::const_iterator
+template<typename StoreT, typename Blk1, typename Blk2, typename FuncElem,
typename FuncElse>
+typename StoreT::const_iterator
ParseElements2(
- const typename _StoreT::const_iterator& itPos, const _StoreT& rStore,
typename _StoreT::size_type nStart, typename _StoreT::size_type nEnd,
- _FuncElem& rFuncElem, _FuncElse& rFuncElse)
+ const typename StoreT::const_iterator& itPos, const StoreT& rStore,
typename StoreT::size_type nStart, typename StoreT::size_type nEnd,
+ FuncElem& rFuncElem, FuncElse& rFuncElse)
{
- typedef std::pair<typename _StoreT::const_iterator, typename
_StoreT::size_type> PositionType;
+ typedef std::pair<typename StoreT::const_iterator, typename
StoreT::size_type> PositionType;
PositionType aPos = rStore.position(itPos, nStart);
- typename _StoreT::const_iterator it = aPos.first;
- typename _StoreT::size_type nOffset = aPos.second;
- typename _StoreT::size_type nDataSize = 0;
- typename _StoreT::size_type nTopRow = nStart;
+ typename StoreT::const_iterator it = aPos.first;
+ typename StoreT::size_type nOffset = aPos.second;
+ typename StoreT::size_type nDataSize = 0;
+ typename StoreT::size_type nTopRow = nStart;
for (; it != rStore.end() && nTopRow <= nEnd; ++it, nOffset = 0, nTopRow
+= nDataSize)
{
@@ -226,11 +226,11 @@ ParseElements2(
switch (it->type)
{
- case _Blk1::block_type:
- EachElem<_Blk1, typename _Blk1::const_iterator>(*it, nOffset,
nDataSize, rFuncElem);
+ case Blk1::block_type:
+ EachElem<Blk1, typename Blk1::const_iterator>(*it, nOffset,
nDataSize, rFuncElem);
break;
- case _Blk2::block_type:
- EachElem<_Blk2, typename _Blk2::const_iterator>(*it, nOffset,
nDataSize, rFuncElem);
+ case Blk2::block_type:
+ EachElem<Blk2, typename Blk2::const_iterator>(*it, nOffset,
nDataSize, rFuncElem);
break;
default:
rFuncElse(it->type, nTopRow, nDataSize);
@@ -243,19 +243,19 @@ ParseElements2(
return it;
}
-template<typename _StoreT, typename _Blk1, typename _Blk2, typename _Blk3,
typename _Blk4, typename _FuncElem, typename _FuncElse>
-typename _StoreT::const_iterator
+template<typename StoreT, typename Blk1, typename Blk2, typename Blk3,
typename Blk4, typename FuncElem, typename FuncElse>
+typename StoreT::const_iterator
ParseElements4(
- const typename _StoreT::const_iterator& itPos, const _StoreT& rStore,
typename _StoreT::size_type nStart, typename _StoreT::size_type nEnd,
- _FuncElem& rFuncElem, _FuncElse& rFuncElse)
+ const typename StoreT::const_iterator& itPos, const StoreT& rStore,
typename StoreT::size_type nStart, typename StoreT::size_type nEnd,
+ FuncElem& rFuncElem, FuncElse& rFuncElse)
{
- typedef std::pair<typename _StoreT::const_iterator, typename
_StoreT::size_type> PositionType;
+ typedef std::pair<typename StoreT::const_iterator, typename
StoreT::size_type> PositionType;
PositionType aPos = rStore.position(itPos, nStart);
- typename _StoreT::const_iterator it = aPos.first;
- typename _StoreT::size_type nOffset = aPos.second;
- typename _StoreT::size_type nDataSize = 0;
- typename _StoreT::size_type nTopRow = nStart;
+ typename StoreT::const_iterator it = aPos.first;
+ typename StoreT::size_type nOffset = aPos.second;
+ typename StoreT::size_type nDataSize = 0;
+ typename StoreT::size_type nTopRow = nStart;
for (; it != rStore.end() && nTopRow <= nEnd; ++it, nOffset = 0, nTopRow
+= nDataSize)
{
@@ -270,17 +270,17 @@ ParseElements4(
switch (it->type)
{
- case _Blk1::block_type:
- EachElem<_Blk1, typename _Blk1::const_iterator>(*it, nOffset,
nDataSize, rFuncElem);
+ case Blk1::block_type:
+ EachElem<Blk1, typename Blk1::const_iterator>(*it, nOffset,
nDataSize, rFuncElem);
break;
- case _Blk2::block_type:
- EachElem<_Blk2, typename _Blk2::const_iterator>(*it, nOffset,
nDataSize, rFuncElem);
+ case Blk2::block_type:
+ EachElem<Blk2, typename Blk2::const_iterator>(*it, nOffset,
nDataSize, rFuncElem);
break;
- case _Blk3::block_type:
- EachElem<_Blk3, typename _Blk3::const_iterator>(*it, nOffset,
nDataSize, rFuncElem);
+ case Blk3::block_type:
+ EachElem<Blk3, typename Blk3::const_iterator>(*it, nOffset,
nDataSize, rFuncElem);
break;
- case _Blk4::block_type:
- EachElem<_Blk4, typename _Blk4::const_iterator>(*it, nOffset,
nDataSize, rFuncElem);
+ case Blk4::block_type:
+ EachElem<Blk4, typename Blk4::const_iterator>(*it, nOffset,
nDataSize, rFuncElem);
break;
default:
rFuncElse(it->type, nTopRow, nDataSize);
@@ -293,41 +293,41 @@ ParseElements4(
return it;
}
-template<typename _StoreT, typename _BlkT, typename _FuncElem, typename
_FuncElse>
-void ProcessElements1(_StoreT& rStore, _FuncElem& rFuncElem, _FuncElse&
rFuncElse)
+template<typename StoreT, typename BlkT, typename FuncElem, typename FuncElse>
+void ProcessElements1(StoreT& rStore, FuncElem& rFuncElem, FuncElse& rFuncElse)
{
- typename _StoreT::size_type nTopRow = 0, nDataSize = 0;
- typename _StoreT::iterator it = rStore.begin(), itEnd = rStore.end();
+ typename StoreT::size_type nTopRow = 0, nDataSize = 0;
+ typename StoreT::iterator it = rStore.begin(), itEnd = rStore.end();
for (; it != itEnd; ++it, nTopRow += nDataSize)
{
nDataSize = it->size;
- if (it->type != _BlkT::block_type)
+ if (it->type != BlkT::block_type)
{
rFuncElse(it->type, nTopRow, nDataSize);
continue;
}
- EachElem<_BlkT, typename _BlkT::iterator>(*it, rFuncElem);
+ EachElem<BlkT, typename BlkT::iterator>(*it, rFuncElem);
}
}
/**
* This variant specifies start and end positions.
*/
-template<typename _StoreT, typename _BlkT, typename _FuncElem, typename
_FuncElse>
-typename _StoreT::iterator
+template<typename StoreT, typename BlkT, typename FuncElem, typename FuncElse>
+typename StoreT::iterator
ProcessElements1(
- const typename _StoreT::iterator& itPos, _StoreT& rStore,
- typename _StoreT::size_type nStart, typename _StoreT::size_type nEnd,
- _FuncElem& rFuncElem, _FuncElse& rFuncElse)
+ const typename StoreT::iterator& itPos, StoreT& rStore,
+ typename StoreT::size_type nStart, typename StoreT::size_type nEnd,
+ FuncElem& rFuncElem, FuncElse& rFuncElse)
{
- typedef std::pair<typename _StoreT::iterator, typename _StoreT::size_type>
PositionType;
+ typedef std::pair<typename StoreT::iterator, typename StoreT::size_type>
PositionType;
PositionType aPos = rStore.position(itPos, nStart);
- typename _StoreT::iterator it = aPos.first;
- typename _StoreT::size_type nOffset = aPos.second;
- typename _StoreT::size_type nDataSize = 0;
- typename _StoreT::size_type nTopRow = nStart;
+ typename StoreT::iterator it = aPos.first;
+ typename StoreT::size_type nOffset = aPos.second;
+ typename StoreT::size_type nDataSize = 0;
+ typename StoreT::size_type nTopRow = nStart;
for (; it != rStore.end() && nTopRow <= nEnd; ++it, nOffset = 0, nTopRow
+= nDataSize)
{
@@ -340,8 +340,8 @@ ProcessElements1(
bLastBlock = true;
}
- if (it->type == _BlkT::block_type)
- EachElem<_BlkT, typename _BlkT::iterator>(*it, nOffset, nDataSize,
rFuncElem);
+ if (it->type == BlkT::block_type)
+ EachElem<BlkT, typename BlkT::iterator>(*it, nOffset, nDataSize,
rFuncElem);
else
rFuncElse(it->type, nTopRow, nDataSize);
@@ -352,21 +352,21 @@ ProcessElements1(
return it;
};
-template<typename _StoreT, typename _Blk1, typename _Blk2, typename _FuncElem,
typename _FuncElse>
-void ProcessElements2(_StoreT& rStore, _FuncElem& rFuncElem, _FuncElse&
rFuncElse)
+template<typename StoreT, typename Blk1, typename Blk2, typename FuncElem,
typename FuncElse>
+void ProcessElements2(StoreT& rStore, FuncElem& rFuncElem, FuncElse& rFuncElse)
{
- typename _StoreT::size_type nTopRow = 0, nDataSize = 0;
- typename _StoreT::iterator it = rStore.begin(), itEnd = rStore.end();
+ typename StoreT::size_type nTopRow = 0, nDataSize = 0;
+ typename StoreT::iterator it = rStore.begin(), itEnd = rStore.end();
for (; it != itEnd; ++it, nTopRow += nDataSize)
{
nDataSize = it->size;
switch (it->type)
{
- case _Blk1::block_type:
- EachElem<_Blk1, typename _Blk1::iterator>(*it, rFuncElem);
+ case Blk1::block_type:
+ EachElem<Blk1, typename Blk1::iterator>(*it, rFuncElem);
break;
- case _Blk2::block_type:
- EachElem<_Blk2, typename _Blk2::iterator>(*it, rFuncElem);
+ case Blk2::block_type:
+ EachElem<Blk2, typename Blk2::iterator>(*it, rFuncElem);
break;
default:
rFuncElse(it->type, nTopRow, nDataSize);
@@ -374,20 +374,20 @@ void ProcessElements2(_StoreT& rStore, _FuncElem&
rFuncElem, _FuncElse& rFuncEls
}
}
-template<typename _StoreT, typename _Blk1, typename _FuncElem, typename
_FuncElse>
-std::pair<typename _StoreT::const_iterator, typename _StoreT::size_type>
+template<typename StoreT, typename Blk1, typename FuncElem, typename FuncElse>
+std::pair<typename StoreT::const_iterator, typename StoreT::size_type>
FindElement1(
- const _StoreT& rStore, typename _StoreT::size_type nStart, typename
_StoreT::size_type nEnd,
- _FuncElem& rFuncElem, _FuncElse& rFuncElse)
+ const StoreT& rStore, typename StoreT::size_type nStart, typename
StoreT::size_type nEnd,
+ FuncElem& rFuncElem, FuncElse& rFuncElse)
{
- typedef std::pair<typename _StoreT::const_iterator, typename
_StoreT::size_type> PositionType;
- typedef std::pair<typename _StoreT::size_type, bool> ElseRetType;
+ typedef std::pair<typename StoreT::const_iterator, typename
StoreT::size_type> PositionType;
+ typedef std::pair<typename StoreT::size_type, bool> ElseRetType;
PositionType aPos = rStore.position(nStart);
- typename _StoreT::const_iterator it = aPos.first;
- typename _StoreT::size_type nOffset = aPos.second;
- typename _StoreT::size_type nDataSize = 0;
- typename _StoreT::size_type nTopRow = nStart;
+ typename StoreT::const_iterator it = aPos.first;
+ typename StoreT::size_type nOffset = aPos.second;
+ typename StoreT::size_type nDataSize = 0;
+ typename StoreT::size_type nTopRow = nStart;
for (; it != rStore.end() && nTopRow <= nEnd; ++it, nOffset = 0, nTopRow
+= nDataSize)
{
@@ -402,9 +402,9 @@ FindElement1(
switch (it->type)
{
- case _Blk1::block_type:
+ case Blk1::block_type:
{
- PositionType aRet = CheckElem<_Blk1>(rStore, it, nOffset,
nDataSize, rFuncElem);
+ PositionType aRet = CheckElem<Blk1>(rStore, it, nOffset,
nDataSize, rFuncElem);
if (aRet.first != rStore.end())
return aRet;
}
@@ -424,20 +424,20 @@ FindElement1(
return PositionType(rStore.end(), 0);
}
-template<typename _StoreT, typename _Blk1, typename _Blk2, typename _FuncElem,
typename _FuncElse>
-std::pair<typename _StoreT::const_iterator, typename _StoreT::size_type>
+template<typename StoreT, typename Blk1, typename Blk2, typename FuncElem,
typename FuncElse>
+std::pair<typename StoreT::const_iterator, typename StoreT::size_type>
FindElement2(
- const _StoreT& rStore, typename _StoreT::size_type nStart, typename
_StoreT::size_type nEnd,
- _FuncElem& rFuncElem, _FuncElse& rFuncElse)
+ const StoreT& rStore, typename StoreT::size_type nStart, typename
StoreT::size_type nEnd,
+ FuncElem& rFuncElem, FuncElse& rFuncElse)
{
- typedef std::pair<typename _StoreT::const_iterator, typename
_StoreT::size_type> PositionType;
- typedef std::pair<typename _StoreT::size_type, bool> ElseRetType;
+ typedef std::pair<typename StoreT::const_iterator, typename
StoreT::size_type> PositionType;
+ typedef std::pair<typename StoreT::size_type, bool> ElseRetType;
PositionType aPos = rStore.position(nStart);
- typename _StoreT::const_iterator it = aPos.first;
- typename _StoreT::size_type nOffset = aPos.second;
- typename _StoreT::size_type nDataSize = 0;
- typename _StoreT::size_type nTopRow = nStart;
+ typename StoreT::const_iterator it = aPos.first;
+ typename StoreT::size_type nOffset = aPos.second;
+ typename StoreT::size_type nDataSize = 0;
+ typename StoreT::size_type nTopRow = nStart;
for (; it != rStore.end() && nTopRow <= nEnd; ++it, nOffset = 0, nTopRow
+= nDataSize)
{
@@ -452,16 +452,16 @@ FindElement2(
switch (it->type)
{
- case _Blk1::block_type:
+ case Blk1::block_type:
{
- PositionType aRet = CheckElem<_Blk1>(rStore, it, nOffset,
nDataSize, rFuncElem);
+ PositionType aRet = CheckElem<Blk1>(rStore, it, nOffset,
nDataSize, rFuncElem);
if (aRet.first != rStore.end())
return aRet;
}
break;
- case _Blk2::block_type:
+ case Blk2::block_type:
{
- PositionType aRet = CheckElem<_Blk2>(rStore, it, nOffset,
nDataSize, rFuncElem);
+ PositionType aRet = CheckElem<Blk2>(rStore, it, nOffset,
nDataSize, rFuncElem);
if (aRet.first != rStore.end())
return aRet;
}
diff --git a/sc/inc/sharedformula.hxx b/sc/inc/sharedformula.hxx
index b3d7615..f4c8ab0 100644
--- a/sc/inc/sharedformula.hxx
+++ b/sc/inc/sharedformula.hxx
@@ -29,10 +29,10 @@ public:
* Group formula cells stored in the passed container. The formula cells
* in the container are assumed to be all <b>non-shared</b>.
*/
- template<typename _Iter>
- static void groupFormulaCells(const _Iter& itBeg, const _Iter& itEnd)
+ template<typename Iter>
+ static void groupFormulaCells(const Iter& itBeg, const Iter& itEnd)
{
- _Iter it = itBeg;
+ Iter it = itBeg;
ScFormulaCell* pPrev = *it;
ScFormulaCell* pCur = nullptr;
for (++it; it != itEnd; ++it, pPrev = pCur)
diff --git a/sc/inc/stlalgorithm.hxx b/sc/inc/stlalgorithm.hxx
index 7cc5eeb..678f306 100644
--- a/sc/inc/stlalgorithm.hxx
+++ b/sc/inc/stlalgorithm.hxx
@@ -21,7 +21,7 @@ namespace sc {
* Custom allocator for STL container to ensure that the base address of
* allocated storage is aligned to a specified boundary.
*/
-template<typename T, size_t _Alignment>
+template<typename T, size_t Alignment>
class AlignedAllocator
{
public:
@@ -36,17 +36,17 @@ public:
typedef T& reference;
typedef const T& const_reference;
- template<typename _Type2>
+ template<typename Type2>
struct rebind
{
- typedef AlignedAllocator<_Type2,_Alignment> other;
+ typedef AlignedAllocator<Type2,Alignment> other;
};
AlignedAllocator() {}
~AlignedAllocator() {}
- template<typename _Type2>
- AlignedAllocator(const AlignedAllocator<_Type2,_Alignment>&) {}
+ template<typename Type2>
+ AlignedAllocator(const AlignedAllocator<Type2,Alignment>&) {}
static void construct(T* p, const value_type& val) { new(p)
value_type(val); }
static void destroy(T* p)
@@ -65,7 +65,7 @@ public:
static pointer allocate(size_type n)
{
- return static_cast<pointer>(rtl_allocateAlignedMemory(_Alignment,
n*sizeof(value_type)));
+ return static_cast<pointer>(rtl_allocateAlignedMemory(Alignment,
n*sizeof(value_type)));
}
static void deallocate(pointer p, size_type)
diff --git a/sc/qa/unit/helper/qahelper.hxx b/sc/qa/unit/helper/qahelper.hxx
index 083e2d1..0d089ce 100644
--- a/sc/qa/unit/helper/qahelper.hxx
+++ b/sc/qa/unit/helper/qahelper.hxx
@@ -138,8 +138,8 @@ SCQAHELPER_DLLPUBLIC ScTokenArray* compileFormula(
ScDocument* pDoc, const OUString& rFormula, const ScAddress* pPos =
nullptr,
formula::FormulaGrammar::Grammar eGram =
formula::FormulaGrammar::GRAM_NATIVE );
-template<size_t _Size>
-bool checkOutput(ScDocument* pDoc, const ScRange& aOutRange, const char*
aOutputCheck[][_Size], const char* pCaption)
+template<size_t Size>
+bool checkOutput(ScDocument* pDoc, const ScRange& aOutRange, const char*
aOutputCheck[][Size], const char* pCaption)
{
bool bResult = true;
const ScAddress& s = aOutRange.aStart;
diff --git a/sc/qa/unit/ucalc.cxx b/sc/qa/unit/ucalc.cxx
index f46cd76..d10ac5b 100644
--- a/sc/qa/unit/ucalc.cxx
+++ b/sc/qa/unit/ucalc.cxx
@@ -1014,8 +1014,8 @@ struct HoriIterCheck
const char* pVal;
};
-template<size_t _Size>
-bool checkHorizontalIterator(ScDocument* pDoc, const char* pData[][_Size],
size_t nDataCount, const HoriIterCheck* pChecks, size_t nCheckCount)
+template<size_t Size>
+bool checkHorizontalIterator(ScDocument* pDoc, const char* pData[][Size],
size_t nDataCount, const HoriIterCheck* pChecks, size_t nCheckCount)
{
ScAddress aPos(0,0,0);
Test::insertRangeData(pDoc, aPos, pData, nDataCount);
diff --git a/sc/qa/unit/ucalc.hxx b/sc/qa/unit/ucalc.hxx
index 9c93016..9427367 100644
--- a/sc/qa/unit/ucalc.hxx
+++ b/sc/qa/unit/ucalc.hxx
@@ -58,17 +58,17 @@ public:
static void setCalcAsShown(ScDocument* pDoc, bool bCalcAsShown);
- template<size_t _Size>
+ template<size_t Size>
static ScRange insertRangeData(
- ScDocument* pDoc, const ScAddress& rPos, const char* aData[][_Size],
size_t nRowCount )
+ ScDocument* pDoc, const ScAddress& rPos, const char* aData[][Size],
size_t nRowCount )
{
ScRange aRange(rPos);
- aRange.aEnd.SetCol(rPos.Col()+_Size-1);
+ aRange.aEnd.SetCol(rPos.Col()+Size-1);
aRange.aEnd.SetRow(rPos.Row()+nRowCount-1);
clearRange(pDoc, aRange);
- for (size_t i = 0; i < _Size; ++i)
+ for (size_t i = 0; i < Size; ++i)
{
for (size_t j = 0; j < nRowCount; ++j)
{
diff --git a/sc/qa/unit/ucalc_formula.cxx b/sc/qa/unit/ucalc_formula.cxx
index cf1944b..a58ec4d 100644
--- a/sc/qa/unit/ucalc_formula.cxx
+++ b/sc/qa/unit/ucalc_formula.cxx
@@ -4425,14 +4425,14 @@ struct StrStrCheck {
const char* pRes;
};
-template<size_t _DataSize, size_t _FormulaSize, int _Type>
-void runTestMATCH(ScDocument* pDoc, const char* aData[_DataSize], StrStrCheck
aChecks[_FormulaSize])
+template<size_t DataSize, size_t FormulaSize, int Type>
+void runTestMATCH(ScDocument* pDoc, const char* aData[DataSize], StrStrCheck
aChecks[FormulaSize])
{
- size_t nDataSize = _DataSize;
+ size_t nDataSize = DataSize;
for (size_t i = 0; i < nDataSize; ++i)
pDoc->SetString(0, i, 0, OUString::createFromAscii(aData[i]));
- for (size_t i = 0; i < _FormulaSize; ++i)
+ for (size_t i = 0; i < FormulaSize; ++i)
{
pDoc->SetString(1, i, 0, OUString::createFromAscii(aChecks[i].pVal));
@@ -4442,17 +4442,17 @@ void runTestMATCH(ScDocument* pDoc, const char*
aData[_DataSize], StrStrCheck aC
aBuf.append(";A1:A");
aBuf.append(static_cast<sal_Int32>(nDataSize));
aBuf.append(";");
- aBuf.append(static_cast<sal_Int32>(_Type));
+ aBuf.append(static_cast<sal_Int32>(Type));
aBuf.append(")");
OUString aFormula = aBuf.makeStringAndClear();
pDoc->SetString(2, i, 0, aFormula);
}
pDoc->CalcAll();
- Test::printRange(pDoc, ScRange(0, 0, 0, 2, _FormulaSize-1, 0), "MATCH");
+ Test::printRange(pDoc, ScRange(0, 0, 0, 2, FormulaSize-1, 0), "MATCH");
// verify the results.
- for (size_t i = 0; i < _FormulaSize; ++i)
+ for (size_t i = 0; i < FormulaSize; ++i)
{
OUString aStr = pDoc->GetString(2, i, 0);
if (!aStr.equalsAscii(aChecks[i].pRes))
@@ -4464,14 +4464,14 @@ void runTestMATCH(ScDocument* pDoc, const char*
aData[_DataSize], StrStrCheck aC
}
}
-template<size_t _DataSize, size_t _FormulaSize, int _Type>
-void runTestHorizontalMATCH(ScDocument* pDoc, const char* aData[_DataSize],
StrStrCheck aChecks[_FormulaSize])
+template<size_t DataSize, size_t FormulaSize, int Type>
+void runTestHorizontalMATCH(ScDocument* pDoc, const char* aData[DataSize],
StrStrCheck aChecks[FormulaSize])
{
- size_t nDataSize = _DataSize;
+ size_t nDataSize = DataSize;
for (size_t i = 0; i < nDataSize; ++i)
pDoc->SetString(i, 0, 0, OUString::createFromAscii(aData[i]));
- for (size_t i = 0; i < _FormulaSize; ++i)
+ for (size_t i = 0; i < FormulaSize; ++i)
{
pDoc->SetString(i, 1, 0, OUString::createFromAscii(aChecks[i].pVal));
@@ -4482,17 +4482,17 @@ void runTestHorizontalMATCH(ScDocument* pDoc, const
char* aData[_DataSize], StrS
aBuf.append("2;A1:");
aBuf.append(static_cast<sal_Unicode>('A'+nDataSize));
aBuf.append("1;");
- aBuf.append(static_cast<sal_Int32>(_Type));
+ aBuf.append(static_cast<sal_Int32>(Type));
aBuf.append(")");
OUString aFormula = aBuf.makeStringAndClear();
pDoc->SetString(i, 2, 0, aFormula);
}
pDoc->CalcAll();
- Test::printRange(pDoc, ScRange(0, 0, 0, _FormulaSize-1, 2, 0), "MATCH");
+ Test::printRange(pDoc, ScRange(0, 0, 0, FormulaSize-1, 2, 0), "MATCH");
// verify the results.
- for (size_t i = 0; i < _FormulaSize; ++i)
+ for (size_t i = 0; i < FormulaSize; ++i)
{
OUString aStr = pDoc->GetString(i, 2, 0);
if (!aStr.equalsAscii(aChecks[i].pRes))
diff --git a/sc/qa/unit/ucalc_pivottable.cxx b/sc/qa/unit/ucalc_pivottable.cxx
index ef11505..c8aa1b3 100644
--- a/sc/qa/unit/ucalc_pivottable.cxx
+++ b/sc/qa/unit/ucalc_pivottable.cxx
@@ -41,8 +41,8 @@ struct DPFieldDef
bool bRepeatItemLabels;
};
-template<size_t _Size>
-ScRange insertDPSourceData(ScDocument* pDoc, DPFieldDef aFields[], size_t
nFieldCount, const char* aData[][_Size], size_t nDataCount)
+template<size_t Size>
+ScRange insertDPSourceData(ScDocument* pDoc, DPFieldDef aFields[], size_t
nFieldCount, const char* aData[][Size], size_t nDataCount)
{
// Insert field names in row 0.
for (size_t i = 0; i < nFieldCount; ++i)
@@ -72,10 +72,10 @@ ScRange insertDPSourceData(ScDocument* pDoc, DPFieldDef
aFields[], size_t nField
return aSrcRange;
}
-template<size_t _Size>
-bool checkDPTableOutput(ScDocument* pDoc, const ScRange& aOutRange, const
char* aOutputCheck[][_Size], const char* pCaption)
+template<size_t Size>
+bool checkDPTableOutput(ScDocument* pDoc, const ScRange& aOutRange, const
char* aOutputCheck[][Size], const char* pCaption)
{
- return checkOutput<_Size>(pDoc, aOutRange, aOutputCheck, pCaption);
+ return checkOutput<Size>(pDoc, aOutRange, aOutputCheck, pCaption);
}
ScDPObject* createDPFromSourceDesc(
diff --git a/sc/source/core/data/cellvalue.cxx
b/sc/source/core/data/cellvalue.cxx
index bba0b95..d6b71f1 100644
--- a/sc/source/core/data/cellvalue.cxx
+++ b/sc/source/core/data/cellvalue.cxx
@@ -33,8 +33,8 @@ CellType adjustCellType( CellType eOrig )
return eOrig;
}
-template<typename _T>
-OUString getString( const _T& rVal )
+template<typename T>
+OUString getString( const T& rVal )
{
if (rVal.meType == CELLTYPE_STRING)
return rVal.mpString->getString();
@@ -75,8 +75,8 @@ bool equalsFormulaCells( const ScFormulaCell* p1, const
ScFormulaCell* p2 )
return true;
}
-template<typename _T>
-bool equalsWithoutFormatImpl( const _T& left, const _T& right )
+template<typename T>
+bool equalsWithoutFormatImpl( const T& left, const T& right )
{
CellType eType1 = adjustCellType(left.meType);
CellType eType2 = adjustCellType(right.meType);
@@ -154,8 +154,8 @@ bool hasNumericImpl( CellType eType, ScFormulaCell*
pFormula )
}
}
-template<typename _CellT>
-OUString getStringImpl( const _CellT& rCell, const ScDocument* pDoc )
+template<typename CellT>
+OUString getStringImpl( const CellT& rCell, const ScDocument* pDoc )
{
switch (rCell.meType)
{
diff --git a/sc/source/core/data/column2.cxx b/sc/source/core/data/column2.cxx
index 3c2986e..8921787 100644
--- a/sc/source/core/data/column2.cxx
+++ b/sc/source/core/data/column2.cxx
@@ -2307,16 +2307,16 @@ void ScColumn::FillMatrix( ScMatrix& rMat, size_t
nMatCol, SCROW nRow1, SCROW nR
namespace {
-template<typename _Blk>
+template<typename Blk>
void getBlockIterators(
const sc::CellStoreType::iterator& it, size_t& rLenRemain,
- typename _Blk::iterator& rData, typename _Blk::iterator& rDataEnd )
+ typename Blk::iterator& rData, typename Blk::iterator& rDataEnd )
{
- rData = _Blk::begin(*it->data);
+ rData = Blk::begin(*it->data);
if (rLenRemain >= it->size)
{
// Block is shorter than the remaining requested length.
- rDataEnd = _Blk::end(*it->data);
+ rDataEnd = Blk::end(*it->data);
rLenRemain -= it->size;
}
else
diff --git a/sc/source/core/data/dociter.cxx b/sc/source/core/data/dociter.cxx
index af2c6de..db67375 100644
--- a/sc/source/core/data/dociter.cxx
+++ b/sc/source/core/data/dociter.cxx
@@ -56,16 +56,16 @@ using ::std::set;
namespace {
-template<typename _Iter>
-void incBlock(std::pair<_Iter, size_t>& rPos)
+template<typename Iter>
+void incBlock(std::pair<Iter, size_t>& rPos)
{
// Move to the next block.
++rPos.first;
rPos.second = 0;
}
-template<typename _Iter>
-void decBlock(std::pair<_Iter, size_t>& rPos)
+template<typename Iter>
+void decBlock(std::pair<Iter, size_t>& rPos)
{
// Move to the last element of the previous block.
--rPos.first;
diff --git a/sc/source/core/data/segmenttree.cxx
b/sc/source/core/data/segmenttree.cxx
index d9e60bc..7159d9c 100644
--- a/sc/source/core/data/segmenttree.cxx
+++ b/sc/source/core/data/segmenttree.cxx
@@ -26,12 +26,12 @@
using ::std::numeric_limits;
-template<typename _ValueType, typename _ExtValueType = _ValueType>
+template<typename ValueType_, typename ExtValueType_ = ValueType_>
class ScFlatSegmentsImpl
{
public:
- typedef _ValueType ValueType;
- typedef _ExtValueType ExtValueType;
+ typedef ValueType_ ValueType;
+ typedef ExtValueType_ ExtValueType;
struct RangeData
{
@@ -71,27 +71,27 @@ private:
bool mbTreeSearchEnabled:1;
};
-template<typename _ValueType, typename _ExtValueType>
-ScFlatSegmentsImpl<_ValueType, _ExtValueType>::ScFlatSegmentsImpl(SCCOLROW
nMax, ValueType nDefault) :
+template<typename ValueType_, typename ExtValueType_>
+ScFlatSegmentsImpl<ValueType_, ExtValueType_>::ScFlatSegmentsImpl(SCCOLROW
nMax, ValueType nDefault) :
maSegments(0, nMax+1, nDefault),
mbTreeSearchEnabled(true)
{
}
-template<typename _ValueType, typename _ExtValueType>
-ScFlatSegmentsImpl<_ValueType, _ExtValueType>::ScFlatSegmentsImpl(const
ScFlatSegmentsImpl<_ValueType, _ExtValueType>& r) :
+template<typename ValueType_, typename ExtValueType_>
+ScFlatSegmentsImpl<ValueType_, ExtValueType_>::ScFlatSegmentsImpl(const
ScFlatSegmentsImpl<ValueType_, ExtValueType_>& r) :
maSegments(r.maSegments),
mbTreeSearchEnabled(r.mbTreeSearchEnabled)
{
}
-template<typename _ValueType, typename _ExtValueType>
-ScFlatSegmentsImpl<_ValueType, _ExtValueType>::~ScFlatSegmentsImpl()
+template<typename ValueType_, typename ExtValueType_>
+ScFlatSegmentsImpl<ValueType_, ExtValueType_>::~ScFlatSegmentsImpl()
{
}
-template<typename _ValueType, typename _ExtValueType>
-bool ScFlatSegmentsImpl<_ValueType, _ExtValueType>::setValue(SCCOLROW nPos1,
SCCOLROW nPos2, ValueType nValue)
+template<typename ValueType_, typename ExtValueType_>
+bool ScFlatSegmentsImpl<ValueType_, ExtValueType_>::setValue(SCCOLROW nPos1,
SCCOLROW nPos2, ValueType nValue)
{
::std::pair<typename fst_type::const_iterator, bool> ret;
ret = maSegments.insert(maItr, nPos1, nPos2+1, nValue);
@@ -99,8 +99,8 @@ bool ScFlatSegmentsImpl<_ValueType,
_ExtValueType>::setValue(SCCOLROW nPos1, SCC
return ret.second;
}
-template<typename _ValueType, typename _ExtValueType>
-typename ScFlatSegmentsImpl<_ValueType, _ExtValueType>::ValueType
ScFlatSegmentsImpl<_ValueType, _ExtValueType>::getValue(SCCOLROW nPos)
+template<typename ValueType_, typename ExtValueType_>
+typename ScFlatSegmentsImpl<ValueType_, ExtValueType_>::ValueType
ScFlatSegmentsImpl<ValueType_, ExtValueType_>::getValue(SCCOLROW nPos)
{
ValueType nValue = 0;
if (!mbTreeSearchEnabled)
@@ -116,9 +116,9 @@ typename ScFlatSegmentsImpl<_ValueType,
_ExtValueType>::ValueType ScFlatSegments
return nValue;
}
-template<typename _ValueType, typename _ExtValueType>
-typename ScFlatSegmentsImpl<_ValueType, _ExtValueType>::ExtValueType
-ScFlatSegmentsImpl<_ValueType, _ExtValueType>::getSumValue(SCCOLROW nPos1,
SCCOLROW nPos2)
+template<typename ValueType_, typename ExtValueType_>
+typename ScFlatSegmentsImpl<ValueType_, ExtValueType_>::ExtValueType
+ScFlatSegmentsImpl<ValueType_, ExtValueType_>::getSumValue(SCCOLROW nPos1,
SCCOLROW nPos2)
{
RangeData aData;
if (!getRangeData(nPos1, aData))
@@ -145,8 +145,8 @@ ScFlatSegmentsImpl<_ValueType,
_ExtValueType>::getSumValue(SCCOLROW nPos1, SCCOL
return nValue;
}
-template<typename _ValueType, typename _ExtValueType>
-bool ScFlatSegmentsImpl<_ValueType, _ExtValueType>::getRangeData(SCCOLROW
nPos, RangeData& rData)
+template<typename ValueType_, typename ExtValueType_>
+bool ScFlatSegmentsImpl<ValueType_, ExtValueType_>::getRangeData(SCCOLROW
nPos, RangeData& rData)
{
if (!mbTreeSearchEnabled)
return getRangeDataLeaf(nPos, rData);
@@ -161,8 +161,8 @@ bool ScFlatSegmentsImpl<_ValueType,
_ExtValueType>::getRangeData(SCCOLROW nPos,
return true;
}
-template<typename _ValueType, typename _ExtValueType>
-bool ScFlatSegmentsImpl<_ValueType, _ExtValueType>::getRangeDataLeaf(SCCOLROW
nPos, RangeData& rData)
+template<typename ValueType_, typename ExtValueType_>
+bool ScFlatSegmentsImpl<ValueType_, ExtValueType_>::getRangeDataLeaf(SCCOLROW
nPos, RangeData& rData)
{
// Conduct leaf-node only search. Faster when searching between range
insertion.
const ::std::pair<typename fst_type::const_iterator, bool> &ret =
@@ -177,22 +177,22 @@ bool ScFlatSegmentsImpl<_ValueType,
_ExtValueType>::getRangeDataLeaf(SCCOLROW nP
return true;
}
-template<typename _ValueType, typename _ExtValueType>
-void ScFlatSegmentsImpl<_ValueType, _ExtValueType>::removeSegment(SCCOLROW
nPos1, SCCOLROW nPos2)
+template<typename ValueType_, typename ExtValueType_>
+void ScFlatSegmentsImpl<ValueType_, ExtValueType_>::removeSegment(SCCOLROW
nPos1, SCCOLROW nPos2)
{
maSegments.shift_left(nPos1, nPos2);
maItr = maSegments.begin();
}
-template<typename _ValueType, typename _ExtValueType>
-void ScFlatSegmentsImpl<_ValueType, _ExtValueType>::insertSegment(SCCOLROW
nPos, SCCOLROW nSize, bool bSkipStartBoundary)
+template<typename ValueType_, typename ExtValueType_>
+void ScFlatSegmentsImpl<ValueType_, ExtValueType_>::insertSegment(SCCOLROW
nPos, SCCOLROW nSize, bool bSkipStartBoundary)
{
maSegments.shift_right(nPos, nSize, bSkipStartBoundary);
maItr = maSegments.begin();
}
-template<typename _ValueType, typename _ExtValueType>
-SCCOLROW ScFlatSegmentsImpl<_ValueType, _ExtValueType>::findLastTrue(ValueType
nValue) const
+template<typename ValueType_, typename ExtValueType_>
+SCCOLROW ScFlatSegmentsImpl<ValueType_, ExtValueType_>::findLastTrue(ValueType
nValue) const
{
SCCOLROW nPos = numeric_limits<SCCOLROW>::max(); // position not found.
typename fst_type::const_reverse_iterator itr = maSegments.rbegin(),
itrEnd = maSegments.rend();
@@ -209,15 +209,15 @@ SCCOLROW ScFlatSegmentsImpl<_ValueType,
_ExtValueType>::findLastTrue(ValueType n
return nPos;
}
-template<typename _ValueType, typename _ExtValueType>
-bool ScFlatSegmentsImpl<_ValueType, _ExtValueType>::getFirst(RangeData& rData)
+template<typename ValueType_, typename ExtValueType_>
+bool ScFlatSegmentsImpl<ValueType_, ExtValueType_>::getFirst(RangeData& rData)
{
maItr = maSegments.begin();
return getNext(rData);
}
-template<typename _ValueType, typename _ExtValueType>
-bool ScFlatSegmentsImpl<_ValueType, _ExtValueType>::getNext(RangeData& rData)
+template<typename ValueType_, typename ExtValueType_>
+bool ScFlatSegmentsImpl<ValueType_, ExtValueType_>::getNext(RangeData& rData)
{
typename fst_type::const_iterator itrEnd = maSegments.end();
if (maItr == itrEnd)
diff --git a/sc/source/core/data/table3.cxx b/sc/source/core/data/table3.cxx
index 4cd6bf2..3fb4799 100644
--- a/sc/source/core/data/table3.cxx
+++ b/sc/source/core/data/table3.cxx
@@ -652,12 +652,12 @@ void ScTable::DestroySortCollator()
namespace {
-template<typename _Hint, typename _ReorderMap, typename _Index>
+template<typename Hint, typename ReorderMap, typename Index>
class ReorderNotifier : public std::unary_function<SvtListener*, void>
{
- _Hint maHint;
+ Hint maHint;
public:
- ReorderNotifier( const _ReorderMap& rMap, SCTAB nTab, _Index nPos1, _Index
nPos2 ) :
+ ReorderNotifier( const ReorderMap& rMap, SCTAB nTab, Index nPos1, Index
nPos2 ) :
maHint(rMap, nTab, nPos1, nPos2) {}
void operator() ( SvtListener* p )
diff --git a/sc/source/core/tool/interpr5.cxx b/sc/source/core/tool/interpr5.cxx
index 40cca4e..66b20f6 100644
--- a/sc/source/core/tool/interpr5.cxx
+++ b/sc/source/core/tool/interpr5.cxx
@@ -1096,11 +1096,11 @@ static inline SCSIZE lcl_GetMinExtent( SCSIZE n1,
SCSIZE n2 )
return n2;
}
-template<class _Function>
+template<class Function>
static ScMatrixRef lcl_MatrixCalculation(
const ScMatrix& rMat1, const ScMatrix& rMat2, ScInterpreter* pInterpreter)
{
- static _Function Op;
+ static Function Op;
SCSIZE nC1, nC2, nMinC;
SCSIZE nR1, nR2, nMinR;
diff --git a/sc/source/core/tool/scmatrix.cxx b/sc/source/core/tool/scmatrix.cxx
index 8c096d4..26b98ac 100644
--- a/sc/source/core/tool/scmatrix.cxx
+++ b/sc/source/core/tool/scmatrix.cxx
@@ -131,10 +131,10 @@ struct ElemLessEqualZero : public unary_function<double,
double>
}
};
-template<typename _Comp>
+template<typename Comp>
class CompareMatrixElemFunc : public
std::unary_function<MatrixImplType::element_block_node_type, void>
{
- static _Comp maComp;
+ static Comp maComp;
std::vector<double> maNewMatValues; // double instead of bool to
transport error values
size_t mnRow;
@@ -190,8 +190,8 @@ public:
}
};
-template<typename _Comp>
-_Comp CompareMatrixElemFunc<_Comp>::maComp;
+template<typename Comp>
+Comp CompareMatrixElemFunc<Comp>::maComp;
}
@@ -979,10 +979,10 @@ struct XorEvaluator
// Do not short circuit logical operations, in case there are error values
// these need to be propagated even if the result was determined earlier.
-template <typename _Evaluator>
+template <typename Evaluator>
double EvalMatrix(const MatrixImplType& rMat)
{
- _Evaluator aEval;
+ Evaluator aEval;
size_t nRows = rMat.size().row, nCols = rMat.size().column;
for (size_t i = 0; i < nRows; ++i)
{
@@ -1030,15 +1030,15 @@ double ScMatrixImpl::Xor() const
namespace {
-template<typename _Op>
+template<typename Op>
class WalkElementBlocks
{
- _Op maOp;
+ Op maOp;
ScMatrix::IterateResult maRes;
bool mbFirst:1;
bool mbTextAsZero:1;
public:
- WalkElementBlocks(bool bTextAsZero) : maRes(_Op::InitVal, _Op::InitVal,
0), mbFirst(true), mbTextAsZero(bTextAsZero) {}
+ WalkElementBlocks(bool bTextAsZero) : maRes(Op::InitVal, Op::InitVal, 0),
mbFirst(true), mbTextAsZero(bTextAsZero) {}
const ScMatrix::IterateResult& getResult() const { return maRes; }
@@ -1099,15 +1099,15 @@ public:
}
};
-template<typename _Op>
+template<typename Op>
class WalkElementBlocksMultipleValues
{
- const std::vector<std::unique_ptr<_Op>>& maOp;
+ const std::vector<std::unique_ptr<Op>>& maOp;
std::vector<ScMatrix::IterateResult> maRes;
bool mbFirst:1;
bool mbTextAsZero:1;
public:
- WalkElementBlocksMultipleValues(bool bTextAsZero, const
std::vector<std::unique_ptr<_Op>>& aOp) :
+ WalkElementBlocksMultipleValues(bool bTextAsZero, const
std::vector<std::unique_ptr<Op>>& aOp) :
maOp(aOp), mbFirst(true), mbTextAsZero(bTextAsZero)
{
for (const auto& pOp : maOp)
@@ -1234,10 +1234,10 @@ public:
const size_t ResultNotSet = std::numeric_limits<size_t>::max();
-template<typename _Type>
+template<typename Type>
class WalkAndMatchElements : public
std::unary_function<MatrixImplType::element_block_node_type, void>
{
- _Type maMatchValue;
+ Type maMatchValue;
MatrixImplType::size_pair_type maSize;
size_t mnCol1;
size_t mnCol2;
@@ -1245,7 +1245,7 @@ class WalkAndMatchElements : public
std::unary_function<MatrixImplType::element_
size_t mnIndex;
public:
- WalkAndMatchElements(_Type aMatchValue, const
MatrixImplType::size_pair_type& aSize, size_t nCol1, size_t nCol2) :
+ WalkAndMatchElements(Type aMatchValue, const
MatrixImplType::size_pair_type& aSize, size_t nCol1, size_t nCol2) :
maMatchValue(aMatchValue),
maSize(aSize),
mnCol1(nCol1),
@@ -1384,7 +1384,7 @@ struct MinOp
}
};
-template<typename _Op>
+template<typename Op>
class CalcMaxMinValue : public
std::unary_function<MatrixImplType::element_block_type, void>
{
double mfVal;
@@ -1392,7 +1392,7 @@ class CalcMaxMinValue : public
std::unary_function<MatrixImplType::element_block
bool mbHasValue;
public:
CalcMaxMinValue( bool bTextAsZero ) :
- mfVal(_Op::init()),
+ mfVal(Op::init()),
mbTextAsZero(bTextAsZero),
mbHasValue(false) {}
@@ -1410,7 +1410,7 @@ public:
block_type::const_iterator it = block_type::begin(*node.data);
block_type::const_iterator itEnd = block_type::end(*node.data);
for (; it != itEnd; ++it)
- mfVal = _Op::compare(mfVal, *it);
+ mfVal = Op::compare(mfVal, *it);
mbHasValue = true;
}
@@ -1421,8 +1421,8 @@ public:
block_type::const_iterator it = block_type::begin(*node.data);
block_type::const_iterator itEnd = block_type::end(*node.data);
- double fVal = _Op::boolValue(it, itEnd);
- mfVal = _Op::compare(mfVal, fVal);
+ double fVal = Op::boolValue(it, itEnd);
+ mfVal = Op::compare(mfVal, fVal);
mbHasValue = true;
}
break;
@@ -1432,7 +1432,7 @@ public:
// empty elements are treated as empty strings.
if (mbTextAsZero)
{
- mfVal = _Op::compare(mfVal, 0.0);
+ mfVal = Op::compare(mfVal, 0.0);
mbHasValue = true;
}
}
@@ -1730,7 +1730,7 @@ struct ArrayMul : public std::binary_function<double,
double, double>
}
};
-template<typename _Op>
+template<typename Op>
class MergeDoubleArrayFunc : public
std::unary_function<MatrixImplType::element_block_type, void>
{
std::vector<double>& mrArray;
@@ -1745,7 +1745,7 @@ public:
void operator() (const MatrixImplType::element_block_node_type& node)
{
using namespace mdds::mtv;
- static _Op op;
+ static Op op;
switch (node.type)
{
diff --git a/sc/source/filter/excel/excform.cxx
b/sc/source/filter/excel/excform.cxx
index 33ec52f..fed5b0e 100644
--- a/sc/source/filter/excel/excform.cxx
+++ b/sc/source/filter/excel/excform.cxx
@@ -923,7 +923,7 @@ ConvErr ExcelToSc::Convert( const ScTokenArray*& pErgebnis,
XclImpStream& aIn, s
}
// stream seeks to first byte after <nFormulaLen>
-ConvErr ExcelToSc::Convert( _ScRangeListTabs& rRangeList, XclImpStream& aIn,
sal_Size nFormulaLen,
+ConvErr ExcelToSc::Convert( ScRangeListTabs& rRangeList, XclImpStream& aIn,
sal_Size nFormulaLen,
SCsTAB nTab, const FORMULA_TYPE eFT )
{
RootData& rR = GetOldRoot();
diff --git a/sc/source/filter/excel/excform8.cxx
b/sc/source/filter/excel/excform8.cxx
index 5e43915..bea8ba3 100644
--- a/sc/source/filter/excel/excform8.cxx
+++ b/sc/source/filter/excel/excform8.cxx
@@ -953,7 +953,7 @@ ConvErr ExcelToSc8::Convert( const ScTokenArray*&
rpTokArray, XclImpStream& aIn,
}
// stream seeks to first byte after <nFormulaLen>
-ConvErr ExcelToSc8::Convert( _ScRangeListTabs& rRangeList, XclImpStream& aIn,
sal_Size nFormulaLen,
+ConvErr ExcelToSc8::Convert( ScRangeListTabs& rRangeList, XclImpStream& aIn,
sal_Size nFormulaLen,
SCsTAB nTab, const FORMULA_TYPE eFT )
{
sal_uInt8 nOp, nLen;
diff --git a/sc/source/filter/excel/exctools.cxx
b/sc/source/filter/excel/exctools.cxx
index 1849c4a..0b3fe11 100644
--- a/sc/source/filter/excel/exctools.cxx
+++ b/sc/source/filter/excel/exctools.cxx
@@ -55,8 +55,8 @@ RootData::RootData()
pFmlaConverter = nullptr;
pAutoFilterBuffer = nullptr;
- pPrintRanges = new _ScRangeListTabs;
- pPrintTitles = new _ScRangeListTabs;
+ pPrintRanges = new ScRangeListTabs;
+ pPrintTitles = new ScRangeListTabs;
pTabId = nullptr;
pUserBViewList = nullptr;
diff --git a/sc/source/filter/excel/frmbase.cxx
b/sc/source/filter/excel/frmbase.cxx
index fd1c4d7..16ec427 100644
--- a/sc/source/filter/excel/frmbase.cxx
+++ b/sc/source/filter/excel/frmbase.cxx
@@ -21,15 +21,15 @@
#include <o3tl/make_unique.hxx>
-_ScRangeListTabs::_ScRangeListTabs()
+ScRangeListTabs::ScRangeListTabs()
{
}
-_ScRangeListTabs::~_ScRangeListTabs()
+ScRangeListTabs::~ScRangeListTabs()
{
}
-void _ScRangeListTabs::Append( const ScAddress& aSRD, SCTAB nTab )
+void ScRangeListTabs::Append( const ScAddress& aSRD, SCTAB nTab )
{
ScAddress a = aSRD;
@@ -66,7 +66,7 @@ void _ScRangeListTabs::Append( const ScAddress& aSRD, SCTAB
nTab )
itr->second->push_back(ScRange(a.Col(),a.Row(),a.Tab()));
}
-void _ScRangeListTabs::Append( const ScRange& aCRD, SCTAB nTab )
+void ScRangeListTabs::Append( const ScRange& aCRD, SCTAB nTab )
{
ScRange a = aCRD;
@@ -124,9 +124,9 @@ void _ScRangeListTabs::Append( const ScRange& aCRD, SCTAB
nTab )
itr->second->push_back(a);
}
-const ScRange* _ScRangeListTabs::First( SCTAB n )
+const ScRange* ScRangeListTabs::First( SCTAB n )
{
- OSL_ENSURE( ValidTab(n), "-_ScRangeListTabs::First(): Good bye!" );
+ OSL_ENSURE( ValidTab(n), "-ScRangeListTabs::First(): Good bye!" );
TabRangeType::iterator itr = m_TabRanges.find(n);
if (itr == m_TabRanges.end())
@@ -139,7 +139,7 @@ const ScRange* _ScRangeListTabs::First( SCTAB n )
return rList.empty() ? nullptr : &(*maItrCur);
}
-const ScRange* _ScRangeListTabs::Next ()
+const ScRange* ScRangeListTabs::Next ()
{
++maItrCur;
if (maItrCur == maItrCurEnd)
diff --git a/sc/source/filter/excel/xiroot.cxx
b/sc/source/filter/excel/xiroot.cxx
index 2ff388b..23cfb0b 100644
--- a/sc/source/filter/excel/xiroot.cxx
+++ b/sc/source/filter/excel/xiroot.cxx
@@ -169,13 +169,13 @@ XclImpXFRangeBuffer& XclImpRoot::GetXFRangeBuffer() const
return *mrImpData.mxXFRangeBfr;
}
-_ScRangeListTabs& XclImpRoot::GetPrintAreaBuffer() const
+ScRangeListTabs& XclImpRoot::GetPrintAreaBuffer() const
{
// TODO still in old RootData
return *GetOldRoot().pPrintRanges;
}
-_ScRangeListTabs& XclImpRoot::GetTitleAreaBuffer() const
+ScRangeListTabs& XclImpRoot::GetTitleAreaBuffer() const
{
// TODO still in old RootData
return *GetOldRoot().pPrintTitles;
diff --git a/sc/source/filter/inc/excform.hxx b/sc/source/filter/inc/excform.hxx
index ebc6db0..5edda9f 100644
--- a/sc/source/filter/inc/excform.hxx
+++ b/sc/source/filter/inc/excform.hxx
@@ -51,7 +51,7 @@ public:
virtual ConvErr Convert( const ScTokenArray*&, XclImpStream& rStrm,
sal_Size nFormulaLen,
bool bAllowArrays, const FORMULA_TYPE eFT =
FT_CellFormula ) override;
- virtual ConvErr Convert( _ScRangeListTabs&, XclImpStream& rStrm,
sal_Size nFormulaLen, SCsTAB nTab, const FORMULA_TYPE eFT = FT_CellFormula )
override;
+ virtual ConvErr Convert( ScRangeListTabs&, XclImpStream& rStrm,
sal_Size nFormulaLen, SCsTAB nTab, const FORMULA_TYPE eFT = FT_CellFormula )
override;
virtual void ConvertExternName( const ScTokenArray*& rpArray,
XclImpStream& rStrm, sal_Size nFormulaLen,
const OUString& rUrl, const
::std::vector<OUString>& rTabNames );
@@ -124,7 +124,7 @@ public:
virtual ConvErr Convert( const ScTokenArray*& rpTokArray,
XclImpStream& rStrm, sal_Size nFormulaLen, bool bAllowArrays, const
FORMULA_TYPE eFT = FT_CellFormula ) override;
- virtual ConvErr Convert( _ScRangeListTabs&, XclImpStream& rStrm,
sal_Size nFormulaLen, SCsTAB nTab, const FORMULA_TYPE eFT = FT_CellFormula )
override;
+ virtual ConvErr Convert( ScRangeListTabs&, XclImpStream& rStrm,
sal_Size nFormulaLen, SCsTAB nTab, const FORMULA_TYPE eFT = FT_CellFormula )
override;
virtual void ConvertExternName( const ScTokenArray*& rpArray,
XclImpStream& rStrm, sal_Size nFormulaLen,
const OUString& rUrl, const
::std::vector<OUString>& rTabNames ) override;
diff --git a/sc/source/filter/inc/formel.hxx b/sc/source/filter/inc/formel.hxx
index 2faca17..8a58151 100644
--- a/sc/source/filter/inc/formel.hxx
+++ b/sc/source/filter/inc/formel.hxx
@@ -58,7 +58,7 @@ enum FORMULA_TYPE
FT_CondFormat
};
-class _ScRangeListTabs
+class ScRangeListTabs
{
typedef ::std::vector<ScRange> RangeListType;
typedef ::std::map<SCTAB, std::unique_ptr<RangeListType>> TabRangeType;
@@ -67,8 +67,8 @@ class _ScRangeListTabs
RangeListType::const_iterator maItrCurEnd;
public:
- _ScRangeListTabs ();
- ~_ScRangeListTabs();
+ ScRangeListTabs ();
+ ~ScRangeListTabs();
void Append( const ScAddress& aSRD, SCTAB nTab );
void Append( const ScRange& aCRD, SCTAB nTab );
@@ -106,7 +106,7 @@ public:
virtual ConvErr Convert( const ScTokenArray*& rpErg, XclImpStream&
rStrm, sal_Size nFormulaLen,
bool bAllowArrays, const FORMULA_TYPE eFT =
FT_CellFormula ) = 0;
- virtual ConvErr Convert( _ScRangeListTabs&, XclImpStream& rStrm,
sal_Size nFormulaLen, SCsTAB nTab,
+ virtual ConvErr Convert( ScRangeListTabs&, XclImpStream& rStrm,
sal_Size nFormulaLen, SCsTAB nTab,
const FORMULA_TYPE eFT = FT_CellFormula )
= 0;
};
diff --git a/sc/source/filter/inc/lotimpop.hxx
b/sc/source/filter/inc/lotimpop.hxx
index 0cae6aa..4d9fe6f 100644
--- a/sc/source/filter/inc/lotimpop.hxx
+++ b/sc/source/filter/inc/lotimpop.hxx
@@ -60,7 +60,7 @@ private:
void Font_Face(); // 174
void Font_Type(); // 176
void Font_Ysize(); // 177
- void _Row( const sal_uInt16 nRecLen ); // 197 ?
+ void Row_( const sal_uInt16 nRecLen ); // 197 ?
inline void Read( ScAddress& );
inline void Read( ScRange& );
diff --git a/sc/source/filter/inc/root.hxx b/sc/source/filter/inc/root.hxx
index f92b2fd..c44088e 100644
--- a/sc/source/filter/inc/root.hxx
+++ b/sc/source/filter/inc/root.hxx
@@ -36,7 +36,7 @@ class ExcelToSc;
class XclImpColRowSettings;
class XclImpAutoFilterBuffer;
-class _ScRangeListTabs;
+class ScRangeListTabs;
class XclExpChTrTabId;
class XclExpUserBViewList;
@@ -57,8 +57,8 @@ struct RootData // -> Inkarnation jeweils im
ImportExcel-Objekt!
// Biff8
XclImpAutoFilterBuffer* pAutoFilterBuffer; // ranges for autofilter
and advanced filter
- _ScRangeListTabs* pPrintRanges;
- _ScRangeListTabs* pPrintTitles;
+ ScRangeListTabs* pPrintRanges;
+ ScRangeListTabs* pPrintTitles;
// Erweiterungen fuer Export
XclExpChTrTabId* pTabId; // pointer to rec list, do not
destroy
diff --git a/sc/source/filter/inc/xiroot.hxx b/sc/source/filter/inc/xiroot.hxx
index 099d885..ca469a4 100644
--- a/sc/source/filter/inc/xiroot.hxx
+++ b/sc/source/filter/inc/xiroot.hxx
@@ -56,7 +56,7 @@ class XclImpTabViewSettings;
class XclImpSheetProtectBuffer;
class XclImpDocProtectBuffer;
-class _ScRangeListTabs;
+class ScRangeListTabs;
class ExcelToSc;
class ScDocumentImport;
@@ -163,9 +163,9 @@ public:
XclImpXFRangeBuffer& GetXFRangeBuffer() const;
/** Returns the buffer that contains all print areas in the document. */
- _ScRangeListTabs& GetPrintAreaBuffer() const;
+ ScRangeListTabs& GetPrintAreaBuffer() const;
/** Returns the buffer that contains all print titles in the document. */
- _ScRangeListTabs& GetTitleAreaBuffer() const;
+ ScRangeListTabs& GetTitleAreaBuffer() const;
/** Returns the buffer that contains the sheet creation order. */
XclImpTabInfo& GetTabInfo() const;
diff --git a/sc/source/filter/lotus/lotimpop.cxx
b/sc/source/filter/lotus/lotimpop.cxx
index 586ca37..fa937c5 100644
--- a/sc/source/filter/lotus/lotimpop.cxx
+++ b/sc/source/filter/lotus/lotimpop.cxx
@@ -379,9 +379,9 @@ void ImportLotus::Font_Ysize()
}
}
-void ImportLotus::_Row( const sal_uInt16 nRecLen )
+void ImportLotus::Row_( const sal_uInt16 nRecLen )
{
- OSL_ENSURE( nExtTab >= 0, "*ImportLotus::_Row(): not possible!" );
+ OSL_ENSURE( nExtTab >= 0, "*ImportLotus::Row_(): not possible!" );
sal_uInt16 nCntDwn = (nRecLen < 4) ? 0 : ( nRecLen - 4 ) / 5;
SCCOL nColCnt = 0;
diff --git a/sc/source/filter/lotus/lotread.cxx
b/sc/source/filter/lotus/lotread.cxx
index 58c5e18..5e30fb5 100644
--- a/sc/source/filter/lotus/lotread.cxx
+++ b/sc/source/filter/lotus/lotread.cxx
@@ -289,7 +289,7 @@ FltError ImportLotus::Read(SvStream& rIn)
nExtTab++;
break;
case 197:
- _Row( nRecLen );
+ Row_( nRecLen );
break;
}
diff --git a/sc/source/ui/unoobj/shapeuno.cxx b/sc/source/ui/unoobj/shapeuno.cxx
index 3a363a5..d7d3928 100644
--- a/sc/source/ui/unoobj/shapeuno.cxx
+++ b/sc/source/ui/unoobj/shapeuno.cxx
@@ -1472,9 +1472,9 @@ OUString SAL_CALL ScShapeObj::getImplementationName( )
throw (uno::RuntimeExcep
return OUString( "com.sun.star.comp.sc.ScShapeObj" );
}
-sal_Bool SAL_CALL ScShapeObj::supportsService( const OUString& _ServiceName )
throw (uno::RuntimeException, std::exception)
+sal_Bool SAL_CALL ScShapeObj::supportsService( const OUString& ServiceName )
throw (uno::RuntimeException, std::exception)
{
- return cppu::supportsService(this, _ServiceName);
+ return cppu::supportsService(this, ServiceName);
}
uno::Sequence< OUString > SAL_CALL ScShapeObj::getSupportedServiceNames( )
throw (uno::RuntimeException, std::exception)
diff --git a/sc/source/ui/unoobj/viewuno.cxx b/sc/source/ui/unoobj/viewuno.cxx
index 3d0aaa4..3725b82 100644
--- a/sc/source/ui/unoobj/viewuno.cxx
+++ b/sc/source/ui/unoobj/viewuno.cxx
@@ -318,7 +318,7 @@ namespace
}
// XFormLayerAccess
-uno::Reference< form::runtime::XFormController > SAL_CALL
ScViewPaneBase::getFormController( const uno::Reference< form::XForm >& _Form )
throw (uno::RuntimeException, std::exception)
+uno::Reference< form::runtime::XFormController > SAL_CALL
ScViewPaneBase::getFormController( const uno::Reference< form::XForm >& Form )
throw (uno::RuntimeException, std::exception)
{
SolarMutexGuard aGuard;
@@ -328,7 +328,7 @@ uno::Reference< form::runtime::XFormController > SAL_CALL
ScViewPaneBase::getFor
SdrView* pSdrView( nullptr );
FmFormShell* pFormShell( nullptr );
if ( lcl_prepareFormShellCall( pViewShell, nPane, pFormShell, pWindow,
pSdrView ) )
- xController = FmFormShell::GetFormController( _Form, *pSdrView,
*pWindow );
+ xController = FmFormShell::GetFormController( Form, *pSdrView,
*pWindow );
return xController;
}
@@ -346,7 +346,7 @@ sal_Bool SAL_CALL ScViewPaneBase::isFormDesignMode( )
throw (uno::RuntimeExcept
return bIsFormDesignMode;
}
-void SAL_CALL ScViewPaneBase::setFormDesignMode( sal_Bool _DesignMode ) throw
(uno::RuntimeException, std::exception)
+void SAL_CALL ScViewPaneBase::setFormDesignMode( sal_Bool DesignMode ) throw
(uno::RuntimeException, std::exception)
{
SolarMutexGuard aGuard;
@@ -354,7 +354,7 @@ void SAL_CALL ScViewPaneBase::setFormDesignMode( sal_Bool
_DesignMode ) throw (u
SdrView* pSdrView( nullptr );
FmFormShell* pFormShell( nullptr );
if ( lcl_prepareFormShellCall( pViewShell, nPane, pFormShell, pWindow,
pSdrView ) )
- pFormShell->SetDesignMode( _DesignMode );
+ pFormShell->SetDesignMode( DesignMode );
}
// XControlAccess
diff --git a/sc/source/ui/vba/vbaformat.hxx b/sc/source/ui/vba/vbaformat.hxx
index c7b14aa..b02bd69 100644
--- a/sc/source/ui/vba/vbaformat.hxx
+++ b/sc/source/ui/vba/vbaformat.hxx
@@ -57,7 +57,7 @@ public:
ScVbaFormat( const css::uno::Reference< ov::XHelperInterface >& xParent,
const css::uno::Reference< css::uno::XComponentContext > & xContext, const
css::uno::Reference< css::beans::XPropertySet >& _xPropertySet, const
css::uno::Reference< css::frame::XModel >& xModel, bool bCheckAmbiguoity )
throw ( css::script::BasicErrorException );
virtual ~ScVbaFormat() {}
virtual css::uno::Reference< ov::XHelperInterface > thisHelperIface() = 0;
- void SAL_CALL setAddIndent( const css::uno::Any& _BAddIndent) throw(
css::uno::RuntimeException ) { _BAddIndent >>= mbAddIndent; }
+ void SAL_CALL setAddIndent( const css::uno::Any& BAddIndent) throw(
css::uno::RuntimeException ) { BAddIndent >>= mbAddIndent; }
css::uno::Any SAL_CALL getAddIndent() throw( css::uno::RuntimeException )
{ return css::uno::makeAny( mbAddIndent ); }
// Interface Methods
virtual css::uno::Any SAL_CALL Borders( const css::uno::Any& Index ) throw
(css::script::BasicErrorException, css::uno::RuntimeException);
diff --git a/sc/source/ui/view/output2.cxx b/sc/source/ui/view/output2.cxx
index 75d60d9..d110c1d 100644
--- a/sc/source/ui/view/output2.cxx
+++ b/sc/source/ui/view/output2.cxx
@@ -264,11 +264,11 @@ void ScDrawStringsVars::SetShrinkScale( long nScale,
SvtScriptType nScript )
namespace {
-template<typename _ItemType, typename _EnumType>
-_EnumType lcl_GetValue(const ScPatternAttr& rPattern, sal_uInt16 nWhich, const
SfxItemSet* pCondSet)
+template<typename ItemType, typename EnumType>
+EnumType lcl_GetValue(const ScPatternAttr& rPattern, sal_uInt16 nWhich, const
SfxItemSet* pCondSet)
{
- const _ItemType& rItem = static_cast<const
_ItemType&>(rPattern.GetItem(nWhich, pCondSet));
- return static_cast<_EnumType>(rItem.GetValue());
+ const ItemType& rItem = static_cast<const
ItemType&>(rPattern.GetItem(nWhich, pCondSet));
+ return static_cast<EnumType>(rItem.GetValue());
}
bool lcl_GetBoolValue(const ScPatternAttr& rPattern, sal_uInt16 nWhich, const
SfxItemSet* pCondSet)
_______________________________________________
Libreoffice-commits mailing list
libreoffice-comm...@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/libreoffice-commits
