You can cast like this:  

    return this.createMarkerStyle(&lt;MarkerSymbolInfo&gt; symbolInfo);

Or like this if you want to be compatible with tsx mode:

    return this.createMarkerStyle(symbolInfo as MarkerSymbolInfo);

Just remember that this is a compile-time cast, and not a runtime cast.


This is called [type assertion][1] in TypeScript, and since TypeScript 1.6, there are two ways to express this:

    // Original syntax
    var markerSymbolInfo = &lt;MarkerSymbolInfo&gt; symbolInfo;

    // Newer additional syntax
    var markerSymbolInfo = symbolInfo as MarkerSymbolInfo;

Both alternatives are **functionally identical**. The reason for introducing the `as`-syntax is that the original syntax conflicts with [JSX][2], see the design discussion [here][3].

If you are in a position to choose, just use the syntax that you feel more comfortable with. I personally prefer the `as`-syntax as it feels more fluent to read and write.

  [1]: https://www.typescriptlang.org/docs/handbook/basic-types.html#type-assertions
  [2]: https://facebook.github.io/react/docs/jsx-in-depth.html
  [3]: https://github.com/Microsoft/TypeScript/issues/296

In typescript it is possible to do an `instanceof` check in an if statement and you will have access to the same variable with the `Typed` properties.

So let&#39;s say `MarkerSymbolInfo` has a property on it called `marker`. You can do the following:

```ts
if (symbolInfo instanceof MarkerSymbol) {
    // access .marker here
    const marker = symbolInfo.marker
}
```

It&#39;s a nice little trick to get the instance of a variable using the same variable without needing to reassign it to a different variable name.

Check out these two resources for more information:

[TypeScript instanceof][1] &amp;
[JavaScript instanceof][2]


  [1]: https://www.typescriptlang.org/docs/handbook/advanced-types.html
  [2]: https://javascript.info/instanceof

I am facing an issue with URLs, I want to be able to convert titles that could contain anything and have them stripped of all special characters so they only have letters and numbers and of course I would like to replace spaces with hyphens.

How would this be done? I&#39;ve heard a lot about regular expressions (regex) being used...

Remove all special characters from a string

I want to set background drawable of a view. There are two methods for this (as far as I see): `setBackground` and `setBackgroundDrawable`. 

When I use `setBackground`, it says it has been added in *API level 16* but my project&#39;s min SDK version is 7. I assume it&#39;s not going to work on anything below 16, am I right? But when I use setBackgroundDrawable, it says it&#39;s deprecated.

What am I supposed to use?

setBackground vs setBackgroundDrawable (Android)

How does one handle type casting in TypeScript or Javascript?  

Say I have the following TypeScript code:

    module Symbology { 
    
        export class SymbolFactory { 
    
            createStyle( symbolInfo : SymbolInfo) : any { 
                if (symbolInfo == null)
                {
                     return null;
                }
    
                if (symbolInfo.symbolShapeType === &quot;marker&quot;) {      
                    
                    // how to cast to MarkerSymbolInfo          
                    return this.createMarkerStyle((MarkerSymbolInfo) symbolInfo);
                }                                  
            }
    
            createMarkerStyle(markerSymbol : MarkerSymbolInfo ): any { 
                throw &quot;createMarkerStyle not implemented&quot;;
            }              
           
        }
    }

where `SymbolInfo` is a base class.  How do I handle typecasting from `SymbolInfo` to `MarkerSymbolInfo` in TypeScript or Javascript?

TypeScript or JavaScript type casting

How does one handle type casting in TypeScript or Javascript?
Say I have the following TypeScript code:
<pre><code class="hljs language-typescript">module Symbology { 

 export class SymbolFactory { 

 createStyle( symbolInfo : SymbolInfo) : any { 
 if (symbolInfo == null)
 {
 return null;
 }

 if (symbolInfo.symbolShapeType === "marker") { 
 
 // how to cast to MarkerSymbolInfo 
 return this.createMarkerStyle((MarkerSymbolInfo) symbolInfo);
 } 
 }

 createMarkerStyle(markerSymbol : MarkerSymbolInfo ): any { 
 throw "createMarkerStyle not implemented";
 } 
 
 }
}
</code></pre>
where <code>SymbolInfo</code> is a base class. How do I handle typecasting from <code>SymbolInfo</code> to <code>MarkerSymbolInfo</code> in TypeScript or Javascript?

I would like to import the following csv as strings not as int64. Pandas read_csv automatically converts it to int64, but I need this column as string.

    ID
    00013007854817840016671868
    00013007854817840016749251
    00013007854817840016754630
    00013007854817840016781876
    00013007854817840017028824
    00013007854817840017963235
    00013007854817840018860166


    df = read_csv(&#39;sample.csv&#39;)

    df.ID
    &gt;&gt;

    0   -9223372036854775808
    1   -9223372036854775808
    2   -9223372036854775808
    3   -9223372036854775808
    4   -9223372036854775808
    5   -9223372036854775808
    6   -9223372036854775808
    Name: ID


Unfortunately using converters gives the same result. 

    df = read_csv(&#39;sample.csv&#39;, converters={&#39;ID&#39;: str})
    df.ID
    &gt;&gt;

    0   -9223372036854775808
    1   -9223372036854775808
    2   -9223372036854775808
    3   -9223372036854775808
    4   -9223372036854775808
    5   -9223372036854775808
    6   -9223372036854775808
    Name: ID




Import pandas dataframe column as string not int

What is the best method to go about passing a `shared_ptr` of a derived type to a function that takes a `shared_ptr` of a base type?

I generally pass `shared_ptr`s by reference to avoid a needless copy:

    int foo(const shared_ptr&lt;bar&gt;&amp; ptr);

but this doesn&#39;t work if I try to do something like

    int foo(const shared_ptr&lt;Base&gt;&amp; ptr);

    ...

    shared_ptr&lt;Derived&gt; bar = make_shared&lt;Derived&gt;();
    foo(bar);

I could use

    foo(dynamic_pointer_cast&lt;Base, Derived&gt;(bar));

but this seems sub-optimal for two reasons:

- A `dynamic_cast` seems a bit excessive for a simple derived-to-base cast.
- As I understand it, `dynamic_pointer_cast` creates a copy (albeit a temporary one) of the pointer to pass to the function.

Is there a better solution?

## Update for posterity:

It turned out to be an issue of a missing header file. Also, what I was trying to do here is considered an antipattern. Generally,

- Functions that don&#39;t impact an object&#39;s lifetime (i.e. the object remains valid for the duration of the function) should take a plain reference or pointer, e.g. `int foo(bar&amp; b)`.

- Functions that *consume* an object (i.e. are the final users of a given object) should take a `unique_ptr` by value, e.g. `int foo(unique_ptr&lt;bar&gt; b)`. Callers should `std::move` the value into the function.

- Functions that extend the lifetime of an object should take a `shared_ptr` by value, e.g. `int foo(shared_ptr&lt;bar&gt; b)`. The usual advice to avoid [circular references](https://en.wikipedia.org/wiki/Circular_reference) applies.

See Herb Sutter&#39;s [Back to Basics talk](https://www.youtube.com/watch?v=xnqTKD8uD64) for details.

Passing shared_ptr&lt;Derived&gt; as shared_ptr&lt;Base&gt;

I noticed that Resharper suggests that I turn this:

    if (myObj.myProp is MyType)
    {
       ...
    }

into this:

    var myObjRef = myObj.myProp as MyType;
    if (myObjRef != null)
    {
       ...
    }

Why would it suggest this change? I&#39;m used to Resharper suggesting optimization changes and code reduction changes, but this feels like it wants to take my single statement and turn it into a two-liner.

According to [MSDN][1]:

&gt; An **is** *expression* evaluates to true if both of the following conditions
&gt; are met:
&gt; 
&gt; *expression* is not null. expression can be cast to *type*. That is, a
&gt; cast expression of the form `(type)(expression)` will complete without
&gt; throwing an exception.

Am I misreading that, or doesn&#39;t `is` do the exact same checks, just in a single line without the need to explicitly create another local variable for the null check?


  [1]: http://msdn.microsoft.com/en-us/library/scekt9xw%28v=vs.71%29.aspx

&#39;is&#39; versus try cast with null check

There is already question like this [link] on StackOverflow and the accepted answer is &quot;casting&quot;:

    Image image = ImageIO.read(new File(file));
    BufferedImage buffered = (BufferedImage) image;

In my program I try:

    final float FACTOR  = 4f;
    BufferedImage img = ImageIO.read(new File(&quot;graphic.png&quot;));
    int scaleX = (int) (img.getWidth() * FACTOR);
    int scaleY = (int) (img.getHeight() * FACTOR);
    Image image = img.getScaledInstance(scaleX, scaleY, Image.SCALE_SMOOTH);
    BufferedImage buffered = (BufferedImage) image;

Unfortunatelly I get run time error: 

&gt; sun.awt.image.ToolkitImage cannot be cast to java.awt.image.BufferedImage

Obviously casting does not work.   
Question is: What is (or is there) the proper way of converting Image to BufferedImage?

[link]: https://stackoverflow.com/questions/9132149/how-to-convert-buffered-image-to-image-and-vice-versa

Java converting Image to BufferedImage

In a recent homework assignment I&#39;ve been told to use `long` variable to store a result, since it may be a big number.

I decided to check will it really matter for me, on my system (intel core i5/64-bit windows 7/gnu gcc compiler) and found out that the following code:

    printf(&quot;sizeof(char) =&gt; %d\n&quot;, sizeof(char));
    printf(&quot;sizeof(short) =&gt; %d\n&quot;, sizeof(short));
    printf(&quot;sizeof(short int) =&gt; %d\n&quot;, sizeof(short int));
    printf(&quot;sizeof(int) =&gt; %d\n&quot;, sizeof(int));
    printf(&quot;sizeof(long) =&gt; %d\n&quot;, sizeof(long));
    printf(&quot;sizeof(long int) =&gt; %d\n&quot;, sizeof(long int));
    printf(&quot;sizeof(long long) =&gt; %d\n&quot;, sizeof(long long));
    printf(&quot;sizeof(long long int) =&gt; %d\n&quot;, sizeof(long long int));

produces the following output:

    sizeof(char) =&gt; 1
    sizeof(short) =&gt; 2
    sizeof(short int) =&gt; 2
    sizeof(int) =&gt; 4
    sizeof(long) =&gt; 4
    sizeof(long int) =&gt; 4
    sizeof(long long) =&gt; 8
    sizeof(long long int) =&gt; 8

In other words, on my system, `int` and `long` are the same, and whatever will be too big for `int` to hold, will be too big for `long` to hold as well.

The homework assignment itself is not the issue here. I wonder how, on a system where `int &lt; long`, should I assign an `int` to long?

I&#39;m aware to the fact that [there](https://stackoverflow.com/questions/12501331/how-does-long-to-int-cast-work-in-java) [are](https://stackoverflow.com/questions/1590831/safely-casting-long-to-int-in-java) [numerous](https://stackoverflow.com/questions/1161887/what-happens-if-i-cast-a-double-to-an-int-but-the-value-of-the-double-is-out-of) [closely](https://stackoverflow.com/questions/2711522/what-happens-if-i-assign-a-negative-value-to-an-unsigned-variable) [related](https://stackoverflow.com/questions/7977265/what-happens-at-background-when-convert-int-to-float) questions on this subject, but I feel that the answers within these do not provide me with the complete understanding of what will or may happen in the process.

Basically I&#39;m trying to figure out the following:

 1. Should I cast `long` to `int` before the assignment, or &lt;del&gt;since `long`
    is not a different data type, but merely a modifier,&lt;/del&gt; it will be
    considered unharmful to assign directly?
 2. What happens on systems where `long &gt; int`? Will the result be
    undefined (or unpredictable) or it will cause the extra parts of the
    variable to be omitted?
 3. How does the casting from `long` to `int` works in C?
 4. How does the assignment from `long` to `int` works in C when I don&#39;t
    use casting?

What happens when I assign long int to int in C?

I wanted to move to TypeScript from traditional JS because I like the C#-like syntax.
My problem is that I can&#39;t find out how to declare static classes in TypeScript.

In C#, I often use static classes to organize variables and methods, putting them together in a named class, without needing to instatiate an object.
In vanilla JS, I used to do this with a simple JS object:
 
    var myStaticClass = {
        property: 10,
        method: function(){}
    }

In TypeScript, I would rather go for my C-sharpy approach, but it seems that static classes don&#39;t exist in TS.
 What is the appropriate solution for this problem ?

TypeScript static classes

Section 6.3 of the TypeScript language spec talks about function overloading and gives concrete examples on how to implement this.  However if I try something like this:

    export class LayerFactory { 

        constructor (public styleFactory: Symbology.StyleFactory) { }
                        
        createFeatureLayer (userContext : Model.UserContext, mapWrapperObj : MapWrapperBase) : any {           
             throw &quot;not implemented&quot;;
        }                 

        createFeatureLayer(layerName : string, style : any) : any {
            throw &quot;not implemented&quot;;
         }        
        
    }

I get a compiler error indicating duplicate identifier even though function parameters are of different types.  Even if I add an additional parameter to the second createFeatureLayer function, I still get a compiler error.  Ideas, please.

TypeScript function overloading

I have a typescript file called `Projects.ts` that I want to reference a global variable declared in a bootstrap plugin called `bootbox.js`.

I want to access a variable called `bootbox` from within a TypeScript classes.

Is it possible?

Call a global variable inside module

I would like to store a mapping of string -&gt; string in a Typescript object, and enforce that all of the keys map to strings.  For example:

    var stuff = {};
    stuff[&quot;a&quot;] = &quot;foo&quot;;   // okay
    stuff[&quot;b&quot;] = &quot;bar&quot;;   // okay
    stuff[&quot;c&quot;] = false;   // ERROR!  bool != string

Is there a way for me to enforce that the values must be strings (or whatever type..)?


Enforcing the type of the indexed members of a Typescript object?

I am trying to figure out how to correctly define abstract methods in TypeScript:

Using the original inheritance example:

    class Animal {
        constructor(public name) { }
        makeSound(input : string) : string;
        move(meters) {
            alert(this.name + &quot; moved &quot; + meters + &quot;m.&quot;);
        }
    }
    
    class Snake extends Animal {
        constructor(name) { super(name); }
        makeSound(input : string) : string {
            return &quot;sssss&quot;+input;
        }
        move() {
            alert(&quot;Slithering...&quot;);
            super.move(5);
        }
    }

I would like to know how to correctly define method makeSound, so it is typed and possible to overried.

Also, I am not sure how to define correctly `protected` methods - it seems to be a keyword, but has no effect and the code won&#39;t compile.

Content Type	Original Author	Original Content on Stackoverflow
Question	Klaus Nji	View Question on Stackoverflow
Solution 1 - Casting	blorkfish	View Answer on Stackoverflow
Solution 2 - Casting	Alex	View Answer on Stackoverflow
Solution 3 - Casting	Newteq Developer	View Answer on Stackoverflow

TypeScript or JavaScript type casting

Casting Problem Overview

Casting Solutions

Solution 1 - Casting

Solution 2 - Casting

Solution 3 - Casting

setBackground vs setBackgroundDrawable (Android)

Remove all special characters from a string

Attributions