Styjun

Is exact Kanji stroke length important?

Unreliable Magic - Is it worth it?

Why Were Madagascar and New Zealand Discovered So Late?

How can I kill an app using Terminal?

CREATE opcode: what does it really do?

How to pronounce the slash sign

Do sorcerers' Subtle Spells require a skill check to be unseen?

How does Loki do this?

Escape a backup date in a file name

Is a stroke of luck acceptable after a series of unfavorable events?

How to draw lines on a tikz-cd diagram

What Brexit proposals are on the table in the indicative votes on the 27th of March 2019?

How to be diplomatic in refusing to write code that breaches the privacy of our users

Was Spock the First Vulcan in Starfleet?

How does it work when somebody invests in my business?

Is expanding the research of a group into machine learning as a PhD student risky?

What is the opposite of 'gravitas'?

How do I extract a value from a time formatted value in excel?

Customer Requests (Sometimes) Drive Me Bonkers!

Trouble understanding the speech of overseas colleagues

Increase performance creating Mandelbrot set in python

How can I get through very long and very dry, but also very useful technical documents when learning a new tool?

Anatomically Correct Strange Women In Ponds Distributing Swords

What happens if you roll doubles 3 times then land on "Go to jail?"

Best practice for naming akka-actors (in the companion object)

Discovery of Akka actors in clusterConfusion over Akka Actors vs Java Objectscreating Akka actor hierarchies lazilyHow do I create a TestActorRef in Scala for an Actor with constructor params?Akka - Common service actor: Identify or ExtensionAkka cluster-sharding: Can Entry actors have dynamic propsWhat are the implications of nesting an akka Actor class in an object to the members of the class?How do I create a “Locator” for Akka ActorsAkka and singleton actorsScala: How to extend an Akka actor?

0

I have several akka-actors defined like this:

object SomethingActor 
 val name: String = "somethingActor"
 def props: Props = Props(new SomethingActor())


class somethingActor extends Actor 
 verride def receive: Receive = ???


// somewhere else
final val myActor = actorSystem.actorOf(SomethingActor.props, SomethingActor.name)

Of these actors, only up to one single instant is "alive" at any given moment of my application, so e.g. a new SomethingActor actor can only be created if the old SomethingActor is dead.

Now, I don't think defining the actor name like this: val name: String = "somethingActor" is very nice, so I have been wondering if I can use something like this:

object SomethingActor 
 val name: String = this.getClass.getName
 def props: Props = Props(new SomethingActor())

Would this be considered bad practice? Is there a better way to handle this? I (think I) need to save the name in the companion object to be able to search for the actor from another point in my program using ActorSystem.actorSelection(path: String) (docu).

scala akka akka-actor

share|improve this question

asked Mar 21 at 15:59

Florian BaierlFlorian Baierl

7551829

• 
  
  
  

  
  

  
  
  
  
  
  

  
  
  I think this.getClass.getName is a good practice. Of these actors, only up to one single instant is alive at any given moment of my application Kindly confirm the mentioned feature you want or not ?
  
  – Shantiswarup Tunga
  Mar 22 at 9:58
  

  
  
  
  


• 
  
  
  

  
  

  
  
  
  
  
  

  
  
  Of these actors, only up to one single instant is alive at any given moment of my application This is the case in my application and I do not intend to change that. :)
  
  – Florian Baierl
  Mar 22 at 13:04
  

  
  
  
  


• 
  
  
  

  
  

  
  
  
  
  
  

  
  
  Then I think your approach is a good.
  
  – Shantiswarup Tunga
  Mar 22 at 17:14
  

  
  
  
  

add a comment | 

0

I have several akka-actors defined like this:

object SomethingActor 
 val name: String = "somethingActor"
 def props: Props = Props(new SomethingActor())


class somethingActor extends Actor 
 verride def receive: Receive = ???


// somewhere else
final val myActor = actorSystem.actorOf(SomethingActor.props, SomethingActor.name)

Of these actors, only up to one single instant is "alive" at any given moment of my application, so e.g. a new SomethingActor actor can only be created if the old SomethingActor is dead.

Now, I don't think defining the actor name like this: val name: String = "somethingActor" is very nice, so I have been wondering if I can use something like this:

object SomethingActor 
 val name: String = this.getClass.getName
 def props: Props = Props(new SomethingActor())

Would this be considered bad practice? Is there a better way to handle this? I (think I) need to save the name in the companion object to be able to search for the actor from another point in my program using ActorSystem.actorSelection(path: String) (docu).

scala akka akka-actor

share|improve this question

asked Mar 21 at 15:59

Florian BaierlFlorian Baierl

7551829

• 
  
  
  

  
  

  
  
  
  
  
  

  
  
  I think this.getClass.getName is a good practice. Of these actors, only up to one single instant is alive at any given moment of my application Kindly confirm the mentioned feature you want or not ?
  
  – Shantiswarup Tunga
  Mar 22 at 9:58
  

  
  
  
  


• 
  
  
  

  
  

  
  
  
  
  
  

  
  
  Of these actors, only up to one single instant is alive at any given moment of my application This is the case in my application and I do not intend to change that. :)
  
  – Florian Baierl
  Mar 22 at 13:04
  

  
  
  
  


• 
  
  
  

  
  

  
  
  
  
  
  

  
  
  Then I think your approach is a good.
  
  – Shantiswarup Tunga
  Mar 22 at 17:14
  

  
  
  
  

add a comment | 

I have several akka-actors defined like this:

object SomethingActor 
 val name: String = "somethingActor"
 def props: Props = Props(new SomethingActor())


class somethingActor extends Actor 
 verride def receive: Receive = ???


// somewhere else
final val myActor = actorSystem.actorOf(SomethingActor.props, SomethingActor.name)

Of these actors, only up to one single instant is "alive" at any given moment of my application, so e.g. a new SomethingActor actor can only be created if the old SomethingActor is dead.

Now, I don't think defining the actor name like this: val name: String = "somethingActor" is very nice, so I have been wondering if I can use something like this:

object SomethingActor 
 val name: String = this.getClass.getName
 def props: Props = Props(new SomethingActor())

Would this be considered bad practice? Is there a better way to handle this? I (think I) need to save the name in the companion object to be able to search for the actor from another point in my program using ActorSystem.actorSelection(path: String) (docu).

scala akka akka-actor

share|improve this question

asked Mar 21 at 15:59

Florian BaierlFlorian Baierl

7551829

object SomethingActor 
 val name: String = "somethingActor"
 def props: Props = Props(new SomethingActor())


class somethingActor extends Actor 
 verride def receive: Receive = ???


// somewhere else
final val myActor = actorSystem.actorOf(SomethingActor.props, SomethingActor.name)

object SomethingActor 
 val name: String = this.getClass.getName
 def props: Props = Props(new SomethingActor())

share|improve this question

asked Mar 21 at 15:59

Florian BaierlFlorian Baierl

7551829

share|improve this question

asked Mar 21 at 15:59

Florian BaierlFlorian Baierl

7551829

asked Mar 21 at 15:59

Florian BaierlFlorian Baierl

7551829

asked Mar 21 at 15:59

Florian BaierlFlorian Baierl

7551829