sid/NazaraEngine
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Switch from Nz prefix to namespace Nz

Browse Source 
What a huge commit


Former-commit-id: 38ac5eebf70adc1180f571f6006192d28fb99897
This commit is contained in:
Lynix
2015-09-25 19:20:05 +02:00
parent c214251ecf
commit df8da275c4
609 changed files with 68265 additions and 66534 deletions
Download Patch File Download Diff File Expand all files Collapse all files

435
include/Nazara/Core/Signal.inl
View File

@@ -6,245 +6,248 @@
#include <utility>
#include <Nazara/Core/Debug.hpp>
template<typename... Args>
NzSignal<Args...>::NzSignal() :
m_slotIterator(0)
namespace Nz
{
}
template<typename... Args>
NzSignal<Args...>::NzSignal(NzSignal&& signal)
{
operator=(std::move(signal));
}
template<typename... Args>
void NzSignal<Args...>::Clear()
{
m_slots.clear();
m_slotIterator = 0;
}
template<typename... Args>
typename NzSignal<Args...>::Connection NzSignal<Args...>::Connect(const Callback& func)
{
return Connect(Callback(func));
}
template<typename... Args>
typename NzSignal<Args...>::Connection NzSignal<Args...>::Connect(Callback&& func)
{
NazaraAssert(func, "Invalid function");
// Since we're incrementing the slot vector size, we need to replace our iterator at the end
// (Except when we are iterating on the signal)
bool resetIt = (m_slotIterator >= m_slots.size());
auto tempPtr = std::make_shared<Slot>(this);
tempPtr->callback = std::move(func);
tempPtr->index = m_slots.size();
m_slots.emplace_back(std::move(tempPtr));
if (resetIt)
m_slotIterator = m_slots.size(); //< Replace the iterator to the end
return Connection(m_slots.back());
}
template<typename... Args>
template<typename O>
typename NzSignal<Args...>::Connection NzSignal<Args...>::Connect(O& object, void (O::*method) (Args...))
{
return Connect([&object, method] (Args&&... args)
template<typename... Args>
Signal<Args...>::Signal() :
m_slotIterator(0)
{
return (object .* method) (std::forward<Args>(args)...);
});
}
template<typename... Args>
template<typename O>
typename NzSignal<Args...>::Connection NzSignal<Args...>::Connect(O* object, void (O::*method)(Args...))
{
return Connect([object, method] (Args&&... args)
{
return (object ->* method) (std::forward<Args>(args)...);
});
}
template<typename... Args>
template<typename O>
typename NzSignal<Args...>::Connection NzSignal<Args...>::Connect(const O& object, void (O::*method) (Args...) const)
{
return Connect([&object, method] (Args&&... args)
{
return (object .* method) (std::forward<Args>(args)...);
});
}
template<typename... Args>
template<typename O>
typename NzSignal<Args...>::Connection NzSignal<Args...>::Connect(const O* object, void (O::*method)(Args...) const)
{
return Connect([object, method] (Args&&... args)
{
return (object ->* method) (std::forward<Args>(args)...);
});
}
template<typename... Args>
void NzSignal<Args...>::operator()(Args... args) const
{
for (m_slotIterator = 0; m_slotIterator < m_slots.size(); ++m_slotIterator)
m_slots[m_slotIterator]->callback(args...);
}
template<typename... Args>
NzSignal<Args...>& NzSignal<Args...>::operator=(NzSignal&& signal)
{
m_slots = std::move(signal.m_slots);
m_slotIterator = signal.m_slotIterator;
// We need to update the signal pointer inside of each slot
for (SlotPtr& slot : m_slots)
slot->signal = this;
return *this;
}
template<typename... Args>
void NzSignal<Args...>::Disconnect(const SlotPtr& slot)
{
NazaraAssert(slot, "Invalid slot pointer");
NazaraAssert(slot->index < m_slots.size(), "Invalid slot index");
// "Swap this slot with the last one and pop" idiom
// This will preserve slot indexes
// Can we safely "remove" this slot?
if (m_slotIterator >= m_slots.size()-1 || slot->index > m_slotIterator)
{
// Yes we can
SlotPtr& newSlot = m_slots[slot->index];
newSlot = std::move(m_slots.back());
newSlot->index = slot->index; //< Update the moved slot index before resizing (in case it's the last one)
}
else
{
// Nope, let's be tricky
SlotPtr& current = m_slots[m_slotIterator];
SlotPtr& newSlot = m_slots[slot->index];
newSlot = std::move(current);
newSlot->index = slot->index; //< Update the moved slot index
current = std::move(m_slots.back());
current->index = m_slotIterator; //< Update the moved slot index
--m_slotIterator;
}
// Pop the last entry (from where we moved our slot)
m_slots.pop_back();
}
template<typename... Args>
Signal<Args...>::Signal(Signal&& signal)
{
operator=(std::move(signal));
}
template<typename... Args>
void Signal<Args...>::Clear()
{
m_slots.clear();
m_slotIterator = 0;
}
template<typename... Args>
typename Signal<Args...>::Connection Signal<Args...>::Connect(const Callback& func)
{
return Connect(Callback(func));
}
template<typename... Args>
typename Signal<Args...>::Connection Signal<Args...>::Connect(Callback&& func)
{
NazaraAssert(func, "Invalid function");
// Since we're incrementing the slot vector size, we need to replace our iterator at the end
// (Except when we are iterating on the signal)
bool resetIt = (m_slotIterator >= m_slots.size());
auto tempPtr = std::make_shared<Slot>(this);
tempPtr->callback = std::move(func);
tempPtr->index = m_slots.size();
m_slots.emplace_back(std::move(tempPtr));
if (resetIt)
m_slotIterator = m_slots.size(); //< Replace the iterator to the end
return Connection(m_slots.back());
}
template<typename... Args>
template<typename O>
typename Signal<Args...>::Connection Signal<Args...>::Connect(O& object, void (O::*method) (Args...))
{
return Connect([&object, method] (Args&&... args)
{
return (object .* method) (std::forward<Args>(args)...);
});
}
template<typename... Args>
template<typename O>
typename Signal<Args...>::Connection Signal<Args...>::Connect(O* object, void (O::*method)(Args...))
{
return Connect([object, method] (Args&&... args)
{
return (object ->* method) (std::forward<Args>(args)...);
});
}
template<typename... Args>
template<typename O>
typename Signal<Args...>::Connection Signal<Args...>::Connect(const O& object, void (O::*method) (Args...) const)
{
return Connect([&object, method] (Args&&... args)
{
return (object .* method) (std::forward<Args>(args)...);
});
}
template<typename... Args>
template<typename O>
typename Signal<Args...>::Connection Signal<Args...>::Connect(const O* object, void (O::*method)(Args...) const)
{
return Connect([object, method] (Args&&... args)
{
return (object ->* method) (std::forward<Args>(args)...);
});
}
template<typename... Args>
void Signal<Args...>::operator()(Args... args) const
{
for (m_slotIterator = 0; m_slotIterator < m_slots.size(); ++m_slotIterator)
m_slots[m_slotIterator]->callback(args...);
}
template<typename... Args>
Signal<Args...>& Signal<Args...>::operator=(Signal&& signal)
{
m_slots = std::move(signal.m_slots);
m_slotIterator = signal.m_slotIterator;
// We need to update the signal pointer inside of each slot
for (SlotPtr& slot : m_slots)
slot->signal = this;
return *this;
}
template<typename... Args>
void Signal<Args...>::Disconnect(const SlotPtr& slot)
{
NazaraAssert(slot, "Invalid slot pointer");
NazaraAssert(slot->index < m_slots.size(), "Invalid slot index");
// "Swap this slot with the last one and pop" idiom
// This will preserve slot indexes
// Can we safely "remove" this slot?
if (m_slotIterator >= m_slots.size()-1 || slot->index > m_slotIterator)
{
// Yes we can
SlotPtr& newSlot = m_slots[slot->index];
newSlot = std::move(m_slots.back());
newSlot->index = slot->index; //< Update the moved slot index before resizing (in case it's the last one)
}
else
{
// Nope, let's be tricky
SlotPtr& current = m_slots[m_slotIterator];
SlotPtr& newSlot = m_slots[slot->index];
newSlot = std::move(current);
newSlot->index = slot->index; //< Update the moved slot index
current = std::move(m_slots.back());
current->index = m_slotIterator; //< Update the moved slot index
--m_slotIterator;
}
// Pop the last entry (from where we moved our slot)
m_slots.pop_back();
}
template<typename... Args>
NzSignal<Args...>::Connection::Connection(const SlotPtr& slot) :
m_ptr(slot)
{
}
template<typename... Args>
Signal<Args...>::Connection::Connection(const SlotPtr& slot) :
m_ptr(slot)
{
}
template<typename... Args>
template<typename... ConnectArgs>
void NzSignal<Args...>::Connection::Connect(BaseClass& signal, ConnectArgs&&... args)
{
operator=(signal.Connect(std::forward<ConnectArgs>(args)...));
}
template<typename... Args>
template<typename... ConnectArgs>
void Signal<Args...>::Connection::Connect(BaseClass& signal, ConnectArgs&&... args)
{
operator=(signal.Connect(std::forward<ConnectArgs>(args)...));
}
template<typename... Args>
void NzSignal<Args...>::Connection::Disconnect()
{
if (SlotPtr ptr = m_ptr.lock())
ptr->signal->Disconnect(ptr);
}
template<typename... Args>
void Signal<Args...>::Connection::Disconnect()
{
if (SlotPtr ptr = m_ptr.lock())
ptr->signal->Disconnect(ptr);
}
template<typename... Args>
bool NzSignal<Args...>::Connection::IsConnected() const
{
return !m_ptr.expired();
}
template<typename... Args>
bool Signal<Args...>::Connection::IsConnected() const
{
return !m_ptr.expired();
}
template<typename... Args>
NzSignal<Args...>::ConnectionGuard::ConnectionGuard(const Connection& connection) :
m_connection(connection)
{
}
template<typename... Args>
Signal<Args...>::ConnectionGuard::ConnectionGuard(const Connection& connection) :
m_connection(connection)
{
}
template<typename... Args>
NzSignal<Args...>::ConnectionGuard::ConnectionGuard(Connection&& connection) :
m_connection(std::move(connection))
{
}
template<typename... Args>
Signal<Args...>::ConnectionGuard::ConnectionGuard(Connection&& connection) :
m_connection(std::move(connection))
{
}
template<typename... Args>
NzSignal<Args...>::ConnectionGuard::~ConnectionGuard()
{
m_connection.Disconnect();
}
template<typename... Args>
Signal<Args...>::ConnectionGuard::~ConnectionGuard()
{
m_connection.Disconnect();
}
template<typename... Args>
template<typename... ConnectArgs>
void NzSignal<Args...>::ConnectionGuard::Connect(BaseClass& signal, ConnectArgs&&... args)
{
m_connection.Disconnect();
m_connection.Connect(signal, std::forward<ConnectArgs>(args)...);
}
template<typename... Args>
template<typename... ConnectArgs>
void Signal<Args...>::ConnectionGuard::Connect(BaseClass& signal, ConnectArgs&&... args)
{
m_connection.Disconnect();
m_connection.Connect(signal, std::forward<ConnectArgs>(args)...);
}
template<typename... Args>
void NzSignal<Args...>::ConnectionGuard::Disconnect()
{
m_connection.Disconnect();
}
template<typename... Args>
void Signal<Args...>::ConnectionGuard::Disconnect()
{
m_connection.Disconnect();
}
template<typename... Args>
typename NzSignal<Args...>::Connection& NzSignal<Args...>::ConnectionGuard::GetConnection()
{
return m_connection;
}
template<typename... Args>
typename Signal<Args...>::Connection& Signal<Args...>::ConnectionGuard::GetConnection()
{
return m_connection;
}
template<typename... Args>
bool NzSignal<Args...>::ConnectionGuard::IsConnected() const
{
return m_connection.IsConnected();
}
template<typename... Args>
bool Signal<Args...>::ConnectionGuard::IsConnected() const
{
return m_connection.IsConnected();
}
template<typename... Args>
typename NzSignal<Args...>::ConnectionGuard& NzSignal<Args...>::ConnectionGuard::operator=(const Connection& connection)
{
m_connection.Disconnect();
m_connection = connection;
template<typename... Args>
typename Signal<Args...>::ConnectionGuard& Signal<Args...>::ConnectionGuard::operator=(const Connection& connection)
{
m_connection.Disconnect();
m_connection = connection;
return *this;
}
return *this;
}
template<typename... Args>
typename NzSignal<Args...>::ConnectionGuard& NzSignal<Args...>::ConnectionGuard::operator=(Connection&& connection)
{
m_connection.Disconnect();
m_connection = std::move(connection);
template<typename... Args>
typename Signal<Args...>::ConnectionGuard& Signal<Args...>::ConnectionGuard::operator=(Connection&& connection)
{
m_connection.Disconnect();
m_connection = std::move(connection);
return *this;
}
return *this;
}
template<typename... Args>
typename NzSignal<Args...>::ConnectionGuard& NzSignal<Args...>::ConnectionGuard::operator=(ConnectionGuard&& connection)
{
m_connection.Disconnect();
m_connection = std::move(connection.m_connection);
template<typename... Args>
typename Signal<Args...>::ConnectionGuard& Signal<Args...>::ConnectionGuard::operator=(ConnectionGuard&& connection)
{
m_connection.Disconnect();
m_connection = std::move(connection.m_connection);
return *this;
return *this;
}
}
#include <Nazara/Core/DebugOff.hpp>