DriverType.hpp

#ifndef DRIVERTYPE_HPP_INCLUDED
#define DRIVERTYPE_HPP_INCLUDED


#include <boost/algorithm/string.hpp>

#include <map>
#include <vector>
#include <string>
#include <sstream>

namespace fire {
namespace source {
namespace raster {
namespace DriverType {


enum DriverType {
  VRT = 1,
  GTiff,
  HFA,
  AAIGrid,
  GRASSASCIIGrid,
  PNG,
  JPEG,
  MEM,
  GIF,
  BIGGIF,
  XPM,
  BMP,
  XYZ,
  PDF,
  E00GRID,
  Unknown
};

inline void _getList(std::vector< DriverType >& list) {
    list.push_back(VRT);
    list.push_back(GTiff);
    list.push_back(HFA);
    list.push_back(AAIGrid);
    list.push_back(GRASSASCIIGrid);
    list.push_back(PNG);
    list.push_back(JPEG);
    list.push_back(MEM);
    list.push_back(GIF);
    list.push_back(BIGGIF);
    list.push_back(XPM);
    list.push_back(BMP);
    list.push_back(XYZ);
    list.push_back(PDF);
    list.push_back(E00GRID);
    list.push_back(Unknown);
}

inline std::string toString(DriverType const& type) {

    std::stringstream ss;
    switch (type) {
        case VRT:
            ss << "VRT";
            break;
        case GTiff:
            ss << "GTiff";
            break;
        case HFA:
            ss << "HFA";
            break;            
        case AAIGrid:            
            ss << "AAIGrid";
            break;      
        case GRASSASCIIGrid:            
            ss << "GRASSASCIIGrid";
            break;            
        case PNG:            
            ss << "PNG";
            break;            
        case JPEG:
            ss << "JPEG";
            break;          
        case MEM:            
            ss << "MEM";
            break;            
        case GIF:            
            ss << "GIF";
            break;            
        case BIGGIF:            
            ss << "BIGGIF";
            break;            
        case XPM:            
            ss << "XPM";
            break;            
        case BMP:            
            ss << "BMP";
            break;            
        case XYZ:            
            ss << "XYZ";
            break;            
        case PDF:            
            ss << "PDF";
            break;            
        case E00GRID:
            ss << "E00GRID";
            break;            
        default: 
            ss << "Unknown";
            break;
    }
    return ss.str();      
}

inline DriverType fromString(const std::string& str) {
  
    /*DriverType list[] = {
        VRT,
        GTiff,
        HFA,
        AAIGrid,
        GRASSASCIIGrid,
        PNG,
        JPEG,
        MEM,
        GIF,
        BIGGIF,
        XPM,
        BMP,
        XYZ,
        PDF,
        E00GRID,
        Unknown
    };
    int len = sizeof(list)/sizeof(DriverType);*/

    std::vector< DriverType > list;
    _getList(list);
    int len = list.size();
    for (int i = 0; i < len; i++) {
        DriverType item = list[i];
        if (toString(item) == str)
            return item;
    }

    return Unknown;
}

inline DriverType fromExtension(const std::string& extension) {
    typedef std::map< std::string, DriverType > MapDriverType;

    std::string tmpExt(extension);
    boost::to_lower(tmpExt);

    MapDriverType map;
    map[".tif"] = GTiff;
    map[".tiff"] = GTiff;
    map[".png"] = PNG;
    map[".jpg"] = JPEG;
    map[".jpeg"] = JPEG;

    MapDriverType::const_iterator it;
    it = map.find(tmpExt);
    if (it != map.end()) {
        return it->second;
    }

    return Unknown;
}

inline int getCount() {

    /*int value;
    DriverType list[] = {
        VRT,
        GTiff,
        HFA,
        AAIGrid,
        GRASSASCIIGrid,
        PNG,
        JPEG,
        MEM,
        GIF,
        BIGGIF,
        XPM,
        BMP,
        XYZ,
        PDF,
        E00GRID,
        Unknown
    };
    value = (sizeof(list)/sizeof(*list));
    return value;*/

    std::vector< DriverType > list;
    _getList(list);
    return list.size() - 1;
}

} // namespace DriverType
} // namespace raster
} // namespace source
} // namespace fire


#endif //DRIVERTYPE_HPP_INCLUDED