reference: move GangRef from actor to reference (#421)

Summary:
Pull Request resolved: #421

plain refactor: move `GangRef` from `hyperator::actor` to `hyperactor::reference` and re-export it as `hyperactor::GangRef`.

Reviewed By: mariusae

Differential Revision: D77738544

fbshipit-source-id: 7a0f16ef4b613a836125d528701f96c8c5ac9ceb

Author: shayne-fletcher

controller/src/lib.rs

@@ -24,11 +24,11 @@ use hyperactor::ActorId;
 use hyperactor::ActorRef;
 use hyperactor::Context;
 use hyperactor::GangId;
+use hyperactor::GangRef;
 use hyperactor::Handler;
 use hyperactor::Named;
 use hyperactor::actor::ActorHandle;
 use hyperactor::actor::ActorStatus;
-use hyperactor::actor::GangRef;
 use hyperactor::cap;
 use hyperactor::channel::ChannelAddr;
 use hyperactor::clock::Clock;

hyperactor/src/actor.rs

@@ -623,62 +623,6 @@ pub trait Binds<A: Actor>: RemoteActor {
 /// is handled by a specific actor type.
 pub trait RemoteHandles<M: RemoteMessage>: RemoteActor {}
 
-/// GangRefs are typed references to gangs.
-#[derive(Debug, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Hash, Ord)]
-pub struct GangRef<A: RemoteActor> {
-    gang_id: GangId,
-    phantom: PhantomData<A>,
-}
-
-impl<A: RemoteActor> GangRef<A> {
-    /// Return an ActorRef corresponding with the provided rank in
-    /// this gang.  Does not check the validity of the rank, so the
-    /// returned identifier is not guaranteed to refer to a valid rank.
-    pub fn rank(&self, rank: Index) -> ActorRef<A> {
-        let GangRef {
-            gang_id: GangId(world_id, name),
-            ..
-        } = self;
-        ActorRef::attest(ActorId(ProcId(world_id.clone(), rank), name.clone(), 0))
-    }
-
-    /// Return the gang ID.
-    pub fn gang_id(&self) -> &GangId {
-        &self.gang_id
-    }
-}
-
-impl<A: RemoteActor> Clone for GangRef<A> {
-    fn clone(&self) -> Self {
-        Self {
-            gang_id: self.gang_id.clone(),
-            phantom: PhantomData,
-        }
-    }
-}
-
-// TODO: remove, replace with attest
-impl<A: RemoteActor> From<GangId> for GangRef<A> {
-    fn from(gang_id: GangId) -> Self {
-        Self {
-            gang_id,
-            phantom: PhantomData,
-        }
-    }
-}
-
-impl<A: RemoteActor> From<GangRef<A>> for GangId {
-    fn from(gang_ref: GangRef<A>) -> Self {
-        gang_ref.gang_id
-    }
-}
-
-impl<'a, A: RemoteActor> From<&'a GangRef<A>> for &'a GangId {
-    fn from(gang_ref: &'a GangRef<A>) -> Self {
-        &gang_ref.gang_id
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use std::sync::Mutex;

hyperactor/src/lib.rs

@@ -156,6 +156,7 @@ pub use proc::Instance;
 pub use reference::ActorId;
 pub use reference::ActorRef;
 pub use reference::GangId;
+pub use reference::GangRef;
 pub use reference::OncePortRef;
 pub use reference::PortId;
 pub use reference::PortRef;

hyperactor/src/reference.rs

@@ -1130,6 +1130,62 @@ fn chop<'a>(mut s: &'a str, delims: &'a [&'a str]) -> impl Iterator<Item = &'a s
     })
 }
 
+/// GangRefs are typed references to gangs.
+#[derive(Debug, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Hash, Ord)]
+pub struct GangRef<A: RemoteActor> {
+    gang_id: GangId,
+    phantom: PhantomData<A>,
+}
+
+impl<A: RemoteActor> GangRef<A> {
+    /// Return an ActorRef corresponding with the provided rank in
+    /// this gang.  Does not check the validity of the rank, so the
+    /// returned identifier is not guaranteed to refer to a valid rank.
+    pub fn rank(&self, rank: Index) -> ActorRef<A> {
+        let GangRef {
+            gang_id: GangId(world_id, name),
+            ..
+        } = self;
+        ActorRef::attest(ActorId(ProcId(world_id.clone(), rank), name.clone(), 0))
+    }
+
+    /// Return the gang ID.
+    pub fn gang_id(&self) -> &GangId {
+        &self.gang_id
+    }
+}
+
+impl<A: RemoteActor> Clone for GangRef<A> {
+    fn clone(&self) -> Self {
+        Self {
+            gang_id: self.gang_id.clone(),
+            phantom: PhantomData,
+        }
+    }
+}
+
+// TODO: remove, replace with attest
+impl<A: RemoteActor> From<GangId> for GangRef<A> {
+    fn from(gang_id: GangId) -> Self {
+        Self {
+            gang_id,
+            phantom: PhantomData,
+        }
+    }
+}
+
+impl<A: RemoteActor> From<GangRef<A>> for GangId {
+    fn from(gang_ref: GangRef<A>) -> Self {
+        gang_ref.gang_id
+    }
+}
+
+impl<'a, A: RemoteActor> From<&'a GangRef<A>> for &'a GangId {
+    fn from(gang_ref: &'a GangRef<A>) -> Self {
+        &gang_ref.gang_id
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use rand::seq::SliceRandom;