Cleanup: remove redundant doxygen \file argument
[blender.git] / source / blender / bmesh / intern / bmesh_operator_api_inline.h
index 16c2b8b..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;
+}
+
+ATTR_NONNULL(1, 2)
+BLI_INLINE void BMO_slot_map_int_insert(
+        BMOperator *op, BMOpSlot *slot,
+        void *element, const int val)
+{
+       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_int_insert(BMesh *bm, BMOperator *op, const char *slot_name,
-                                        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)
 {
-       BMO_slot_map_insert(bm, op, slot_name, 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(BMesh *bm, BMOperator *op, const char *slot_name,
-                                          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)
 {
-       BMO_slot_map_insert(bm, op, slot_name, 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));
 }
 
 
@@ -87,62 +110,109 @@ BLI_INLINE void BMO_slot_map_float_insert(BMesh *bm, BMOperator *op, const char
  * 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(BMesh *bm, BMOperator *op, const char *slot_name,
-                                        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)
 {
-       BMO_slot_map_insert(bm, op, slot_name, 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 int BMO_slot_map_contains(BMesh *UNUSED(bm), BMOperator *op, const char *slot_name, void *element)
+ATTR_NONNULL(1, 2)
+BLI_INLINE void BMO_slot_map_elem_insert(
+        BMOperator *op, BMOpSlot *slot,
+        const void *element, void *val)
 {
-       BMOpSlot *slot = BMO_slot_get(op, slot_name);
-       BLI_assert(slot->slot_type == BMO_OP_SLOT_MAPPING);
+       BLI_assert(slot->slot_subtype.map == BMO_OP_SLOT_SUBTYPE_MAP_ELEM);
+       BMO_slot_map_insert(op, slot, element, val);
+}
 
-       /* sanity check */
-       if (!slot->data.ghash) return 0;
 
-       return BLI_ghash_haskey(slot->data.ghash, element);
+/* no values */
+ATTR_NONNULL(1, 2)
+BLI_INLINE void BMO_slot_map_empty_insert(
+        BMOperator *op, BMOpSlot *slot,
+        const void *element)
+{
+       BLI_assert(slot->slot_subtype.map == BMO_OP_SLOT_SUBTYPE_MAP_EMPTY);
+       BMO_slot_map_insert(op, slot, element, NULL);
 }
 
-BLI_INLINE void *BMO_slot_map_data_get(BMesh *UNUSED(bm), BMOperator *op, const char *slot_name,
-                                       void *element)
+ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
+BLI_INLINE bool BMO_slot_map_contains(BMOpSlot *slot, const void *element)
 {
-       BMOElemMapping *mapping;
-       BMOpSlot *slot = BMO_slot_get(op, slot_name);
        BLI_assert(slot->slot_type == BMO_OP_SLOT_MAPPING);
+       return BLI_ghash_haskey(slot->data.ghash, element);
+}
 
-       /* sanity check */
-       if (!slot->data.ghash) return NULL;
-
-       mapping = (BMOElemMapping *)BLI_ghash_lookup(slot->data.ghash, element);
+ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
+BLI_INLINE void **BMO_slot_map_data_get(BMOpSlot *slot, const void *element)
+{
 
-       if (!mapping) return NULL;
+       return BLI_ghash_lookup_p(slot->data.ghash, element);
+}
 
-       return mapping + 1;
+ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
+BLI_INLINE float BMO_slot_map_float_get(BMOpSlot *slot, const void *element)
+{
+       void **data;
+       BLI_assert(slot->slot_subtype.map == BMO_OP_SLOT_SUBTYPE_MAP_FLT);
+
+       data = BMO_slot_map_data_get(slot, element);
+       if (data) {
+               return *(float *)data;
+       }
+       else {
+               return 0.0f;
+       }
 }
 
-BLI_INLINE float BMO_slot_map_float_get(BMesh *bm, BMOperator *op, const char *slot_name,
-                                        void *element)
+ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
+BLI_INLINE int BMO_slot_map_int_get(BMOpSlot *slot, const void *element)
 {
-       float *val = (float *) BMO_slot_map_data_get(bm, op, slot_name, element);
-       if (val) return *val;
+       void **data;
+       BLI_assert(slot->slot_subtype.map == BMO_OP_SLOT_SUBTYPE_MAP_INT);
+
+       data = BMO_slot_map_data_get(slot, element);
+       if (data) {
+               return *(int *)data;
+       }
+       else {
+               return 0;
+       }
+}
 
-       return 0.0f;
+ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
+BLI_INLINE bool BMO_slot_map_bool_get(BMOpSlot *slot, const void *element)
+{
+       void **data;
+       BLI_assert(slot->slot_subtype.map == BMO_OP_SLOT_SUBTYPE_MAP_BOOL);
+
+       data = BMO_slot_map_data_get(slot, element);
+       if (data) {
+               return *(bool *)data;
+       }
+       else {
+               return false;
+       }
 }
 
-BLI_INLINE int BMO_slot_map_int_get(BMesh *bm, BMOperator *op, const char *slot_name,
-                                    void *element)
+ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
+BLI_INLINE void *BMO_slot_map_ptr_get(BMOpSlot *slot, const void *element)
 {
-       int *val = (int *) BMO_slot_map_data_get(bm, op, slot_name, element);
+       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 0;
+       return NULL;
 }
 
-BLI_INLINE void *BMO_slot_map_ptr_get(BMesh *bm, BMOperator *op, const char *slot_name,
-                                      void *element)
+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(bm, op, slot_name, element);
+       void **val = (void **) BMO_slot_map_data_get(slot, element);
+       BLI_assert(slot->slot_subtype.map == BMO_OP_SLOT_SUBTYPE_MAP_ELEM);
        if (val) return *val;
 
        return NULL;