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

Commit a41be6ab authored by Kevin DuBois's avatar Kevin DuBois
Browse files

SF: Scheduler add strong typing helpers. 

Adds templating for creating stronger types from primitives.
Used to increase type safety by making it easier to enrich
the meaning of primitive types to express the concept of things
like tokens, units, etc.

Bug: 140301853
Test: 2 new StrongTypeTest
Change-Id: I765b166e6024ed1c888abd8083eaa1b00e370fff
parent e676761d

services/surfaceflinger/Scheduler/StrongTyping.h

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

 * Copyright 2019 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

namespace android {



template <typename T, template <typename> class AbilityType>

struct Ability {

    T& base() { return static_cast<T&>(*this); }

    T const& base() const { return static_cast<T const&>(*this); }

};



template <typename T>

struct Add : Ability<T, Add> {

    inline T operator+(T const& other) const { return T(this->base().value() + other.value()); }

    inline T& operator++() {

        ++this->base().value();

        return this->base();

    };

    inline T operator++(int) {

        T tmp(this->base());

        operator++();

        return tmp;

    };

    inline T& operator+=(T const& other) {

        this->base().value() += other.value();

        return this->base();

    };

};



template <typename T>

struct Compare : Ability<T, Compare> {

    inline bool operator==(T const& other) const { return this->base().value() == other.value(); };

    inline bool operator<(T const& other) const { return this->base().value() < other.value(); }

    inline bool operator<=(T const& other) const { return (*this < other) || (*this == other); }

    inline bool operator!=(T const& other) const { return !(*this == other); }

    inline bool operator>=(T const& other) const { return !(*this < other); }

    inline bool operator>(T const& other) const { return !(*this < other || *this == other); }

};



template <typename T, typename W, template <typename> class... Ability>

struct StrongTyping : Ability<StrongTyping<T, W, Ability...>>... {

    StrongTyping() : mValue(0) {}

    explicit StrongTyping(T const& value) : mValue(value) {}

    StrongTyping(StrongTyping const&) = default;

    StrongTyping& operator=(StrongTyping const&) = default;

    inline operator T() const { return mValue; }

    T const& value() const { return mValue; }

    T& value() { return mValue; }



private:

    T mValue;

};

} // namespace android

services/surfaceflinger/tests/unittests/Android.bp

+1 −0
Original line number Diff line number Diff line
@@ -53,6 +53,7 @@ cc_test { 
        "TimeStatsTest.cpp",

        "FrameTracerTest.cpp",

        "TransactionApplicationTest.cpp",

        "StrongTypingTest.cpp",

        "mock/DisplayHardware/MockComposer.cpp",

        "mock/DisplayHardware/MockDisplay.cpp",

        "mock/DisplayHardware/MockPowerAdvisor.cpp",

services/surfaceflinger/tests/unittests/StrongTypingTest.cpp

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

 * Copyright 2019 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.

 */



#include <gmock/gmock.h>

#include <gtest/gtest.h>

#include "Scheduler/StrongTyping.h"



using namespace testing;



namespace android {



TEST(StrongTypeTest, comparison) {

    using SpunkyType = StrongTyping<int, struct SpunkyTypeTag, Compare>;

    SpunkyType f2(22);

    SpunkyType f1(10);



    EXPECT_TRUE(f1 == f1);

    EXPECT_TRUE(SpunkyType(10) != SpunkyType(11));

    EXPECT_FALSE(SpunkyType(31) != SpunkyType(31));



    EXPECT_TRUE(SpunkyType(10) < SpunkyType(11));

    EXPECT_TRUE(SpunkyType(-1) < SpunkyType(0));

    EXPECT_FALSE(SpunkyType(-10) < SpunkyType(-20));



    EXPECT_TRUE(SpunkyType(10) <= SpunkyType(11));

    EXPECT_TRUE(SpunkyType(10) <= SpunkyType(10));

    EXPECT_TRUE(SpunkyType(-10) <= SpunkyType(1));

    EXPECT_FALSE(SpunkyType(10) <= SpunkyType(9));



    EXPECT_TRUE(SpunkyType(11) >= SpunkyType(11));

    EXPECT_TRUE(SpunkyType(12) >= SpunkyType(11));

    EXPECT_FALSE(SpunkyType(11) >= SpunkyType(12));



    EXPECT_FALSE(SpunkyType(11) > SpunkyType(12));

    EXPECT_TRUE(SpunkyType(-11) < SpunkyType(7));

}



TEST(StrongTypeTest, addition) {

    using FunkyType = StrongTyping<int, struct FunkyTypeTag, Compare, Add>;

    FunkyType f2(22);

    FunkyType f1(10);



    EXPECT_THAT(f1 + f2, Eq(FunkyType(32)));

    EXPECT_THAT(f2 + f1, Eq(FunkyType(32)));



    EXPECT_THAT(++f1, Eq(11));

    EXPECT_THAT(f1, Eq(11));

    EXPECT_THAT(f1++, Eq(11));

    EXPECT_THAT(f1++, Eq(12));

    EXPECT_THAT(f1, Eq(13));



    auto f3 = f1;

    EXPECT_THAT(f1, Eq(f3));

    EXPECT_THAT(f1, Lt(f2));



    f3 += f1;

    EXPECT_THAT(f1, Eq(13));

    EXPECT_THAT(f3, Eq(26));

}

} // namespace android