Config.h

/*
 * Copyright (c) 2018, Stefan Osswald
 * All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 * 
 * * Redistributions of source code must retain the above copyright notice, this
 *   list of conditions and the following disclaimer.
 * 
 * * Redistributions in binary form must reproduce the above copyright notice,
 *   this list of conditions and the following disclaimer in the documentation
 *   and/or other materials provided with the distribution.
 * 
 * * Neither the name of the copyright holder nor the names of its
 *   contributors may be used to endorse or promote products derived from
 *   this software without specific prior written permission.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */ 

#ifndef INCLUDE_ARTICULATION_CONFIG_H_
#define INCLUDE_ARTICULATION_CONFIG_H_

#include <string>
#include <iostream>
#include <stdexcept>
#include <map>
#include <vector>
#if __ANDROID__
#include <android/asset_manager.h>
#include <android/asset_manager_jni.h>
#endif

namespace gpu_coverage {

class Config {
public:
    enum PanoOutputValue {
        IMAGE_STRIP_HORIZONTAL,
        IMAGE_STRIP_VERTICAL,  
        CUBE,                  
        EQUIRECTANGULAR,       
        CYLINDRICAL            
    };

protected:
    Config(const std::string& filename);
    virtual ~Config();

    const std::string filename; 

    struct AbstractParam {
        const std::string name;            
        const std::string description;     

        friend std::ostream& operator<<(std::ostream& os, AbstractParam& param);

        friend std::istream& operator>>(std::istream& is, AbstractParam& param);

        virtual void write(std::ostream& os) const = 0;

        virtual void read(std::istream& is) = 0;
        AbstractParam(const std::string& name, const std::string& description)
                : name(name), description(description) {
        }
        virtual ~AbstractParam() {
        }
    };
    friend std::ostream& operator<<(std::ostream& os, AbstractParam& param);
    friend std::istream& operator>>(std::istream& is, AbstractParam& param);

    template<class T>
    struct Param: public AbstractParam {
        T dflt;       
        T value;      

        Param(const std::string& name, const std::string& description, const T& dflt)
                : AbstractParam(name, description), dflt(dflt), value(dflt) {
        }

        virtual ~Param() {
        }

        virtual void write(std::ostream& os) const;

        virtual void read(std::istream& is) throw (std::invalid_argument);
    };

    typedef std::map<std::string, AbstractParam *> Params;   
    Params params;                                           
    static Config *instance;                                 

#if __ANDROID__
    static AAssetManager *apkAssetManager;                   
#endif

public:
#if __ANDROID__

    static void setAssetManager(AAssetManager *manager) {
        apkAssetManager = manager;
    }
    static AAssetManager * getAssetManager() {
        return apkAssetManager;
    }
#endif

    static inline Config &getInstance() {
        return *instance;
    }

    static void init(const int argc, const char * const argv[]);

    void save() const;

    void load();

    template<class T>
    T getParam(const std::string& name) const {
        Params::const_iterator paramIt = params.find(name);
        if (paramIt == params.end()) {
            throw std::invalid_argument(std::string("Parameter ") + name + " not found");
        }
        const Param<T> * const bp = dynamic_cast<Param<T>*>(paramIt->second);
        if (!bp) {
            throw std::invalid_argument(std::string("Parameter ") + name + " is not of requested type");
        }
        return bp->value;
    }
};

} /* namespace gpu_coverage */

#endif /* INCLUDE_ARTICULATION_CONFIG_H_ */