Input.h

Go to the documentation of this file.

#pragma once
 
#include <stdint.h>
#include <string>
#include <vector>
#include <iomanip>
#include <fstream>
#include "../String.h"
#include "../Scripting.h"
 
namespace Gorgon { namespace Scripting {
        
    class InputProvider {
    public:
        enum Dialect {
            Console,
            Programming,
            Intermediate,
            Binary
        };
        
        InputProvider(Dialect dialect) : dialect(dialect) {}
        
        Dialect GetDialect() const {
            return dialect;
        }
        
        void SetDialect(Dialect dialect) {
            this->dialect=dialect;
            checkdialect();
        }
        
        std::string GetName() const { return name; }
        
        
        virtual bool ReadLine(std::string &, bool newline) = 0;
        
        virtual bool IsInteractive() const { return false; }
        
        //virtual int ReadBinary(std::vector<Byte> &buffer) = 0;
        
        virtual void Reset() = 0;
        
    protected:
        std::string name;
        
        virtual void checkdialect() { }
        
        Dialect dialect;
    };
    
    class ConsoleInput : public InputProvider {
    public:
        
        ConsoleInput(Dialect dialect=InputProvider::Console, const std::string &prompt="> ") : InputProvider(dialect),
        prompt(prompt) { 
            name="#Console";
        }
        
        void SetPrompt(const std::string &prompt) {
            this->prompt=prompt;
        }
        
        virtual bool ReadLine(std::string &input, bool newline) override final {
            line++;
            std::cout<<std::setw(3)<<line<<prompt;
 
            return bool(std::getline(std::cin, input));
        }
        
        virtual void Reset() override {
            line=0;
        }
        
        virtual bool IsInteractive() const override { return true; }
        
        
    protected:
        virtual void checkdialect() override { 
            if(dialect==InputProvider::Binary) {
                SetDialect(InputProvider::Console);
                throw std::runtime_error("Cannot accept binary code from the console");
            }
        }
        
    private:
        std::string prompt;
        int line=0;
    };
    
    class StreamInput : public InputProvider {
    public:
        StreamInput(std::istream &stream, Dialect dialect, const std::string &name="") : InputProvider(dialect), stream(stream) {
            this->name=name;
        }
        
        virtual bool ReadLine(std::string &input, bool) override final {
            return bool(std::getline(stream,input));
        }
        
        virtual void Reset() override {
            stream.seekg(0);
        }
        
    private:
        std::istream &stream;
    };
    
    class FileInput : public StreamInput {
    public:
        FileInput(const std::string &filename) : StreamInput(file, InputProvider::Programming) {
            auto loc=filename.find_last_of('.');
            std::string ext="";
            if(loc!=filename.npos)
                ext=filename.substr(loc);
            
            name=filename;
            
            //determine dialect from the extension
            if(ext.length()>=3 && ext.substr(0,3)=="gsb") {
                dialect=InputProvider::Binary;
            }
            else if(ext.length()>=3 && ext.substr(0,3)=="gsc") {
                dialect=InputProvider::Console;
            }
            else if(ext.length()>=3 && ext.substr(0,3)=="gsi") {
                dialect=InputProvider::Intermediate;
            }
            else { // generally *.gs*
                dialect=InputProvider::Programming;
            }
            
            file.open(filename, dialect==InputProvider::Binary ? std::ios::out | std::ios::binary : std::ios::out);
            if(!file.is_open()) {
                throw std::runtime_error("Cannot open file");
            }
        }
        
    private:
        std::ifstream file;
    };
        
} }