string.hpp

Go to the documentation of this file.

#pragma once
#ifndef OGLPLUS_STRING_1107121519_HPP
#define OGLPLUS_STRING_1107121519_HPP

#include <oglplus/config.hpp>

#include <string>
#include <cassert>

#if OGLPLUS_LAZY_STR_LIT
#include <cstring>
#endif

namespace oglplus {


bool ValidString(const GLchar* begin, const GLchar* end);


typedef ::std::basic_string<GLchar> String;

const String& EmptyString(void)
OGLPLUS_NOEXCEPT(true);

class StrLit;

namespace aux {

// helper class used for implementation of concatenation
template <typename Left, typename Right>
class StrLitCat
{
private:
    Left _left;
    Right _right;
public:
    StrLitCat(Left left, Right right)
     : _left(left)
     , _right(right)
    { }

    bool empty(void) const
    {
        return _left.empty() && _right.empty();
    }

    std::size_t size(void) const
    {
        return _left.size() + _right.size();
    }

    void append_to(String& dest) const
    {
        _left.append_to(dest);
        _right.append_to(dest);
    }

    String str(void) const
    {
        String result;
        result.reserve(this->size()+1);
        this->append_to(result);
        return result;
    }

#if !OGLPLUS_NO_EXPLICIT_CONVERSION_OPERATORS
    inline explicit operator String(void) const
#else
    inline operator String(void) const
#endif
    {
        return str();
    }
};

} // namespace aux


class StrLit
{
private:
    const GLchar* _lit;
#if !OGLPLUS_LAZY_STR_LIT
    std::size_t _size;
#endif

    void _check(void) const
    {
        assert(ValidString(begin(), end()));
    }
public:
    StrLit(void)
     : _lit("")
#if !OGLPLUS_LAZY_STR_LIT
     , _size(0)
#endif
    { }

#if OGLPLUS_DOCUMENTATION_ONLY
    StrLit(std::nullptr_t);
#elif !OGLPLUS_NO_NULLPTR
    StrLit(std::nullptr_t)
#else
    StrLit(int)
#endif
     : _lit("")
#if !OGLPLUS_LAZY_STR_LIT
     , _size(0)
#endif
    { }

#if OGLPLUS_DOCUMENTATION_ONLY

    explicit StrLit(const GLchar* literal);
#elif !OGLPLUS_LAZY_STR_LIT
    template <std::size_t N>
    explicit StrLit(const GLchar (&lit)[N])
     : _lit(lit)
     , _size(N-1)
    { _check(); }
#else
    explicit StrLit(const GLchar* lit)
     : _lit(lit)
    { _check(); }
#endif


    explicit StrLit(const GLchar* lit, std::size_t lit_size)
     : _lit(lit)
#if !OGLPLUS_LAZY_STR_LIT
     , _size(lit_size)
#endif
    {
        OGLPLUS_FAKE_USE(lit_size);
        _check();
    }

    String str(void) const
    {
#if !OGLPLUS_LAZY_STR_LIT
        return String(_lit, _lit+_size);
#else
        return String(_lit);
#endif
    }

    void append_to(String& dest) const
    {
#if !OGLPLUS_LAZY_STR_LIT
        dest.append(_lit, _lit+_size);
#else
        dest.append(_lit);
#endif
    }

    const GLchar* c_str(void) const
    {
        return _lit;
    }

    std::size_t size(void) const
    {
#if !OGLPLUS_LAZY_STR_LIT
        return _size;
#else
        return std::strlen(_lit);
#endif
    }

    bool empty(void) const
    {
#if !OGLPLUS_LAZY_STR_LIT
        return _size == 0;
#else
        return _lit[0] == '\0';
#endif
    }

    typedef const GLchar* iterator;

    typedef const GLchar* const_iterator;

    const_iterator begin(void) const
    {
        return c_str();
    }

    const_iterator end(void) const
    {
        return c_str()+size();
    }

    friend const_iterator begin(const StrLit& strlit)
    {
        return strlit.begin();
    }

    friend const_iterator end(const StrLit& strlit)
    {
        return strlit.end();
    }

    operator bool (void) const
    {
        return !empty();
    }

    bool operator ! (void) const
    {
        return empty();
    }

#if OGLPLUS_DOCUMENTATION_ONLY

    friend Unspecified operator + (StrLit a, StrLit b);
#endif

    friend aux::StrLitCat<StrLit, StrLit> operator + (StrLit a, StrLit b)
    {
        return aux::StrLitCat<StrLit, StrLit>(a, b);
    }

    template <typename Left, typename Right>
    friend aux::StrLitCat<aux::StrLitCat<Left, Right>, StrLit>
    operator + (aux::StrLitCat<Left, Right> a, StrLit b)
    {
        return aux::StrLitCat<aux::StrLitCat<Left, Right>,StrLit>(a, b);
    }
};

} // namespace oglplus

#if !OGLPLUS_LINK_LIBRARY || defined(OGLPLUS_IMPLEMENTING_LIBRARY)
#include <oglplus/string.ipp>
#endif

#endif // include guard