source: orxonox.OLD/branches/new_class_id/src/lib/util/loading/resource.h @ 9791

/*!
 * @file resource.h
 * @brief Definition of a NewResource.
*/

#ifndef _RESOURCE_H
#define _RESOURCE_H

#include "base_object.h"
#include <string>
#include <vector>
#include <set>

#include "filesys/directory.h"

namespace Resources
{
  class KeepLevel
  {
  public:
    KeepLevel(unsigned int keepLevel) { _keepLevel = keepLevel; };
    KeepLevel(const std::string& keepLevelName);

    static void defineKeepLevelName(unsigned int level, const std::string& name);
  private:
    unsigned int                        _keepLevel;
  private:
    static std::vector<std::string>     _keepLevelNames;
  };

  class StorePointer
  {
    public:
      StorePointer(const std::string& loadString, const Resources::KeepLevel& keeplevel);
      const std::string& loadString() const { return _loadString; };
      const Resources::KeepLevel& keepLevel() const { return _keepLevel; };

    private:
      std::string                 _loadString;             //!< An identifier, to match when loading a File.
      Resources::KeepLevel        _keepLevel;              //!< The Priority of this resource. (can only be increased, so none else will delete this)
  };

  class Type
  {
  public:
    Type(const ClassID& classID);
    bool operator==(const ClassID& classID) const { return this->_classID == classID; };
    bool operator==(const std::string& resourceName) const { return this->_classID.name() == resourceName; };

    void addExtension(const std::string& extension);

    bool addResourcePath(const std::string& path);
    bool addResourceSubPath(const std::string& subPath);

    /// Retrieve Functions
    const ClassID& storedClassID() const { return _classID; };
    int id() const { return _id; };
    const std::vector<Directory>& resourcePaths() const { return _resourcePaths; };
    const std::vector<Directory>& resourceSubPaths() const { return _resourceSubPaths; };
    const std::vector<Resources::StorePointer*>& storedResources() const { return _storedResources; };

    void setID(int id);
    void addResource(Resources::StorePointer* resource);

  private:
    int                             _id;
    const ClassID&                  _classID;
    std::vector<Directory>          _resourcePaths;
    std::vector<Directory>          _resourceSubPaths;
    std::vector<std::string>        _fileExtensions;

    std::vector<Resources::StorePointer*> _storedResources;
  };
}

//! A NewResource is an Object, that can be loaded from Disk
/**
 *
 */
class NewResource : virtual public BaseObject
{
  ObjectListDeclaration(NewResource);

public:
  NewResource(Resources::Type* type);
  virtual ~NewResource();

  virtual bool reload() { return false; };
  virtual bool unload() { return false; };

  std::string locateFile(const std::string& fileName) const;


public:
protected:
  Resources::StorePointer* acquireResource(const std::string& loadString);
  void addResource(Resources::StorePointer* pointer);

private:
  std::string locateFileInSubDir(const Directory& directory, const std::string& fileName) const;

private:
  Resources::StorePointer*       _pointer;                         //!< Virtual Pointer to the ResourceData.
  Resources::Type*               _type;                            //!< Type of the NewResource.
};

#endif /* _RESOURCE_H */