MPools.h

/*****************************************************************************
 **
 **  Header file for Muster API Pools object
 **
 **  Name    : MPools.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 MPOOLS_H
#define MPOOLS_H

#ifdef WIN32
// Windows definitions
#ifdef MCLIENTLIB_EXPORTS
#define MCLIENTLIB_API __declspec(dllexport)
#else
#define MCLIENTLIB_API __declspec(dllimport)
#endif
#else

#ifndef MCLIENTLIB_EXPORTS
#ifdef LINUX
#define MCLIENTLIB_API
#else
#define MCLIENTLIB_API
#endif
#else
#define MCLIENTLIB_API
#endif
#endif

#include <MClientLib/MTimeRule.h>

// Disable STL Export warning, member is private, we don't need direct access from the DLL client
#if defined(_WIN32)
#pragma warning(disable: 4251)
#endif // _WIN32

#include <string>
#include <list>
#include <vector>
#include <map>
#include <set>

namespace MClientLib {
    
    class MPool;

    class MCLIENTLIB_API MPoolItem {
    private:
        std::string hostName;
        std::string hostIp;
        MPool* parent;
    public:
#ifndef SWIG
        MPoolItem& operator=( const MPoolItem& src );
        MPoolItem( const MPoolItem& src );
#endif
        MPoolItem();
        MPoolItem(MPool* parent);
        virtual ~MPoolItem();
        virtual std::string getHostName() const ;
        virtual void setHostName(const std::string& _hostName);
        virtual std::string getHostIp() const;
        virtual void setHostIp(const std::string& _hostIp);
        virtual MPool* getParent();
        virtual void setParent(MPool* parent);
        static std::vector<MPoolItem> Unmarshall(const std::string& items);
        static std::string Marshall(const std::vector<MPoolItem>& childs);
        void castedRelease();
    };

    class MCLIENTLIB_API MPool {
    private:
        std::string poolName;
        int nodesPriority;
        int jobsPriority;
        long id;
        bool hasNodesPriority;
        bool hasJobsPriority;
        std::string autoPoolIpFilter;
        std::string autoPoolHostnameFilter;
        std::vector<MPoolItem> childs;
        std::vector<MClientLib::MTimeRule> timeRules;


    public:
        MPool();
        virtual ~MPool();
#ifndef SWIG
        MPool& operator=( const MPool& src );
        MPool(const MPool &src);
        virtual std::vector<MClientLib::MPoolItem>* getInnerNodesContainer();
        virtual void setNodes(std::vector<MClientLib::MPoolItem>);
        virtual std::vector<MClientLib::MPoolItem> getNodes();
        virtual int indexOfNode(MClientLib::MPoolItem node);
        virtual std::vector<MClientLib::MTimeRule> getTimeRules();
        virtual void setTimeRules(std::vector<MClientLib::MTimeRule>);
#endif
        virtual long getId();
        virtual void setId(long _id);
        virtual std::string getName();
        virtual void setName(const std::string& _name);
        virtual int getNodesPriority();
        virtual void setNodesPriority(int _nodesPriority);
        virtual int getJobsPriority();
        virtual void setJobsPriority(int _jobsPriority);
        virtual bool getHasNodesPriority();
        virtual void setHasNodesPriority(bool _hasNodesPriority);
        virtual bool getHasJobsPriority();
        virtual void setHasJobsPriority(bool _hasJobsPriority);
        virtual std::string getAutoPoolIpFilter();
        virtual void setAutoPoolIpFilter(const std::string& _autoPoolIpFilter);
        virtual std::string getAutoPoolHostnameFilter();
        virtual void setAutoPoolHostnameFilter(const std::string& _autoPoolHostnameFilter);

        virtual bool containsNode(const std::string& hostName, const std::string& hostIp);
        virtual bool containsNodeName(const std::string& hostName);
        virtual bool containsNodeIp(const std::string& hostIp);

        virtual bool removeNode(const std::string& hostName, const std::string& hostIp);
        virtual void addNode(const std::string& hostName, const std::string& hostIp);
        virtual int indexOfNode(const std::string& hostName, const std::string& hostIp);
        virtual MClientLib::MPoolItem nodeAtIndex(int index);
        virtual bool removeNodeAtIndex(int index);
        virtual int getNodesCount();
        
        virtual void addTimeRule(const MClientLib::MTimeRule& rule);
        virtual MClientLib::MTimeRule getTimeRuleAtIndex(int index);
        virtual void setTimeRuleAtIndex(int index,const MClientLib::MTimeRule& rule);
        virtual bool removeTimeRuleAtIndex(int index);
        virtual int getTimeRulesCount();
        virtual bool Unmarshall(const std::vector<std::string>& items);
        virtual const std::string Marshall();
        void castedRelease();
    };

    class MCLIENTLIB_API MPools {
    private:
        std::vector<MPool*> pools;
        std::map<std::string,MPool*> poolsNames;
    public:
#ifndef SWIG
        MPools(const MPools &src);
        MPools& operator=( const MPools& src );
        virtual std::vector<MPool*>* getInnerPoolsContainer();
#endif
        MPools();
        virtual ~MPools();
        
        virtual std::vector<std::string> groupOf(const std::string& hostName, const std::string& ipAddress);

        virtual bool containsNode(const std::string& poolName,const std::string& hostName, const std::string& hostIp);
        virtual bool containsNodeName(const std::string& poolName,const std::string& hostName);
        virtual bool containsNodeIp(const std::string& poolName,const std::string& hostIp);

        virtual bool removeNode(const std::string& poolName,const std::string& hostName, const std::string& hostIp);
        virtual void addNode(const std::string& poolName,const std::string& hostName, const std::string& hostIp);

        virtual void addPool(const std::string& poolName);
        virtual bool removePool(const std::string& poolName);
        virtual bool containsPool(const std::string& poolName);
        virtual int indexOfPool(const std::string& poolName);
        virtual MPool* getPool(const std::string& pool);

        virtual void addPool(MPool* pool);
        virtual bool removePool(MPool* pool);
        virtual int indexOfPool(MPool* pool);
        virtual bool updatePool(MPool* pool);
        virtual bool renamePool(MPool* pool, const std::string& newName);

        virtual std::vector<MPool> getPools();
        virtual void clear();

        virtual int getPoolsCount();

    };

}

#endif