daeURI.h

Go to the documentation of this file.

/*
* Copyright 2006 Sony Computer Entertainment Inc.
*
* Licensed under the MIT Open Source License, for details please see license.txt or the website
* http://www.opensource.org/licenses/mit-license.php
*
*/ 

#ifndef __DAE_URI_H__
#define __DAE_URI_H__

#include <string>
#include <dae/daeTypes.h>
#include <dae/daeElement.h>
#include <dae/daeUtils.h>
class DAE;

class DLLSPEC daeURI
{
private:
        daeElement* internalResolveElement() const;
        
public:
        enum ResolveState{
                uri_empty,
                uri_loaded,
                uri_pending,
                uri_success,
                uri_failed_unsupported_protocol,
                uri_failed_file_not_found,
                uri_failed_id_not_found,
                uri_failed_invalid_id,
                uri_resolve_local,
                uri_resolve_relative,
                uri_resolve_absolute,
                uri_failed_invalid_reference,
                uri_failed_externalization,
                uri_failed_missing_container,
                uri_failed_external_document
        };
        
private:
        // All daeURIs have a pointer to a master DAE that they use to access global information.
        mutable DAE* dae;
        
        std::string uriString;

        std::string originalURIString;
        
        std::string _scheme;
        std::string _authority;
        std::string _path;
        std::string _query;
        std::string _fragment;
        daeElement* container;
        
public:
        daeURI(DAE& dae);
        ~daeURI();

        daeURI(DAE& dae, const std::string& URIString, daeBool nofrag = false);
        
        daeURI(const daeURI& baseURI, const std::string& URIString);

        daeURI(const daeURI& constructFromURI);

        daeURI(daeElement& container, const std::string& uriString = "");

        // This constructor is for internal DOM purposes only. For client code, use the constructor
        // that takes only a daeElement instead of this one.
        daeURI(DAE& dae, daeElement& container, const std::string& uriString = "");

        DAE* getDAE() const;

        // Returns the fully resolved URI as a string
        const std::string& str() const;
        // Returns the URI as originally set (i.e. not resolved against the base URI)
        const std::string& originalStr() const;

        // Old C string versions of the previous functions
        daeString getURI() const; // Alias for str()
        daeString getOriginalURI() const; // Alias for originalStr();

        // Setter function for setting the full uri.
        void set(const std::string& uriStr, const daeURI* baseURI = NULL);
        // Setter function for setting the individual uri components.
        void set(const std::string& scheme,
                 const std::string& authority,
                 const std::string& path,
                 const std::string& query,
                 const std::string& fragment,
                 const daeURI* baseURI = NULL);

        // Old C string function. Alias for set().
        void setURI(daeString uriStr, const daeURI* baseURI = NULL);

        // std::string based component accessors.
        const std::string& scheme() const;
        const std::string& authority() const;
        const std::string& path() const;
        const std::string& query() const;
        const std::string& fragment() const;
        const std::string& id() const; // Alias for fragment()

        // Component setter functions. If you're going to be calling multiple setters, as in
        //   uri.path(path);
        //   uri.fragment(frag);
        // it'd be more efficient to call uri.set once instead.
        void scheme(const std::string& scheme);
        void authority(const std::string& authority);
        void path(const std::string& path);
        void query(const std::string& query);
        void fragment(const std::string& fragment);
        void id(const std::string& id); // Alias for uri.fragment(frag)
        
        // Retrieves the individual path components. For example, in a uri of the form
        // file:/folder/file.dae, dir = /folder/, baseName = file, ext = .dae
        void pathComponents(std::string& dir, std::string& baseName, std::string& ext) const;

        // Individual path component accessors. If you need access to multiple path
        // components, calling pathComponents() will be faster.
        std::string pathDir() const;      // daeURI("/folder/file.dae").pathDir() == "/folder/"
        std::string pathFileBase() const; // daeURI("/folder/file.dae").pathFileBase() == "file"
        std::string pathExt() const;      // daeURI("/folder/file.dae").pathExt() == ".dae"
        std::string pathFile() const;     // daeURI("/folder/file.dae").pathFile() == "file.dae"

        // Path component setter.
        void path(const std::string& dir, const std::string& baseName, const std::string& ext);

        // Individual path component setters. If you're going to be calling multiple setters,
        // it'd be more efficient to call set() instead.
        void pathDir(const std::string& dir);
        void pathFileBase(const std::string& baseName);
        void pathExt(const std::string& ext);
        void pathFile(const std::string& file);
        
        // The older C string accessors. Aliases for the std::string based component accessors.
        daeString getScheme() const;
        daeString getProtocol() const; // Alias for getScheme()
        daeString getAuthority() const;
        daeString getPath() const;
        daeString getQuery() const;
        daeString getFragment() const;
        daeString getID() const; // Alias for getFragment()
        // Same as getPath(), but puts the result in the destination buffer. This is only here
        // for backward compatibility. Use getPath() instead.
        daeBool getPath(daeChar* dest, daeInt size) const;

        daeElementRef getElement() const;

        // Returns the document that this URI references, or null if the document
        // hasn't been loaded yet.
        daeDocument* getReferencedDocument() const;
        
        inline daeElement* getContainer() const {return(container);};

        void setContainer(daeElement* container);

        daeBool isExternalReference() const;
         
        void copyFrom(const daeURI& from);

        void print();
        
        int makeRelativeTo(const daeURI* uri);

        inline bool operator==(const daeURI& other) const {
                return uriString == other.uriString;
        }

        daeURI& operator=(const daeURI& other);
        daeURI& operator=(const std::string& uri);

        // These methods are deprecated.
        void resolveElement(); // Call getElement directly.
        void validate(const daeURI* baseURI = NULL); // Shouldn't ever need to call this.
        ResolveState getState() const;  // Call getElement to see if resolving succeeded.
        void setState(ResolveState newState); // Don't call this.

private:
        void reset();

        void initialize();
public:
        static void normalizeURIPath(char* path);
};

class daeURIResolver;
typedef daeTArray<daeURIResolver*> daeURIResolverPtrArray;

class DLLSPEC daeURIResolver
{
public:
        daeURIResolver(DAE& dae);

        virtual ~daeURIResolver();
        
        static void setAutoLoadExternalDocuments( daeBool load );

        static daeBool getAutoLoadExternalDocuments();

        virtual daeElement* resolveElement(const daeURI& uri) = 0;

        virtual daeString getName() = 0;

protected:
        static daeBool _loadExternalDocuments;
        DAE* dae;
};


// This is a container class for storing a modifiable list of daeURIResolver objects.
class DLLSPEC daeURIResolverList {
public:
        daeURIResolverList();
        ~daeURIResolverList();

        daeTArray<daeURIResolver*>& list();
        daeElement* resolveElement(const daeURI& uri);

private:
        // Disabled copy constructor/assignment operator
        daeURIResolverList(const daeURIResolverList& resolverList) { };
        daeURIResolverList& operator=(const daeURIResolverList& resolverList) { return *this; };

        daeTArray<daeURIResolver*> resolvers;
};


// Helper functions for file path <--> URI conversion
namespace cdom {
        // Takes a uri reference and parses it into its components.
        DLLSPEC bool parseUriRef(const std::string& uriRef,
                                 std::string& scheme,
                                 std::string& authority,
                                 std::string& path,
                                 std::string& query,
                                 std::string& fragment);

        // Takes the uri components of a uri ref and combines them.
        //
        // The 'forceLibxmlCompatible' param is meant to work around bugs in the file
        // scheme uri handling of libxml. It causes the function to output a uri
        // that's fully compatible with libxml. It only modifies file scheme uris,
        // since uris with other schemes seem to work fine.
        //
        // The known libxml uri bugs are as follows:
        //   1) libxml won't write files when given file scheme URIs with an empty
        //      authority, as in "file:/home".
        //   2) libxml won't read or write Windows UNC paths represented with the
        //      machine name in the authority, as in "file://otherMachine/folder/file.dae"
        //   3) On Windows, libxml won't read or write paths that don't have a drive
        //      letter, as in "/folder/file.dae".
        DLLSPEC std::string assembleUri(const std::string& scheme,
                                        const std::string& authority,
                                        const std::string& path,
                                        const std::string& query,
                                        const std::string& fragment,
                                        bool forceLibxmlCompatible = false);

        // A wrapper function for calling assembleUri to create a URI that's compatible
        // with libxml.
        DLLSPEC std::string fixUriForLibxml(const std::string& uriRef);

        // This function takes a file path in the OS's native format and converts it to
        // a URI reference. If a relative path is given, a relative URI reference is
        // returned. If an absolute path is given, a relative URI reference containing 
        // a fully specified path is returned. Spaces are encoded as %20. The 'type'
        // parameter indicates the format of the nativePath.
        //
        // Examples - Windows
        //   nativePathToUri("C:\myFolder\myFile.dae") --> "/C:/myFolder/myFile.dae"
        //   nativePathToUri("\myFolder\myFile.dae") --> "/myFolder/myFile.dae"
        //   nativePathToUri("..\myFolder\myFile.dae") --> "../myFolder/myFile.dae"
        //   nativePathToUri("\\otherComputer\myFile.dae") --> "//otherComputer/myFile.dae"
        //
        // Examples - Linux/Mac
        //   nativePathToUri("/myFolder/myFile.dae") --> "/myFolder/myFile.dae"
        //   nativePathToUri("../myFolder/myFile.dae") --> "../myFolder/myFile.dae"
        //   nativePathToUri("/my folder/my file.dae") --> "/my%20folder/my%20file.dae"
        DLLSPEC std::string nativePathToUri(const std::string& nativePath,
                                            systemType type = getSystemType());

        // This function takes a URI reference and converts it to an OS file path. Conversion
        // can fail if the URI reference is ill-formed, or if the URI contains a scheme other
        // than "file", in which case an empty string is returned. The 'type' parameter
        // indicates the format of the returned native path.
        //
        // Examples - Windows
        //   uriToNativePath("../folder/file.dae") --> "..\folder\file.dae"
        //   uriToNativePath("/folder/file.dae") --> "\folder\file.dae"
        //   uriToNativePath("file:/C:/folder/file.dae") --> "C:\folder\file.dae"
        //   uriToNativePath("file://otherComputer/file.dae") --> "\\otherComputer\file.dae"
        //   uriToNativePath("http://www.slashdot.org") --> "" (it's not a file scheme URI!)
        //
        // Examples - Linux/Mac
        //   uriToNativePath("../folder/file.dae") --> "../folder/file.dae"
        //   uriToNativePath("file:/folder/file.dae") --> "/folder/file.dae"
        //   uriToNativePath("http://www.slashdot.org") --> "" (it's not a file scheme URI!)
        DLLSPEC std::string uriToNativePath(const std::string& uriRef,
                                            systemType type = getSystemType());

        DLLSPEC std::string filePathToUri(const std::string& filePath); // Alias for nativePathToUri
        DLLSPEC std::string uriToFilePath(const std::string& uriRef); // Alias for uriToNativePath
}

#endif //__DAE_URI_H__

---

colladadom
Author(s): Du Hung Hou, Khronos.org, Marcus Barnes, Greg Corson, Herbert Law, Sebastian Schwarz, Steven Thomas, John Hsu (ros package), Tim Field (ros package)
autogenerated on Fri Jan 11 09:24:25 2013