Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 47fa868e authored by Ady Abraham's avatar Ady Abraham Committed by Android (Google) Code Review
Browse files

Merge changes from topic "libui_hashcombine" into sc-dev 

* changes:
  libui: Add std::hash support for Rects/Region
  libmath: Add HashCombine
parents ee577e1b ce58d5b1

libs/math/Android.bp

+20 −0
Original line number Diff line number Diff line
@@ -39,6 +39,7 @@ cc_library_static { 
        "com.android.media.swcodec",

        "com.android.neuralnetworks",

    ],



    min_sdk_version: "29",



    export_include_dirs: ["include"],
@@ -49,4 +50,23 @@ cc_library_static { 
    }

}



cc_library_headers {

    name: "libmath_headers",

    export_include_dirs: ["include"],

    host_supported: true,

    vendor_available: true,



    apex_available: [

        "//apex_available:anyapex",

        "//apex_available:platform",

    ],

    min_sdk_version: "apex_inherit",



    target:  {

        windows: {

            enabled: true,

        }

    }

}



subdirs = ["tests"]

libs/math/include/math/HashCombine.h

0 → 100644
+38 −0
Original line number Diff line number Diff line 
/*

 * Copyright 2021 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#pragma once



#include <functional>



namespace android {

static inline void hashCombineSingleHashed(size_t& combinedHash, size_t hash) {

    combinedHash = 31 * combinedHash + hash;

}



template<typename T>

static inline void hashCombineSingle(size_t& combinedHash, const T& val) {

    hashCombineSingleHashed(combinedHash, std::hash<T>{}(val));

}



template<typename... Types>

static inline size_t hashCombine(const Types& ... args) {

    size_t hash = 0;

    ( hashCombineSingle(hash, args), ... );

    return hash;

}



} // namespace android
 
 No newline at end of file

libs/math/include/math/TVecHelpers.h

+26 −0
Original line number Diff line number Diff line
@@ -19,9 +19,11 @@ 


#include <math.h>

#include <stdint.h>

#include <math/HashCombine.h>

#include <sys/types.h>



#include <cmath>

#include <functional>

#include <limits>

#include <iostream>
@@ -250,6 +252,17 @@ public: 
        }

        return r;

    }



    // This isn't strictly a unary operator, but it is a common place shared between both

    // matrix and vector classes

    size_t hash() const {

        VECTOR<T> const& rv(static_cast<VECTOR<T> const&>(*this));

        size_t hashed = 0;

        for (size_t i = 0; i < rv.size(); i++) {

            android::hashCombineSingle(hashed, rv[i]);

        }

        return hashed;

    }

};



/*
@@ -606,3 +619,16 @@ public: 
// -------------------------------------------------------------------------------------

}  // namespace details

}  // namespace android



namespace std {

    template<template<typename T> class VECTOR, typename T>

    struct hash<VECTOR<T>> {

        static constexpr bool IS_VECTOR =

            std::is_base_of<android::details::TVecUnaryOperators<VECTOR, T>, VECTOR<T>>::value;



        typename std::enable_if<IS_VECTOR, size_t>::type

        operator()(const VECTOR<T>& v) const {

            return v.hash();

        }

    };

}

libs/math/include/math/half.h

+7 −0
Original line number Diff line number Diff line
@@ -17,6 +17,7 @@ 
#pragma once



#include <stdint.h>

#include <functional>

#include <iosfwd>

#include <limits>

#include <type_traits>
@@ -202,6 +203,12 @@ public: 
    inline static constexpr type signaling_NaN() noexcept { return android::half(android::half::binary, 0x7dff); }

};



template<> struct hash<android::half> {

    size_t operator()(const android::half& half) {

        return std::hash<float>{}(half);

    }

};



} // namespace std



#ifdef LIKELY_DEFINED_LOCAL

libs/math/tests/Android.bp

+7 −0
Original line number Diff line number Diff line
@@ -50,3 +50,10 @@ cc_test { 
    static_libs: ["libmath"],

    cflags: ["-Wall", "-Werror"],

}



cc_test {

    name: "hashcombine_test",

    srcs: ["hashcombine_test.cpp"],

    static_libs: ["libmath"],

    cflags: ["-Wall", "-Werror"],

}