# -*- coding: utf-8 -*-
#
# Copyright (c) ZeroC, Inc. All rights reserved.
#
#
# Ice version 3.7.6
#
# <auto-generated>
#
# Generated from file `ValueFactory.ice'
#
# Warning: do not edit this file.
#
# </auto-generated>
#

from sys import version_info as _version_info_
import Ice, IcePy

# Start of module Ice
_M_Ice = Ice.openModule('Ice')
__name__ = 'Ice'

if 'ValueFactory' not in _M_Ice.__dict__:
    _M_Ice.ValueFactory = Ice.createTempClass()
    class ValueFactory(object):
        """
        A factory for values. Value factories are used in several
        places, such as when Ice receives a class instance and
        when Freeze restores a persistent value. Value factories
        must be implemented by the application writer and registered
        with the communicator.
        """
        def __init__(self):
            if Ice.getType(self) == _M_Ice.ValueFactory:
                raise RuntimeError('Ice.ValueFactory is an abstract class')

        def create(self, type):
            """
            Create a new value for a given value type. The type is the
            absolute Slice type id, i.e., the id relative to the
            unnamed top-level Slice module. For example, the absolute
            Slice type id for an interface Bar in the module
            Foo is "::Foo::Bar".
            Note that the leading "::" is required.
            Arguments:
            type -- The value type.
            Returns: The value created for the given type, or nil if the factory is unable to create the value.
            """
            raise NotImplementedError("method 'create' not implemented")

        def __str__(self):
            return IcePy.stringify(self, _M_Ice._t_ValueFactory)

        __repr__ = __str__

    _M_Ice._t_ValueFactory = IcePy.defineValue('::Ice::ValueFactory', ValueFactory, -1, (), False, True, None, ())
    ValueFactory._ice_type = _M_Ice._t_ValueFactory

    _M_Ice.ValueFactory = ValueFactory
    del ValueFactory

if 'ValueFactoryManager' not in _M_Ice.__dict__:
    _M_Ice.ValueFactoryManager = Ice.createTempClass()
    class ValueFactoryManager(object):
        """
        A value factory manager maintains a collection of value factories.
        An application can supply a custom implementation during communicator
        initialization, otherwise Ice provides a default implementation.
        """
        def __init__(self):
            if Ice.getType(self) == _M_Ice.ValueFactoryManager:
                raise RuntimeError('Ice.ValueFactoryManager is an abstract class')

        def add(self, factory, id):
            """
            Add a value factory. Attempting to add a factory with an id for
            which a factory is already registered throws AlreadyRegisteredException.
            When unmarshaling an Ice value, the Ice run time reads the
            most-derived type id off the wire and attempts to create an
            instance of the type using a factory. If no instance is created,
            either because no factory was found, or because all factories
            returned nil, the behavior of the Ice run time depends on the
            format with which the value was marshaled:
            If the value uses the "sliced" format, Ice ascends the class
            hierarchy until it finds a type that is recognized by a factory,
            or it reaches the least-derived type. If no factory is found that
            can create an instance, the run time throws NoValueFactoryException.
            If the value uses the "compact" format, Ice immediately raises
            NoValueFactoryException.
            The following order is used to locate a factory for a type:
            The Ice run-time looks for a factory registered
            specifically for the type.
            If no instance has been created, the Ice run-time looks
            for the default factory, which is registered with an empty type id.
            If no instance has been created by any of the preceding
            steps, the Ice run-time looks for a factory that may have been
            statically generated by the language mapping for non-abstract classes.
            Arguments:
            factory -- The factory to add.
            id -- The type id for which the factory can create instances, or an empty string for the default factory.
            """
            raise NotImplementedError("method 'add' not implemented")

        def find(self, id):
            """
            Find an value factory registered with this communicator.
            Arguments:
            id -- The type id for which the factory can create instances, or an empty string for the default factory.
            Returns: The value factory, or null if no value factory was found for the given id.
            """
            raise NotImplementedError("method 'find' not implemented")

        def __str__(self):
            return IcePy.stringify(self, _M_Ice._t_ValueFactoryManager)

        __repr__ = __str__

    _M_Ice._t_ValueFactoryManager = IcePy.defineValue('::Ice::ValueFactoryManager', ValueFactoryManager, -1, (), False, True, None, ())
    ValueFactoryManager._ice_type = _M_Ice._t_ValueFactoryManager

    _M_Ice.ValueFactoryManager = ValueFactoryManager
    del ValueFactoryManager

# End of module Ice
