#ifndef CSM_WOLRD_REFIDADAPTERIMP_H
#define CSM_WOLRD_REFIDADAPTERIMP_H
#include <algorithm>
#include <map>
#include <memory>
#include <stdexcept>
#include <string>
#include <string_view>
#include <utility>
#include <vector>
#include <QVariant>
#include <components/esm/defs.hpp>
#include <components/esm/esmcommon.hpp>
#include <components/esm3/aipackage.hpp>
#include <components/esm3/loadalch.hpp>
#include <components/esm3/loadappa.hpp>
#include <components/esm3/loadarmo.hpp>
#include <components/esm3/loadbook.hpp>
#include <components/esm3/loadclot.hpp>
#include <components/esm3/loadcont.hpp>
#include <components/esm3/loadcrea.hpp>
#include <components/esm3/loaddoor.hpp>
#include <components/esm3/loadingr.hpp>
#include <components/esm3/loadlevlist.hpp>
#include <components/esm3/loadligh.hpp>
#include <components/esm3/loadmisc.hpp>
#include <components/esm3/loadnpc.hpp>
#include <components/esm3/loadweap.hpp>
#include <components/esm3/transport.hpp>
#include "columnbase.hpp"
#include "nestedtablewrapper.hpp"
#include "record.hpp"
#include "refidadapter.hpp"
#include "refiddata.hpp"
#include "universalid.hpp"
namespace CSMWorld
{
class RefIdColumn;
struct BaseColumns
{
const RefIdColumn* mId;
const RefIdColumn* mModified;
const RefIdColumn* mType;
const RefIdColumn* mBlocked;
BaseColumns()
: mId(nullptr)
, mModified(nullptr)
, mType(nullptr)
, mBlocked(nullptr)
{
}
};
/// \brief Base adapter for all refereceable record types
/// Adapters that can handle nested tables, needs to return valid qvariant for parent columns
template <typename RecordT>
class BaseRefIdAdapter : public RefIdAdapter
{
UniversalId::Type mType;
BaseColumns mBase;
public:
BaseRefIdAdapter(UniversalId::Type type, const BaseColumns& base);
ESM::RefId getId(const RecordBase& record) const override;
void setId(RecordBase& record, const std::string& id) override;
QVariant getData(const RefIdColumn* column, const RefIdData& data, int index) const override;
void setData(const RefIdColumn* column, RefIdData& data, int index, const QVariant& value) const override;
///< If the data type does not match an exception is thrown.
UniversalId::Type getType() const;
};
template <typename RecordT>
BaseRefIdAdapter<RecordT>::BaseRefIdAdapter(UniversalId::Type type, const BaseColumns& base)
: mType(type)
, mBase(base)
{
}
template <typename RecordT>
void BaseRefIdAdapter<RecordT>::setId(RecordBase& record, const std::string& id)
{
(dynamic_cast<Record<RecordT>&>(record).get().mId) = ESM::RefId::stringRefId(id);
}
template <typename RecordT>
ESM::RefId BaseRefIdAdapter<RecordT>::getId(const RecordBase& record) const
{
return dynamic_cast<const Record<RecordT>&>(record).get().mId;
}
template <typename RecordT>
QVariant BaseRefIdAdapter<RecordT>::getData(const RefIdColumn* column, const RefIdData& data, int index) const
{
const Record<RecordT>& record
= static_cast<const Record<RecordT>&>(data.getRecord(RefIdData::LocalIndex(index, mType)));
if (column == mBase.mId)
return QString::fromStdString(record.get().mId.toString());
if (column == mBase.mModified)
{
if (record.mState == Record<RecordT>::State_Erased)
return static_cast<int>(Record<RecordT>::State_Deleted);
return static_cast<int>(record.mState);
}
if (column == mBase.mType)
return static_cast<int>(mType);
if (column == mBase.mBlocked)
return (record.get().mRecordFlags & ESM::FLAG_Blocked) != 0;
return QVariant();
}
template <typename RecordT>
void BaseRefIdAdapter<RecordT>::setData(
const RefIdColumn* column, RefIdData& data, int index, const QVariant& value) const
{
Record<RecordT>& record = static_cast<Record<RecordT>&>(data.getRecord(RefIdData::LocalIndex(index, mType)));
if (column == mBase.mModified)
record.mState = static_cast<RecordBase::State>(value.toInt());
else if (column == mBase.mBlocked)
{
RecordT record2 = record.get();
if (value.toInt() != 0)
record2.mRecordFlags |= ESM::FLAG_Blocked;
else
record2.mRecordFlags &= ~ESM::FLAG_Blocked;
record.setModified(record2);
}
}
template <typename RecordT>
UniversalId::Type BaseRefIdAdapter<RecordT>::getType() const
{
return mType;
}
// NOTE: Body Part should not have persistence (but BodyPart is not listed in the Objects
// table at the moment).
//
// Spellmaking - not persistent - currently not part of objects table
// Enchanting - not persistent - currently not part of objects table
//
// Leveled Creature - no model, so not persistent
// Leveled Item - no model, so not persistent
struct ModelColumns : public BaseColumns
{
const RefIdColumn* mModel;
const RefIdColumn* mPersistence;
ModelColumns(const BaseColumns& base)
: BaseColumns(base)
, mModel(nullptr)
, mPersistence(nullptr)
{
}
};
/// \brief Adapter for IDs with models (all but levelled lists)
template <typename RecordT>
class ModelRefIdAdapter : public BaseRefIdAdapter<RecordT>
{
ModelColumns mModel;
public:
ModelRefIdAdapter(UniversalId::Type type, const ModelColumns& columns);
QVariant getData(const RefIdColumn* column, const RefIdData& data, int index) const override;
void setData(const RefIdColumn* column, RefIdData& data, int index, const QVariant& value) const override;
///< If the data type does not match an exception is thrown.
};
template <typename RecordT>
ModelRefIdAdapter<RecordT>::ModelRefIdAdapter(UniversalId::Type type, const ModelColumns& columns)
: BaseRefIdAdapter<RecordT>(type, columns)
, mModel(columns)
{
}
template <typename RecordT>
QVariant ModelRefIdAdapter<RecordT>::getData(const RefIdColumn* column, const RefIdData& data, int index) const
{
const Record<RecordT>& record = static_cast<const Record<RecordT>&>(
data.getRecord(RefIdData::LocalIndex(index, BaseRefIdAdapter<RecordT>::getType())));
if (column == mModel.mModel)
return QString::fromUtf8(record.get().mModel.c_str());
if (column == mModel.mPersistence)
return (record.get().mRecordFlags & ESM::FLAG_Persistent) != 0;
return BaseRefIdAdapter<RecordT>::getData(column, data, index);
}
template <typename RecordT>
void ModelRefIdAdapter<RecordT>::setData(
const RefIdColumn* column, RefIdData& data, int index, const QVariant& value) const
{
Record<RecordT>& record = static_cast<Record<RecordT>&>(
data.getRecord(RefIdData::LocalIndex(index, BaseRefIdAdapter<RecordT>::getType())));
RecordT record2 = record.get();
if (column == mModel.mModel)
record2.mModel = value.toString().toUtf8().constData();
else if (column == mModel.mPersistence)
{
if (value.toInt() != 0)
record2.mRecordFlags |= ESM::FLAG_Persistent;
else
record2.mRecordFlags &= ~ESM::FLAG_Persistent;
}
else
{
BaseRefIdAdapter<RecordT>::setData(column, data, index, value);
return;
}
record.setModified(record2);
}
struct NameColumns : public ModelColumns
{
const RefIdColumn* mName;
const RefIdColumn* mScript;
NameColumns(const ModelColumns& base)
: ModelColumns(base)
, mName(nullptr)
, mScript(nullptr)
{
}
};
/// \brief Adapter for IDs with names (all but levelled lists and statics)
template <typename RecordT>
class NameRefIdAdapter : public ModelRefIdAdapter<RecordT>
{
NameColumns mName;
public:
NameRefIdAdapter(UniversalId::Type type, const NameColumns& columns);
QVariant getData(const RefIdColumn* column, const RefIdData& data, int index) const override;
void setData(const RefIdColumn* column, RefIdData& data, int index, const QVariant& value) const override;
///< If the data type does not match an exception is thrown.
};
template <typename RecordT>
NameRefIdAdapter<RecordT>::NameRefIdAdapter(UniversalId::Type type, const NameColumns& columns)
: ModelRefIdAdapter<RecordT>(type, columns)
, mName(columns)
{
}
template <typename RecordT>
QVariant NameRefIdAdapter<RecordT>::getData(const RefIdColumn* column, const RefIdData& data, int index) const
{
const Record<RecordT>& record = static_cast<const Record<RecordT>&>(
data.getRecord(RefIdData::LocalIndex(index, BaseRefIdAdapter<RecordT>::getType())));
if (column == mName.mName)
return QString::fromUtf8(record.get().mName.c_str());
if (column == mName.mScript)
return QString::fromUtf8(record.get().mScript.getRefIdString().c_str());
return ModelRefIdAdapter<RecordT>::getData(column, data, index);
}
template <typename RecordT>
void NameRefIdAdapter<RecordT>::setData(
const RefIdColumn* column, RefIdData& data, int index, const QVariant& value) const
{
Record<RecordT>& record = static_cast<Record<RecordT>&>(
data.getRecord(RefIdData::LocalIndex(index, BaseRefIdAdapter<RecordT>::getType())));
RecordT record2 = record.get();
if (column == mName.mName)
record2.mName = value.toString().toUtf8().constData();
else if (column == mName.mScript)
record2.mScript = ESM::RefId::stringRefId(value.toString().toUtf8().constData());
else
{
ModelRefIdAdapter<RecordT>::setData(column, data, index, value);
return;
}
record.setModified(record2);
}
struct InventoryColumns : public NameColumns
{
const RefIdColumn* mIcon;
const RefIdColumn* mWeight;
const RefIdColumn* mValue;
InventoryColumns(const NameColumns& base)
: NameColumns(base)
, mIcon(nullptr)
, mWeight(nullptr)
, mValue(nullptr)
{
}
};
/// \brief Adapter for IDs that can go into an inventory
template <typename RecordT>
class InventoryRefIdAdapter : public NameRefIdAdapter<RecordT>
{
InventoryColumns mInventory;
public:
InventoryRefIdAdapter(UniversalId::Type type, const InventoryColumns& columns);
QVariant getData(const RefIdColumn* column, const RefIdData& data, int index) const override;
void setData(const RefIdColumn* column, RefIdData& data, int index, const QVariant& value) const override;
///< If the data type does not match an exception is thrown.
};
template <typename RecordT>
InventoryRefIdAdapter<RecordT>::InventoryRefIdAdapter(UniversalId::Type type, const InventoryColumns& columns)
: NameRefIdAdapter<RecordT>(type, columns)
, mInventory(columns)
{
}
template <typename RecordT>
QVariant InventoryRefIdAdapter<RecordT>::getData(const RefIdColumn* column, const RefIdData& data, int index) const
{
const Record<RecordT>& record = static_cast<const Record<RecordT>&>(
data.getRecord(RefIdData::LocalIndex(index, BaseRefIdAdapter<RecordT>::getType())));
if (column == mInventory.mIcon)
return QString::fromUtf8(record.get().mIcon.c_str());
if (column == mInventory.mWeight)
return record.get().mData.mWeight;
if (column == mInventory.mValue)
return record.get().mData.mValue;
return NameRefIdAdapter<RecordT>::getData(column, data, index);
}
template <typename RecordT>
void InventoryRefIdAdapter<RecordT>::setData(
const RefIdColumn* column, RefIdData& data, int index, const QVariant& value) const
{
Record<RecordT>& record = static_cast<Record<RecordT>&>(
data.getRecord(RefIdData::LocalIndex(index, BaseRefIdAdapter<RecordT>::getType())));
RecordT record2 = record.get();
if (column == mInventory.mIcon)
record2.mIcon = value.toString().toUtf8().constData();
else if (column == mInventory.mWeight)
record2.mData.mWeight = value.toFloat();
else if (column == mInventory.mValue)
record2.mData.mValue = value.toInt();
else
{
NameRefIdAdapter<RecordT>::setData(column, data, index, value);
return;
}
record.setModified(record2);
}
struct PotionColumns : public InventoryColumns
{
const RefIdColumn* mEffects;
PotionColumns(const InventoryColumns& columns);
};
class PotionRefIdAdapter : public InventoryRefIdAdapter<ESM::Potion>
{
PotionColumns mColumns;
const RefIdColumn* mAutoCalc;
public:
PotionRefIdAdapter(const PotionColumns& columns, const RefIdColumn* autoCalc);
QVariant getData(const RefIdColumn* column, const RefIdData& data, int index) const override;
void setData(const RefIdColumn* column, RefIdData& data, int index, const QVariant& value) const override;
///< If the data type does not match an exception is thrown.
};
struct IngredientColumns : public InventoryColumns
{
const RefIdColumn* mEffects;
IngredientColumns(const InventoryColumns& columns);
};
class IngredientRefIdAdapter : public InventoryRefIdAdapter<ESM::Ingredient>
{
IngredientColumns mColumns;
public:
IngredientRefIdAdapter(const IngredientColumns& columns);
QVariant getData(const RefIdColumn* column, const RefIdData& data, int index) const override;
void setData(const RefIdColumn* column, RefIdData& data, int index, const QVariant& value) const override;
///< If the data type does not match an exception is thrown.
};
class IngredEffectRefIdAdapter : public NestedRefIdAdapterBase
{
UniversalId::Type mType;
public:
IngredEffectRefIdAdapter();
IngredEffectRefIdAdapter(const IngredEffectRefIdAdapter&) = delete;
IngredEffectRefIdAdapter& operator=(const IngredEffectRefIdAdapter&) = delete;
~IngredEffectRefIdAdapter() override = default;
void addNestedRow(const RefIdColumn* column, RefIdData& data, int index, int position) const override;
void removeNestedRow(const RefIdColumn* column, RefIdData& data, int index, int rowToRemove) const override;
void setNestedTable(const RefIdColumn* column, RefIdData& data, int index,
const NestedTableWrapperBase& nestedTable) const override;
NestedTableWrapperBase* nestedTable(const RefIdColumn* column, const RefIdData& data, int index) const override;
QVariant getNestedData(const RefIdColumn* column, const RefIdData& data, int index, int subRowIndex,
int subColIndex) const override;
void setNestedData(const RefIdColumn* column, RefIdData& data, int row, const QVariant& value, int subRowIndex,
int subColIndex) const override;
int getNestedColumnsCount(const RefIdColumn* column, const RefIdData& data) const override;
int getNestedRowsCount(const RefIdColumn* column, const RefIdData& data, int index) const override;
};
struct EnchantableColumns : public InventoryColumns
{
const RefIdColumn* mEnchantment;
const RefIdColumn* mEnchantmentPoints;
EnchantableColumns(const InventoryColumns& base)
: InventoryColumns(base)
, mEnchantment(nullptr)
, mEnchantmentPoints(nullptr)
{
}
};
/// \brief Adapter for enchantable IDs
template <typename RecordT>
class EnchantableRefIdAdapter : public InventoryRefIdAdapter<RecordT>
{
EnchantableColumns mEnchantable;
public:
EnchantableRefIdAdapter(UniversalId::Type type, const EnchantableColumns& columns);
QVariant getData(const RefIdColumn* column, const RefIdData& data, int index) const override;
void setData(const RefIdColumn* column, RefIdData& data, int index, const QVariant& value) const override;
///< If the data type does not match an exception is thrown.
};
template <typename RecordT>
EnchantableRefIdAdapter<RecordT>::EnchantableRefIdAdapter(UniversalId::Type type, const EnchantableColumns& columns)
: InventoryRefIdAdapter<RecordT>(type, columns)
, mEnchantable(columns)
{
}
template <typename RecordT>
QVariant EnchantableRefIdAdapter<RecordT>::getData(
const RefIdColumn* column, const RefIdData& data, int index) const
{
const Record<RecordT>& record = static_cast<const Record<RecordT>&>(
data.getRecord(RefIdData::LocalIndex(index, BaseRefIdAdapter<RecordT>::getType())));
if (column == mEnchantable.mEnchantment)
return QString::fromUtf8(record.get().mEnchant.getRefIdString().c_str());
if (column == mEnchantable.mEnchantmentPoints)
return static_cast<int>(record.get().mData.mEnchant);
return InventoryRefIdAdapter<RecordT>::getData(column, data, index);
}
template <typename RecordT>
void EnchantableRefIdAdapter<RecordT>::setData(
const RefIdColumn* column, RefIdData& data, int index, const QVariant& value) const
{
Record<RecordT>& record = static_cast<Record<RecordT>&>(
data.getRecord(RefIdData::LocalIndex(index, BaseRefIdAdapter<RecordT>::getType())));
RecordT record2 = record.get();
if (column == mEnchantable.mEnchantment)
record2.mEnchant = ESM::RefId::stringRefId(value.toString().toUtf8().constData());
else if (column == mEnchantable.mEnchantmentPoints)
record2.mData.mEnchant = value.toInt();
else
{
InventoryRefIdAdapter<RecordT>::setData(column, data, index, value);
return;
}
record.setModified(record2);
}
struct ToolColumns : public InventoryColumns
{
const RefIdColumn* mQuality;
const RefIdColumn* mUses;
ToolColumns(const InventoryColumns& base)
: InventoryColumns(base)
, mQuality(nullptr)
, mUses(nullptr)
{
}
};
/// \brief Adapter for tools with limited uses IDs (lockpick, repair, probes)
template <typename RecordT>
class ToolRefIdAdapter : public InventoryRefIdAdapter<RecordT>
{
ToolColumns mTools;
public:
ToolRefIdAdapter(UniversalId::Type type, const ToolColumns& columns);
QVariant getData(const RefIdColumn* column, const RefIdData& data, int index) const override;
void setData(const RefIdColumn* column, RefIdData& data, int index, const QVariant& value) const override;
///< If the data type does not match an exception is thrown.
};
template <typename RecordT>
ToolRefIdAdapter<RecordT>::ToolRefIdAdapter(UniversalId::Type type, const ToolColumns& columns)
: InventoryRefIdAdapter<RecordT>(type, columns)
, mTools(columns)
{
}
template <typename RecordT>
QVariant ToolRefIdAdapter<RecordT>::getData(const RefIdColumn* column, const RefIdData& data, int index) const
{
const Record<RecordT>& record = static_cast<const Record<RecordT>&>(
data.getRecord(RefIdData::LocalIndex(index, BaseRefIdAdapter<RecordT>::getType())));
if (column == mTools.mQuality)
return record.get().mData.mQuality;
if (column == mTools.mUses)
return record.get().mData.mUses;
return InventoryRefIdAdapter<RecordT>::getData(column, data, index);
}
template <typename RecordT>
void ToolRefIdAdapter<RecordT>::setData(
const RefIdColumn* column, RefIdData& data, int index, const QVariant& value) const
{
Record<RecordT>& record = static_cast<Record<RecordT>&>(
data.getRecord(RefIdData::LocalIndex(index, BaseRefIdAdapter<RecordT>::getType())));
RecordT record2 = record.get();
if (column == mTools.mQuality)
record2.mData.mQuality = value.toFloat();
else if (column == mTools.mUses)
record2.mData.mUses = value.toInt();
else
{
InventoryRefIdAdapter<RecordT>::setData(column, data, index, value);
return;
}
record.setModified(record2);
}
struct ActorColumns : public NameColumns
{
const RefIdColumn* mHello;
const RefIdColumn* mFlee;
const RefIdColumn* mFight;
const RefIdColumn* mAlarm;
const RefIdColumn* mInventory;
const RefIdColumn* mSpells;
const RefIdColumn* mDestinations;
const RefIdColumn* mAiPackages;
std::map<const RefIdColumn*, unsigned int> mServices;
ActorColumns(const NameColumns& base)
: NameColumns(base)
, mHello(nullptr)
, mFlee(nullptr)
, mFight(nullptr)
, mAlarm(nullptr)
, mInventory(nullptr)
, mSpells(nullptr)
, mDestinations(nullptr)
, mAiPackages(nullptr)
{
}
};
/// \brief Adapter for actor IDs (handles common AI functionality)
template <typename RecordT>
class ActorRefIdAdapter : public NameRefIdAdapter<RecordT>
{
ActorColumns mActors;
public:
ActorRefIdAdapter(UniversalId::Type type, const ActorColumns& columns);
QVariant getData(const RefIdColumn* column, const RefIdData& data, int index) const override;
void setData(const RefIdColumn* column, RefIdData& data, int index, const QVariant& value) const override;
///< If the data type does not match an exception is thrown.
};
template <typename RecordT>
ActorRefIdAdapter<RecordT>::ActorRefIdAdapter(UniversalId::Type type, const ActorColumns& columns)
: NameRefIdAdapter<RecordT>(type, columns)
, mActors(columns)
{
}
template <typename RecordT>
QVariant ActorRefIdAdapter<RecordT>::getData(const RefIdColumn* column, const RefIdData& data, int index) const
{
const Record<RecordT>& record = static_cast<const Record<RecordT>&>(
data.getRecord(RefIdData::LocalIndex(index, BaseRefIdAdapter<RecordT>::getType())));
if (column == mActors.mHello)
return record.get().mAiData.mHello;
if (column == mActors.mFlee)
return record.get().mAiData.mFlee;
if (column == mActors.mFight)
return record.get().mAiData.mFight;
if (column == mActors.mAlarm)
return record.get().mAiData.mAlarm;
if (column == mActors.mInventory)
return QVariant::fromValue(ColumnBase::TableEdit_Full);
if (column == mActors.mSpells)
return QVariant::fromValue(ColumnBase::TableEdit_Full);
if (column == mActors.mDestinations)
return QVariant::fromValue(ColumnBase::TableEdit_Full);
if (column == mActors.mAiPackages)
return QVariant::fromValue(ColumnBase::TableEdit_Full);
std::map<const RefIdColumn*, unsigned int>::const_iterator iter = mActors.mServices.find(column);
if (iter != mActors.mServices.end())
return (record.get().mAiData.mServices & iter->second) != 0;
return NameRefIdAdapter<RecordT>::getData(column, data, index);
}
template <typename RecordT>
void ActorRefIdAdapter<RecordT>::setData(
const RefIdColumn* column, RefIdData& data, int index, const QVariant& value) const
{
Record<RecordT>& record = static_cast<Record<RecordT>&>(
data.getRecord(RefIdData::LocalIndex(index, BaseRefIdAdapter<RecordT>::getType())));
RecordT record2 = record.get();
if (column == mActors.mHello)
record2.mAiData.mHello = value.toInt();
else if (column == mActors.mFlee) // Flee, Fight and Alarm ratings are probabilities.
record2.mAiData.mFlee = std::min(100, value.toInt());
else if (column == mActors.mFight)
record2.mAiData.mFight = std::min(100, value.toInt());
else if (column == mActors.mAlarm)
record2.mAiData.mAlarm = std::min(100, value.toInt());
else
{
typename std::map<const RefIdColumn*, unsigned int>::const_iterator iter = mActors.mServices.find(column);
if (iter != mActors.mServices.end())
{
if (value.toInt() != 0)
record2.mAiData.mServices |= iter->second;
else
record2.mAiData.mServices &= ~iter->second;
}
else
{
NameRefIdAdapter<RecordT>::setData(column, data, index, value);
return;
}
}
record.setModified(record2);
}
class ApparatusRefIdAdapter : public InventoryRefIdAdapter<ESM::Apparatus>
{
const RefIdColumn* mType;
const RefIdColumn* mQuality;
public:
ApparatusRefIdAdapter(const InventoryColumns& columns, const RefIdColumn* type, const RefIdColumn* quality);
QVariant getData(const RefIdColumn* column, const RefIdData& data, int index) const override;
void setData(const RefIdColumn* column, RefIdData& data, int index, const QVariant& value) const override;
///< If the data type does not match an exception is thrown.
};
class ArmorRefIdAdapter : public EnchantableRefIdAdapter<ESM::Armor>
{
const RefIdColumn* mType;
const RefIdColumn* mHealth;
const RefIdColumn* mArmor;
const RefIdColumn* mPartRef;
public:
ArmorRefIdAdapter(const EnchantableColumns& columns, const RefIdColumn* type, const RefIdColumn* health,
const RefIdColumn* armor, const RefIdColumn* partRef);
QVariant getData(const RefIdColumn* column, const RefIdData& data, int index) const override;
void setData(const RefIdColumn* column, RefIdData& data, int index, const QVariant& value) const override;
///< If the data type does not match an exception is thrown.
};
class BookRefIdAdapter : public EnchantableRefIdAdapter<ESM::Book>
{
const RefIdColumn* mBookType;
const RefIdColumn* mSkill;
const RefIdColumn* mText;
public:
BookRefIdAdapter(const EnchantableColumns& columns, const RefIdColumn* bookType, const RefIdColumn* skill,
const RefIdColumn* text);
QVariant getData(const RefIdColumn* column, const RefIdData& data, int index) const override;
void setData(const RefIdColumn* column, RefIdData& data, int index, const QVariant& value) const override;
///< If the data type does not match an exception is thrown.
};
class ClothingRefIdAdapter : public EnchantableRefIdAdapter<ESM::Clothing>
{
const RefIdColumn* mType;
const RefIdColumn* mPartRef;
public:
ClothingRefIdAdapter(const EnchantableColumns& columns, const RefIdColumn* type, const RefIdColumn* partRef);
QVariant getData(const RefIdColumn* column, const RefIdData& data, int index) const override;
void setData(const RefIdColumn* column, RefIdData& data, int index, const QVariant& value) const override;
///< If the data type does not match an exception is thrown.
};
class ContainerRefIdAdapter : public NameRefIdAdapter<ESM::Container>
{
const RefIdColumn* mWeight;
const RefIdColumn* mOrganic;
const RefIdColumn* mRespawn;
const RefIdColumn* mContent;
public:
ContainerRefIdAdapter(const NameColumns& columns, const RefIdColumn* weight, const RefIdColumn* organic,
const RefIdColumn* respawn, const RefIdColumn* content);
QVariant getData(const RefIdColumn* column, const RefIdData& data, int index) const override;
void setData(const RefIdColumn* column, RefIdData& data, int index, const QVariant& value) const override;
///< If the data type does not match an exception is thrown.
};
struct CreatureColumns : public ActorColumns
{
std::map<const RefIdColumn*, unsigned int> mFlags;
const RefIdColumn* mType;
const RefIdColumn* mScale;
const RefIdColumn* mOriginal;
const RefIdColumn* mAttributes;
const RefIdColumn* mAttacks;
const RefIdColumn* mMisc;
const RefIdColumn* mBloodType;
CreatureColumns(const ActorColumns& actorColumns);
};
class CreatureRefIdAdapter : public ActorRefIdAdapter<ESM::Creature>
{
CreatureColumns mColumns;
public:
CreatureRefIdAdapter(const CreatureColumns& columns);
QVariant getData(const RefIdColumn* column, const RefIdData& data, int index) const override;
void setData(const RefIdColumn* column, RefIdData& data, int index, const QVariant& value) const override;
///< If the data type does not match an exception is thrown.
};
class DoorRefIdAdapter : public NameRefIdAdapter<ESM::Door>
{
const RefIdColumn* mOpenSound;
const RefIdColumn* mCloseSound;
public:
DoorRefIdAdapter(const NameColumns& columns, const RefIdColumn* openSound, const RefIdColumn* closeSound);
QVariant getData(const RefIdColumn* column, const RefIdData& data, int index) const override;
void setData(const RefIdColumn* column, RefIdData& data, int index, const QVariant& value) const override;
///< If the data type does not match an exception is thrown.
};
struct LightColumns : public InventoryColumns
{
const RefIdColumn* mTime;
const RefIdColumn* mRadius;
const RefIdColumn* mColor;
const RefIdColumn* mSound;
const RefIdColumn* mEmitterType;
std::map<const RefIdColumn*, unsigned int> mFlags;
LightColumns(const InventoryColumns& columns);
};
class LightRefIdAdapter : public InventoryRefIdAdapter<ESM::Light>
{
LightColumns mColumns;
public:
LightRefIdAdapter(const LightColumns& columns);
QVariant getData(const RefIdColumn* column, const RefIdData& data, int index) const override;
void setData(const RefIdColumn* column, RefIdData& data, int index, const QVariant& value) const override;
///< If the data type does not match an exception is thrown.
};
class MiscRefIdAdapter : public InventoryRefIdAdapter<ESM::Miscellaneous>
{
const RefIdColumn* mKey;
public:
MiscRefIdAdapter(const InventoryColumns& columns, const RefIdColumn* key);
QVariant getData(const RefIdColumn* column, const RefIdData& data, int index) const override;
void setData(const RefIdColumn* column, RefIdData& data, int index, const QVariant& value) const override;
///< If the data type does not match an exception is thrown.
};
struct NpcColumns : public ActorColumns
{
std::map<const RefIdColumn*, unsigned int> mFlags;
const RefIdColumn* mRace;
const RefIdColumn* mClass;
const RefIdColumn* mFaction;
const RefIdColumn* mHair;
const RefIdColumn* mHead;
const RefIdColumn* mAttributes; // depends on npc type
const RefIdColumn* mSkills; // depends on npc type
const RefIdColumn* mMisc; // may depend on npc type, e.g. FactionID
const RefIdColumn* mBloodType;
const RefIdColumn* mGender;
NpcColumns(const ActorColumns& actorColumns);
};
class NpcRefIdAdapter : public ActorRefIdAdapter<ESM::NPC>
{
NpcColumns mColumns;
public:
NpcRefIdAdapter(const NpcColumns& columns);
QVariant getData(const RefIdColumn* column, const RefIdData& data, int index) const override;
void setData(const RefIdColumn* column, RefIdData& data, int index, const QVariant& value) const override;
///< If the data type does not match an exception is thrown.
};
struct WeaponColumns : public EnchantableColumns
{
const RefIdColumn* mType;
const RefIdColumn* mHealth;
const RefIdColumn* mSpeed;
const RefIdColumn* mReach;
const RefIdColumn* mChop[2];
const RefIdColumn* mSlash[2];
const RefIdColumn* mThrust[2];
std::map<const RefIdColumn*, unsigned int> mFlags;
WeaponColumns(const EnchantableColumns& columns);
};
class WeaponRefIdAdapter : public EnchantableRefIdAdapter<ESM::Weapon>
{
WeaponColumns mColumns;
public:
WeaponRefIdAdapter(const WeaponColumns& columns);
QVariant getData(const RefIdColumn* column, const RefIdData& data, int index) const override;
void setData(const RefIdColumn* column, RefIdData& data, int index, const QVariant& value) const override;
///< If the data type does not match an exception is thrown.
};
class NpcAttributesRefIdAdapter : public NestedRefIdAdapterBase
{
public:
NpcAttributesRefIdAdapter() = default;
void addNestedRow(const RefIdColumn* column, RefIdData& data, int index, int position) const override;
void removeNestedRow(const RefIdColumn* column, RefIdData& data, int index, int rowToRemove) const override;
void setNestedTable(const RefIdColumn* column, RefIdData& data, int index,
const NestedTableWrapperBase& nestedTable) const override;
NestedTableWrapperBase* nestedTable(const RefIdColumn* column, const RefIdData& data, int index) const override;
QVariant getNestedData(const RefIdColumn* column, const RefIdData& data, int index, int subRowIndex,
int subColIndex) const override;
void setNestedData(const RefIdColumn* column, RefIdData& data, int row, const QVariant& value, int subRowIndex,
int subColIndex) const override;
int getNestedColumnsCount(const RefIdColumn* column, const RefIdData& data) const override;
int getNestedRowsCount(const RefIdColumn* column, const RefIdData& data, int index) const override;
};
class NpcSkillsRefIdAdapter : public NestedRefIdAdapterBase
{
public:
NpcSkillsRefIdAdapter() = default;
void addNestedRow(const RefIdColumn* column, RefIdData& data, int index, int position) const override;
void removeNestedRow(const RefIdColumn* column, RefIdData& data, int index, int rowToRemove) const override;
void setNestedTable(const RefIdColumn* column, RefIdData& data, int index,
const NestedTableWrapperBase& nestedTable) const override;
NestedTableWrapperBase* nestedTable(const RefIdColumn* column, const RefIdData& data, int index) const override;
QVariant getNestedData(const RefIdColumn* column, const RefIdData& data, int index, int subRowIndex,
int subColIndex) const override;
void setNestedData(const RefIdColumn* column, RefIdData& data, int row, const QVariant& value, int subRowIndex,
int subColIndex) const override;
int getNestedColumnsCount(const RefIdColumn* column, const RefIdData& data) const override;
int getNestedRowsCount(const RefIdColumn* column, const RefIdData& data, int index) const override;
};
class NpcMiscRefIdAdapter : public NestedRefIdAdapterBase
{
public:
NpcMiscRefIdAdapter() = default;
NpcMiscRefIdAdapter(const NpcMiscRefIdAdapter&) = delete;
NpcMiscRefIdAdapter& operator=(const NpcMiscRefIdAdapter&) = delete;
~NpcMiscRefIdAdapter() override = default;
void addNestedRow(const RefIdColumn* column, RefIdData& data, int index, int position) const override;
void removeNestedRow(const RefIdColumn* column, RefIdData& data, int index, int rowToRemove) const override;
void setNestedTable(const RefIdColumn* column, RefIdData& data, int index,
const NestedTableWrapperBase& nestedTable) const override;
NestedTableWrapperBase* nestedTable(const RefIdColumn* column, const RefIdData& data, int index) const override;
QVariant getNestedData(const RefIdColumn* column, const RefIdData& data, int index, int subRowIndex,
int subColIndex) const override;
void setNestedData(const RefIdColumn* column, RefIdData& data, int row, const QVariant& value, int subRowIndex,
int subColIndex) const override;
int getNestedColumnsCount(const RefIdColumn* column, const RefIdData& data) const override;
int getNestedRowsCount(const RefIdColumn* column, const RefIdData& data, int index) const override;
};
class CreatureAttributesRefIdAdapter : public NestedRefIdAdapterBase
{
public:
CreatureAttributesRefIdAdapter() = default;
void addNestedRow(const RefIdColumn* column, RefIdData& data, int index, int position) const override;
void removeNestedRow(const RefIdColumn* column, RefIdData& data, int index, int rowToRemove) const override;
void setNestedTable(const RefIdColumn* column, RefIdData& data, int index,
const NestedTableWrapperBase& nestedTable) const override;
NestedTableWrapperBase* nestedTable(const RefIdColumn* column, const RefIdData& data, int index) const override;
QVariant getNestedData(const RefIdColumn* column, const RefIdData& data, int index, int subRowIndex,
int subColIndex) const override;
void setNestedData(const RefIdColumn* column, RefIdData& data, int row, const QVariant& value, int subRowIndex,
int subColIndex) const override;
int getNestedColumnsCount(const RefIdColumn* column, const RefIdData& data) const override;
int getNestedRowsCount(const RefIdColumn* column, const RefIdData& data, int index) const override;
};
class CreatureAttackRefIdAdapter : public NestedRefIdAdapterBase
{
public:
CreatureAttackRefIdAdapter() = default;
void addNestedRow(const RefIdColumn* column, RefIdData& data, int index, int position) const override;
void removeNestedRow(const RefIdColumn* column, RefIdData& data, int index, int rowToRemove) const override;
void setNestedTable(const RefIdColumn* column, RefIdData& data, int index,
const NestedTableWrapperBase& nestedTable) const override;
NestedTableWrapperBase* nestedTable(const RefIdColumn* column, const RefIdData& data, int index) const override;
QVariant getNestedData(const RefIdColumn* column, const RefIdData& data, int index, int subRowIndex,
int subColIndex) const override;
void setNestedData(const RefIdColumn* column, RefIdData& data, int row, const QVariant& value, int subRowIndex,
int subColIndex) const override;
int getNestedColumnsCount(const RefIdColumn* column, const RefIdData& data) const override;
int getNestedRowsCount(const RefIdColumn* column, const RefIdData& data, int index) const override;
};
class CreatureMiscRefIdAdapter : public NestedRefIdAdapterBase
{
public:
CreatureMiscRefIdAdapter() = default;
CreatureMiscRefIdAdapter(const CreatureMiscRefIdAdapter&) = delete;
CreatureMiscRefIdAdapter& operator=(const CreatureMiscRefIdAdapter&) = delete;
~CreatureMiscRefIdAdapter() override = default;
void addNestedRow(const RefIdColumn* column, RefIdData& data, int index, int position) const override;
void removeNestedRow(const RefIdColumn* column, RefIdData& data, int index, int rowToRemove) const override;
void setNestedTable(const RefIdColumn* column, RefIdData& data, int index,
const NestedTableWrapperBase& nestedTable) const override;
NestedTableWrapperBase* nestedTable(const RefIdColumn* column, const RefIdData& data, int index) const override;
QVariant getNestedData(const RefIdColumn* column, const RefIdData& data, int index, int subRowIndex,
int subColIndex) const override;
void setNestedData(const RefIdColumn* column, RefIdData& data, int row, const QVariant& value, int subRowIndex,
int subColIndex) const override;
int getNestedColumnsCount(const RefIdColumn* column, const RefIdData& data) const override;
int getNestedRowsCount(const RefIdColumn* column, const RefIdData& data, int index) const override;
};
template <typename ESXRecordT>
class EffectsListAdapter;
template <typename ESXRecordT>
class EffectsRefIdAdapter : public EffectsListAdapter<ESXRecordT>, public NestedRefIdAdapterBase
{
UniversalId::Type mType;
// not implemented
EffectsRefIdAdapter(const EffectsRefIdAdapter&);
EffectsRefIdAdapter& operator=(const EffectsRefIdAdapter&);
public:
EffectsRefIdAdapter(UniversalId::Type type)
: mType(type)
{
}
virtual ~EffectsRefIdAdapter() = default;
void addNestedRow(const RefIdColumn* column, RefIdData& data, int index, int position) const override
{
Record<ESXRecordT>& record
= static_cast<Record<ESXRecordT>&>(data.getRecord(RefIdData::LocalIndex(index, mType)));
EffectsListAdapter<ESXRecordT>::addRow(record, position);
}
void removeNestedRow(const RefIdColumn* column, RefIdData& data, int index, int rowToRemove) const override
{
Record<ESXRecordT>& record
= static_cast<Record<ESXRecordT>&>(data.getRecord(RefIdData::LocalIndex(index, mType)));
EffectsListAdapter<ESXRecordT>::removeRow(record, rowToRemove);
}
void setNestedTable(const RefIdColumn* column, RefIdData& data, int index,
const NestedTableWrapperBase& nestedTable) const override
{
Record<ESXRecordT>& record
= static_cast<Record<ESXRecordT>&>(data.getRecord(RefIdData::LocalIndex(index, mType)));
EffectsListAdapter<ESXRecordT>::setTable(record, nestedTable);
}
NestedTableWrapperBase* nestedTable(const RefIdColumn* column, const RefIdData& data, int index) const override
{
const Record<ESXRecordT>& record
= static_cast<const Record<ESXRecordT>&>(data.getRecord(RefIdData::LocalIndex(index, mType)));
return EffectsListAdapter<ESXRecordT>::table(record);
}
QVariant getNestedData(const RefIdColumn* column, const RefIdData& data, int index, int subRowIndex,
int subColIndex) const override
{
const Record<ESXRecordT>& record
= static_cast<const Record<ESXRecordT>&>(data.getRecord(RefIdData::LocalIndex(index, mType)));
return EffectsListAdapter<ESXRecordT>::getData(record, subRowIndex, subColIndex);
}
void setNestedData(const RefIdColumn* column, RefIdData& data, int row, const QVariant& value, int subRowIndex,
int subColIndex) const override
{
Record<ESXRecordT>& record
= static_cast<Record<ESXRecordT>&>(data.getRecord(RefIdData::LocalIndex(row, mType)));
EffectsListAdapter<ESXRecordT>::setData(record, value, subRowIndex, subColIndex);
}
int getNestedColumnsCount(const RefIdColumn* column, const RefIdData& data) const override
{
const Record<ESXRecordT> record; // not used, just a dummy
return EffectsListAdapter<ESXRecordT>::getColumnsCount(record);
}
int getNestedRowsCount(const RefIdColumn* column, const RefIdData& data, int index) const override
{
const Record<ESXRecordT>& record
= static_cast<const Record<ESXRecordT>&>(data.getRecord(RefIdData::LocalIndex(index, mType)));
return EffectsListAdapter<ESXRecordT>::getRowsCount(record);
}
};
template <typename ESXRecordT>
class NestedInventoryRefIdAdapter : public NestedRefIdAdapterBase
{
UniversalId::Type mType;
// not implemented
NestedInventoryRefIdAdapter(const NestedInventoryRefIdAdapter&);
NestedInventoryRefIdAdapter& operator=(const NestedInventoryRefIdAdapter&);
public:
NestedInventoryRefIdAdapter(UniversalId::Type type)
: mType(type)
{
}
virtual ~NestedInventoryRefIdAdapter() = default;
void addNestedRow(const RefIdColumn* column, RefIdData& data, int index, int position) const override
{
Record<ESXRecordT>& record
= static_cast<Record<ESXRecordT>&>(data.getRecord(RefIdData::LocalIndex(index, mType)));
ESXRecordT container = record.get();
std::vector<ESM::ContItem>& list = container.mInventory.mList;
ESM::ContItem newRow = ESM::ContItem();
if (position >= (int)list.size())
list.push_back(newRow);
else
list.insert(list.begin() + position, newRow);
record.setModified(container);
}
void removeNestedRow(const RefIdColumn* column, RefIdData& data, int index, int rowToRemove) const override
{
Record<ESXRecordT>& record
= static_cast<Record<ESXRecordT>&>(data.getRecord(RefIdData::LocalIndex(index, mType)));
ESXRecordT container = record.get();
std::vector<ESM::ContItem>& list = container.mInventory.mList;
if (rowToRemove < 0 || rowToRemove >= static_cast<int>(list.size()))
throw std::runtime_error("index out of range");
list.erase(list.begin() + rowToRemove);
record.setModified(container);
}
void setNestedTable(const RefIdColumn* column, RefIdData& data, int index,
const NestedTableWrapperBase& nestedTable) const override
{
Record<ESXRecordT>& record
= static_cast<Record<ESXRecordT>&>(data.getRecord(RefIdData::LocalIndex(index, mType)));
ESXRecordT container = record.get();
container.mInventory.mList
= static_cast<const NestedTableWrapper<std::vector<typename ESM::ContItem>>&>(nestedTable).mNestedTable;
record.setModified(container);
}
NestedTableWrapperBase* nestedTable(const RefIdColumn* column, const RefIdData& data, int index) const override
{
const Record<ESXRecordT>& record
= static_cast<const Record<ESXRecordT>&>(data.getRecord(RefIdData::LocalIndex(index, mType)));
// deleted by dtor of NestedTableStoring
return new NestedTableWrapper<std::vector<typename ESM::ContItem>>(record.get().mInventory.mList);
}
QVariant getNestedData(const RefIdColumn* column, const RefIdData& data, int index, int subRowIndex,
int subColIndex) const override
{
const Record<ESXRecordT>& record
= static_cast<const Record<ESXRecordT>&>(data.getRecord(RefIdData::LocalIndex(index, mType)));
const std::vector<ESM::ContItem>& list = record.get().mInventory.mList;
if (subRowIndex < 0 || subRowIndex >= static_cast<int>(list.size()))
throw std::runtime_error("index out of range");
const ESM::ContItem& content = list.at(subRowIndex);
switch (subColIndex)
{
case 0:
return QString::fromUtf8(content.mItem.getRefIdString().c_str());
case 1:
return content.mCount;
default:
throw std::runtime_error("Trying to access non-existing column in the nested table!");
}
}
void setNestedData(const RefIdColumn* column, RefIdData& data, int row, const QVariant& value, int subRowIndex,
int subColIndex) const override
{
Record<ESXRecordT>& record
= static_cast<Record<ESXRecordT>&>(data.getRecord(RefIdData::LocalIndex(row, mType)));
ESXRecordT container = record.get();
std::vector<ESM::ContItem>& list = container.mInventory.mList;
if (subRowIndex < 0 || subRowIndex >= static_cast<int>(list.size()))
throw std::runtime_error("index out of range");
switch (subColIndex)
{
case 0:
list.at(subRowIndex).mItem = ESM::RefId::stringRefId(value.toString().toUtf8().constData());
break;
case 1:
list.at(subRowIndex).mCount = value.toInt();
break;
default:
throw std::runtime_error("Trying to access non-existing column in the nested table!");
}
record.setModified(container);
}
int getNestedColumnsCount(const RefIdColumn* column, const RefIdData& data) const override { return 2; }
int getNestedRowsCount(const RefIdColumn* column, const RefIdData& data, int index) const override
{
const Record<ESXRecordT>& record
= static_cast<const Record<ESXRecordT>&>(data.getRecord(RefIdData::LocalIndex(index, mType)));
return static_cast<int>(record.get().mInventory.mList.size());
}
};
template <typename ESXRecordT>
class NestedSpellRefIdAdapter : public NestedRefIdAdapterBase
{
UniversalId::Type mType;
// not implemented
NestedSpellRefIdAdapter(const NestedSpellRefIdAdapter&);
NestedSpellRefIdAdapter& operator=(const NestedSpellRefIdAdapter&);
public:
NestedSpellRefIdAdapter(UniversalId::Type type)
: mType(type)
{
}
virtual ~NestedSpellRefIdAdapter() = default;
void addNestedRow(const RefIdColumn* column, RefIdData& data, int index, int position) const override
{
Record<ESXRecordT>& record
= static_cast<Record<ESXRecordT>&>(data.getRecord(RefIdData::LocalIndex(index, mType)));
ESXRecordT caster = record.get();
std::vector<ESM::RefId>& list = caster.mSpells.mList;
ESM::RefId newString;
if (position >= (int)list.size())
list.push_back(newString);
else
list.insert(list.begin() + position, newString);
record.setModified(caster);
}
void removeNestedRow(const RefIdColumn* column, RefIdData& data, int index, int rowToRemove) const override
{
Record<ESXRecordT>& record
= static_cast<Record<ESXRecordT>&>(data.getRecord(RefIdData::LocalIndex(index, mType)));
ESXRecordT caster = record.get();
std::vector<ESM::RefId>& list = caster.mSpells.mList;
if (rowToRemove < 0 || rowToRemove >= static_cast<int>(list.size()))
throw std::runtime_error("index out of range");
list.erase(list.begin() + rowToRemove);
record.setModified(caster);
}
void setNestedTable(const RefIdColumn* column, RefIdData& data, int index,
const NestedTableWrapperBase& nestedTable) const override
{
Record<ESXRecordT>& record
= static_cast<Record<ESXRecordT>&>(data.getRecord(RefIdData::LocalIndex(index, mType)));
ESXRecordT caster = record.get();
caster.mSpells.mList
= static_cast<const NestedTableWrapper<std::vector<typename ESM::RefId>>&>(nestedTable).mNestedTable;
record.setModified(caster);
}
NestedTableWrapperBase* nestedTable(const RefIdColumn* column, const RefIdData& data, int index) const override
{
const Record<ESXRecordT>& record
= static_cast<const Record<ESXRecordT>&>(data.getRecord(RefIdData::LocalIndex(index, mType)));
// deleted by dtor of NestedTableStoring
return new NestedTableWrapper<std::vector<typename ESM::RefId>>(record.get().mSpells.mList);
}
QVariant getNestedData(const RefIdColumn* column, const RefIdData& data, int index, int subRowIndex,
int subColIndex) const override
{
const Record<ESXRecordT>& record
= static_cast<const Record<ESXRecordT>&>(data.getRecord(RefIdData::LocalIndex(index, mType)));
const std::vector<ESM::RefId>& list = record.get().mSpells.mList;
if (subRowIndex < 0 || subRowIndex >= static_cast<int>(list.size()))
throw std::runtime_error("index out of range");
const ESM::RefId& content = list.at(subRowIndex);
if (subColIndex == 0)
return QString::fromUtf8(content.getRefIdString().c_str());
else
throw std::runtime_error("Trying to access non-existing column in the nested table!");
}
void setNestedData(const RefIdColumn* column, RefIdData& data, int row, const QVariant& value, int subRowIndex,
int subColIndex) const override
{
Record<ESXRecordT>& record
= static_cast<Record<ESXRecordT>&>(data.getRecord(RefIdData::LocalIndex(row, mType)));
ESXRecordT caster = record.get();
std::vector<ESM::RefId>& list = caster.mSpells.mList;
if (subRowIndex < 0 || subRowIndex >= static_cast<int>(list.size()))
throw std::runtime_error("index out of range");
if (subColIndex == 0)
list.at(subRowIndex) = ESM::RefId::stringRefId(value.toString().toUtf8().constData());
else
throw std::runtime_error("Trying to access non-existing column in the nested table!");
record.setModified(caster);
}
int getNestedColumnsCount(const RefIdColumn* column, const RefIdData& data) const override { return 1; }
int getNestedRowsCount(const RefIdColumn* column, const RefIdData& data, int index) const override
{
const Record<ESXRecordT>& record
= static_cast<const Record<ESXRecordT>&>(data.getRecord(RefIdData::LocalIndex(index, mType)));
return static_cast<int>(record.get().mSpells.mList.size());
}
};
template <typename ESXRecordT>
class NestedTravelRefIdAdapter : public NestedRefIdAdapterBase
{
UniversalId::Type mType;
// not implemented
NestedTravelRefIdAdapter(const NestedTravelRefIdAdapter&);
NestedTravelRefIdAdapter& operator=(const NestedTravelRefIdAdapter&);
public:
NestedTravelRefIdAdapter(UniversalId::Type type)
: mType(type)
{
}
virtual ~NestedTravelRefIdAdapter() = default;
void addNestedRow(const RefIdColumn* column, RefIdData& data, int index, int position) const override
{
Record<ESXRecordT>& record
= static_cast<Record<ESXRecordT>&>(data.getRecord(RefIdData::LocalIndex(index, mType)));
ESXRecordT traveller = record.get();
std::vector<ESM::Transport::Dest>& list = traveller.mTransport.mList;
ESM::Position newPos;
for (unsigned i = 0; i < 3; ++i)
{
newPos.pos[i] = 0;
newPos.rot[i] = 0;
}
ESM::Transport::Dest newRow;
newRow.mPos = newPos;
newRow.mCellName.clear();
if (position >= (int)list.size())
list.push_back(newRow);
else
list.insert(list.begin() + position, newRow);
record.setModified(traveller);
}
void removeNestedRow(const RefIdColumn* column, RefIdData& data, int index, int rowToRemove) const override
{
Record<ESXRecordT>& record
= static_cast<Record<ESXRecordT>&>(data.getRecord(RefIdData::LocalIndex(index, mType)));
ESXRecordT traveller = record.get();
std::vector<ESM::Transport::Dest>& list = traveller.mTransport.mList;
if (rowToRemove < 0 || rowToRemove >= static_cast<int>(list.size()))
throw std::runtime_error("index out of range");
list.erase(list.begin() + rowToRemove);
record.setModified(traveller);
}
void setNestedTable(const RefIdColumn* column, RefIdData& data, int index,
const NestedTableWrapperBase& nestedTable) const override
{
Record<ESXRecordT>& record
= static_cast<Record<ESXRecordT>&>(data.getRecord(RefIdData::LocalIndex(index, mType)));
ESXRecordT traveller = record.get();
traveller.mTransport.mList
= static_cast<const NestedTableWrapper<std::vector<typename ESM::Transport::Dest>>&>(nestedTable)
.mNestedTable;
record.setModified(traveller);
}
NestedTableWrapperBase* nestedTable(const RefIdColumn* column, const RefIdData& data, int index) const override
{
const Record<ESXRecordT>& record
= static_cast<const Record<ESXRecordT>&>(data.getRecord(RefIdData::LocalIndex(index, mType)));
// deleted by dtor of NestedTableStoring
return new NestedTableWrapper<std::vector<typename ESM::Transport::Dest>>(record.get().mTransport.mList);
}
QVariant getNestedData(const RefIdColumn* column, const RefIdData& data, int index, int subRowIndex,
int subColIndex) const override
{
const Record<ESXRecordT>& record
= static_cast<const Record<ESXRecordT>&>(data.getRecord(RefIdData::LocalIndex(index, mType)));
const std::vector<ESM::Transport::Dest>& list = record.get().mTransport.mList;
if (subRowIndex < 0 || subRowIndex >= static_cast<int>(list.size()))
throw std::runtime_error("index out of range");
const ESM::Transport::Dest& content = list.at(subRowIndex);
switch (subColIndex)
{
case 0:
return QString::fromUtf8(content.mCellName.c_str());
case 1:
return content.mPos.pos[0];
case 2:
return content.mPos.pos[1];
case 3:
return content.mPos.pos[2];
case 4:
return content.mPos.rot[0];
case 5:
return content.mPos.rot[1];
case 6:
return content.mPos.rot[2];
default:
throw std::runtime_error("Trying to access non-existing column in the nested table!");
}
}
void setNestedData(const RefIdColumn* column, RefIdData& data, int row, const QVariant& value, int subRowIndex,
int subColIndex) const override
{
Record<ESXRecordT>& record
= static_cast<Record<ESXRecordT>&>(data.getRecord(RefIdData::LocalIndex(row, mType)));
ESXRecordT traveller = record.get();
std::vector<ESM::Transport::Dest>& list = traveller.mTransport.mList;
if (subRowIndex < 0 || subRowIndex >= static_cast<int>(list.size()))
throw std::runtime_error("index out of range");
switch (subColIndex)
{
case 0:
list.at(subRowIndex).mCellName = value.toString().toUtf8().constData();
break;
case 1:
list.at(subRowIndex).mPos.pos[0] = value.toFloat();
break;
case 2:
list.at(subRowIndex).mPos.pos[1] = value.toFloat();
break;
case 3:
list.at(subRowIndex).mPos.pos[2] = value.toFloat();
break;
case 4:
list.at(subRowIndex).mPos.rot[0] = value.toFloat();
break;
case 5:
list.at(subRowIndex).mPos.rot[1] = value.toFloat();
break;
case 6:
list.at(subRowIndex).mPos.rot[2] = value.toFloat();
break;
default:
throw std::runtime_error("Trying to access non-existing column in the nested table!");
}
record.setModified(traveller);
}
int getNestedColumnsCount(const RefIdColumn* column, const RefIdData& data) const override { return 7; }
int getNestedRowsCount(const RefIdColumn* column, const RefIdData& data, int index) const override
{
const Record<ESXRecordT>& record
= static_cast<const Record<ESXRecordT>&>(data.getRecord(RefIdData::LocalIndex(index, mType)));
return static_cast<int>(record.get().mTransport.mList.size());
}
};
template <typename ESXRecordT>
class ActorAiRefIdAdapter : public NestedRefIdAdapterBase
{
UniversalId::Type mType;
// not implemented
ActorAiRefIdAdapter(const ActorAiRefIdAdapter&);
ActorAiRefIdAdapter& operator=(const ActorAiRefIdAdapter&);
public:
ActorAiRefIdAdapter(UniversalId::Type type)
: mType(type)
{
}
virtual ~ActorAiRefIdAdapter() = default;
// FIXME: should check if the AI package type is already in the list and use a default
// that wasn't used already (in extreme case do not add anything at all?
void addNestedRow(const RefIdColumn* column, RefIdData& data, int index, int position) const override
{
Record<ESXRecordT>& record
= static_cast<Record<ESXRecordT>&>(data.getRecord(RefIdData::LocalIndex(index, mType)));
ESXRecordT actor = record.get();
std::vector<ESM::AIPackage>& list = actor.mAiPackage.mList;
ESM::AIPackage newRow;
newRow.mType = ESM::AI_Wander;
newRow.mWander.mDistance = 0;
newRow.mWander.mDuration = 0;
newRow.mWander.mTimeOfDay = 0;
for (int i = 0; i < 8; ++i)
newRow.mWander.mIdle[i] = 0;
newRow.mWander.mShouldRepeat = 1;
newRow.mCellName.clear();
if (position >= (int)list.size())
list.push_back(newRow);
else
list.insert(list.begin() + position, newRow);
record.setModified(actor);
}
void removeNestedRow(const RefIdColumn* column, RefIdData& data, int index, int rowToRemove) const override
{
Record<ESXRecordT>& record
= static_cast<Record<ESXRecordT>&>(data.getRecord(RefIdData::LocalIndex(index, mType)));
ESXRecordT actor = record.get();
std::vector<ESM::AIPackage>& list = actor.mAiPackage.mList;
if (rowToRemove < 0 || rowToRemove >= static_cast<int>(list.size()))
throw std::runtime_error("index out of range");
list.erase(list.begin() + rowToRemove);
record.setModified(actor);
}
void setNestedTable(const RefIdColumn* column, RefIdData& data, int index,
const NestedTableWrapperBase& nestedTable) const override
{
Record<ESXRecordT>& record
= static_cast<Record<ESXRecordT>&>(data.getRecord(RefIdData::LocalIndex(index, mType)));
ESXRecordT actor = record.get();
actor.mAiPackage.mList
= static_cast<const NestedTableWrapper<std::vector<typename ESM::AIPackage>>&>(nestedTable)
.mNestedTable;
record.setModified(actor);
}
NestedTableWrapperBase* nestedTable(const RefIdColumn* column, const RefIdData& data, int index) const override
{
const Record<ESXRecordT>& record
= static_cast<const Record<ESXRecordT>&>(data.getRecord(RefIdData::LocalIndex(index, mType)));
// deleted by dtor of NestedTableStoring
return new NestedTableWrapper<std::vector<typename ESM::AIPackage>>(record.get().mAiPackage.mList);
}
QVariant getNestedData(const RefIdColumn* column, const RefIdData& data, int index, int subRowIndex,
int subColIndex) const override
{
const Record<ESXRecordT>& record
= static_cast<const Record<ESXRecordT>&>(data.getRecord(RefIdData::LocalIndex(index, mType)));
const std::vector<ESM::AIPackage>& list = record.get().mAiPackage.mList;
if (subRowIndex < 0 || subRowIndex >= static_cast<int>(list.size()))
throw std::runtime_error("index out of range");
const ESM::AIPackage& content = list.at(subRowIndex);
switch (subColIndex)
{
case 0:
// FIXME: should more than one AI package type be allowed? Check vanilla
switch (content.mType)
{
case ESM::AI_Wander:
return 0;
case ESM::AI_Travel:
return 1;
case ESM::AI_Follow:
return 2;
case ESM::AI_Escort:
return 3;
case ESM::AI_Activate:
return 4;
default:
return QVariant();
}
case 1: // wander dist
if (content.mType == ESM::AI_Wander)
return content.mWander.mDistance;
else
return QVariant();
case 2: // wander/follow dur
if (content.mType == ESM::AI_Wander)
return content.mWander.mDuration;
else if (content.mType == ESM::AI_Follow || content.mType == ESM::AI_Escort)
return content.mTarget.mDuration;
else
return QVariant();
case 3: // wander ToD
if (content.mType == ESM::AI_Wander)
return content.mWander.mTimeOfDay; // FIXME: not sure of the format
else
return QVariant();
case 4: // wander idle
case 5:
case 6:
case 7:
case 8:
case 9:
case 10:
case 11:
if (content.mType == ESM::AI_Wander)
return static_cast<int>(content.mWander.mIdle[subColIndex - 4]);
else
return QVariant();
case 12: // repeat
if (content.mType == ESM::AI_Wander)
return content.mWander.mShouldRepeat != 0;
else if (content.mType == ESM::AI_Travel)
return content.mTravel.mShouldRepeat != 0;
else if (content.mType == ESM::AI_Follow || content.mType == ESM::AI_Escort)
return content.mTarget.mShouldRepeat != 0;
else if (content.mType == ESM::AI_Activate)
return content.mActivate.mShouldRepeat != 0;
else
return QVariant();
case 13: // activate name
if (content.mType == ESM::AI_Activate)
return QString(content.mActivate.mName.toString().c_str());
else
return QVariant();
case 14: // target id
if (content.mType == ESM::AI_Follow || content.mType == ESM::AI_Escort)
return QString(content.mTarget.mId.toString().c_str());
else
return QVariant();
case 15: // target cell
if (content.mType == ESM::AI_Follow || content.mType == ESM::AI_Escort)
return QString::fromUtf8(content.mCellName.c_str());
else
return QVariant();
case 16:
if (content.mType == ESM::AI_Travel)
return content.mTravel.mX;
else if (content.mType == ESM::AI_Follow || content.mType == ESM::AI_Escort)
return content.mTarget.mX;
else
return QVariant();
case 17:
if (content.mType == ESM::AI_Travel)
return content.mTravel.mY;
else if (content.mType == ESM::AI_Follow || content.mType == ESM::AI_Escort)
return content.mTarget.mY;
else
return QVariant();
case 18:
if (content.mType == ESM::AI_Travel)
return content.mTravel.mZ;
else if (content.mType == ESM::AI_Follow || content.mType == ESM::AI_Escort)
return content.mTarget.mZ;
else
return QVariant();
default:
throw std::runtime_error("Trying to access non-existing column in the nested table!");
}
}
void setNestedData(const RefIdColumn* column, RefIdData& data, int row, const QVariant& value, int subRowIndex,
int subColIndex) const override
{
Record<ESXRecordT>& record
= static_cast<Record<ESXRecordT>&>(data.getRecord(RefIdData::LocalIndex(row, mType)));
ESXRecordT actor = record.get();
std::vector<ESM::AIPackage>& list = actor.mAiPackage.mList;
if (subRowIndex < 0 || subRowIndex >= static_cast<int>(list.size()))
throw std::runtime_error("index out of range");
ESM::AIPackage& content = list.at(subRowIndex);
switch (subColIndex)
{
case 0: // ai package type
switch (value.toInt())
{
case 0:
content.mType = ESM::AI_Wander;
break;
case 1:
content.mType = ESM::AI_Travel;
break;
case 2:
content.mType = ESM::AI_Follow;
break;
case 3:
content.mType = ESM::AI_Escort;
break;
case 4:
content.mType = ESM::AI_Activate;
break;
default:
return; // return without saving
}
break; // always save
case 1:
if (content.mType == ESM::AI_Wander)
content.mWander.mDistance = static_cast<short>(value.toInt());
else
return; // return without saving
break; // always save
case 2:
if (content.mType == ESM::AI_Wander)
content.mWander.mDuration = static_cast<short>(value.toInt());
else if (content.mType == ESM::AI_Follow || content.mType == ESM::AI_Escort)
content.mTarget.mDuration = static_cast<short>(value.toInt());
else
return; // return without saving
break;
case 3:
if (content.mType == ESM::AI_Wander)
content.mWander.mTimeOfDay = static_cast<unsigned char>(value.toInt());
else
return; // return without saving
break; // always save
case 4:
case 5:
case 6:
case 7:
case 8:
case 9:
case 10:
case 11:
if (content.mType == ESM::AI_Wander)
content.mWander.mIdle[subColIndex - 4] = static_cast<unsigned char>(value.toInt());
else
return; // return without saving
break; // always save
case 12:
if (content.mType == ESM::AI_Wander)
content.mWander.mShouldRepeat = static_cast<unsigned char>(value.toInt());
else if (content.mType == ESM::AI_Travel)
content.mTravel.mShouldRepeat = static_cast<unsigned char>(value.toInt());
else if (content.mType == ESM::AI_Follow || content.mType == ESM::AI_Escort)
content.mTarget.mShouldRepeat = static_cast<unsigned char>(value.toInt());
else if (content.mType == ESM::AI_Activate)
content.mActivate.mShouldRepeat = static_cast<unsigned char>(value.toInt());
else
return; // return without saving
break; // always save
case 13: // NAME32
if (content.mType == ESM::AI_Activate)
{
const QByteArray name = value.toString().toUtf8();
content.mActivate.mName.assign(std::string_view(name.constData(), name.size()));
}
else
return; // return without saving
break; // always save
case 14: // NAME32
if (content.mType == ESM::AI_Follow || content.mType == ESM::AI_Escort)
{
const QByteArray id = value.toString().toUtf8();
content.mTarget.mId.assign(std::string_view(id.constData(), id.size()));
}
else
return; // return without saving
break; // always save
case 15:
if (content.mType == ESM::AI_Follow || content.mType == ESM::AI_Escort)
content.mCellName = std::string(value.toString().toUtf8().constData());
else
return; // return without saving
break; // always save
case 16:
if (content.mType == ESM::AI_Travel)
content.mTravel.mX = value.toFloat();
else if (content.mType == ESM::AI_Follow || content.mType == ESM::AI_Escort)
content.mTarget.mX = value.toFloat();
else
return; // return without saving
break; // always save
case 17:
if (content.mType == ESM::AI_Travel)
content.mTravel.mY = value.toFloat();
else if (content.mType == ESM::AI_Follow || content.mType == ESM::AI_Escort)
content.mTarget.mY = value.toFloat();
else
return; // return without saving
break; // always save
case 18:
if (content.mType == ESM::AI_Travel)
content.mTravel.mZ = value.toFloat();
else if (content.mType == ESM::AI_Follow || content.mType == ESM::AI_Escort)
content.mTarget.mZ = value.toFloat();
else
return; // return without saving
break; // always save
default:
throw std::runtime_error("Trying to access non-existing column in the nested table!");
}
record.setModified(actor);
}
int getNestedColumnsCount(const RefIdColumn* column, const RefIdData& data) const override { return 19; }
int getNestedRowsCount(const RefIdColumn* column, const RefIdData& data, int index) const override
{
const Record<ESXRecordT>& record
= static_cast<const Record<ESXRecordT>&>(data.getRecord(RefIdData::LocalIndex(index, mType)));
return static_cast<int>(record.get().mAiPackage.mList.size());
}
};
template <typename ESXRecordT>
class BodyPartRefIdAdapter : public NestedRefIdAdapterBase
{
UniversalId::Type mType;
// not implemented
BodyPartRefIdAdapter(const BodyPartRefIdAdapter&);
BodyPartRefIdAdapter& operator=(const BodyPartRefIdAdapter&);
public:
BodyPartRefIdAdapter(UniversalId::Type type)
: mType(type)
{
}
virtual ~BodyPartRefIdAdapter() = default;
void addNestedRow(const RefIdColumn* column, RefIdData& data, int index, int position) const override
{
Record<ESXRecordT>& record
= static_cast<Record<ESXRecordT>&>(data.getRecord(RefIdData::LocalIndex(index, mType)));
ESXRecordT apparel = record.get();
std::vector<ESM::PartReference>& list = apparel.mParts.mParts;
ESM::PartReference newPart;
newPart.mPart = 0; // 0 == head
newPart.mMale = ESM::RefId();
newPart.mFemale = ESM::RefId();
if (position >= (int)list.size())
list.push_back(newPart);
else
list.insert(list.begin() + position, newPart);
record.setModified(apparel);
}
void removeNestedRow(const RefIdColumn* column, RefIdData& data, int index, int rowToRemove) const override
{
Record<ESXRecordT>& record
= static_cast<Record<ESXRecordT>&>(data.getRecord(RefIdData::LocalIndex(index, mType)));
ESXRecordT apparel = record.get();
std::vector<ESM::PartReference>& list = apparel.mParts.mParts;
if (rowToRemove < 0 || rowToRemove >= static_cast<int>(list.size()))
throw std::runtime_error("index out of range");
list.erase(list.begin() + rowToRemove);
record.setModified(apparel);
}
void setNestedTable(const RefIdColumn* column, RefIdData& data, int index,
const NestedTableWrapperBase& nestedTable) const override
{
Record<ESXRecordT>& record
= static_cast<Record<ESXRecordT>&>(data.getRecord(RefIdData::LocalIndex(index, mType)));
ESXRecordT apparel = record.get();
apparel.mParts.mParts
= static_cast<const NestedTableWrapper<std::vector<typename ESM::PartReference>>&>(nestedTable)
.mNestedTable;
record.setModified(apparel);
}
NestedTableWrapperBase* nestedTable(const RefIdColumn* column, const RefIdData& data, int index) const override
{
const Record<ESXRecordT>& record
= static_cast<const Record<ESXRecordT>&>(data.getRecord(RefIdData::LocalIndex(index, mType)));
// deleted by dtor of NestedTableStoring
return new NestedTableWrapper<std::vector<typename ESM::PartReference>>(record.get().mParts.mParts);
}
QVariant getNestedData(const RefIdColumn* column, const RefIdData& data, int index, int subRowIndex,
int subColIndex) const override
{
const Record<ESXRecordT>& record
= static_cast<const Record<ESXRecordT>&>(data.getRecord(RefIdData::LocalIndex(index, mType)));
const std::vector<ESM::PartReference>& list = record.get().mParts.mParts;
if (subRowIndex < 0 || subRowIndex >= static_cast<int>(list.size()))
throw std::runtime_error("index out of range");
const ESM::PartReference& content = list.at(subRowIndex);
switch (subColIndex)
{
case 0:
{
if (content.mPart < ESM::PRT_Count)
return content.mPart;
else
throw std::runtime_error("Part Reference Type unexpected value");
}
case 1:
return QString(content.mMale.getRefIdString().c_str());
case 2:
return QString(content.mFemale.getRefIdString().c_str());
default:
throw std::runtime_error("Trying to access non-existing column in the nested table!");
}
}
void setNestedData(const RefIdColumn* column, RefIdData& data, int row, const QVariant& value, int subRowIndex,
int subColIndex) const override
{
Record<ESXRecordT>& record
= static_cast<Record<ESXRecordT>&>(data.getRecord(RefIdData::LocalIndex(row, mType)));
ESXRecordT apparel = record.get();
std::vector<ESM::PartReference>& list = apparel.mParts.mParts;
if (subRowIndex < 0 || subRowIndex >= static_cast<int>(list.size()))
throw std::runtime_error("index out of range");
switch (subColIndex)
{
case 0:
list.at(subRowIndex).mPart = static_cast<unsigned char>(value.toInt());
break;
case 1:
list.at(subRowIndex).mMale = ESM::RefId::stringRefId(value.toString().toStdString());
break;
case 2:
list.at(subRowIndex).mFemale = ESM::RefId::stringRefId(value.toString().toStdString());
break;
default:
throw std::runtime_error("Trying to access non-existing column in the nested table!");
}
record.setModified(apparel);
}
int getNestedColumnsCount(const RefIdColumn* column, const RefIdData& data) const override { return 3; }
int getNestedRowsCount(const RefIdColumn* column, const RefIdData& data, int index) const override
{
const Record<ESXRecordT>& record
= static_cast<const Record<ESXRecordT>&>(data.getRecord(RefIdData::LocalIndex(index, mType)));
return static_cast<int>(record.get().mParts.mParts.size());
}
};
struct LevListColumns : public BaseColumns
{
const RefIdColumn* mLevList;
const RefIdColumn* mNestedListLevList;
LevListColumns(const BaseColumns& base)
: BaseColumns(base)
, mLevList(nullptr)
, mNestedListLevList(nullptr)
{
}
};
template <typename RecordT>
class LevelledListRefIdAdapter : public BaseRefIdAdapter<RecordT>
{
LevListColumns mLevList;
public:
LevelledListRefIdAdapter(UniversalId::Type type, const LevListColumns& columns);
QVariant getData(const RefIdColumn* column, const RefIdData& data, int index) const override;
void setData(const RefIdColumn* column, RefIdData& data, int index, const QVariant& value) const override;
///< If the data type does not match an exception is thrown.
};
template <typename RecordT>
LevelledListRefIdAdapter<RecordT>::LevelledListRefIdAdapter(UniversalId::Type type, const LevListColumns& columns)
: BaseRefIdAdapter<RecordT>(type, columns)
, mLevList(columns)
{
}
template <typename RecordT>
QVariant LevelledListRefIdAdapter<RecordT>::getData(
const RefIdColumn* column, const RefIdData& data, int index) const
{
if (column == mLevList.mLevList || column == mLevList.mNestedListLevList)
return QVariant::fromValue(ColumnBase::TableEdit_Full);
return BaseRefIdAdapter<RecordT>::getData(column, data, index);
}
template <typename RecordT>
void LevelledListRefIdAdapter<RecordT>::setData(
const RefIdColumn* column, RefIdData& data, int index, const QVariant& value) const
{
BaseRefIdAdapter<RecordT>::setData(column, data, index, value);
return;
}
// for non-tables
template <typename ESXRecordT>
class NestedListLevListRefIdAdapter : public NestedRefIdAdapterBase
{
UniversalId::Type mType;
// not implemented
NestedListLevListRefIdAdapter(const NestedListLevListRefIdAdapter&);
NestedListLevListRefIdAdapter& operator=(const NestedListLevListRefIdAdapter&);
public:
NestedListLevListRefIdAdapter(UniversalId::Type type)
: mType(type)
{
}
virtual ~NestedListLevListRefIdAdapter() = default;
void addNestedRow(const RefIdColumn* column, RefIdData& data, int index, int position) const override
{
throw std::logic_error("cannot add a row to a fixed table");
}
void removeNestedRow(const RefIdColumn* column, RefIdData& data, int index, int rowToRemove) const override
{
throw std::logic_error("cannot remove a row to a fixed table");
}
void setNestedTable(const RefIdColumn* column, RefIdData& data, int index,
const NestedTableWrapperBase& nestedTable) const override
{
throw std::logic_error("table operation not supported");
}
NestedTableWrapperBase* nestedTable(const RefIdColumn* column, const RefIdData& data, int index) const override
{
throw std::logic_error("table operation not supported");
}
QVariant getNestedData(const RefIdColumn* column, const RefIdData& data, int index, int subRowIndex,
int subColIndex) const override
{
const Record<ESXRecordT>& record
= static_cast<const Record<ESXRecordT>&>(data.getRecord(RefIdData::LocalIndex(index, mType)));
if (mType == UniversalId::Type_CreatureLevelledList)
{
switch (subColIndex)
{
case 0:
return QVariant(); // disable the checkbox editor
case 1:
return record.get().mFlags & ESM::CreatureLevList::AllLevels;
case 2:
return static_cast<int>(record.get().mChanceNone);
default:
throw std::runtime_error("Trying to access non-existing column in levelled creatues!");
}
}
else
{
switch (subColIndex)
{
case 0:
return record.get().mFlags & ESM::ItemLevList::Each;
case 1:
return record.get().mFlags & ESM::ItemLevList::AllLevels;
case 2:
return static_cast<int>(record.get().mChanceNone);
default:
throw std::runtime_error("Trying to access non-existing column in levelled items!");
}
}
}
void setNestedData(const RefIdColumn* column, RefIdData& data, int row, const QVariant& value, int subRowIndex,
int subColIndex) const override
{
Record<ESXRecordT>& record
= static_cast<Record<ESXRecordT>&>(data.getRecord(RefIdData::LocalIndex(row, mType)));
ESXRecordT leveled = record.get();
if (mType == UniversalId::Type_CreatureLevelledList)
{
switch (subColIndex)
{
case 0:
return; // return without saving
case 1:
{
if (value.toBool())
{
leveled.mFlags |= ESM::CreatureLevList::AllLevels;
break;
}
else
{
leveled.mFlags &= ~ESM::CreatureLevList::AllLevels;
break;
}
}
case 2:
leveled.mChanceNone = static_cast<unsigned char>(value.toInt());
break;
default:
throw std::runtime_error("Trying to set non-existing column in levelled creatures!");
}
}
else
{
switch (subColIndex)
{
case 0:
{
if (value.toBool())
{
leveled.mFlags |= ESM::ItemLevList::Each;
break;
}
else
{
leveled.mFlags &= ~ESM::ItemLevList::Each;
break;
}
}
case 1:
{
if (value.toBool())
{
leveled.mFlags |= ESM::ItemLevList::AllLevels;
break;
}
else
{
leveled.mFlags &= ~ESM::ItemLevList::AllLevels;
break;
}
}
case 2:
leveled.mChanceNone = static_cast<unsigned char>(value.toInt());
break;
default:
throw std::runtime_error("Trying to set non-existing column in levelled items!");
}
}
record.setModified(leveled);
}
int getNestedColumnsCount(const RefIdColumn* column, const RefIdData& data) const override { return 3; }
int getNestedRowsCount(const RefIdColumn* column, const RefIdData& data, int index) const override
{
return 1; // fixed at size 1
}
};
// for tables
template <typename ESXRecordT>
class NestedLevListRefIdAdapter : public NestedRefIdAdapterBase
{
UniversalId::Type mType;
// not implemented
NestedLevListRefIdAdapter(const NestedLevListRefIdAdapter&);
NestedLevListRefIdAdapter& operator=(const NestedLevListRefIdAdapter&);
public:
NestedLevListRefIdAdapter(UniversalId::Type type)
: mType(type)
{
}
virtual ~NestedLevListRefIdAdapter() = default;
void addNestedRow(const RefIdColumn* column, RefIdData& data, int index, int position) const override
{
Record<ESXRecordT>& record
= static_cast<Record<ESXRecordT>&>(data.getRecord(RefIdData::LocalIndex(index, mType)));
ESXRecordT leveled = record.get();
std::vector<ESM::LevelledListBase::LevelItem>& list = leveled.mList;
ESM::LevelledListBase::LevelItem newItem;
newItem.mId = ESM::RefId();
newItem.mLevel = 0;
if (position >= (int)list.size())
list.push_back(newItem);
else
list.insert(list.begin() + position, newItem);
record.setModified(leveled);
}
void removeNestedRow(const RefIdColumn* column, RefIdData& data, int index, int rowToRemove) const override
{
Record<ESXRecordT>& record
= static_cast<Record<ESXRecordT>&>(data.getRecord(RefIdData::LocalIndex(index, mType)));
ESXRecordT leveled = record.get();
std::vector<ESM::LevelledListBase::LevelItem>& list = leveled.mList;
if (rowToRemove < 0 || rowToRemove >= static_cast<int>(list.size()))
throw std::runtime_error("index out of range");
list.erase(list.begin() + rowToRemove);
record.setModified(leveled);
}
void setNestedTable(const RefIdColumn* column, RefIdData& data, int index,
const NestedTableWrapperBase& nestedTable) const override
{
Record<ESXRecordT>& record
= static_cast<Record<ESXRecordT>&>(data.getRecord(RefIdData::LocalIndex(index, mType)));
ESXRecordT leveled = record.get();
leveled.mList
= static_cast<const NestedTableWrapper<std::vector<typename ESM::LevelledListBase::LevelItem>>&>(
nestedTable)
.mNestedTable;
record.setModified(leveled);
}
NestedTableWrapperBase* nestedTable(const RefIdColumn* column, const RefIdData& data, int index) const override
{
const Record<ESXRecordT>& record
= static_cast<const Record<ESXRecordT>&>(data.getRecord(RefIdData::LocalIndex(index, mType)));
// deleted by dtor of NestedTableStoring
return new NestedTableWrapper<std::vector<typename ESM::LevelledListBase::LevelItem>>(record.get().mList);
}
QVariant getNestedData(const RefIdColumn* column, const RefIdData& data, int index, int subRowIndex,
int subColIndex) const override
{
const Record<ESXRecordT>& record
= static_cast<const Record<ESXRecordT>&>(data.getRecord(RefIdData::LocalIndex(index, mType)));
const std::vector<ESM::LevelledListBase::LevelItem>& list = record.get().mList;
if (subRowIndex < 0 || subRowIndex >= static_cast<int>(list.size()))
throw std::runtime_error("index out of range");
const ESM::LevelledListBase::LevelItem& content = list.at(subRowIndex);
switch (subColIndex)
{
case 0:
return QString(content.mId.getRefIdString().c_str());
case 1:
return content.mLevel;
default:
throw std::runtime_error("Trying to access non-existing column in the nested table!");
}
}
void setNestedData(const RefIdColumn* column, RefIdData& data, int row, const QVariant& value, int subRowIndex,
int subColIndex) const override
{
Record<ESXRecordT>& record
= static_cast<Record<ESXRecordT>&>(data.getRecord(RefIdData::LocalIndex(row, mType)));
ESXRecordT leveled = record.get();
std::vector<ESM::LevelledListBase::LevelItem>& list = leveled.mList;
if (subRowIndex < 0 || subRowIndex >= static_cast<int>(list.size()))
throw std::runtime_error("index out of range");
switch (subColIndex)
{
case 0:
list.at(subRowIndex).mId = ESM::RefId::stringRefId(value.toString().toStdString());
break;
case 1:
list.at(subRowIndex).mLevel = static_cast<short>(value.toInt());
break;
default:
throw std::runtime_error("Trying to access non-existing column in the nested table!");
}
record.setModified(leveled);
}
int getNestedColumnsCount(const RefIdColumn* column, const RefIdData& data) const override { return 2; }
int getNestedRowsCount(const RefIdColumn* column, const RefIdData& data, int index) const override
{
const Record<ESXRecordT>& record
= static_cast<const Record<ESXRecordT>&>(data.getRecord(RefIdData::LocalIndex(index, mType)));
return static_cast<int>(record.get().mList.size());
}
};
}
#endif