path: root/qpid/extras/qmf/src/py/qmf2-prototype/common.py

# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.
#
import time
from logging import getLogger
from threading import Lock
from threading import Condition
try:
    import hashlib
    _md5Obj = hashlib.md5
except ImportError:
    import md5
    _md5Obj = md5.new

log = getLogger("qmf")
log_query = getLogger("qmf.query")


##
## Constants
##

QMF_APP_ID="qmf2"


class ContentType(object):
    """ Values for the 'qmf.content' message header
    """
    schema_package = "_schema_package"
    schema_id = "_schema_id"
    schema_class = "_schema_class"
    object_id = "_object_id"
    data = "_data"
    event = "_event"


class OpCode(object):
    """ Values for the 'qmf.opcode' message header.
    """
    noop = "_noop"

    # codes sent by a console and processed by the agent
    agent_locate_req = "_agent_locate_request"
    subscribe_req = "_subscribe_request"
    subscribe_cancel_ind = "_subscribe_cancel_indication"
    subscribe_refresh_ind = "_subscribe_refresh_indication"
    query_req = "_query_request"
    method_req = "_method_request"


    # codes sent by the agent to a console
    agent_locate_rsp = "_agent_locate_response"
    agent_heartbeat_ind = "_agent_heartbeat_indication"
    query_rsp = "_query_response"
    subscribe_rsp = "_subscribe_response"
    data_ind = "_data_indication"
    method_rsp = "_method_response"



def timedelta_to_secs(td):
    """
    Convert a time delta to a time interval in seconds (float)
    """
    return td.days * 86400 + td.seconds + td.microseconds/1000000.0


##==============================================================================
## Async Event Model
##==============================================================================


class Notifier(object):
    """
    Virtual base class that defines a call back which alerts the application that
    a QMF Console notification is pending.
    """
    def indication(self):
        """
        Called when one or more items are ready for the application to process.
        This method may be called by an internal QMF library thread.  Its purpose is to
        indicate that the application should process pending work items.
        """
        raise Exception("The indication method must be overridden by the application!")



class WorkItem(object):
    """
    Describes an event that has arrived for the application to process.  The
    Notifier is invoked when one or more of these WorkItems become available
    for processing. 
    """
    # Enumeration of the types of WorkItems produced on the Console
    AGENT_ADDED=1
    AGENT_DELETED=2
    NEW_PACKAGE=3
    NEW_CLASS=4
    OBJECT_UPDATE=5
    EVENT_RECEIVED=7
    AGENT_HEARTBEAT=8
    QUERY_COMPLETE=9
    METHOD_RESPONSE=10
    SUBSCRIBE_RESPONSE=11
    SUBSCRIBE_INDICATION=12
    RESUBSCRIBE_RESPONSE=13
    # Enumeration of the types of WorkItems produced on the Agent
    METHOD_CALL=1000
    QUERY=1001
    SUBSCRIBE_REQUEST=1002
    RESUBSCRIBE_REQUEST=1003
    UNSUBSCRIBE_REQUEST=1004

    def __init__(self, kind, handle, _params=None):
        """
        Used by the Console to create a work item.
        
        @type kind: int
        @param kind: work item type
        """
        self._kind = kind
        self._handle = handle
        self._params = _params

    def get_type(self):
        return self._kind

    def get_handle(self):
        return self._handle

    def get_params(self):
        return self._params



##==============================================================================
## Addressing
##==============================================================================

class QmfAddress(object):
    """
    Address format: "qmf.<domain>.[topic|direct]/<subject>"
    TBD
    """

    TYPE_DIRECT = "direct"
    TYPE_TOPIC = "topic"

    ADDRESS_FMT = "qmf.%s.%s/%s"
    DEFAULT_DOMAIN = "default"

    # Directly-addressed messages:
    # agent's direct address: "qmf.<domain>.direct/<agent-name>
    # console's direct address: "qmf.<domain>.direct/<console-name>

    # Well-known Topic Addresses:
    # "qmf.<domain>.topic/<subject>
    # Where <subject> has the following format:
    #   "console.ind#" - indications sent from consoles
    #   "agent.ind#" - indications sent from agents
    #
    # The following "well known" subjects are defined:
    #
    # console.ind.locate[.<agent-name>] - agent discovery request
    # agent.ind.heartbeat[.<agent-name>"] - agent heartbeats
    # agent.ind.event[.<severity>.<agent-name>] - events
    # agent.ind.schema[TBD] - schema updates
    #
    SUBJECT_AGENT_IND="agent.ind"
    SUBJECT_AGENT_HEARTBEAT = "agent.ind.heartbeat"
    SUBJECT_AGENT_EVENT="agent.ind.event"
    SUBJECT_AGENT_SCHEMA="agent.ind.schema"

    SUBJECT_CONSOLE_IND="console.ind"
    SUBJECT_CONSOLE_LOCATE_AGENT="console.ind.locate"
    


    def __init__(self, subject, domain, type_):
        if '/' in domain or '.' in domain:
            raise Exception("domain string must not contain '/' or '.'"
                            " characters.")

        self._subject = subject
        self._domain = domain
        self._type = type_

    def _direct(cls, subject, _domain=None):
        if _domain is None:
            _domain = QmfAddress.DEFAULT_DOMAIN
        return cls(subject, _domain, type_=QmfAddress.TYPE_DIRECT)
    direct = classmethod(_direct)

    def _topic(cls, subject, _domain=None):
        if _domain is None:
            _domain = QmfAddress.DEFAULT_DOMAIN
        return cls(subject, _domain, type_=QmfAddress.TYPE_TOPIC)
    topic = classmethod(_topic)

    def __from_string(cls, address):
        node,subject = address.split('/',1)
        qmf,domain,type_ = node.split('.',2)

        if qmf != "qmf" or (type_ != QmfAddress.TYPE_DIRECT and 
                            type_ != QmfAddress.TYPE_TOPIC):
            raise ValueError("invalid QmfAddress format: %s" % address)

        return cls(subject, domain, type_)
    from_string = classmethod(__from_string)

    def get_address(self):
        """
        Return the QMF address as a string, suitable for use with the AMQP
        messaging API.
        """
        return str(self)

    def get_node(self):
        """
        Return the 'node' portion of the address.
        """
        return self.get_address().split('/',1)[0]

    def get_subject(self):
        """
        Return the 'subject' portion of the address.
        """
        return self.get_address().split('/',1)[1]

    def get_domain(self):
        return self._domain

    def is_direct(self):
        return self._type == self.TYPE_DIRECT

    def __repr__(self):
        return QmfAddress.ADDRESS_FMT % (self._domain, self._type, self._subject)




class AgentName(object):
    """
    Uniquely identifies a management agent within the management domain.
    """
    _separator = ":"

    def __init__(self, vendor, product, name, _str=None):
        """
        Note: this object must be immutable, as it is used to index into a dictionary
        """
        if _str is not None:
            # construct from string representation
            if _str.count(AgentName._separator) < 2:
                raise TypeError("AgentName string format must be 'vendor.product.name'")
            self._vendor, self._product, self._name = _str.split(AgentName._separator)
        else:
            self._vendor = vendor
            self._product = product
            self._name = name


    def _from_str(cls, str_):
        return cls(None, None, None, str_=str_)
    from_str = classmethod(_from_str)

    def vendor(self):
        return self._vendor

    def product(self):
        return self._product

    def name(self):
        return self._name

    def __cmp__(self, other):
        if not isinstance(other, AgentName) :
            raise TypeError("Invalid types for compare")
            # return 1
        me = str(self)
        them = str(other)

        if me < them:
            return -1
        if me > them:
            return 1
        return 0

    def __hash__(self):
        return (self._vendor, self._product, self._name).__hash__()

    def __repr__(self):
        return self._vendor + AgentName._separator + \
            self._product + AgentName._separator + \
            self._name



##==============================================================================
## DATA MODEL
##==============================================================================


class _mapEncoder(object):
    """ 
    virtual base class for all objects that support being converted to a map
    """

    def map_encode(self):
        raise Exception("The map_encode method my be overridden.")


class QmfData(_mapEncoder):
    """
    Base class representing management data.

    Map format:
    map["_values"] = map of unordered "name"=<value> pairs (optional)
    map["_subtype"] = map of unordered "name"="subtype string" pairs (optional)
    map["_tag"] = application-specific tag for this instance (optional)
    """
    KEY_VALUES = "_values"
    KEY_SUBTYPES = "_subtypes"
    KEY_TAG="_tag"
    KEY_OBJECT_ID = "_object_id"
    KEY_SCHEMA_ID = "_schema_id"
    KEY_UPDATE_TS = "_update_ts"
    KEY_CREATE_TS = "_create_ts"
    KEY_DELETE_TS = "_delete_ts"

    def __init__(self,
                 _values={}, _subtypes={}, _tag=None,
                 _object_id=None, _schema_id=None,
                 _ctime = 0, _utime = 0, _dtime = 0,
                 _map=None, _const=False):
        """
        @type _values: dict
        @param _values: dictionary of initial name=value pairs for object's
        named data. 
        @type _subtypes: dict
        @param _subtype: dictionary of subtype strings for each of the object's
        named data. 
        @type _desc: string
        @param _desc: Human-readable description of this data object.
        @type _const: boolean
        @param _const: if true, this object cannot be modified
        """
        if _map is not None:
            # construct from map
            _tag = _map.get(self.KEY_TAG, _tag)
            _values = _map.get(self.KEY_VALUES, _values)
            _subtypes = _map.get(self.KEY_SUBTYPES, _subtypes)
            _object_id = _map.get(self.KEY_OBJECT_ID, _object_id)
            sid = _map.get(self.KEY_SCHEMA_ID)
            if sid:
                _schema_id = SchemaClassId.from_map(sid)
            _ctime = long(_map.get(self.KEY_CREATE_TS, _ctime))
            _utime = long(_map.get(self.KEY_UPDATE_TS, _utime))
            _dtime = long(_map.get(self.KEY_DELETE_TS, _dtime))

        self._values = _values.copy()
        self._subtypes = _subtypes.copy()
        self._tag = _tag
        self._ctime = _ctime
        self._utime = _utime
        self._dtime = _dtime
        self._const = _const
        self._schema_id = _schema_id
        self._object_id = str(_object_id)


    def __create(cls, values, _subtypes={}, _tag=None, _object_id=None,
                _schema_id=None, _const=False):
        # timestamp in millisec since epoch UTC
        ctime = long(time.time() * 1000)
        return cls(_values=values, _subtypes=_subtypes, _tag=_tag,
                   _ctime=ctime, _utime=ctime,
                   _object_id=_object_id, _schema_id=_schema_id, _const=_const)
    create = classmethod(__create)

    def __from_map(cls, map_, _const=False):
        return cls(_map=map_, _const=_const)
    from_map = classmethod(__from_map)

    def is_managed(self):
        return self._object_id is not None

    def is_described(self):
        return self._schema_id is not None

    def get_tag(self):
        return self._tag

    def get_value(self, name):
        """
        Will throw an AttributeError exception if the named value does not exist.
        """
        # meta-properties first:
        if name == SchemaClassId.KEY_PACKAGE:
            if self._schema_id:
                return self._schema_id.get_package_name()
            return None
        if name == SchemaClassId.KEY_CLASS:
            if self._schema_id:
                return self._schema_id.get_class_name()
            return None
        if name == SchemaClassId.KEY_TYPE:
            if self._schema_id:
                return self._schema_id.get_type()
            return None
        if name == SchemaClassId.KEY_HASH:
            if self._schema_id:
                return self._schema_id.get_hash_string()
            return None
        if name == self.KEY_SCHEMA_ID:
            return self._schema_id
        if name == self.KEY_OBJECT_ID:
            return self._object_id
        if name == self.KEY_TAG:
            return self._tag
        if name == self.KEY_UPDATE_TS:
            return self._utime
        if name == self.KEY_CREATE_TS:
            return self._ctime
        if name == self.KEY_DELETE_TS:
            return self._dtime

        try:
            return self._values[name]
        except KeyError:
            raise AttributeError("no value named '%s' in this object" % name)

    def has_value(self, name):

        if name in [SchemaClassId.KEY_PACKAGE, SchemaClassId.KEY_CLASS,
                    SchemaClassId.KEY_TYPE, SchemaClassId.KEY_HASH,
                    self.KEY_SCHEMA_ID]:
            return self._schema_id is not None
        if name in [self.KEY_UPDATE_TS, self.KEY_CREATE_TS,
                    self.KEY_DELETE_TS]:
            return True
        if name == self.KEY_OBJECT_ID:
            return self._object_id is not None
        if name == self.KEY_TAG:
            return self._tag is not None

        return name in self._values

    def set_value(self, _name, _value, _subType=None):
        if self._const:
            raise Exception("cannot modify constant data object")
        self._values[_name] = _value
        if _subType:
            self._subtypes[_name] = _subType
        return _value

    def get_subtype(self, _name):
        return self._subtypes.get(_name)

    def get_schema_class_id(self): 
        """
        @rtype: class SchemaClassId
        @returns: the identifier of the Schema that describes the structure of the data.
        """
        return self._schema_id

    def get_object_id(self): 
        """
        Get the instance's identification string.
        @rtype: str
        @returns: the identification string, or None if not assigned and id. 
        """
        return self._object_id

    def map_encode(self):
        _map = {}
        if self._tag:
            _map[self.KEY_TAG] = self._tag

        # data in the _values map may require recursive map_encode()
        vmap = {}
        for name,val in self._values.iteritems():
            if isinstance(val, _mapEncoder):
                vmap[name] = val.map_encode()
            else:
                # otherwise, just toss in the native type...
                vmap[name] = val

        _map[self.KEY_VALUES] = vmap
        # subtypes are never complex, so safe to just copy
        _map[self.KEY_SUBTYPES] = self._subtypes.copy()
        if self._object_id:
            _map[self.KEY_OBJECT_ID] = self._object_id
        if self._schema_id:
            _map[self.KEY_SCHEMA_ID] = self._schema_id.map_encode()
        return _map

    def __repr__(self):
        return "QmfData=<<" + str(self.map_encode()) + ">>"
        

    def __setattr__(self, _name, _value):
        # ignore private data members
        if _name[0] == '_':
            return super(QmfData, self).__setattr__(_name, _value)
        if _name in self._values:
            return self.set_value(_name, _value)
        return super(QmfData, self).__setattr__(_name, _value)

    def __getattr__(self, _name):
        if _name != "_values" and _name in self._values: 
            return self._values[_name]
        raise AttributeError("no value named '%s' in this object" % _name)

    def __getitem__(self, _name):
        return self.__getattr__(_name)

    def __setitem__(self, _name, _value):
        return self.__setattr__(_name, _value)



class QmfEvent(QmfData):
    """
    A QMF Event is a type of described data that is not managed. Events are 
    notifications that are sent by Agents. An event notifies a Console of a 
    change in some aspect of the system under managment.
    """
    KEY_TIMESTAMP = "_timestamp"
    KEY_SEVERITY = "_severity"

    SEV_EMERG = "emerg"
    SEV_ALERT = "alert"
    SEV_CRIT = "crit"
    SEV_ERR = "err"
    SEV_WARNING = "warning"
    SEV_NOTICE = "notice"
    SEV_INFO = "info"
    SEV_DEBUG = "debug"

    def __init__(self, _timestamp=None, _sev=SEV_NOTICE, _values={},
                 _subtypes={}, _tag=None,
                 _map=None,
                 _schema_id=None, _const=True):
        """
        @type _map: dict
        @param _map: if not None, construct instance from map representation. 
        @type _timestamp: int
        @param _timestamp: moment in time when event occurred, expressed
               as milliseconds since Midnight, Jan 1, 1970 UTC.
        @type _agentId: class AgentId
        @param _agentId: Identifies agent issuing this event.
        @type _schema: class Schema
        @param _schema:
        @type _schemaId: class SchemaClassId (event)
        @param _schemaId: identi
        """

        if _map is not None:
            # construct from map
            super(QmfEvent, self).__init__(_map=_map, _const=_const,
                                           _object_id="_event")
            _timestamp = _map.get(self.KEY_TIMESTAMP, _timestamp)
            _sev = _map.get(self.KEY_SEVERITY, _sev)
        else:
            super(QmfEvent, self).__init__(_object_id="_event",
                                           _values=_values,
                                           _subtypes=_subtypes, _tag=_tag,
                                           _schema_id=_schema_id,
                                           _const=_const)
        if _timestamp is None:
            raise TypeError("QmfEvent: a valid timestamp is required.")

        try:
            self._timestamp = long(_timestamp)
        except:
            raise TypeError("QmfEvent: a numeric timestamp is required.")

        self._severity = _sev

    def _create(cls, timestamp, severity, values,
                _subtypes={}, _tag=None, _schema_id=None, _const=False):
        return cls(_timestamp=timestamp, _sev=severity, _values=values,
                _subtypes=_subtypes, _tag=_tag, _schema_id=_schema_id, _const=_const)
    create = classmethod(_create)

    def _from_map(cls, map_, _const=False):
        return cls(_map=map_, _const=_const)
    from_map = classmethod(_from_map)

    def get_timestamp(self): 
        return self._timestamp

    def get_severity(self):
        return self._severity

    def map_encode(self):
        _map = super(QmfEvent, self).map_encode()
        _map[self.KEY_TIMESTAMP] = self._timestamp
        _map[self.KEY_SEVERITY] = self._severity
        return _map



##==============================================================================
## QUERY
##==============================================================================



class QmfQuery(_mapEncoder):

    KEY_TARGET="what"
    KEY_PREDICATE="where"
    KEY_ID="id"

    ### Query Types
    ID=1
    PREDICATE=2

    #### Query Targets ####
    TARGET_PACKAGES="schema_package"
    # (returns just package names)
    # allowed predicate key(s):
    #
    # SchemaClassId.KEY_PACKAGE

    TARGET_SCHEMA_ID="schema_id"
    TARGET_SCHEMA="schema"
    # allowed id: value:
    # SchemaClassId
    #
    # allowed predicate key(s):
    # SchemaClassId.KEY_PACKAGE
    # SchemaClassId.KEY_CLASS
    # SchemaClassId.KEY_TYPE
    # SchemaClassId.KEY_HASH
    # SchemaClass.KEY_SCHEMA_ID
    # name of property (exist test only)
    # name of method (exist test only)

    TARGET_AGENT="agent"
    # allowed id: value:
    # string name of agent
    # allowed predicate keys(s):
    # 
    KEY_AGENT_NAME="_name"

    TARGET_OBJECT_ID="object_id"
    TARGET_OBJECT="object"
    # If object is described by a schema, the value of the target map must
    # include a "_schema_id": {map encoded schema id} value.
    #
    # allowed id: value:
    # object_id string
    #
    # allowed predicate keys(s):
    #
    # QmfData.KEY_OBJECT_ID
    # QmfData.KEY_UPDATE_TS
    # QmfData.KEY_CREATE_TS
    # QmfData.KEY_DELETE_TS
    # <name of data value>

    # supported predicate operators

    # evaluation operators
    QUOTE="quote"
    UNQUOTE="unquote"
    # boolean operators
    EQ="eq"
    NE="ne"
    LT="lt"
    LE="le"
    GT="gt"
    GE="ge"
    RE_MATCH="re_match"
    EXISTS="exists"
    TRUE="true"
    FALSE="false"
    # logic operators
    AND="and"
    OR="or"
    NOT="not"

    _valid_targets = [TARGET_PACKAGES, TARGET_OBJECT_ID, TARGET_SCHEMA, TARGET_SCHEMA_ID, 
                      TARGET_OBJECT, TARGET_AGENT]
    _valid_bool_ops = [EQ, NE, LT, GT, LE, GE, EXISTS, RE_MATCH, TRUE, FALSE]
    _valid_logic_ops = [AND, OR, NOT]
    _valid_eval_ops = [QUOTE, UNQUOTE]

    def __init__(self, _target=None, _target_params=None, _predicate=None,
                 _id=None, _map=None):
        """
        """
        if _map is not None:
            target_map = _map.get(self.KEY_TARGET)
            if not target_map:
                raise TypeError("QmfQuery requires a target map")

            _target = None
            for key in target_map.iterkeys():
                if key in self._valid_targets:
                    _target = key
                    break
            if _target is None:
                raise TypeError("Invalid QmfQuery target: '%s'" %
                                str(target_map))

            # convert target params from map format
            _target_params = target_map.get(_target)
            if _target_params:
                if not isinstance(_target_params, type({})):
                    raise TypeError("target params must be a map: '%s'" %
                                    str(_target_params))
                t_params = {}
                for name,value in _target_params.iteritems():
                    if name == QmfData.KEY_SCHEMA_ID:
                        t_params[name] = SchemaClassId.from_map(value)
                    else:
                        t_params[name] = value
                _target_params = t_params

            _id = _map.get(self.KEY_ID)
            if _id is not None:
                # Convert identifier to native type if necessary
                if _target == self.TARGET_SCHEMA:
                    _id = SchemaClassId.from_map(_id)
            else: 
                _predicate = _map.get(self.KEY_PREDICATE, _predicate)

        self._target = _target
        if not self._target:
            raise TypeError("QmfQuery requires a target value")
        self._target_params = _target_params
        self._predicate = _predicate
        self._id = _id

    # constructors
    def _create_wildcard(cls, target, _target_params=None):
        return cls(_target=target, _target_params=_target_params)
    create_wildcard = classmethod(_create_wildcard)

    def _create_wildcard_object_id(cls, schema_id):
        """
        Create a wildcard to match all object_ids for a given schema.
        """
        if not isinstance(schema_id, SchemaClassId):
            raise TypeError("class SchemaClassId expected")
        params = {QmfData.KEY_SCHEMA_ID: schema_id}
        return cls(_target=QmfQuery.TARGET_OBJECT_ID,
                   _target_params=params)
    create_wildcard_object_id = classmethod(_create_wildcard_object_id)

    def _create_wildcard_object(cls, schema_id):
        """
        Create a wildcard to match all objects for a given schema.
        """
        if not isinstance(schema_id, SchemaClassId):
            raise TypeError("class SchemaClassId expected")
        params = {QmfData.KEY_SCHEMA_ID: schema_id}
        return cls(_target=QmfQuery.TARGET_OBJECT,
                   _target_params=params)
    create_wildcard_object = classmethod(_create_wildcard_object)

    def _create_predicate(cls, target, predicate, _target_params=None): 
        return cls(_target=target, _target_params=_target_params,
                   _predicate=predicate)
    create_predicate = classmethod(_create_predicate)

    def _create_id(cls, target, ident, _target_params=None): 
        return cls(_target=target, _target_params=_target_params, _id=ident)
    create_id = classmethod(_create_id)

    def _create_id_object(cls, object_id, _schema_id=None):
        """
        Create a ID Query for an object (schema optional).
        """
        if _schema_id is not None:
            if not isinstance(_schema_id, SchemaClassId):
                raise TypeError("class SchemaClassId expected")
            params = {QmfData.KEY_SCHEMA_ID: _schema_id}
        else:
            params = None
        return cls(_target=QmfQuery.TARGET_OBJECT,
                   _id=object_id,
                   _target_params=params)
    create_id_object = classmethod(_create_id_object)

    def _create_id_object_id(cls, object_id, _schema_id=None):
        """
        Create a ID Query for object_ids (schema optional).
        """
        if _schema_id is not None:
            if not isinstance(_schema_id, SchemaClassId):
                raise TypeError("class SchemaClassId expected")
            params = {QmfData.KEY_SCHEMA_ID: _schema_id}
        else:
            params = None
        return cls(_target=QmfQuery.TARGET_OBJECT_ID,
                   _id=object_id,
                   _target_params=params)
    create_id_object_id = classmethod(_create_id_object_id)

    def _from_map(cls, map_):
        return cls(_map=map_)
    from_map = classmethod(_from_map)
    # end constructors

    def get_target(self):
        return self._target

    def get_target_param(self):
        return self._target_params

    def get_selector(self):
        if self._id:
            return QmfQuery.ID
        else:
            return QmfQuery.PREDICATE

    def get_id(self):
        return self._id

    def get_predicate(self):
        """
        """
        return self._predicate

    def evaluate(self, qmfData):
        """
        """
        if self._id:
            if self._target == self.TARGET_SCHEMA:
                return (qmfData.has_value(qmfData.KEY_SCHEMA_ID) and
                        qmfData.get_value(qmfData.KEY_SCHEMA_ID) == self._id)
            elif self._target == self.TARGET_OBJECT:
                return (qmfData.has_value(qmfData.KEY_OBJECT_ID) and
                        qmfData.get_value(qmfData.KEY_OBJECT_ID) == self._id)
            elif self._target == self.TARGET_AGENT:
                return (qmfData.has_value(self.KEY_AGENT_NAME) and
                        qmfData.get_value(self.KEY_AGENT_NAME) == self._id)

            raise Exception("Unsupported query target '%s'" % str(self._target))

        if self._predicate:
            return self._eval_pred(self._predicate, qmfData)
        # no predicate and no id - always match
        return True

    def map_encode(self):
        t_params = {}
        if self._target_params:
            for name,value in self._target_params.iteritems():
                if isinstance(value, _mapEncoder):
                    t_params[name] = value.map_encode()
                else:
                    t_params[name] = value
        if t_params:
            _map = {self.KEY_TARGET: {self._target: t_params}}
        else:
            _map = {self.KEY_TARGET: {self._target: None}}

        if self._id is not None:
            if isinstance(self._id, _mapEncoder):
                _map[self.KEY_ID] = self._id.map_encode()
            else:
                _map[self.KEY_ID] = self._id
        elif self._predicate is not None:
            _map[self.KEY_PREDICATE] = self._predicate
        return _map

    def _eval_pred(self, pred, qmfData):
        """
        Evaluate the predicate expression against a QmfData object.
        """
        if not isinstance(qmfData, QmfData):
            raise TypeError("Query expects to evaluate QmfData types.")

        if not isinstance(pred, type([])):
            log.warning("Invalid type for predicate expression: '%s'" % str(pred))
            return False

        # empty predicate - match all???
        if len(pred) == 0:
            return True

        oper = pred[0]
        if oper == QmfQuery.TRUE:
            log_query.debug("query evaluate TRUE")
            return True

        if oper == QmfQuery.FALSE:
            log_query.debug("query evaluate FALSE")
            return False

        if oper == QmfQuery.AND:
            log_query.debug("query evaluate AND: '%s'" % str(pred))
            for exp in pred[1:]:
                if not self._eval_pred(exp, qmfData):
                    log_query.debug("---> False")
                    return False
            log_query.debug("---> True")
            return True

        if oper == QmfQuery.OR:
            log_query.debug("query evaluate OR: [%s]" % str(pred))
            for exp in pred[1:]:
                if self._eval_pred(exp, qmfData):
                    log_query.debug("---> True")
                    return True
            log_query.debug("---> False")
            return False

        if oper == QmfQuery.NOT:
            log_query.debug("query evaluate NOT: [%s]" % str(pred))
            for exp in pred[1:]:
                if self._eval_pred(exp, qmfData):
                    log_query.debug("---> False")
                    return False
            log_query.debug("---> True")
            return True

        if oper == QmfQuery.EXISTS:
            if len(pred) != 2:
                log.warning("Malformed query: 'exists' operator"
                            " - bad arguments '%s'" % str(pred))
                return False
            ### Q: Should we assume "quote", or should it be explicit?
            ### "foo" or ["quote" "foo"] 
            ### my guess is "explicit"
            log_query.debug("query evaluate EXISTS: [%s]" % str(pred))
            try:
                arg = self._fetch_pred_arg(pred[1], qmfData)
            except AttributeError:
                log.warning("query parameter not found: '%s'" % str(pred))
                return False
            v = qmfData.has_value(arg)
            log_query.debug("---> %s" % str(v))
            return v

        # binary operators
        if oper in [QmfQuery.EQ, QmfQuery.NE, QmfQuery.LT,
                    QmfQuery.LE, QmfQuery.GT, QmfQuery.GE,
                    QmfQuery.RE_MATCH]:
            if len(pred) != 3:
                log.warning("Malformed query: '%s' operator"
                            " - requires 2 arguments '%s'" %
                            (oper, str(pred)))
                return False
            # @todo: support regular expression match
            log_query.debug("query evaluate binary op: [%s]" % str(pred))
            try:
                arg1 = self._fetch_pred_arg(pred[1], qmfData)
                arg2 = self._fetch_pred_arg(pred[2], qmfData)
            except AttributeError:
                log.warning("query parameter not found: '%s'" % str(pred))
                return False
            log_query.debug("query evaluate %s: %s, %s" % (oper, str(arg1), str(arg2)))
            v = False
            try:
                if oper == QmfQuery.EQ: v = arg1 == arg2
                elif oper == QmfQuery.NE: v = arg1 != arg2
                elif oper == QmfQuery.LT: v = arg1 < arg2
                elif oper == QmfQuery.LE: v = arg1 <= arg2
                elif oper == QmfQuery.GT: v = arg1 > arg2
                elif oper == QmfQuery.GE: v = arg1 >= arg2
            except TypeError:
                log.warning("query comparison failed: '%s'" %  str(pred))
            log_query.debug("---> %s" % str(v))
            return v

        log.warning("Unrecognized query operator: [%s]" % str(pred[0]))
        return False

    def _fetch_pred_arg(self, arg, qmfData):
        """
        Determine the value of a predicate argument by evaluating quoted
        arguments.
        """
        if isinstance(arg, basestring):
            return qmfData.get_value(arg)
        if isinstance(arg, type([])) and len(arg) == 2:
            if arg[0] == QmfQuery.QUOTE:
                return arg[1]
            if arg[0] == QmfQuery.UNQUOTE:
                return qmfData.get_value(arg[1])
        return arg

    def __repr__(self):
        return "QmfQuery=<<" + str(self.map_encode()) + ">>"





##==============================================================================
## SCHEMA
##==============================================================================


# Argument typecodes, access, and direction qualifiers

class qmfTypes(object):
    TYPE_UINT8      = 1
    TYPE_UINT16     = 2
    TYPE_UINT32     = 3
    TYPE_UINT64     = 4

    TYPE_SSTR       = 6
    TYPE_LSTR       = 7

    TYPE_ABSTIME    = 8
    TYPE_DELTATIME  = 9

    TYPE_REF        = 10

    TYPE_BOOL       = 11

    TYPE_FLOAT      = 12
    TYPE_DOUBLE     = 13

    TYPE_UUID       = 14

    TYPE_MAP        = 15

    TYPE_INT8       = 16
    TYPE_INT16      = 17
    TYPE_INT32      = 18
    TYPE_INT64      = 19

    TYPE_OBJECT     = 20

    TYPE_LIST       = 21

    TYPE_ARRAY      = 22

# New subtypes:
# integer (for time, duration, signed/unsigned)
# double (float)
# bool
# string
# map (ref, qmfdata)
# list
# uuid


class qmfAccess(object):
    READ_CREATE = 1 
    READ_WRITE = 2
    READ_ONLY = 3


class qmfDirection(object):
    DIR_IN = 1
    DIR_OUT = 2
    DIR_IN_OUT = 3



def _to_bool( param ):
    """
    Helper routine to convert human-readable representations of
    boolean values to python bool types.
    """
    _false_strings = ["off", "no", "false", "0", "none"]
    _true_strings =  ["on",  "yes", "true", "1"]
    if type(param) == str:
        lparam = param.lower()
        if lparam in _false_strings:
            return False
        if lparam in _true_strings:
            return True
        raise TypeError("unrecognized boolean string: '%s'" % param )
    else:
        return bool(param)



class SchemaClassId(_mapEncoder):
    """ 
    Unique identifier for an instance of a SchemaClass.

    Map format:
    map["package_name"] = str, name of associated package
    map["class_name"] = str, name of associated class
    map["type"] = str, "data"|"event", default: "data"
    optional:
    map["hash_str"] = str, hash value in standard format or None 
    if hash is unknown.
    """
    KEY_PACKAGE="_package_name"
    KEY_CLASS="_class_name"
    KEY_TYPE="_type"
    KEY_HASH="_hash_str"

    TYPE_DATA = "_data"
    TYPE_EVENT = "_event"

    _valid_types=[TYPE_DATA, TYPE_EVENT]
    _schemaHashStrFormat = "%08x-%08x-%08x-%08x"
    _schemaHashStrDefault = "00000000-00000000-00000000-00000000"

    def __init__(self, pname=None, cname=None, stype=TYPE_DATA, hstr=None,
                 _map=None): 
        """
        @type pname: str
        @param pname: the name of the class's package
        @type cname: str
        @param cname: name of the class
        @type stype: str
        @param stype: schema type [data | event]
        @type hstr: str
        @param hstr: the hash value in '%08x-%08x-%08x-%08x' format
        """
        if _map is not None:
            # construct from map
            pname = _map.get(self.KEY_PACKAGE, pname)
            cname = _map.get(self.KEY_CLASS, cname)
            stype = _map.get(self.KEY_TYPE, stype)
            hstr = _map.get(self.KEY_HASH, hstr)

        self._pname = pname
        self._cname = cname
        if stype not in SchemaClassId._valid_types:
            raise TypeError("Invalid SchemaClassId type: '%s'" % stype)
        self._type = stype
        self._hstr = hstr
        if self._hstr:
            try:
                # sanity check the format of the hash string
                hexValues = hstr.split("-")
                h0 = int(hexValues[0], 16)
                h1 = int(hexValues[1], 16)
                h2 = int(hexValues[2], 16)
                h3 = int(hexValues[3], 16)
            except:
                raise Exception("Invalid SchemaClassId format: bad hash string: '%s':"
                                % hstr)
    # constructor
    def _create(cls, pname, cname, stype=TYPE_DATA, hstr=None):
        return cls(pname=pname, cname=cname, stype=stype, hstr=hstr)
    create = classmethod(_create)

    # map constructor 
    def _from_map(cls, map_):
        return cls(_map=map_)
    from_map = classmethod(_from_map)

    def get_package_name(self): 
        """ 
        Access the package name in the SchemaClassId.

        @rtype: str
        """
        return self._pname


    def get_class_name(self): 
        """ 
        Access the class name in the SchemaClassId

        @rtype: str
        """
        return self._cname


    def get_hash_string(self): 
        """ 
        Access the schema's hash as a string value

        @rtype: str
        """
        return self._hstr


    def get_type(self):
        """ 
        Returns the type code associated with this Schema

        @rtype: str
        """
        return self._type

    def map_encode(self):
        _map = {}
        _map[self.KEY_PACKAGE] = self._pname
        _map[self.KEY_CLASS] = self._cname
        _map[self.KEY_TYPE] = self._type
        if self._hstr: _map[self.KEY_HASH] = self._hstr
        return _map

    def __repr__(self):
        hstr = self.get_hash_string()
        if not hstr:
            hstr = SchemaClassId._schemaHashStrDefault
        return self._pname + ":" + self._cname + ":" + self._type +  "(" + hstr  + ")"


    def __cmp__(self, other):
        if isinstance(other, dict):
            other = SchemaClassId.from_map(other)
        if not isinstance(other, SchemaClassId):
            raise TypeError("Invalid types for compare")
            # return 1
        me = str(self)
        them = str(other)
        if me < them:
            return -1
        if me > them:
            return 1
        return 0


    def __hash__(self):
        return (self._pname, self._cname, self._hstr).__hash__()



class SchemaProperty(_mapEncoder):
    """
    Describes the structure of a Property data object.
    Map format:
    map["amqp_type"] = int, AMQP type code indicating property's data type
    
    optional:
    map["access"] = str, access allowed to this property, default "RO"
    map["index"] = bool, True if this property is an index value, default False
    map["optional"] = bool, True if this property is optional, default False
    map["unit"] = str, describes units used
    map["min"] = int, minimum allowed value
    map["max"] = int, maximun allowed value
    map["maxlen"] = int, if string type, this is the maximum length in bytes
    required to represent the longest instance of this string.
    map["desc"] = str, human-readable description of this argument
    map["reference"] = str, ???
    map["parent_ref"] = bool, true if this property references an object  in
    which this object is in a child-parent relationship. Default False
    map["continuous"] = bool, true if the value potentially changes too fast to
    be directly monitorable.  Example: fast changing statistic or random
    number. Subscriptions to objects containing continuous data will publish
    only on an interval basis, rather than every time the data changes. Default
    False.
    """
    __hash__ = None
    _access_strings = ["RO","RW","RC"]
    _dir_strings = ["I", "O", "IO"]
    def __init__(self, _type_code=None, _map=None, kwargs={}):
        if _map is not None:
            # construct from map
            _type_code = _map.get("amqp_type", _type_code)
            kwargs = _map
            if not _type_code:
                raise TypeError("SchemaProperty: amqp_type is a mandatory"
                                " parameter")

        self._type = _type_code
        self._access  = "RO"
        self._isIndex   = False
        self._isOptional = False
        self._unit    = None
        self._min     = None
        self._max     = None
        self._maxlen  = None
        self._desc    = None
        self._reference = None
        self._isParentRef  = False
        self._dir = None
        self._default = None
        self._is_continuous = False

        for key, value in kwargs.items():
            if key == "access":
                value = str(value).upper()
                if value not in self._access_strings:
                    raise TypeError("invalid value for access parameter: '%s':" % value )
                self._access = value
            elif key == "index"   : self._isIndex = _to_bool(value)
            elif key == "optional": self._isOptional = _to_bool(value)
            elif key == "unit"    : self._unit    = value
            elif key == "min"     : self._min     = value
            elif key == "max"     : self._max     = value
            elif key == "maxlen"  : self._maxlen  = value
            elif key == "desc"    : self._desc    = value
            elif key == "reference" : self._reference = value
            elif key == "parent_ref"   : self._isParentRef = _to_bool(value)
            elif key == "parent_ref"   : self._isParentRef = _to_bool(value)
            elif key == "continuous"   : self._is_continuous = _to_bool(value)
            elif key == "dir":
                value = str(value).upper()
                if value not in self._dir_strings:
                    raise TypeError("invalid value for direction parameter: '%s'" % value)
                self._dir = value
            elif key == "default" : self._default = value

    # constructor
    def _create(cls, type_code, **kwargs):
        return cls(_type_code=type_code, kwargs=kwargs)
    create = classmethod(_create)

    # map constructor
    def _from_map(cls, map_):
        return cls(_map=map_)
    from_map = classmethod(_from_map)

    def get_type(self): return self._type

    def get_access(self): return self._access

    def is_optional(self): return self._isOptional

    def is_index(self): return self._isIndex

    def get_unit(self): return self._unit

    def get_min(self): return self._min

    def get_max(self): return self._max

    def get_max_len(self): return self._maxlen

    def get_desc(self): return self._desc

    def get_reference(self): return self._reference

    def is_parent_ref(self): return self._isParentRef

    def get_direction(self): return self._dir

    def get_default(self): return self._default

    def is_continuous(self): return self._is_continuous

    def map_encode(self):
        """
        Return the map encoding of this schema.
        """
        _map = {}
        _map["amqp_type"] = self._type
        _map["access"] = self._access
        _map["index"] = self._isIndex
        _map["optional"] = self._isOptional
        if self._unit: _map["unit"] = self._unit
        if self._min:  _map["min"] = self._min
        if self._max:  _map["max"] = self._max
        if self._maxlen: _map["maxlen"] = self._maxlen
        if self._desc: _map["desc"] = self._desc
        if self._reference: _map["reference"] = self._reference
        _map["parent_ref"] = self._isParentRef
        if self._dir: _map["dir"] = self._dir
        if self._default: _map["default"] = self._default
        if self._is_continuous: _map["continuous"] = self._is_continuous
        return _map

    def __repr__(self): 
        return "SchemaProperty=<<" + str(self.map_encode()) + ">>"

    def _update_hash(self, hasher):
        """
        Update the given hash object with a hash computed over this schema.
        """
        hasher.update(str(self._type))
        hasher.update(str(self._isIndex))
        hasher.update(str(self._isOptional))
        hasher.update(str(self._is_continuous))
        if self._access: hasher.update(self._access)
        if self._unit: hasher.update(self._unit)
        if self._desc: hasher.update(self._desc)
        if self._dir: hasher.update(self._dir)
        if self._default: hasher.update(self._default)


class SchemaMethod(_mapEncoder):
    """ 
    The SchemaMethod class describes the method's structure, and contains a
    SchemaProperty class for each argument declared by the method.

    Map format:
    map["arguments"] = map of "name"=<SchemaProperty> pairs.
    map["desc"] = str, description of the method
    """
    KEY_NAME="_name"
    KEY_ARGUMENTS="_arguments"
    KEY_DESC="_desc"
    KEY_ERROR="_error"
    def __init__(self, _args={}, _desc=None, _map=None):
        """
        Construct a SchemaMethod.

        @type args: map of "name"=<SchemaProperty> objects
        @param args: describes the arguments accepted by the method
        @type _desc: str
        @param _desc: Human-readable description of the schema
        """
        if _map is not None:
            _desc = _map.get(self.KEY_DESC)
            margs = _map.get(self.KEY_ARGUMENTS)
            if margs:
                # margs are in map format - covert to SchemaProperty
                tmp_args = {}
                for name,val in margs.iteritems():
                    tmp_args[name] = SchemaProperty.from_map(val)
                _args=tmp_args

        self._arguments = _args.copy()
        self._desc = _desc

    # map constructor
    def _from_map(cls, map_):
        return cls(_map=map_)
    from_map = classmethod(_from_map)

    def get_desc(self): return self._desc

    def get_arg_count(self): return len(self._arguments)

    def get_arguments(self): return self._arguments.copy()

    def get_argument(self, name): return self._arguments.get(name)

    def add_argument(self, name, schema):
        """
        Add an argument to the list of arguments passed to this method.  
        Used by an agent for dynamically creating method schema.

        @type name: string
        @param name: name of new argument
        @type schema: SchemaProperty
        @param schema: SchemaProperty to add to this method
        """
        if not isinstance(schema, SchemaProperty):
            raise TypeError("argument must be a SchemaProperty class")
        # "Input" argument, by default
        if schema._dir is None:
            schema._dir = "I"
        self._arguments[name] = schema

    def map_encode(self):
        """
        Return the map encoding of this schema.
        """
        _map = {}
        _args = {}
        for name,val in self._arguments.iteritems():
            _args[name] = val.map_encode()
        _map[self.KEY_ARGUMENTS] = _args
        if self._desc: _map[self.KEY_DESC] = self._desc
        return _map

    def __repr__(self):
        result = "SchemaMethod=<<args=("
        first = True
        for name,arg in self._arguments.iteritems():
            if first:
                first = False
            else:
                result += ", "
            result += name
        result += ")>>"
        return result

    def _update_hash(self, hasher):
        """
        Update the given hash object with a hash computed over this schema.
        """
        for name,val in self._arguments.iteritems():
            hasher.update(name)
            val._update_hash(hasher)
        if self._desc: hasher.update(self._desc)



class SchemaClass(QmfData):
    """
    Base class for Data and Event Schema classes.

    Map format:
    map(QmfData), plus:
    map["_schema_id"] = map representation of a SchemaClassId instance
    map["_primary_key_names"] = order list of primary key names
    """
    KEY_PRIMARY_KEY_NAMES="_primary_key_names"
    KEY_DESC = "_desc"

    SUBTYPE_PROPERTY="qmfProperty"
    SUBTYPE_METHOD="qmfMethod"

    def __init__(self, _classId=None, _desc=None, _map=None):
        """
        Schema Class constructor.

        @type classId: class SchemaClassId
        @param classId: Identifier for this SchemaClass
        @type _desc: str
        @param _desc: Human-readable description of the schema
        """
        if _map is not None:
            super(SchemaClass, self).__init__(_map=_map)

            # decode each value based on its type
            for name,value in self._values.iteritems():
                if self._subtypes.get(name) == self.SUBTYPE_METHOD:
                    self._values[name] = SchemaMethod.from_map(value)
                else:
                    self._values[name] = SchemaProperty.from_map(value)
            cid = _map.get(self.KEY_SCHEMA_ID)
            if cid:
                _classId = SchemaClassId.from_map(cid)
            self._object_id_names = _map.get(self.KEY_PRIMARY_KEY_NAMES,[])
            _desc = _map.get(self.KEY_DESC)
        else:
            if _classId is None:
                raise Exception("A class identifier must be supplied.")
            super(SchemaClass, self).__init__(_object_id=str(_classId))
            self._object_id_names = []

        self._classId = _classId
        self._desc = _desc

    def get_class_id(self): 
        if not self._classId.get_hash_string():
            self.generate_hash()
        return self._classId

    def get_desc(self): return self._desc

    def generate_hash(self): 
        """
        generate an md5 hash over the body of the schema,
        and return a string representation of the hash
        in format "%08x-%08x-%08x-%08x"
        """
        md5Hash = _md5Obj()
        md5Hash.update(self._classId.get_package_name())
        md5Hash.update(self._classId.get_class_name())
        md5Hash.update(self._classId.get_type())
        for name,x in self._values.iteritems():
            md5Hash.update(name)
            x._update_hash( md5Hash )
        for name,value in self._subtypes.iteritems():
            md5Hash.update(name)
            md5Hash.update(value)
        idx = 0
        for name in self._object_id_names:
            md5Hash.update(str(idx) + name)
            idx += 1
        hstr = md5Hash.hexdigest()[0:8] + "-" +\
            md5Hash.hexdigest()[8:16] + "-" +\
            md5Hash.hexdigest()[16:24] + "-" +\
            md5Hash.hexdigest()[24:32]
        # update classId with new hash value
        self._classId._hstr = hstr
        return hstr


    def get_property_count(self): 
        count = 0
        for value in self._subtypes.itervalues():
            if value == self.SUBTYPE_PROPERTY:
                count += 1
        return count

    def get_properties(self): 
        props = {}
        for name,value in self._subtypes.iteritems():
            if value == self.SUBTYPE_PROPERTY:
                props[name] = self._values.get(name)
        return props

    def get_property(self, name):
        if self._subtypes.get(name) == self.SUBTYPE_PROPERTY:
            return self._values.get(name)
        return None

    def add_property(self, name, prop):
        self.set_value(name, prop, self.SUBTYPE_PROPERTY)
        # need to re-generate schema hash
        self._classId._hstr = None

    def get_value(self, name):
        # check for meta-properties first
        if name == SchemaClassId.KEY_PACKAGE:
            return self._classId.get_package_name()
        if name == SchemaClassId.KEY_CLASS:
            return self._classId.get_class_name()
        if name == SchemaClassId.KEY_TYPE:
            return self._classId.get_type()
        if name == SchemaClassId.KEY_HASH:
            return self.get_class_id().get_hash_string()
        if name == self.KEY_SCHEMA_ID:
            return self.get_class_id()
        if name == self.KEY_PRIMARY_KEY_NAMES:
            return self._object_id_names[:]
        return super(SchemaClass, self).get_value(name)

    def has_value(self, name):
        if name in [SchemaClassId.KEY_PACKAGE, SchemaClassId.KEY_CLASS, SchemaClassId.KEY_TYPE,
                    SchemaClassId.KEY_HASH, self.KEY_SCHEMA_ID, self.KEY_PRIMARY_KEY_NAMES]:
            return True
        super(SchemaClass, self).has_value(name)

    def map_encode(self):
        """
        Return the map encoding of this schema.
        """
        _map = super(SchemaClass,self).map_encode()
        _map[self.KEY_SCHEMA_ID] = self.get_class_id().map_encode()
        if self._object_id_names:
            _map[self.KEY_PRIMARY_KEY_NAMES] = self._object_id_names[:]
        if self._desc:
            _map[self.KEY_DESC] = self._desc
        return _map

    def __repr__(self):
        return str(self.get_class_id())



class SchemaObjectClass(SchemaClass):
    """
    A schema class that describes a data object.  The data object is composed 
    of zero or more properties and methods.  An instance of the SchemaObjectClass
    can be identified using a key generated by concantenating the values of
    all properties named in the primary key list.
    
    Map format:
    map(SchemaClass)
    """
    def __init__(self, _classId=None, _desc=None,
                 _props={}, _methods={}, _object_id_names=[],
                 _map=None):
        """
        @type pname: str
        @param pname: name of package this schema belongs to
        @type cname: str
        @param cname: class name for this schema
        @type desc: str
        @param desc: Human-readable description of the schema
        @type _hash: str
        @param _methods: hash computed on the body of this schema, if known
        @type _props: map of 'name':<SchemaProperty> objects
        @param _props: all properties provided by this schema
        @type _pkey: list of strings
        @param _pkey: names of each property to be used for constructing the primary key
        @type _methods: map of 'name':<SchemaMethod> objects
        @param _methods: all methods provided by this schema
        """
        if _map is not None:
            super(SchemaObjectClass,self).__init__(_map=_map)
        else:
            super(SchemaObjectClass, self).__init__(_classId=_classId, _desc=_desc)
            self._object_id_names = _object_id_names
            for name,value in _props.iteritems():
                self.set_value(name, value, self.SUBTYPE_PROPERTY)
            for name,value in _methods.iteritems():
                self.set_value(name, value, self.SUBTYPE_METHOD)

        if self._classId.get_type() != SchemaClassId.TYPE_DATA:
            raise TypeError("Invalid ClassId type for data schema: %s" % self._classId)

    # map constructor
    def __from_map(cls, map_):
        return cls(_map=map_)
    from_map = classmethod(__from_map)

    def get_id_names(self): 
        return self._object_id_names[:]

    def get_method_count(self):
        count = 0
        for value in self._subtypes.itervalues():
            if value == self.SUBTYPE_METHOD:
                count += 1
        return count

    def get_methods(self):
        meths = {}
        for name,value in self._subtypes.iteritems():
            if value == self.SUBTYPE_METHOD:
                meths[name] = self._values.get(name)
        return meths

    def get_method(self, name):
        if self._subtypes.get(name) == self.SUBTYPE_METHOD:
            return self._values.get(name)
        return None

    def add_method(self, name, method): 
        self.set_value(name, method, self.SUBTYPE_METHOD)
        # need to re-generate schema hash
        self._classId._hstr = None




class SchemaEventClass(SchemaClass):
    """
    A schema class that describes an event.  The event is composed
    of zero or more properties.
    
    Map format:
    map["schema_id"] = map, SchemaClassId map for this object.
    map["desc"] = string description of this schema
    map["properties"] = map of "name":SchemaProperty values.
    """
    def __init__(self, _classId=None, _desc=None, _props={},
                 _map=None):
        if _map is not None:
            super(SchemaEventClass,self).__init__(_map=_map)
        else:
            super(SchemaEventClass, self).__init__(_classId=_classId,
                                                   _desc=_desc)
            for name,value in _props.iteritems():
                self.set_value(name, value, self.SUBTYPE_PROPERTY)

        if self._classId.get_type() != SchemaClassId.TYPE_EVENT:
            raise TypeError("Invalid ClassId type for event schema: %s" %
                            self._classId)

    # map constructor
    def __from_map(cls, map_):
        return cls(_map=map_)
    from_map = classmethod(__from_map)