## java – How to use google maps android SDK with View Binding?

I am using android maps sdk and trying to plot a point on it. I followed the steps as given here
I get an NPE saying that my Support Map Fragment is null. I am guessing this happens due to the fact that I am using view binding and setting the view as binding.getroot() in my main fragment.

``````  SupportMapFragment supportMapFragment = (SupportMapFragment) getActivity().getSupportFragmentManager().findFragmentById(R.id.map_view);
``````

The XML where I have declared this.

``````<androidx.fragment.app.FragmentContainerView
android:id="@+id/map_view"
android:layout_width="match_parent"
android:layout_gravity="center"
android:layout_height="match_parent"/>
``````

## object oriented – Can I say that the code I provided is early/static binding in c++

I wanted to confirm that my code is implementing the concept of static/early binding in c++ or not.Because I know if we don’t use the keyword virtual its early/static binding but still I am not clear so please confirm me that my code is implementing the concept of early/Static binding in c++ or not.

``````#pragma once
#include<iostream>
#include<string>
using namespace std;
//3 -a) Write a program for simple calculator using Dynamic / Latebinding
class Calculate
{
protected:
int val1; int val2;
public:
Calculate()
{
cout << "nThe Base class startedn";
}
~Calculate() = default;
Calculate(int x, int y)
{
this->val1 = x;
this->val2 = y;
}
int calculate()
{
return 1;
};
};
{
public:
{
cout << "nThe derived class Addn";
}
{
this->val1 = x;
this->val2 = y;
}
int calculate()
{
return val1 + val2;
}
};
class Sub :public Calculate
{
public:
Sub()
{
cout << "nThe derived class Sub startedn";
}
~Sub() = default;
Sub(int x, int y)
{
this->val1 = x;
this->val2 = y;
}
int calculate()
{
return this->val1 - this->val2;
}
};
class Mul :public Calculate
{
public:
Mul()
{
cout << "nThe derived class Mul startedn";
}
~Mul() = default;
Mul(int x, int y)
{
val1 = x;
val2 = y;
}
int calculate()
{
return val1 * val2;
}
};
class Divide :public Calculate
{
public:
Divide()
{
cout << "nThe derived class Divide startedn";
}
~Divide() = default;
Divide(int x, int y)
{
val1 = x;
val2 = y;
}
int calculate()
{
return val1 / val2;
}
};

{
Calculate* calculates = nullptr;
cout << "nThe value of addition is: " << calculates->calculate();
Sub sub(20, 30);
calculates = &sub;
cout << "nThe value of subtraction is: " << calculates->calculate();
Mul mul(20, 30);
calculates = &mul;
cout << "nThe value of multiplication is: " << calculates->calculate();
Divide divide(20, 10);
calculates = &divide;
cout << "nThe value of division is: " << calculates->calculate();
}
int main()
{
return 0;
}
``````

## c++ – Capture by value/reference and early/late binding

The lambda defines a closure, which is an anonymous function together with an environment composed of captured variables.

The binding of captured variables happens at the moment the lambda is defined and uses the variables of the scope in which it was defined. This is early binding. As you said, early binding of a value and of a reference in your example.

As a consequence of early binding, if you would enclose your lambda call in its own scope with another x and y variable, the capture would still use the original x value and the reference to the y of the scope of the definition:

``````int main() {
auto x = 0, y = 0;
auto lambda = (x, &y)() { std::cout << x << ' ' << y; };
x = 1, y = 1;
{
auto x = 27, y = 2;
lambda();  // still outputs: 0 1
}
return 0;
}
``````

Online demo

Another consequence is that if the variable captured by reference no longer exists when you invoke the lambda you have undefined behaviour.

Late binding would work differently: the capture would not bind to y in main(). It would bind to an identifier corresponding to y. The binding would be done when the lambda would be invoked. In my example, the binding would be done with the inner y, and the output would be 0 2.

## key binding – assign keybinding to windows terminal profile

I would like to assign to one of the new windows terminal profiles a keybinding, as in the following (`"keys": "alt+shift+d"`):

``````        {
// Connects to a remote machine using SSH
"name":  "SSH My Local Server",
"tabTitle": "Local Server",
"commandline": "ssh eddy@flyer.local",
"keys": "alt+shift+d"
},
``````

what is the way to do this?

## c++ – Binding Lua Function to Perform tasks using std::async

I am trying to load a bunch of mesh resources in the format of .obj files. Some of the files are very high in poly count so when loading using the below method It takes more than 10 seconds. I would really like to cut this time down.

My question is how can I bind this to call loadMesh with std::async? Because I think that might help speed up the process.

``````Mesh *Loader::loadMesh(const std::string &path)
{

m_meshes.push_back(mesh);

return m_meshes.back().get();
}

.
.
.

//this is the binding
luabind::module(m_world->getLua()->get())
(
)

``````

## Virtual IP or Mac Binding IP for loadbalancer

I am configuring LoadBalancing for my website which is hosted on 2 webservers.
I have MAC binded static IPs for both the servers.
For LoadBalancer also can I have a MAC binded IP or a Virtual IP without any binding is mandatory?
I am referring to a physical load balancer. Mostly Cisco Router with LoadBalancing feature.

## sharepoint server – Selected value from binding dropdownlist to enable controls

I have this code to fill drop down list from sharepoint list. what I want to do is once the user select ticket number from the drop down list there an invisible label will be visible. I have no issue with this code when selecting a value from non binding drop down list.

.cs

``````     protected void Page_Load(object sender, EventArgs e)
{

if (!IsPostBack)
{
fillServiceTypesDropDownList();

}

}
private void fillServiceTypesDropDownList()
{
ddlServiceType.DataSource = ServiceTypes();
ddlServiceType.DataValueField = "ID";

ddlServiceType.DataTextField = "Title";
ddlServiceType.DataBind();

}

protected void ddlServiceType_TextChanged(object sender, EventArgs e)
{
if (ddlServiceType.SelectedValue == "Ticket Number")
{
lblChngRqust.Visible = true;

}
else
{
lblChngRqust.Visible = false;

}
}
``````

ascx

``````<asp:DropDownList runat="server" ID="ddlServiceType" Width="300px"  onchange="showchngReq()" OnTextChanged="ddlServiceType_TextChanged"></asp:DropDownList>

<asp:Label runat="server" ID="lblChngRqust" Visible="false" Text="please write the ticket number"></asp:Label>
``````

javascript

`````` function showchngReq(){

var chngrquest = document.getElementById('<%=lblChngRqust.ClientID%>');
var serviceTypeDD = document.getElementById('<%=ddlServiceType.ClientID%>');
var selectedSrvcTyp = serviceTypeDD.options(serviceTypeDD.selectedIndex).value;

if (selectedSrvcTyp == "Ticket Number") {
chngrquest.disabled = false;

} else {
chngrquest.disabled = true;
}

}
``````

## process algebras – Applied \$pi\$-calculus: Name binding and if clauses

Assume in the applied pi-calculus we have the following process:
$$(nu n)overline{c} langle n rangle.0 | (nu n) (c(y).(text{if n=y then P else Q}))$$
where $$P$$ and $$Q$$ are further processes.

I know that the following reduction semantic holds for the applied $$pi$$-calculus (from wikipedia):
$$overline{x}langle z rangle.P | x(y).Q rightarrow P | Q(z/y)$$
where $$Q(z/y)$$ denotes the process $$Q$$ in which the free name $$z$$ has been ”substituted” for the free occurrences of $$y$$. If a free occurrence of $$y$$ occurs in a location where $$z$$ would not be free, alpha-conversion may be required.

Do I understand correctly, that in the above example, because $$n$$ is already used and thus not free, we would need to rename and thus the reduction would be like so:
$$(nu n’) (nu n) (c(y).(text{if n=n’ then P else Q}))$$

While on the other hand, in the following process:
$$(nu n)overline{c} langle n rangle.0 | c(y).(text{if n = y then P else Q}))$$
because $$n$$ is not bound, we can simply perform the transaction like so:
$$(nu n) (text{if n = n then P else Q})$$
(and thus those two processes are also semantically different)?

## Excel VBA early/late binding in the context of application behaviour

In reference to the following changes you can make to application behaviour while running VBA in Excel, I saw a note saying that for early binding, it requires you to add an object model reference (saying In the VBA editor, click Tools > References, Select ‘Microsoft Scripting Runtime’, Click ‘OK’):

``````Application.ScreenUpdating = False
Application.Calculation = xlCalculationManual
Application.EnableEvents = False
``````

I understand the need for that reference in other contexts (e.g. using the FSO) but what is the connection between the above four lines of code and early binding? And why the Microsoft Scripting Runtime reference for this?

## ethernet – Binding NDIS based device with mac and IP in windows

I have a workaround where

1. I need to connect n number of NDIS/RNDIS based Ethernet devices
2. They will connect and disconnect several times
3. Need to assign them 1 fixed IP by mapping the Mac address of each device

Thus i can connect/disconnect but whenever they gets joined as Ethernet device they gets the old internal IP

What i tried:

DHCP for windows 10
But looks like that needs 1 main Ethernet connection which i do not have.