CRNPath.h

Go to the documentation of this file.

/* Copyright 2010-2016 CoReNum, INSA-Lyon, Université Paris Descartes, ENS-Lyon
 * 
 * This file is part of libcrn.
 * 
 * libcrn is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * libcrn 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 Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public License
 * along with libcrn.  If not, see <http://www.gnu.org/licenses/>.
 * 
 * file: CRNPath.h
 * \author Yann LEYDIER
 */

#ifndef CRNPath_HEADER
#define CRNPath_HEADER

#include <CRNStringUTF8.h>

namespace crn
{
    class Path: public StringUTF8
    {
        public:
            enum class Format
            {
                AUTO = 0, URI = 1, UNIX = 2, WINDOWS = 3,
#ifdef _MSC_VER
                LOCAL = 3
#else
                LOCAL = 2
#endif
            };
            // Constructors

            Path(Format fmt = Format::LOCAL):format(fmt) {}
            Path(const std::string &s, Format fmt = Format::LOCAL):StringUTF8(s),format(Format::AUTO) { ConvertTo(fmt); }
            Path(std::string &s, Format fmt = Format::LOCAL):StringUTF8(s),format(Format::AUTO) { ConvertTo(fmt); }
            Path(char *s, Format fmt = Format::LOCAL):StringUTF8(s),format(Format::AUTO) { ConvertTo(fmt); }
            Path(const char *s, Format fmt = Format::LOCAL):StringUTF8(s),format(Format::AUTO) { ConvertTo(fmt); }
            Path(const Path &s, Format fmt = Format::AUTO):StringUTF8(s),format(s.format) { ConvertTo(fmt); }
            Path(Path&&) = default;
            Path(const StringUTF8 &s, Format fmt = Format::LOCAL):StringUTF8(s),format(Format::AUTO) { ConvertTo(fmt); }
            explicit Path(const String &s, Format fmt = Format::LOCAL):StringUTF8(s),format(Format::AUTO) { ConvertTo(fmt); }
            Path(char c, size_t n = 1, Format fmt = Format::LOCAL):StringUTF8(c, n),format(Format::AUTO) { ConvertTo(fmt); }
            Path(int i, Format fmt = Format::LOCAL):StringUTF8(i),format(fmt) { }   
            Path(xml::Element &el):format(Format::AUTO) { Deserialize(el); }
            virtual ~Path() override = default;

            Path& operator=(const Path&) = default;
            Path& operator=(Path&&) = default;

            std::vector<Path> Split(const StringUTF8 &sep) const;

            // Format info

            Format GetFormat() const;
            bool IsURI() const;
            bool IsUnix() const;
            bool IsWindows() const;
            Path& ConvertTo(Format fmt);
            
            // Generic methods
            
            const Path& operator+=(const Path &s);
            const Path& operator/=(const Path &s);

            bool IsAbsolute() const;
            bool IsRelative() const { return !IsAbsolute(); }
            Path GetFilename() const;
            Path GetBase() const;
            Path GetExtension() const;
            Path GetDirectory() const;

            static char Separator() noexcept;

            void Swap(Path &str) noexcept { StringUTF8::Swap(str); std::swap(format, str.format); }

            // URI methods
    
            StringUTF8 GetScheme() const;
            Path& ToURI();
            Path& Decode();

            // Unix methods

            Path& ToUnix();

            // Windows methods

            char GetDrive() const;
            static char NoDrive(); 
            Path& ToWindows();

            Path& ToLocal();

            virtual void Deserialize(xml::Element &el) override;
            virtual xml::Element Serialize(xml::Element &parent) const override;
        private:
            Format format;

        CRN_DECLARE_CLASS_CONSTRUCTOR(Path)
    };
    template<> struct IsSerializable<Path> : public std::true_type {};
    template<> struct IsClonable<Path> : public std::true_type {};

    inline Path operator+(const Path &s1, const Path &s2) { Path tmp(s1); return tmp += s2; }
    inline Path operator/(const Path &s1, const Path &s2) { Path tmp(s1); return tmp /= s2; }
    inline size_t Size(Path &p) noexcept { return p.Size(); }
    inline void Swap(Path &p1, Path &p2) noexcept { p1.Swap(p2); }

    namespace literals
    {
        inline Path operator"" _p(const char *str, size_t len)
        {
            return Path{std::string{str, len}};
        }
    }   
}

namespace std
{
    inline void swap(crn::Path &p1, crn::Path &p2) noexcept { p1.Swap(p2); }

    template<> struct hash<crn::Path>
    {
        inline size_t operator()(const crn::Path &p) { return hash<string>{}(p.Std()); }
    };
}

#include <CRNIO/CRNPathPtr.h>
#endif