CacheLayoutGenerator.h

#pragma once
// ===========================================================================
// Copyright (c) 2015 Toolchefs Ltd. All rights reserved.
//
// Use of this software is subject to the terms of the Toolchefs license
// agreement provided at the time of installation or download, or which
// otherwise accompanies this software in either electronic or hard copy form.
// ===========================================================================
 
#include <Atoms/LayoutGenerators/LayoutGenerator.h>
#include <set>
 
namespace Atoms
{
    class ATOMS_EXPORT CacheLayoutGenerator : public LayoutGenerator
    {
    public:
 
        CacheLayoutGenerator();
 
        virtual ~CacheLayoutGenerator();
        
        virtual std::vector<AgentInitData> generate(double time)
#ifdef __APPLE__
        override
#endif
        ;
 
        inline bool allowMultiLayoutGenerator() override { return false; }
 
        inline AtomsCore::Matrix matrix() const { return m_matrix; }
 
        inline void setMatrix(const AtomsCore::Matrix& mtx) { m_matrix = mtx; }
 
        inline void setCache(const std::string& cachePath, const std::string& cacheName) 
        { 
            m_cachePath = cachePath; 
            m_cacheName = cacheName;
        }
 
        inline void setNewAgents(const std::vector<int>& newAgents) { m_newAgents = newAgents; }
 
        void setAgentsFilter(const std::vector<int>& newAgents);
 
        inline void setCacheFrame(double value) { m_cacheFrame = value; };
 
        inline void setStartFrame(double value) { m_startFrame = value; };
 
        inline void setAgentsTimes(std::unordered_map<int, double>* value) { m_agentsTime = value; };
 
        inline size_t getAgentCacheId(size_t id) { return m_agentIds[id]; };
 
        inline void addAgentCacheId(size_t id, size_t value) { m_agentIds[id] = value; };
 
        void setExtraAgents(const std::unordered_map<size_t, size_t>& extraAgents);
 
        void setTimeOffsetInPlace(const bool value, const std::unordered_map<int, bool> &overrides) { m_timeOffsetInPlace = value;  m_timeOffsetInPlaces = overrides; }
 
        inline const char* typeName() override { return "cacheReader"; };
 
    private:
 
        AtomsCore::Matrix m_matrix;
 
        std::vector<int> m_newAgents;
 
        std::unordered_map<int, bool> m_agentsFilter;
 
        bool m_timeOffsetInPlace;
 
        std::unordered_map<int, bool> m_timeOffsetInPlaces;
 
        std::unordered_map<int, double>* m_agentsTime;
 
        std::unordered_map<size_t, size_t> m_agentIds;
 
        std::unordered_map<size_t, size_t> m_extraAgents;
 
        std::string m_cachePath;
 
        std::string m_cacheName;
 
        double m_cacheFrame;
 
        double m_startFrame;
 
        std::set<int> m_agentsCreated;
    };
}