[Libreoffice-commits] core.git: Branch 'feature/item_refactor2' - basctl/source include/item include/svx item/source item/test svx/source
Armin Le Grand (via logerrit)
logerrit at kemper.freedesktop.org
Thu Apr 11 15:00:38 UTC 2019
basctl/source/basicide/sbxitem.cxx | 27 +-
basctl/source/inc/sbxitem.hxx | 2
include/item/base/ItemBase.hxx | 14 -
include/item/base/ItemControlBlock.hxx | 16 -
include/item/base/ItemSet.hxx | 9
include/item/base/SlotSet.hxx | 2
include/item/simple/CntInt16.hxx | 6
include/item/simple/CntOUString.hxx | 5
include/svx/item/TransformAnchor.hxx | 5
item/source/base/ItemBase.cxx | 29 --
item/source/base/ItemControlBlock.cxx | 24 +-
item/source/simple/CntInt16.cxx | 19 -
item/source/simple/CntOUString.cxx | 19 -
item/test/ItemTest.cxx | 326 +++++++++++++++++++++++++--------
svx/source/items/TransformAnchor.cxx | 21 +-
15 files changed, 359 insertions(+), 165 deletions(-)
New commits:
commit 0c1b918b84c1b47a35dbb7a9a995728f3fcb1d7c
Author: Armin Le Grand <Armin.Le.Grand at me.com>
AuthorDate: Thu Apr 11 16:54:36 2019 +0200
Commit: Armin Le Grand <Armin.Le.Grand at me.com>
CommitDate: Thu Apr 11 16:54:36 2019 +0200
WIP: Further basic changes
Decided to have a reference to the ItemControlBlock
in each incarnation of Item to make accesses from the
incarnations more simple. This avoids the hierarchical
virtual GetItemControlBlock implementations which just
call the local static ones - easy to forget when
implementing items. Instead, hand over a reference
when constructing an Item - anyways inside the protected
constructors, not in ::Create methods.
Adapted ItemControlBlock accordingly to get now two
lambdas (construct and default-construct). The default
no longer gets pre-constructed, that may lead to endless
loops when inside the 1st constructor call the static
ItemControlBlock gets created
Change-Id: Id4629578ef46668652c949f3ec831ba4a784cb6e
diff --git a/basctl/source/basicide/sbxitem.cxx b/basctl/source/basicide/sbxitem.cxx
index 33b3adca54e7..1243535c22f4 100644
--- a/basctl/source/basicide/sbxitem.cxx
+++ b/basctl/source/basicide/sbxitem.cxx
@@ -30,19 +30,20 @@ namespace Item
{
static ::Item::ItemControlBlock aItemControlBlock(
std::shared_ptr<::Item::ItemAdministrator>(new ::Item::IAdministrator_vector()),
- std::shared_ptr<const ::Item::ItemBase>(new Sbx()),
- [](){ return new Sbx(); });
+ [](){ return new Sbx(Sbx::GetStaticItemControlBlock()); },
+ [](){ return new Sbx(Sbx::GetStaticItemControlBlock()); });
return aItemControlBlock;
}
- ::Item::ItemControlBlock& Sbx::GetItemControlBlock() const
- {
- return Sbx::GetStaticItemControlBlock();
- }
-
- Sbx::Sbx(const ScriptDocument* pDocument, const OUString& aLibName, const OUString& aName, const OUString& aMethodName, ItemType eType)
- : ::Item::ItemBase(),
+ Sbx::Sbx(
+ ::Item::ItemControlBlock& rItemControlBlock,
+ const ScriptDocument* pDocument,
+ const OUString& aLibName,
+ const OUString& aName,
+ const OUString& aMethodName,
+ ItemType eType)
+ : ::Item::ItemBase(rItemControlBlock),
m_aDocument(nullptr != pDocument ? *pDocument : ScriptDocument::getApplicationScriptDocument()),
m_aLibName(aLibName),
m_aName(aName),
@@ -65,7 +66,13 @@ namespace Item
{
return std::static_pointer_cast<const Sbx>(
Sbx::GetStaticItemControlBlock().GetItemAdministrator()->Create(
- new Sbx(&rDocument, aLibName, aName, aMethodName, eType)));
+ new Sbx(
+ Sbx::GetStaticItemControlBlock(),
+ &rDocument,
+ aLibName,
+ aName,
+ aMethodName,
+ eType)));
}
bool Sbx::operator==(const ItemBase& rCandidate) const
diff --git a/basctl/source/inc/sbxitem.hxx b/basctl/source/inc/sbxitem.hxx
index fe6cc705b83d..56b62d3e4ed4 100644
--- a/basctl/source/inc/sbxitem.hxx
+++ b/basctl/source/inc/sbxitem.hxx
@@ -47,7 +47,6 @@ namespace Item
{
public:
static ::Item::ItemControlBlock& GetStaticItemControlBlock();
- virtual ::Item::ItemControlBlock& GetItemControlBlock() const override;
private:
const ScriptDocument m_aDocument;
@@ -58,6 +57,7 @@ namespace Item
protected:
Sbx(
+ ::Item::ItemControlBlock& rItemControlBlock,
const ScriptDocument* pDocument = nullptr,
const OUString& aLibName = OUString(),
const OUString& aName = OUString(),
diff --git a/include/item/base/ItemBase.hxx b/include/item/base/ItemBase.hxx
index f356d5edadc1..f7fbd889a640 100644
--- a/include/item/base/ItemBase.hxx
+++ b/include/item/base/ItemBase.hxx
@@ -98,6 +98,12 @@ namespace Item
typedef std::vector<AnyIDPair> AnyIDArgs;
private:
+ // local reference to instance of ItemControlBlock for this
+ // incarnation - same as type::GetStaticItemControlBlock(), but
+ // this way accessible for all incarnations - at the cost of
+ // one local reference
+ ItemControlBlock& m_rItemControlBlock;
+
// flag to mark this instance being administared by an
// ItemAdministrator. Not urgently needed due to also being
// able to check being administrated in the HintExpired
@@ -106,23 +112,19 @@ namespace Item
// administrated it is not necessary to do that check
// if it is administrated which means a 'find' access
// to a kind of list which may have varying costs...
- bool m_bAdministrated;
+ bool m_bAdministrated;
// needed to allow access for ItemAdministrator to m_bAdministrated,
// but limited to a single local method in the implementation there
friend void SetAdministratedFromItemAdministrator(ItemBase& rIBase);
- public:
- static ItemControlBlock& GetStaticItemControlBlock();
- virtual ItemControlBlock& GetItemControlBlock() const;
-
protected:
// constructor - protected BY DEFAULT - do NOT CHANGE (!)
// Use ::Create(...) methods in derived classes instead
// Note: Every derivation *needs* an empty constructor to
// allow unified created static methods like CreateFromAny
// to create instances
- ItemBase();
+ ItemBase(ItemControlBlock& rItemControlBlock);
// PutValue/Any interface for automated instance creation from SfxType
// mechanism (UNO API and sfx2 stuff)
diff --git a/include/item/base/ItemControlBlock.hxx b/include/item/base/ItemControlBlock.hxx
index cfa2e62583fc..d61b8e79d07d 100755
--- a/include/item/base/ItemControlBlock.hxx
+++ b/include/item/base/ItemControlBlock.hxx
@@ -33,14 +33,15 @@ namespace Item
class ITEM_DLLPUBLIC ItemControlBlock
{
private:
- std::shared_ptr<ItemAdministrator> m_aItemAdministrator;
- const std::shared_ptr<const ItemBase> m_aDefaultItem;
- std::function<ItemBase*()> m_aConstructItem;
+ std::shared_ptr<ItemAdministrator> m_aItemAdministrator;
+ std::shared_ptr<const ItemBase> m_aDefaultItem;
+ std::function<ItemBase*()> m_aConstructDefaultItem;
+ std::function<ItemBase*()> m_aConstructItem;
public:
ItemControlBlock(
const std::shared_ptr<ItemAdministrator>& rItemAdministrator,
- const std::shared_ptr<const ItemBase>& rDefaultItem,
+ std::function<ItemBase*()>constructDefaultItem,
std::function<ItemBase*()>constructItem);
ItemControlBlock();
@@ -49,10 +50,7 @@ namespace Item
return m_aItemAdministrator;
}
- const std::shared_ptr<const ItemBase>& GetDefaultItem() const
- {
- return m_aDefaultItem;
- }
+ const std::shared_ptr<const ItemBase>& GetDefaultItem() const;
ItemBase* ConstructItem() const
{
@@ -60,7 +58,7 @@ namespace Item
}
std::shared_ptr<const ItemBase> CreateFromAny(const ItemBase::AnyIDArgs& rArgs);
- bool IsDefaultDDD(const ItemBase& rItem) const;
+ bool IsDefault(const ItemBase& rItem) const;
};
} // end of namespace Item
diff --git a/include/item/base/ItemSet.hxx b/include/item/base/ItemSet.hxx
index 3f1cab7ed137..142fe53d4467 100644
--- a/include/item/base/ItemSet.hxx
+++ b/include/item/base/ItemSet.hxx
@@ -21,6 +21,7 @@
#define INCLUDED_ITEM_BASE_ITEMSET_HXX
#include <item/base/ModelSpecificItemValues.hxx>
+#include <item/base/ItemControlBlock.hxx>
///////////////////////////////////////////////////////////////////////////////
//
@@ -215,16 +216,20 @@ namespace Item
// SfxItemState::DONTCARE -> IsInvalidItem -> pItem == INVALID_POOL_ITEM -> reinterpret_cast<SfxPoolItem*>(-1)
class ImplInvalidateItem : public ItemBase
{
+ private:
+ ItemControlBlock m_aItemControlBlock;
public:
- ImplInvalidateItem() = default;
+ ImplInvalidateItem() : ItemBase(m_aItemControlBlock), m_aItemControlBlock() {}
};
// helper class for a ImplDisableItem - placeholder for InvaidateState
// SfxItemState::DISABLED -> IsVoidItem() -> instance of SfxVoidItem, virtual bool IsVoidItem()
class ImplDisableItem : public ItemBase
{
+ private:
+ ItemControlBlock m_aItemControlBlock;
public:
- ImplDisableItem() = default;
+ ImplDisableItem() : ItemBase(m_aItemControlBlock), m_aItemControlBlock() {}
};
// the Parent of this ItemSet
diff --git a/include/item/base/SlotSet.hxx b/include/item/base/SlotSet.hxx
index 491354463fa7..74a144e677a8 100755
--- a/include/item/base/SlotSet.hxx
+++ b/include/item/base/SlotSet.hxx
@@ -22,7 +22,7 @@
#include <cassert>
#include <item/base/ModelSpecificItemValues.hxx>
-#include <item/base/ItemControlBlock.hxx>
+//#include <item/base/ItemControlBlock.hxx>
///////////////////////////////////////////////////////////////////////////////
diff --git a/include/item/simple/CntInt16.hxx b/include/item/simple/CntInt16.hxx
index 677221f359d0..fbaad683ef2a 100644
--- a/include/item/simple/CntInt16.hxx
+++ b/include/item/simple/CntInt16.hxx
@@ -20,12 +20,10 @@ namespace Item
// It uses IAdministrator_set to provide an Administrator using
// a sorted list for fast accesses. This requires ::operator< to be
// implemented.
-
class ITEM_DLLPUBLIC CntInt16 : public ItemBase
{
public:
static ItemControlBlock& GetStaticItemControlBlock();
- virtual ItemControlBlock& GetItemControlBlock() const override;
private:
// local variavbles
@@ -33,7 +31,9 @@ namespace Item
protected:
// SharedPtr-constructor - protected BY DEFAULT - do NOT CHANGE (!)
- CntInt16(sal_Int16 nValue = 0);
+ CntInt16(
+ ItemControlBlock& rItemControlBlock,
+ sal_Int16 nValue = 0);
public:
virtual ~CntInt16();
diff --git a/include/item/simple/CntOUString.hxx b/include/item/simple/CntOUString.hxx
index 1d5b085f7351..7424f31b6f2a 100644
--- a/include/item/simple/CntOUString.hxx
+++ b/include/item/simple/CntOUString.hxx
@@ -26,7 +26,6 @@ namespace Item
{
public:
static ItemControlBlock& GetStaticItemControlBlock();
- virtual ItemControlBlock& GetItemControlBlock() const override;
private:
// local variavbles
@@ -34,7 +33,9 @@ namespace Item
protected:
// SharedPtr-constructor - protected BY DEFAULT - do NOT CHANGE (!)
- CntOUString(const rtl::OUString& rValue = rtl::OUString());
+ CntOUString(
+ ItemControlBlock& rItemControlBlock,
+ const rtl::OUString& rValue = rtl::OUString());
public:
virtual ~CntOUString();
diff --git a/include/svx/item/TransformAnchor.hxx b/include/svx/item/TransformAnchor.hxx
index d78c5e2a93c5..4a9175244daf 100755
--- a/include/svx/item/TransformAnchor.hxx
+++ b/include/svx/item/TransformAnchor.hxx
@@ -21,10 +21,11 @@ namespace Item
{
public:
static ItemControlBlock& GetStaticItemControlBlock();
- virtual ItemControlBlock& GetItemControlBlock() const override;
protected:
- TransformAnchor(RndStdIds nValue = RndStdIds::UNKNOWN);
+ TransformAnchor(
+ ItemControlBlock& rItemControlBlock,
+ RndStdIds nValue = RndStdIds::UNKNOWN);
public:
static std::shared_ptr<const TransformAnchor> Create(RndStdIds nValue);
diff --git a/item/source/base/ItemBase.cxx b/item/source/base/ItemBase.cxx
index 08dcc25ab8eb..01f320174b56 100644
--- a/item/source/base/ItemBase.cxx
+++ b/item/source/base/ItemBase.cxx
@@ -209,24 +209,9 @@ class SW_DLLPUBLIC SwPaMItem : public SfxPoolItem
namespace Item
{
- ItemControlBlock& ItemBase::GetStaticItemControlBlock()
- {
- assert(false && "ItemBase::GetItemControlBlock call not allowed (!)");
- static ItemControlBlock aItemControlBlock(
- std::shared_ptr<ItemAdministrator>(),
- std::shared_ptr<const ItemBase>(),
- [](){ return nullptr; });
-
- return aItemControlBlock;
- }
-
- ItemControlBlock& ItemBase::GetItemControlBlock() const
- {
- return ItemBase::GetStaticItemControlBlock();
- }
-
- ItemBase::ItemBase()
+ ItemBase::ItemBase(ItemControlBlock& rItemControlBlock)
: std::enable_shared_from_this<ItemBase>(),
+ m_rItemControlBlock(rItemControlBlock),
m_bAdministrated(false)
{
}
@@ -249,7 +234,7 @@ namespace Item
{
if(IsAdministrated())
{
- GetItemControlBlock().GetItemAdministrator()->HintExpired(this);
+ m_rItemControlBlock.GetItemAdministrator()->HintExpired(this);
}
}
@@ -282,19 +267,19 @@ namespace Item
bool ItemBase::IsDefault() const
{
// callback to ItemControlBlock
- return GetItemControlBlock().IsDefaultDDD(*this);
+ return m_rItemControlBlock.IsDefault(*this);
}
const std::shared_ptr<const ItemBase>& ItemBase::GetDefault() const
{
// callback to ItemControlBlock
- assert(GetItemControlBlock().GetDefaultItem() && "empty DefaultItem detected - not allowed (!)");
- return GetItemControlBlock().GetDefaultItem();
+ assert(m_rItemControlBlock.GetDefaultItem() && "empty DefaultItem detected - not allowed (!)");
+ return m_rItemControlBlock.GetDefaultItem();
}
bool ItemBase::IsDefault(const std::shared_ptr<const ItemBase>& rCandidate)
{
- return rCandidate && rCandidate->GetItemControlBlock().IsDefaultDDD(*rCandidate);
+ return rCandidate && rCandidate->m_rItemControlBlock.IsDefault(*rCandidate);
}
} // end of namespace Item
diff --git a/item/source/base/ItemControlBlock.cxx b/item/source/base/ItemControlBlock.cxx
index c95517e7ef12..ffd32e7c4a86 100755
--- a/item/source/base/ItemControlBlock.cxx
+++ b/item/source/base/ItemControlBlock.cxx
@@ -16,23 +16,34 @@ namespace Item
{
ItemControlBlock::ItemControlBlock(
const std::shared_ptr<ItemAdministrator>& rItemAdministrator,
- const std::shared_ptr<const ItemBase>& rDefaultItem,
+ std::function<ItemBase*()>constructDefaultItem,
std::function<ItemBase*()>constructItem)
: m_aItemAdministrator(rItemAdministrator),
- m_aDefaultItem(rDefaultItem),
+ m_aDefaultItem(),
+ m_aConstructDefaultItem(constructDefaultItem),
m_aConstructItem(constructItem)
{
assert(rItemAdministrator && "nullptr not allowed, an ItemAdministrator *is* required (!)");
- assert(rDefaultItem && "nullptr not allowed, a default value *is* required (!)");
}
ItemControlBlock::ItemControlBlock()
: m_aItemAdministrator(),
m_aDefaultItem(),
+ m_aConstructDefaultItem(),
m_aConstructItem()
{
}
+ const std::shared_ptr<const ItemBase>& ItemControlBlock::GetDefaultItem() const
+ {
+ if(!m_aDefaultItem)
+ {
+ const_cast<ItemControlBlock*>(this)->m_aDefaultItem.reset(m_aConstructDefaultItem());
+ }
+
+ return m_aDefaultItem;
+ }
+
std::shared_ptr<const ItemBase> ItemControlBlock::CreateFromAny(const ItemBase::AnyIDArgs& rArgs)
{
ItemBase* pNewInstance(ConstructItem());
@@ -40,11 +51,10 @@ namespace Item
return std::shared_ptr<const ItemBase>(pNewInstance);
}
- bool ItemControlBlock::IsDefaultDDD(const ItemBase& rItem) const
+ bool ItemControlBlock::IsDefault(const ItemBase& rItem) const
{
- assert(nullptr != m_aDefaultItem.get() && "empty DefaultItem detected - not allowed (!)");
- assert(typeid(rItem) == typeid(*m_aDefaultItem) && "different types compared - not allowed (!)");
- return &rItem == m_aDefaultItem.get() || rItem.operator==(*m_aDefaultItem.get());
+ assert(typeid(rItem) == typeid(*GetDefaultItem()) && "different types compared - not allowed (!)");
+ return &rItem == GetDefaultItem().get() || rItem.operator==(*GetDefaultItem().get());
}
} // end of namespace Item
diff --git a/item/source/simple/CntInt16.cxx b/item/source/simple/CntInt16.cxx
index a9fd7a0169f1..9da54cdf2ae7 100644
--- a/item/source/simple/CntInt16.cxx
+++ b/item/source/simple/CntInt16.cxx
@@ -20,19 +20,16 @@ namespace Item
{
static ItemControlBlock aItemControlBlock(
std::shared_ptr<ItemAdministrator>(new IAdministrator_set()),
- std::shared_ptr<const ItemBase>(new CntInt16()),
- [](){ return new CntInt16(); });
+ [](){ return new CntInt16(CntInt16::GetStaticItemControlBlock()); },
+ [](){ return new CntInt16(CntInt16::GetStaticItemControlBlock()); });
return aItemControlBlock;
}
- ItemControlBlock& CntInt16::GetItemControlBlock() const
- {
- return CntInt16::GetStaticItemControlBlock();
- }
-
- CntInt16::CntInt16(sal_Int16 nValue)
- : ItemBase(),
+ CntInt16::CntInt16(
+ ItemControlBlock& rItemControlBlock,
+ sal_Int16 nValue)
+ : ItemBase(rItemControlBlock),
m_nValue(nValue)
{
}
@@ -53,7 +50,9 @@ namespace Item
// - detectiomn of new use - will create shared_ptr for local incarnation and buffer
return std::static_pointer_cast<const CntInt16>(
CntInt16::GetStaticItemControlBlock().GetItemAdministrator()->Create(
- new CntInt16(nValue)));
+ new CntInt16(
+ CntInt16::GetStaticItemControlBlock(),
+ nValue)));
}
bool CntInt16::operator==(const ItemBase& rCandidate) const
diff --git a/item/source/simple/CntOUString.cxx b/item/source/simple/CntOUString.cxx
index 9f9eeb75372f..47de99947372 100644
--- a/item/source/simple/CntOUString.cxx
+++ b/item/source/simple/CntOUString.cxx
@@ -20,19 +20,16 @@ namespace Item
{
static ItemControlBlock aItemControlBlock(
std::shared_ptr<ItemAdministrator>(new IAdministrator_unordered_set()),
- std::shared_ptr<const ItemBase>(new CntOUString()),
- [](){ return new CntOUString(); });
+ [](){ return new CntOUString(CntOUString::GetStaticItemControlBlock()); },
+ [](){ return new CntOUString(CntOUString::GetStaticItemControlBlock()); });
return aItemControlBlock;
}
- ItemControlBlock& CntOUString::GetItemControlBlock() const
- {
- return CntOUString::GetStaticItemControlBlock();
- }
-
- CntOUString::CntOUString(const rtl::OUString& rValue)
- : ItemBase(),
+ CntOUString::CntOUString(
+ ItemControlBlock& rItemControlBlock,
+ const rtl::OUString& rValue)
+ : ItemBase(rItemControlBlock),
m_aValue(rValue)
{
}
@@ -53,7 +50,9 @@ namespace Item
// - detectiomn of new use - will create shared_ptr for local incarnation and buffer
return std::static_pointer_cast<const CntOUString>(
CntOUString::GetStaticItemControlBlock().GetItemAdministrator()->Create(
- new CntOUString(rValue)));
+ new CntOUString(
+ CntOUString::GetStaticItemControlBlock(),
+ rValue)));
}
bool CntOUString::operator==(const ItemBase& rCandidate) const
diff --git a/item/test/ItemTest.cxx b/item/test/ItemTest.cxx
index 8c7b839b11c4..b5c78cb57de4 100644
--- a/item/test/ItemTest.cxx
+++ b/item/test/ItemTest.cxx
@@ -33,24 +33,21 @@ namespace Item
{
static ItemControlBlock aItemControlBlock(
std::shared_ptr<ItemAdministrator>(new IAdministrator_vector()),
- std::shared_ptr<const ItemBase>(new MultiValueAB()),
- [](){ return new MultiValueAB(); });
+ [](){ return new MultiValueAB(MultiValueAB::GetStaticItemControlBlock()); },
+ [](){ return new MultiValueAB(MultiValueAB::GetStaticItemControlBlock()); });
return aItemControlBlock;
}
- virtual ItemControlBlock& MultiValueAB::GetItemControlBlock() const override
- {
- return MultiValueAB::GetStaticItemControlBlock();
- }
-
- private:
sal_Int16 m_nValueA;
sal_Int32 m_nValueB;
protected:
- MultiValueAB(sal_Int16 nValueA = 0, sal_Int16 nValueB = 0)
- : ItemBase(),
+ MultiValueAB(
+ ItemControlBlock& rItemControlBlock,
+ sal_Int16 nValueA = 0,
+ sal_Int16 nValueB = 0)
+ : ItemBase(rItemControlBlock),
m_nValueA(nValueA),
m_nValueB(nValueB)
{
@@ -73,7 +70,10 @@ namespace Item
// - detectiomn of new use - will create shared_ptr for local incarnation and buffer
return std::static_pointer_cast<const MultiValueAB>(
MultiValueAB::GetStaticItemControlBlock().GetItemAdministrator()->Create(
- new MultiValueAB(nValueA, nValueB)));
+ new MultiValueAB(
+ MultiValueAB::GetStaticItemControlBlock(),
+ nValueA,
+ nValueB)));
}
virtual bool operator==(const ItemBase& rCandidate) const override
@@ -120,23 +120,24 @@ namespace Item
{
static ItemControlBlock aItemControlBlock(
std::shared_ptr<ItemAdministrator>(new IAdministrator_vector()),
- std::shared_ptr<const ItemBase>(new MultiValueABC()),
- [](){ return new MultiValueABC(); });
+ [](){ return new MultiValueABC(MultiValueABC::GetStaticItemControlBlock()); },
+ [](){ return new MultiValueABC(MultiValueABC::GetStaticItemControlBlock()); });
return aItemControlBlock;
}
- virtual ItemControlBlock& MultiValueABC::GetItemControlBlock() const override
- {
- return MultiValueABC::GetStaticItemControlBlock();
- }
-
- private:
sal_Int64 m_nValueC;
protected:
- MultiValueABC(sal_Int16 nValueA = 0, sal_Int16 nValueB = 0, sal_Int16 nValueC = 0)
- : MultiValueAB(nValueA, nValueB),
+ MultiValueABC(
+ ItemControlBlock& rItemControlBlock,
+ sal_Int16 nValueA = 0,
+ sal_Int16 nValueB = 0,
+ sal_Int16 nValueC = 0)
+ : MultiValueAB(
+ rItemControlBlock,
+ nValueA,
+ nValueB),
m_nValueC(nValueC)
{
}
@@ -158,7 +159,11 @@ namespace Item
// - detectiomn of new use - will create shared_ptr for local incarnation and buffer
return std::static_pointer_cast<const MultiValueABC>(
MultiValueABC::GetStaticItemControlBlock().GetItemAdministrator()->Create(
- new MultiValueABC(nValueA, nValueB, nValueC)));
+ new MultiValueABC(
+ MultiValueABC::GetStaticItemControlBlock(),
+ nValueA,
+ nValueB,
+ nValueC)));
}
virtual bool operator==(const ItemBase& rCandidate) const override
@@ -186,41 +191,87 @@ namespace Item
namespace Item
{
- // example for Item deived from existing ojne, only new type
- class MultiValueAB_Alternative : public MultiValueAB
+ // example for Item deived from existing one, only new type
+ class MultiValueABD : public MultiValueAB
{
public:
- static ItemControlBlock& GetStaticItemControlBlock()
+ static ItemControlBlock& MultiValueABD::GetStaticItemControlBlock()
{
static ItemControlBlock aItemControlBlock(
- MultiValueAB::GetStaticItemControlBlock().GetItemAdministrator(),
- std::shared_ptr<const ItemBase>(new MultiValueAB_Alternative()),
- [](){ return new MultiValueAB_Alternative(); });
+ std::shared_ptr<ItemAdministrator>(new IAdministrator_vector()),
+ [](){ return new MultiValueABD(MultiValueABD::GetStaticItemControlBlock()); },
+ [](){ return new MultiValueABD(MultiValueABD::GetStaticItemControlBlock()); });
return aItemControlBlock;
}
- virtual ItemControlBlock& GetItemControlBlock() const override
+ protected:
+ MultiValueABD(
+ ItemControlBlock& rItemControlBlock,
+ sal_Int16 nValueA = 0,
+ sal_Int16 nValueB = 0)
+ : MultiValueAB(
+ rItemControlBlock,
+ nValueA,
+ nValueB)
+ {
+ }
+
+ public:
+ static std::shared_ptr<const MultiValueABD> Create(sal_Int16 nValueA, sal_Int16 nValueB)
+ {
+ return std::static_pointer_cast<const MultiValueABD>(
+ MultiValueABD::GetStaticItemControlBlock().GetItemAdministrator()->Create(
+ new MultiValueABD(
+ MultiValueABD::GetStaticItemControlBlock(),
+ nValueA,
+ nValueB)));
+ }
+ };
+} // end of namespace Item
+
+///////////////////////////////////////////////////////////////////////////////
+
+namespace Item
+{
+ // example for Item deived from existing combined one, only new type
+ class MultiValueABCD : public MultiValueABC
+ {
+ public:
+ static ItemControlBlock& MultiValueABCD::GetStaticItemControlBlock()
{
- return MultiValueAB_Alternative::GetStaticItemControlBlock();
+ static ItemControlBlock aItemControlBlock(
+ std::shared_ptr<ItemAdministrator>(new IAdministrator_vector()),
+ [](){ return new MultiValueABCD(MultiValueABCD::GetStaticItemControlBlock()); },
+ [](){ return new MultiValueABCD(MultiValueABCD::GetStaticItemControlBlock()); });
+
+ return aItemControlBlock;
}
protected:
- MultiValueAB_Alternative(sal_Int16 nValueA = 0, sal_Int16 nValueB = 0)
- : MultiValueAB(nValueA, nValueB)
+ MultiValueABCD(
+ ItemControlBlock& rItemControlBlock,
+ sal_Int16 nValueA = 0,
+ sal_Int16 nValueB = 0,
+ sal_Int16 nValueC = 0)
+ : MultiValueABC(
+ rItemControlBlock,
+ nValueA,
+ nValueB,
+ nValueC)
{
}
public:
- static std::shared_ptr<const MultiValueAB_Alternative> Create(sal_Int16 nValueA, sal_Int16 nValueB)
+ static std::shared_ptr<const MultiValueABCD> Create(sal_Int16 nValueA, sal_Int16 nValueB, sal_Int16 nValueC)
{
- // use ::Create(...) method with local incarnation, it will handle
- // - detection of being default (will delete local incarnation)
- // - detection of reuse (will delete local incarnation)
- // - detectiomn of new use - will create shared_ptr for local incarnation and buffer
- return std::static_pointer_cast<const MultiValueAB_Alternative>(
- MultiValueAB_Alternative::GetStaticItemControlBlock().GetItemAdministrator()->Create(
- new MultiValueAB_Alternative(nValueA, nValueB)));
+ return std::static_pointer_cast<const MultiValueABCD>(
+ MultiValueABCD::GetStaticItemControlBlock().GetItemAdministrator()->Create(
+ new MultiValueABCD(
+ MultiValueABCD::GetStaticItemControlBlock(),
+ nValueA,
+ nValueB,
+ nValueC)));
}
};
} // end of namespace Item
@@ -233,7 +284,7 @@ namespace Item
{
private:
public:
- void checkMultiValue()
+ void checkMultiValueAB()
{
// make direct use of local MultiValueAB item
@@ -303,7 +354,7 @@ namespace Item
test.clear();
}
- void checkMultiValueDerived()
+ void checkMultiValueABC()
{
// make direct use of local MultiValueABC item
int nIncrement(0);
@@ -358,43 +409,95 @@ namespace Item
testx.clear();
}
- void checkMultiValueAlternative()
+ void checkMultiValueABD()
+ {
+ int nIncrement(0);
+ const sal_uInt32 nLoopNumber(50);
+ std::shared_ptr<const MultiValueABD> mhas3_A(MultiValueABD::Create(5,2));
+
+ if(ItemBase::IsDefault(MultiValueABD::Create(3,0)))
+ {
+ nIncrement++;
+ }
+
+ if(ItemBase::IsDefault(MultiValueABD::Create(8,7)))
+ {
+ nIncrement++;
+ }
+
+ if(ItemBase::IsDefault(ItemBase::GetDefault<MultiValueABD>()))
+ {
+ nIncrement++;
+ }
+
+ std::vector<std::shared_ptr<const MultiValueABD>> testAB_A;
+
+ for(sal_uInt32 aloop(0); aloop < nLoopNumber; aloop++)
+ {
+ testAB_A.push_back(MultiValueABD::Create(aloop+1, (aloop+1)*2));
+ }
+
+ std::shared_ptr<const MultiValueABD> testA_A(MultiValueABD::Create(2,4));
+ std::shared_ptr<const MultiValueABD> testB_A(MultiValueABD::Create(2,3));
+
+ for(sal_uInt32 dloop(0); dloop < nLoopNumber; dloop+=2)
+ {
+ testAB_A[dloop] = nullptr;
+ if(dloop%5)
+ {
+ testAB_A.push_back(MultiValueABD::Create(dloop+1, (dloop+1)*2));
+ }
+ }
+
+ for(sal_uInt32 eloop(1); eloop < (nLoopNumber * 2) / 3; eloop+=2)
+ {
+ testAB_A[eloop] = nullptr;
+ if(eloop%7)
+ {
+ testAB_A.push_back(MultiValueABD::Create(eloop+1, (eloop+1)*2));
+ }
+ }
+
+ testAB_A.clear();
+ }
+
+ void checkMultiValueABCD()
{
int nIncrement(0);
const sal_uInt32 nLoopNumber(50);
- std::shared_ptr<const MultiValueAB_Alternative> mhas3_A(MultiValueAB_Alternative::Create(5,2));
+ std::shared_ptr<const MultiValueABCD> mhas3_A(MultiValueABCD::Create(5,2, 3));
- if(ItemBase::IsDefault(MultiValueAB_Alternative::Create(3,0)))
+ if(ItemBase::IsDefault(MultiValueABCD::Create(3,0, 4)))
{
nIncrement++;
}
- if(ItemBase::IsDefault(MultiValueAB_Alternative::Create(8,7)))
+ if(ItemBase::IsDefault(MultiValueABCD::Create(8,7,2)))
{
nIncrement++;
}
- if(ItemBase::IsDefault(ItemBase::GetDefault<MultiValueAB_Alternative>()))
+ if(ItemBase::IsDefault(ItemBase::GetDefault<MultiValueABCD>()))
{
nIncrement++;
}
- std::vector<std::shared_ptr<const MultiValueAB_Alternative>> testAB_A;
+ std::vector<std::shared_ptr<const MultiValueABCD>> testAB_A;
for(sal_uInt32 aloop(0); aloop < nLoopNumber; aloop++)
{
- testAB_A.push_back(MultiValueAB_Alternative::Create(aloop+1, (aloop+1)*2));
+ testAB_A.push_back(MultiValueABCD::Create(aloop+1, (aloop+1)*2, (aloop+1)*5));
}
- std::shared_ptr<const MultiValueAB_Alternative> testA_A(MultiValueAB_Alternative::Create(2,4));
- std::shared_ptr<const MultiValueAB_Alternative> testB_A(MultiValueAB_Alternative::Create(2,3));
+ std::shared_ptr<const MultiValueABCD> testA_A(MultiValueABCD::Create(2,4,7));
+ std::shared_ptr<const MultiValueABCD> testB_A(MultiValueABCD::Create(2,3,3));
for(sal_uInt32 dloop(0); dloop < nLoopNumber; dloop+=2)
{
testAB_A[dloop] = nullptr;
if(dloop%5)
{
- testAB_A.push_back(MultiValueAB_Alternative::Create(dloop+1, (dloop+1)*2));
+ testAB_A.push_back(MultiValueABCD::Create(dloop+1, (dloop+1)*2, (dloop+1)*6));
}
}
@@ -403,41 +506,123 @@ namespace Item
testAB_A[eloop] = nullptr;
if(eloop%7)
{
- testAB_A.push_back(MultiValueAB_Alternative::Create(eloop+1, (eloop+1)*2));
+ testAB_A.push_back(MultiValueABCD::Create(eloop+1, (eloop+1)*2, (eloop+1)*3));
}
}
testAB_A.clear();
}
- void checkMultiValueAtISet()
+ void checkMultiValuesAtISet()
{
int nIncrement(0);
// make use of local MultiValueAB item in conjuction with ItemSet
ModelSpecificItemValues::SharedPtr aModelSpecificIValues(ModelSpecificItemValues::Create());
ItemSet::SharedPtr aSet(ItemSet::Create(aModelSpecificIValues));
- aSet->SetItem(MultiValueAB::Create(5,4));
- if(const auto Item(aSet->GetStateAndItem<const MultiValueAB>()); Item.IsSet())
+ ///////////////////////////////////////////////////////////////////////////////
+
+ std::shared_ptr<const MultiValueAB> testAB(MultiValueAB::Create(2,4));
+ std::shared_ptr<const MultiValueABC> testABC(MultiValueABC::Create(2,4,6));
+ std::shared_ptr<const MultiValueABD> testABD(MultiValueABD::Create(2,4));
+ std::shared_ptr<const MultiValueABCD> testABCD(MultiValueABCD::Create(2,4,6));
+
+ aSet->SetItem(testAB);
+ aSet->SetItem(testABC);
+ aSet->SetItem(testABD);
+ aSet->SetItem(testABCD);
+
+ ///////////////////////////////////////////////////////////////////////////////
+
+ if(const auto ItemAB(aSet->GetStateAndItem<const MultiValueAB>()); ItemAB.IsSet())
{
- nIncrement += (ItemSet::IState::SET == Item.GetIState()) ? 1 : 0;
- nIncrement += (Item.GetItem()) ? 1 : 0;
- nIncrement += (nullptr != Item.GetItemInstance()) ? 1 : 0;
- nIncrement += Item.HasItem();
- nIncrement += Item.IsDisabled();
+ nIncrement += (ItemSet::IState::SET == ItemAB.GetIState()) ? 1 : 0;
+ nIncrement += (ItemAB.GetItem()) ? 1 : 0;
+ nIncrement += (nullptr != ItemAB.GetItemInstance()) ? 1 : 0;
+ nIncrement += ItemAB.HasItem();
+ nIncrement += ItemAB.IsDisabled();
}
- else if(Item.IsDefault())
+ else if(ItemAB.IsDefault())
{
- nIncrement += Item.IsDisabled();
+ nIncrement += ItemAB.IsDisabled();
}
- else if(Item.IsDontCare())
+ else if(ItemAB.IsDontCare())
{
- nIncrement += Item.IsDisabled();
+ nIncrement += ItemAB.IsDisabled();
}
else
{
- nIncrement += Item.IsDisabled();
+ nIncrement += ItemAB.IsDisabled();
+ }
+
+ ///////////////////////////////////////////////////////////////////////////////
+
+ if(const auto ItemABC(aSet->GetStateAndItem<const MultiValueABC>()); ItemABC.IsSet())
+ {
+ nIncrement += (ItemSet::IState::SET == ItemABC.GetIState()) ? 1 : 0;
+ nIncrement += (ItemABC.GetItem()) ? 1 : 0;
+ nIncrement += (nullptr != ItemABC.GetItemInstance()) ? 1 : 0;
+ nIncrement += ItemABC.HasItem();
+ nIncrement += ItemABC.IsDisabled();
+ }
+ else if(ItemABC.IsDefault())
+ {
+ nIncrement += ItemABC.IsDisabled();
+ }
+ else if(ItemABC.IsDontCare())
+ {
+ nIncrement += ItemABC.IsDisabled();
+ }
+ else
+ {
+ nIncrement += ItemABC.IsDisabled();
+ }
+
+ ///////////////////////////////////////////////////////////////////////////////
+
+ if(const auto ItemABD(aSet->GetStateAndItem<const MultiValueABD>()); ItemABD.IsSet())
+ {
+ nIncrement += (ItemSet::IState::SET == ItemABD.GetIState()) ? 1 : 0;
+ nIncrement += (ItemABD.GetItem()) ? 1 : 0;
+ nIncrement += (nullptr != ItemABD.GetItemInstance()) ? 1 : 0;
+ nIncrement += ItemABD.HasItem();
+ nIncrement += ItemABD.IsDisabled();
+ }
+ else if(ItemABD.IsDefault())
+ {
+ nIncrement += ItemABD.IsDisabled();
+ }
+ else if(ItemABD.IsDontCare())
+ {
+ nIncrement += ItemABD.IsDisabled();
+ }
+ else
+ {
+ nIncrement += ItemABD.IsDisabled();
+ }
+
+ ///////////////////////////////////////////////////////////////////////////////
+
+ if(const auto ItemABCD(aSet->GetStateAndItem<const MultiValueABCD>()); ItemABCD.IsSet())
+ {
+ nIncrement += (ItemSet::IState::SET == ItemABCD.GetIState()) ? 1 : 0;
+ nIncrement += (ItemABCD.GetItem()) ? 1 : 0;
+ nIncrement += (nullptr != ItemABCD.GetItemInstance()) ? 1 : 0;
+ nIncrement += ItemABCD.HasItem();
+ nIncrement += ItemABCD.IsDisabled();
+ }
+ else if(ItemABCD.IsDefault())
+ {
+ nIncrement += ItemABCD.IsDisabled();
+ }
+ else if(ItemABCD.IsDontCare())
+ {
+ nIncrement += ItemABCD.IsDisabled();
+ }
+ else
+ {
+ nIncrement += ItemABCD.IsDisabled();
}
// CPPUNIT_ASSERT_EQUAL_MESSAGE("simple range rounding from double to integer",
@@ -603,10 +788,11 @@ namespace Item
// because these macros are need by auto register mechanism.
CPPUNIT_TEST_SUITE(ibase);
- CPPUNIT_TEST(checkMultiValue);
- CPPUNIT_TEST(checkMultiValueDerived);
- CPPUNIT_TEST(checkMultiValueAlternative);
- CPPUNIT_TEST(checkMultiValueAtISet);
+ CPPUNIT_TEST(checkMultiValueAB);
+ CPPUNIT_TEST(checkMultiValueABC);
+ CPPUNIT_TEST(checkMultiValueABD);
+ CPPUNIT_TEST(checkMultiValueABCD);
+ CPPUNIT_TEST(checkMultiValuesAtISet);
CPPUNIT_TEST(checkSimpleItems);
CPPUNIT_TEST(checkSimpleItemsAtISet);
CPPUNIT_TEST_SUITE_END();
diff --git a/svx/source/items/TransformAnchor.cxx b/svx/source/items/TransformAnchor.cxx
index d10d7d24bcaa..dfef45fb7981 100755
--- a/svx/source/items/TransformAnchor.cxx
+++ b/svx/source/items/TransformAnchor.cxx
@@ -19,19 +19,18 @@ namespace Item
{
static ItemControlBlock aItemControlBlock(
CntInt16::GetStaticItemControlBlock().GetItemAdministrator(),
- std::shared_ptr<const ItemBase>(new TransformAnchor()),
- [](){ return new TransformAnchor(); });
+ [](){ return new TransformAnchor(TransformAnchor::GetStaticItemControlBlock()); },
+ [](){ return new TransformAnchor(TransformAnchor::GetStaticItemControlBlock()); });
return aItemControlBlock;
}
- ItemControlBlock& TransformAnchor::GetItemControlBlock() const
- {
- return TransformAnchor::GetStaticItemControlBlock();
- }
-
- TransformAnchor::TransformAnchor(RndStdIds nValue)
- : CntInt16(static_cast<sal_Int16>(nValue))
+ TransformAnchor::TransformAnchor(
+ ItemControlBlock& rItemControlBlock,
+ RndStdIds nValue)
+ : CntInt16(
+ rItemControlBlock,
+ static_cast<sal_Int16>(nValue))
{
}
@@ -43,7 +42,9 @@ namespace Item
// - detectiomn of new use - will create shared_ptr for local incarnation and buffer
return std::static_pointer_cast<const TransformAnchor>(
TransformAnchor::GetStaticItemControlBlock().GetItemAdministrator()->Create(
- new TransformAnchor(nValue)));
+ new TransformAnchor(
+ TransformAnchor::GetStaticItemControlBlock(),
+ nValue)));
}
} // end of namespace Item
More information about the Libreoffice-commits
mailing list