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);
    Util::String AsString() const;

    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 MakeURI(const Util::StringAtom& extension) const;
private:
    bool Split(const Util::String& s);
    Util::String Build() const;
 
    bool isEmpty;
    Util::String nid;
    Util::String nss;
    Util::String query;
    Util::String fragment;
};
 
//------------------------------------------------------------------------------
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;
    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;
    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)
{
    // 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;
}
 
//------------------------------------------------------------------------------
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();
}
 
//------------------------------------------------------------------------------
inline 
Util::String
URN::AsString() const
{
    return this->Build();
}
 
//------------------------------------------------------------------------------
inline
void
IO::URN::Set(const Util::String& s)
{
    this->Split(s);
}
 
//------------------------------------------------------------------------------
inline
void
IO::URN::SetNamespace(const Util::String& s)
{
    this->isEmpty = false;
    this->nid = s;
}
 
//------------------------------------------------------------------------------
inline
const Util::String&
IO::URN::GetNamespace() const
{
    return this->nid;
}
 
//------------------------------------------------------------------------------
inline
void
IO::URN::SetSpecific(const Util::String& s)
{
    this->isEmpty = false;
    this->nss = s;
}
 
//------------------------------------------------------------------------------
inline
const Util::String&
IO::URN::GetSpecific() const
{
    return this->nss;
}
 
//------------------------------------------------------------------------------
inline
void
IO::URN::SetQuery(const Util::String& s)
{
    this->isEmpty = false;
    this->query = s;
}
 
//------------------------------------------------------------------------------
inline
const Util::String&
IO::URN::GetQuery() const
{
    return this->query;
}
 
//------------------------------------------------------------------------------
inline
void
IO::URN::SetFragment(const Util::String& s)
{
    this->isEmpty = false;
    this->fragment = s;
}
 
//------------------------------------------------------------------------------
inline
const Util::String&
IO::URN::GetFragment() const
{
    return this->fragment;
}
 
//------------------------------------------------------------------------------
inline const IO::URI 
URN::MakeURI(const Util::StringAtom& extension) const
{
    return IO::URI(Util::Format("%s:%s.%s", this->nid.AsCharPtr(), this->nss.AsCharPtr(), extension.Value()));
}
 
} // namespace IO
//------------------------------------------------------------------------------
IO::URN operator ""_urn(const char* c, std::size_t s);
 
//------------------------------------------------------------------------------