urn.h

Go to the documentation of this file.

#pragma once
//------------------------------------------------------------------------------
#include "core/types.h"
#include "util/string.h"
#include "util/stringatom.h"
#include "util/dictionary.h"
#include "io/uri.h"
 
//------------------------------------------------------------------------------
namespace IO
{
class URN
{
public:
    URN();
    explicit URN(const Util::String& s);
    explicit URN(const char* s);
    explicit URN(const char* nid, const Util::String& nss);
    explicit URN(const char* nid, const char* nss);
    URN(const URN& rhs);
    void operator=(const URN& rhs);
    bool operator==(const URN& rhs) const;
    bool operator!=(const URN& rhs) const;
    
    void Set(const Util::String& s);
    const Util::String& AsString();

    bool IsEmpty() const;
    bool IsValid() const;
    void Clear();
    void SetNamespace(const Util::String& s);
    const Util::String& GetNamespace() const;
    void SetSpecific(const Util::String& s);
    const Util::String& GetSpecific() const;
    void SetQuery(const Util::String& s);
    const Util::String& GetQuery() const;
    void SetFragment(const Util::String& s);
    const Util::String& GetFragment() const;

    const IO::URI ExportURI() const;
    const IO::URI WorkURI(const Util::StringAtom& root);

    static void AddExportMapping(const Util::StringAtom& ns, const Util::StringAtom& extension);
    static void AddWorkMapping(const Util::StringAtom& ns, const Util::StringAtom& extension);
    static void SetWorkRoot(const Util::StringAtom& root);

    void Build();
 
private:
    bool Split(const Util::String& s);
 
 
    bool isEmpty;
    bool isDirty;
    Util::String nid;
    Util::String nss;
    Util::String query;
    Util::String fragment;
    Util::String string;
 
    static Util::Dictionary<Util::StringAtom, Util::StringAtom> ExportExtensions, WorkExtensions;
    static Util::StringAtom WorkRoot;
};
 
//------------------------------------------------------------------------------
inline
URN::URN() :
    isEmpty(true)
{
    // empty
}
 
//------------------------------------------------------------------------------
inline
URN::URN(const Util::String& s) :
    isEmpty(true)
{
    bool validUrn = this->Split(s);
    n_assert2(validUrn, s.AsCharPtr());
}
 
//------------------------------------------------------------------------------
inline
URN::URN(const char* s) :
    isEmpty(true)
{
    bool validUrn = this->Split(s);
    n_assert2(validUrn, s);
}
 
//------------------------------------------------------------------------------
inline 
URN::URN(const char* nid, const Util::String& nss)
{
    this->isEmpty = strlen(nid) == 0 || nss.Length() == 0;
    this->nid = nid;
    this->nss = nss;
    this->Build();
    n_assert(this->IsValid());
}
 
//------------------------------------------------------------------------------
inline 
URN::URN(const char* nid, const char* nss)
{
    this->isEmpty = strlen(nid) == 0 || strlen(nss) == 0;
    this->nid = nid;
    this->nss = nss;
    this->Build();
    n_assert(this->IsValid());
}
 
//------------------------------------------------------------------------------
inline
URN::URN(const URN& rhs) :
    isEmpty(rhs.isEmpty),
    nid(rhs.nid),
    nss(rhs.nss),
    query(rhs.query),
    fragment(rhs.fragment),
    string(rhs.string)
{
    // empty
}
 
//------------------------------------------------------------------------------
inline 
void
URN::operator=(const URN& rhs)
{
    this->isEmpty = rhs.isEmpty;
    this->nid = rhs.nid;
    this->nss = rhs.nss;
    this->query = rhs.query;
    this->fragment = rhs.fragment;
    this->string = rhs.string;
}
 
//------------------------------------------------------------------------------
inline 
bool
URN::operator==(const URN& rhs) const
{
    if (this->isEmpty && rhs.isEmpty)
    {
        return true;
    }
    return ((this->nid == rhs.nid) &&
            (this->nss == rhs.nss) &&
            (this->query == rhs.query) &&
            (this->fragment == rhs.fragment));
}
 
//------------------------------------------------------------------------------
inline 
bool
URN::operator!=(const URN& rhs) const
{
    return !(*this == rhs);
}
 
//------------------------------------------------------------------------------
inline 
bool
URN::IsEmpty() const
{
    return this->isEmpty;
}
 
//------------------------------------------------------------------------------
inline 
bool
URN::IsValid() const
{
    return !this->isEmpty;
}
 
//------------------------------------------------------------------------------
inline 
void
URN::Clear()
{
    this->isEmpty = true;
    this->nid.Clear();
    this->nss.Clear();
    this->query.Clear();
    this->fragment.Clear();
    this->string.Clear();
}
 
//------------------------------------------------------------------------------
inline const Util::String&
URN::AsString()
{
    if (this->isDirty)
        this->Build();
    this->isDirty = false;
    return this->string;
}
 
//------------------------------------------------------------------------------
inline void
URN::Set(const Util::String& s)
{
    this->Split(s);
}
 
//------------------------------------------------------------------------------
inline void
URN::SetNamespace(const Util::String& s)
{
    this->isEmpty = false;
    this->isDirty = true;
    this->nid = s;
}
 
//------------------------------------------------------------------------------
inline const Util::String&
URN::GetNamespace() const
{
    return this->nid;
}
 
//------------------------------------------------------------------------------
inline void
URN::SetSpecific(const Util::String& s)
{
    this->isEmpty = false;
    this->isDirty = true;
    this->nss = s;
}
 
//------------------------------------------------------------------------------
inline const Util::String&
URN::GetSpecific() const
{
    return this->nss;
}
 
//------------------------------------------------------------------------------
inline void
URN::SetQuery(const Util::String& s)
{
    this->isEmpty = false;
    this->isDirty = true;
    this->query = s;
}
 
//------------------------------------------------------------------------------
inline const Util::String&
URN::GetQuery() const
{
    return this->query;
}
 
//------------------------------------------------------------------------------
inline void
URN::SetFragment(const Util::String& s)
{
    this->isEmpty = false;
    this->isDirty = true;
    this->fragment = s;
}
 
//------------------------------------------------------------------------------
inline const Util::String&
URN::GetFragment() const
{
    return this->fragment;
}
 
//------------------------------------------------------------------------------
inline const IO::URI 
URN::ExportURI() const
{
    IndexT i = URN::ExportExtensions.FindIndex(this->nid);
    n_assert(i != InvalidIndex);
    return IO::URI(Util::Format("%s:%s.%s", this->nid.AsCharPtr(), this->nss.AsCharPtr(), URN::ExportExtensions.ValueAtIndex(i).Value()));
}
 
//------------------------------------------------------------------------------
inline const IO::URI
URN::WorkURI(const Util::StringAtom& root)
{
    n_assert(URN::WorkRoot.IsValid());
    IndexT i = URN::ExportExtensions.FindIndex(this->nid);
    n_assert(i != InvalidIndex);
    return IO::URI(Util::Format("%s:%s.%s", URN::WorkRoot.Value(), (this->nss + "/" + root.AsString()).AsCharPtr(), URN::WorkExtensions.ValueAtIndex(i).Value()));
}
 
//------------------------------------------------------------------------------
inline void
URN::AddExportMapping(const Util::StringAtom& ns, const Util::StringAtom& extension)
{
    n_assert(URN::ExportExtensions.FindIndex(ns) == InvalidIndex);
    URN::ExportExtensions.Add(ns, extension);
}
 
//------------------------------------------------------------------------------
inline void
URN::AddWorkMapping(const Util::StringAtom& ns, const Util::StringAtom& extension)
{
    n_assert(URN::WorkExtensions.FindIndex(ns) == InvalidIndex);
    URN::WorkExtensions.Add(ns, extension);
}
 
//------------------------------------------------------------------------------
inline void
URN::SetWorkRoot(const Util::StringAtom& root)
{
    URN::WorkRoot = root;
}
 
} // namespace IO
//------------------------------------------------------------------------------
IO::URN operator ""_urn(const char* c, std::size_t s);
 
//------------------------------------------------------------------------------