ImmutableString.h

Go to the documentation of this file.

/*
 * This file is a part of the Biology project by eons LLC.
 * Biology (aka Develop Biology) is a framework for approaching software
 * development from a natural sciences perspective.
 *
 * Copyright (C) 2022 Séon O'Shannon & eons LLC
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#pragma once
 
#include "bio/common/macro/Macros.h"
 
#include <string>
#include <cstring>
#include <cstdlib>
 
namespace bio {
 
class ImmutableString
{
    friend class String; //makes life easy, no need to use this-> or define extra access methods here.
 
public:
 
    BIO_CONSTEXPR ImmutableString() :
        mString(NULL),
        mLength(0)
    {
 
    }
 
    BIO_CONSTEXPR ImmutableString(const char* string) :
        mString(string),
        mLength(strlen(string))
    {
 
    }
 
    explicit ImmutableString(const char* string, const ::std::size_t length) :
        mString(string),
        mLength(length)
    {
 
    }
 
    BIO_CONSTEXPR ImmutableString(const ImmutableString& toCopy) :
        mString(toCopy.mString),
        mLength(toCopy.mLength)
    {
 
    }
 
    #if BIO_CPP_VERSION >= 11
    BIO_CONSTEXPR ImmutableString(const ImmutableString&& toMove):
        mString(toMove.mString),
        mLength(toMove.mLength)
    {
 
    }
    #endif
 
    #if BIO_CPP_VERSION >= 11
    BIO_CONSTEXPR ImmutableString& operator=(const ImmutableString&& toMove)
    {
        mString = toMove.mString;
        mLength = toMove.mLength;
        return *this;
    }
    #endif
 
    BIO_CONSTEXPR ImmutableString& operator=(const ImmutableString& toCopy)
    {
        mString = toCopy.mString;
        mLength = toCopy.mLength;
        return *this;
    }
 
    BIO_CONSTEXPR const char* Data() const
    {
        return mString;
    }
 
    BIO_CONSTEXPR ::std::size_t Length() const
    {
        return mLength;
    }
 
    BIO_CONSTEXPR bool Empty() const
    {
        return mLength == 0;
    }
 
    BIO_CONSTEXPR ::std::size_t Find(const ImmutableString& substring) const
    {
        //We can almost use strstr here. However, our use of mLength means we would need strnstr, which does not appear to be standard.
        //We could also simplify this by making the inner loop use strncmp but meh.
 
        ::std::size_t start = 0;
        ::std::size_t str = 0;
        ::std::size_t sub = 0;
        while (start < mLength)
        {
            if (mString[start] == substring.mString[0])
            {
                str = start + 1;
                sub = 1;
                if (sub == substring.mLength) //mLength is 1.
                {
                    return start;
                }
                while (mString[str] == substring.mString[sub])
                {
                    ++str;
                    ++sub;
                    if (sub == substring.mLength)
                    {
                        return start;
                    }
                    else if (str == mLength)
                    {
                        return 0;
                    }
                }
            }
            ++start;
        }
        return 0;
    }
 
    BIO_CONSTEXPR ::std::size_t FirstDifference(const ImmutableString& other) const
    {
        ::std::size_t i = 0;
        while (i < mLength && i < other.mLength && mString[i] == other.mString[i])
        {
            ++i;
        }
        return i;
    }
 
    BIO_CONSTEXPR ImmutableString GetImmutableSubString(const ::std::size_t start, const ::std::size_t length) const
    {
        BIO_SANITIZE(start + length <= Length(),
        ,
            return ImmutableString()
        )
        ImmutableString ret;
        ret.mString = &mString[start];
        ret.mLength = length;
        return ret;
    }
 
 
protected:
    const char* mString;
    ::std::size_t mLength;
};
 
} //bio namespace