source: TI12-security/trunk/NDG_XACML/ndg/xacml/parsers/etree/attributereader.py @ 6747

"""NDG XACML ElementTree based reader for AttributeValue type

NERC DataGrid Project
"""
__author__ = "P J Kershaw"
__date__ = "16/03/10"
__copyright__ = "(C) 2010 Science and Technology Facilities Council"
__contact__ = "Philip.Kershaw@stfc.ac.uk"
__license__ = "BSD - see LICENSE file in top-level directory"
__contact__ = "Philip.Kershaw@stfc.ac.uk"
__revision__ = "$Id: $"
from abc import abstractmethod

from ndg.xacml.core.attribute import Expression, AttributeValue
from ndg.xacml.parsers import XMLParseError
from ndg.xacml.parsers.etree import QName
from ndg.xacml.parsers.etree.reader import ETreeAbstractReader


class ExpressionReader(ETreeAbstractReader):
    '''ElementTree based XACML Expression type parser
    '''
    TYPE = Expression
    
    def __call__(self, obj):
        """Parse AttributeValue object"""
        elem = super(ExpressionReader, self)._parse(obj)
        
        cls = self.__class__.TYPE
        expression = cls()
        
        localName = QName.getLocalPart(elem.tag)
        if localName != cls.ELEMENT_LOCAL_NAME:
            raise XMLParseError("No \"%s\" element found" % 
                                cls.ELEMENT_LOCAL_NAME)
        
        dataType = elem.attrib.get(cls.DATA_TYPE_ATTRIB_NAME)
        if dataType is None:
            raise XMLParseError('No "%s" attribute found in "%s" element' %
                                (cls.DATA_TYPE_ATTRIB_NAME, 
                                 cls.ELEMENT_LOCAL_NAME))
                
        expression.dataType = dataType
        
        self._parseExtension(elem, expression)
        
        return expression
        
    @abstractmethod
    def _parseExtension(self, elem, expression):
        """Derived classes should implement this method to read any remaining
        attributes and elements specific to their type"""
        raise NotImplementedError()
          
# Set up new class as an abstract base itself             
ETreeAbstractReader.register(ExpressionReader)


class AttributeValueReader(ExpressionReader):
    '''ElementTree based XACML AttributeValue type parser
    '''
    TYPE = AttributeValue
    
    def _parseExtension(self, elem, attributeValue):
        """Implement abstract method to complete parsing of attribute value"""
            
        if elem.text is None:
            raise XMLParseError('No attribute value element found parsing %r' % 
                                AttributeValueReader.TYPE.ELEMENT_LOCAL_NAME) 
              
        attributeValue.value = elem.text.strip()