ScriptInfo.h

//========================================================================================
// 
// $File$
// 
// Owner: Jonathan W. Brown
// 
// $Author$
// 
// $DateTime$
// 
// $Revision$
// 
// $Change$
// 
// Copyright 1997-2010 Adobe Systems Incorporated. All rights reserved.
// 
// NOTICE: Adobe permits you to use, modify, and distribute this file in accordance 
// with the terms of the Adobe license agreement accompanying it. If you have received
// this file from a source other than Adobe, then your use, modification, or 
// distribution of it requires the prior written permission of Adobe.
// 
// 
// Note: Changes to these classes must be reflected in ScriptInfoTypes.fh
// to ensure ReadWrite from the core scripting resources works correctly.
// 
//========================================================================================

#ifndef __SCRIPTINFO__
#define __SCRIPTINFO__

#include "ScriptInfoDefs.h"
#include "GUID.h"
#include "ScriptData.h"
#include "ScriptingDefs.h"
#include "IDThreading.h" // for spin_mutex

namespace ScriptInfo
{

const int32 kVariableLength = 0x0 ;

class TypeInfo ;
typedef K2Vector<TypeInfo> TypeInfoList ;

class TypeInfo
{
 public:
 typedef object_type data_type ;

 TypeInfo( const ScriptElementID& siid = kInvalidScriptElementID, int32 length = 1 ) :
 fType( siid ), fLength( length ), fMin(), fMax(), fDefault(), 
 fSubtypes(), fStructFieldName(), fFormatted( kFalse ) {}

 TypeInfo( const TypeInfoList& variableTypes, int32 length = 1 ) :
 fType( kScriptInfoVariableType ), fLength( length ), fMin(), fMax(), fDefault(), 
 fSubtypes( variableTypes ), fStructFieldName(), fFormatted( kFalse ) {}

 void AddType( const TypeInfo& subType ) ;
 void SetLength( int32 length ) { fLength = length ; }

 const ScriptElementID& GetType() const { return fType ; }
 int32 GetLength() const { return fLength ; }
 const ScriptData& GetMinimum() const { return fMin ; }
 const ScriptData& GetMaximum() const { return fMax ; }
 const ScriptData& GetDefault() const { return fDefault ; }
 const TypeInfoList& GetVariableTypes() const ;
 const TypeInfoList& GetStructFields() const ;
 const PMString& GetStructFieldName() const { return fStructFieldName ; }
 PMString GetFormattedStructFieldName( const RequestContext& context ) const ;
 const ObjectScriptElement* GetRecordTypeObject( const RequestContext& context ) const ;

 bool16 HasRangeData() const { return ( !fMin.IsEmpty() || !fMax.IsEmpty() ) ; }
 bool16 HasDefault() const { return !fDefault.IsEmpty() ; }

 bool16 IsBaseType() const { return ( kScriptInfoFirstBaseType <= fType && fType <= kScriptInfoLastBaseType ) ; }
 bool16 IsArrayType() const { return ( fLength != 1 ) ; }
 bool16 IsVariableType() const { return ( fType == kScriptInfoVariableType ) ; }
 bool16 IsStructType() const { return ( fType == kScriptInfoStructType ) ; }
 bool16 IsRecordType() const { return ( fType == kScriptInfoRecordType ) ; }
 bool16 IsObjectType( const RequestContext& context ) const ;
 bool16 IsEnumType( const RequestContext& context ) const ;
 bool16 IsTypeDef( const RequestContext& context ) const ;
 bool16 IsValidType( const RequestContext& context ) const ;
 bool16 HasAnyValidType( const RequestContext& context ) const ;
 bool16 IsValidValue( const ScriptData& value, const ObjectScriptElement* ) const ;

 void FormatType( const ObjectScriptElement* ) ;

 PMString GetTypeAsString( const ObjectScriptElement*, int32 includeInfo = kIncludeRangeData ) const ;

 PMString GetTypeAsString( const RequestContext& context, int32 includeInfo = kIncludeRangeData ) const ;

 bool16 operator==( const TypeInfo& ) const ;
 void ReadWrite( IPMStream* s ) ;

 private:
 ScriptElementID fType ; //either a base type (from ScriptingID.h), an object type, an enum type, or a typedef
 int32 fLength ; //if != 1, this is an array; if == 0, this is a variable length array
 ScriptData fMin ; //minimum value (empty, if none)
 ScriptData fMax ; //maximum value (empty, if none)
 ScriptData fDefault ; //default value (empty, if none)
 TypeInfoList fSubtypes ; //the list of subtypes for a variable type, fields for a struct type, or governing object for a record type
 PMString fStructFieldName ; //field name for a struct type
 bool16 fFormatted ; //whether FormatType has been called
} ;

DEFINEK2READWRITE( TypeInfo )

//----------------------------------------------------------------------------
class BaseScriptInfo
{
 public:
 typedef object_type data_type ;

 BaseScriptInfo() : fScriptID(), fName( new PMString() ), fDescription( new PMString() )
 {
 #ifdef ID_ENABLE_DEBUGGING
 fWhoAmI = nil ;
 #endif
 }
 BaseScriptInfo( const ScriptID& id, const PMString& name, const PMString& desc ) : 
 fScriptID( id ), fName( new PMString( name ) ), fDescription( new PMString( desc ) )
 {
 #ifdef ID_ENABLE_DEBUGGING
 fWhoAmI = nil ;
 #endif
 }
 BaseScriptInfo( const BaseScriptInfo& other ) { *this = other ; }
 virtual ~BaseScriptInfo();

 const ScriptID& GetScriptID() const { return fScriptID ; }

 const PMString& GetName() const { return *fName ; }
 void SetName( const PMString& name ) ;
 const PMString& GetFormattedName( const FormatNamePolicy& policy ) const ;
 virtual const PMString& GetFormattedName( const RequestContext& context, ScriptElementType as ) const ;

 virtual PMString GetDescription() const { return BaseScriptInfo::GetFormattedDescription( nil ) ; }

 BaseScriptInfo& operator=( const BaseScriptInfo& ) ;
 bool16 operator==( const BaseScriptInfo& ) const ;
 virtual void ReadWrite( IPMStream* s ) ;

 protected:
 PMString GetFormattedDescription( const ObjectScriptElement* ) const ;
 static void FormatDescription( PMString& desc, const ObjectScriptElement* ) ;
 mutable IDThreading::spin_mutex fMutex;
 
 typedef IDThreading::lock_guard<IDThreading::spin_mutex> LockGuard;

 private:
 ScriptID fScriptID ;
 boost::shared_ptr<PMString> fName; 
 boost::shared_ptr<PMString> fDescription ;

 mutable FormatNamePolicy fLastFormatNamePolicy ;
 mutable PMString fLastFormattedName ;

#ifdef ID_ENABLE_DEBUGGING
 public:
 virtual ConstCString WhoAmI() const ;
 mutable std::atomic<char *> fWhoAmI ;
#endif
} ;

//----------------------------------------------------------------------------
class ScriptElement : public BaseScriptInfo
{
 public:
 ScriptElement() {}
 ScriptElement( const ScriptElementID& siid, const ScriptID& id, const PMString& name, const PMString& desc ) :
 BaseScriptInfo( id, name, desc ), fScriptElementID( siid ) {}
 virtual ~ScriptElement() {}

 const ElementContext& GetContext() const { return fContext ; }
 const ScriptElementID& GetScriptElementID() const { return fScriptElementID ; }
 const PluginID& GetPluginID() const { return fPluginID ; }
 const ScriptRecordData& GetMetadata() const { return fMetadata ; }
 ScriptRecordData& GetMetadata() { return fMetadata ; }
 bool16 HasMetadata( const ScriptID& key, ScriptData& value ) const ;
 bool16 HasMetadata( const ScriptIDValuePair& kvp ) const ;

 bool16 operator==( const ScriptElement& ) const ;
 virtual void ReadWrite( IPMStream* s ) ;

 void SetContext( const ElementContext& context ) { fContext = context ; }
 void SetPluginID( const PluginID& ) ;

 private:
 ElementContext fContext ;
 ScriptElementID fScriptElementID ;
 PluginID fPluginID ;
 ScriptRecordData fMetadata ;

#ifdef ID_ENABLE_DEBUGGING
 public:
 virtual ConstCString WhoAmI() const ;
#endif
} ;

//----------------------------------------------------------------------------
class TypeDefScriptElement : public ScriptElement
{
 public:
 virtual const PMString& GetFormattedName( const RequestContext& context, ScriptElementType as = kTypeDefElement ) const { return BaseScriptInfo::GetFormattedName( context, as ) ; }

 TypeInfo GetDefinedType( const ObjectScriptElement* ) const ;

 bool16 operator==( const TypeDefScriptElement& ) const ;
 virtual void ReadWrite( IPMStream* s ) ;

 private:
 TypeInfo fType ;
} ;

//----------------------------------------------------------------------------
class SuiteScriptElement : public ScriptElement
{
 public:
 virtual const PMString& GetFormattedName( const RequestContext& context, ScriptElementType as = kSuiteElement ) const { return BaseScriptInfo::GetFormattedName( context, as ) ; }
} ;

//----------------------------------------------------------------------------
class ObjectScriptElement : public ScriptElement
{
 public:
 ObjectScriptElement() ;
 ObjectScriptElement( const ObjectScriptElement&, const RequestContext& ) ;

 bool16 HasSingular() const { return GetScriptID() != kInvalidScriptID ; }
 bool16 HasCollection() const { return fCollection.GetScriptID() != kInvalidScriptID ; }

 const PMString& GetFormattedName( ScriptElementType as = kObjectElement ) const ;
 const GUID& GetGUID() const { return fGUID ; }
 const ScriptElementID& GetSuite() const { return fSuite ; }

 const BaseScriptInfo* GetCollectionInfo() const { return &fCollection ; }
 BaseScriptInfo* GetCollectionInfo() { return &fCollection ; }
 PMString GetCollectionFormattedName( ScriptElementType as = kObjectElement ) const ;
 const GUID& GetCollectionGUID() const { return fCollectionGUID ; }

 bool16 IsPropertyReadOnly( const ScriptElementID& propertyID, bool16 obsoleteArg = kTrue ) const ;
 bool16 IsPropertyReadOnly( const ScriptID& propertyID, bool16 obsoleteArg = kTrue ) const ;

 const ScriptElementID& GetBaseObject() const { return fBaseObject ; }
 const ObjectScriptElement* FindBaseObject() const ;
 bool16 IsObjectType( const ScriptElementID& id ) const ;
 bool16 IsObjectType( const ScriptID& type ) const ;
 bool16 IsPreferencesObject() const { return IsObjectType( ScriptID( c_PrefsObject ) ) ; }
 bool16 IsSingletonChild() const { return !HasCollection() ; }

 ObjectElementIterator Subclasses() const ;

 const ParentProviderPacket* FindParent( const ScriptElementID& id ) const ;
 const ParentProviderPacket* FindParent( const ScriptID& id ) const ;
 const ParentProviderPacket* FindParent( const PMString& name, ScriptElementType as = kObjectElement ) const ;

 const ChildProviderPacket* FindChild( const ScriptElementID& id ) const ;
 const ChildProviderPacket* FindChildBySingularID( const ScriptID& id ) const ; //the ScriptID of the singular object
 const ChildProviderPacket* FindChildByCollectionID( const ScriptID& id ) const ; //the ScriptID of the collection object
 const ChildProviderPacket* FindChildBySingularName( const PMString& name, ScriptElementType as = kObjectElement ) const ; //the name of the singular object
 const ChildProviderPacket* FindChildByCollectionName( const PMString& name, ScriptElementType as = kObjectElement ) const ; //the name of the collection object

 const MethodProviderPacket* FindMethod( const ScriptElementID& id ) const ;
 const MethodProviderPacket* FindMethod( const ScriptID& id ) const ;
 const MethodProviderPacket* FindMethod( const PMString& name, ScriptElementType as = kMethodElement ) const ;

 const CollectionMethodProviderPacket* FindCollectionMethod( const ObjectScriptElement* parent, const ScriptElementID& id ) const ;
 const CollectionMethodProviderPacket* FindCollectionMethod( const ObjectScriptElement* parent, const ScriptID& id ) const ;
 const CollectionMethodProviderPacket* FindCollectionMethod( const ObjectScriptElement* parent, const PMString& name, ScriptElementType as = kMethodElement ) const ;

 const PropertyProviderPacket* FindProperty( const ScriptElementID& id ) const ;
 const PropertyProviderPacket* FindProperty( const ScriptID& id ) const ;
 const PropertyProviderPacket* FindProperty( const PMString& name, ScriptElementType as = kPropertyElement ) const ;

 PropertyProviderIterator FindProperties( const ClassID& attributeID ) const ;

 const EventProviderPacket* FindEvent( const ScriptElementID& id ) const ;
 const EventProviderPacket* FindEvent( const ScriptID& id ) const ;
 const EventProviderPacket* FindEvent( const PMString& name, ScriptElementType as = kEventElement ) const ;

 ParentProviderIterator Parents() const ;
 ChildProviderIterator Children() const ;
 MethodProviderIterator Methods( bool16 iterateBaseObjects = kTrue ) const ;
 CollectionMethodProviderIterator CollectionMethods( const ObjectScriptElement* parent = nil ) const ;
 PropertyProviderIterator Properties( bool16 iterateBaseObjects = kTrue ) const ;

 EventProviderIterator Events( bool16 iterateBaseObjects = kTrue ) const ;

 void AddSubclass( const ObjectScriptElement* subclass ) ;
 void AddParent( const ParentProviderPacket& pp ) ;
 void AddChild( const ChildProviderPacket& pp ) ;
 void AddMethod( const MethodProviderPacket& pp ) ;
 void AddCollectionMethod( const CollectionMethodProviderPacket& pp ) ;
 void AddProperty( const PropertyProviderPacket& pp ) ;
 void AddEvent( const EventProviderPacket& pp ) ;

 bool16 operator==( const ObjectScriptElement& ) const ;
 virtual void ReadWrite( IPMStream* s ) ;

 const RequestContext& GetRequestContext() const ;

 void SortChildren(PacketComp func);

 private:
 const ParentProviderLookup& GetElements( AccessParents* ) const { return fParents ; }
 const ChildProviderLookup& GetElements( AccessChildren* ) const { return fChildren ; }
 const MethodProviderLookup& GetElements( AccessMethods* ) const { return fMethods ; }
 const CollectionMethodProviderLookup& GetElements( AccessCollectionMethods* ) const { return fCollectionMethods ; }
 const PropertyProviderLookup& GetElements( AccessProperties* ) const { return fProperties ; }
 const EventProviderLookup& GetElements( AccessEvents* ) const { return fEvents ; }
 friend class ProviderPacketIterator<ObjectScriptElement, ParentProviderPacket, AccessParents> ;
 friend class ProviderPacketIterator<ObjectScriptElement, ChildProviderPacket, AccessChildren> ;
 friend class ProviderPacketIterator<ObjectScriptElement, MethodProviderPacket, AccessMethods> ;
 friend class ProviderPacketIterator<ObjectScriptElement, CollectionMethodProviderPacket, AccessCollectionMethods> ;
 friend class ProviderPacketIterator<ObjectScriptElement, PropertyProviderPacket, AccessProperties> ;
 friend class ProviderPacketIterator<ObjectScriptElement, EventProviderPacket, AccessEvents> ;

 virtual const PMString& GetFormattedName( const RequestContext& context, ScriptElementType as = kObjectElement ) const { return BaseScriptInfo::GetFormattedName( context, as ) ; }

 private:
 GUID fGUID ;
 BaseScriptInfo fCollection ;
 GUID fCollectionGUID ;
 ScriptElementID fBaseObject ;
 mutable const ObjectScriptElement* fBaseObjectCache ;
 ScriptElementID fSuite ;

 //the following data is not read from the resource nor persisted; it is constructed at run-time
 const RequestContext* fRequestContext ; //request context of this object
 ParentProviderLookup fParents ; //parents of this object
 ChildProviderLookup fChildren ; //objects of which this object is a parent
 MethodProviderLookup fMethods ; //methods on this object
 CollectionMethodProviderLookup fCollectionMethods ; //methods on a collection of this object
 PropertyProviderLookup fProperties ; //properties on this object
 EventProviderLookup fEvents ; //events on this object

 ObjectScriptElementList fSubclasses ; //subclasses of this object

 //the following vectors are used to cache a sorted list of previously found properties for performance reasons
 mutable K2Vector<KeyValuePair<ScriptID, const PropertyProviderPacket*> > fPropertiesByScriptID ;
 mutable K2Vector<KeyValuePair<ScriptElementID, const PropertyProviderPacket*> > fPropertiesByScriptElementID ;
 mutable K2Vector<const PropertyProviderPacket *> fPropertiesByFormattedName ;
} ;


//----------------------------------------------------------------------------
class MethodParam : public BaseScriptInfo
{
 public:
 MethodParam() : fOptional(kFalse) {}
 MethodParam( const ScriptID& id, const PMString& name, const PMString& desc, const TypeInfo& type, bool16 optional ) :
 BaseScriptInfo( id, name, desc ), fType( type ), fOptional( optional ) {}

 virtual const PMString& GetFormattedName( const RequestContext& context, ScriptElementType as = kMethodParameterElement ) const { return BaseScriptInfo::GetFormattedName( context, as ) ; }
 PMString GetFormattedDescription( const ObjectScriptElement* se ) const { return BaseScriptInfo::GetFormattedDescription( se ) ; }
 TypeInfo GetParamType( const ObjectScriptElement* ) const ;
 bool16 IsOptional() const { return fOptional ; }
 const ScriptData& GetDefault() const { return fType.GetDefault() ; }

 bool16 operator==( const MethodParam& ) const ;
 virtual void ReadWrite( IPMStream* s ) ;

 void SetParamType( const TypeInfo& type ) { fType = type ; }

 private:
 TypeInfo fType ;
 bool16 fOptional ;
} ;

typedef K2Vector<MethodParam> MethodParamList ;
DEFINEK2READWRITE( MethodParam )


class MethodScriptElement : public ScriptElement
{
 public:
 MethodScriptElement() {}
 MethodScriptElement( const ScriptElementID& siid, const ScriptID& id, const PMString& name, const PMString& desc, const TypeInfo& type, const PMString& returnDesc ) :
 ScriptElement( siid, id, name, desc ), fReturnType( type ), fReturnDescription( returnDesc ), fParameters() {}

 virtual const PMString& GetFormattedName( const RequestContext& context, ScriptElementType as = kMethodElement ) const { return BaseScriptInfo::GetFormattedName( context, as ) ; }
 PMString GetFormattedDescription( const ObjectScriptElement* se ) const { return BaseScriptInfo::GetFormattedDescription( se ) ; }
 TypeInfo GetReturnType( const ObjectScriptElement* ) const ;
 PMString GetReturnDescription( const ObjectScriptElement* ) const ;
 MethodParamList GetParameters( const ObjectScriptElement* ) const ;
 MethodParamList& GetParameters() { return fParameters ; }
 const MethodParam* FindParameter( const ObjectScriptElement*, const ScriptID& id ) const ;

 bool16 operator==( const MethodScriptElement& ) const ;
 virtual void ReadWrite( IPMStream* s ) ;

 private:
 TypeInfo fReturnType ;
 PMString fReturnDescription ;
 MethodParamList fParameters ;
} ;


//----------------------------------------------------------------------------
class PropertyScriptElement : public ScriptElement
{
 public:
 virtual const PMString& GetFormattedName( const RequestContext& context, ScriptElementType as = kPropertyElement ) const { return BaseScriptInfo::GetFormattedName( context, as ) ; }
 PMString GetFormattedDescription( const ObjectScriptElement* se ) const { return BaseScriptInfo::GetFormattedDescription( se ) ; }
 TypeInfo GetStorageType( const ObjectScriptElement*, bool16 includeAssignableTypes = kFalse ) const ;
 const TypeInfoList& GetAssignableTypes() const { return fAssignableTypes ; }
 TypeInfoList& GetAssignableTypes() { return fAssignableTypes ; }
 const ClassID& GetAttributeID() const { return fAttributeID ; }

 bool16 operator==( const PropertyScriptElement& ) const ;
 virtual void ReadWrite( IPMStream* s ) ;

 private:
 TypeInfo fStorageType ;
 TypeInfoList fAssignableTypes ;
 ClassID fAttributeID ;
} ;


//----------------------------------------------------------------------------
class EventScriptElement : public ScriptElement
{
 public:
 EventScriptElement() : ScriptElement(), fBubbles(kFalse), fCancelable(kFalse)
 {}
 virtual const PMString& GetFormattedName( const RequestContext& context, ScriptElementType as = kEventElement ) const { return BaseScriptInfo::GetFormattedName( context, as ) ; }
 PMString GetFormattedDescription( const ObjectScriptElement* se ) const { return BaseScriptInfo::GetFormattedDescription( se ) ; }
 bool16 GetBubbles() const { return fBubbles ; }
 bool16 GetCancelable() const { return fCancelable ; }
 ClassID GetEventClassID() const { return fEventClassID ; }
 ScriptID GetEventScriptID() const { return fEventScriptID ; }

 bool16 operator==( const EventScriptElement& ) const ;
 virtual void ReadWrite( IPMStream* s ) ;

 private:
 bool16 fBubbles ;
 bool16 fCancelable ;
 ClassID fEventClassID ;
 ScriptID fEventScriptID ;
} ;


//----------------------------------------------------------------------------
class EnumValue : public BaseScriptInfo
{
 public:
 virtual const PMString& GetFormattedName( const RequestContext& context, ScriptElementType as = kEnumValueElement ) const { return BaseScriptInfo::GetFormattedName( context, as ) ; }
} ;

typedef K2Vector<EnumValue> EnumValueList ;
DEFINEK2READWRITE( EnumValue )


class EnumScriptElement : public ScriptElement
{
 public:
 virtual const PMString& GetFormattedName( const RequestContext& context, ScriptElementType as = kEnumElement ) const { return BaseScriptInfo::GetFormattedName( context, as ) ; }

 const EnumValueList& GetValues() const { return fValues ; }
 EnumValueList& GetValues() { return fValues ; }

 bool16 operator==( const EnumScriptElement& ) const ;
 virtual void ReadWrite( IPMStream* s ) ;

 private:
 EnumValueList fValues ;
} ;

//----------------------------------------------------------------------------
class AccessParents
{
 public:
 bool16 SkipPacket( const ParentProviderPacket* ) const { return kFalse ; }
 static bool16 Matches( const ParentProviderPacket* p1, const ParentProviderPacket* p2 )
 { return p1->Element()->GetScriptID() == p2->Element()->GetScriptID() ; }
 static bool16 SortByName( const ParentProviderPacket* p1, const ParentProviderPacket* p2 )
 { return p1->Element()->GetName().Compare( kFalse, p2->Element()->GetName() ) < 0 ; }
} ;

class AccessChildren
{
 public:
 bool16 SkipPacket( const ChildProviderPacket* ) const { return kFalse ; }
 static bool16 Matches( const ChildProviderPacket* p1, const ChildProviderPacket* p2 )
 { return p1->Element()->GetScriptID() == p2->Element()->GetScriptID() ; }
 static bool16 SortByName( const ChildProviderPacket* p1, const ChildProviderPacket* p2 )
 { return p1->Element()->GetName().Compare( kFalse, p2->Element()->GetName() ) < 0 ; }
} ;

class AccessMethods
{
 public:
 bool16 SkipPacket( const MethodProviderPacket* ) const { return kFalse ; }
 static bool16 Matches( const MethodProviderPacket* p1, const MethodProviderPacket* p2 )
 { return p1->Element()->GetScriptID() == p2->Element()->GetScriptID() ; }
 static bool16 SortByName( const MethodProviderPacket* p1, const MethodProviderPacket* p2 )
 { return p1->Element()->GetName().Compare( kFalse, p2->Element()->GetName() ) < 0 ; }
} ;

class AccessCollectionMethods
{
 public:
 AccessCollectionMethods( const ObjectScriptElement* parent ) : fParent( parent ) {} ; //nil parent is OK
 bool16 SkipPacket( const CollectionMethodProviderPacket* p ) const { return ( fParent && fParent != p->Parent() ) ; }
 static bool16 Matches( const CollectionMethodProviderPacket* p1, const CollectionMethodProviderPacket* p2 )
 { return ( p1->Element()->GetScriptID() == p2->Element()->GetScriptID() ) && ( p1->Parent() == p2->Parent() ) ; }
 static bool16 SortByName( const CollectionMethodProviderPacket* p1, const CollectionMethodProviderPacket* p2 )
 {
 int32 x = p1->Parent()->GetName().Compare( kFalse, p2->Parent()->GetName() ) ;
 if ( x < 0 )
 return kTrue ;
 if ( x == 0 && p1->Element()->GetName().Compare( kFalse, p2->Element()->GetName() ) < 0 )
 return kTrue ;
 return kFalse ;
 }

 private:
 const ObjectScriptElement* fParent ;
} ;

class AccessProperties
{
 public:
 AccessProperties( const ClassID& attributeID = kInvalidClass ) : fAttrID( attributeID ) {} ;
 bool16 SkipPacket( const PropertyProviderPacket* p ) const { return ( fAttrID != kInvalidClass && fAttrID != p->Element()->GetAttributeID() ) ; }
 static bool16 Matches( const PropertyProviderPacket* p1, const PropertyProviderPacket* p2 )
 { return p1->Element()->GetScriptID() == p2->Element()->GetScriptID() ; }
 static bool16 SortByName( const PropertyProviderPacket* p1, const PropertyProviderPacket* p2 )
 { return p1->Element()->GetName().Compare( kFalse, p2->Element()->GetName() ) < 0 ; }
 private:
 ClassID fAttrID ;
} ;

class AccessEvents
{
 public:
 bool16 SkipPacket( const EventProviderPacket* ) const { return kFalse ; }
 static bool16 Matches( const EventProviderPacket* p1, const EventProviderPacket* p2 )
 { return p1->Element()->GetScriptID() == p2->Element()->GetScriptID() ; }
 static bool16 SortByName( const EventProviderPacket* p1, const EventProviderPacket* p2 )
 { return p1->Element()->GetName().Compare( kFalse, p2->Element()->GetName() ) < 0 ; }
 private:
 ClassID fAttrID ;
} ;

} // End namespace ScriptInfo

#endif //__SCRIPTINFO__