ResourcePoolOptions.hh

//********************************************************************
//*** ResourcePool/ResourcePoolOptions.hh
//*** Copyright (c) 2003-2009 by Markus Winand <mws@fatalmind.com>
//*** $Id: ResourcePoolOptions.hh,v 1.23 2009-03-18 14:16:10 mws Exp $
//********************************************************************
/*
This file is part of ResourcePool.

ResourcePool is free software; you can redistribute it
and/or modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2 of 
the License, or (at your option) any later version.

ResourcePool is distributed in the hope that it will be
useful, but WITHOUT ANY WARRANTY; without even the implied warranty
of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with ResourcePool; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307  USA */

#ifndef RESOURCEPOOL_RESOURCEPOOLOPTIONS_HH
#define RESOURCEPOOL_RESOURCEPOOLOPTIONS_HH

#ifndef POSIX_TIME_HH
#include "POSIX/time.hh"
#endif

#ifndef INCLUDED_EXCEPTIONS_HH
#include "Exceptions/Exception.hh"
#endif

#ifndef INCLUDED_THREAD_LOCK_HH
#include "Thread/Lock.hh"
#endif

#include <vector>
#include <string>

namespace fatalmind {
class ResourcePoolOptions {
        typedef POSIX::timespec<SingleThreadedModel<> > timespec_t;
        typedef std::vector<POSIX::timespec<SingleThreadedModel<> > >         SleepOnFail_t;

        SleepOnFail_t _SleepOnFail;
        int           _Max;
        int           _MaxTry;
        int           _MaxExecTry;
        int           _PreCreate;
        timespec_t    _wait;    

    public:
        ResourcePoolOptions();  
        ~ResourcePoolOptions() {
        }

        void setMax(const int a_Max);

        void setMaxTry(const int a_MaxTry);

        void setMaxExecTry(const int a_MaxExecTry);

        void setPreCreate(const int a_PreCreate);

        void setSleepOnFail(const SleepOnFail_t&);
        void setSleepOnFail(const float
            , const float = -1
            , const float = -1
            , const float = -1
        );
        void setWait();
        void setWait(const float);

        inline int getPreCreate() const {
            return _PreCreate;
        }

        inline int getMaxTry() const {
            return _MaxTry;
        }

        inline int getMaxExecTry() const {
            return _MaxExecTry;
        }

        inline int getMax() const {
            return _Max;
        }

        void SleepOnFail(const int) const;

        POSIX::timespec<SingleThreadedModel<> > getSleepOnFail(int tryno) const;

        const timespec_t* getWait() const {
            return &_wait;
        }

        class IllegalArgumentException: public fatalmind::Exception {
            public:
                IllegalArgumentException(const std::string& msg)
                : fatalmind::Exception(msg)
                {
                };
        };

        static const ResourcePoolOptions defaultOptions;
};
        
} // namespace fatalmind

#endif

---