backup/xn65
1
0
Fork 0
mirror of https://github.com/borgesdan/xn65 synced 2024-12-29 21:54:47 +01:00
Code Issues Projects Releases Activity

Remove XnaErrorCode em ContentTypeReaderManager

Browse Source
This commit is contained in:
Danilo 2024-06-03 21:15:20 -03:00
parent 3d81be8066
commit a0c5d31b12
3 changed files with 25 additions and 32 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
framework/content/typereadermanager.cpp
View File

@ -33,7 +33,7 @@ namespace xna {
activators.insert({ hash, activador });
}
std::vector<PContentTypeReader> ContentTypeReaderManager::ReadTypeManifest(Int typeCount, sptr<ContentReader>& contentReader, xna_error_ptr_arg)
std::vector<PContentTypeReader> ContentTypeReaderManager::ReadTypeManifest(Int typeCount, sptr<ContentReader>& contentReader)
{
initMaps();
@ -48,8 +48,7 @@ namespace xna {
auto typeReader = ContentTypeReaderManager::GetTypeReader(xnaType.empty() ? readerTypeName : xnaType, contentReader, newTypeReaders);
if (contentReader->ReadInt32() != typeReader->TypeVersion()) {
xna_error_apply(err, XnaErrorCode::BAD_TYPE);
if (contentReader->ReadInt32() != typeReader->TypeVersion()) {
ContentTypeReaderManager::RollbackAddReaders(newTypeReaders);
return std::vector<PContentTypeReader>();
}
@ -69,11 +68,10 @@ namespace xna {
return contentTypeReaderArray;
}
sptr<ContentTypeReader> ContentTypeReaderManager::GetTypeReader(sptr<Type> const& targetType, sptr<ContentReader>& contentReader, xna_error_ptr_arg)
sptr<ContentTypeReader> ContentTypeReaderManager::GetTypeReader(sptr<Type> const& targetType)
{
if (!targetType) {
xna_error_apply(err, XnaErrorCode::ARGUMENT_IS_NULL);
return nullptr;
throw std::invalid_argument("ContentTypeReaderManager::GetTypeReader: targetType is null.");
}
for (auto const& item : ContentTypeReaderManager::targetTypeToReader) {
@ -91,30 +89,25 @@ namespace xna {
initMaps();
}
sptr<ContentTypeReader> ContentTypeReaderManager::GetTypeReader(String const& readerTypeName, sptr<ContentReader>& contentReader, std::vector<PContentTypeReader>& newTypeReaders, xna_error_ptr_arg)
sptr<ContentTypeReader> ContentTypeReaderManager::GetTypeReader(String const& readerTypeName, sptr<ContentReader>& contentReader, std::vector<PContentTypeReader>& newTypeReaders)
{
sptr<ContentTypeReader> reader = nullptr;
if (ContentTypeReaderManager::nameToReader.contains(readerTypeName)) {
return ContentTypeReaderManager::nameToReader[readerTypeName];
}
else if (!ContentTypeReaderManager::InstantiateTypeReader(readerTypeName, contentReader, reader, err)) {
else if (!ContentTypeReaderManager::InstantiateTypeReader(readerTypeName, contentReader, reader)) {
return reader;
}
}
if (xna_error_haserros(err))
return nullptr;
ContentTypeReaderManager::AddTypeReader(readerTypeName, contentReader, reader, err);
if (xna_error_haserros(err)) return nullptr;
ContentTypeReaderManager::AddTypeReader(readerTypeName, contentReader, reader);
newTypeReaders.push_back(reader);
return reader;
}
bool ContentTypeReaderManager::InstantiateTypeReader(String const& readerTypeName, sptr<ContentReader>& contentReader, sptr<ContentTypeReader>& reader, xna_error_ptr_arg)
bool ContentTypeReaderManager::InstantiateTypeReader(String const& readerTypeName, sptr<ContentReader>& contentReader, sptr<ContentTypeReader>& reader)
{
sptr<Type> type = nullptr;
@ -122,8 +115,7 @@ namespace xna {
type = Type::NameOfRegisteredTypes[readerTypeName];
if (!type) {
xna_error_apply(err, XnaErrorCode::INVALID_OPERATION);
return false;
throw std::runtime_error("ContentTypeReaderManager::InstantiateTypeReader: registered type is null.");
}
if (ContentTypeReaderManager::readerTypeToReader.contains(type)) {
@ -136,12 +128,11 @@ namespace xna {
return true;
}
void ContentTypeReaderManager::AddTypeReader(String const& readerTypeName, sptr<ContentReader>& contentReader, sptr<ContentTypeReader>& reader, xna_error_ptr_arg)
void ContentTypeReaderManager::AddTypeReader(String const& readerTypeName, sptr<ContentReader>& contentReader, sptr<ContentTypeReader>& reader)
{
auto targetType = reader->TargetType();
if (ContentTypeReaderManager::targetTypeToReader.contains(targetType)) {
xna_error_apply(err, XnaErrorCode::INVALID_OPERATION);
return;
}
@ -156,7 +147,7 @@ namespace xna {
return;
for (size_t i = 0; i < newTypeReaders.size(); ++i) {
auto newTypeReader = newTypeReaders[i];
auto& newTypeReader = newTypeReaders[i];
ContentTypeReaderManager::RollbackAddReader(ContentTypeReaderManager::nameToReader, newTypeReader);
ContentTypeReaderManager::RollbackAddReader(ContentTypeReaderManager::targetTypeToReader, newTypeReader);
ContentTypeReaderManager::RollbackAddReader(ContentTypeReaderManager::readerTypeToReader, newTypeReader);

18
inc/content/typereadermanager.hpp
View File

@ -89,14 +89,14 @@ namespace xna {
//-------------------------------------------------------//
// ContentTypeReaderManager //
//-------------------------------------------------------//
//A manager that constructs and keeps track of type reader objects.
class ContentTypeReaderManager {
public:
static std::vector<PContentTypeReader> ReadTypeManifest(Int typeCount, sptr<ContentReader>& contentReader, xna_error_nullarg);
static sptr<ContentTypeReader> GetTypeReader(sptr<Type> const& targetType, sptr<ContentReader>& contentReader, xna_error_nullarg);
inline sptr<ContentTypeReader> GetTypeReader(sptr<Type> const& targetType, xna_error_nullarg) {
return ContentTypeReaderManager::GetTypeReader(targetType, this->contentReader, err);
}
static std::vector<PContentTypeReader> ReadTypeManifest(Int typeCount, sptr<ContentReader>& contentReader);
//Looks up a reader for the specified type.
static sptr<ContentTypeReader> GetTypeReader(sptr<Type> const& targetType);
inline static bool ContainsTypeReader(sptr<Type> const& targetType) {
return ContentTypeReaderManager::targetTypeToReader.contains(targetType);
@ -104,9 +104,9 @@ namespace xna {
private:
ContentTypeReaderManager(sptr<ContentReader>& contentReader);
static sptr<ContentTypeReader> GetTypeReader(String const& readerTypeName, sptr<ContentReader>& contentReader, std::vector<PContentTypeReader>& newTypeReaders, xna_error_nullarg);
static bool InstantiateTypeReader(String const& readerTypeName, sptr<ContentReader>& contentReader, sptr<ContentTypeReader>& reader, xna_error_nullarg);
static void AddTypeReader(String const& readerTypeName, sptr<ContentReader>& contentReader, sptr<ContentTypeReader>& reader, xna_error_nullarg);
static sptr<ContentTypeReader> GetTypeReader(String const& readerTypeName, sptr<ContentReader>& contentReader, std::vector<PContentTypeReader>& newTypeReaders);
static bool InstantiateTypeReader(String const& readerTypeName, sptr<ContentReader>& contentReader, sptr<ContentTypeReader>& reader);
static void AddTypeReader(String const& readerTypeName, sptr<ContentReader>& contentReader, sptr<ContentTypeReader>& reader);
static void RollbackAddReaders(std::vector<sptr<ContentTypeReader>>& newTypeReaders);
static void RollbackAddReader(std::map<String, PContentTypeReader>& dictionary, sptr<ContentTypeReader>& reader);

6
samples/02_PlatfformerStarterKit/level.cpp
View File

@ -59,9 +59,9 @@ namespace PlatformerStarterKit {
}
if (!player)
std::exception("A level must have a starting point.");
throw std::runtime_error("A level must have a starting point.");
if (exit == InvalidPosition)
std::exception("A level must have an exit.");
throw std::runtime_error("A level must have an exit.");
}
Tile Level::LoadTile(char tileType, int x, int y) {
@ -93,6 +93,8 @@ namespace PlatformerStarterKit {
default:
std::exception("Unsupported tile type character");
}
return Tile(nullptr, TileCollision::Passable);;
}
Tile Level::LoadTile(xna::String const& name, TileCollision collision) {