xmp_toolkit_ruby 0.0.2

data/ext/xmp_toolkit_ruby/XMP-Toolkit-SDK/public/include/XMPCore/Interfaces/INodeIterator.h

@@ -0,0 +1,193 @@
+#ifndef __INodeIterator_h__
+#define __INodeIterator_h__ 1
+
+
+// =================================================================================================
+// Copyright Adobe
+// Copyright 2014 Adobe
+// 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. 
+// =================================================================================================
+
+#include "XMPCore/XMPCoreFwdDeclarations.h"
+#include "XMPCommon/Interfaces/BaseInterfaces/ISharedObject.h"
+#include "XMPCore/Interfaces/INode.h"
+#include "XMPCommon/Interfaces/BaseInterfaces/IVersionable.h"
+
+namespace AdobeXMPCore {
+
+	//!
+	//! @brief Interface that represents an iterator over the mutable children of a XMP DOM Node.
+	//! \note Iterators are valid as long as their are no changes performed on the node. In case there are some
+	//!  changes performed on the node then the behavior is undefined.
+	//!
+	class XMP_PUBLIC INodeIterator_v1
+		: public virtual ISharedObject
+		, public virtual IVersionable
+	{
+	public:
+
+		//!
+		//! @brief Gets the type of the node currently pointed by the iterator.
+		//! \return A value of type \#INode_v1::eNodeType indicating the type of the node currently pointed by the iterator.
+		//!
+		virtual INode_v1::eNodeType APICALL GetNodeType() const = 0;
+
+		//!
+		//! @{
+		//! @brief Gets the node currently pointed by the iterator.
+		//! \return A shared pointer to a const or non const object of type \#INode.
+		//! \note In case iterator has gone beyond its limit, an invalid shared pointer is returned
+		//!
+		virtual spINode APICALL GetNode() = 0;
+		XMP_PRIVATE spcINode APICALL GetNode() const {
+			return const_cast< INodeIterator * >( this )->GetNode();
+		};
+		//! @}
+
+		//!
+		//! @{
+		//! @brief Gets the iterator's currently pointed node as simple node, if possible.
+		//! \return A shared pointer to a const or non const object of type \#ISimpleNode.
+		//! \attention Error is thrown in case
+		//!		- iterator's currently pointed node is valid but is not a simple node.
+		//! \note In case iterator has gone beyond its limit, an invalid shared pointer is returned.
+		//!
+		XMP_PRIVATE spISimpleNode GetSimpleNode() {
+			auto node = GetNode();
+			if ( node ) return node->ConvertToSimpleNode();
+			return spISimpleNode();
+		}
+
+		XMP_PRIVATE spcISimpleNode GetSimpleNode() const {
+			return const_cast< INodeIterator * >( this )->GetSimpleNode();
+		}
+		//! @}
+
+		//!
+		//! @brief Gets the iterator's currently pointed node as structure node, if possible.
+		//! \return A shared pointer to a const or non const object of type \#IStructureNode.
+		//! \attention Error is thrown in case
+		//!		- iterator's currently pointed node is valid but is not a structure node.
+		//! \note In case iterator has gone beyond its limit, an invalid shared pointer is returned.
+		//!
+		XMP_PRIVATE spIStructureNode GetStructureNode() {
+			auto node = GetNode();
+			if ( node ) return node->ConvertToStructureNode();
+			return spIStructureNode();
+		}
+
+		XMP_PRIVATE spcIStructureNode GetStructureNode() const {
+			return const_cast< INodeIterator * >( this )->GetStructureNode();
+		}
+		//! @}
+
+		//!
+		//! @brief Gets the iterator's currently pointed node as an array node, if possible.
+		//! \return A shared pointer to a const or non const object of type \#IArrayNode.
+		//! \attention Error is thrown in case
+		//!		- iterator's currently pointed node is valid but is not an array node.
+		//! \note In case iterator has gone beyond its limit, an invalid shared pointer is returned.
+		//!
+		XMP_PRIVATE spIArrayNode GetArrayNode() {
+			auto node = GetNode();
+			if ( node ) return node->ConvertToArrayNode();
+			return spIArrayNode();
+		}
+
+		XMP_PRIVATE spcIArrayNode GetArrayNode() const {
+			return const_cast< INodeIterator * >( this )->GetArrayNode();
+		}
+		//! @}
+
+		//!
+		//! @{
+		//! @brief Advances iterator by one position.
+		//! \return A shared pointer to a const or non object of type \#INodeIterator.
+		//! \note Returned shared pointer is invalid in case the current node is the last one.
+		//!
+		virtual spINodeIterator APICALL Next() = 0;
+		XMP_PRIVATE spcINodeIterator APICALL Next() const {
+			return const_cast< INodeIterator * >( this )->Next();
+		}
+		//! @}
+
+
+		//!
+		//! \cond XMP_INTERNAL_DOCUMENTATION
+
+		//!
+		//! @{
+		//! @brief Returns the actual raw pointer from the shared pointer, which can be a shared pointer of a proxy class.
+		//! \return Either a const or non const pointer to INodeIterator interface.
+		//!
+		virtual pINodeIterator APICALL GetActualINodeIterator() __NOTHROW__ = 0;
+		XMP_PRIVATE pcINodeIterator GetActualINodeIterator() const __NOTHROW__ {
+			return const_cast< INodeIterator * >( this )->GetActualINodeIterator();
+		}
+		//!
+		//! @}
+
+		//!
+		//! @{
+		//! @brief Returns the pointer to internal interfaces.
+		//! \return Either a const or non const pointer to INodeIterator_I interface.
+		//!
+		virtual AdobeXMPCore_Int::pINodeIterator_I APICALL GetINodeIterator_I() __NOTHROW__ = 0;
+		XMP_PRIVATE AdobeXMPCore_Int::pcINodeIterator_I GetINodeIterator_I() const __NOTHROW__ {
+			return const_cast< INodeIterator * >( this )->GetINodeIterator_I();
+		}
+		//!
+		//! @}
+		
+		//!
+		//! @{
+		//! @brief Converts raw pointer to shared pointer.
+		//! \return Shared pointer to const or non constant interface.
+		//!
+		XMP_PRIVATE static spINodeIterator MakeShared( pINodeIterator ptr );
+		XMP_PRIVATE static spcINodeIterator MakeShared( pcINodeIterator ptr ) {
+			return MakeShared( const_cast< pINodeIterator >( ptr ) );
+		}
+		//!
+		//! @}
+
+		//!
+		//! @}
+
+		//!
+		//! return the unique ID assigned to the interface.
+		//! \return 64 bit unsigned integer representing the unique ID assigned to the interface.
+		//!
+		XMP_PRIVATE static uint64 GetInterfaceID() { return kINodeIteratorID; }
+
+		//!
+		//! return the version of the interface.
+		//! \return 32 bit unsigned integer representing the version of the interface.
+		//!
+		XMP_PRIVATE static uint32 GetInterfaceVersion() { return 1; }
+		//! \endcond
+
+	protected:
+		//!
+		//! Destructor
+		//! 
+		virtual ~INodeIterator_v1() __NOTHROW__ {}
+
+		//! \cond XMP_INTERNAL_DOCUMENTATION
+		virtual uint32 APICALL getNodeType( pcIError_base & error ) const __NOTHROW__ = 0;
+		virtual pINode_base APICALL getNode( pcIError_base & error ) __NOTHROW__ = 0;
+		virtual pINodeIterator_base APICALL next( pcIError_base & error ) __NOTHROW__ = 0;
+
+		#ifdef FRIEND_CLASS_DECLARATION
+			FRIEND_CLASS_DECLARATION();
+		#endif
+		REQ_FRIEND_CLASS_DECLARATION();
+		//! \endcond
+
+	};
+}
+
+#endif  // __INodeIterator_h__

data/ext/xmp_toolkit_ruby/XMP-Toolkit-SDK/public/include/XMPCore/Interfaces/IPath.h

@@ -0,0 +1,212 @@
+#ifndef __IPath_h__
+#define __IPath_h__ 1
+
+// =================================================================================================
+// Copyright 2014 Adobe
+// 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. 
+// =================================================================================================
+
+#include "XMPCore/XMPCoreFwdDeclarations.h"
+#include "XMPCommon/Interfaces/BaseInterfaces/ISharedObject.h"
+#include "XMPCommon/Interfaces/BaseInterfaces/IVersionable.h"
+
+namespace AdobeXMPCore {
+
+	//!
+	//! @brief Version1 of the interface that provides an easy iterative description of a specific path into the XMP tree.
+	//! @details Path consists of multiple path segments in an order and each \#IPathSegment represents one segment
+	//! of the path into the XMP tree.
+	//! Provides all the functions to create path and get the various properties of a path.
+	//! \attention Do not support multi-threading.
+	//! \note Index in the path are 1-based.
+	//!
+	class XMP_PUBLIC IPath_v1
+		: public virtual ISharedObject
+		, public virtual IVersionable
+	{
+	public:
+
+		//!
+		//! @brief Registers a map of namespace and prefix with the object.
+		//! This map will be used during serialization and parsing.
+		//! \param[in] map A shared pointer of an object \#AdobeXMPCore::INameSpacePrefixMap.
+		//! \return A shared pointer to the const map registered previously with the object.
+		//!
+		virtual spcINameSpacePrefixMap APICALL RegisterNameSpacePrefixMap( const spcINameSpacePrefixMap & map ) = 0;
+
+		//!
+		//! @brief Serializes the IPath object to a utf8 string representation. This will produce either a long form of the path using
+		//! the full namespace strings or short form of the path using the prefix for the namespace.
+		//! \param[in] map A shared pointer to a const \#AdobeXMPCore::INameSpacePrefixMap object which can contain the
+		//! mapping for nameSpaces to prefixes. They will take precedence over the map registered with the object.
+		//! \return A shard pointer to \#AdobeXMPCommon::IUTF8String object containing serialized form of path.
+		//! \note In case map is not a valid shared pointer all the mappings will be picked from the map registered with the object.
+		//!  If neither a map is registered nor it is provided in the arguments then it will serialize to long form of the path.
+		//! \attention Error will be thrown in case
+		//!		- no prefix exists for a namespace used in the path.
+		//!
+		virtual spIUTF8String APICALL Serialize( const spcINameSpacePrefixMap & map = spcINameSpacePrefixMap() ) const = 0;
+
+		//!
+		//! @brief Appends a path segment to the path.
+		//! \param[in] segment	A shared pointer to a const \#AdobeXMPCore::IPathSegment object.
+		//! \attention Error is thrown in case
+		//!		- segment is not a valid shared pointer.
+		//!
+		virtual void APICALL AppendPathSegment( const spcIPathSegment & segment ) = 0;
+
+		//!
+		//! @brief Removes a path segment from the path.
+		//! \param[in] index Indicates the index of the path segment to be removed.
+		//! \returns A shared pointer to the const path segment removed.
+		//! \attention Error is thrown in case
+		//!		- index is out of bounds.
+		//!
+		virtual spcIPathSegment APICALL RemovePathSegment( sizet index ) = 0;
+
+		//!
+		//! @brief Gets the path segment at a particular index in the path
+		//! \param[in] index Indicates the index for the path segment in the path.
+		//! \return A shared pointer to a const path segment.
+		//! \attention Error is thrown in case
+		//!		-index is out of bounds.
+		//!
+		virtual spcIPathSegment APICALL GetPathSegment( sizet index ) const = 0;
+
+		//!
+		//! @brief Gets the number of the path segments in the path.
+		//! \return The count of the path segments in the path.
+		//!
+		virtual sizet APICALL Size() const __NOTHROW__ = 0;
+
+		//!
+		//! @brief To check whether path is empty or not.
+		//! \returns A bool object indicating true in case the path is empty (no path segment)
+		//!
+		XMP_PRIVATE bool IsEmpty() const {
+			return Size() == 0;
+		}
+
+		//!
+		//! @brief Clears the path by removing all the path segments from it
+		//!
+		virtual void APICALL Clear() __NOTHROW__ = 0;
+
+		//!
+		//! @brief Gets a new path having a selected range of path segments
+		//! \param[in] startingIndex Indicates the starting index of the path segment to be part of the returned path object. Default value is 1.
+		//! \param[in] countOfSegments Indicates the count of the path segments to be part of the returned path object starting from startingIndex.
+		//!  Default value is \#AdobeXMPCommon::kMaxSize.
+		//! \note In case countOfSegments is more than the number of segments available in the path object starting from the starting index
+		//!  then internally it is truncated to the number of path segments available.
+		//! \attention Error is thrown in case
+		//!		- startingIndex is more than the count of segments in the object.
+		//!
+		virtual spIPath APICALL Clone( sizet startingIndex = 1, sizet countOfSegments = kMaxSize ) const = 0;
+
+		//!
+		//! \cond XMP_INTERNAL_DOCUMENTATION
+		
+		//!
+		//! @{
+		//! @brief Returns the actual raw pointer from the shared pointer, which can be a shared pointer of a proxy class.
+		//! \return Either a const or non const pointer to IPath interface.
+		//!
+		virtual pIPath APICALL GetActualIPath() __NOTHROW__ = 0;
+		XMP_PRIVATE pcIPath GetActualIPath() const __NOTHROW__ {
+			return const_cast< IPath_v1 * >( this )->GetActualIPath();
+		}
+		//!
+		//! @}
+
+		//!
+		//! @{
+		//! @brief Returns the pointer to internal interfaces.
+		//! \return Either a const or non const pointer to IPath_I interface.
+		//!
+		virtual AdobeXMPCore_Int::pIPath_I APICALL GetIPath_I() __NOTHROW__ = 0;
+
+		XMP_PRIVATE AdobeXMPCore_Int::pcIPath_I GetIPath_I() const __NOTHROW__ {
+			return const_cast< IPath_v1 * >( this )->GetIPath_I();
+		}
+		//!
+		//! @}
+		
+		//!
+		//! @{
+		//! @brief Converts raw pointer to shared pointer. The raw pointer is of version 1 interface
+		//! where as the returned shared pointer depends on the version client is interested in.
+		//! \return Shared pointer to const or non constant interface.
+		//!
+		XMP_PRIVATE static spIPath MakeShared( pIPath_base ptr );
+		XMP_PRIVATE static spcIPath MakeShared( pcIPath_base ptr ) {
+			return MakeShared( const_cast< pIPath_base >( ptr ) );
+		}
+		//!
+		//! @}
+
+		//!
+		//! @brief Returns the unique ID assigned to the interface.
+		//! \return 64 bit unsigned integer representing the unique ID assigned to the interface.
+		//!
+		XMP_PRIVATE static uint64 GetInterfaceID() { return kIPathID; }
+
+		//!
+		//! @brief Returns the version of the interface.
+		//! \return 32 bit unsigned integer representing the version of the interface.
+		//!
+		XMP_PRIVATE static uint32 GetInterfaceVersion() { return 1; }
+		//! \endcond
+
+		// static factory functions
+
+		//!
+		//! @brief Creates an empty IPath object.
+		//! \return a shared pointer to an empty IPath object
+		//!
+		XMP_PRIVATE static spIPath CreatePath();
+
+		//!
+		//! @brief Creates a path from a char buffer which contains the serialized path.
+		//! \param[in] path Pointer to a const char buffer containing serialized form of the path.
+		//! \param[in] pathLength Number of characters in the path. In case path in null terminated set it to \#AdobeXMPCommon::npos.
+		//! \param[in] map A shared pointer to a const \#AdobeXMPCore::IXMPNameSpacePrefixMap object which will contain the
+		//!  mapping from nameSpaces to prefixes.
+		//! \return A shared pointer to a \#AdobeXMPCore::IPath object.
+		//! \note In case the serializedPath is NULL or the contents are empty then it will result in an empty path.
+		//! \note This operation is currently not implemented for the IPath interface.
+		//! \attention Error is thrown in case
+		//!		- no mapping exists for a prefix to name space.
+		//!		- path contains invalid data.
+		//!
+		XMP_PRIVATE static spIPath ParsePath( const char * path, sizet pathLength, const spcINameSpacePrefixMap & map );
+
+
+	protected:
+		//!
+		//! Destructor
+		//! 
+		virtual ~IPath_v1() __NOTHROW__ {}
+
+		//! \cond XMP_INTERNAL_DOCUMENTATION
+		virtual pcINameSpacePrefixMap_base APICALL registerNameSpacePrefixMap( pcINameSpacePrefixMap_base map, pcIError_base & error ) __NOTHROW__ = 0;
+		virtual pIUTF8String_base APICALL serialize( pcINameSpacePrefixMap_base map, pcIError_base & error ) const __NOTHROW__ = 0;
+		virtual void APICALL appendPathSegment( pcIPathSegment_base segment, pcIError_base & error ) __NOTHROW__ = 0;
+		virtual pcIPathSegment_base APICALL removePathSegment( sizet index, pcIError_base & error ) __NOTHROW__ = 0;
+		virtual pcIPathSegment_base APICALL getPathSegment( sizet index, pcIError_base & error ) const __NOTHROW__ = 0;
+		virtual pIPath_base APICALL clone( sizet startingIndex, sizet countOfSegemetns, pcIError_base & error ) const __NOTHROW__ = 0;
+
+
+		#ifdef FRIEND_CLASS_DECLARATION
+			FRIEND_CLASS_DECLARATION();
+		#endif
+		REQ_FRIEND_CLASS_DECLARATION();
+		//! \endcond
+
+	};
+}
+
+#endif  // __IPath_h__

data/ext/xmp_toolkit_ruby/XMP-Toolkit-SDK/public/include/XMPCore/Interfaces/IPathSegment.h

@@ -0,0 +1,225 @@
+#ifndef __IPathSegment_h__
+#define __IPathSegment_h__ 1
+
+// =================================================================================================
+// Copyright 2014 Adobe
+// 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. 
+// =================================================================================================
+
+#include "XMPCore/XMPCoreFwdDeclarations.h"
+#include "XMPCommon/Interfaces/BaseInterfaces/ISharedObject.h"
+#include "XMPCommon/Interfaces/BaseInterfaces/IVersionable.h"
+
+namespace AdobeXMPCore {
+
+	//! 
+	//! @brief Version1 of the interface that represents one segment in a path to a node into the XMP tree.
+	//! @details Provides all the functions to access properties of the path segment and factory functions
+	//! to create various kinds of path segments.
+	//! \attention Not thread safe and not required as only read only access is provided to client.
+	//!
+	class XMP_PUBLIC IPathSegment_v1
+		: public virtual ISharedObject
+		, public virtual IVersionable
+	{
+	public:
+
+		//!
+		//! @brief This enumeration represents the types of a path segment.
+		//!
+		typedef enum {
+			//! None type
+			kPSTNone							= 0,
+
+			//! Any property that consists of namespace and a localName
+			kPSTProperty						= 1,
+			
+			//! An array index which does not have a namespace or localName itself
+			kPSTArrayIndex						= 1 << 1,
+			
+			//! A qualifier of a property, also consists of namespace and localName
+			kPSTQualifier						= 1 << 2,
+			
+			//! Selects a specific qualifier by its value (e.g. specific language)
+			kPSTQualifierSelector				= 1 << 3,
+
+			//! Represents all property types
+			kPSTAll								= kAllBits
+		} ePathSegmentType;
+
+		//!
+		//! @brief Gets the name space of the path segment.
+		//! \return A shared pointer to const \#AdobeXMPCommon::IUTF8String object representing namespace of the path segment.
+		//!
+		virtual spcIUTF8String APICALL GetNameSpace() const = 0;
+
+		//!
+		//! @brief Gets the name of the path segment.
+		//! \return A shared pointer to const \#AdobeXMPCommon::IUTF8String object containing name of the path segment. In case
+		//! path segment has no name space, an invalid shared pointer is returned.
+		//!
+		virtual spcIUTF8String APICALL GetName() const = 0;
+
+		//!
+		//! @brief Gets the type of the path segment.
+		//! \return An object of type \#ePathSegmentType representing type of the path segment.
+		//!
+		virtual ePathSegmentType APICALL GetType() const = 0;
+
+		//!
+		//! @brief Gets the index of the array type path segment.
+		//! \return An objet of type \#AdobeXMPCommon::sizet object representing index of the array type path segment. In case
+		//!  path segment is not of type kPSTArrayIndex, it returns \#AdobeXMPCommon::kMaxSize.
+		//!
+		virtual sizet APICALL GetIndex() const __NOTHROW__ = 0;
+
+		//!
+		//! @brief Gets the value of the qualifier type path segment.
+		//! \return A shared pointer to const \#AdobeXMP::IUTF8String object representing value of the qualifier type path segment.
+		//! In case path segment is not of type kPSTQualifier an invalid shared pointer is returned.
+		//!
+		virtual spcIUTF8String APICALL GetValue() const  = 0;
+
+		//!
+		//! \cond XMP_INTERNAL_DOCUMENTATION
+		
+		//!
+		//! @{
+		//! @brief Returns the actual raw pointer from the shared pointer, which can be a shared pointer of a proxy class.
+		//! \return Either a const or non const pointer to IPathSegment interface.
+		//!
+		virtual pIPathSegment APICALL GetActualIPathSegment() __NOTHROW__ = 0;
+		XMP_PRIVATE pcIPathSegment GetActualIPathSegment() const __NOTHROW__ {
+			return const_cast< IPathSegment_v1 * >( this )->GetActualIPathSegment();
+		}
+		//!
+		//! @}
+
+		//!
+		//! @{
+		//! @brief Returns the pointer to internal interfaces.
+		//! \return Either a const or non const pointer to IPathSegment_I interface.
+		//!
+		virtual AdobeXMPCore_Int::pIPathSegment_I APICALL GetIPathSegment_I() __NOTHROW__ = 0;
+
+		XMP_PRIVATE AdobeXMPCore_Int::pcIPathSegment_I GetIPathSegment_I() const __NOTHROW__ {
+			return const_cast< IPathSegment_v1 * >( this )->GetIPathSegment_I();
+		}
+		//!
+		//! @}
+		
+		//!
+		//! @{
+		//! @brief Converts raw pointer to shared pointer. 
+		//! @details The raw pointer is of version 1 interface
+		//! where as the returned shared pointer depends on the version client is interested in.
+		//! \return Shared pointer to const or non constant interface.
+		//!
+		XMP_PRIVATE static spIPathSegment MakeShared( pIPathSegment_base ptr );
+		XMP_PRIVATE static spcIPathSegment MakeShared( pcIPathSegment_base ptr ) {
+			return MakeShared( const_cast< pIPathSegment_base >( ptr ) );
+		}
+		//!
+		//! @}
+
+		//!
+		//! @brief Returns the unique ID assigned to the interface.
+		//! \return 64 bit unsigned integer representing the unique ID assigned to the interface.
+		//!
+		XMP_PRIVATE static uint64 GetInterfaceID() { return kIPathSegmentID; }
+
+		//!
+		//! @brief Returns the version of the interface.
+		//! \return 32 bit unsigned integer representing the version of the interface.
+		//!
+		XMP_PRIVATE static uint32 GetInterfaceVersion() { return 1; }
+		//! \endcond
+
+		// static factory functions
+
+		// Factories to create the specific segments
+
+		//!
+		//! @brief Creates a normal property path segment.These are essentially all properties (simple, struct and arrays).
+		//! \param[in] nameSpace Pointer to a constant char buffer containing name space URI of the property.
+		//! \param[in] nameSpaceLength Number of characters in nameSpace. In case nameSpace is null terminated set it to \#AdobeXMPCommon::npos.
+		//! \param[in] name Pointer to a constant char buffer containing local name of the property.
+		//! \param[in] nameLength Number of characters in name. In case name is null terminated set it to \#AdobeXMPCommon::npos.
+		//! \return A shared pointer to const \#IPathSegment.
+		//! \attention Throws \#AdobeXMPCommon::pcIError in case
+		//!		- pointers to const char buffers are NULL,
+		//!		- their content is empty.
+		//!
+		XMP_PRIVATE static spcIPathSegment CreatePropertyPathSegment( const char * nameSpace, sizet nameSpaceLength, const char * name, sizet nameLength );
+
+		//!
+		//! @brief Creates an array index path segment that denotes a specific element of an array.
+		//! @details Such segments do not have an own name and inherits the namespace from the Array property itself.
+		//! \param[in] nameSpace Pointer to a constant char buffer containing name space URI of the property.
+		//! \param[in] nameSpaceLength Number of characters in nameSpace. In case nameSpace is null terminated set it to \#AdobeXMPCommon::npos.
+		//! \param[in] index An object of type \#AdobeXMP::sizet containting the index of the array element.
+		//! \return A shared pointer to const \#IPathSegment.
+		//! \attention Throws \#AdobeXMP::pcIError in case
+		//!		- pointers to const char buffers are NULL,
+		//!		- their content is empty.
+		//!
+		//!
+		XMP_PRIVATE static spcIPathSegment CreateArrayIndexPathSegment( const char * nameSpace, sizet nameSpaceLength, sizet index );
+
+		//!
+		//! @brief Creates a Qualifier path segment, which behaves like a normal property
+		//! \param[in] nameSpace Pointer to a constant char buffer containing name space URI of the property.
+		//! \param[in] nameSpaceLength Number of characters in nameSpace. In case nameSpace is null terminated set it to \#AdobeXMPCommon::npos.
+		//! \param[in] name Pointer to a constant char buffer containing local name of the property.
+		//! \param[in] nameLength Number of characters in name. In case name is null terminated set it to \#AdobeXMPCommon::npos.
+		//! \return A shared pointer to const \#IPathSegment.
+		//! \attention Throws \#AdobeXMPCommon::pcIError in case
+		//!		- pointers to const char buffers are NULL,
+		//!		- their content is empty.
+		//!
+		XMP_PRIVATE static spcIPathSegment CreateQualifierPathSegment( const char * nameSpace, sizet nameSpaceLength, const char * name, sizet nameLength );
+
+		//!
+		//! @brief Creates a path segment that selects a specific qualifier by its value.
+		//!        For example a specific language in a alternative array of languages.
+		//! \param[in] nameSpace Pointer to a constant char buffer containing name space URI of the property.
+		//! \param[in] nameSpaceLength Number of characters in nameSpace. In case nameSpace is null terminated set it to \#AdobeXMPCommon::npos.
+		//! \param[in] name Pointer to a constant char buffer containing local name of the property.
+		//! \param[in] nameLength Number of characters in name. In case name is null terminated set it to \#AdobeXMPCommon::npos.
+		//! \param[in] value Pointer to a constant char buffer containing value of the language (xml:lang)
+		//! \param[in] valueLength Number of characters in value. In case value is null terminated set it to \#AdobeXMPCommon::npos.
+		//! \return A shared pointer to const \#IPathSegment.
+		//! \attention Throws #AdobeXMPCommon::pcIError in case
+		//!		- pointers to const char buffers are NULL,
+		//!		- their content is empty.
+		//!
+		XMP_PRIVATE static spcIPathSegment CreateQualifierSelectorPathSegment( const char * nameSpace, sizet nameSpaceLength, const char * name,
+			sizet nameLength, const char * value, sizet valueLength );
+
+
+
+	protected:
+		//!
+		//! Destructor
+		//! 
+		virtual ~IPathSegment_v1() __NOTHROW__ {}
+
+		//! \cond XMP_INTERNAL_DOCUMENTATION
+		virtual pcIUTF8String_base APICALL getNameSpace( pcIError_base & error ) const __NOTHROW__ = 0;
+		virtual pcIUTF8String_base APICALL getName( pcIError_base & error ) const __NOTHROW__ = 0;
+		virtual uint32 APICALL getType( pcIError_base & error ) const __NOTHROW__ = 0;
+		virtual pcIUTF8String_base APICALL getValue( pcIError_base & error ) const __NOTHROW__ = 0;
+
+		#ifdef FRIEND_CLASS_DECLARATION
+			FRIEND_CLASS_DECLARATION();
+		#endif
+		REQ_FRIEND_CLASS_DECLARATION();
+		//! \endcond
+
+	};
+}
+
+#endif  // __IPathSegment_h__