ResourceContainer.h

Go to the documentation of this file.

#pragma once

//#include "swCommonLib/Common/System/Path.h"

#include <map>
#include <vector>
#include <type_traits>

#include "swGraphicAPI/Resources/ResourcePtr.h"


template < class TYPE >
class ResourceContainer
{
    friend class AssetsManager;
    friend class ResourceManager;
private:
    unsigned int count;     

protected:
    std::map<std::wstring, TYPE*> container;    

    // Kasowanie obiektów
    int     ForceRemove         ( const std::wstring& name );
    int     ForceRemove         ( unsigned int id );
    void    ForceRemoveAll      ();
    void    ReleaseMemory       ( TYPE* );
public:
    ResourceContainer();
    ~ResourceContainer();

    // Kasowanie obiektów
    int     Remove              ( const std::wstring& name );
    int     Remove              ( unsigned int id );
    int     RemoveUnused        ();

    // Dodawanie obiektów
    void    UnsafeAdd           ( const std::wstring& name, TYPE* resource );

    // Dostęp do obiektów
    TYPE*   get                 ( unsigned int id );
    inline unsigned int         GetNextId() { return count; }   

    inline TYPE* get( const std::wstring& name )
    {
        auto iter = container.find( name );
        if ( iter != container.end() )
            return iter->second;
        return nullptr;
    }

    template< typename DescType >
    TYPE*   Find                ( const DescType& desc );

    // Listowanie obiektów.
    std::vector< ResourcePtr< TYPE > >      List();
};

template <class TYPE>
ResourceContainer<TYPE>::ResourceContainer()
{
    count = 1;
}

template <class TYPE>
ResourceContainer<TYPE>::~ResourceContainer( )
{
    for ( auto iter = container.begin( ); iter != container.end( ); iter++ )
    {
        ReleaseMemory( iter->second );
    }
    container.clear();
}

template <class TYPE>
TYPE*           ResourceContainer<TYPE>::get    ( unsigned int id )
{
    for ( auto iter = container.begin(); iter != container.end(); iter++ )
    {
        if ( iter->second->GetID() == id )
            return iter->second;
    }
    return nullptr;
}

// ================================ //
//
template< class TYPE >
template< typename DescType >
inline TYPE*    ResourceContainer< TYPE >::Find ( const DescType& desc )
{
    static_assert( std::is_member_function_pointer< decltype( &TYPE::GetDescriptor ) >::value, "TYPE must implement GetDescriptor function." );

    for( auto& resource : container )
    {
        if( resource.second->GetDescriptor() == desc )
            return resource.second;
    }
    return nullptr;
}


//-------------------------------------------------------------------------------//
//                          dodawanie obiektów
//-------------------------------------------------------------------------------//

/*Dodaje element do kontanera + nadaje mu unikalny identyfikator.
Jeżeli element już istniał, to po prostu nie zostanie wstawiony, dlatego
przed uzyciem warto pobrać element o danej nazwie, żeby sprawdzić
czy dodawanie jest konieczne.*/
// Może kiedyś zrobie wstawianie ze sprawdzaniem, na razie nie wydaje się potrzebne


template <class TYPE>
void ResourceContainer<TYPE>::UnsafeAdd( const std::wstring& name, TYPE* resource )
{
    if ( !resource )
        return; //Nie możemy potem ustawić id

    container[name] = resource;

    resource->SetID( count );
    ++count;            // Inkrementujemy licznik
}

//-------------------------------------------------------------------------------//
//                          kasowanie obiektów
//-------------------------------------------------------------------------------//
template <class TYPE>
void ResourceContainer<TYPE>::ReleaseMemory( TYPE* object )
{
    // Destruktor jest prywatny, więc nie możemy kasować obiektu bezpośrednio.
    ObjectDeleterKey<TYPE> key;                         // Tworzymy klucz.
    ObjectDeleter<TYPE> model_deleter( key );           // Tworzymy obiekt kasujący i podajemy mu nasz klucz.
    model_deleter.delete_object( object );              // Kasujemy obiekt za pośrednictwem klucza.
}

template <class TYPE>
int ResourceContainer<TYPE>::Remove( const std::wstring& name )
{
    auto iter = container.find( name );
    if ( iter != container.end() )
        return -1;      // Nie znaleźliśmy elementu

    if ( !iter->second->CanDelete() )
        return 1;       // Nie możemy skasować, bo są odwołania

    ReleaseMemory( iter->second );      // Zwalniamy pamięć spod wskaźnika
    container.erase( iter );    // Kasujemy element z mapy

    return 0;           // Wychodzimy z powodzeniem
}


template <class TYPE>
int ResourceContainer<TYPE>::Remove( unsigned int id )
{
    for ( auto iter = container.begin( ); iter != container.end( ); iter++ )
    {
        if ( iter->second->GetID() == id )
        {
            // Sprawdzamy czy nie ma jakichś odwołań do obiektu
            if ( !iter->second->CanDelete() )
                return 1;               // Są odwołania, więc nie kasujemy

            ReleaseMemory( iter->second );      // Zwalniamy pamięć spod wskaźnika
            container.erase( iter );    // Kasujemy element z mapy

            return 0;                   // Zwracamy 0 jako powodzenie operacji
        }
    }
    return -1;      // Nie znaleźliśmy elementu
}

template <class TYPE>
int ResourceContainer<TYPE>::RemoveUnused()
{
    int count = 0;
    for ( auto iter = container.begin(); iter != container.end(); iter++ )
    {// Iterujemy po całej mapie
        if ( iter->second->CanDelete() )
        {
            // Możemy skasować obiekt, bo nikt go nie używa
            ReleaseMemory( iter->second );      // Zwalniamy pamięć spod wskaźnika
            container.erase( iter );    // Kasujemy element z mapy

            ++count;
        }
    }

    return count;
}


template <class TYPE>
int ResourceContainer<TYPE>::ForceRemove( const std::wstring& name )
{
    auto iter = container.find( name );
    if ( iter != container.end( ) )
        return -1;      // Nie znaleźliśmy elementu

    delete iter->second;        // Zwalniamy pamięć spod wskaźnika
    return 0;
}

template <class TYPE>
int ResourceContainer<TYPE>::ForceRemove( unsigned int id )
{
    for ( auto iter = container.begin( ); iter != container.end( ); iter++ )
    {
        if ( iter->second->GetID( ) == id )
        {
            delete iter->second;        // Zwalniamy pamięć spod wskaźnika
            return 0;
        }
    }
    return -1;      // Nie znaleziono elementu
}

template <class TYPE>
void ResourceContainer<TYPE>::ForceRemoveAll( )
{
    for ( auto iter = container.begin(); iter != container.end(); iter++ )
    {// Iterujemy po całej mapie
        delete iter->second;        // Zwalniamy pamięć spod wskaźnika
    }
    container.clear();
}

template< class TYPE >
inline std::vector< ResourcePtr< TYPE > > ResourceContainer< TYPE >::List()
{
    std::vector< ResourcePtr< TYPE > > resourcesList;
    resourcesList.reserve( container.size() );

    for( auto iter = container.begin(); iter != container.end(); iter++ )
    {
        resourcesList.push_back( ResourcePtr< TYPE >( iter->second ) );
    }

    return resourcesList;
}