Get already configured Domain object by name.

@return Domain
339025
public function getDomain($domainName)
    {
        if (isset($this->domainMap[$domainName])) {
            return $this->domainMap[$domainName];
        }

        return null; // just to be explicit
    }
1024867
public static function getInstance() {

		if( !isset( self::$instance ) ) {

			self::$instance	= new GoogleProperties();

			self::$instance->init( SnsConnectGlobal::CONFIG_SNS_GOOGLE );
		}

		return self::$instance;
	}
196547
public static function checkDomain()
	{
		$domain = Config::get('@.DOMAIN');
		return empty($domain) || !Config::get('@.FILTER_DOMAIN') || $domain === Request::server('HTTP_HOST');
	}
34373
public function getBind($domain = null)
    {
        if (is_null($domain)) {
            $domain = $this->domain;
        } elseif (true === $domain) {
            return $this->bind;
        } elseif (false === strpos($domain, '.')) {
            $domain .= '.' . $this->request->rootDomain();
        }

        $subDomain = $this->getSubDomain();

        if (strpos($subDomain, '.')) {
            $name = '*' . strstr($subDomain, '.');
        }

        if (isset($this->bind[$domain])) {
            $result = $this->bind[$domain];
        } elseif (isset($name) && isset($this->bind[$name])) {
            $result = $this->bind[$name];
        } elseif (isset($this->bind['*'])) {
            $result = $this->bind['*'];
        } else {
            $result = null;
        }

        return $result;
    }
269182
public static function getDomain()
    {
        $domain=self::getAppDomain();
        $arr=explode(".", $domain);
        $c=count($arr);
        $root="";
        if($c>0)$root=$arr[$c-1];
        if($c>1)$root=$arr[$c-2].".".$root;
        if(strpos($root, ":")){
            $root=substr($root, 0,strpos($root, ":"));
        }
        return $root;
    }
206367
public function getComponentIdentifier($name, $domain = null)
    {
        if(!isset($domain)) {
            $domain = $this->getComponentDomain($name);
        }

        if($domain) {
            $hash = 'com://'.$domain.'/'.$name;
        } else {
            $hash = 'com:'.$name;
        }

        return $hash;
    }
1189012
def get_existing_domain(conn, name)
      return conn.lookup_domain_by_name(name)
    rescue Libvirt::Error => e
      return nil if e.libvirt_code == 42 # If domain not defined
      raise # Otherwise reraise
    end
861024
public function getDomainMapper()
    {
        if (null === $this->domainMapper) {
            $this->domainMapper = $this->serviceLocator->get('playgroundflow_domain_mapper');
        }

        return $this->domainMapper;
    }
1257790
public function domain($domain = null)
    {
        if (func_num_args() === 0) {
            return $this->_data['domain'];
        }
        return $this->_data['domain'] = $domain === null ?  $domain : (string) $domain;
    }
1248495
public function domain($domain = null)
    {
        if (is_null($domain)) {
            return $this->getDomain();
        }

        $this->action['domain'] = $domain;

        return $this;
    }
831250
private function getInstance()
    {
        if (is_null($this->instance)) {
            $this->instance = \RegexGuard\Factory::getGuard();
        }
        
        return $this->instance;
    }
299408
public function getDomains()
    {
        $res = $this->doRequest('GET_DOMAINS');
        if (!$res) {
            return false;
        }

        $domains = array();

        for ($i = 1; $i <= $res['domains']; ++$i) {
            $dom = 'domain'.$i;
            $classes = array();

            // Associate classes to current domain (class name => mindevcount)
            for ($j = 1; $j <= $res[$dom.'classes']; ++$j) {
                $classes[$res[$dom.'class'.$j.'name']] = $res[$dom.'class'.$j.'mindevcount'];
            }

            $domains[] = array('name' => $res[$dom], 'classes' => $classes);
        }

        return $domains;
    }
906210
public function getConnection($domain = null)
    {
        $domain = $domain ?: $this->context;
        $this->validateDomainName($domain);

        if (!$this->connections[$domain]) {
            $this->connections[$domain] = new LdapConnection(
                $this->domains[$domain],
                $this->config->getEventDispatcher(),
                $this->config->getLogger(),
                $this->getCache()
            );
        }

        return $this->connections[$domain];
    }
632833
public function getDomain()
    {
        $returnValue = null;
        if (is_null($this->domain)){
        	$this->domain = new core_kernel_classes_ContainerCollection(new common_Object(__METHOD__));
			$domainValues = $this->getPropertyValues($this->getProperty(OntologyRdfs::RDFS_DOMAIN));
			foreach ($domainValues as $domainValue){
				$this->domain->add($this->getClass($domainValue));
			}
		}
		$returnValue = $this->domain;
        

        return $returnValue;
    }
1162292
protected function getDomains() {
        if (!$this->_domains) {
            $this->_domains = new DomainList($this->version, $this->solution['accountSid']);
        }

        return $this->_domains;
    }
232176
public function getDomain()
    {
        $result = $this->host;
        if(null !== $this->port)
        {
            $result .= ':' . $this->port;
        }
        return $result;
    }
1021300
public function getByName($domainName)
    {
        $domain = $this->adapter->get(sprintf('%s/domains/%s', $this->endpoint, $domainName));

        $domain = json_decode($domain);

        return new DomainEntity($domain->domain);
    }