zeroc-ice 3.6b1

data/ext/ice/cpp/include/IceUtil/MutexPtrTryLock.h

@@ -0,0 +1,82 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+#ifndef ICE_UTIL_MUTEX_PTR_TRY_LOCK_H
+#define ICE_UTIL_MUTEX_PTR_TRY_LOCK_H
+
+#include <IceUtil/Config.h>
+#include <IceUtil/Mutex.h>
+
+namespace IceUtilInternal
+{
+
+template<class T>
+class MutexPtrTryLock
+{
+public:
+    
+    MutexPtrTryLock<T>(const T* mutex) :
+        _mutex(mutex),
+        _acquired(false)
+    {
+        if(_mutex)
+        {
+            _acquired = _mutex->tryLock();
+        }
+    }
+
+    ~MutexPtrTryLock<T>()
+    {
+        if(_mutex && _acquired)
+        {
+            _mutex->unlock();
+        }
+    }
+
+    void acquire() const
+    {
+        if(_mutex)
+        {
+            _mutex->lock();
+            _acquired = true;
+        }
+    }
+
+    void release() const
+    {
+        if(_mutex)
+        {
+            if(!_acquired)
+            {
+                throw IceUtil::ThreadLockedException(__FILE__, __LINE__);
+            }
+            _mutex->unlock();
+            _acquired = false;
+        }
+    }
+
+    bool acquired() const
+    {
+        return _acquired;
+    }
+   
+private:
+    
+    // Not implemented; prevents accidental use.
+    //
+    MutexPtrTryLock<T>(const MutexPtrTryLock&);
+    MutexPtrTryLock<T>& operator=(const MutexPtrTryLock<T>&);
+
+    const T* _mutex;
+    mutable bool _acquired;
+};
+
+} // End namespace IceUtilInternal
+
+#endif

data/ext/ice/cpp/include/IceUtil/Optional.h

@@ -0,0 +1,322 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+#ifndef ICE_UTIL_OPTIONAL_H
+#define ICE_UTIL_OPTIONAL_H
+
+#include <IceUtil/Config.h>
+
+namespace IceUtilInternal
+{
+
+struct NoneType 
+{
+};
+
+}
+
+namespace IceUtil
+{
+
+const IceUtilInternal::NoneType None = {};
+
+template<typename T>
+class Optional
+{
+public:
+
+    typedef T element_type;
+
+    Optional() : _isSet(false)
+    {
+    }
+
+    Optional(IceUtilInternal::NoneType) : _isSet(false)
+    {
+    }
+
+    template<typename Y>
+    Optional(Y p) : _value(p), _isSet(true)
+    {
+    }
+
+    template<typename Y>
+    Optional(const Optional<Y>& r) : _value(r._value), _isSet(r._isSet)
+    {
+    }
+    
+    ~Optional()
+    {
+    }
+    
+    Optional& operator=(IceUtilInternal::NoneType)
+    {
+        _value = T();
+        _isSet = false;
+        return *this;
+    }
+
+    template<typename Y>
+    Optional& operator=(Y p)
+    {
+        _value = p;
+        _isSet = true;
+        return *this;
+    }
+        
+    template<typename Y>
+    Optional& operator=(const Optional<Y>& r)
+    {
+        _value = r._value;
+        _isSet = r._isSet;
+        return *this;
+    }
+
+    Optional& operator=(const Optional& r)
+    {
+        _value = r._value;
+        _isSet = r._isSet;
+        return *this;
+    }
+
+    const T& get() const
+    {
+        checkIsSet();
+        return _value;
+    }
+    T& get()
+    {
+        checkIsSet();
+        return _value;
+    }
+
+    const T* operator->() const
+    {
+        return &get();
+    }
+    T* operator->()
+    {
+        return &get();
+    }
+
+    const T& operator*() const
+    {
+        return get();
+    }
+    T& operator*()
+    {
+        return get();
+    }
+
+    operator bool() const
+    {
+        return _isSet;
+    }
+
+    bool operator!() const 
+    { 
+        return !_isSet;
+    }
+
+    void swap(Optional& other)
+    {
+        std::swap(_isSet, other._isSet);
+        std::swap(_value, other._value);
+    }
+
+    void __setIsSet()
+    {
+        _isSet = true;
+    }
+
+private:
+
+    void checkIsSet() const
+    {
+        if(!_isSet)
+        {
+            throwOptionalNotSetException(__FILE__, __LINE__);
+        }
+    }
+    
+    void throwOptionalNotSetException(const char *, int) const;
+
+    T _value;
+    bool _isSet;
+};
+
+template<class T> inline Optional<T> 
+makeOptional(const T& v)
+{
+    return Optional<T>(v);
+}
+
+template<typename T> inline void 
+Optional<T>::throwOptionalNotSetException(const char* file, int line) const
+{
+    throw OptionalNotSetException(file, line);
+}
+
+template<typename T, typename U>
+inline bool operator==(const Optional<T>& lhs, const Optional<U>& rhs)
+{
+    if(lhs && rhs)
+    {
+        return *lhs == *rhs;
+    }
+    else
+    {
+        return !lhs && !rhs;
+    }
+}
+
+template<typename T, typename U>
+inline bool operator!=(const Optional<T>& lhs, const Optional<U>& rhs)
+{
+    return !operator==(lhs, rhs);
+}
+
+template<typename T, typename U>
+inline bool operator<(const Optional<T>& lhs, const Optional<U>& rhs)
+{
+    if(lhs && rhs)
+    {
+        return *lhs < *rhs;
+    }
+    else
+    {
+        return !lhs && rhs;
+    }
+}
+
+template<typename T, typename U>
+inline bool operator<=(const Optional<T>& lhs, const Optional<U>& rhs)
+{
+    return lhs < rhs || lhs == rhs;
+}
+
+template<typename T, typename U>
+inline bool operator>(const Optional<T>& lhs, const Optional<U>& rhs)
+{
+    return !(lhs < rhs || lhs == rhs);
+}
+
+template<typename T, typename U>
+inline bool operator>=(const Optional<T>& lhs, const Optional<U>& rhs)
+{
+    return !(lhs < rhs);
+}
+
+// Optional<T> vs Y
+
+template<typename T, typename Y>
+inline bool operator==(const Optional<T>& lhs, const Y& rhs)
+{
+    if(!lhs)
+    {
+        return false;
+    }
+    else 
+    {
+        return *lhs == rhs;
+    }
+}
+
+template<typename T, typename Y>
+inline bool operator!=(const Optional<T>& lhs, const Y& rhs)
+{
+    return !operator==(lhs, rhs);
+}
+
+template<typename T, typename Y>
+inline bool operator<(const Optional<T>& lhs, const Y& rhs)
+{
+    if(lhs)
+    {
+        return *lhs < rhs;
+    }
+    else
+    {
+        return true;
+    }
+}
+
+template<typename T, typename Y>
+inline bool operator<=(const Optional<T>& lhs, const Y& rhs)
+{
+    return lhs < rhs || lhs == rhs;
+}
+
+template<typename T, typename Y>
+inline bool operator>(const Optional<T>& lhs, const Y& rhs)
+{
+    return !(lhs < rhs || lhs == rhs);
+}
+
+template<typename T, typename Y>
+inline bool operator>=(const Optional<T>& lhs, const Y& rhs)
+{
+    return !(lhs < rhs);
+}
+
+// Y vs Optional<T>
+
+template<typename T, typename Y>
+inline bool operator==(const Y& lhs, const Optional<T>& rhs)
+{
+    if(!rhs)
+    {
+        return false;
+    }
+    else 
+    {
+        return lhs == *rhs;
+    }
+}
+
+template<typename T, typename Y>
+inline bool operator!=(const Y& lhs, const Optional<T>& rhs)
+{
+    return !operator==(lhs, rhs);
+}
+
+template<typename T, typename Y>
+inline bool operator<(const Y& lhs, const Optional<T>& rhs)
+{
+    if(rhs)
+    {
+        return lhs < *rhs;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+template<typename T, typename Y>
+inline bool operator<=(const Y& lhs, const Optional<T>& rhs)
+{
+    return lhs < rhs || lhs == rhs;
+}
+
+template<typename T, typename Y>
+inline bool operator>(const Y& lhs, const Optional<T>& rhs)
+{
+    return !(lhs < rhs || lhs == rhs);
+}
+
+template<typename T, typename Y>
+inline bool operator>=(const Y& lhs, const Optional<T>& rhs)
+{
+    return !(lhs < rhs);
+}
+
+}
+
+#endif

data/ext/ice/cpp/include/IceUtil/Options.h

@@ -0,0 +1,141 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+#ifndef ICE_UTIL_OPTIONS_H
+#define ICE_UTIL_OPTIONS_H
+
+#include <IceUtil/Config.h>
+#include <IceUtil/RecMutex.h>
+#include <IceUtil/Shared.h>
+#include <IceUtil/Handle.h>
+#include <IceUtil/Exception.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace IceUtilInternal
+{
+
+class ICE_UTIL_API APIException : public IceUtil::Exception
+{
+public:
+
+    APIException(const char*, int, const ::std::string&);
+    virtual ~APIException() throw();
+    virtual ::std::string ice_name() const;
+    virtual void ice_print(std::ostream&) const;
+    virtual APIException* ice_clone() const;
+    virtual void ice_throw() const;
+
+    ::std::string reason;
+
+private:
+
+    static const char* _name;
+};
+
+ICE_UTIL_API ::std::ostream& operator<<(::std::ostream&, const APIException&);
+
+class ICE_UTIL_API BadOptException : public IceUtil::Exception
+{
+public:
+
+    BadOptException(const char*, int, const ::std::string&);
+    virtual ~BadOptException() throw();
+    virtual ::std::string ice_name() const;
+    virtual void ice_print(std::ostream&) const;
+    virtual BadOptException* ice_clone() const;
+    virtual void ice_throw() const;
+
+    ::std::string reason;
+
+private:
+
+    static const char* _name;
+};
+
+ICE_UTIL_API ::std::ostream& operator<<(::std::ostream&, const BadOptException&);
+
+class ICE_UTIL_API Options
+{
+public:
+
+    enum LengthType { ShortOpt, LongOpt };
+    enum RepeatType { Repeat, NoRepeat };
+    enum ArgType { NeedArg, NoArg };
+
+    Options();
+    void addOpt(const ::std::string&, const ::std::string& = "",
+                ArgType = NoArg, ::std::string = "", RepeatType = NoRepeat);
+
+    typedef ::std::vector< ::std::string> StringVector;
+
+    static StringVector split(const ::std::string&);
+    StringVector parse(const StringVector&);
+    StringVector parse(int, const char* const []);
+    bool isSet(const ::std::string&) const;
+    ::std::string optArg(const ::std::string&) const;
+    StringVector argVec(const ::std::string&) const;
+
+private:
+
+    struct OptionDetails : public IceUtil::Shared
+    {
+        LengthType length;
+        ArgType arg;
+        RepeatType repeat;
+        bool hasDefault;
+    };
+    typedef IceUtil::Handle<OptionDetails> ODPtr;
+
+    struct OptionValue : public IceUtil::Shared
+    {
+        ::std::string val;
+    };
+    typedef IceUtil::Handle<OptionValue> OValPtr;
+
+    struct OptionValueVector : public IceUtil::Shared
+    {
+        ::std::vector< ::std::string> vals;
+    };
+    typedef IceUtil::Handle<OptionValueVector> OVecPtr;
+
+    typedef ::std::map< ::std::string, ODPtr> ValidOpts; // Valid options and their details.
+    typedef ::std::map< ::std::string, OValPtr> Opts; // Value of non-repeating options.
+    typedef ::std::map< ::std::string, OVecPtr> ROpts; // Value of repeating options.
+    typedef ::std::map< ::std::string, ::std::string> Synonyms; // Map from short to long option and vice versa.
+
+    void addValidOpt(const ::std::string&, const ::std::string&, ArgType, const ::std::string&, RepeatType);
+    ValidOpts::iterator checkOpt(const ::std::string&, LengthType);
+    void setOpt(const ::std::string&, const ::std::string&, const ::std::string&, RepeatType);
+    void setNonRepeatingOpt(const ::std::string&, const ::std::string&);
+    void setRepeatingOpt(const ::std::string&, const ::std::string&);
+    ValidOpts::const_iterator checkOptIsValid(const ::std::string&) const;
+    ValidOpts::const_iterator checkOptHasArg(const ::std::string&) const;
+    void updateSynonyms(const ::std::string&, const ::std::string&);
+    ::std::string getSynonym(const ::std::string&) const;
+
+    ValidOpts _validOpts;
+    Opts _opts;
+    ROpts _ropts;
+    Synonyms _synonyms;
+
+    bool parseCalled;
+
+    IceUtil::RecMutex _m;
+
+    Options(const Options&); // Not allowed.
+    void operator=(const Options&); // Not allowed.
+
+    static void checkArgs(const ::std::string&, const ::std::string&, bool, const ::std::string&);
+};
+
+}
+
+#endif