Writes the start of the class.
771558
public function ClassStart() {
        $output = $this->_CRLF . "class " . ucfirst($this->className) . " extends " . $this->baseClass . " {" . $this->_LF;
        fwrite($this->writer, $output);
    }
767523
private function _processClassStart() {
		$this->_inClass = true;
		$this->_classLevel = $this->statementStack->count();

		// Check the position of the open curly after the class declaration
		if ($this->_isActive('classOpenCurly')) {
			$pos = $this->_config->getTestProperty('classOpenCurly', 'position');

			$currentToken = $this->tokenizer->getCurrentToken();
			$previousToken = $this->tokenizer->peekPrvsValidToken();

			if ($pos === NEW_LINE) {
				// The previous token should be on the previous line
				$isPosOk = ($previousToken->line < $currentToken->line);
			} else {
				// The previous token should be on the same line
				$isPosOk = ($previousToken->line === $currentToken->line);
			}

			if (!$isPosOk) {
				$tmp = ($pos === SAME_LINE) ? "the previous line." : "a new line.";
				$msg = $this->_getMessage('LEFT_CURLY_POS', $tmp);
				$this->_writeError('classOpenCurly', $msg);
			}
		}
	}
827299
public synchronized void start() {
		if ((todoFlags & RECORD_CPUTIME) != 0) {
			currentStartCpuTime = getThreadCpuTime(threadId);
		} else {
			currentStartCpuTime = -1;
		}
		if ((todoFlags & RECORD_WALLTIME) != 0) {
			currentStartWallTime = System.nanoTime();
		} else {
			currentStartWallTime = -1;
		}
		isRunning = true;
	}
99481
def WriteInit(self, out):
        """"""
        printer = self._GetPrinter(out)
        if self.__init_wildcards_file:
            printer('"""Common imports for generated %s client library."""',
                    self.__client_info.package)
            printer('# pylint:disable=wildcard-import')
        else:
            printer('"""Package marker file."""')
        printer()
        printer('import pkgutil')
        printer()
        if self.__init_wildcards_file:
            printer('from %s import *', self.__base_files_package)
            if self.__root_package == '.':
                import_prefix = ''
            else:
                import_prefix = '%s.' % self.__root_package
            printer('from %s%s import *',
                    import_prefix, self.__client_info.client_rule_name)
            printer('from %s%s import *',
                    import_prefix, self.__client_info.messages_rule_name)
            printer()
        printer('__path__ = pkgutil.extend_path(__path__, __name__)')
1120719
public void writeLoaderClasses() throws IOException {
        URL loaderJar = getClass().getClassLoader().getResource(NESTED_LOADER_JAR);
        JarInputStream inputStream = new JarInputStream(
                new BufferedInputStream(loaderJar.openStream()));
        JarEntry entry;
        while ((entry = inputStream.getNextJarEntry()) != null) {
            if (entry.getName().endsWith(".class")) {
                writeEntry(entry, new InputStreamEntryWriter(inputStream, false));
            }
        }
        inputStream.close();
    }
683775
public function start() {
        if ($this->running === true) {
            throw new xml_writer_exception('xml_writer_already_started');
        }
        if ($this->running === false) {
            throw new xml_writer_exception('xml_writer_already_stopped');
        }
        $this->output->start(); // Initialize whatever we need in output
        if (!is_null($this->prologue)) { // Output prologue
            $this->write($this->prologue);
        } else {
            $this->write($this->get_default_prologue());
        }
        $this->running = true;
    }
958057
def simple_write(self, s, frame, node=None):
        """"""
        self.start_write(frame, node)
        self.write(s)
        self.end_write(frame)
1072946
private function initialiseForWriting()
    {
        // move to the end of the file to always append
        fseek($this->stream, 0, SEEK_END);

        if (ftell($this->stream) === 0) {
            fwrite($this->stream, $this->formatter->getInitialBlock());
        } elseif (strlen($this->formatter->getClosingBlock()) > 0) {
            $endBlock = $this->formatter->getClosingBlock();
            fseek($this->stream, strlen($endBlock) * -1, SEEK_CUR);
            fwrite($this->stream, $this->formatter->getRowSeparator());
        } elseif (strlen($this->formatter->getRowSeparator()) > 0) {
            fwrite($this->stream, $this->formatter->getRowSeparator());
        }
    }
105251
@Override
  public synchronized void start() {
    if (isStarted()) {
      return;
    }
    MonitoredResource resource = getMonitoredResource(getProjectId());
    defaultWriteOptions =
        new WriteOption[] {WriteOption.logName(getLogName()), WriteOption.resource(resource)};
    getLogging().setFlushSeverity(severityFor(getFlushLevel()));
    loggingEnhancers = new ArrayList<>();
    List<LoggingEnhancer> resourceEnhancers = MonitoredResourceUtil.getResourceEnhancers();
    loggingEnhancers.addAll(resourceEnhancers);
    loggingEnhancers.addAll(getLoggingEnhancers());
    loggingEventEnhancers = new ArrayList<>();
    loggingEventEnhancers.addAll(getLoggingEventEnhancers());

    super.start();
  }
760326
private function write()
    {
        ftruncate($this->handle, 0);
        rewind($this->handle);

        fwrite($this->handle, serialize($this->data));
    }
369377
private void init() {
        writers.put(Boolean.class, new BooleanDataWriter());
        writers.put(Calendar.class, new CalendarDataWriter());
        writers.put(Date.class, new DateDataWriter());
        writers.put(Enum.class, new EnumDataWriter());
        writers.put(Number.class, new NumberDataWriter());
        writers.put(String.class, new StringDataWriter());
    }
1201467
public void start()
    {
        pen.start();
        try
        {
            cache.start();
        }
        catch ( Exception e )
        {
            ThreadUtils.checkInterrupted(e);
            Throwables.propagate(e);
        }
    }
1080039
@Override
  public void write(JsonWriter writer, SpeechTimestamp speechTimestamp) throws IOException {
    writer.beginArray();

    writer.value(speechTimestamp.getWord());
    writer.value(speechTimestamp.getStartTime());
    writer.value(speechTimestamp.getEndTime());

    writer.endArray();
    writer.flush();
  }
735337
def start_output (self):
        """"""
        super(CSVLogger, self).start_output()
        row = []
        if self.has_part("intro"):
            self.write_intro()
            self.flush()
        else:
            # write empty string to initialize file output
            self.write(u"")
        self.queue = StringIO()
        self.writer = csv.writer(self.queue, dialect=self.dialect,
               delimiter=self.separator, lineterminator=self.linesep,
               quotechar=self.quotechar)
        for s in Columns:
            if self.has_part(s):
                row.append(s)
        if row:
            self.writerow(row)
837640
function start_output() {
        $this->started_output = true;
        if ($this->exportclass!==null) {
            $this->exportclass->start_table($this->sheettitle);
            $this->exportclass->output_headers($this->headers);
        } else {
            $this->start_html();
            $this->print_headers();
            echo html_writer::start_tag('tbody');
        }
    }
797373
public void writeStartObject(String name) throws IOException
   {
      writeComma();
      writeNewLineIndent();

      if (name != null)
      {
         writeName(name);
         writeNewLineIndent();
      }

      m_writer.write("{");
      increaseIndent();
   }
779138
private void writeStartSequence(IXADataRecorder dataRecorder)
			throws IOException, InterruptedException {

		LogRecordWriter writer = new LogRecordWriter();
		writer.writeLong(dataRecorder.getXADataRecorderId());
		dataRecorder.writeRollbackData(writer.toByteArray());
	}