Refactor'n'Feature

CMakeLists.txt

@@ -12,6 +12,8 @@ INCLUDE_DIRECTORIES(
     ${CMAKE_CURRENT_SOURCE_DIR}
 )
 
+#ADD_DEFINITIONS(-DGW_NO_DEPRECATION)
+
 ADD_SUBDIRECTORY(libGitWrap)
 ADD_SUBDIRECTORY(testGitWrap)
 

libGitWrap/Base.cpp

@@ -17,9 +17,11 @@
  *
  */
 
-#include "Base.hpp"
+#include "libGitWrap/Base.hpp"
+#include "libGitWrap/Object.hpp"
 
-#include "Private/BasePrivate.hpp"
+#include "libGitWrap/Private/BasePrivate.hpp"
+#include "libGitWrap/Private/ObjectPrivate.hpp"
 
 namespace Git
 {
@@ -35,9 +37,65 @@ namespace Git
         {
         }
 
-        const git_oid* BasePrivate::sha(const ObjectId& id)
+        git_object* BasePrivate::objectOf(const Object& o)
         {
-            return reinterpret_cast<const git_oid*>(id.raw());
+            Object::Private* op = dataOf<Object>(o);
+
+            if (!op) {
+                return NULL;
+            }
+
+            return op->o();
+        }
+
+        /**
+         * @internal
+         * @brief           Static private validity checker
+         *
+         * This is a private validity checker. It is used from the GW_D macro. Implementing it as a
+         * private static method, allows a lot of code reduction (resulting in isValid() being in
+         * the CPU cache and thus much less cache misses on code that uses GitWrap a lot).
+         *
+         * Also, this allows us to transparently delegate to the virtual method isValidObject(),
+         * which gives the object itself an opportunitiy to tell whether it is valid or not and also
+         * set a custom result.
+         *
+         * This is esp. useful since Reference objects can become invalid (when destroy() is used)
+         * and we cannot warrant that this will be checked in all methods of Reference derivates.
+         *
+         * @param[in,out]   r   A Result that will be set to invalid if @a d is `NULL` and can be
+         *                      set to anything, if @a d is not `NULL`.
+         *
+         * @param[in]       d   The BasePrivate to check.
+         *
+         * @return          `true`, if this object can be treated as vaild.
+         *
+         */
+        bool BasePrivate::isValid(Result& r, const BasePrivate* d)
+        {
+            if (Q_LIKELY(d)) {
+                return d->isValidObject(r);
+            }
+            r.setInvalidObject();
+            return false;
+        }
+
+        /**
+         * @internal
+         * @brief           Check for validity
+         *
+         * @param[in,out]   r   A Result that can be used to tell the user about any problems with
+         *                      the object at hand.
+         *
+         * @return          `true`, if this object is valid - `false` otherwise. Note, that by
+         *                  convention, the object is invalid if the Result @a r contains an error
+         *                  on input, thus this method should `return r;` whenever it wants to
+         *                  return `true` actually.
+         *
+         */
+        bool BasePrivate::isValidObject(Result& r) const
+        {
+            return r;
         }
 
     }
@@ -46,8 +104,8 @@ namespace Git
     {
     }
 
-    Base::Base(Internal::BasePrivate &_d)
-        : mData(&_d)
+    Base::Base(const PrivatePtr& _d)
+        : mData(_d)
     {
     }
 
@@ -71,6 +129,11 @@ namespace Git
         return mData == other.mData;
     }
 
+    bool Base::operator!=(const Base& other) const
+    {
+        return mData != other.mData;
+    }
+
     bool Base::isValid() const
     {
         return mData;

libGitWrap/Base.hpp

@@ -46,12 +46,25 @@ namespace Git
         Base(const Base& other);
         virtual ~Base();
         Base& operator=(const Base& other);
-        bool isValid() const;
         bool operator==(const Base& other) const;
+        bool operator!=(const Base& other) const;
+
+    public:
+        bool isValid() const;
+
+    protected:
+        typedef QExplicitlySharedDataPointer<Internal::BasePrivate> PrivatePtr;
+        Base(const PrivatePtr& _d);
+        PrivatePtr mData;
 
     protected:
-        Base(Internal::BasePrivate& _d);
-        QExplicitlySharedDataPointer<Internal::BasePrivate> mData;
+        inline void ensureThisIsNotConst()
+        {
+            // This method is invoked from the GW_D macro. Its only purpose is to error out at
+            // compile time, if we casted from a const outer object. This is actually neccessary
+            // because QExplicitlySharedDataPointer seems to give a shit about const
+            // correctness.
+        }
     };
 
 }

libGitWrap/Blob.cpp

@@ -0,0 +1,54 @@
+/*
+ * MacGitver
+ * Copyright (C) 2012-2013 Sascha Cunz <[email protected]>
+ *
+ * This program is free software; you can redistribute it and/or modify it under the terms of the
+ * GNU General Public License (Version 2) as published by the Free Software Foundation.
+ *
+ * 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
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with this program; if
+ * not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "libGitWrap/Blob.hpp"
+
+#include "libGitWrap/Private/GitWrapPrivate.hpp"
+#include "libGitWrap/Private/BlobPrivate.hpp"
+
+namespace Git
+{
+
+    namespace Internal {
+
+        BlobPrivate::BlobPrivate(const RepositoryPrivate::Ptr& repo, git_blob* o)
+            : ObjectPrivate(repo, reinterpret_cast<git_object*>(o))
+        {
+            Q_ASSERT(o);
+        }
+
+        BlobPrivate::BlobPrivate(const RepositoryPrivate::Ptr& repo, git_object* o)
+            : ObjectPrivate(repo, o)
+        {
+            Q_ASSERT(o);
+            Q_ASSERT(git_object_type(o) == GIT_OBJ_BLOB);
+        }
+
+        git_otype BlobPrivate::otype() const
+        {
+            return GIT_OBJ_BLOB;
+        }
+
+        ObjectType BlobPrivate::objectType() const
+        {
+            return otBlob;
+        }
+
+    }
+
+    GW_PRIVATE_IMPL(Blob, Object)
+
+}

libGitWrap/ObjectBlob.cpp → libGitWrap/Blob.hpp

@@ -14,28 +14,43 @@
  *
  */
 
-#include "ObjectBlob.hpp"
+#ifndef GIT_OBJECT_BLOB_H
+#define GIT_OBJECT_BLOB_H
 
-#include "Private/GitWrapPrivate.hpp"
+#include "libGitWrap/GitWrap.hpp"
+#include "libGitWrap/ObjectId.hpp"
+#include "libGitWrap/Object.hpp"
 
 namespace Git
 {
 
-    ObjectBlob::ObjectBlob()
+    namespace Internal
     {
+
+        class BlobPrivate;
+
     }
 
-    ObjectBlob::ObjectBlob(Internal::ObjectPrivate& _d)
-        : Object(_d)
+    /**
+     * @ingroup     GitWrap
+     * @brief       Provides access to git BLOB (Binary Large Object) objects
+     *
+     */
+    class GITWRAP_API Blob : public Object
     {
-        Result r;
-        Q_UNUSED( r );
-        Q_ASSERT( type(r) == otBlob );
-    }
+    public:
+        GW_PRIVATE_DECL(Blob, Object, public);
+        enum { ObjectTypeId = otBlob };
+    };
 
-    ObjectBlob::ObjectBlob(const ObjectBlob& o)
-        : Object(o)
+    template<>
+    inline Blob Object::as() const
     {
+        return asBlob();
     }
 
 }
+
+Q_DECLARE_METATYPE(Git::Blob)
+
+#endif

libGitWrap/BranchRef.cpp

@@ -0,0 +1,55 @@
+/*
+ * MacGitver
+ * Copyright (C) 2012-2013 The MacGitver-Developers <[email protected]>
+ *
+ * (C) Sascha Cunz <[email protected]>
+ * (C) Nils Fenner <[email protected]>
+ * (C) Cunz RaD Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify it under the terms of the
+ * GNU General Public License (Version 2) as published by the Free Software Foundation.
+ *
+ * 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
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with this program; if
+ * not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "libGitWrap/BranchRef.hpp"
+#include "libGitWrap/Private/BranchRefPrivate.hpp"
+
+namespace Git
+{
+
+    namespace Internal
+    {
+
+        BranchRefPrivate::BranchRefPrivate(const RepositoryPrivate::Ptr& repo,
+                                           git_reference* reference)
+            : ReferencePrivate(repo, reference)
+        {
+            #ifdef QT_DEBUG
+            // We want this constructor to analyze only for the assert...
+            ensureAnalyzed();
+            Q_ASSERT(isBranch);
+            #endif
+        }
+
+        BranchRefPrivate::BranchRefPrivate(git_reference* reference, const RefNamePrivate* refName)
+            : ReferencePrivate(reference, refName)
+        {
+        }
+
+        ReferenceKinds BranchRefPrivate::kind() const
+        {
+            return BranchReference;
+        }
+
+    }
+
+    GW_PRIVATE_IMPL(BranchRef, Reference)
+
+}

libGitWrap/BranchRef.hpp

@@ -0,0 +1,53 @@
+/*
+ * MacGitver
+ * Copyright (C) 2012-2013 The MacGitver-Developers <[email protected]>
+ *
+ * (C) Sascha Cunz <[email protected]>
+ * (C) Nils Fenner <[email protected]>
+ * (C) Cunz RaD Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify it under the terms of the
+ * GNU General Public License (Version 2) as published by the Free Software Foundation.
+ *
+ * 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
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with this program; if
+ * not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef GITWRAP_BRANCH_REF_HPP
+#define GITWRAP_BRANCH_REF_HPP
+#pragma once
+
+#include "libGitWrap/Reference.hpp"
+
+namespace Git
+{
+
+    namespace Internal
+    {
+
+        class BranchRefPrivate;
+
+    }
+
+    class GITWRAP_API BranchRef : public Reference
+    {
+        GW_PRIVATE_DECL(BranchRef, Reference, public)
+
+    public:
+    };
+
+    template<>
+    inline BranchRef Reference::as() const {
+        return asBranch();
+    }
+
+}
+
+Q_DECLARE_METATYPE(Git::BranchRef)
+
+#endif