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;
    bool IsFolder() 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;
    void Build();
private:
    bool Split(const Util::String& s);
 
    bool isFolder;
    bool isEmpty;
    bool isDirty;
    Util::String nid;
    Util::String nss;
    Util::String query;
    Util::String fragment;
    Util::String string;
 
    
};
 
//------------------------------------------------------------------------------
inline
URN::URN() :
    isEmpty(true),
    isFolder(false)
{
    // empty
}
 
//------------------------------------------------------------------------------
inline
URN::URN(const Util::String& s) :
    isEmpty(true),
    isFolder(false)
{
    bool validUrn = this->Split(s);
}
 
//------------------------------------------------------------------------------
inline
URN::URN(const char* s) :
    isEmpty(true),
    isFolder(false)
{
    bool validUrn = this->Split(s);
    n_assert2(validUrn, s);
}
 
//------------------------------------------------------------------------------
inline 
URN::URN(const char* nid, const Util::String& nss)
{
    this->isFolder = strlen(nid) == 0;
    this->isEmpty = this->isFolder && nss.Length() == 0;
    this->nid = nid;
    this->nss = nss;
    this->Build();
}
 
//------------------------------------------------------------------------------
inline 
URN::URN(const char* nid, const char* nss)
{
    this->isFolder = strlen(nid) == 0;
    this->isEmpty = this->isFolder && strlen(nss) == 0;
    this->nid = nid;
    this->nss = nss;
    this->Build();
}
 
//------------------------------------------------------------------------------
inline
URN::URN(const URN& rhs) :
    isEmpty(rhs.isEmpty),
    isFolder(rhs.isFolder),
    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->isFolder = rhs.isFolder;
    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 bool 
URN::IsFolder() const
{
    return this->isFolder;
}
 
//------------------------------------------------------------------------------
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;
}
 
} // namespace IO
 
//------------------------------------------------------------------------------
IO::URN operator ""_urn(const char* c, std::size_t s);
 
//------------------------------------------------------------------------------