concat(trg,src..) log
2666
public void logConcat(String trg, String [] srcs, long timestamp) {
    ConcatDeleteOp op = ConcatDeleteOp.getInstance();
    op.set(trg, srcs, timestamp);
    logEdit(op);
  }
104576
def text_concat(*args, **kwargs):
    
    separator = text_value(kwargs.get("separator", ""))
    values = filter(None, [text_value(v) for v in args])
    return separator.join(values)
652219
function concatFooter() {
	if (argv.footer) {
		return Promise.resolve().then(() => {
			concat.add(null, require(path.join(process.cwd(), argv.footer)));
			return log('footer', `Concat footer from ${argv.footer}`);
		});
	}
	return Promise.resolve();
}
476953
function writeShell(grunt, options, src, cwd, argArr) {
  let dir = options.writeShell;

  if (grunt.file.isFile(options.writeShell)) {
    dir = path.dirname(options.writeShell);
  }

  const gf = path.basename(src.toLowerCase(), path.extname(src));
  const base = path.join(dir, options.target + '__' + gf);

  const _ = grunt.util._;
  const gruntCli = (_.isUndefined(options.gruntCli) || _.isNull(options.gruntCli)) ? 'grunt' : options.gruntCli;

  // beh
  const shPath = base + '.sh';
  const shContent = [
    '#!/bin/bash',
    '',
    'cd ' + path.resolve(cwd),
    gruntCli + ' ' + argArr.join(' '),
    ''
  ].join('\n');
  grunt.file.write(shPath, shContent);

  //TODO chmod the shell-script?

  // semi broken
  const batPath = base + '.bat';
  const batContent = [
    'set PWD=%~dp0',
    'cd ' + path.resolve(cwd),
    gruntCli + ' ' + argArr.join(' '),
    'cd "%PWD%"',
    ''
  ].join('\r\n');
  grunt.file.write(batPath, batContent);

  console.log('argArr: ' + argArr.join(' '));
}
1088558
function concatenateAndWriteFile(files, destination, separator) {
			if (!destination || !files || !files.length) return;

			files = _.map(files, process);

			var src = files.join(separator || grunt.util.linefeed);
			grunt.file.write(destination, src);
			grunt.log.writeln('File ' + destination.cyan + ' created.');
		}
1117444
def concat(self, operand, start=0, end=0, offset=0):
        """"""
        if not Gauged.map_concat(self.ptr, operand.ptr, start, end, offset):
            raise MemoryError
161263
def logWrite(self, string):
		""""""
		logFile = open(self.logFile, 'at')
		logFile.write(string + '\n')
		logFile.close()
210785
function log() {
  var _console;

  for (var _len = arguments.length, msgs = Array(_len), _key = 0; _key < _len; _key++) {
    msgs[_key] = arguments[_key];
  }

  (_console = console).log.apply(_console, _toConsumableArray(['' + _config2.default.name].concat(msgs)));
}
1134009
function writeLog(level, msg) {
  var line;
  if(showSourceInfo) {
    var si = getSourceInfo();
    if (includeDate) {
      line = util.format("[%s] <%s>\t[%s:%s] %s", moment().format(), level, si.file, si.lineNumber, msg);
    } else {
      line = util.format("<%s>\t[%s:%s] %s", level, si.file, si.lineNumber, msg);
    }
  } else {
    if (includeDate) {
      line = util.format("[%s] <%s>\t%s", moment().format(), level, msg);
    } else {
      line = util.format("<%s>\t%s", level, msg);
    }
  }

  line += '\n';
  appenders.forEach(function(appender) {
    appender(level, line);
  });
}
603171
@Override
  public void concat(Path trg, Path[] psrcs) throws IOException {
    logger.atFine().log("GHFS.concat: %s, %s", trg, lazy(() -> Arrays.toString(psrcs)));

    checkArgument(psrcs.length > 0, "psrcs must have at least one source");

    URI trgPath = getGcsPath(trg);
    List<URI> srcPaths = Arrays.stream(psrcs).map(this::getGcsPath).collect(toImmutableList());

    checkArgument(!srcPaths.contains(trgPath), "target must not be contained in sources");

    List<List<URI>> partitions =
        Lists.partition(srcPaths, GoogleCloudStorage.MAX_COMPOSE_OBJECTS - 1);
    logger.atFine().log("GHFS.concat: %s, %d partitions", trg, partitions.size());
    for (List<URI> partition : partitions) {
      // We need to include the target in the list of sources to compose since
      // the GCS FS compose operation will overwrite the target, whereas the Hadoop
      // concat operation appends to the target.
      List<URI> sources = Lists.newArrayList(trgPath);
      sources.addAll(partition);
      logger.atFine().log("GHFS.concat compose: %s, %s", trgPath, sources);
      getGcsFs().compose(sources, trgPath, CreateFileOptions.DEFAULT_CONTENT_TYPE);
    }
    logger.atFine().log("GHFS.concat:=> ");
  }
1198441
function concat(buffers) {
  var size = 0;
  for (var i = 0; i < buffers.length; i++) {
    size += buffers[i].length;
  }

  var concatenated = new Buffer(size);
  for (var cursor = 0, j = 0; j < buffers.length; cursor += buffers[j].length, j++) {
    buffers[j].copy(concatenated, cursor);
  }

  return concatenated;
}
1076888
def grep_log(self, expr, filename='system.log', from_mark=None):
        
        matchings = []
        pattern = re.compile(expr)
        with open(os.path.join(self.get_path(), 'logs', filename)) as f:
            if from_mark:
                f.seek(from_mark)
            for line in f:
                m = pattern.search(line)
                if m:
                    matchings.append((line, m))
        return matchings
200665
def p_concat(self, p):
        ''
        p[0] = Concat(p[2], lineno=p.lineno(1))
        p.set_lineno(0, p.lineno(1))
514050
def _concat(prefix, list, suffix, env, f=lambda x: x, target=None, source=None):
    
    if not list:
        return list

    l = f(SCons.PathList.PathList(list).subst_path(env, target, source))
    if l is not None:
        list = l

    return _concat_ixes(prefix, list, suffix, env)
268037
function appendToLogs(level, args) {
      if (!args) return;

      var message = toDebugString(args);
      if (message.length <= 2) return;

      _logs.push(
        [level, formatDateStamp(), message]
      );
    }
318417
public static function concat()
    {
        $args = func_get_args();
        $separator = array_shift($args);

        $output = null;
        foreach ($args as $string) {
            $output .= $string . $separator;
        }

        $output = rtrim($output, $separator);
        return $output;
    }
802645
function log () {
    if (argv.stdin && argv.fix) {
      arguments[0] = opts.cmd + ': ' + arguments[0]
      console.error.apply(console, arguments)
    } else {
      console.log.apply(console, arguments)
    }
  }