Creates a domain through specialization by constraint

 @param [Class] super_domain
   the super_domain of the factored domain
 @param [Proc] pred
   the domain predicate

 @return [Class]
   the created domain as a ruby Class

 @api public
771011
def sbyc(super_domain = Object, &pred)
      Class.new(super_domain){ extend SByC.new(super_domain, pred) }
    end
868506
@Trace(dispatcher = true)
	public Domain createReverseDomain(String name, Long templateId, String authorityType) throws GloboDnsException {
		NewRelic.setTransactionName(null, "/globodns/createReverseDomain");
		return this.createDomain(name, templateId, authorityType, true);
	}
33804
function(SuperC, args) {
		args = this._breakdown_subs(args);
		return this._extendclass(
			SuperC,
			args.protos,
			args.recurring,
			args.statics,
			args.name
		);
	}
208571
def create(server_context, domain_definition, container_path=None):
    # type: (ServerContext, dict, str) -> Domain
    
    url = server_context.build_url('property', 'createDomain.api', container_path=container_path)

    headers = {
        'Content-Type': 'application/json'
    }

    domain = None

    raw_domain = server_context.make_request(url, json_dumps(domain_definition), headers=headers)

    if raw_domain is not None:
        domain = Domain.from_data(raw_domain)

    return domain
559432
function domain() {
        return wrap('domain', function domainCheckTLD() {
            var result = or(obsDomain, dotAtom, domainLiteral)();
            if (opts.rejectTLD) {
                if (result && result.semantic && result.semantic.indexOf('.') < 0) {
                    return null;
                }
            }
            // strip all whitespace from domains
            if (result) {
                result.semantic = result.semantic.replace(/\s+/g, '');
            }
            return result;
        }());
    }
864667
function _gpfGenSuperMember (superMethod, method) {
    return function GpfSuperableMethod () {
        var previousSuper = this._super,
            result;
        // Add a new ._super() method pointing to the base class member
        this._super = superMethod;
        try {
            // Execute the method
            result = method.apply(this, arguments);
        } finally {
            // Remove it after execution
            if (undefined === previousSuper) {
                delete this._super;
            } else {
                this._super = previousSuper;
            }
        }
        return result;
    };
}
170059
def do_super(parser, token):
    '''
    
    '''
    name = token.strip()
    return ast.YieldFrom(
        value=_a.Call(_a.Attribute(_a.Call(_a.Name('super')), name), [
            # _a.Attribute(_a.Name('context'), 'parent'),
            _a.Name('context'),
        ])
    )
1229962
public function createDomainAction(Domain $domain)
    {
        $this->domainRepository->add($domain);
        $this->addFlashMessage('The domain "%s" has been created.', 'Domain created', Message::SEVERITY_OK, [htmlspecialchars($domain)], 1412373192);
        $this->unsetLastVisitedNodeAndRedirect('edit', null, null, ['site' => $domain->getSite()]);
    }
799512
public function addPreinitDomain($domain) {
		$domain = (string) $domain;
		
		if (in_array($domain, $this->preinitDomains, true)) {
			return $this;
		}
		
		$this->preinitDomains[] = $domain;
		$this->preinitNeed      = true;
		
		return $this;
	}
726520
def call(env)
      # Create a method called domain which will return the current domain
      # name
      Rails.application.send :define_singleton_method, 'domain_name' do
        env['SERVER_NAME']
      end

      # Create `fetch_domain` method on `Rails.application`
      # only if it didn't already define.
      unless Rails.application.respond_to? :fetch_domain
        Rails.application.send :define_singleton_method, 'fetch_domain' do
          if defined? ActiveRecord
            Domain.find_by(nam: Rails.application.domain_name)
          elsif defined? Mongoid
            Site.where('domains.name' => Rails.application.domain_name).domains.first
          end
        end
      end

      Rails.application.send :define_singleton_method, 'site' do
        site = nil
        unless Rails.application.domain.nil?
          site = Rails.application.domain.site
        end
        site
      end

      Rails.application
      @app.call(env)
    end
958363
def subdomain?(*jids)
      !jids.flatten.index do |jid|
        !component?(jid) && !pubsub?(jid)
      end
    end
594013
def domain_name=(domain_name)
      if domain_name.nil?
        fail ArgumentError, "domain_name cannot be nil"
      end

      if domain_name.to_s.length > 255
        fail ArgumentError, "invalid value for 'domain_name', the character length must be smaller than or equal to 255."
      end

      if domain_name.to_s.length < 1
        fail ArgumentError, "invalid value for 'domain_name', the character length must be great than or equal to 1."
      end

      @domain_name = domain_name
    end
39498
def create(cls, this: str, super_: str=u'java/lang/Object') -> 'ClassFile':
        
        cf = ClassFile()
        cf.access_flags.acc_public = True
        cf.access_flags.acc_super = True

        cf.this = cf.constants.create_class(this)
        cf.super_ = cf.constants.create_class(super_)

        return cf
765333
def create(cls, domain, tlp_level=0, tags=[]):
        
        return cls._create(domain=domain, tlp_level=tlp_level, tags=tags)
1118182
def inheritance_tree(include_mods = false)
      list = (include_mods ? mixins(:instance, :class) : [])
      if superclass.is_a?(Proxy) || superclass.respond_to?(:inheritance_tree)
        list += [superclass] unless superclass == P(:Object) || superclass == P(:BasicObject)
      end
      [self] + list.map do |m|
        next m if m == self
        next m unless m.respond_to?(:inheritance_tree)
        m.inheritance_tree(include_mods)
      end.flatten.uniq
    end
1067792
def super_(dev):
    '''
    

    '''
    dev = _devpath(dev)
    ret = {}

    res = _run_all('bcache-super-show {0}'.format(dev), 'error', 'Error reading superblock on {0}: %s'.format(dev))
    if not res:
        return False

    for line in res.splitlines():  # pylint: disable=no-member
        line = line.strip()
        if not line:
            continue

        key, val = [val.strip() for val in re.split(r'[\s]+', line, maxsplit=1)]
        if not (key and val):
            continue

        mval = None
        if ' ' in val:
            rval, mval = [val.strip() for val in re.split(r'[\s]+', val, maxsplit=1)]
            mval = mval[1:-1]
        else:
            rval = val

        try:
            rval = int(rval)
        except Exception:
            try:
                rval = float(rval)
            except Exception:
                if rval == 'yes':
                    rval = True
                elif rval == 'no':
                    rval = False

        pkey, key = re.split(r'\.', key, maxsplit=1)
        if pkey not in ret:
            ret[pkey] = {}

        if mval is not None:
            ret[pkey][key] = (rval, mval)
        else:
            ret[pkey][key] = rval

    return ret
2295
def is_superdomain(self, other):
        

        (nr, o, nl) = self.fullcompare(other)
        if nr == NAMERELN_SUPERDOMAIN or nr == NAMERELN_EQUAL:
            return True
        return False