2.9.1 "best" approach to creating object based on string class name?

The thread you linked mentions:
class Something[T](implicit val m:Manifest[T]) {
def getOne(): T = { m.erasure.newInstance.asInstanceOf[T] }
}
Now you can also use a bit more sugar:
class Something[T : Manifest] {
def getOne(): T = { manifest[T].erasure.newInstance.asInstanceOf[T] }
}
But if you really have a dirty string and want to use that, the old Java standby is:
// Get a class loader from somewhere val loader = ClassLoader.getSystemClassLoader Class.forName( stringNameOfClass , false, loader ).newInstance.asInstanceOf[ SomeType ]
If you don't use the many-arg Class.forName you may create equality/same-type issues in multiple class loader environments.
Ryan Richt Monsanto
This e-mail message may contain privileged and/or confidential information, and is intended to be received only by persons entitled
to receive such information. If you have received this e-mail in error, please notify the sender immediately. Please delete it and
all attachments from any servers, hard drives or any other media. Other use of this e-mail by you is strictly prohibited.

All e-mails and attachments sent and received are subject to monitoring, reading and archival by Monsanto, including its
subsidiaries. The recipient of this e-mail is solely responsible for checking for the presence of "Viruses" or other "Malware".
Monsanto, along with its subsidiaries, accepts no liability for any damage caused by any such code transmitted by or accompanying
this e-mail or any attachment.


The information contained in this email may be subject to the export control laws and regulations of the United States, potentially
including but not limited to the Export Administration Regulations (EAR) and sanctions regulations issued by the U.S. Department of
Treasury, Office of Foreign Asset Controls (OFAC).  As a recipient of this information you are obligated to comply with all
applicable U.S. export laws and regulations.

Ryan, thanks

It's not that I want to use the "dirty string", it's just that in the
Scala framework I'm using (Spray), URI elements are parsed to strings.

Class.forName() is certainly the most explicit/direct approach, but if
you have a number of URI routes to handle, then the boilerplate gets a
little tiresome.

Groovy and Ruby, for example, use MOP to do things like,
"com.foo.Bar".newify(). Dynamic seems to be Scala's answer to
method_missing in Ruby, and implicit has the feel of dynamic language
magic.

Just getting my feet wet in Scala, there appear to be many ways to
solve the same problem. I'll experiment..

On Dec 19, 7:47 pm, "RICHT, RYAN JERRY (AG/1005)"
wrote:
> The thread you linked mentions:
>
> class Something[T](implicit val m:Manifest[T]) {
> def getOne(): T = { m.erasure.newInstance.asInstanceOf[T] }
>
> }
>
> Now you can also use a bit more sugar:
>
> class Something[T : Manifest] {
> def getOne(): T = { manifest[T].erasure.newInstance.asInstanceOf[T] }
>
> }
>
> But if you really have a dirty string and want to use that, the old Java standby is:
>
> // Get a class loader from somewhere
> val loader = ClassLoader.getSystemClassLoader
> Class.forName( stringNameOfClass , false, loader ).newInstance.asInstanceOf[ SomeType ]
>
> If you don't use the many-arg Class.forName you may create equality/same-type issues in multiple class loader environments.
>
> Ryan Richt
> Monsanto
>
> This e-mail message may contain privileged and/or confidential information, and is intended to be received only by persons entitled
> to receive such information. If you have received this e-mail in error, please notify the sender immediately. Please delete it and
> all attachments from any servers, hard drives or any other media. Other use of this e-mail by you is strictly prohibited.
>
> All e-mails and attachments sent and received are subject to monitoring, reading and archival by Monsanto, including its
> subsidiaries. The recipient of this e-mail is solely responsible for checking for the presence of "Viruses" or other "Malware".
> Monsanto, along with its subsidiaries, accepts no liability for any damage caused by any such code transmitted by or accompanying
> this e-mail or any attachment.
>
> The information contained in this email may be subject to the export control laws and regulations of the United States, potentially
> including but not limited to the Export Administration Regulations (EAR) and sanctions regulations issued by the U.S. Department of
> Treasury, Office of Foreign Asset Controls (OFAC).  As a recipient of this information you are obligated to comply with all
> applicable U.S. export laws and regulations.

In that case (dangerous!), you can pass a type parameter to an implicit conversion that itself will be inferred so you dont have to type it out either. Then you could do something like:

scala> val now: java.util.Date = "java.util.Date"
:7: error: type mismatch;
found : java.lang.String("java.util.Date")
required: java.util.Date
val now: java.util.Date = "java.util.Date"
^

scala> implicit def newify[T](className: String) = Class.forName(className).newInstance.asInstanceOf[T]
newify: [T](className: String)T

scala> val now: java.util.Date = "java.util.Date"
now: java.util.Date = Mon Dec 19 15:40:04 CST 2011

And strings which are a type mismatch at compile type will be reflect-o-magically converted to new, no-arg instances of that type.

Ryan Richt
Monsanto
This e-mail message may contain privileged and/or confidential information, and is intended to be received only by persons entitled
to receive such information. If you have received this e-mail in error, please notify the sender immediately. Please delete it and
all attachments from any servers, hard drives or any other media. Other use of this e-mail by you is strictly prohibited.

All e-mails and attachments sent and received are subject to monitoring, reading and archival by Monsanto, including its
subsidiaries. The recipient of this e-mail is solely responsible for checking for the presence of "Viruses" or other "Malware".
Monsanto, along with its subsidiaries, accepts no liability for any damage caused by any such code transmitted by or accompanying
this e-mail or any attachment.

The information contained in this email may be subject to the export control laws and regulations of the United States, potentially
including but not limited to the Export Administration Regulations (EAR) and sanctions regulations issued by the U.S. Department of
Treasury, Office of Foreign Asset Controls (OFAC). As a recipient of this information you are obligated to comply with all
applicable U.S. export laws and regulations.

Yes, the first link I posted goes down that road:

implicit def string2Class[T<:AnyRef](name: String)(implicit
classLoader: ClassLoader): Class[T] = {
val clazz = Class.forName(name, true, classLoader)
clazz.asInstanceOf[Class[T]]
}

Risky business, match {...} would be the safer bet.

Dropping the hacker urges is proving difficult and Scala is not
helping, there are ways around compiler tyranny ;-)

On Dec 19, 10:42 pm, "RICHT, RYAN JERRY (AG/1005)"
wrote:
> In that case (dangerous!), you can pass a type parameter to an implicit conversion that itself will be inferred so you dont have to type it out either. Then you could do something like:
>
> scala> val now: java.util.Date = "java.util.Date"
> :7: error: type mismatch;
>  found   : java.lang.String("java.util.Date")
>  required: java.util.Date
>        val now: java.util.Date = "java.util.Date"
>                                  ^
>
> scala> implicit def newify[T](className: String) = Class.forName(className).newInstance.asInstanceOf[T]
> newify: [T](className: String)T
>
> scala> val now: java.util.Date = "java.util.Date"
> now: java.util.Date = Mon Dec 19 15:40:04 CST 2011
>
> And strings which are a type mismatch at compile type will be reflect-o-magically converted to new, no-arg instances of that type.
>
> Ryan Richt
> Monsanto
> This e-mail message may contain privileged and/or confidential information, and is intended to be received only by persons entitled
> to receive such information. If you have received this e-mail in error, please notify the sender immediately. Please delete it and
> all attachments from any servers, hard drives or any other media. Other use of this e-mail by you is strictly prohibited.
>
> All e-mails and attachments sent and received are subject to monitoring, reading and archival by Monsanto, including its
> subsidiaries. The recipient of this e-mail is solely responsible for checking for the presence of "Viruses" or other "Malware".
> Monsanto, along with its subsidiaries, accepts no liability for any damage caused by any such code transmitted by or accompanying
> this e-mail or any attachment.
>
> The information contained in this email may be subject to the export control laws and regulations of the United States, potentially
> including but not limited to the Export Administration Regulations (EAR) and sanctions regulations issued by the U.S. Department of
> Treasury, Office of Foreign Asset Controls (OFAC).  As a recipient of this information you are obligated to comply with all
> applicable U.S. export laws and regulations.

p, li { white-space: pre-wrap; }

Am Montag, 19. Dezember 2011, 23:36:56 schrieb virtualeyes:

> Yes, the first link I posted goes down that road:

>

> implicit def string2Class[T<:AnyRef](name: String)(implicit

> classLoader: ClassLoader): Class[T] = {

> val clazz = Class.forName(name, true, classLoader)

> clazz.asInstanceOf[Class[T]]

> }

>

> Risky business, match {...} would be the safer bet.

>

> Dropping the hacker urges is proving difficult and Scala is not

> helping, there are ways around compiler tyranny ;-)

>

...

I think there is nothing wrong with "low level" code as long as it is well confined.

And we invite runtime failures - but this is the price to pay for dynamic configuration abilities.

Greetings

Bernd