CVManager.h

#pragma once

#include "CollectiveVariable.h"
#include <vector>

namespace SSAGES
{

    class CVManager
    {
    private:
    std::vector<CollectiveVariable*> cvs_;

    static std::map<std::string, uint> cvmap_;

    public:
        CVManager() = default;


        void AddCV(CollectiveVariable* cv)
        {
            if(std::find(cvs_.begin(), cvs_.end(), cv) == cvs_.end())
                cvs_.push_back(cv);
        }

        /*
         * \note This destroys all CVs stored in the CV manager!
         */ 
        void ClearCVs()
        {
            for(auto& cv : cvs_)
                delete cv;
            cvs_.clear();
        }

         /* 
          * \param mask Vector mask which contains the indices of
          *        which CV to include in the container. 
          * \return Vector containing pointers to requested CVs.
          */
        std::vector<CollectiveVariable*> GetCVs(const std::vector<uint>& mask = std::vector<uint>()) const
        {
            if(mask.empty())
                return cvs_; 
            
            // Pack from mask. 
            std::vector<CollectiveVariable*> cvs;
            for(auto& i : mask)
                cvs.push_back(cvs_[i]);
            
            return cvs;
        }

         /*
          * \param name Name of CV to register. 
          * \param id ID to associate with name. 
          * 
          * \note If a previous name is already used, it will override the old entry.
          */
        static void AddCVtoMap(const std::string& name, uint id)
        {
            cvmap_[name] = id;
        }

         /*
          * \param name Name of CV to look up.
          * \return ID of CV. -1 if nonexistent.
          */ 
        static int LookupCV(const std::string& name)
        {
            if(cvmap_.find(name) == cvmap_.end())
                return -1;

            return cvmap_.at(name);
        }

        ~CVManager()
        {
            for(auto& cv : cvs_)
                delete cv;
        }
    };
}