auto | A collection of source code generators for Java | Generator Utils library

by google Java Version: auto-value-1.9 License: Apache-2.0

Download this library from

kandi X-RAY | auto Summary

auto is a Java library typically used in Generator, Generator Utils applications. auto has no bugs, it has no vulnerabilities, it has a Permissive License and it has high support. However auto build file is not available. You can download it from GitHub, Maven.

A collection of source code generators for Java.

Support

Quality

Security

License

Reuse

kandi-support Support

auto has a highly active ecosystem.
It has 9703 star(s) with 1152 fork(s). There are 351 watchers for this library.
There were 1 major release(s) in the last 12 months.
There are 63 open issues and 380 have been closed. On average issues are closed in 267 days. There are 14 open pull requests and 0 closed requests.
It has a negative sentiment in the developer community.
The latest version of auto is auto-value-1.9

auto Support

Best in #Generator Utils

Average in #Generator Utils

auto Support

Best in #Generator Utils

Average in #Generator Utils

quality kandi Quality

auto has 0 bugs and 0 code smells.

auto Quality

Best in #Generator Utils

Average in #Generator Utils

auto Quality

Best in #Generator Utils

Average in #Generator Utils

security Security

auto has no vulnerabilities reported, and its dependent libraries have no vulnerabilities reported.
auto code analysis shows 0 unresolved vulnerabilities.
There are 0 security hotspots that need review.

auto Security

Best in #Generator Utils

Average in #Generator Utils

auto Security

Best in #Generator Utils

Average in #Generator Utils

license License

auto is licensed under the Apache-2.0 License. This license is Permissive.
Permissive licenses have the least restrictions, and you can use them in most projects.

auto License

Best in #Generator Utils

Average in #Generator Utils

auto License

Best in #Generator Utils

Average in #Generator Utils

build Reuse

auto releases are available to install and integrate.
Deployable package is available in Maven.
auto has no build file. You will be need to create the build yourself to build the component from source.
Installation instructions are not available. Examples and code snippets are available.
auto saves you 15783 person hours of effort in developing the same functionality from scratch.
It has 38413 lines of code, 3716 functions and 311 files.
It has low code complexity. Code complexity directly impacts maintainability of the code.

auto Reuse

Best in #Generator Utils

Average in #Generator Utils

auto Reuse

Best in #Generator Utils

Average in #Generator Utils

Top functions reviewed by kandi - BETA

kandi has reviewed auto and discovered the below as its top functions. This is intended to give you an instant insight into auto implemented functionality, and help decide if they suit your requirements.

Make a property builder for a property .

Process all methods in the round environment .

Fixes the given string .

Classify one argument .

Generate a set of factory method descriptor .

Creates a new constructor for the given class .

Returns a map of property names to an enum constant map .

Add factory methods .

Collects the methods consumed by the extensions .

Determine the set of valid elements .

Get all kandi verified functions for this library.

auto Key Features

A collection of source code generators for Java.

auto Examples and Code Snippets

See all related Code Snippets

License

Copy

Download

Copyright 2013 Google LLC

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.

Is if(A | B) always faster than if(A || B)?

Copy

Download

if (b1[i])  // maybe this exists somewhere in the program
    b2 = nullptr;

if(b1[i] || b2[i]) // OK
if(b1[i]  | b2[i]) // NOT OK; indirection through null pointer

if(a || (a = b)) // OK
if(a  | (a = b)) // NOT OK; undefined behaviour

if(ptr1 || ptr2) // OK
if(ptr1  | ptr2) // NOT OK; no bitwise or for pointers

if (b1[i])  // maybe this exists somewhere in the program
    b2 = nullptr;

if(b1[i] || b2[i]) // OK
if(b1[i]  | b2[i]) // NOT OK; indirection through null pointer

if(a || (a = b)) // OK
if(a  | (a = b)) // NOT OK; undefined behaviour

if(ptr1 || ptr2) // OK
if(ptr1  | ptr2) // NOT OK; no bitwise or for pointers

if (b1[i])  // maybe this exists somewhere in the program
    b2 = nullptr;

if(b1[i] || b2[i]) // OK
if(b1[i]  | b2[i]) // NOT OK; indirection through null pointer

if(a || (a = b)) // OK
if(a  | (a = b)) // NOT OK; undefined behaviour

if(ptr1 || ptr2) // OK
if(ptr1  | ptr2) // NOT OK; no bitwise or for pointers

if (p == NULL || test(*p)) { ... }  // null pointer would crash on *p

if (should_skip() || try_update()) { ... }  // active use of side effects

x = y+z;
flag1 = (x==0);
... code that uses flag1

x = y+z;
if (processor's Z flag was set)
{
... copy of that uses flag1, but where flag is replaced with constant 1
}
else
{
... copy of that uses flag1, but where flag is replaced with constant 0
}

x = y+z;
flag1 = (x==0);
... code that uses flag1

x = y+z;
if (processor's Z flag was set)
{
... copy of that uses flag1, but where flag is replaced with constant 1
}
else
{
... copy of that uses flag1, but where flag is replaced with constant 0
}

What is the proper evaluation order when assigning a value in a map?

Copy

Download

auto size = valMap.size();
valMap[val] = size;

valMap.emplace(val, size);

auto size = valMap.size();
valMap[val] = size;

valMap.emplace(val, size);

Why does the thread sanitizer complain about acquire/release thread fences?

Copy

Download

atomic_base.h:133:26: warning: 'atomic_thread_fence' is not supported with '-fsanitize=thread' [-Wtsan]
  133 |   { __atomic_thread_fence(int(__m)); }
      |     ~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~

while (a.load(std::memory_order_relaxed) != from) {}
__tsan_acquire(&a); // <--
std::atomic_thread_fence(std::memory_order_acquire);

atomic_base.h:133:26: warning: 'atomic_thread_fence' is not supported with '-fsanitize=thread' [-Wtsan]
  133 |   { __atomic_thread_fence(int(__m)); }
      |     ~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~

while (a.load(std::memory_order_relaxed) != from) {}
__tsan_acquire(&a); // <--
std::atomic_thread_fence(std::memory_order_acquire);

Why would one want to put a unary plus (+) operator in front of a C++ lambda?

Copy

Download

#include <type_traits>

void foo(int);

template<class T>
struct is_foo : std::is_same<T, decltype(&foo)> {};

int main()
{
    auto foo1 = +[](int)->void {};
    auto foo2 = [](int)->void {};
    static_assert(is_foo<decltype(foo1)>::value, "foo1 is not like foo");
    static_assert(is_foo<decltype(+foo2)>::value, "+foo2 is not like foo");
    static_assert(is_foo<decltype(foo2)>::value, "foo2 is not like foo"); 
}

template <typename F>
void f(F func) { func(); }


int main()
{
    f([](){});  // f<lambda_1>
    f([](){});  // f<lambda_2>
    f(+[](){}); // f<void(*)()>
    f(+[](){}); // f<void(*)()>
}

xcrun: error: SDK "iphoneos" cannot be located

Copy

Download

sudo xcode-select --switch /Applications/Xcode.app

Why can't a const mutable lambda with an auto& parameter be invoked?

Copy

Download

struct foo {
    void operator()(){}
};

int main() {
    const foo f;
    f();
}

<source>:7:5: error: no matching function for call to object of type 'const foo'
    f();
    ^
<source>:2:10: note: candidate function not viable: 'this' argument has type 'const foo', but method is not marked const
    void operator()(){}
         ^

struct foo {
    void operator()(){}
};

int main() {
    const foo f;
    f();
}

<source>:7:5: error: no matching function for call to object of type 'const foo'
    f();
    ^
<source>:2:10: note: candidate function not viable: 'this' argument has type 'const foo', but method is not marked const
    void operator()(){}
         ^

auto const f3 = [](auto&) mutable {};
static_assert(std::is_invocable_v<decltype(f3), int&>); // failed

auto const f4 = [](int&) mutable {}; // changed auto& to int&
static_assert(std::is_invocable_v<decltype(f4), int&>); // now ok

struct __unique_f4 {
    auto operator()(int&) /* not const */ { }
};

struct __unique_f4 {
    auto operator()(int&) /* not const */ { }

    // conversion function to the appropriate function
    // pointer type
    operator void(*)(int&)() const { /* ... */ }
};

auto const f3 = [](auto&) mutable {};
static_assert(std::is_invocable_v<decltype(f3), int&>); // failed

auto const f4 = [](int&) mutable {}; // changed auto& to int&
static_assert(std::is_invocable_v<decltype(f4), int&>); // now ok

struct __unique_f4 {
    auto operator()(int&) /* not const */ { }
};

struct __unique_f4 {
    auto operator()(int&) /* not const */ { }

    // conversion function to the appropriate function
    // pointer type
    operator void(*)(int&)() const { /* ... */ }
};

auto const f3 = [](auto&) mutable {};
static_assert(std::is_invocable_v<decltype(f3), int&>); // failed

auto const f4 = [](int&) mutable {}; // changed auto& to int&
static_assert(std::is_invocable_v<decltype(f4), int&>); // now ok

struct __unique_f4 {
    auto operator()(int&) /* not const */ { }
};

struct __unique_f4 {
    auto operator()(int&) /* not const */ { }

    // conversion function to the appropriate function
    // pointer type
    operator void(*)(int&)() const { /* ... */ }
};

auto const f3 = [](auto&) mutable {};
static_assert(std::is_invocable_v<decltype(f3), int&>); // failed

auto const f4 = [](int&) mutable {}; // changed auto& to int&
static_assert(std::is_invocable_v<decltype(f4), int&>); // now ok

struct __unique_f4 {
    auto operator()(int&) /* not const */ { }
};

struct __unique_f4 {
    auto operator()(int&) /* not const */ { }

    // conversion function to the appropriate function
    // pointer type
    operator void(*)(int&)() const { /* ... */ }
};

Passing a C-style array to `span<T>`

Copy

Download

template<typename T>
size_t my_size(std::span<T> s)
{
    return s.size();
}

prog.cc:18:25: error: no matching function for call to 'my_size(std::array<int, 5>&)'
   18 |     std::cout << my_size(arr) << my_size(vec) << my_size(il) << my_size(c_arr);
      |                  ~~~~~~~^~~~~
prog.cc:7:8: note: candidate: 'template<class T> size_t my_size(std::span<_Type, 18446744073709551615>)'
    7 | size_t my_size(std::span<T> s)
      |        ^~~~~~~
prog.cc:7:8: note:   template argument deduction/substitution failed:
prog.cc:18:25: note:   'std::array<int, 5>' is not derived from 'std::span<_Type, 18446744073709551615>'
   18 |     std::cout << my_size(arr) << my_size(vec) << my_size(il) << my_size(c_arr);
      |                  ~~~~~~~^~~~~

template<typename T>
size_t my_size(std::span<T> s)
{
    return s.size();
}

prog.cc:18:25: error: no matching function for call to 'my_size(std::array<int, 5>&)'
   18 |     std::cout << my_size(arr) << my_size(vec) << my_size(il) << my_size(c_arr);
      |                  ~~~~~~~^~~~~
prog.cc:7:8: note: candidate: 'template<class T> size_t my_size(std::span<_Type, 18446744073709551615>)'
    7 | size_t my_size(std::span<T> s)
      |        ^~~~~~~
prog.cc:7:8: note:   template argument deduction/substitution failed:
prog.cc:18:25: note:   'std::array<int, 5>' is not derived from 'std::span<_Type, 18446744073709551615>'
   18 |     std::cout << my_size(arr) << my_size(vec) << my_size(il) << my_size(c_arr);
      |                  ~~~~~~~^~~~~

std::cout << getSize(std::span(arr));
std::cout << getSize(std::span(vec.begin(), vec.end()));
std::cout << getSize(std::span(il.begin(), il.end()));
std::cout << getSize(std::span(c_arr));

// For std containers
template<class T>
size_t getSize(T myContainer)
{
    return std::span(myContainer.begin(), myContainer.end()).size();
}

// For c-style arrays
template<typename T, int n>
size_t getSize(T (&myArray)[n])
{
    return std::span<T>(myArray).size();
}

std::cout << getSize(std::span(arr));
std::cout << getSize(std::span(vec.begin(), vec.end()));
std::cout << getSize(std::span(il.begin(), il.end()));
std::cout << getSize(std::span(c_arr));

// For std containers
template<class T>
size_t getSize(T myContainer)
{
    return std::span(myContainer.begin(), myContainer.end()).size();
}

// For c-style arrays
template<typename T, int n>
size_t getSize(T (&myArray)[n])
{
    return std::span<T>(myArray).size();
}

Doesn't constraining the "auto" in C++ defeat the purpose of it?

Copy

Download

foo f = // ...

foo auto f = // ...

foo f = // ...

foo auto f = // ...

auto fn(auto x) {
    return x++;
}

f(std::string("hello"));

error: cannot increment value of type 'std::basic_string<char>'
    return x++;

auto fn(std::integral auto x) {
    return x++;
}

auto fn(auto x) {
    return x++;
}

f(std::string("hello"));

error: cannot increment value of type 'std::basic_string<char>'
    return x++;

auto fn(std::integral auto x) {
    return x++;
}

auto fn(auto x) {
    return x++;
}

f(std::string("hello"));

error: cannot increment value of type 'std::basic_string<char>'
    return x++;

auto fn(std::integral auto x) {
    return x++;
}

auto fn(auto x) {
    return x++;
}

f(std::string("hello"));

error: cannot increment value of type 'std::basic_string<char>'
    return x++;

auto fn(std::integral auto x) {
    return x++;
}

What is the purpose of `operator auto() = delete` in C++?

Copy

Download

auto f() = delete;

A a = b;   // error in Clang

auto f() = delete;  // never expose a valid overload for f()

// elsewhere:
int f() { return 42; }
  // error: functions that differ only in 
  //        their return type cannot be overloaded

struct NoUserDefinedConversionFunctionsAllowed {
    operator auto() = delete;
};

struct S : NoUserDefinedConversionFunctionsAllowed { 
    operator int() { return 1; }  // can never be used
};

auto f() = delete;

A a = b;   // error in Clang

auto f() = delete;  // never expose a valid overload for f()

// elsewhere:
int f() { return 42; }
  // error: functions that differ only in 
  //        their return type cannot be overloaded

struct NoUserDefinedConversionFunctionsAllowed {
    operator auto() = delete;
};

struct S : NoUserDefinedConversionFunctionsAllowed { 
    operator int() { return 1; }  // can never be used
};

auto f() = delete;

A a = b;   // error in Clang

auto f() = delete;  // never expose a valid overload for f()

// elsewhere:
int f() { return 42; }
  // error: functions that differ only in 
  //        their return type cannot be overloaded

struct NoUserDefinedConversionFunctionsAllowed {
    operator auto() = delete;
};

struct S : NoUserDefinedConversionFunctionsAllowed { 
    operator int() { return 1; }  // can never be used
};

auto f() = delete;

A a = b;   // error in Clang

auto f() = delete;  // never expose a valid overload for f()

// elsewhere:
int f() { return 42; }
  // error: functions that differ only in 
  //        their return type cannot be overloaded

struct NoUserDefinedConversionFunctionsAllowed {
    operator auto() = delete;
};

struct S : NoUserDefinedConversionFunctionsAllowed { 
    operator int() { return 1; }  // can never be used
};

Why does std::initializer_list in ctor not behave as expected?

Copy

Download

auto vTemp = std::vector<int>{};
auto v = std::vector<int>( vTemp );

auto v = std::vector{{std::vector<int>{}}};
auto v = std::vector<std::vector<int>>{ std::vector<int>{} };

auto vTemp = std::vector<int>{};
auto v = std::vector<int>( vTemp );

auto v = std::vector{{std::vector<int>{}}};
auto v = std::vector<std::vector<int>>{ std::vector<int>{} };

template<class T> void f(T x) {
  std::vector v{x};
  // …
}

See all related Code Snippets

Community Discussions

Trending Discussions on auto

How to open emulators in different windows at Android Studio (Bumblebee | 2021.1.1)?
Is if(A | B) always faster than if(A || B)?
What is the proper evaluation order when assigning a value in a map?
Why does the thread sanitizer complain about acquire/release thread fences?
Why would one want to put a unary plus (+) operator in front of a C++ lambda?
xcrun: error: SDK "iphoneos" cannot be located
Why can't a const mutable lambda with an auto& parameter be invoked?
Passing a C-style array to `span<T>`
Doesn't constraining the "auto" in C++ defeat the purpose of it?
sklearn.manifold.TSNE TypeError: ufunc 'multiply' did not contain a loop with signature matching types (dtype('<U32'), dtype('<U32'))...)

Trending Discussions on auto

QUESTION

How to open emulators in different windows at Android Studio (Bumblebee | 2021.1.1)?

Asked 2022-Feb-22 at 19:06

I have two running emulators but they open together in different tabs and in one single window.

How to open them in two different window?

Android Studio Bumblebee | 2021.1.1
Build #AI-211.7628.21.2111.8092744, built on January 19, 2022
Runtime version: 11.0.11+0-b60-7590822 amd64
VM: OpenJDK 64-Bit Server VM by JetBrains s.r.o.
Linux 5.4.0-96-generic
GC: G1 Young Generation, G1 Old Generation
Memory: 3072M
Cores: 12
Registry: external.system.auto.import.disabled=true, debugger.watches.in.variables=false
Non-Bundled Plugins: JUnit4-Parallel-Runner (1.5), com.intellij.javafx (1.0.3), com.intellij.marketplace (211.7628.36), com.atlassian.bitbucket.references (2021.1.195), com.thoughtworks.gauge (211.6693.111), org.jetbrains.kotlin (211-1.6.10-release-923-AS7442.40), com.developerphil.adbidea (1.6.4)
Current Desktop: ubuntu:GNOME

ANSWER

Answered 2022-Feb-17 at 10:47

File->Settings->Tools->Emulator, and uncheck Launch in a tool window Then they will open in their own stand alone windows again.

Source https://stackoverflow.com/questions/70923189

QUESTION

Is if(A | B) always faster than if(A || B)?

Asked 2022-Feb-11 at 05:03

I am reading this book by Fedor Pikus and he has some very very interesting examples which for me were a surprise.
Particularly this benchmark caught me, where the only difference is that in one of them we use || in if and in another we use |.

void BM_misspredict(benchmark::State& state)
{

    std::srand(1);
    const unsigned int N = 10000;;
    std::vector<unsigned long> v1(N), v2(N);
    std::vector<int> c1(N), c2(N);

    for (int i = 0; i < N; ++i) 
    {
        v1[i] = rand();
        v2[i] = rand();
        c1[i] = rand() & 0x1;
        c2[i] = !c1[i];
    }

    unsigned long* p1 = v1.data();
    unsigned long* p2 = v2.data();
    int* b1 = c1.data();
    int* b2 = c2.data();

    for (auto _ : state)
    {
        unsigned long a1 = 0, a2 = 0;
        for (size_t i = 0; i < N; ++i) 
        {
            if (b1[i] || b2[i])  // Only difference
            {
                a1 += p1[i];
            }
            else 
            {
                a2 *= p2[i];
            }
        }
        benchmark::DoNotOptimize(a1);
        benchmark::DoNotOptimize(a2);
        benchmark::ClobberMemory();

    }
    state.SetItemsProcessed(state.iterations());
}

void BM_predict(benchmark::State& state)
{

    std::srand(1);
    const unsigned int N = 10000;;
    std::vector<unsigned long> v1(N), v2(N);
    std::vector<int> c1(N), c2(N);

    for (int i = 0; i < N; ++i)
    {
        v1[i] = rand();
        v2[i] = rand();
        c1[i] = rand() & 0x1;
        c2[i] = !c1[i];
    }

    unsigned long* p1 = v1.data();
    unsigned long* p2 = v2.data();
    int* b1 = c1.data();
    int* b2 = c2.data();

    for (auto _ : state)
    {
        unsigned long a1 = 0, a2 = 0;
        for (size_t i = 0; i < N; ++i)
        {
            if (b1[i] | b2[i]) // Only difference
            {
                a1 += p1[i];
            }
            else
            {
                a2 *= p2[i];
            }
        }
        benchmark::DoNotOptimize(a1);
        benchmark::DoNotOptimize(a2);
        benchmark::ClobberMemory();

    }
    state.SetItemsProcessed(state.iterations());
}

I will not go in all the details explained in the book why the latter is faster, but the idea is that hardware branch predictor is given 2 chances to misspredict in slower version and in the | (bitwise or) version. See the benchmark results below.

So the question is why don't we always use | instead of || in branches?

ANSWER

Answered 2022-Feb-08 at 19:57

Code readability, short-circuiting and it is not guaranteed that Ord will always outperform a || operand. Computer systems are more complicated than expected, even though they are man-made.

There was a case where a for loop with a much more complicated condition ran faster on an IBM. The CPU didn't cool and thus instructions were executed faster, that was a possible reason. What I am trying to say, focus on other areas to improve code than fighting small-cases which will differ depending on the CPU and the boolean evaluation (compiler optimizations).

Source https://stackoverflow.com/questions/71039947

QUESTION

What is the proper evaluation order when assigning a value in a map?

Asked 2022-Feb-02 at 09:25

I know that compiler is usually the last thing to blame for bugs in a code, but I do not see any other explanation for the following behaviour of the following C++ code (distilled down from an actual project):

#include <iostream>
#include <map>

int main()
{
    auto values = { 1, 3, 5 };
    std::map<int, int> valMap;

    for (auto const & val : values) {
        std::cout << "before assignment: valMap.size() = " << valMap.size();
        valMap[val] = valMap.size();
        std::cout << " -> set valMap[" << val << "] to " << valMap[val] << "\n";
    }
}

The expected output of this code is:

before assignment: valMap.size() = 0 -> set valMap[1] to 0
before assignment: valMap.size() = 1 -> set valMap[3] to 1
before assignment: valMap.size() = 2 -> set valMap[5] to 2

However, when I build a Release version with the (default) C++14 compiler, the output becomes:

before assignment: valMap.size() = 0 -> set valMap[1] to 1
before assignment: valMap.size() = 1 -> set valMap[3] to 2
before assignment: valMap.size() = 2 -> set valMap[5] to 3

In other words, all values in valMap are larger by 1 than what they should be - it looks like the map gets appended before the right-hand-side of the assignment is evaluated.

This happens only in a Release build with C++14 language standard (which is the default in VS2019). Debug builds work fine (I hate when this happens - it took me hours to find out what is going on), as do Release builds of C++17 and C++20. This is why it looks like a bug to me.

My question is: is this a compiler bug, or am I doing something wrong/dangerous by using .size() in the assignment?

ANSWER

Answered 2022-Feb-01 at 15:49

The evaluation order of A = B was not specified before c++17, after c++17 B is guaranteed to be evaluated before A, see https://en.cppreference.com/w/cpp/language/eval_order rule 20.

The behaviour of valMap[val] = valMap.size(); is therefore unspecified in c++14, you should use:

auto size = valMap.size();
valMap[val] = size;

Or avoid the problem by using emplace which is more explicit than relying on [] to automatically insert a value if it doesn't already exist:

valMap.emplace(val, size);

Source https://stackoverflow.com/questions/70943170

QUESTION

Why does the thread sanitizer complain about acquire/release thread fences?

Asked 2022-Jan-04 at 16:06

I'm learning about different memory orders.

I have this code, which works and passes GCC's and Clang's thread sanitizers:

#include <atomic>
#include <iostream>
#include <future>
    
int state = 0;
std::atomic_int a = 0;

void foo(int from, int to) 
{
    for (int i = 0; i < 10; i++)
    {
        while (a.load(std::memory_order_acquire) != from) {}
        state++;
        a.store(to, std::memory_order_release);
    }
}

int main()
{    
    auto x = std::async(std::launch::async, foo, 0, 1);
    auto y = std::async(std::launch::async, foo, 1, 0);
}

I reckon that an 'acquire' load is unnecessary if it doesn't end up returning from, so I decided to use a 'relaxed' load, followed by an 'acquire' fence.

I expected it to work, but it's rejected by the thread sanitizers, which claim that concurrent state++s are a data race.

#include <atomic>
#include <iostream>
#include <future>
    
int state = 0;
std::atomic_int a = 0;

void foo(int from, int to) 
{
    for (int i = 0; i < 10; i++)
    {
        while (a.load(std::memory_order_relaxed) != from) {}
        std::atomic_thread_fence(std::memory_order_acquire);
        state++;
        a.store(to, std::memory_order_release);
    }
}

int main()
{    
    auto x = std::async(std::launch::async, foo, 0, 1);
    auto y = std::async(std::launch::async, foo, 1, 0);
}

Why is this a data race?

Cppreference says that

Atomic-fence synchronization

An atomic release operation X in thread A synchronizes-with an acquire fence F in thread B, if

there exists an atomic read Y (with any memory order)

Y reads the value written by X (or by the release sequence headed by X)

Y is sequenced-before F in thread B

In this case, all non-atomic and relaxed atomic stores that are sequenced-before X in thread A will happen-before all non-atomic and relaxed atomic loads from the same locations made in thread B after F.

In my understanding, all conditions are met:

"there exists an atomic read Y (with any memory order)" — check: a.load(std::memory_order_relaxed).
"Y reads the value written by X" — check, it reads the value from a.store(to, std::memory_order_release);.
"Y is sequenced-before F in thread B" — check.

ANSWER

Answered 2022-Jan-04 at 16:06

The thread sanitizer currently doesn't support std::atomic_thread_fence. (GCC and Clang use the same thread sanitizer, so it applies to both.)

GCC 12 (currently trunk) warns about it:

atomic_base.h:133:26: warning: 'atomic_thread_fence' is not supported with '-fsanitize=thread' [-Wtsan]
  133 |   { __atomic_thread_fence(int(__m)); }
      |     ~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~

To stop the sanitizer from disregarding fences, you can manually instrument them, using __tsan_acquire and __tsan_release.

#include <sanitizer/tsan_interface.h>

while (a.load(std::memory_order_relaxed) != from) {}
__tsan_acquire(&a); // <--
std::atomic_thread_fence(std::memory_order_acquire);

I assume it's tricky to automatically determine which atomic variables are affected by the fence.

Even though the bug report says seq_cst fences are not affected, the code is still rejected if I use such a fence, they still need to be annotated with __tsan_acquire+__tsan_release, exactly the same as acq-rel fences.

Source https://stackoverflow.com/questions/70542993

QUESTION

Why would one want to put a unary plus (+) operator in front of a C++ lambda?

Asked 2021-Dec-28 at 23:15

I found out that in C++ we can use + in lambda function +[]{} Example from the article:

#include <iostream>
#include <type_traits>
int main()
{
    auto funcPtr = +[] {};
    static_assert(std::is_same<decltype(funcPtr), void (*)()>::value);
}

The main idea of + sign in lambda

You can force the compiler to generate lambda as a function pointer rather than closure by adding + in front of it as above.

But what are advantages of using '+' in lambda? Could you please provide example or link me to the explanation?

ANSWER

Answered 2021-Dec-28 at 10:21

It's not a feature of lambda and more is a feature of implicit type conversion.

What happens there is stemming from the fact that a captureless lambda can be implicitly converted to a pointer to function with same signature as lambda's operator(). +[]{} is an expression where unary + is a no-op , so the only legal result of expression is a pointer to function.

In result auto funcPtr would be a pointer to a function, not an instance of an object with anonymous type returned by lambda expression. Not much of advantage in provided code, but it can be important in type-agnostic code, e.g. where some kind of decltype expression is used. E.g.

#include <type_traits>

void foo(int);

template<class T>
struct is_foo : std::is_same<T, decltype(&foo)> {};

int main()
{
    auto foo1 = +[](int)->void {};
    auto foo2 = [](int)->void {};
    static_assert(is_foo<decltype(foo1)>::value, "foo1 is not like foo");
    static_assert(is_foo<decltype(+foo2)>::value, "+foo2 is not like foo");
    static_assert(is_foo<decltype(foo2)>::value, "foo2 is not like foo"); 
}

Note that you can do same with foo: std::is_same<T, decltype(+foo)> {};

Albeit some platforms may not support that, because they inherently may have a variety of function pointers with different calling convention and the expression will be ambiguous.

Source https://stackoverflow.com/questions/70505162

QUESTION

xcrun: error: SDK "iphoneos" cannot be located

Asked 2021-Dec-15 at 20:35

I'm not experienced so I can't really pinpoint what is the problem. Thanks for the help.

I cloned this repo: https://github.com/flatlogic/react-native-starter.git

And was trying to follow the steps below:

Clone the repo

git clone https://github.com/flatlogic/react-native-starter.git

Navigate to clonned folder and Install dependencies

cd react-native-starter && yarn install

Install Pods

cd ios && pod install

When I got to the pod install I'm getting that error.

karar@Karars-MacBook-Air ios % pod install
Auto-linking React Native modules for target `ReactNativeStarter`: BVLinearGradient, RNCMaskedView, RNGestureHandler, RNLocalize, RNReanimated, RNScreens, RNVectorIcons, ReactNativeUiLib, react-native-safe-area-context, and toolbar-android
Analyzing dependencies
Fetching podspec for `DoubleConversion` from `../node_modules/react-native/third-party-podspecs/DoubleConversion.podspec`
Fetching podspec for `Folly` from `../node_modules/react-native/third-party-podspecs/Folly.podspec`
Fetching podspec for `glog` from `../node_modules/react-native/third-party-podspecs/glog.podspec`
Downloading dependencies
Installing BVLinearGradient (2.5.6)
Installing DoubleConversion (1.1.6)
Installing FBLazyVector (0.63.1)
Installing FBReactNativeSpec (0.63.1)
Installing Folly (2020.01.13.00)
Installing RCTRequired (0.63.1)
Installing RCTTypeSafety (0.63.1)
Installing RNCMaskedView (0.1.10)
Installing RNGestureHandler (1.8.0)
Installing RNLocalize (1.4.2)
Installing RNReanimated (1.13.1)
Installing RNScreens (2.11.0)
Installing RNVectorIcons (6.7.0)
Installing React (0.63.1)
Installing React-Core (0.63.1)
Installing React-CoreModules (0.63.1)
Installing React-RCTActionSheet (0.63.1)
Installing React-RCTAnimation (0.63.1)
Installing React-RCTBlob (0.63.1)
Installing React-RCTImage (0.63.1)
Installing React-RCTLinking (0.63.1)
Installing React-RCTNetwork (0.63.1)
Installing React-RCTSettings (0.63.1)
Installing React-RCTText (0.63.1)
Installing React-RCTVibration (0.63.1)
Installing React-callinvoker (0.63.1)
Installing React-cxxreact (0.63.1)
Installing React-jsi (0.63.1)
Installing React-jsiexecutor (0.63.1)
Installing React-jsinspector (0.63.1)
Installing ReactCommon (0.63.1)
Installing ReactNativeUiLib (3.41.0)
Installing Yoga (1.14.0)
Installing boost-for-react-native (1.63.0)
Installing glog (0.3.5)
[!] /bin/bash -c 
set -e
#!/bin/bash
# Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.

set -e

PLATFORM_NAME="${PLATFORM_NAME:-iphoneos}"
CURRENT_ARCH="${CURRENT_ARCH}"

if [ -z "$CURRENT_ARCH" ] || [ "$CURRENT_ARCH" == "undefined_arch" ]; then
    # Xcode 10 beta sets CURRENT_ARCH to "undefined_arch", this leads to incorrect linker arg.
    # it's better to rely on platform name as fallback because architecture differs between simulator and device

    if [[ "$PLATFORM_NAME" == *"simulator"* ]]; then
        CURRENT_ARCH="x86_64"
    else
        CURRENT_ARCH="armv7"
    fi
fi

export CC="$(xcrun -find -sdk $PLATFORM_NAME cc) -arch $CURRENT_ARCH -isysroot $(xcrun -sdk $PLATFORM_NAME --show-sdk-path)"
export CXX="$CC"

# Remove automake symlink if it exists
if [ -h "test-driver" ]; then
    rm test-driver
fi

./configure --host arm-apple-darwin

# Fix build for tvOS
cat << EOF >> src/config.h

/* Add in so we have Apple Target Conditionals */
#ifdef __APPLE__
#include <TargetConditionals.h>
#include <Availability.h>
#endif

/* Special configuration for AppleTVOS */
#if TARGET_OS_TV
#undef HAVE_SYSCALL_H
#undef HAVE_SYS_SYSCALL_H
#undef OS_MACOSX
#endif

/* Special configuration for ucontext */
#undef HAVE_UCONTEXT_H
#undef PC_FROM_UCONTEXT
#if defined(__x86_64__)
#define PC_FROM_UCONTEXT uc_mcontext->__ss.__rip
#elif defined(__i386__)
#define PC_FROM_UCONTEXT uc_mcontext->__ss.__eip
#endif
EOF

# Prepare exported header include
EXPORTED_INCLUDE_DIR="exported/glog"
mkdir -p exported/glog
cp -f src/glog/log_severity.h "$EXPORTED_INCLUDE_DIR/"
cp -f src/glog/logging.h "$EXPORTED_INCLUDE_DIR/"
cp -f src/glog/raw_logging.h "$EXPORTED_INCLUDE_DIR/"
cp -f src/glog/stl_logging.h "$EXPORTED_INCLUDE_DIR/"
cp -f src/glog/vlog_is_on.h "$EXPORTED_INCLUDE_DIR/"

checking for a BSD-compatible install... /usr/bin/install -c
checking whether build environment is sane... yes
checking for arm-apple-darwin-strip... no
checking for strip... strip
checking for a thread-safe mkdir -p... ./install-sh -c -d
checking for gawk... no
checking for mawk... no
checking for nawk... no
checking for awk... awk
checking whether make sets $(MAKE)... yes
checking whether make supports nested variables... yes
checking for arm-apple-darwin-gcc... /Library/Developer/CommandLineTools/usr/bin/cc -arch armv7 -isysroot 
checking whether the C compiler works... no
xcrun: error: SDK "iphoneos" cannot be located
xcrun: error: SDK "iphoneos" cannot be located
xcrun: error: SDK "iphoneos" cannot be located
xcrun: error: unable to lookup item 'Path' in SDK 'iphoneos'
/Users/karar/Library/Caches/CocoaPods/Pods/External/glog/2263bd123499e5b93b5efe24871be317-40a13/missing: Unknown `--is-lightweight' option
Try `/Users/karar/Library/Caches/CocoaPods/Pods/External/glog/2263bd123499e5b93b5efe24871be317-40a13/missing --help' for more information
configure: WARNING: 'missing' script is too old or missing
configure: error: in `/Users/karar/Library/Caches/CocoaPods/Pods/External/glog/2263bd123499e5b93b5efe24871be317-40a13':
configure: error: C compiler cannot create executables
See `config.log' for more details

karar@Karars-MacBook-Air ios %

ANSWER

Answered 2021-Jul-28 at 18:31

I think your pod install working fine and has done its job. You need to set up iPhone SDK on your mac then try to run cd ../ && react-native run-ios.

Follow this guide : React Native Environment set up on Mac OS with Xcode and Android Studio

Source https://stackoverflow.com/questions/68565356

QUESTION

Passing a C-style array to `span<T>`

Asked 2021-Nov-27 at 02:27

C++20 introduced std::span, which is a view-like object that can take in a continuous sequence, such as a C-style array, std::array, and std::vector. A common problem with a C-style array is it will decay to a pointer when passing to a function. Such a problem can be solved by using std::span:

size_t size(std::span<int> s)
{
    return s.size();
}

int main()
{
    std::array arr = {1,2,3,4,5};
    std::vector vec = {1,2,3,4,5};
    auto il = {1,2,3,4,5};
    int c_arr[] = {1,2,3,4,5};
    std::cout << size(arr) << size(vec) << size(il) << size(c_arr);
}

This would print 5555, as expected. However, size probably shouldn't take in only containers of int. Instead it should take in containers of any type. However, changing the size to a templated function, that takes in a std::span<T>, it can no longer substitute the C-style array successfully, while the others can:

template<typename T>
size_t size(std::span<T> s)
{
    return s.size();
}

int main()
{
    std::array arr = {1,2,3,4,5};
    std::vector vec = {1,2,3,4,5};
    auto il = {1,2,3,4,5};
    int c_arr[] = {1,2,3,4,5};
    std::cout << size(arr) << size(vec) << size(il) << size(c_arr);
                                                       ^^^^^^^^^^^
    // error: no matching function for call to 'size(int [5])'
    // note: template argument deduction/substitution failed:
    // note: mismatched types 'std::span<_Type, 18446744073709551615>' and 'int*'
}

Godbolt

Is this the correct behavior? If so, is there a way to accept a C-style array with span<T>?

ANSWER

Answered 2021-Nov-27 at 02:27

The question is not why this fails for int[], but why it works for all the other types! Unfortunately, you have fallen prey to ADL which is actually calling std::size instead of the size function you have written. This is because all overloads of your function fail, and so it looks in the namespace of the first argument for a matching function, where it finds std::size. Rerun your program with the function renamed to something else:

template<typename T>
size_t my_size(std::span<T> s)
{
    return s.size();
}

And on GCC 12 I get

prog.cc:18:25: error: no matching function for call to 'my_size(std::array<int, 5>&)'
   18 |     std::cout << my_size(arr) << my_size(vec) << my_size(il) << my_size(c_arr);
      |                  ~~~~~~~^~~~~
prog.cc:7:8: note: candidate: 'template<class T> size_t my_size(std::span<_Type, 18446744073709551615>)'
    7 | size_t my_size(std::span<T> s)
      |        ^~~~~~~
prog.cc:7:8: note:   template argument deduction/substitution failed:
prog.cc:18:25: note:   'std::array<int, 5>' is not derived from 'std::span<_Type, 18446744073709551615>'
   18 |     std::cout << my_size(arr) << my_size(vec) << my_size(il) << my_size(c_arr);
      |                  ~~~~~~~^~~~~

plus similar errors for all the other types. If your question is why is this failing; then the short answer is that template type deduction is far more strict than regular type deduction and so unless you give it an exact match (more or less), it will fail. For a more detailed explanation, read a similar question such as this one which deals with something similar.

Source https://stackoverflow.com/questions/70117922

Community Discussions, Code Snippets contain sources that include Stack Exchange Network

Vulnerabilities

No vulnerabilities reported

Install auto

You can download it from GitHub, Maven.
You can use auto like any standard Java library. Please include the the jar files in your classpath. You can also use any IDE and you can run and debug the auto component as you would do with any other Java program. Best practice is to use a build tool that supports dependency management such as Maven or Gradle. For Maven installation, please refer maven.apache.org. For Gradle installation, please refer gradle.org .

Support

For any new features, suggestions and bugs create an issue on GitHub. If you have any questions check and ask questions on community page Stack Overflow .