ScriptInfoDefs.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.
// 
//========================================================================================

#ifndef __SCRIPTINFODEFS__
#define __SCRIPTINFODEFS__

#include "K2Vector.h"
#include "K2Pair.h"
#include "RequestContext.h"
#include "ScriptingID.h"

class IScriptProvider ;

namespace ScriptInfo
{

//----------------------------------------------------------------------------
// Enum definitions
//----------------------------------------------------------------------------

enum ScriptElementType
{
 kNoElement = 0x00,
 kSuiteElement = 0x01,
 kObjectElement = 0x02,
 kMethodElement = 0x04,
 kMethodParameterElement = 0x08,
 kPropertyElement = 0x10,
 kEnumElement = 0x20,
 kEnumValueElement = 0x40,
 kTypeDefElement = 0x80,
 kEventElement = 0x100,
 kStructField = 0x1000
} ;

enum ErrorPolicy
{
 kIgnoreErrors,
 kReturnFirstError,
 kReturnCompleteFailureOnly
} ;

enum TypeFormattingInfo
{
 kIncludeTypeInfo = 0,
 kIncludeRangeData = 1,
 kIncludeDefaultValue = 2,
 kFormatAsPlural = 4,

 kGetEnumTypeByName = 0x10000000,
 kDontTranslateKeyStringDefaultType = 0x20000000,
} ;

enum SetPropertiesOrderPolicy
{
 kDefaultOrder = 0,
 kCustomOrder = 1
} ;

//----------------------------------------------------------------------------
// Class definitions
//----------------------------------------------------------------------------

class FormatNamePolicy
{
 public:
 enum Capitalization
 {
 kUseDefaultCapitalization,
 kUpperCaseFirstCharOfWords,
 kAllLowerCaseExceptInterCaps,
 kAllUpperCase
 } ;

 enum Spacing
 {
 kUseDefaultSpacing,
 kRemoveSpaces,
 kReplaceSpacesWithUnderScore,
 kReplaceSpacesWithDash
 } ;

 FormatNamePolicy() :
 fCapitalization( kUseDefaultCapitalization ), fSpacing( kUseDefaultSpacing ), fPrefix(), fSuffix() {}
 FormatNamePolicy( Capitalization c, Spacing s, const PMString& prefix, const PMString& suffix ) :
 fCapitalization( c ), fSpacing( s ), fPrefix( prefix ), fSuffix( suffix ) {}

 Capitalization GetCapitalization() const { return fCapitalization ; }
 Spacing GetSpacing() const { return fSpacing ; }
 const PMString& GetPrefix() const { return fPrefix ; }
 const PMString& GetSuffix() const { return fSuffix ; }

 bool16 operator==( const FormatNamePolicy& other ) const { return ( fCapitalization == other.fCapitalization &&
 fSpacing == other.fSpacing &&
 fPrefix == other.fPrefix &&
 fSuffix == other.fSuffix ) ; }

 void FormatName( PMString& name ) const ;

private:
 Capitalization fCapitalization ;
 Spacing fSpacing ;
 PMString fPrefix ;
 PMString fSuffix ;
} ;

class TypeDefScriptElement ;
class SuiteScriptElement ;
class ObjectScriptElement ;
class MethodScriptElement ;
class PropertyScriptElement ;
class EnumScriptElement ;
class EventScriptElement ;

typedef K2Vector<ScriptID> ScriptIDList ;
typedef K2Vector<ScriptElementID> ScriptElementIDList ;
typedef K2Vector<const ObjectScriptElement*> ObjectScriptElementList ;
typedef K2Vector<const MethodScriptElement*> MethodScriptElementList ;
typedef K2Vector<const PropertyScriptElement*> PropertyScriptElementList ;
typedef K2Vector<const EventScriptElement*> EventScriptElementList ;
 
typedef std::pair<uint32, uint32> ScriptMethodUniqueID;
typedef std::vector<ScriptMethodUniqueID> ScriptMethodUniqueIDList;
 
template <class SI>
class ScriptElementIterator
{
 public:
 ScriptElementIterator( const SI* const* inBegin, const SI* const* inEnd ) : fCurrent( inBegin ), fEnd( inEnd ) {}
 ScriptElementIterator( const ScriptElementIterator& sei ) : fCurrent( sei.fCurrent ), fEnd( sei.fEnd ) {}

 ScriptElementIterator& operator++() { ++fCurrent ; return *this ;}

 operator const SI*() const { return *fCurrent ; }
 const SI* operator->() const { return *fCurrent ; }

 const SI* const* current() const { return fCurrent ; }
 const SI* const* end() const { return fEnd ; }

 private:
 const SI* const* fCurrent ;
 const SI* const* fEnd ;

 private:
 //hide
 ScriptElementIterator operator++(int) ; //{ ScriptElementIterator tmp(*this) ; ++(*this) ; return tmp ; }
 ScriptElementIterator& operator=( const ScriptElementIterator& ) ;
 bool16 operator==( const ScriptElementIterator& ) const ;
} ;

typedef ScriptElementIterator<TypeDefScriptElement> TypeDefElementIterator ;
typedef ScriptElementIterator<SuiteScriptElement> SuiteElementIterator ;
typedef ScriptElementIterator<ObjectScriptElement> ObjectElementIterator ;
typedef ScriptElementIterator<MethodScriptElement> MethodElementIterator ;
typedef ScriptElementIterator<PropertyScriptElement> PropertyElementIterator ;
typedef ScriptElementIterator<EnumScriptElement> EnumElementIterator ;
typedef ScriptElementIterator<EventScriptElement> EventElementIterator ;

class ElementContext
{
 public:
 ElementContext() : fLocale(), fFirstVersion( kMinimumScriptVersion ), fLastVersion( kMaximumScriptVersion ), fClient( kCoreScriptManagerBoss ) {}
 ElementContext( const PMLocaleId& locale, const ScriptVersion& firstVersion, const ScriptVersion& lastVersion, const ScriptClient& client ) :
 fLocale( locale ), fFirstVersion( firstVersion ), fLastVersion( lastVersion ), fClient( client ) {}
 ElementContext( const ElementContext& other ) { *this = other ; }
 ~ElementContext() {}

 const PMLocaleId& GetLocale() const { return fLocale ; }
 const ScriptVersion& GetFirstVersion() const { return fFirstVersion ; }
 const ScriptVersion& GetLastVersion() const { return fLastVersion ; }
 const ScriptClient& GetClient() const { return fClient ; }

 ElementContext& operator=( const ElementContext& ) ;
 bool16 operator==( const ElementContext& other ) const { return ( fLocale == other.fLocale &&
 fFirstVersion == other.fFirstVersion &&
 fLastVersion == other.fLastVersion &&
 fClient == other.fClient ) ; }
 void ReadWrite( IPMStream* s ) ;

 private:
 PMLocaleId fLocale ; //defined in PMLocaleId.h
 ScriptVersion fFirstVersion ; //The first version for which this element applies (minimum is 0.0)
 ScriptVersion fLastVersion ; //The first version for which this element is obsolete (maximum is kMaxInt32.kMaxInt32 (0x7FFFFFFF))
 ScriptClient fClient ; //kCoreScriptManagerBoss indicates "always match"

#ifdef ID_ENABLE_DEBUGGING
 public:
 ConstCString WhoAmI() const ;
 mutable scoped_array<char> fWhoAmI ;
#endif
} ;

class ProviderPacket
{
 public:
 typedef object_type data_type ;

 ProviderPacket( const ElementContext& context, const ClassID& provider, const PluginID& pluginID, 
 bool16 surrogate, uint8 inheritance ) :
 fContext( context ), fProvider( provider ), fPluginID( pluginID ), fSurrogate( surrogate ), fInheritance( inheritance ) {}

 const ElementContext& GetContext() const { return fContext ; }
 const ClassID& GetProvider() const { return fProvider ; }
 const PluginID& GetPluginID() const { return fPluginID ; }

 IScriptProvider* QueryScriptProvider() const ;

 void SetPluginID( const PluginID& pluginID ) { fPluginID = pluginID ; }

#ifdef ID_ENABLE_DEBUGGING

 virtual ConstCString WhoAmI() const = 0 ;
#endif

 bool16 IsSurrogate() const { return fSurrogate ; }
 bool16 IsInherited() const { return fInheritance > 0 ; }
 uint8 GetInheritance() const { return fInheritance ; }

private:
 ElementContext fContext ;
 ClassID fProvider ; //kInvalidClass for "don't match"
 PluginID fPluginID ;
 bool16 fSurrogate ; //A surrogate is not a formal parent/child relationship in the DOM hierarchy
 uint8 fInheritance ;
} ;

class ParentProviderPacket : public ProviderPacket
{
 public:
 ParentProviderPacket( const ObjectScriptElement* parent, const ElementContext& context, const ClassID& provider, 
 const PluginID& pluginID, bool16 surrogate, uint8 inheritance ) :
 ProviderPacket( context, provider, pluginID, surrogate, inheritance ), fParent( parent ) {}

 const ObjectScriptElement* Element() const { return fParent ; }

#ifdef ID_ENABLE_DEBUGGING

 virtual ConstCString WhoAmI() const ;
#endif

 private:
 const ObjectScriptElement* fParent ;
} ;

class ChildProviderPacket : public ProviderPacket
{
 public:
 ChildProviderPacket( const ObjectScriptElement* child, const ElementContext& context, const ClassID& provider, 
 const PluginID& pluginID, bool16 surrogate, uint8 inheritance ) :
 ProviderPacket( context, provider, pluginID, surrogate, inheritance ), fChild( child ) {}

 const ObjectScriptElement* Element() const { return fChild ; }

#ifdef ID_ENABLE_DEBUGGING

 virtual ConstCString WhoAmI() const ;
#endif

 private:
 const ObjectScriptElement* fChild ;
} ;

class MethodProviderPacket : public ProviderPacket
{
 public:
 MethodProviderPacket( const MethodScriptElement* method, const ElementContext& context, const ClassID& provider, 
 const PluginID& pluginID ) :
 ProviderPacket( context, provider, pluginID, kFalse, 0 ), fMethod( method ) {}

 const MethodScriptElement* Element() const { return fMethod ; }

#ifdef ID_ENABLE_DEBUGGING

 virtual ConstCString WhoAmI() const ;
#endif

 private:
 const MethodScriptElement* fMethod ;
} ;

class CollectionMethodProviderPacket : public ProviderPacket
{
 public:
 CollectionMethodProviderPacket( const MethodScriptElement* method, const ElementContext& context, const ClassID& provider, 
 const PluginID& pluginID, const ObjectScriptElement* parent, uint8 inheritance ) :
 ProviderPacket( context, provider, pluginID, kFalse, inheritance ), fMethod( method ), fParent( parent ) {}

 const MethodScriptElement* Element() const { return fMethod ; }
 const ObjectScriptElement* Parent() const { return fParent ; }

#ifdef ID_ENABLE_DEBUGGING

 virtual ConstCString WhoAmI() const ;
#endif

 private:
 const MethodScriptElement* fMethod ;
 const ObjectScriptElement* fParent ;
} ;

class PropertyProviderPacket : public ProviderPacket
{
 public:
 PropertyProviderPacket( const PropertyScriptElement* property, const ElementContext& context, const ClassID& provider, 
 const PluginID& pluginID, bool16 readonly ) :
 ProviderPacket( context, provider, pluginID, kFalse, 0 ), fProperty( property ), fReadOnly( readonly ) {}

 const PropertyScriptElement* Element() const { return fProperty ; }
 bool16 IsReadWrite() const { return !fReadOnly ; }
 bool16 IsReadOnly() const { return fReadOnly ; }

#ifdef ID_ENABLE_DEBUGGING

 virtual ConstCString WhoAmI() const ;
#endif

 private:
 const PropertyScriptElement* fProperty ;
 bool16 fReadOnly ;
} ;

class EventProviderPacket : public ProviderPacket
{
 public:
 EventProviderPacket( const EventScriptElement* event, const ElementContext& context, const ClassID& provider, 
 const PluginID& pluginID ) :
 ProviderPacket( context, provider, pluginID, kFalse, 0 ), fEvent( event ) {}

 const EventScriptElement* Element() const { return fEvent ; }

#ifdef ID_ENABLE_DEBUGGING

 virtual ConstCString WhoAmI() const ;
#endif

 private:
 const EventScriptElement* fEvent ;
} ;

typedef K2Vector<ParentProviderPacket> ParentProviderLookup ;
typedef K2Vector<ChildProviderPacket> ChildProviderLookup ;
typedef K2Vector<MethodProviderPacket> MethodProviderLookup ;
typedef K2Vector<CollectionMethodProviderPacket> CollectionMethodProviderLookup ;
typedef K2Vector<PropertyProviderPacket> PropertyProviderLookup ;
typedef K2Vector<EventProviderPacket> EventProviderLookup ;

class AccessParents ;
class AccessChildren ;
class AccessMethods ;
class AccessCollectionMethods ;
class AccessProperties ;
class AccessEvents ;

template <class SI, class PP, class Access>
class ProviderPacketIterator
{
 public:
 typedef PP packet_type ;
 typedef Access access_type ;

 ProviderPacketIterator( const SI* pSI, bool16 iterateBaseObjects, Access filter = Access() ) :
 fSI( pSI ),
 fIterateBaseObjects( iterateBaseObjects ),
 fCurrent( nil ),
 fEnd( nil ),
 fAlreadySeen(),
 fFilter( filter )
 {
 Initialize() ;
 }
 ProviderPacketIterator( const ProviderPacketIterator& ppi ) ;/*:
 fSI( ppi.fSI ),
 fIterateBaseObjects( ppi.fIterateBaseObjects ),
 fCurrent( ppi.fCurrent ),
 fEnd( ppi.fEnd ),
 fAlreadySeen( ppi.fAlreadySeen ),
 fFilter( ppi.fFilter )
 {}*/

 ProviderPacketIterator& operator++(){ ++fCurrent ; IterateUntilValid() ; return *this ;}

 operator const PP*() const { return fCurrent ; }
 const PP* operator->() const { return fCurrent ; }

 const PP* current() const { return fCurrent ; }
 const PP* end() const { return fEnd ; }

 private:
 void Initialize()
 {
 if ( fSI )
 {
 fCurrent = fSI->GetElements( (Access*) nil ).begin() ;
 fEnd = fSI->GetElements( (Access*) nil ).end() ;
 IterateUntilValid() ;
 }
 }

 void IterateUntilValid()
 {
 //Apply filter and skip duplicate elements
 while ( fCurrent != fEnd && SkipPacket() )
 ++fCurrent ;

 //Cache elements we've seen
 if ( fCurrent != fEnd )
 fAlreadySeen.push_back( fCurrent ) ;

 //Skip elements that are not supported (no provider)
 if ( fCurrent != fEnd && fCurrent->GetProvider() == kInvalidClass )
 {
 ++fCurrent ;
 IterateUntilValid() ;
 }

 //Iterate the elements on the base object, if any
 if ( fIterateBaseObjects && fCurrent == fEnd )
 {
 if ( fSI != nil )
 fSI = fSI->FindBaseObject() ;

 Initialize() ;
 }
 }

 bool16 SkipPacket() const
 {
 if ( fFilter.SkipPacket( fCurrent ) )
 return kTrue ;

 for ( const PP* const* iter = fAlreadySeen.begin() ; iter != fAlreadySeen.end() ; ++iter )
 {
 if ( fFilter.Matches( *iter, fCurrent ) )
 return kTrue ;
 }
 return kFalse ;
 }

 private:
 const SI* fSI ;
 bool16 fIterateBaseObjects ;
 const PP* fCurrent ;
 const PP* fEnd ;
 K2Vector<const PP*> fAlreadySeen ;
 Access fFilter ;

 private:
 //hide
 ProviderPacketIterator operator++(int) ; //{ ProviderPacketIterator tmp(*this) ; ++(*this) ; return tmp ; }
 ProviderPacketIterator& operator=( const ProviderPacketIterator& ) ;
 bool16 operator==( const ProviderPacketIterator& ) const ;
} ;

typedef ProviderPacketIterator<ObjectScriptElement, ParentProviderPacket, AccessParents> ParentProviderIterator ;
typedef ProviderPacketIterator<ObjectScriptElement, ChildProviderPacket, AccessChildren> ChildProviderIterator ;
typedef ProviderPacketIterator<ObjectScriptElement, MethodProviderPacket, AccessMethods> MethodProviderIterator ;
typedef ProviderPacketIterator<ObjectScriptElement, CollectionMethodProviderPacket, AccessCollectionMethods> CollectionMethodProviderIterator ;
typedef ProviderPacketIterator<ObjectScriptElement, PropertyProviderPacket, AccessProperties> PropertyProviderIterator ;
typedef ProviderPacketIterator<ObjectScriptElement, EventProviderPacket, AccessEvents> EventProviderIterator ;
//Note: ObjectScriptElement has to be specified as a template class argument because it hasn't been defined yet

typedef bool16 (*PacketComp)(const ChildProviderPacket left, const ChildProviderPacket right);

} // End namespace ScriptInfo

#endif //__SCRIPTINFODEFS__