Subclassificação ctypes - Python
Pergunta
Isto é algum código que encontrei na internet. Não tenho certeza como ele é feito para ser usado. Eu simplesmente preenchido membros com as enum chaves / valores e funciona, mas estou curioso o que este metaclass é tudo. Estou assumindo que tem algo a ver com ctypes, mas não consigo encontrar muita informação sobre ctypes subclasses. Eu sei EnumerationType não está fazendo nada do jeito que eu estou usando enumeração.
from ctypes import *
class EnumerationType(type(c_uint)):
def __new__(metacls, name, bases, dict):
if not "_members_" in dict:
_members_ = {}
for key,value in dict.items():
if not key.startswith("_"):
_members_[key] = value
dict["_members_"] = _members_
cls = type(c_uint).__new__(metacls, name, bases, dict)
for key,value in cls._members_.items():
globals()[key] = value
return cls
def __contains__(self, value):
return value in self._members_.values()
def __repr__(self):
return "<Enumeration %s>" % self.__name__
class Enumeration(c_uint):
__metaclass__ = EnumerationType
_members_ = {}
def __init__(self, value):
for k,v in self._members_.items():
if v == value:
self.name = k
break
else:
raise ValueError("No enumeration member with value %r" % value)
c_uint.__init__(self, value)
@classmethod
def from_param(cls, param):
if isinstance(param, Enumeration):
if param.__class__ != cls:
raise ValueError("Cannot mix enumeration members")
else:
return param
else:
return cls(param)
def __repr__(self):
return "<member %s=%d of %r>" % (self.name, self.value, self.__class__)
And an enumeration probably done the wrong way.
class TOKEN(Enumeration):
_members_ = {'T_UNDEF':0, 'T_NAME':1, 'T_NUMBER':2, 'T_STRING':3, 'T_OPERATOR':4, 'T_VARIABLE':5, 'T_FUNCTION':6}
Solução
A metaclasse é uma classe usada para criar classes. Pense nisso desta maneira:. Todos os objetos têm uma classe, uma classe também é um objeto, portanto, faz sentido que uma classe pode ter uma classe
http://www.ibm.com/developerworks/linux /library/l-pymeta.html
Para entender o que isso está fazendo, você pode olhar para alguns pontos no código.
_members_ = {'T_UNDEF':0, 'T_NAME':1, 'T_NUMBER':2, 'T_STRING':3, 'T_OPERATOR':4, 'T_VARIABLE':5, 'T_FUNCTION':6}
globals()[key] = value
Aqui é preciso cada chave definida no seu dicionário: "T_UNDEF" "T_NUMBER" e os torna disponíveis em seus globals Dictionary
def __init__(self, value):
for k,v in self._members_.items():
if v == value:
self.name = k
break
Sempre que você faz uma instância de sua enumeração, ele irá verificar para ver se o "valor" está na sua lista de nomes de enum permitidas quando inicializado a classe. Quando o valor for encontrado, ele define o nome string para self.name.
c_uint.__init__(self, value)
Esta é a linha real que define o "valor ctypes" para um inteiro sem sinal real c.
Outras dicas
Isso é realmente uma classe estranho.
A maneira como você está usando ele está correto, embora de outra forma seria:
class TOKEN(Enumeration):
T_UNDEF = 0
T_NAME = 1
T_NUMBER = 2
T_STRING = 3
T_OPERATOR = 4
T_VARIABLE = 5
T_FUNCTION = 6
(que é o que os primeiros 6 linhas em __new__
são para)
Em seguida, você pode usá-lo assim:
>>> TOKEN
<Enumeration TOKEN>
>>> TOKEN(T_NAME)
<member T_NAME=1 of <Enumeration TOKEN>>
>>> T_NAME in TOKEN
True
>>> TOKEN(1).name
'T_NAME'
O método from_param
parece ser por conveniência, para escrever métodos que aceitam tanto um int ou um objeto Enumeration
. Não tenho certeza se isso é realmente o seu propósito.
Eu acho que essa classe é feito para ser usado quando se trabalha com APIs externos os enums uso c-estilo, mas parece que um monte de trabalho para muito pouco ganho.