CeylanBasicResourceManager.h

Go to the documentation of this file.

/* 
 * Copyright (C) 2003-2009 Olivier Boudeville
 *
 * This file is part of the Ceylan library.
 *
 * The Ceylan library is free software: you can redistribute it and/or modify
 * it under the terms of either the GNU Lesser General Public License or
 * the GNU General Public License, as they are published by the Free Software
 * Foundation, either version 3 of these Licenses, or (at your option) 
 * any later version.
 *
 * The Ceylan library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Lesser General Public License and the GNU General Public License
 * for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License and the GNU General Public License along with the Ceylan library.
 * If not, see <http://www.gnu.org/licenses/>.
 *
 * Author: Olivier Boudeville (olivier.boudeville@esperide.com)
 *
 */


#ifndef CEYLAN_BASIC_RESOURCE_MANAGER_H_
#define CEYLAN_BASIC_RESOURCE_MANAGER_H_


#include "CeylanResourceManager.h"  // for inheritance

#include "CeylanResource.h"         // for Ceylan::Resource

#include "CeylanStringUtils.h"      // for Ceylan::formatStringList
#include "CeylanSystem.h"           // for Ceylan::System::Size
#include "CeylanOperators.h"        // for string operations


#include <map>
#include <list>
#include <string>
#include <iostream>                 // for ostringstream



namespace Ceylan
{


    
    template <typename Key>
    class BasicResourceManager : public Ceylan::ResourceManager<Key>
    {
    
    
        public:
        
            
            explicit BasicResourceManager() ;
  
  
 
            virtual ~BasicResourceManager() throw() ;
    
        
        
            virtual void takeOwnershipOf( const Key & key, 
                const Resource & resource ) ;
            
            
            
            virtual bool isKeyAlreadyAssociated( const Key & key ) const ;
            
            
            
             virtual const Resource * get( const Key & key ) ;
                                    
             
             
            virtual void flush() ;
                        
            
            
             virtual const std::string toString( 
                Ceylan::VerbosityLevels level = Ceylan::high ) const ;

            
            
            
        protected:
        
                    
/* 
 * Takes care of the awful issue of Windows DLL with templates.
 *
 * @see Ceylan's developer guide and README-build-for-windows.txt 
 * to understand it, and to be aware of the associated risks. 
 * 
 */
#pragma warning( push )
#pragma warning( disable : 4251 )

            std::map<Key, const Resource *> _entries ;

#pragma warning( pop )          


        private:
        
        
        
            BasicResourceManager( const BasicResourceManager & source ) ;
            
            
            BasicResourceManager & operator = ( 
                const BasicResourceManager & source ) ;
            
            
    } ;




    // Public section: implementation.


    template <typename Key>
    BasicResourceManager<Key>::BasicResourceManager() :
        ResourceManager<Key>(),
        _entries()
    {
    
    }   


                
    template <typename Key>
    BasicResourceManager<Key>::~BasicResourceManager() throw()
    {
    
        flush() ; 
        
    }   
            
            
        
    template <typename Key>
    void BasicResourceManager<Key>::takeOwnershipOf( const Key & key, 
        const Resource & resource )     
    {

        // Look-up any previous entry:
        typename std::map<Key, const Resource *>::const_iterator it =
            _entries.find( key ) ;
            
        if ( it != _entries.end() )
        {
            /*
             * Key type not known, using streams to get as much information as
             * possible:
             *
             */
            std::ostringstream os ;
            os << key ;
            throw ResourceManagerException(
                "BasicResourceManager<Key>::takeOwnershipOf: key '"
                + os.str() + "' already associated with ressource '" 
                + resource.toString() + "'." ) ;
        }   
            
        _entries[ key ] = & resource ;
                
    }



    template <typename Key>
    bool BasicResourceManager<Key>::isKeyAlreadyAssociated( const Key & key )
        const
    {

        // Look-up any previous entry:
        return ( _entries.find( key ) != _entries.end() ) ;

    }
    


    template <typename Key>
    const Resource * BasicResourceManager<Key>::get( const Key & key )
    {
    
        typename std::map<Key, const Resource *>::const_iterator it =
            _entries.find( key ) ;
            
        if ( it != _entries.end() )
        {
            this->_cacheHits++ ;
            return (*it).second ;
        }
        else
        {
            this->_cacheMisses++ ;
            return 0 ;
        }   
        
    }

    
    
    template <typename Key>
    void BasicResourceManager<Key>::flush()
    {
    
        for ( typename std::map<Key, const Resource *>::const_iterator it =
            _entries.begin(); it != _entries.end(); it++ )
        {
            delete (*it).second ;
        }
        
        _entries.clear() ;
        
    }
    
    

    template <typename Key>
    const std::string BasicResourceManager<Key>::toString( 
        VerbosityLevels level ) const
    {
        
        std::string res = "Basic Resource manager currently managing " ;
                
        System::Size resourceCount = _entries.size() ;
        
        if ( resourceCount == 0 )
            res += "no resource" ;
        else    
            res += Ceylan::toString( 
                static_cast<Ceylan::Uint32>( resourceCount ) ) 
                + " resource(s)" ;
                
        if ( level == Ceylan::low ) 
            return res ;

                    
        Ceylan::Uint32 total = this->_cacheHits + this->_cacheMisses ;
        
        if ( total == 0 )
            res += ". No resource request processed for the moment" ;   
        else
            res += ". The average cache success is " 
                + Ceylan::toNumericalString( static_cast<Ceylan::Uint8>( 
                    ( 100.0f * this->_cacheHits ) / total ) )
                + "% (" + Ceylan::toString( this->_cacheHits ) 
                + " cache hit(s) for " 
                + Ceylan::toString( this->_cacheMisses ) + " cache miss(es))" ;


        if ( level == Ceylan::medium )  
            return res ;
        
        if ( resourceCount == 0 )
            return res ;
            
        res += ". Displaying current cached entrie(s): " ;
        
        Ceylan::Uint32 count = 0 ;
        std::list<std::string> entries ;
            
        for ( typename std::map<Key, const Resource *>::const_iterator it =
            _entries.begin(); it != _entries.end(); it++ )
        {
        
            count++ ;
            entries.push_back( "[Entry #" + Ceylan::toString( count ) 
                + "] resource description = '"  
                + (*it).second->toString( Ceylan::low ) + "'" ) ; 
                
        }   
        
        return res + Ceylan::formatStringList( entries ) ;
        
    }
    
    
}



#endif // CEYLAN_BASIC_RESOURCE_MANAGER_H_

---