LocalJsonFileLoader.h

// Copyright eeGeo Ltd (2012-2014), All Rights Reserved

#pragma once

#include "IJsonFileLoader.h"
#include "IJsonFileParser.h"
#include "Types.h"
#include "CallbackCollection.h"
#include "IFileIO.h"
#include <vector>
#include <string>
#include <fstream>

namespace Eegeo
{
    namespace Io
    {
        template <class T>
        class LocalJsonFileLoader : public IJsonFileLoader, public IUpdatableLoader, private Eegeo::NonCopyable
        {
        public:
            typedef Helpers::CallbackCollection1<const T> TParsedResultsCallbacks;
            
        private:
            
            struct LocalJsonFileLoad
            {
                LocalJsonFileLoad(const std::string& url,  LoadCompleteCallbackType& callback)
                : m_url(url)
                , m_pCallback(&callback)
                {}
                
                const std::string& GetUrl() const { return m_url; }
                LoadCompleteCallbackType& GetCallback() const { return *m_pCallback; }
            private:
                std::string m_url;
                LoadCompleteCallbackType* m_pCallback;
            };
            
            Helpers::IFileIO& m_fileIO;
            const IJsonFileParser<T>& m_parser;
            TParsedResultsCallbacks& m_parsedResultsCallbacks;
            
            std::vector<LocalJsonFileLoad> m_loads;
            
            bool TryLoad(const LocalJsonFileLoad& load)
            {
                std::fstream stream;
                size_t size;
                
                const bool fileOpenSuccess = m_fileIO.OpenFile(stream, size, load.GetUrl());
                
                if (!fileOpenSuccess)
                {
                    return false;
                }
                
                const std::string categoryJson((std::istreambuf_iterator<char>(stream)), std::istreambuf_iterator<char>());
                stream.close();
                
                T parserResult;
                const bool parseSuccess = m_parser.TryParse(categoryJson, parserResult);
                
                if (!parseSuccess)
                {
                    return false;
                }
                
                m_parsedResultsCallbacks.ExecuteCallbacks(parserResult);
                
                return true;
            }
            
        public:
            
            LocalJsonFileLoader(Helpers::IFileIO& fileIO,
                                const IJsonFileParser<T>& jsonParser,
                                TParsedResultsCallbacks& parsedResultsCallbacks
                                )
            : m_fileIO(fileIO)
            , m_parser(jsonParser)
            , m_parsedResultsCallbacks(parsedResultsCallbacks)
            {
            }
            
            void Load(const std::string& url, LoadCompleteCallbackType& callback)
            {
                // work deferred until Update - similar behaviour to if we were doing web request
                m_loads.emplace_back(url, callback);
            }
            
            void Update()
            {
                for (typename std::vector<LocalJsonFileLoad>::const_iterator iter = m_loads.begin(); iter != m_loads.end(); ++iter)
                {
                    bool success = TryLoad(*iter);
                    if(!success)
                    {
                        Eegeo_TTY("Failed to load interior label category json file %s", iter->GetUrl().c_str());
                    }
                    
                    JsonFileLoaderResult result(iter->GetUrl(), success);
                    iter->GetCallback()(result);
                }
                m_loads.clear();
            }
            
        
        };
    }
}