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

18
inc/content/typereadermanager.hpp
View File

@ -89,14 +89,14 @@ namespace xna {
//-------------------------------------------------------// //-------------------------------------------------------//
// ContentTypeReaderManager // // ContentTypeReaderManager //
//-------------------------------------------------------// //-------------------------------------------------------//
//A manager that constructs and keeps track of type reader objects.
class ContentTypeReaderManager { class ContentTypeReaderManager {
public: public:
static std::vector<PContentTypeReader> ReadTypeManifest(Int typeCount, sptr<ContentReader>& contentReader, xna_error_nullarg); static std::vector<PContentTypeReader> ReadTypeManifest(Int typeCount, sptr<ContentReader>& contentReader);
static sptr<ContentTypeReader> GetTypeReader(sptr<Type> const& targetType, sptr<ContentReader>& contentReader, xna_error_nullarg);
//Looks up a reader for the specified type.
inline sptr<ContentTypeReader> GetTypeReader(sptr<Type> const& targetType, xna_error_nullarg) { static sptr<ContentTypeReader> GetTypeReader(sptr<Type> const& targetType);
return ContentTypeReaderManager::GetTypeReader(targetType, this->contentReader, err);
}
inline static bool ContainsTypeReader(sptr<Type> const& targetType) { inline static bool ContainsTypeReader(sptr<Type> const& targetType) {
return ContentTypeReaderManager::targetTypeToReader.contains(targetType); return ContentTypeReaderManager::targetTypeToReader.contains(targetType);
@ -104,9 +104,9 @@ namespace xna {
private: private:
ContentTypeReaderManager(sptr<ContentReader>& contentReader); ContentTypeReaderManager(sptr<ContentReader>& contentReader);
static sptr<ContentTypeReader> GetTypeReader(String const& readerTypeName, sptr<ContentReader>& contentReader, std::vector<PContentTypeReader>& newTypeReaders, 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, xna_error_nullarg); static bool InstantiateTypeReader(String const& readerTypeName, sptr<ContentReader>& contentReader, sptr<ContentTypeReader>& reader);
static void AddTypeReader(String const& readerTypeName, sptr<ContentReader>& contentReader, sptr<ContentTypeReader>& reader, xna_error_nullarg); static void AddTypeReader(String const& readerTypeName, sptr<ContentReader>& contentReader, sptr<ContentTypeReader>& reader);
static void RollbackAddReaders(std::vector<sptr<ContentTypeReader>>& newTypeReaders); static void RollbackAddReaders(std::vector<sptr<ContentTypeReader>>& newTypeReaders);
static void RollbackAddReader(std::map<String, PContentTypeReader>& dictionary, sptr<ContentTypeReader>& reader); 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) 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) 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) { Tile Level::LoadTile(char tileType, int x, int y) {
@ -93,6 +93,8 @@ namespace PlatformerStarterKit {
default: default:
std::exception("Unsupported tile type character"); std::exception("Unsupported tile type character");
} }
return Tile(nullptr, TileCollision::Passable);;
} }
Tile Level::LoadTile(xna::String const& name, TileCollision collision) { Tile Level::LoadTile(xna::String const& name, TileCollision collision) {