MManager.h

/*****************************************************************************
**                                       
**  Header file for Virtual Vertex Template manager class
**
**  Name    : MManager.h
**  Author  : Leonardo Bernardini
**  Version : Alpha 9.0 Wed May 17th 2017
**
**  Copyright 2000-2017, Virtual Vertex
**  All Rights Reserved.
**
**  This file contains UNPUBLISHED PROPRIETARY SOURCE CODE.
**  The contents of this file may not be disclosed to third parties, copied
**  or duplicated in any form, in whole or in part, without the prior written
**  permission of the author.
**
*****************************************************************************/
#ifndef MMANAGER_H
#define MMANAGER_H

#ifdef WIN32
// Windows definitions
#ifdef MTEMPLATE_EXPORTS
#define MTEMPLATE_API __declspec(dllexport)
#else
#define MTEMPLATE_API __declspec(dllimport)
#endif
#else

#ifndef MTEMPLATE_EXPORTS
#ifdef LINUX
#define MTEMPLATE_API
#else
#define MTEMPLATE_API
#endif
#else
#define MTEMPLATE_API
#endif

#endif

#ifdef WIN32
#define MThread uintptr_t
#else
#define MThread pthread_t
#endif

#include "MClientLib/MProcess.h"
#include "MClientLib/MStringRef.h"
#include "MClientLib/MJob.h"

#include <list>

// Disable STL Export warning
#if defined(_WIN32)
#pragma warning(disable: 4251)
#endif // _WIN32

namespace MTemplateEngine {

    enum kTemplatesLogic {
        kTemplateMultiframe  = 0x01, 
        kTemplateImageSlicing  = 0x02, 
        kTemplateBroadcast  = 0x04, 
        kTemplateSingleCommand  = 0x08, 
        kTemplateMultiTask = 0x10 
    } ;

    enum kTemplatesProcessDetection {
        kProcessDirect, 
        kProcessChild, 
        kProcessChildOfChild 
    } ;

    enum kTemplateScanSearchSystem
    {
        kTemplateScanNone, 
        kTemplateScanModule, 
        kTemplateScanClass 
    };

    enum kTemplatesPythonOutputRedirection {
        kPyRedirectNone, 
        kPyRedirectStdouterr, 
        kPyRedirectLog, 
    } ;

    class MTemplate;
    
    class MTEMPLATE_API MTemplateHash
    {
    private:
        int uid;
        std::string md5hash;
        std::string filename;
    public:
        MTemplateHash(void); 
        ~MTemplateHash(void); 
        int getUid(); 
        std::string getMd5Hash(); 
        std::string getFilename(); 
        void setUid(int _uid);
        void setMd5Hash(std::string _hash);
        void setFilename(std::string _filename);

    };

    class MTEMPLATE_API MIconHash
    {
    private:
        std::string md5hash;
        std::string filename;
    public:
        MIconHash(void); 
        ~MIconHash(void); 
        std::string getMd5Hash(); 
        std::string getFilename(); 
        void setMd5Hash(std::string _hash);
        void setFilename(std::string _filename);

    };

    typedef std::map<std::string, MIconHash*> iconsHashesMap; 
    typedef std::map<int,MTemplateHash*> templatesHashesMap; 
    typedef std::map<int,MTemplate*> templatesMap; 
    typedef std::set<std::string> iconsSet; 
    typedef void (*redirectionFuncPtr)(const char*,const char*); 
    class MTEMPLATE_API MManager
    {

    public:
        MManager();
        ~MManager();
    public:
        static MManager* getUniqueClass(bool allocNewClass = true); 
        static void destroyUniqueClass(void); 
        static MManager* allocateClass(void); 
        static void destroyClass(MManager*); 
        static void setIsMacBundle(bool isMacBundle); 
        static void setPythonPath(const std::string& _pythonPath);  
        static std::string getPythonPath(); 
        static std::string getInterpreterModuleName(); 
        static void initializePythonPath(bool showPath=false, std::string moduleName=std::string()); 
        bool normalizeTemplatesDirectories(const std::string& basePath, std::string& versionsFilePath, std::string& macroFilePath, std::string& environmentsFilePath, std::string& logParserFilePath); 
        bool loadTemplateFromFile(const std::string& filePath, const std::string& basePath, const std::string& baseName, const std::string& versionsFilePath, const std::string& macroFilePath, const std::string& environmentsFilePath, const std::string& logParserFilePath, bool moveToInvalidFolders, bool& moved, std::string& err); 
        bool saveTemplateToFile(const std::string& filePath, const std::string& baseName, const std::string& basePath, const std::string& versionsFilePath, const std::string& macroFilePath, const std::string& environmentsFilePath, const std::string& logParserFilePath, MTemplate* templateClass); 
        bool loadVersionsFromFile(MTemplate* t,const std::string& filePath); 
        bool loadMacrosFromFile(MTemplate* t,const std::string& filePath); 
        bool loadEnvironmentsFromFile(MTemplate* t, const std::string& filePath); 
        bool loadParserFromFile(MTemplate* t,const std::string& filePath); 
        bool loadVersionsFromBuffer(MTemplate* t, const std::string& buffer); 
        bool loadMacrosFromBuffer(MTemplate* t, const std::string& buffer);  
        bool loadEnvironmentsFromBuffer(MTemplate* t, const std::string& buffer);  
        bool loadParserFromBuffer(MTemplate* t, const std::string& buffer);  
        bool saveVersionsToFile(MTemplate* t, const std::string& filePath);  
        bool saveMacrosToFile(MTemplate* t, const std::string& filePath); 
        bool saveEnvironmentsToFile(MTemplate* t, const std::string& filePath); 
        bool saveParserToFile(MTemplate* t, const std::string& filePath); 
        bool saveVersionsToBuffer(MTemplate* t, std::string& buffer); 
        bool saveEnvironmentsToBuffer(MTemplate* t, std::string& buffer); 
        bool saveMacrosToBuffer(MTemplate* t, std::string& buffer); 
        bool saveParserToBuffer(MTemplate* t, std::string& buffer); 
        std::string encodeTemplate(MTemplate *t); 
        bool decodeTemplate(const std::string& content, int& id, std::string& md5Hash, std::string& filename, std::string& templateBuffer, 
            std::string& versionsBuffer, std::string& macrosBuffer, std::string& environmentsBuffer, std::string& parserBuffer); 
        bool installTemplate(MTemplate* templateClass); 
        MTemplate* getFirstTemplate(); 
        MTemplate* getNextTemplate(int previous_uid); 
        std::string resolveMappingToJob(int template_id, const char* key) ; 
        std::string resolveMappingToTemplate(int template_id, const char* key) ; 
        void Lock(void); 
        void Unlock(void); 
        void acquirePython(void); 
        void releasePython(void); 
        std::string getPyExceptionStr(); 
        bool runPythonFile(const char* path,MClientLib::MStringRef& _err); 
        bool runPythonString(const char* buffer,const char* sourceFile,MClientLib::MStringRef& _err); 
        void registerPythonOutputCallbacks(redirectionFuncPtr, redirectionFuncPtr); 
        void onPythonStdout(const char* out); 
        void onPythonStderr(const char* out); 
        void onPythonStderrFlush(); 
        void onPythonStdoutFlush(); 
        bool _installPyTemplate(void* templateClass); 
        MClientLib::MJob* getExpressionJob();
        MClientLib::MChunk* getExpressionChunk();
        void setExpressionJob(MClientLib::MJob*);
        void setExpressionChunk(MClientLib::MChunk*);
        void setExpressionOut(std::string);
        std::string getExpressionOut();
        std::string EvaluatePython(const std::string& in, MClientLib::MJob*, MClientLib::MChunk* c);
        std::string ResolveInlinePython(const std::string& in, MClientLib::MJob*j, MClientLib::MChunk* c);
        std::string NormalizeToken(const std::string& in);
        void AddStringToEnvironment(const std::string& in, MClientLib::MEnvironment* env, MClientLib::MJob* j, MClientLib::MChunk* c);
        void clear(void);  
        void flushGC(void); 
        void addTemplateToGC(MTemplate* t); 
        void copyFrom(MManager*); 
        MTemplate* parsePython(const char* template_buf,const char* template_filename,bool _recache,MClientLib::MStringRef& err, bool store=true); 
        MTemplate* getTemplate(const char* name); 
        MTemplate* getTemplateByFilename(const char* filename); 
        MTemplate* getTemplate(int id); 
        MTemplate* getTemplateAt(int num); 
        void unloadTemplate(int id); 
        int getTemplatesCount(); 
        int getNextFreeUID(); 
        void deallocateTemplate(MTemplate* t); 
        void calculateMD5(MTemplate* t); 
        templatesHashesMap* getInternalHashesMap(); 
        void fillInternalHashesMap(); 
        std::string marshallHashesMap(templatesHashesMap*); 
        void unmarshallHashesMap(templatesHashesMap*, const char*); 
        void makeHashesMap(templatesHashesMap*); 
        void calculateHashesDiffs(templatesHashesMap* remote, templatesHashesMap* out_of_date, templatesHashesMap* invalid); 
        void deleteHashesMap(templatesHashesMap*); 
        std::string calculateIconMD5(const std::string& iconPath); 
        iconsHashesMap* getIconsHashesMap(); 
        void fillIconsHashesMap(const std::string& iconPath); 
        std::string marshallIconsHashesMap(iconsHashesMap*); 
        void unmarshallIconsHashesMap(iconsHashesMap*, const char*); 
        void makeIconsHashesMap(iconsHashesMap*, const std::string& iconPath); 
        void calculateIconsHashesDiffs(iconsHashesMap* remote, iconsHashesMap* out_of_date, iconsHashesMap* invalid); 
        void deleteIconsHashesMap(iconsHashesMap*); 
        void addIcon(const std::string& iconFile);
        void removeIcon(const std::string& iconFile);
        void clearIcons();

        void sortListByField(const std::string& field, std::list<MTemplate*>* list); 
        bool validateJobSubmission(MClientLib::MJob& job, MClientLib::MStringRef& err); 
        std::set<int> getTemplatesID(); 
        MClientLib::MTextFileMarker checkForLineParsingOverrides(MClientLib::MJob* job, MClientLib::MChunk* chunk, const char* line, int lineNum); 
    private:
        void updateTemplateHash(MTemplate* t); 
        void* _mutex;
        templatesMap list;
        iconsSet icons_set;
        iconsHashesMap icons_hash_map;
        templatesHashesMap hash_map;
        static MManager* _unique_class;
        static bool _isMacBundle;
        static bool pythonFromHere;
        static std::map<MThread,void*> threadStates;
        static void* mainThreadState;
        static MThread mainThread;
        static void* m_PyFormatException;
        static void* m_pMainModule;
        static void* m_pMainDict;
        static std::string pythonPath;
        static std::string interpreterModuleName;
        static std::list<MTemplate*> gc;
        std::string expressionOut;
        MClientLib::MJob* expressionJob;
        MClientLib::MChunk* expressionChunk;
        redirectionFuncPtr stdoutCallback;
        redirectionFuncPtr stderrCallback;
        std::string callbackContext;

        MTemplate* lastInstalledTemplate;

        struct sortFunctor {
            const std::string field;
            sortFunctor(const std::string& field) : field(field) {}
            bool operator()(MTemplate* a,MTemplate* b);
        };
    };

};

#endif