LCOV - code coverage report
Current view: top level - snapwebsites - snap_version.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 0 36 0.0 %
Date: 2019-12-15 17:13:15 Functions: 0 40 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : // Snap Websites Server -- handle versions and dependencies
       2             : // Copyright (c) 2014-2019  Made to Order Software Corp.  All Rights Reserved
       3             : //
       4             : // This program is free software; you can redistribute it and/or modify
       5             : // it under the terms of the GNU General Public License as published by
       6             : // the Free Software Foundation; either version 2 of the License, or
       7             : // (at your option) any later version.
       8             : //
       9             : // This program is distributed in the hope that it will be useful,
      10             : // but WITHOUT ANY WARRANTY; without even the implied warranty of
      11             : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      12             : // GNU General Public License for more details.
      13             : //
      14             : // You should have received a copy of the GNU General Public License
      15             : // along with this program; if not, write to the Free Software
      16             : // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
      17             : #pragma once
      18             : 
      19             : #include "snapwebsites/snap_exception.h"
      20             : #include "snapwebsites/qstring_stream.h"
      21             : 
      22             : #include <QVector>
      23             : 
      24             : 
      25             : namespace snap
      26             : {
      27             : namespace snap_version
      28             : {
      29             : 
      30           0 : class snap_version_exception : public snap_exception
      31             : {
      32             : public:
      33           0 :     explicit snap_version_exception(char const *        whatmsg) : snap_exception("snap_version", whatmsg) {}
      34             :     explicit snap_version_exception(std::string const & whatmsg) : snap_exception("snap_version", whatmsg) {}
      35             :     explicit snap_version_exception(QString const &     whatmsg) : snap_exception("snap_version", whatmsg) {}
      36             : };
      37             : 
      38           0 : class snap_version_exception_invalid_extension : public snap_version_exception
      39             : {
      40             : public:
      41           0 :     explicit snap_version_exception_invalid_extension(char const *        whatmsg) : snap_version_exception(whatmsg) {}
      42             :     explicit snap_version_exception_invalid_extension(std::string const & whatmsg) : snap_version_exception(whatmsg) {}
      43             :     explicit snap_version_exception_invalid_extension(QString const &     whatmsg) : snap_version_exception(whatmsg) {}
      44             : };
      45             : 
      46             : 
      47             : enum class compare_t : signed int
      48             : {
      49             :     COMPARE_INVALID = -2, // i.e. unordered
      50             :     COMPARE_SMALLER = -1,
      51             :     COMPARE_EQUAL   =  0,
      52             :     COMPARE_LARGER  =  1
      53             : };
      54             : 
      55             : typedef uint32_t basic_version_number_t;
      56             : 
      57             : static basic_version_number_t const SPECIAL_VERSION_ALL               = static_cast<basic_version_number_t>(-4); // apply to all branches
      58             : static basic_version_number_t const SPECIAL_VERSION_EXTENDED          = static_cast<basic_version_number_t>(-3); // revision of .js/.css may be more than one number
      59             : static basic_version_number_t const SPECIAL_VERSION_INVALID           = static_cast<basic_version_number_t>(-2);
      60             : static basic_version_number_t const SPECIAL_VERSION_UNDEFINED         = static_cast<basic_version_number_t>(-1);
      61             : static basic_version_number_t const SPECIAL_VERSION_MIN               = 0;
      62             : static basic_version_number_t const SPECIAL_VERSION_SYSTEM_BRANCH     = 0;
      63             : static basic_version_number_t const SPECIAL_VERSION_USER_FIRST_BRANCH = 1;
      64             : static basic_version_number_t const SPECIAL_VERSION_FIRST_REVISION    = 0;
      65             : static basic_version_number_t const SPECIAL_VERSION_MAX_BRANCH_NUMBER = static_cast<basic_version_number_t>(-5);
      66             : static basic_version_number_t const SPECIAL_VERSION_MAX               = static_cast<basic_version_number_t>(-1);
      67             : 
      68             : static basic_version_number_t const SPECIAL_VERSION_DEFAULT           = SPECIAL_VERSION_UNDEFINED;
      69             : 
      70             : class version_number_t
      71             : {
      72             : public:
      73           0 :     version_number_t() noexcept
      74           0 :     {
      75           0 :     }
      76             : 
      77           0 :     version_number_t(version_number_t const & rhs)
      78           0 :         : f_version(rhs.f_version)
      79             :     {
      80           0 :     }
      81             : 
      82           0 :     version_number_t(basic_version_number_t const v)
      83           0 :         : f_version(v)
      84             :     {
      85           0 :     }
      86             : 
      87           0 :     version_number_t & operator = (version_number_t const & rhs)
      88             :     {
      89           0 :         f_version = rhs.f_version;
      90           0 :         return *this;
      91             :     }
      92             : 
      93           0 :     version_number_t & operator = (basic_version_number_t const v)
      94             :     {
      95           0 :         f_version = v;
      96           0 :         return *this;
      97             :     }
      98             : 
      99           0 :     /*explicit*/ operator basic_version_number_t () const
     100             :     {
     101           0 :         return f_version;
     102             :     }
     103             : 
     104             :     version_number_t & operator -- ()
     105             :     {
     106             :         --f_version;
     107             :         return *this;
     108             :     }
     109             : 
     110             :     version_number_t & operator ++ ()
     111             :     {
     112             :         ++f_version;
     113             :         return *this;
     114             :     }
     115             : 
     116             :     version_number_t operator -- (int)
     117             :     {
     118             :         version_number_t const copy(*this);
     119             :         --f_version;
     120             :         return copy;
     121             :     }
     122             : 
     123             :     version_number_t operator ++ (int)
     124             :     {
     125             :         version_number_t const copy(*this);
     126             :         ++f_version;
     127             :         return copy;
     128             :     }
     129             : 
     130             : private:
     131             :     basic_version_number_t          f_version = SPECIAL_VERSION_UNDEFINED;
     132             : };
     133             : 
     134             : typedef QVector<version_number_t> version_numbers_vector_t;
     135             : 
     136             : enum class operator_t
     137             : {
     138             :     /* ?? */ OPERATOR_UNORDERED,
     139             :     /* == */ OPERATOR_EQUAL,
     140             :     /* != */ OPERATOR_EXCEPT,
     141             :     /* <  */ OPERATOR_EARLIER,
     142             :     /* >  */ OPERATOR_LATER,
     143             :     /* <= */ OPERATOR_EARLIER_OR_EQUAL,
     144             :     /* >= */ OPERATOR_LATER_OR_EQUAL
     145             : };
     146             : 
     147             : 
     148             : char const * find_extension(QString const & filename, char const ** extensions);
     149             : bool validate_basic_name(QString const & name, QString & error);
     150             : bool validate_name(QString & name, QString & error, QString & namespace_string);
     151             : bool validate_version(QString const & version_string, version_numbers_vector_t & version, QString & error);
     152             : bool validate_operator(QString const & operator_string, operator_t & op, QString & error);
     153             : 
     154             : 
     155           0 : class name
     156             : {
     157             : public:
     158             :     typedef QVector<name>   vector_t;
     159             : 
     160           0 :     void                    clear() { f_name.clear(); f_error.clear(); }
     161             :     bool                    set_name(QString const & name_string);
     162           0 :     QString const &         get_name() const { return f_name; }
     163           0 :     QString const &         get_namespace() const { return f_namespace; }
     164           0 :     bool                    is_valid() const { return f_error.isEmpty(); }
     165           0 :     QString                 get_error() const { return f_error; }
     166             : 
     167             :     compare_t               compare(name const & rhs) const;
     168             : 
     169             : private:
     170             :     QString                 f_name = QString();
     171             :     QString                 f_namespace = QString();
     172             :     QString                 f_error = QString();
     173             : };
     174             : 
     175             : 
     176           0 : class version_operator
     177             : {
     178             : public:
     179             :     bool                    set_operator_string(QString const & operator_string);
     180             :     bool                    set_operator(operator_t op);
     181             :     char const *            get_operator_string() const;
     182           0 :     operator_t              get_operator() const { return f_operator; }
     183           0 :     bool                    is_valid() const { return f_error.isEmpty(); }
     184           0 :     QString const &         get_error() const { return f_error; }
     185             : 
     186             : private:
     187             :     operator_t              f_operator = operator_t::OPERATOR_UNORDERED;
     188             :     QString                 f_error = QString();
     189             : };
     190             : 
     191             : 
     192           0 : class version
     193             : {
     194             : public:
     195             :     typedef QVector<version>    vector_t;
     196             : 
     197             :     bool                        set_version_string(QString const & version_string);
     198             :     void                        set_version(version_numbers_vector_t const & version);
     199             :     void                        set_operator(version_operator const & op);
     200             :     version_numbers_vector_t const & get_version() const { return f_version; }
     201             :     QString const &             get_version_string() const;
     202             :     QString                     get_opversion_string() const;
     203             :     version_operator const &    get_operator() const { return f_operator; }
     204           0 :     bool                        is_valid() const { return f_error.isEmpty() && f_operator.is_valid(); }
     205           0 :     QString                     get_error() const { return f_error; }
     206             : 
     207             :     compare_t                   compare(version const & rhs) const;
     208             : 
     209             : private:
     210             :     mutable QString             f_version_string = QString();
     211             :     version_numbers_vector_t    f_version = version_numbers_vector_t();
     212             :     QString                     f_error = QString();
     213             :     version_operator            f_operator = version_operator();
     214             : };
     215             : 
     216             : 
     217             : class versioned_filename
     218             : {
     219             : public:
     220             : 
     221             :                                 versioned_filename(QString const & extension);
     222             : 
     223             :     bool                        set_filename(QString const & filename);
     224             :     bool                        set_name(QString const & name);
     225             :     bool                        set_version(QString const & version_string);
     226             : 
     227           0 :     bool                        is_valid() const { return f_error.isEmpty() && f_name.is_valid() && f_version.is_valid() && f_browser.is_valid(); }
     228             : 
     229             :     QString                     get_error() const { return f_error; }
     230             :     QString                     get_filename(bool extension = false) const;
     231             :     QString const &             get_extension() const { return f_extension; }
     232             :     QString const &             get_name() const { return f_name.get_name(); }
     233             :     QString const &             get_version_string() const { return f_version.get_version_string(); } // this was canonicalized
     234             :     version_numbers_vector_t const & get_version() const { return f_version.get_version(); }
     235             :     QString const &             get_browser() const { return f_browser.get_name(); }
     236             : 
     237             :     compare_t                   compare(versioned_filename const & rhs) const;
     238             :     bool                        operator == (versioned_filename const & rhs) const;
     239             :     bool                        operator != (versioned_filename const & rhs) const;
     240             :     bool                        operator <  (versioned_filename const & rhs) const;
     241             :     bool                        operator <= (versioned_filename const & rhs) const;
     242             :     bool                        operator >  (versioned_filename const & rhs) const;
     243             :     bool                        operator >= (versioned_filename const & rhs) const;
     244             : 
     245             :                                 operator bool () const { return is_valid(); }
     246             :     bool                        operator ! () const { return !is_valid(); }
     247             : 
     248             : private:
     249             :     QString                     f_error = QString();
     250             :     QString                     f_extension = QString();
     251             :     name                        f_name = name();
     252             :     version                     f_version = version();
     253             :     name                        f_browser = name();
     254             : };
     255             : 
     256             : 
     257           0 : class dependency
     258             : {
     259             : public:
     260             :     bool                        set_dependency(QString const & dependency_string);
     261             :     QString                     get_dependency_string() const;
     262             :     QString const &             get_name() const { return f_name.get_name(); }
     263             :     QString const &             get_namespace() const { return f_name.get_namespace(); }
     264             :     version::vector_t const &   get_versions() const { return f_versions; }
     265             :     name::vector_t const &      get_browsers() const { return f_browsers; }
     266             :     bool                        is_valid() const;
     267             :     QString const &             get_error() const { return f_error; }
     268             : 
     269             : private:
     270             :     QString                     f_error = QString();
     271             :     name                        f_name = name();
     272             :     version::vector_t           f_versions = version::vector_t();
     273             :     name::vector_t              f_browsers = name::vector_t();
     274             : };
     275             : typedef QVector<dependency>     dependency_vector_t;
     276             : 
     277             : 
     278             : class quick_find_version_in_source
     279             : {
     280             : public:
     281             :                                 quick_find_version_in_source();
     282             :                                 quick_find_version_in_source(quick_find_version_in_source const & rhs) = delete;
     283             :     quick_find_version_in_source & operator = (quick_find_version_in_source const & rhs) = delete;
     284             : 
     285             :     bool                        find_version(char const * data, int const size);
     286             : 
     287             :     void                        set_name(QString const & name) { f_name.set_name(name); }
     288             :     QString const &             get_name() const { return f_name.get_name(); }
     289             :     QString const &             get_layout() const { return f_layout.get_name(); }
     290             :     QString const &             get_version_string() const { return f_version.get_version_string(); } // this was canonicalized
     291             :     version_number_t            get_branch() const { if(f_version.get_version().empty()) return SPECIAL_VERSION_UNDEFINED; else return f_version.get_version()[0]; }
     292             :     version_numbers_vector_t const & get_version() const { return f_version.get_version(); }
     293             :     name::vector_t const &      get_browsers() const { return f_browsers; }
     294             :     QString const &             get_description() const { return f_description; }
     295             :     dependency_vector_t const & get_depends() const { return f_depends; }
     296             :     bool                        is_defined() const { return f_data != nullptr; }
     297             :     bool                        is_valid() const;
     298             :     QString const &             get_error() const { return f_error; }
     299             : 
     300             : private:
     301             :     int                         getc();
     302             :     QString                     get_line();
     303             : 
     304             :     char const *                f_data = nullptr;
     305             :     char const *                f_end = nullptr;
     306             : 
     307             :     name                        f_name = name();
     308             :     name                        f_layout = name();
     309             :     version                     f_version = version();
     310             :     name::vector_t              f_browsers = name::vector_t();
     311             :     QString                     f_error = QString();
     312             :     QString                     f_description = QString();
     313             :     dependency_vector_t         f_depends = dependency_vector_t();
     314             : };
     315             : 
     316             : 
     317             : } // namespace snap_version
     318             : } // namespace snap
     319             : // vim: ts=4 sw=4 et

Generated by: LCOV version 1.13