zeroc-ice-x64-mingw 3.6b1

data/slice/Freeze/DB.ice

@@ -0,0 +1,37 @@
+// **********************************************************************
+//
+// 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.
+//
+// **********************************************************************
+
+#pragma once
+
+[["cpp:header-ext:h"]]
+
+/**
+ *
+ * Freeze provides automatic persistence for Ice servants.
+ *
+ **/
+module Freeze
+{
+
+/**
+ *
+ * A database key, represented as a sequence of bytes.
+ *
+ **/
+sequence<byte> Key;
+
+/**
+ *
+ * A database value, represented as a sequence of bytes.
+ *
+ **/
+sequence<byte> Value;
+
+};
+

data/slice/Freeze/Evictor.ice

@@ -0,0 +1,339 @@
+// **********************************************************************
+//
+// 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.
+//
+// **********************************************************************
+
+#pragma once
+
+[["cpp:header-ext:h"]]
+
+#include <Ice/ObjectAdapterF.ice>
+#include <Ice/ServantLocator.ice>
+#include <Ice/Identity.ice>
+#include <Freeze/Exception.ice>
+
+module Freeze
+{
+
+/**
+ *
+ * A servant initializer provides the application with an
+ * opportunity to perform custom servant initialization.
+ *
+ * @see Evictor
+ *
+ **/
+local interface ServantInitializer
+{
+    /**
+     *
+     * Called whenever the evictor creates a new servant. This
+     * operation allows application code to perform custom servant
+     * initialization after the servant has been created by the
+     * evictor and its persistent state has been restored.
+     *
+     * @param adapter The object adapter in which the evictor is
+     * installed.
+     *
+     * @param identity The identity of the Ice object for which the
+     * servant was created.
+     *
+     * @param facet The facet. An empty facet means the default
+     * facet.
+     *
+     * @param servant The servant to initialize.
+     *
+     * @see Ice.Identity
+     *
+     **/
+    void initialize(Ice::ObjectAdapter adapter, Ice::Identity identity, string facet, Object servant);
+};
+
+
+/**
+ *
+ * This exception is raised if there are no further elements in the iteration.
+ *
+ **/
+local exception NoSuchElementException
+{
+};
+
+/**
+ *
+ * An iterator for the objects managed by the evictor.
+ * Note that an EvictorIterator is not thread-safe: the application needs to
+ * serialize access to a given EvictorIterator, for example by using it
+ * in just one thread.
+ *
+ * @see Evictor
+ *
+ **/
+local interface EvictorIterator
+{
+    /**
+     *
+     * Determines if the iteration has more elements.
+     *
+     * @return True if the iterator has more elements, false
+     * otherwise.
+     *
+     * @throws DatabaseException Raised if a database failure
+     * occurs while retrieving a batch of objects.
+     *
+     **/
+    bool hasNext();
+
+    /**
+     *
+     * Obtains the next identity in the iteration.
+     *
+     * @return The next identity in the iteration.
+     *
+     * @throws NoSuchElementException Raised if there is no further
+     * elements in the iteration.
+     *
+     * @throws DatabaseException Raised if a database failure
+     * occurs while retrieving a batch of objects.
+     **/
+    Ice::Identity next();
+};
+
+/**
+ *
+ * This exception is raised if the evictor has been deactivated.
+ *
+ **/
+local exception EvictorDeactivatedException
+{
+};
+
+
+/**
+ *
+ * An automatic Ice object persistence manager, based on the
+ * evictor pattern. The evictor is a servant locator implementation
+ * that stores the persistent state of its objects in a database. Any
+ * number of objects can be registered with an evictor, but only a
+ * configurable number of servants are active at a time.  These active
+ * servants reside in a queue; the least recently used servant in the
+ * queue is the first to be evicted when a new servant is activated.
+ *
+ *
+ * @see ServantInitializer
+ *
+ **/
+local interface Evictor extends Ice::ServantLocator
+{
+  
+    /**
+     *
+     * Set the size of the evictor's servant queue. This is the
+     * maximum number of servants the evictor keeps active. Requests
+     * to set the queue size to a value smaller than zero are ignored.
+     *
+     * @param sz The size of the servant queue. If the evictor
+     * currently holds more than <tt>sz</tt> servants in its queue, it evicts
+     * enough servants to match the new size. Note that this operation
+     * can block if the new queue size is smaller than the current
+     * number of servants that are servicing requests. In this case,
+     * the operation waits until a sufficient number of servants
+     * complete their requests.
+     *
+     *
+     * @throws EvictorDeactivatedException Raised if a the evictor has
+     * been deactivated.
+     *
+     * @see #getSize
+     *
+     **/
+    void setSize(int sz);
+
+    /**
+     *
+     * Get the size of the evictor's servant queue.
+     *
+     * @return The size of the servant queue.
+     *
+     * @throws EvictorDeactivatedException Raised if a the evictor has
+     * been deactivated.
+     *
+     * @see #setSize
+     *
+     **/
+    int getSize();
+
+
+    /**
+     *
+     * Add a servant to this evictor. The state of the servant passed to 
+     * this operation will be saved in the evictor's persistent store.
+     *
+     * @param servant The servant to add.
+     *
+     * @param id The identity of the Ice object that is implemented by 
+     * the servant.
+     *
+     * @return A proxy that matches the given identity and this evictor's
+     * object adapter.
+     *
+     * @throws Ice.AlreadyRegisteredException Raised if the evictor already has
+     * an object with this identity.
+     *
+     * @throws DatabaseException Raised if a database failure occurred.
+     *
+     * @throws EvictorDeactivatedException Raised if the evictor has
+     * been deactivated.
+     *
+     * @see #addFacet
+     * @see #remove
+     * @see #removeFacet
+     *
+     **/
+    Object* add(Object servant, Ice::Identity id);
+
+    /**
+     *
+     * Like {@link #add}, but with a facet. Calling <tt>add(servant, id)</tt>
+     * is equivalent to calling {@link #addFacet} with an empty
+     * facet.
+     *
+     * @param servant The servant to add.
+     *
+     * @param id The identity of the Ice object that is implemented by 
+     * the servant.
+     *
+     * @param facet The facet. An empty facet means the default
+     * facet.
+     *
+     * @return A proxy that matches the given identity and this evictor's
+     * object adapter.
+     *
+     * @throws Ice.AlreadyRegisteredException Raised if the evictor already has
+     * an object with this identity.
+     *
+     * @throws DatabaseException Raised if a database failure occurred.
+     *
+     * @throws EvictorDeactivatedException Raised if the evictor has
+     * been deactivated.
+     *
+     * @see #add
+     * @see #remove
+     * @see #removeFacet
+     *
+     **/
+    Object* addFacet(Object servant, Ice::Identity id, string facet);
+
+    //
+    // Note: no UUID operation as we don't know the category or 
+    // categories this evictor was registered with.
+    //
+
+    /**
+     *
+     * Permanently destroy an Ice object.
+     *
+     * @param id The identity of the Ice object.
+     *
+     * @return The removed servant.
+     *
+     * @throws Ice.NotRegisteredException Raised if this identity was not 
+     * registered with the evictor.
+     *
+     * @throws DatabaseException Raised if a database failure occurred.
+     *
+     * @throws EvictorDeactivatedException Raised if the evictor has
+     * been deactivated.
+     *
+     * @see #add
+     * @see #removeFacet
+     *
+     **/
+    Object remove(Ice::Identity id);
+
+    /**
+     *
+     * Like {@link #remove}, but with a facet. Calling <tt>remove(id)</tt> 
+     * is equivalent to calling {@link #removeFacet} with an empty facet.
+     *
+     * @param id The identity of the Ice object.
+     *
+     * @param facet The facet. An empty facet means the default
+     * facet.
+     *
+     * @return The removed servant.
+     *
+     * @throws Ice.NotRegisteredException Raised if this identity was not 
+     * registered with the evictor.
+     *
+     * @throws DatabaseException Raised if a database failure occurred.
+     *
+     * @throws EvictorDeactivatedException Raised if the evictor has
+     * been deactivated.
+     *
+     *
+     * @see #remove
+     * @see #addFacet
+     *
+     **/
+    Object removeFacet(Ice::Identity id, string facet);
+
+    /**
+     *
+     * Returns true if the given identity is managed by the evictor
+     * with the default facet.
+     *
+     * @return true if the identity is managed by the evictor, false
+     * otherwise.
+     *
+     * @throws DatabaseException Raised if a database failure occurred.
+     *
+     * @throws EvictorDeactivatedException Raised if a the evictor has
+     * been deactivated.
+     *
+     **/
+    bool hasObject(Ice::Identity id);
+
+    /**
+     * 
+     * Like {@link #hasObject}, but with a facet. Calling <tt>hasObject(id)</tt>
+     * is equivalent to calling {@link #hasFacet} with an empty
+     * facet.
+     *
+     * @return true if the identity is managed by the evictor for the
+     * given facet, false otherwise.
+     *
+     * @throws DatabaseException Raised if a database failure occurred.
+     *
+     * @throws EvictorDeactivatedException Raised if a the evictor has
+     * been deactivated.
+     *
+     **/
+    bool hasFacet(Ice::Identity id, string facet);  
+
+    /**
+     *
+     * Get an iterator for the identities managed by the evictor.
+     *
+     * @param facet The facet. An empty facet means the default
+     * facet.
+     *
+     * @param batchSize Internally, the Iterator retrieves the
+     * identities in batches of size batchSize. Selecting a small batchSize
+     * can have an adverse effect on performance.
+     *
+     * @return A new iterator.
+     *
+     * @throws EvictorDeactivatedException Raised if a the evictor has
+     * been deactivated.
+     *
+     **/
+    EvictorIterator getIterator(string facet, int batchSize);
+};
+
+};
+

data/slice/Freeze/EvictorF.ice

@@ -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.
+//
+// **********************************************************************
+
+#pragma once
+
+[["cpp:header-ext:h"]]
+
+module Freeze
+{
+
+local interface ServantInitializer;
+local interface BackgroundSaveEvictor;
+local interface TransactionalEvictor;
+
+};
+

data/slice/Freeze/EvictorStorage.ice

@@ -0,0 +1,72 @@
+// **********************************************************************
+//
+// 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.
+//
+// **********************************************************************
+
+#pragma once
+
+[["cpp:header-ext:h"]]
+
+#include <Ice/Identity.ice>
+
+module Freeze
+{
+
+/**
+ *
+ *  Evictors maintain statistics about each object, when using Ice encoding version 1.0.
+ *
+ **/
+struct Statistics
+{
+    /**
+     *
+     * The time the object was created, in milliseconds since Jan 1, 1970 0:00.
+     *
+     **/
+    long creationTime;
+
+    /**
+     *
+     * The time the object was last saved, in milliseconds relative to <tt>creationTime</tt>.
+     *
+     **/
+    long lastSaveTime;
+
+    /**
+     *
+     * The average time between saves, in milliseconds.
+     *
+     **/
+    long avgSaveTime;
+};
+
+/**
+ *
+ * ObjectRecord is the value-type for the persistent maps maintained by evictors 
+ * when using Ice encoding version is 1.0.
+ *
+ **/
+struct ObjectRecord
+{
+    /**
+     *
+     * The servant implementing the object.
+     *
+     **/
+    Object servant;
+
+    /**
+     *
+     * The statistics for the object. 
+     *
+     **/
+    Statistics stats;
+};
+
+};
+