'Checks to ensure implicit tagging is not being used since it is
incompatible with Choice, then forwards on to Asn1Value.__init__()
:param name:
The name of the alternative to be set - used with value.
Alternatively this may be a dict with a single key being the name
and the value being the value, or a two-element tuple of the the
name and the value.
:param value:
The alternative value to set - used with name
:param tag_type:
The tag_type of the value - None, "implicit" or "explicit"
:raises:
ValueError - when tag_type is "implicit"'

def __init__(self, name=None, value=None, tag_type=None, **kwargs):

    kwargs[u'tag_type'] = tag_type
    Asn1Value.__init__(self, **kwargs)
    try:
        if (tag_type == u'implicit'):
            raise ValueError(unwrap(u'\n                                                                                The    Choice    type    can    not    be    implicitly    tagged    even    if    in    an\n                                                                                implicit    module    -    due    to    its    nature    any    tagging    must    be\n                                                                                explicit\n                                                                                '))
        if (name is not None):
            if isinstance(name, dict):
                if (len(name) != 1):
                    raise ValueError(unwrap(u'\n                                                                                                                When    passing    a    dict    as    the    "name"    argument    to    %s,\n                                                                                                                it    must    have    a    single    key/value    -    however    %d    were\n                                                                                                                present\n                                                                                                                ', type_name(self), len(name)))
                (name, value) = list(name.items())[0]
            if isinstance(name, tuple):
                if (len(name) != 2):
                    raise ValueError(unwrap(u'\n                                                                                                                When    passing    a    tuple    as    the    "name"    argument    to    %s,\n                                                                                                                it    must    have    two    elements,    the    name    and    value    -\n                                                                                                                however    %d    were    present\n                                                                                                                ', type_name(self), len(name)))
                value = name[1]
                name = name[0]
            if (name not in self._name_map):
                raise ValueError(unwrap(u'\n                                                                                                The    name    specified,    "%s",    is    not    a    valid    alternative\n                                                                                                for    %s\n                                                                                                ', name, type_name(self)))
            self._choice = self._name_map[name]
            (_, spec, params) = self._alternatives[self._choice]
            if (not isinstance(value, spec)):
                value = spec(value, **params)
            else:
                value = _fix_tagging(value, params)
            self._parsed = value
    except (ValueError, TypeError) as e:
        args = e.args[1:]
        e.args = (((e.args[0] + (u'\n                while    constructing    %s' % type_name(self))),) + args)
        raise e
