Cleanup: remove redundant doxygen \file argument
[blender.git] / source / blender / bmesh / intern / bmesh_operator_api_inline.h
index acbc765..ae6c525 100644 (file)
@@ -1,6 +1,4 @@
 /*
- * ***** BEGIN GPL LICENSE BLOCK *****
- *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * Contributor(s): Joseph Eagar, Geoffrey Bantle, Campbell Barton
- *
- * ***** END GPL LICENSE BLOCK *****
  */
 
-/** \file blender/bmesh/intern/bmesh_operator_api_inline.h
- *  \ingroup bmesh
+/** \file \ingroup bmesh
  *
  * BMesh inline operator functions.
  */
  * ghash or a mapping slot to do it. */
 
 /* flags 15 and 16 (1 << 14 and 1 << 15) are reserved for bmesh api use */
-BLI_INLINE short _bmo_elem_flag_test(BMesh *bm, BMFlagLayer *oflags, const short oflag)
+ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1, 2)
+BLI_INLINE short _bmo_elem_flag_test(BMesh *bm, const BMFlagLayer *oflags, const short oflag)
 {
-       return oflags[bm->stackdepth - 1].f & oflag;
+       BLI_assert(bm->use_toolflags);
+       return oflags[bm->toolflag_index].f & oflag;
 }
 
-BLI_INLINE short _bmo_elem_flag_test_bool(BMesh *bm, BMFlagLayer *oflags, const short oflag)
+ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1, 2)
+BLI_INLINE bool _bmo_elem_flag_test_bool(BMesh *bm, const BMFlagLayer *oflags, const short oflag)
 {
-       return (oflags[bm->stackdepth - 1].f & oflag) != 0;
+       BLI_assert(bm->use_toolflags);
+       return (oflags[bm->toolflag_index].f & oflag) != 0;
 }
 
+ATTR_NONNULL(1, 2)
 BLI_INLINE void _bmo_elem_flag_enable(BMesh *bm, BMFlagLayer *oflags, const short oflag)
 {
-       oflags[bm->stackdepth - 1].f |= oflag;
+       BLI_assert(bm->use_toolflags);
+       oflags[bm->toolflag_index].f |= oflag;
 }
 
+ATTR_NONNULL(1, 2)
 BLI_INLINE void _bmo_elem_flag_disable(BMesh *bm, BMFlagLayer *oflags, const short oflag)
 {
-       oflags[bm->stackdepth - 1].f &= ~oflag;
+       BLI_assert(bm->use_toolflags);
+       oflags[bm->toolflag_index].f &= (short)~oflag;
 }
 
+ATTR_NONNULL(1, 2)
 BLI_INLINE void _bmo_elem_flag_set(BMesh *bm, BMFlagLayer *oflags, const short oflag, int val)
 {
-       if (val) oflags[bm->stackdepth - 1].f |= oflag;
-       else     oflags[bm->stackdepth - 1].f &= ~oflag;
+       BLI_assert(bm->use_toolflags);
+       if (val) oflags[bm->toolflag_index].f |= oflag;
+       else     oflags[bm->toolflag_index].f &= (short)~oflag;
 }
 
+ATTR_NONNULL(1, 2)
 BLI_INLINE void _bmo_elem_flag_toggle(BMesh *bm, BMFlagLayer *oflags, const short oflag)
 {
-       oflags[bm->stackdepth - 1].f ^= oflag;
+       BLI_assert(bm->use_toolflags);
+       oflags[bm->toolflag_index].f ^= oflag;
 }
 
-BLI_INLINE void BMO_slot_map_int_insert(BMOperator *op, BMOpSlot *slot,
-                                        void *element, int val)
+ATTR_NONNULL(1, 2)
+BLI_INLINE void BMO_slot_map_int_insert(
+        BMOperator *op, BMOpSlot *slot,
+        void *element, const int val)
 {
-       BLI_assert(slot->slot_subtype == BMO_OP_SLOT_SUBTYPE_MAP_INT);
-       BMO_slot_map_insert(op, slot, element, &val, sizeof(int));
+       union { void *ptr; int val; } t = {NULL};
+       BLI_assert(slot->slot_subtype.map == BMO_OP_SLOT_SUBTYPE_MAP_INT);
+       BMO_slot_map_insert(op, slot, element, ((void)(t.val = val), t.ptr));
 }
 
-BLI_INLINE void BMO_slot_map_bool_insert(BMOperator *op, BMOpSlot *slot,
-                                        void *element, int val)
+ATTR_NONNULL(1, 2)
+BLI_INLINE void BMO_slot_map_bool_insert(
+        BMOperator *op, BMOpSlot *slot,
+        void *element, const bool val)
 {
-       BLI_assert(slot->slot_subtype == BMO_OP_SLOT_SUBTYPE_MAP_BOOL);
-       BLI_assert(val == FALSE || val == TRUE);
-       BMO_slot_map_insert(op, slot, element, &val, sizeof(int));
+       union { void *ptr; bool val; } t = {NULL};
+       BLI_assert(slot->slot_subtype.map == BMO_OP_SLOT_SUBTYPE_MAP_BOOL);
+       BMO_slot_map_insert(op, slot, element, ((void)(t.val = val), t.ptr));
 }
 
-BLI_INLINE void BMO_slot_map_float_insert(BMOperator *op, BMOpSlot *slot,
-                                          void *element, float val)
+ATTR_NONNULL(1, 2)
+BLI_INLINE void BMO_slot_map_float_insert(
+        BMOperator *op, BMOpSlot *slot,
+        void *element, const float val)
 {
-       BLI_assert(slot->slot_subtype == BMO_OP_SLOT_SUBTYPE_MAP_FLOAT);
-       BMO_slot_map_insert(op, slot, element, &val, sizeof(float));
+       union { void *ptr; float val; } t = {NULL};
+       BLI_assert(slot->slot_subtype.map == BMO_OP_SLOT_SUBTYPE_MAP_FLT);
+       BMO_slot_map_insert(op, slot, element, ((void)(t.val = val), t.ptr));
 }
 
 
@@ -97,107 +110,109 @@ BLI_INLINE void BMO_slot_map_float_insert(BMOperator *op, BMOpSlot *slot,
  * do NOT use these for non-operator-api-allocated memory! instead
  * use BMO_slot_map_data_get and BMO_slot_map_insert, which copies the data. */
 
-BLI_INLINE void BMO_slot_map_ptr_insert(BMOperator *op, BMOpSlot *slot,
-                                        const void *element, void *val)
+ATTR_NONNULL(1, 2)
+BLI_INLINE void BMO_slot_map_ptr_insert(
+        BMOperator *op, BMOpSlot *slot,
+        const void *element, void *val)
 {
-       BLI_assert(slot->slot_subtype == BMO_OP_SLOT_SUBTYPE_MAP_INTERNAL);
-       BMO_slot_map_insert(op, slot, element, &val, sizeof(void *));
+       BLI_assert(slot->slot_subtype.map == BMO_OP_SLOT_SUBTYPE_MAP_INTERNAL);
+       BMO_slot_map_insert(op, slot, element, val);
 }
 
-BLI_INLINE void BMO_slot_map_elem_insert(BMOperator *op, BMOpSlot *slot,
-                                        const void *element, void *val)
+ATTR_NONNULL(1, 2)
+BLI_INLINE void BMO_slot_map_elem_insert(
+        BMOperator *op, BMOpSlot *slot,
+        const void *element, void *val)
 {
-       BLI_assert(slot->slot_subtype == BMO_OP_SLOT_SUBTYPE_MAP_ELEM);
-       BMO_slot_map_insert(op, slot, element, &val, sizeof(void *));
+       BLI_assert(slot->slot_subtype.map == BMO_OP_SLOT_SUBTYPE_MAP_ELEM);
+       BMO_slot_map_insert(op, slot, element, val);
 }
 
 
 /* no values */
-BLI_INLINE void BMO_slot_map_empty_insert(BMOperator *op, BMOpSlot *slot,
-                                        const void *element)
+ATTR_NONNULL(1, 2)
+BLI_INLINE void BMO_slot_map_empty_insert(
+        BMOperator *op, BMOpSlot *slot,
+        const void *element)
 {
-       BLI_assert(slot->slot_subtype == BMO_OP_SLOT_SUBTYPE_MAP_EMPTY);
-       BMO_slot_map_insert(op, slot, element, NULL, 0);
+       BLI_assert(slot->slot_subtype.map == BMO_OP_SLOT_SUBTYPE_MAP_EMPTY);
+       BMO_slot_map_insert(op, slot, element, NULL);
 }
 
-BLI_INLINE int BMO_slot_map_contains(BMOpSlot *slot, const void *element)
+ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
+BLI_INLINE bool BMO_slot_map_contains(BMOpSlot *slot, const void *element)
 {
        BLI_assert(slot->slot_type == BMO_OP_SLOT_MAPPING);
-
-       /* sanity check */
-       if (UNLIKELY(slot->data.ghash == NULL)) {
-               return 0;
-       }
-
        return BLI_ghash_haskey(slot->data.ghash, element);
 }
 
-BLI_INLINE void *BMO_slot_map_data_get(BMOpSlot *slot, const void *element)
+ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
+BLI_INLINE void **BMO_slot_map_data_get(BMOpSlot *slot, const void *element)
 {
-       BMOElemMapping *mapping;
-       BLI_assert(slot->slot_type == BMO_OP_SLOT_MAPPING);
-
-       /* sanity check */
-       if (UNLIKELY(slot->data.ghash == NULL)) {
-               return NULL;
-       }
-
-       mapping = (BMOElemMapping *)BLI_ghash_lookup(slot->data.ghash, element);
 
-       if (!mapping) {
-               return NULL;
-       }
-
-       return mapping + 1;
+       return BLI_ghash_lookup_p(slot->data.ghash, element);
 }
 
+ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
 BLI_INLINE float BMO_slot_map_float_get(BMOpSlot *slot, const void *element)
 {
-       float *val;
-       BLI_assert(slot->slot_subtype == BMO_OP_SLOT_SUBTYPE_MAP_FLOAT);
+       void **data;
+       BLI_assert(slot->slot_subtype.map == BMO_OP_SLOT_SUBTYPE_MAP_FLT);
 
-       val = (float *) BMO_slot_map_data_get(slot, element);
-       if (val) return *val;
-
-       return 0.0f;
+       data = BMO_slot_map_data_get(slot, element);
+       if (data) {
+               return *(float *)data;
+       }
+       else {
+               return 0.0f;
+       }
 }
 
+ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
 BLI_INLINE int BMO_slot_map_int_get(BMOpSlot *slot, const void *element)
 {
-       int *val;
-       BLI_assert(slot->slot_subtype == BMO_OP_SLOT_SUBTYPE_MAP_INT);
+       void **data;
+       BLI_assert(slot->slot_subtype.map == BMO_OP_SLOT_SUBTYPE_MAP_INT);
 
-       val = (int *) BMO_slot_map_data_get(slot, element);
-       if (val) return *val;
-
-       return 0;
+       data = BMO_slot_map_data_get(slot, element);
+       if (data) {
+               return *(int *)data;
+       }
+       else {
+               return 0;
+       }
 }
 
-BLI_INLINE int BMO_slot_map_bool_get(BMOpSlot *slot, const void *element)
+ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
+BLI_INLINE bool BMO_slot_map_bool_get(BMOpSlot *slot, const void *element)
 {
-       int *val;
-       BLI_assert(slot->slot_subtype == BMO_OP_SLOT_SUBTYPE_MAP_BOOL);
-
-       val = (int *) BMO_slot_map_data_get(slot, element);
-       BLI_assert(val == NULL || *val == FALSE || *val == TRUE);
-       if (val) return *val;
+       void **data;
+       BLI_assert(slot->slot_subtype.map == BMO_OP_SLOT_SUBTYPE_MAP_BOOL);
 
-       return 0;
+       data = BMO_slot_map_data_get(slot, element);
+       if (data) {
+               return *(bool *)data;
+       }
+       else {
+               return false;
+       }
 }
 
+ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
 BLI_INLINE void *BMO_slot_map_ptr_get(BMOpSlot *slot, const void *element)
 {
-       void **val = (void **) BMO_slot_map_data_get(slot, element);
-       BLI_assert(slot->slot_subtype == BMO_OP_SLOT_SUBTYPE_MAP_INTERNAL);
+       void **val = BMO_slot_map_data_get(slot, element);
+       BLI_assert(slot->slot_subtype.map == BMO_OP_SLOT_SUBTYPE_MAP_INTERNAL);
        if (val) return *val;
 
        return NULL;
 }
 
+ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
 BLI_INLINE void *BMO_slot_map_elem_get(BMOpSlot *slot, const void *element)
 {
        void **val = (void **) BMO_slot_map_data_get(slot, element);
-       BLI_assert(slot->slot_subtype == BMO_OP_SLOT_SUBTYPE_MAP_ELEM);
+       BLI_assert(slot->slot_subtype.map == BMO_OP_SLOT_SUBTYPE_MAP_ELEM);
        if (val) return *val;
 
        return NULL;