zeroc-ice 3.6b1

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

@@ -0,0 +1,143 @@
+// **********************************************************************
+//
+// 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_TIMER_H
+#define ICE_UTIL_TIMER_H
+
+#include <IceUtil/Shared.h>
+#include <IceUtil/Thread.h>
+#include <IceUtil/Monitor.h>
+#include <IceUtil/Time.h>
+
+#include <set>
+#include <map>
+
+namespace IceUtil
+{
+
+class Timer;
+typedef IceUtil::Handle<Timer> TimerPtr;
+
+//
+// Extend the TimerTask class and override the runTimerTask() method to execute
+// code at a specific time or repeatedly.
+//
+class ICE_UTIL_API TimerTask : virtual public IceUtil::Shared
+{
+public:
+
+    virtual ~TimerTask() { }
+
+    virtual void runTimerTask() = 0;
+};
+typedef IceUtil::Handle<TimerTask> TimerTaskPtr;
+
+//
+// The timer class is used to schedule tasks for one-time execution or
+// repeated execution. Tasks are executed by the dedicated timer thread 
+// sequentially.
+//
+class ICE_UTIL_API Timer : virtual public IceUtil::Shared, private IceUtil::Thread
+{
+public:
+
+    //
+    // Construct a timer and starts its execution thread.
+    //
+    Timer();
+
+
+    //
+    // Construct a timer and starts its execution thread with the priority.
+    //
+    Timer(int priority);
+
+    //
+    // Destroy the timer and detach its execution thread if the calling thread 
+    // is the timer thread, join the timer execution thread otherwise.
+    //
+    void destroy();
+
+    //
+    // Schedule a task for execution after a given delay.
+    //
+    void schedule(const TimerTaskPtr&, const IceUtil::Time&);
+
+    //
+    // Schedule a task for repeated execution with the given delay
+    // between each execution.
+    //
+    void scheduleRepeated(const TimerTaskPtr&, const IceUtil::Time&);
+
+    //
+    // Cancel a task. Returns true if the task has not yet run or if
+    // it's a task scheduled for repeated execution. Returns false if
+    // the task has already run, was already cancelled or was never
+    // schedulded.
+    //
+    bool cancel(const TimerTaskPtr&);
+
+protected:
+
+    virtual void run();
+    virtual void runTimerTask(const TimerTaskPtr&);
+
+    struct Token
+    {
+        IceUtil::Time scheduledTime;
+        IceUtil::Time delay;
+        TimerTaskPtr task;
+
+        inline Token(const IceUtil::Time&, const IceUtil::Time&, const TimerTaskPtr&);
+        inline bool operator<(const Token& r) const;
+    };
+
+    IceUtil::Monitor<IceUtil::Mutex> _monitor;
+    bool _destroyed;
+    std::set<Token> _tokens;
+    
+    class TimerTaskCompare : public std::binary_function<TimerTaskPtr, TimerTaskPtr, bool>
+    {
+    public:
+        
+        bool operator()(const TimerTaskPtr& lhs, const TimerTaskPtr& rhs) const
+        {
+            return lhs.get() < rhs.get();
+        }
+    };
+    std::map<TimerTaskPtr, IceUtil::Time, TimerTaskCompare> _tasks;
+    IceUtil::Time _wakeUpTime;
+};
+typedef IceUtil::Handle<Timer> TimerPtr;
+
+inline 
+Timer::Token::Token(const IceUtil::Time& st, const IceUtil::Time& d, const TimerTaskPtr& t) :
+    scheduledTime(st), delay(d), task(t)
+{
+}
+
+inline bool
+Timer::Token::operator<(const Timer::Token& r) const
+{
+    if(scheduledTime < r.scheduledTime)
+    {
+        return true;
+    }
+    else if(scheduledTime > r.scheduledTime)
+    {
+        return false;
+    }
+    
+    return task.get() < r.task.get();
+}
+
+}
+
+#endif
+

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

@@ -0,0 +1,22 @@
+// **********************************************************************
+//
+// 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_UUID_H
+#define ICE_UTIL_UUID_H
+
+#include <IceUtil/Config.h>
+
+namespace IceUtil
+{
+
+ICE_UTIL_API std::string generateUUID();
+
+}
+
+#endif

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

@@ -0,0 +1,42 @@
+// **********************************************************************
+//
+// 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_UNDEF_SYS_MACROS_H
+#define ICE_UTIL_UNDEF_SYS_MACROS_H
+
+//
+// This header includes macros that can end up being dragged into
+// the generated code from system headers, such as major() or NDEBUG.
+// If a Slice symbol has the same name as a macro, the generated
+// code most likely won't compile (but, depending how the macro is
+// defined, may even compile).
+//
+// Here, we undefine symbols that cause such problems.
+//
+// The #ifdef ... #endif protection is necessary to prevent
+// warnings on some platforms.
+//
+
+#ifdef major
+#undef major
+#endif
+
+#ifdef minor
+#undef minor
+#endif
+
+#ifdef min
+#undef min
+#endif
+
+#ifdef max
+#undef max
+#endif
+
+#endif

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

@@ -0,0 +1,101 @@
+// **********************************************************************
+//
+// 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_UNIQUE_PTR_H
+#define ICE_UTIL_UNIQUE_PTR_H
+
+#include <IceUtil/Config.h>
+
+namespace IceUtil
+{
+
+//
+// This is temporary and very partial placeholder for std::unique_ptr,
+// which is not yet widely available.
+//
+
+
+template<typename T>
+class UniquePtr
+{
+public:
+
+    explicit UniquePtr(T* ptr = 0) :
+        _ptr(ptr)
+    {
+    }
+
+    UniquePtr(UniquePtr& o) :
+        _ptr(o.release())
+    {
+    }
+
+    UniquePtr& operator=(UniquePtr& o)
+    {
+        reset(o.release());
+        return *this;
+    }
+
+    ~UniquePtr()
+    {
+        if(_ptr != 0)
+        {
+            delete _ptr;
+        }
+    }
+
+    T* release()
+    {
+        T* r = _ptr;
+        _ptr = 0;
+        return r;
+    }
+
+    void reset(T* ptr = 0)
+    {
+        assert(ptr == 0 || ptr != _ptr);
+
+        if(_ptr != 0)
+        {
+            delete _ptr;
+        }
+        _ptr = ptr;
+    }
+
+    T& operator*() const
+    {
+        return *_ptr;
+    }
+    
+    T* operator->() const
+    {
+        return _ptr;
+    }
+
+
+    T* get() const
+    {
+        return _ptr;
+    }
+
+    void swap(UniquePtr& a)
+    {
+        T* tmp = a._ptr;
+        a._ptr = _ptr;
+        _ptr = tmp;
+    }
+
+private:
+
+    T* _ptr;
+};
+
+} // End of namespace IceUtil
+
+#endif

data/ext/ice/cpp/include/Slice/CPlusPlusUtil.h

@@ -0,0 +1,64 @@
+// **********************************************************************
+//
+// 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 C_PLUS_PLUS_UTIL_H
+#define C_PLUS_PLUS_UTIL_H
+
+#include <Slice/Parser.h>
+#include <IceUtil/OutputUtil.h>
+
+namespace Slice
+{
+
+SLICE_API extern FeatureProfile featureProfile;
+
+struct ToIfdef
+{
+    SLICE_API char operator()(char);
+};
+
+SLICE_API void printHeader(::IceUtilInternal::Output&);
+SLICE_API void printVersionCheck(::IceUtilInternal::Output&);
+SLICE_API void printDllExportStuff(::IceUtilInternal::Output&, const std::string&);
+
+const int TypeContextInParam = 1;
+const int TypeContextAMIEnd = 2;
+const int TypeContextAMIPrivateEnd = 4;
+const int TypeContextAMICallPrivateEnd = 8;
+
+const int TypeContextUseWstring = 16;
+
+SLICE_API std::string typeToString(const TypePtr&, const StringList& = StringList(), int = 0);
+SLICE_API std::string typeToString(const TypePtr&, bool, const StringList& = StringList(), int = 0);
+SLICE_API std::string returnTypeToString(const TypePtr&, bool, const StringList& = StringList(), int = 0);
+SLICE_API std::string inputTypeToString(const TypePtr&, bool, const StringList& = StringList(), int = 0);
+SLICE_API std::string outputTypeToString(const TypePtr&, bool, const StringList& = StringList(), int = 0);
+SLICE_API std::string operationModeToString(Operation::Mode);
+SLICE_API std::string opFormatTypeToString(const OperationPtr&);
+
+SLICE_API std::string fixKwd(const std::string&);
+
+SLICE_API void writeMarshalUnmarshalCode(::IceUtilInternal::Output&, const TypePtr&, bool, int, const std::string&,
+                                         bool, const StringList& = StringList(), int = 0, const std::string& = "",
+                                         bool = true);
+                                             
+SLICE_API void writeMarshalCode(::IceUtilInternal::Output&, const ParamDeclList&, const OperationPtr&, int = 0);
+SLICE_API void writeUnmarshalCode(::IceUtilInternal::Output&, const ParamDeclList&, const OperationPtr&, int = 0);
+SLICE_API void writeAllocateCode(::IceUtilInternal::Output&, const ParamDeclList&, const OperationPtr&, int = 0);
+
+SLICE_API std::string getEndArg(const TypePtr&, const StringList&, const std::string&);
+SLICE_API void writeEndCode(::IceUtilInternal::Output&, const ParamDeclList&, const OperationPtr&);
+
+SLICE_API std::string findMetaData(const StringList&, int = 0);
+SLICE_API bool inWstringModule(const SequencePtr&);
+
+SLICE_API std::string getDataMemberRef(const DataMemberPtr&);
+}
+
+#endif

data/ext/ice/cpp/include/Slice/Checksum.h

@@ -0,0 +1,26 @@
+// **********************************************************************
+//
+// 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 SLICE_CHECKSUM_H
+#define SLICE_CHECKSUM_H
+
+#include <Slice/Parser.h>
+#include <map>
+#include <vector>
+
+namespace Slice
+{
+
+typedef std::map<std::string, std::vector<unsigned char> > ChecksumMap;
+
+SLICE_API ChecksumMap createChecksums(const UnitPtr&);
+
+}
+
+#endif

data/ext/ice/cpp/include/Slice/CsUtil.h

@@ -0,0 +1,92 @@
+// **********************************************************************
+//
+// 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 CS_UTIL_H
+#define CS_UTIL_H
+
+#include <Slice/Parser.h>
+#include <IceUtil/OutputUtil.h>
+
+namespace Slice
+{
+
+class SLICE_API CsGenerator : private ::IceUtil::noncopyable
+{
+public:
+
+    virtual ~CsGenerator() {};
+
+    //
+    // Convert a dimension-less array declaration to one with a dimension.
+    //
+    static std::string toArrayAlloc(const std::string& decl, const std::string& sz);
+
+    //
+    // Validate all metadata in the unit with a "cs:" prefix.
+    //
+    static void validateMetaData(const UnitPtr&);
+
+protected:
+    static std::string fixId(const std::string&, int = 0, bool = false);
+    static std::string fixId(const ContainedPtr&, int = 0, bool = false);
+    static std::string getOptionalFormat(const TypePtr&);
+    static std::string getStaticId(const TypePtr&);
+    static std::string typeToString(const TypePtr&, bool = false);
+    static bool isValueType(const TypePtr&);
+    static bool isSerializable(const TypePtr&);
+
+    //
+    // Generate code to marshal or unmarshal a type
+    //
+    void writeMarshalUnmarshalCode(::IceUtilInternal::Output&, const TypePtr&, const std::string&, bool, bool);
+    void writeOptionalMarshalUnmarshalCode(::IceUtilInternal::Output&, const TypePtr&, const std::string&, int, bool,
+                                           bool);
+    void writeSequenceMarshalUnmarshalCode(::IceUtilInternal::Output&, const SequencePtr&, const std::string&,
+                                           bool, bool, bool);
+    void writeOptionalSequenceMarshalUnmarshalCode(::IceUtilInternal::Output&, const SequencePtr&, const std::string&,
+                                                   int, bool, bool);
+
+    void writeSerializeDeserializeCode(::IceUtilInternal::Output&, const TypePtr&, const std::string&, bool, int, bool);
+
+private:
+
+    class MetaDataVisitor : public ParserVisitor
+    {
+    public:
+
+        virtual bool visitUnitStart(const UnitPtr&);
+        virtual bool visitModuleStart(const ModulePtr&);
+        virtual void visitModuleEnd(const ModulePtr&);
+        virtual void visitClassDecl(const ClassDeclPtr&);
+        virtual bool visitClassDefStart(const ClassDefPtr&);
+        virtual void visitClassDefEnd(const ClassDefPtr&);
+        virtual bool visitExceptionStart(const ExceptionPtr&);
+        virtual void visitExceptionEnd(const ExceptionPtr&);
+        virtual bool visitStructStart(const StructPtr&);
+        virtual void visitStructEnd(const StructPtr&);
+        virtual void visitOperation(const OperationPtr&);
+        virtual void visitParamDecl(const ParamDeclPtr&);
+        virtual void visitDataMember(const DataMemberPtr&);
+        virtual void visitSequence(const SequencePtr&);
+        virtual void visitDictionary(const DictionaryPtr&);
+        virtual void visitEnum(const EnumPtr&);
+        virtual void visitConst(const ConstPtr&);
+
+    private:
+
+        void validate(const ContainedPtr&);
+
+        std::string _fileName;
+        StringSet _history;
+    };
+};
+
+}
+
+#endif