Returns a list of all the terminals connecter to this terminal through its wires.
@method getConnectedTerminals
@return  {Array}  List of all connected terminals
773578
function() {
      var terminalList = [];
      if(this.wires) {
         for(var i = 0 ; i < this.wires.length ; i++) {
            terminalList.push(this.wires[i].getOtherTerminal(this));
         }
      }
      return terminalList;
   }
750945
def connections(self):
        
        conn = lambda x: str(x).replace('connection:', '')
        return [conn(name) for name in self.sections()]
307605
async function listConnections() {
    const connList = await executeCommand(
        ['nmcli', '-f', 'NAME,DEVICE', '-t', 'connection', 'show']);
    const ret = {};
    connList.split('\n').map((l) => {
        return l.split(/:/);
    }).filter((ary) => {
        return ary[0] && ary[1];
    }).forEach((ary) => {
        ret[ary[0]] = ary[1];
    });
    return ret;
}
1208336
public List<N> getConnectedComponents() {
        setMarkedAllNodes(false);
        ArrayList<N> roots = new ArrayList<N>();
        //for (int i=0; i<nodes.size(); i++) {
        for (N n : nodes) {
            if (!n.isMarked()) {
                roots.add(n);
                dfs(n);
            }
        }
        return roots;
    }
1050332
public java.util.List<String> getConnectIps() {
        if (connectIps == null) {
            connectIps = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return connectIps;
    }
1345878
private static List<ConnectionNotation> getAllSelfCycleConnections(List<ConnectionNotation> connections) {
    List<ConnectionNotation> listSelfCycle = new ArrayList<ConnectionNotation>();
    for (ConnectionNotation connection : connections) {
      if ((connection.getTargetId().getId().equals(connection.getSourceId().getId()))) {
        listSelfCycle.add(connection);
      }
    }
    return listSelfCycle;
  }
284757
function listNetInterfaces() {
    return new Promise((ac, rj) => {
        exec('nmcli d', (err, stdout, stderr) => {
            const lines = stdout.split('\n');
            if (err || lines.length<2) {
                rj({error: 'No network available.'});
                return;
            }

            lines.shift();
            // Correct visible APs should be listed
            let bWlanExist = false;
            const interfaces = [];
            lines.forEach((line)=>{
                let sp = line.trim().split(/\s+/);
                if (sp.length < 4 || sp[0]=='lo') return; // Illegally formatted line
                if (sp[0].indexOf('wlan')==0) bWlanExist = true;
                interfaces.push(sp[0]);
            });

            ac([interfaces, bWlanExist]);
        });
    });
}
78494
public List<ConnectionDefinitionType<OutboundResourceadapterType<T>>> getAllConnectionDefinition()
   {
      List<ConnectionDefinitionType<OutboundResourceadapterType<T>>> list = new ArrayList<ConnectionDefinitionType<OutboundResourceadapterType<T>>>();
      List<Node> nodeList = childNode.get("connection-definition");
      for(Node node: nodeList)
      {
         ConnectionDefinitionType<OutboundResourceadapterType<T>>  type = new ConnectionDefinitionTypeImpl<OutboundResourceadapterType<T>>(this, "connection-definition", childNode, node);
         list.add(type);
      }
      return list;
   }
727184
function allConnect(){
    Object.keys(KMMotorOneBLE.motors).forEach((key)=>{
        let motor=KMMotorOneBLE.motors[key];
        //モーターの接続
        if(!motor.isConnect){
            motor.connect();
        }
    });
}
1313862
def switches(self):
        
        if not self.__switches:
            self.__switches = Switches(self.__connection)
        return self.__switches
1174499
List<Object> getConnections(ConnectionListener cl)
   {
      List<Object> l = null;

      if (clToC != null)
         l = clToC.get(cl);

      if (l == null)
         l = Collections.emptyList();
         
      return Collections.unmodifiableList(l);
   }
152916
def getconnections(self, vhost = None):
        ""
        if vhost is None:
            return list(self.managed_connections)
        else:
            return [c for c in self.managed_connections if c.protocol.vhost == vhost]
343369
function getList() {
  if(!COMMAND_LIST) {
    COMMAND_LIST = [];
    for(var z in this.execs) {
      COMMAND_LIST.push(this.execs[z].definition.getDefinition());
    }
  }
  return COMMAND_LIST;
}
1053244
public ActiveTunnel[] getLocalForwardingTunnels() throws IOException {
		Vector<ActiveTunnel> v = new Vector<ActiveTunnel>();
		String[] localForwardings = getLocalForwardings();
		for (int i = 0; i < localForwardings.length; i++) {
			ActiveTunnel[] tmp = getLocalForwardingTunnels(localForwardings[i]);
			for (int x = 0; x < tmp.length; x++) {
				v.add(tmp[x]);
			}
		}

		return (ActiveTunnel[]) v.toArray(new ActiveTunnel[v.size()]);
	}
163642
public static Collection<NetworkInterface> getNetworkInterfaces() {
		Enumeration<NetworkInterface> networkInterfaces = null;
		try {
			networkInterfaces = NetworkInterface.getNetworkInterfaces();
		} catch (SocketException e) {
			return null;
		}

		return CollectionUtil.addAll(new ArrayList<NetworkInterface>(), networkInterfaces);
	}
1072222
def connected_outports(self):
        '''

        '''
        return [p for p in self.ports \
                    if p.__class__.__name__ == 'DataOutPort' \
                    and p.is_connected]
129687
function getAllGroups(connections, options, cb) {
  var conn = connections.mongooseConnection;
  var groupsModel = models.get(conn, models.MODELNAMES.GROUPS);
  groupsModel.find().exec(function(err, groupsList) {
    if (err) {
      return cb(err);
    }
    return cb(null, groupsList || []); // Note: purposely returning empty array here for now, maybe this should be null instead?
  });
}