Renamed *NetworkGraph* references to *Topology*.
Change-Id: Iec01c47086e1518592c0753e75395d3fe5abcde3
diff --git a/src/main/java/net/onrc/onos/core/topology/TopologyImpl.java b/src/main/java/net/onrc/onos/core/topology/TopologyImpl.java
new file mode 100644
index 0000000..d48e222
--- /dev/null
+++ b/src/main/java/net/onrc/onos/core/topology/TopologyImpl.java
@@ -0,0 +1,145 @@
+package net.onrc.onos.core.topology;
+
+import java.util.Collections;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReadWriteLock;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+
+import net.floodlightcontroller.util.MACAddress;
+import net.onrc.onos.core.util.SwitchPort;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class TopologyImpl implements Topology {
+ @SuppressWarnings("unused")
+ private static final Logger log = LoggerFactory.getLogger(TopologyImpl.class);
+
+ // DPID -> Switch
+ private final ConcurrentMap<Long, Switch> switches;
+ private final ConcurrentMap<MACAddress, Device> mac2Device;
+
+ private final ConcurrentMap<SwitchPort, Link> outgoingLinks;
+ private final ConcurrentMap<SwitchPort, Link> incomingLinks;
+
+ private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
+ private Lock readLock = readWriteLock.readLock();
+ // TODO use the write lock after refactor
+ private Lock writeLock = readWriteLock.writeLock();
+
+ public TopologyImpl() {
+ // TODO: Does these object need to be stored in Concurrent Collection?
+ switches = new ConcurrentHashMap<>();
+ mac2Device = new ConcurrentHashMap<>();
+ outgoingLinks = new ConcurrentHashMap<>();
+ incomingLinks = new ConcurrentHashMap<>();
+ }
+
+ @Override
+ public Switch getSwitch(Long dpid) {
+ // TODO Check if it is safe to directly return this Object.
+ return switches.get(dpid);
+ }
+
+ protected void putSwitch(Switch sw) {
+ switches.put(sw.getDpid(), sw);
+ }
+
+ protected void removeSwitch(Long dpid) {
+ switches.remove(dpid);
+ }
+
+ @Override
+ public Iterable<Switch> getSwitches() {
+ // TODO Check if it is safe to directly return this Object.
+ return Collections.unmodifiableCollection(switches.values());
+ }
+
+ @Override
+ public Port getPort(Long dpid, Long number) {
+ Switch sw = getSwitch(dpid);
+ if (sw != null) {
+ return sw.getPort(number);
+ }
+ return null;
+ }
+
+ @Override
+ public Link getOutgoingLink(Long dpid, Long number) {
+ return outgoingLinks.get(new SwitchPort(dpid, number.shortValue()));
+ }
+
+ @Override
+ public Link getIncomingLink(Long dpid, Long number) {
+ return incomingLinks.get(new SwitchPort(dpid, number.shortValue()));
+ }
+
+ @Override
+ public Link getLink(Long srcDpid, Long srcNumber, Long dstDpid,
+ Long dstNumber) {
+ Link link = getOutgoingLink(srcDpid, srcNumber);
+ if (link == null) {
+ return null;
+ }
+ if (!link.getDstSwitch().getDpid().equals(dstDpid)) {
+ return null;
+ }
+ if (!link.getDstPort().getNumber().equals(dstNumber)) {
+ return null;
+ }
+ return link;
+ }
+
+ @Override
+ public Iterable<Link> getLinks() {
+ return Collections.unmodifiableCollection(outgoingLinks.values());
+ }
+
+ protected void putLink(Link link) {
+ outgoingLinks.put(link.getSrcPort().asSwitchPort(), link);
+ incomingLinks.put(link.getDstPort().asSwitchPort(), link);
+ }
+
+ protected void removeLink(Link link) {
+ outgoingLinks.remove(link.getSrcPort().asSwitchPort(), link);
+ incomingLinks.remove(link.getDstPort().asSwitchPort(), link);
+ }
+
+ @Override
+ public Device getDeviceByMac(MACAddress address) {
+ return mac2Device.get(address);
+ }
+
+ @Override
+ public Iterable<Device> getDevices() {
+ return Collections.unmodifiableCollection(mac2Device.values());
+ }
+
+ protected void putDevice(Device device) {
+ mac2Device.put(device.getMacAddress(), device);
+ }
+
+ protected void removeDevice(Device device) {
+ mac2Device.remove(device.getMacAddress());
+ }
+
+ @Override
+ public void acquireReadLock() {
+ readLock.lock();
+ }
+
+ @Override
+ public void releaseReadLock() {
+ readLock.unlock();
+ }
+
+ protected void acquireWriteLock() {
+ writeLock.lock();
+ }
+
+ protected void releaseWriteLock() {
+ writeLock.unlock();
+ }
+}