domain          =   dot-atom / domain-literal / obs-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;
        }());
    }
150052
def domain
      components = rdns.map {|rdn| rdn[:dc]}.compact
      components.join('.') unless components.empty?
    end
781215
function dnToDomain (dn) {
  if (!dn || typeof dn !== 'string') { return null }
  var matches = domainDnRegex.exec(dn)
  if (matches) {
    return matches[1].replace(dnPartRegex, '$1.').toLowerCase()
  } else {
    return null
  }
}
613992
function obsFws() {
        return opts.strict ? null : wrap('obs-FWS', star(
            and(invis(opt(crlf)), wsp),
            1
        )());
    }
263779
def _domain_event_metadata_change_cb(conn, domain, mtype, nsuri, opaque):
    '''
    
    '''
    _salt_send_domain_event(opaque, conn, domain, opaque['event'], {
        'type': _get_libvirt_enum_string('VIR_DOMAIN_METADATA_', mtype),
        'nsuri': nsuri
    })
1042623
def p_domain_block(self, p):
        ''''''
        d = Domain(p[2], p[4], p[5])
        p[0] = ('domain', d)
958363
def subdomain?(*jids)
      !jids.flatten.index do |jid|
        !component?(jid) && !pubsub?(jid)
      end
    end
883126
function (domain, poString, verbose) {
        if (typeof verbose === 'undefined') {
            verbose = false;
        }

        var normalizedDomain = gt._normalizeDomain(domain);
        gt.addTextdomain(domain, poString);
        var poDomain = gt.domains[normalizedDomain];
        var language = poDomain.headers.language;
        var options = {};

        if (language && domain != language && verbose) {
            process.stdout.write('domain specified does not match language specified in po file.\n');
        }

        var icuObject = {};
        var self = this;
        Object.keys(poDomain['translations']['']).forEach(function (key) {
            var msg = poDomain['translations'][''][key];
            if (msg.msgid.length > 0) {
                var icuMsg = null;
                if (msg.comments !== undefined) {
                    options.poFormat = msg.comments.flag;
                }
                if (msg.msgid_plural !== undefined) {
                    try {
                        icuMsg = self.pluralMsgToICU(msg, domain, options);
                    } catch (err) {
                        // msg is undefined or cannot have regex used against it.
                        if (verbose) {
                            process.stdout.write('Warning: undefined msg encountered for ' + domain + '\n');
                        }
                        icuMsg = '';
                    }
                } else {
                    try {
                        icuMsg = self.msgToICU(msg, options);
                    } catch (err) {
                        // msg is undefined or cannot have regex used against it.
                        if (verbose) {
                            process.stdout.write('Warning: undefined msg encountered for ' + domain + '\n');
                        }
                        icuMsg = '';
                    }
                }
                icuObject[icuMsg['icuId']] = icuMsg['icuStr'];
            }
        });
        return icuObject;
    }
293510
function nodeInjectmd (opts) {
  const inBuf = bl()

  assert.equal(typeof opts, 'object', 'opts should be an object')
  assert.equal(typeof opts.in, 'string', 'opts.in should be a string')
  assert.equal(typeof opts.tag, 'string', 'opts.tag should be a string')

  const inFile = opts.in
  const tag = opts.tag
  const startTag = new RegExp('<!--\\s*START ' + tag + '\\s*-->')
  const endTag = new RegExp('<!--\\s*END ' + tag + '\\s*-->')

  assert.equal(typeof opts, 'object', 'opts must be an object')

  const rs = new stream.PassThrough()

  rs.pipe(inBuf)

  rs.on('end', function () {
    var tagMode = false
    const mdPath = path.join(process.cwd(), inFile)
    const irs = fs.createReadStream(mdPath)
    const its = split(parse)
    const tmpBuf = bl()

    irs.pipe(its).pipe(tmpBuf)

    tmpBuf.on('finish', function () {
      const ws = fs.createWriteStream(inFile, { flags: 'w' })
      const rs = tmpBuf.duplicate()
      rs.pipe(ws)
    })

    function parse (line) {
      if (startTag.test(line.trim())) {
        tagMode = true
        const res = line + EOL + String(inBuf) + EOL
        return res
      } else if (endTag.test(line.trim())) {
        tagMode = false
        return line + EOL
      } else if (!tagMode) {
        return line + EOL
      }
    }
  })

  return rs
}
822254
def domain(word)
      check_params(word)

      arg1 = ['Wort', word]
      answer = query(@cl_Sachgebiet, arg1)

      get_answer(answer)
    end
833595
def to_dotfile(self):
        
        domain = self.get_domain()
        filename = "%s.dot" % (self.__class__.__name__)
        nx.write_dot(domain, filename)
        return filename
415309
def strip_domain(jid)
      domain = jid.domain.split('.').drop(1).join('.')
      JID.new(domain)
    end
748609
@Override
	public List<EcodDomain> getDomainsForPdb(String pdbId) throws IOException {
		domainsFileLock.readLock().lock();
		try {
			logger.trace("LOCK readlock");
			while( domainMap == null ) {
				// unlock to allow ensureDomainsFileInstalled to get the write lock
				logger.trace("UNLOCK readlock");
				domainsFileLock.readLock().unlock();
				indexDomains();
				domainsFileLock.readLock().lock();
				logger.trace("LOCK readlock");
			}

			if(pdbId != null)
				pdbId = pdbId.toLowerCase();
			List<EcodDomain> doms = domainMap.get(pdbId);
			if(doms == null) {
				return null;
			}
			// Deep clone
			List<EcodDomain> clonedDoms = new ArrayList<EcodDomain>(doms.size());
			for(EcodDomain d : doms) {
				clonedDoms.add( new EcodDomain(d) );
			}
			return clonedDoms;
		} finally {
			logger.trace("UNLOCK readlock");
			domainsFileLock.readLock().unlock();
		}
	}
1054857
private void parseDomains() throws IOException {
		domainsFileLock.writeLock().lock();
		logger.trace("LOCK writelock");
		try {
			EcodParser parser = new EcodParser(getDomainFile());
			allDomains = parser.getDomains();
			parsedVersion = parser.getVersion();
		} finally {
			logger.trace("UNLOCK writelock");
			domainsFileLock.writeLock().unlock();
		}
	}
568460
def match(self, dom, act):
        
        return self.match_domain(dom) and self.match_action(act)
766817
@SuppressWarnings("unused") // called through reflection by RequestServer
  public FramesV3 columnDomain(int version, FramesV3 s) {
    Frame frame = getFromDKV("key", s.frame_id.key());
    Vec vec = frame.vec(s.column);
    if (vec == null)
      throw new H2OColumnNotFoundArgumentException("column", s.frame_id.toString(), s.column);
    s.domain = new String[1][];
    s.domain[0] = vec.domain();
    return s;
  }
229181
function(d) {
		"use strict";

		var index = this._domainType[this.options.subDomain].position.x(new Date(d));
		return index * this.options.cellSize + index * this.options.cellPadding;
	}