ResourceLibrary.h

#ifndef RESOURCE_LIBRARY_H
#define RESOURCE_LIBRARY_H

#include <KrisLibrary/Logger.h>
#include "AnyCollection.h"
#include <memory>
#include <string>
#include <string.h>
#include <iostream>
#include <sstream>
#include <typeinfo>
#include <map>
#include <vector>

class TiXmlElement;

class ResourceBase
{
 public:
  ResourceBase();
  ResourceBase(const std::string& name);
  ResourceBase(const std::string& name,const std::string& fn);
  virtual ~ResourceBase() {}
  virtual bool Load(const std::string& fn);
  virtual bool Load();
  virtual bool Save(const std::string& fn);
  virtual bool Save();
  virtual bool Load(std::istream& in) { return false; }
  virtual bool Save(std::ostream& out) { return false; }
  virtual bool Load(TiXmlElement* in);
  virtual bool Save(TiXmlElement* out);
  virtual bool Load(AnyCollection& c);
  virtual bool Save(AnyCollection& c);
  virtual const char* Type() const { return typeid(*this).name(); }
  virtual ResourceBase* Make() { return new ResourceBase; }
  virtual ResourceBase* Copy() { return new ResourceBase(name,fileName); }

  std::string name,fileName;
};

typedef std::shared_ptr<ResourceBase> ResourcePtr;


class ResourceLibrary
{
 public:
  template <class T>
  void AddType();
  template <class T>
  void AddLoader(const std::string& ext);

  void Clear();
  bool SaveXml(const std::string& fn);
  bool LoadXml(const std::string& fn);
  bool Save(TiXmlElement* e);
  bool Load(TiXmlElement* e);
  bool LazyLoadXml(const std::string& fn);
  bool SaveJSON(std::ostream& s);
  bool LoadJSON(std::istream& s);
  bool LazyLoadJSON(std::istream& s);
  bool Save(AnyCollection& c);
  bool Load(AnyCollection& c);
  bool LazyLoad(AnyCollection& c);
  void AddBaseDirectory(const std::string& dir);
  void ChangeBaseDirectory(const std::string& dir);
  bool SaveAll();
  bool SaveItem(const std::string& name);
  bool LoadAll(const std::string& dir);
  bool LazyLoadAll(const std::string& dir);
  ResourcePtr LoadItem(const std::string& fn);
  bool ReloadAll();

  //accessors
  template <class T>
  T* Get(const std::string& name,int index);
  std::vector<ResourcePtr>& Get(const std::string& name);
  std::vector<ResourcePtr>& GetByType(const std::string& type);
  template <class T>
  std::vector<ResourcePtr>& GetByType();
  template <class T>
  std::vector<T*> GetPtrsByType();
  size_t Count(const std::string& name) const;
  size_t CountByType(const std::string& type) const;
  template <class T>
  size_t CountByType() const;
  std::vector<ResourcePtr> Enumerate() const;

  //modifiers
  void Add(const ResourcePtr& resource);
  bool Erase(const ResourcePtr& resource);
  bool Erase(const std::string& name,int index=-1);

  //helpers
  std::string DefaultFileName(const ResourcePtr& r);

  typedef std::map<std::string,std::vector<ResourcePtr> > Map;
  Map knownTypes;
  Map loaders;
  Map itemsByName,itemsByType;
};


template <class T>
std::vector<T*> ResourcesByType(std::vector<ResourcePtr>& resources)
{
  std::vector<T*> rtype;
  for(size_t i=0;i<resources.size();i++) {
    T* ptr = dynamic_cast<T*>(resources[i].get());
    if(ptr) rtype.push_back(ptr);
  }
  return rtype;
}

std::vector<ResourcePtr> ResourcesByType(std::vector<ResourcePtr>& resources,const std::string& type);

std::vector<std::string> ResourceTypes(const std::vector<ResourcePtr>& resources);



template <class T>
const char* BasicResourceTypeName() { return typeid(T).name(); }

template <class T>
class BasicResource : public ResourceBase
{
 public:
  BasicResource() {}
  BasicResource(const T& val) : data(val) {}
  BasicResource(const T& val,const std::string& name) : ResourceBase(name),data(val) {}
  BasicResource(const T& val,const std::string& name,const std::string& fileName) : ResourceBase(name,fileName),data(val) {}
  virtual ~BasicResource() {}
  virtual bool Load(std::istream& in) {
    in>>data;
    if(in.bad()) {
      return false;
    }
    return true;
  }
  virtual bool Save(std::ostream& out) {
    out<<data<<std::endl;
    return true;
  }
  virtual bool Load(const std::string& fn) { return ResourceBase::Load(fn); }
  virtual bool Load() { return ResourceBase::Load(); }
  virtual bool Save(const std::string& fn) { return ResourceBase::Save(fn); }
  virtual bool Save() { return ResourceBase::Save(); }
  virtual const char* Type() const { return BasicResourceTypeName<T>(); }
  virtual ResourceBase* Make() { return new BasicResource<T>; }
  virtual ResourceBase* Copy() { return new BasicResource<T>(data,name,fileName); }

  T data;
};

template <> const char* BasicResourceTypeName<int>();
template <> const char* BasicResourceTypeName<double>();
template <> const char* BasicResourceTypeName<std::string>();
typedef BasicResource<int> IntResource;
typedef BasicResource<double> FloatResource;
typedef BasicResource<std::string> StringResource;


class CompoundResourceBase : public ResourceBase
{
 public:
  CompoundResourceBase() {}
  CompoundResourceBase(const std::string& name) : ResourceBase(name) {}
  CompoundResourceBase(const std::string& name,const std::string& fileName) : ResourceBase(name,fileName) {}
  virtual ~CompoundResourceBase() {}

  virtual std::vector<std::string> CastTypes() const { return std::vector<std::string>(); }
  virtual std::vector<std::string> ExtractTypes() const { return SubTypes(); }
  virtual std::vector<std::string> SubTypes() const { return std::vector<std::string>(); }

  virtual ResourcePtr Cast(const char* type) { return NULL; }

  virtual bool Extract(const char* subtype,std::vector<ResourcePtr>& subobjects);

  virtual bool Pack(std::vector<ResourcePtr>& subobjects,std::string* errorMessage=NULL) { if(errorMessage) *errorMessage = std::string(Type())+"::Pack not implemented"; return false; }

  virtual bool Unpack(std::vector<ResourcePtr>& subobjects,bool* incomplete=NULL) { return false; }
};

template <class T>
class BasicArrayResource : public CompoundResourceBase
{
 public:
  typedef BasicResource<T> BaseType;
  BasicArrayResource() {}
  BasicArrayResource(const std::vector<T>& val) : data(val) {}
  BasicArrayResource(const std::vector<T>& val,const std::string& name) : CompoundResourceBase(name),data(val) {}
  BasicArrayResource(const std::vector<T>& val,const std::string& name,const std::string& fileName) : CompoundResourceBase(name,fileName),data(val) {}
  virtual ~BasicArrayResource() {}
  virtual bool Load(std::istream& in) {
    size_t n;
    in>>n;
    if(in.bad()) return false;
    data.resize(n);
    for(size_t i=0;i<n;i++) {
      in>>data[i];
      if(in.bad()) return false; 
    }
    return true;
  }
  virtual bool Save(std::ostream& out) {
    out<<data.size()<<'\t';
    for(size_t i=0;i<data.size();i++) {
      out<<data[i];
      if(i+1!=data.size()) out<<" ";
    }
    out<<std::endl;
    return true;
  }
  virtual bool Load(const std::string& fn) { return ResourceBase::Load(fn); }
  virtual bool Load() { return ResourceBase::Load(); }
  virtual bool Save(const std::string& fn) { return ResourceBase::Save(fn); }
  virtual bool Save() { return ResourceBase::Save(); }
  virtual bool Load(AnyCollection& c) { return c["data"].asvector(data); }
  virtual bool Save(AnyCollection& c) { c["data"] = data; return true;}
  virtual const char* Type() const { return BasicResourceTypeName<std::vector<T> >(); }
  virtual ResourceBase* Make() { return new BasicArrayResource<T>; }
  virtual ResourceBase* Copy() { return new BasicArrayResource<T>(data,name,fileName); }

  //CompoundResourceBase methods
  virtual std::vector<std::string> SubTypes() const { return std::vector<std::string>(1,BasicResourceTypeName<T>()); }
  virtual bool Extract(const char* subtype,std::vector<ResourcePtr>& subobjects) {
    if(0==strcmp(subtype,BasicResourceTypeName<T>()))
      return Unpack(subobjects);
    return false;
  }
  virtual bool Pack(std::vector<ResourcePtr>& subobjects,std::string* errorMessage=NULL) {
    for(size_t i=0;i<subobjects.size();i++)
      if(typeid(*subobjects[i]) != typeid(BaseType)) {
        if(errorMessage) *errorMessage = std::string("Subobject does not have type ")+std::string(BasicResourceTypeName<T>());
        return false;
      }
    data.resize(subobjects.size());
    for(size_t i=0;i<subobjects.size();i++)    
      data[i] = dynamic_cast<BaseType*>(&*subobjects[i])->data;
    return true;
  }
  virtual bool Unpack(std::vector<ResourcePtr>& subobjects,bool* incomplete=NULL) {
    subobjects.resize(data.size());
    for(size_t i=0;i<data.size();i++) {
      subobjects[i] = std::make_shared<BaseType>(data[i]);
      std::stringstream ss;
      ss<<"data["<<i<<"]";
      subobjects[i]->name = ss.str();
    }
    return true;
  }

  std::vector<T> data;
};

template <> const char* BasicResourceTypeName<std::vector<int> >();
template <> const char* BasicResourceTypeName<std::vector<double> >();
template <> const char* BasicResourceTypeName<std::vector<std::string> >();
typedef BasicArrayResource<int> IntArrayResource;
typedef BasicArrayResource<double> FloatArrayResource;
typedef BasicArrayResource<std::string> StringArrayResource;


class ResourceLibraryResource : public CompoundResourceBase
{
 public:
  virtual bool Load(const std::string& fn);
  virtual bool Save(const std::string& fn);
  virtual bool Load(AnyCollection& c);
  virtual bool Save(AnyCollection& c);
  virtual const char* Type() const { return "ResourceLibrary"; }
  virtual ResourceBase* Make() { return new ResourceLibraryResource; }
  virtual ResourceBase* Copy();
  virtual std::vector<std::string> SubTypes() const;
  virtual bool Extract(const char* subtype,std::vector<ResourcePtr>& subobjects);
  virtual bool Pack(std::vector<ResourcePtr>& subobjects,std::string* errorMessage=NULL);
  virtual bool Unpack(std::vector<ResourcePtr>& subobjects,bool* incomplete=NULL);

  ResourceLibrary library;
};

template <class T>
void ResourceLibrary::AddType()
{
  ResourcePtr res(new T);
  if(knownTypes.count(res->Type()) == 0) {
    knownTypes[res->Type()].push_back(res);
  }
  else {
    //potential conflict? check raw string
    if(knownTypes[res->Type()][0]->Type() != res->Type())
            LOG4CXX_ERROR(KrisLibrary::logger(),"ResourceLibrary: Potential conflict with type "<<res->Type());
    knownTypes[res->Type()][0] = res;
  }
}

template <class T>
void ResourceLibrary::AddLoader(const std::string& ext)
{
  AddType<T>();
  ResourcePtr res(new T);
  loaders[ext].push_back(res);
}

template <class T>
T* ResourceLibrary::Get(const std::string& name,int index)
{
  std::vector<ResourcePtr>& items=Get(name);
  if(index < 0 || index > (int)items.size()) return NULL;
  return dynamic_cast<T*>(items[index].get());
}

template <class T>
std::vector<ResourcePtr>& ResourceLibrary::GetByType()
{
  T temp;
  return GetByType(temp.Type());
}

template <class T>
std::vector<T*> ResourceLibrary::GetPtrsByType()
{
  std::vector<ResourcePtr>& items = GetByType<T>();
  std::vector<T*> cast_items(items.size());
  for(size_t i=0;i<items.size();i++)
    cast_items[i] = dynamic_cast<T*>(items[i].get());
  return cast_items;
}

template <class T>
size_t ResourceLibrary::CountByType() const
{
  T temp;
  return CountByType(temp.Type());
}

#endif