text:
// flowlint ambiguous-object-type:error

'use strict';

const RelayFeatureFlags = require('../util/RelayFeatureFlags');
const RelayModernRecord = require('./RelayModernRecord');

const invariant = require('invariant');

const {
  CLIENT_EXTENSION,
  CONDITION,
  DEFER,
  FLIGHT_FIELD,
  FRAGMENT_SPREAD,
  INLINE_DATA_FRAGMENT_SPREAD,
  INLINE_FRAGMENT,
  LINKED_FIELD,
  MODULE_IMPORT,
  REQUIRED_FIELD,
  SCALAR_FIELD,
  STREAM,
} = require('../util/RelayConcreteNode');
const {getReactFlightClientResponse} = require('./RelayStoreReactFlightUtils');
const {
  FRAGMENTS_KEY,
  FRAGMENT_OWNER_KEY,
  FRAGMENT_PROP_NAME_KEY,
  ID_KEY,
  IS_WITHIN_UNMATCHED_TYPE_REFINEMENT,
  MODULE_COMPONENT_KEY,
  ROOT_ID,
  getArgumentValues,
  getStorageKey,
  getModuleComponentKey,
} = require('./RelayStoreUtils');
const {generateTypeID} = require('./TypeID');

import type {
  ReaderFlightField,
  ReaderFragmentSpread,
  ReaderInlineDataFragmentSpread,
  ReaderLinkedField,
  ReaderModuleImport,
  ReaderNode,
  ReaderRequiredField,
  ReaderScalarField,
  ReaderSelection,
} from '../util/ReaderNode';
import type {DataID, Variables} from '../util/RelayRuntimeTypes';
import type {
  Record,
  RecordSource,
  RequestDescriptor,
  SelectorData,
  SingularReaderSelector,
  Snapshot,
  MissingRequiredFields,
  DataIDSet,
} from './RelayStoreTypes';

function read(
  recordSource: RecordSource,
  selector: SingularReaderSelector,
): Snapshot {
  const reader = new RelayReader(recordSource, selector);
  return reader.read();
}

/**
 * @private
 */
class RelayReader {
  _isMissingData: boolean;
  _isWithinUnmatchedTypeRefinement: boolean;
  _missingRequiredFields: ?MissingRequiredFields;
  _owner: RequestDescriptor;
  _recordSource: RecordSource;
  _seenRecords: DataIDSet;
  _selector: SingularReaderSelector;
  _variables: Variables;

  constructor(recordSource: RecordSource, selector: SingularReaderSelector) {
    this._isMissingData = false;
    this._isWithinUnmatchedTypeRefinement = false;
    this._missingRequiredFields = null;
    this._owner = selector.owner;
    this._recordSource = recordSource;
    this._seenRecords = new Set();
    this._selector = selector;
    this._variables = selector.variables;
  }

  read(): Snapshot {
    const {node, dataID, isWithinUnmatchedTypeRefinement} = this._selector;
    const {abstractKey} = node;
    const record = this._recordSource.get(dataID);

    // Relay historically allowed child fragments to be read even if the root object
    // did not match the type of the fragment: either the root object has a different
    // concrete type than the fragment (for concrete fragments) or the root object does
    // not conform to the interface/union for abstract fragments.
    // For suspense purposes, however, we want to accurately compute whether any data
    // is missing: but if the fragment type doesn't match (or a parent type didn't
    // match), then no data is expected to be present.

    // By default data is expected to be present unless this selector was read out
    // from within a non-matching type refinement in a parent fragment:
    let isDataExpectedToBePresent = !isWithinUnmatchedTypeRefinement;

    // If this is a concrete fragment and the concrete type of the record does not
    // match, then no data is expected to be present.
    if (isDataExpectedToBePresent && abstractKey == null && record != null) {
      const recordType = RelayModernRecord.getType(record);
      if (recordType !== node.type && dataID !== ROOT_ID) {
        isDataExpectedToBePresent = false;
      }
    }

    // If this is an abstract fragment (and the precise refinement GK is enabled)
    // then data is only expected to be present if the record type is known to
    // implement the interface. If we aren't sure whether the record implements
    // the interface, that itself constitutes "expected" data being missing.
    if (
      isDataExpectedToBePresent &&
      abstractKey != null &&
      record != null &&
      RelayFeatureFlags.ENABLE_PRECISE_TYPE_REFINEMENT
    ) {
      const recordType = RelayModernRecord.getType(record);
      const typeID = generateTypeID(recordType);
      const typeRecord = this._recordSource.get(typeID);
      const implementsInterface =
        typeRecord != null
          ? RelayModernRecord.getValue(typeRecord, abstractKey)
          : null;
      if (implementsInterface === false) {
        // Type known to not implement the interface
        isDataExpectedToBePresent = false;
      } else if (implementsInterface == null) {
        // Don't know if the type implements the interface or not
        this._isMissingData = true;
      }
    }

    this._isWithinUnmatchedTypeRefinement = !isDataExpectedToBePresent;
    const data = this._traverse(node, dataID, null);
    return {
      data,
      isMissingData: this._isMissingData && isDataExpectedToBePresent,
      seenRecords: this._seenRecords,
      selector: this._selector,
      missingRequiredFields: this._missingRequiredFields,
    };
  }

  _traverse(
    node: ReaderNode,
    dataID: DataID,
    prevData: ?SelectorData,
  ): ?SelectorData {
    const record = this._recordSource.get(dataID);
    this._seenRecords.add(dataID);
    if (record == null) {
      if (record === undefined) {
        this._isMissingData = true;
      }
      return record;
    }
    const data = prevData || {};
    const hadRequiredData = this._traverseSelections(
      node.selections,
      record,
      data,
    );
    return hadRequiredData ? data : null;
  }

  _getVariableValue(name: string): mixed {
    invariant(
      this._variables.hasOwnProperty(name),
      'RelayReader(): Undefined variable `%s`.',
      name,
    );
    // $FlowFixMe[cannot-write]
    return this._variables[name];
  }

  _maybeReportUnexpectedNull(
    fieldPath: string,
    action: 'LOG' | 'THROW',
    record: Record,
  ) {
    if (this._missingRequiredFields?.action === 'THROW') {
      // Chained @required directives may cause a parent `@required(action:
      // THROW)` field to become null, so the first missing field we
      // encounter is likely to be the root cause of the error.
      return;
    }
    const owner = this._selector.node.name;

    switch (action) {
      case 'THROW':
        this._missingRequiredFields = {action, field: {path: fieldPath, owner}};
        return;
      case 'LOG':
        if (this._missingRequiredFields == null) {
          this._missingRequiredFields = {action, fields: []};
        }
        this._missingRequiredFields.fields.push({path: fieldPath, owner});
        return;
      default:
        (action: empty);
    }
  }

  _traverseSelections(
    selections: $ReadOnlyArray<ReaderSelection>,
    record: Record,
    data: SelectorData,
  ): boolean /* had all expected data */ {
    for (let i = 0; i < selections.length; i++) {
      const selection = selections[i];
      switch (selection.kind) {
        case REQUIRED_FIELD:
          invariant(
            RelayFeatureFlags.ENABLE_REQUIRED_DIRECTIVES,
            'RelayReader(): Encountered a `@required` directive at path "%s" in `%s` without the `ENABLE_REQUIRED_DIRECTIVES` feature flag enabled.',
            selection.path,
            this._selector.node.name,
          );

          const fieldValue = this._readRequiredField(selection, record, data);
          if (fieldValue == null) {
            const {action} = selection;
            if (action !== 'NONE') {
              this._maybeReportUnexpectedNull(selection.path, action, record);
            }
            // We are going to throw, or our parent is going to get nulled out.
            // Either way, sibling values are going to be ignored, so we can
            // bail early here as an optimization.
            return false;
          }
          break;
        case SCALAR_FIELD:
          this._readScalar(selection, record, data);
          break;
        case LINKED_FIELD:
          if (selection.plural) {
            this._readPluralLink(selection, record, data);
          } else {
            this._readLink(selection, record, data);
          }
          break;
        case CONDITION:
          const conditionValue = this._getVariableValue(selection.condition);
          if (conditionValue === selection.passingValue) {
            const hasExpectedData = this._traverseSelections(
              selection.selections,
              record,
              data,
            );
            if (!hasExpectedData) {
              return false;
            }
          }
          break;
        case INLINE_FRAGMENT: {
          const {abstractKey} = selection;
          if (abstractKey == null) {
            // concrete type refinement: only read data if the type exactly matches
            const typeName = RelayModernRecord.getType(record);
            if (typeName != null && typeName === selection.type) {
              const hasExpectedData = this._traverseSelections(
                selection.selections,
                record,
                data,
              );
              if (!hasExpectedData) {
                return false;
              }
            }
          } else if (RelayFeatureFlags.ENABLE_PRECISE_TYPE_REFINEMENT) {
            // Similar to the logic in read(): data is only expected to be present
            // if the record is known to conform to the interface. If we don't know
            // whether the type conforms or not, that constitutes missing data.

            // store flags to reset after reading
            const parentIsMissingData = this._isMissingData;
            const parentIsWithinUnmatchedTypeRefinement = this
              ._isWithinUnmatchedTypeRefinement;

            const typeName = RelayModernRecord.getType(record);
            const typeID = generateTypeID(typeName);
            const typeRecord = this._recordSource.get(typeID);
            const implementsInterface =
              typeRecord != null
                ? RelayModernRecord.getValue(typeRecord, abstractKey)
                : null;
            this._isWithinUnmatchedTypeRefinement =
              parentIsWithinUnmatchedTypeRefinement ||
              implementsInterface === false;
            this._traverseSelections(selection.selections, record, data);
            this._isWithinUnmatchedTypeRefinement = parentIsWithinUnmatchedTypeRefinement;

            if (implementsInterface === false) {
              // Type known to not implement the interface, no data expected
              this._isMissingData = parentIsMissingData;
            } else if (implementsInterface == null) {
              // Don't know if the type implements the interface or not
              this._isMissingData = true;
            }
          } else {
            // legacy behavior for abstract refinements: always read even
            // if the type doesn't conform and don't reset isMissingData
            this._traverseSelections(selection.selections, record, data);
          }
          break;
        }
        case FRAGMENT_SPREAD:
          this._createFragmentPointer(selection, record, data);
          break;
        case MODULE_IMPORT:
          this._readModuleImport(selection, record, data);
          break;
        case INLINE_DATA_FRAGMENT_SPREAD:
          this._createInlineDataFragmentPointer(selection, record, data);
          break;
        case DEFER:
        case CLIENT_EXTENSION: {
          const isMissingData = this._isMissingData;
          const hasExpectedData = this._traverseSelections(
            selection.selections,
            record,
            data,
          );
          this._isMissingData = isMissingData;
          if (!hasExpectedData) {
            return false;
          }
          break;
        }
        case STREAM: {
          const hasExpectedData = this._traverseSelections(
            selection.selections,
            record,
            data,
          );
          if (!hasExpectedData) {
            return false;
          }
          break;
        }
        case FLIGHT_FIELD:
          if (RelayFeatureFlags.ENABLE_REACT_FLIGHT_COMPONENT_FIELD) {
            this._readFlightField(selection, record, data);
          } else {
            throw new Error('Flight fields are not yet supported.');
          }
          break;
        default:
          (selection: empty);
          invariant(
            false,
            'RelayReader(): Unexpected ast kind `%s`.',
            selection.kind,
          );
      }
    }
    return true;
  }

  _readRequiredField(
    selection: ReaderRequiredField,
    record: Record,
    data: SelectorData,
  ): ?mixed {
    switch (selection.field.kind) {
      case SCALAR_FIELD:
        return this._readScalar(selection.field, record, data);
      case LINKED_FIELD:
        if (selection.field.plural) {
          return this._readPluralLink(selection.field, record, data);
        } else {
          return this._readLink(selection.field, record, data);
        }
      default:
        (selection.field.kind: empty);
        invariant(
          false,
          'RelayReader(): Unexpected ast kind `%s`.',
          selection.kind,
        );
    }
  }

  _readFlightField(
    field: ReaderFlightField,
    record: Record,
    data: SelectorData,
  ): ?mixed {
    const applicationName = field.alias ?? field.name;
    const storageKey = getStorageKey(field, this._variables);
    const reactFlightClientResponseRecordID = RelayModernRecord.getLinkedRecordID(
      record,
      storageKey,
    );
    if (reactFlightClientResponseRecordID == null) {
      data[applicationName] = reactFlightClientResponseRecordID;
      if (reactFlightClientResponseRecordID === undefined) {
        this._isMissingData = true;
      }
      return reactFlightClientResponseRecordID;
    }
    const reactFlightClientResponseRecord = this._recordSource.get(
      reactFlightClientResponseRecordID,
    );
    this._seenRecords.add(reactFlightClientResponseRecordID);
    if (reactFlightClientResponseRecord == null) {
      data[applicationName] = reactFlightClientResponseRecord;
      if (reactFlightClientResponseRecord === undefined) {
        this._isMissingData = true;
      }
      return reactFlightClientResponseRecord;
    }
    const clientResponse = getReactFlightClientResponse(
      reactFlightClientResponseRecord,
    );
    data[applicationName] = clientResponse;
    return clientResponse;
  }

  _readScalar(
    field: ReaderScalarField,
    record: Record,
    data: SelectorData,
  ): ?mixed {
    const applicationName = field.alias ?? field.name;
    const storageKey = getStorageKey(field, this._variables);
    const value = RelayModernRecord.getValue(record, storageKey);
    if (value === undefined) {
      this._isMissingData = true;
    }
    data[applicationName] = value;
    return value;
  }

  _readLink(
    field: ReaderLinkedField,
    record: Record,
    data: SelectorData,
  ): ?mixed {
    const applicationName = field.alias ?? field.name;
    const storageKey = getStorageKey(field, this._variables);
    const linkedID = RelayModernRecord.getLinkedRecordID(record, storageKey);
    if (linkedID == null) {
      data[applicationName] = linkedID;
      if (linkedID === undefined) {
        this._isMissingData = true;
      }
      return linkedID;
    }

    const prevData = data[applicationName];
    invariant(
      prevData == null || typeof prevData === 'object',
      'RelayReader(): Expected data for field `%s` on record `%s` ' +
        'to be an object, got `%s`.',
      applicationName,
      RelayModernRecord.getDataID(record),
      prevData,
    );
    // $FlowFixMe[incompatible-variance]
    const value = this._traverse(field, linkedID, prevData);
    data[applicationName] = value;
    return value;
  }

  _readPluralLink(
    field: ReaderLinkedField,
    record: Record,
    data: SelectorData,
  ): ?mixed {
    const applicationName = field.alias ?? field.name;
    const storageKey = getStorageKey(field, this._variables);
    const linkedIDs = RelayModernRecord.getLinkedRecordIDs(record, storageKey);

    if (linkedIDs == null) {
      data[applicationName] = linkedIDs;
      if (linkedIDs === undefined) {
        this._isMissingData = true;
      }
      return linkedIDs;
    }

    const prevData = data[applicationName];
    invariant(
      prevData == null || Array.isArray(prevData),
      'RelayReader(): Expected data for field `%s` on record `%s` ' +
        'to be an array, got `%s`.',
      applicationName,
      RelayModernRecord.getDataID(record),
      prevData,
    );
    const linkedArray = prevData || [];
    linkedIDs.forEach((linkedID, nextIndex) => {
      if (linkedID == null) {
        if (linkedID === undefined) {
          this._isMissingData = true;
        }
        // $FlowFixMe[cannot-write]
        linkedArray[nextIndex] = linkedID;
        return;
      }
      const prevItem = linkedArray[nextIndex];
      invariant(
        prevItem == null || typeof prevItem === 'object',
        'RelayReader(): Expected data for field `%s` on record `%s` ' +
          'to be an object, got `%s`.',
        applicationName,
        RelayModernRecord.getDataID(record),
        prevItem,
      );
      // $FlowFixMe[cannot-write]
      // $FlowFixMe[incompatible-variance]
      linkedArray[nextIndex] = this._traverse(field, linkedID, prevItem);
    });
    data[applicationName] = linkedArray;
    return linkedArray;
  }

  /**
   * Reads a ReaderModuleImport, which was generated from using the @module
   * directive.
   */
  _readModuleImport(
    moduleImport: ReaderModuleImport,
    record: Record,
    data: SelectorData,
  ): void {
    // Determine the component module from the store: if the field is missing
    // it means we don't know what component to render the match with.
    const componentKey = getModuleComponentKey(moduleImport.documentName);
    const component = RelayModernRecord.getValue(record, componentKey);
    if (component == null) {
      if (component === undefined) {
        this._isMissingData = true;
      }
      return;
    }

    // Otherwise, read the fragment and module associated to the concrete
    // type, and put that data with the result:
    // - For the matched fragment, create the relevant fragment pointer and add
    //   the expected fragmentPropName
    // - For the matched module, create a reference to the module
    this._createFragmentPointer(
      {
        kind: 'FragmentSpread',
        name: moduleImport.fragmentName,
        args: null,
      },
      record,
      data,
    );
    data[FRAGMENT_PROP_NAME_KEY] = moduleImport.fragmentPropName;
    data[MODULE_COMPONENT_KEY] = component;
  }

  _createFragmentPointer(
    fragmentSpread: ReaderFragmentSpread,
    record: Record,
    data: SelectorData,
  ): void {
    let fragmentPointers = data[FRAGMENTS_KEY];
    if (fragmentPointers == null) {
      fragmentPointers = data[FRAGMENTS_KEY] = {};
    }
    invariant(
      typeof fragmentPointers === 'object' && fragmentPointers != null,
      'RelayReader: Expected fragment spread data to be an object, got `%s`.',
      fragmentPointers,
    );
    if (data[ID_KEY] == null) {
      data[ID_KEY] = RelayModernRecord.getDataID(record);
    }
    // $FlowFixMe[cannot-write] - writing into read-only field
    fragmentPointers[fragmentSpread.name] = fragmentSpread.args
      ? getArgumentValues(fragmentSpread.args, this._variables)
      : {};
    data[FRAGMENT_OWNER_KEY] = this._owner;

    if (RelayFeatureFlags.ENABLE_PRECISE_TYPE_REFINEMENT) {
      data[
        IS_WITHIN_UNMATCHED_TYPE_REFINEMENT
      ] = this._isWithinUnmatchedTypeRefinement;
    }
  }

  _createInlineDataFragmentPointer(
    inlineDataFragmentSpread: ReaderInlineDataFragmentSpread,
    record: Record,
    data: SelectorData,
  ): void {
    let fragmentPointers = data[FRAGMENTS_KEY];
    if (fragmentPointers == null) {
      fragmentPointers = data[FRAGMENTS_KEY] = {};
    }
    invariant(
      typeof fragmentPointers === 'object' && fragmentPointers != null,
      'RelayReader: Expected fragment spread data to be an object, got `%s`.',
      fragmentPointers,
    );
    if (data[ID_KEY] == null) {
      data[ID_KEY] = RelayModernRecord.getDataID(record);
    }
    const inlineData = {};
    this._traverseSelections(
      inlineDataFragmentSpread.selections,
      record,
      inlineData,
    );
    // $FlowFixMe[cannot-write] - writing into read-only field
    fragmentPointers[inlineDataFragmentSpread.name] = inlineData;
  }
}

module.exports = {read};


text:
package com.microsoft.recognizers.text.numberwithunit.portuguese.parsers;

import com.microsoft.recognizers.text.Culture;
import com.microsoft.recognizers.text.CultureInfo;
import com.microsoft.recognizers.text.numberwithunit.portuguese.extractors.DimensionExtractorConfiguration;

public class DimensionParserConfiguration extends PortugueseNumberWithUnitParserConfiguration {

    public DimensionParserConfiguration() {
        this(new CultureInfo(Culture.Portuguese));
    }

    public DimensionParserConfiguration(CultureInfo cultureInfo) {
        super(cultureInfo);

        this.bindDictionary(DimensionExtractorConfiguration.DimensionSuffixList);
    }
}

redpajama_set_name: RedPajamaGithub


text:
/*
 * cowCal CSS
 * Author: Dave Russell Jr (drussell393)
 */
html body div#cowCal div.cowCal-yearSwitcher {
  text-align: center; }
  html body div#cowCal div.cowCal-yearSwitcher input {
    width: 60px;
    text-align: center; }
  html body div#cowCal div.cowCal-yearSwitcher span.left-nav, html body div#cowCal div.cowCal-yearSwitcher span.right-nav {
    display: inline-block;
    border-top: 7px solid transparent;
    border-bottom: 7px solid transparent;
    cursor: pointer; }
  html body div#cowCal div.cowCal-yearSwitcher span.left-nav {
    border-right: 7px solid #222222; }
  html body div#cowCal div.cowCal-yearSwitcher span.right-nav {
    border-left: 7px solid #222222; }
html body div#cowCal div#cowCal-12months {
  margin-top: 50px; }
  html body div#cowCal div#cowCal-12months div.cowCal-month {
    z-index: -1;
    display: inline-block;
    width: 25%;
    margin: 1% 0 4% 5.5%; }
    html body div#cowCal div#cowCal-12months div.cowCal-month .holidayChooser {
      display: none;
      position: absolute;
      z-index: 100;
      padding: 20px;
      width: 200px; }

/*# sourceMappingURL=cowCal.css.map */


text:
<?php
require_once realpath(__DIR__ . '/..') . '/vendor/autoload.php';
require_once realpath(__DIR__ . '/..') . '/Utils.php';

use Aspose\Slides\SlidesApi;
use Aspose\Slides\AsposeApp;

class Text {

	public $slidesApi;

	public function __construct() {
		AsposeApp::$appSID = Utils::appSID;
		AsposeApp::$apiKey = Utils::apiKey;
		$this->slidesApi = new SlidesApi();
	}

	public function postSlidesPresentationReplaceText() {
		$fileName = "sample.pptx";
		Utils::uploadFile($fileName);

		$result = $this->slidesApi->PostSlidesPresentationReplaceText($fileName, $oldValue = "Aspose", $newValue = "Aspose File Format APIs", $ignoreCase = "", $folder = "", $storage = "", $body = null);
		print_r($result);
	}
}

$text = new Text();
$text->postSlidesPresentationReplaceText();

?>
//ExEnd:


text:
<?xml version="1.0" encoding="ISO-8859-1"?>

<audio_platform_info>
    <acdb_ids>
        <device name="SND_DEVICE_OUT_VOICE_HANDSET"         acdb_id="67"/>
        <device name="SND_DEVICE_OUT_VOICE_SPEAKER"         acdb_id="66"/>
        <device name="SND_DEVICE_OUT_VOICE_HANDSET_TMUS"    acdb_id="67"/>
        <device name="SND_DEVICE_IN_HEADSET_MIC_AEC"        acdb_id="47"/>
        <device name="SND_DEVICE_IN_VOICE_DMIC_TMUS"        acdb_id="89"/>
    </acdb_ids>

    <pcm_ids>
        <usecase name="USECASE_VOICE_CALL" type="in" id="20"/>
        <usecase name="USECASE_VOICE_CALL" type="out" id="20"/>
        <usecase name="USECASE_VOICE2_CALL" type="in" id="25"/>
        <usecase name="USECASE_VOICE2_CALL" type="out" id="25"/>
        <usecase name="USECASE_VOLTE_CALL" type="in" id="21"/>
        <usecase name="USECASE_VOLTE_CALL" type="out" id="21"/>
        <usecase name="USECASE_QCHAT_CALL" type="in" id="33"/>
        <usecase name="USECASE_QCHAT_CALL" type="out" id="33"/>
        <usecase name="USECASE_VOWLAN_CALL" type="in" id="-1"/>
        <usecase name="USECASE_VOWLAN_CALL" type="out" id="-1"/>
    </pcm_ids>

    <backend_names>
        <device name="SND_DEVICE_OUT_SPEAKER"           backend="speaker" interface="QUAT_MI2S_RX"/>
        <device name="SND_DEVICE_OUT_SPEAKER_SAFE"      backend="speaker" interface="QUAT_MI2S_RX"/>
        <device name="SND_DEVICE_OUT_VOICE_SPEAKER"     backend="speaker" interface="QUAT_MI2S_RX"/>
        <device name="SND_DEVICE_OUT_SPEAKER_REVERSE"   backend="speaker" interface="QUAT_MI2S_RX"/>

        <device name="SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES"      backend="speaker-and-headphones" interface="QUAT_MI2S_RX-and-SLIMBUS_0_RX"/>
        <device name="SND_DEVICE_OUT_SPEAKER_AND_LINE"            backend="speaker-and-headphones" interface="QUAT_MI2S_RX-and-SLIMBUS_0_RX"/>
        <device name="SND_DEVICE_OUT_SPEAKER_SAFE_AND_HEADPHONES" backend="speaker-and-headphones" interface="QUAT_MI2S_RX-and-SLIMBUS_0_RX"/>
        <device name="SND_DEVICE_OUT_SPEAKER_SAFE_AND_LINE"       backend="speaker-and-headphones" interface="QUAT_MI2S_RX-and-SLIMBUS_0_RX"/>

        <device name="SND_DEVICE_OUT_VOICE_HANDSET"             backend="handset" interface="QUAT_MI2S_RX"/>
        <device name="SND_DEVICE_OUT_VOICE_HAC_HANDSET"         backend="handset" interface="QUAT_MI2S_RX"/>
        <device name="SND_DEVICE_OUT_VOICE_HANDSET_TMUS"        backend="handset" interface="QUAT_MI2S_RX"/>
        <device name="SND_DEVICE_OUT_HANDSET"                   backend="handset" interface="QUAT_MI2S_RX"/>
        <device name="SND_DEVICE_OUT_VOICE_TTY_HCO_HANDSET"     backend="handset" interface="QUAT_MI2S_RX"/>
    </backend_names>

    <config_params>
        <!-- If sound card name is not known, remove this entry -->
        <param key="snd_card_name" value="apq8084-taiko-tfa9890_stereo_codec-snd-card"/>
    </config_params>

</audio_platform_info>


text:
/*
 * Use and distribution licensed under the Apache license version 2.
 *
 * See the COPYING file in the root project directory for full text.
 */

#include "parser/error.h"
#include "parser/parse.h"

namespace sqltoast {

// <query expression> ::=
//     <non-join query expression>
//     | <joined table>
//
// <query term> ::=
//     <non-join query term>
//     | <joined table>
//
// <query primary> ::=
//     <non-join query primary>
//     | <joined table>
bool parse_query_expression(
        parse_context_t& ctx,
        token_t& cur_tok,
        std::unique_ptr<query_expression_t>& out) {
    lexer_t& lex = ctx.lexer;
    parse_position_t start = lex.cursor;
    token_t start_tok = lex.current_token;
    std::unique_ptr<table_reference_t> joined_table;

    if (parse_non_join_query_expression(ctx, cur_tok, out))
        return true;
    if (ctx.result.code == PARSE_SYNTAX_ERROR)
        return false;

    // Reset cursor to before parsing of joined table attempt.
    lex.cursor = start;
    lex.current_token = cur_tok = start_tok;
    if (! parse_joined_table(ctx, cur_tok, joined_table))
        return false;
    if (ctx.opts.disable_statement_construction)
        return true;
    out = std::make_unique<joined_table_query_expression_t>(joined_table);
    return true;
}

// <non-join query expression> ::=
//     <non-join query term>
//     | <query expression> UNION
//     [ ALL ] [ <corresponding spec> ] <query term>
//     | <query expression> EXCEPT
//     [ ALL ] [ <corresponding spec> ] <query term>
bool parse_non_join_query_expression(
        parse_context_t& ctx,
        token_t& cur_tok,
        std::unique_ptr<query_expression_t>& out) {
    std::unique_ptr<non_join_query_term_t> njqt;

    if (! parse_non_join_query_term(ctx, cur_tok, njqt))
        return false;
    // TODO(jaypipes): Handle UNION and EXCEPT
    if (ctx.opts.disable_statement_construction)
        return true;
    out = std::make_unique<non_join_query_expression_t>(njqt);
    return true;
}

// <non-join query term> ::=
//     <non-join query primary>
//     | <query term> INTERSECT
//     [ ALL ] [ <corresponding spec> ] <query primary>
bool parse_non_join_query_term(
        parse_context_t& ctx,
        token_t& cur_tok,
        std::unique_ptr<non_join_query_term_t>& out) {
    std::unique_ptr<non_join_query_primary_t> njqp;

    if (! parse_non_join_query_primary(ctx, cur_tok, njqp))
        return false;
    // TODO(jaypipes): Handle INTERSECT
    if (ctx.opts.disable_statement_construction)
        return true;
    out = std::make_unique<non_join_query_term_t>(njqp);
    return true;
}

// <non-join query primary> ::=
//     <simple table>
//     | <left paren> <non-join query expression> <right paren>
//
// <simple table> ::=
//     <query specification>
//     | <table value constructor>
//     | <explicit table>
bool parse_non_join_query_primary(
        parse_context_t& ctx,
        token_t& cur_tok,
        std::unique_ptr<non_join_query_primary_t>& out) {
    lexer_t& lex = ctx.lexer;
    parse_position_t start = lex.cursor;
    token_t start_tok = lex.current_token;
    std::unique_ptr<query_specification_t> query_spec;
    std::unique_ptr<table_value_constructor_t> tvc;

    if (parse_query_specification(ctx, cur_tok, query_spec))
        goto push_primary;
    if (ctx.result.code == PARSE_SYNTAX_ERROR)
        return false;
    // Reset cursor to before parsing of joined table attempt.
    lex.cursor = start;
    lex.current_token = cur_tok = start_tok;
    if (! parse_table_value_constructor(ctx, cur_tok, tvc))
        return false;
    // TODO(jaypipes): explicit table
push_primary:
    if (ctx.opts.disable_statement_construction)
        return true;
    if (query_spec)
        out = std::make_unique<query_specification_non_join_query_primary_t>(query_spec);
    else if (tvc)
        out = std::make_unique<table_value_constructor_non_join_query_primary_t>(tvc);
    return true;
}

//  <table value constructor> ::=
//      VALUES <table value constructor list>
//
//  <table value constructor list> ::=
//      <row value constructor>
//      [ { <comma> <row value constructor> }... ]
bool parse_table_value_constructor(
        parse_context_t& ctx,
        token_t& cur_tok,
        std::unique_ptr<table_value_constructor_t>& out) {
    lexer_t& lex = ctx.lexer;
    symbol_t cur_sym = cur_tok.symbol;

    std::vector<std::unique_ptr<row_value_constructor_t>> val_list;
    std::unique_ptr<row_value_constructor_t> val_list_item;

    if (cur_sym != SYMBOL_VALUES)
        return false;
    cur_tok = lex.next();
    goto process_value_list_item;
process_value_list_item:
    if (! parse_row_value_constructor(ctx, cur_tok, val_list_item))
        goto err_expect_value_item;
    val_list.emplace_back(std::move(val_list_item));
    cur_sym = cur_tok.symbol;
    if (cur_sym == SYMBOL_COMMA) {
        cur_tok = lex.next();
        goto process_value_list_item;
    }
    goto push_tvc;
err_expect_value_item:
    {
        std::stringstream estr;
        estr << "Expected a value item, but got " << cur_tok << "." << std::endl;
        create_syntax_error_marker(ctx, estr);
        return false;
    }
push_tvc:
    if (ctx.opts.disable_statement_construction)
        return true;
    out = std::make_unique<table_value_constructor_t>(val_list);
    return true;
}

// <joined table> ::=
//     <cross join>
//     | <qualified join>
//     | <left paren> <joined table> <right paren>
bool parse_joined_table(
        parse_context_t& ctx,
        token_t& cur_tok,
        std::unique_ptr<table_reference_t>& out) {
    lexer_t& lex = ctx.lexer;
    parse_position_t start = lex.cursor;
    token_t start_tok = lex.current_token;
    symbol_t cur_sym = cur_tok.symbol;
    join_type_t join_type = JOIN_TYPE_NONE;
    std::unique_ptr<join_target_t> join_target;
    std::unique_ptr<join_specification_t> join_spec;
    std::unique_ptr<search_condition_t> join_cond;
    std::unique_ptr<table_reference_t> right;
    // Used for the USING clause
    std::vector<lexeme_t> named_columns;

    if (parse_table_reference(ctx, cur_tok, out))
        goto process_join_type;
    // Reset cursor to before parsing of table reference attempt. If the next
    // symbol is a LPAREN, pop it and try parsing a parens-enclosed
    // joined_table construct
    lex.cursor = start;
    lex.current_token = cur_tok = start_tok;
    cur_sym = cur_tok.symbol;
    if (cur_sym != SYMBOL_LPAREN)
        return false;
    cur_tok = lex.next();
    goto process_enclosed_joined_table;
process_join_type:
    // We get here after successfully parsing a table reference for the left
    // side of a joined table.  We must now check for symbols that indicate
    // what type of join follows
    cur_sym = cur_tok.symbol;
    switch (cur_sym) {
        case SYMBOL_CROSS:
            cur_tok = lex.next();
            join_type = JOIN_TYPE_CROSS;
            goto expect_join;
        case SYMBOL_INNER:
            cur_tok = lex.next();
            cur_sym = cur_tok.symbol;
            if (cur_sym != SYMBOL_JOIN)
                goto err_expect_join;
            cur_tok = lex.next();
            join_type = JOIN_TYPE_INNER;
            goto optional_join_specification;
        case SYMBOL_JOIN:
            cur_tok = lex.next();
            join_type = JOIN_TYPE_INNER;
            goto expect_right_table_reference;
        case SYMBOL_LEFT:
            cur_tok = lex.next();
            join_type = JOIN_TYPE_LEFT;
            goto optional_outer;
        case SYMBOL_RIGHT:
            cur_tok = lex.next();
            join_type = JOIN_TYPE_RIGHT;
            goto optional_outer;
        case SYMBOL_FULL:
            cur_tok = lex.next();
            join_type = JOIN_TYPE_FULL;
            goto optional_outer;
        case SYMBOL_NATURAL:
            cur_tok = lex.next();
            join_type = JOIN_TYPE_NATURAL;
            goto expect_join;
        case SYMBOL_UNION:
            // NOTE(jaypipes): UNION JOIN was removed in ANSI-SQL 2003
            cur_tok = lex.next();
            join_type = JOIN_TYPE_UNION;
            goto expect_join;
        default:
            return false;
    }
expect_join:
    // We get here after successfully parsing a normal or derived table
    // followed by the UNION, CROSS or NATURAL symbol. We now expect a JOIN
    // symbol followed by another <table_reference>
    cur_sym = cur_tok.symbol;
    if (cur_sym != SYMBOL_JOIN)
        goto err_expect_join;
    cur_tok = lex.next();
    goto expect_right_table_reference;
expect_right_table_reference:
    if (! parse_table_reference(ctx, cur_tok, right))
        goto err_expect_table_reference;
    goto optional_join_specification;
err_expect_join:
    expect_error(ctx, SYMBOL_JOIN);
    return false;
err_expect_table_reference:
    {
        std::stringstream estr;
        estr << "Expected <table reference> but found "
             << cur_tok << std::endl;
        create_syntax_error_marker(ctx, estr);
        return false;
    }
optional_join_specification:
    // We get here after successfully parsing an INNER or OUTER symbol followed
    // by a JOIN symbol and a <table reference>. We now must check for the
    // optional <join specification> clause
    cur_sym = cur_tok.symbol;
    switch (cur_sym) {
        case SYMBOL_ON:
            cur_tok = lex.next();
            goto process_join_condition;
        case SYMBOL_USING:
            cur_tok = lex.next();
            goto process_named_columns;
        default:
            goto push_joined_table;
    }
process_join_condition:
    // We get here after parsing the joined table references and finding an ON
    // symbol. We now expect to find a search condition
    if (! parse_search_condition(ctx, cur_tok, join_cond))
        goto err_expect_join_condition;
    goto push_joined_table;
err_expect_join_condition:
    {
        std::stringstream estr;
        estr << "Expected <join condition> but found "
             << cur_tok << std::endl;
        create_syntax_error_marker(ctx, estr);
        return false;
    }
process_named_columns:
    // We get here after parsing a USING symbol, which must be followed by a
    // parens-enclosed list of column identifiers
    cur_sym = cur_tok.symbol;
    if (cur_sym != SYMBOL_LPAREN)
        goto err_expect_lparen;
    cur_tok = lex.next();
    goto process_named_column;
err_expect_lparen:
    expect_error(ctx, SYMBOL_LPAREN);
    return false;
process_named_column:
    cur_sym = cur_tok.symbol;
    if (cur_sym != SYMBOL_IDENTIFIER)
        goto err_expect_identifier;
    named_columns.emplace_back(cur_tok.lexeme);
    cur_tok = lex.next();
    cur_sym = cur_tok.symbol;
    if (cur_sym == SYMBOL_COMMA) {
        cur_tok = lex.next();
        goto process_named_column;
    }
    else if (cur_sym != SYMBOL_RPAREN)
        goto err_expect_rparen;
    cur_tok = lex.next();
    goto push_joined_table;
err_expect_identifier:
    expect_error(ctx, SYMBOL_IDENTIFIER);
    return false;
err_expect_rparen:
    expect_error(ctx, SYMBOL_RPAREN);
    return false;
optional_outer:
    // We get here after successfully parsing the FULL, LEFT or RIGHT symbols.
    // These symbols may be followed by an optional OUTER symbol and then the
    // required JOIN symbol.
    cur_sym = cur_tok.symbol;
    if (cur_sym == SYMBOL_OUTER)
        cur_tok = lex.next();
    goto expect_join;
process_enclosed_joined_table:
    return false;
push_joined_table:
    if (ctx.opts.disable_statement_construction)
        return true;
    if (! named_columns.empty())
        join_spec = std::make_unique<join_specification_t>(named_columns);
    else if (join_cond)
        join_spec = std::make_unique<join_specification_t>(join_cond);
    join_target = std::make_unique<join_target_t>(join_type, right, join_spec);
    out->join(join_target);
    return true;
}

// <query specification> ::=
//     SELECT [ <set quantifier> ] <select list> <table expression>
//
// <set quantifier> ::= DISTINCT | ALL
//
// <select list> ::=
//     <asterisk>
//     | <select sublist> [ { <comma> <select sublist> }... ]
//
// <select sublist> ::= <derived column> | <qualifier> <period> <asterisk>
//
// <derived column> ::= <value expression> [ <as clause> ]
//
// <as clause> ::= [ AS ] <column name>
bool parse_query_specification(
        parse_context_t& ctx,
        token_t& cur_tok,
        std::unique_ptr<query_specification_t>& out) {
    lexer_t& lex = ctx.lexer;
    symbol_t cur_sym = cur_tok.symbol;
    std::unique_ptr<value_expression_t> selected_col;
    std::vector<derived_column_t> selected_columns;
    std::unique_ptr<table_expression_t> table_expression;
    bool distinct = false;

    cur_sym = cur_tok.symbol;
    if (cur_sym != SYMBOL_SELECT)
        return false;
    cur_tok = lex.next();
    cur_sym = cur_tok.symbol;
    if (cur_sym == SYMBOL_DISTINCT) {
        cur_tok = lex.next();
        distinct = true;
    } else if (cur_sym == SYMBOL_ALL) {
        cur_tok = lex.next();
        distinct = false;
    }
expect_derived_column:
    cur_sym = cur_tok.symbol;
    if (cur_sym == SYMBOL_ASTERISK) {
        selected_columns.emplace_back(derived_column_t());
        cur_tok = lex.next();
        goto comma_or_from;
    }
    // If the <select list> element isn't an asterisk it needs to be a value
    // expression...
    if (! parse_value_expression(ctx, cur_tok, selected_col))
        goto err_expect_derived_column;
    selected_columns.emplace_back(derived_column_t(selected_col));
    goto optional_column_alias;
err_expect_derived_column:
    expect_any_error(ctx, {SYMBOL_ASTERISK, SYMBOL_IDENTIFIER});
    return false;
optional_column_alias:
    // We get here after consuming a column identifier or value expression. An
    // alias can be provided for this column either by specifying an identifier
    // immediately after the value expression or the keyword AS followed by the
    // alias.
    cur_sym = cur_tok.symbol;
    if (cur_sym == SYMBOL_AS) {
        cur_tok = lex.next();
        cur_sym = cur_tok.symbol;
        if (cur_sym != SYMBOL_IDENTIFIER)
            goto err_expect_identifier;
    }
    if (cur_sym == SYMBOL_IDENTIFIER) {
        derived_column_t& dc = selected_columns.back();
        dc.alias = cur_tok.lexeme;
        cur_tok = lex.next();
    }
    goto comma_or_from;
err_expect_identifier:
    expect_error(ctx, SYMBOL_IDENTIFIER);
    return false;
comma_or_from:
    // We get here after consuming a derived column and now we expect to find
    // either a comma, indicating another derived column should be next, or the
    // FROM symbol, indicating the end of the <select list> clause.
    cur_sym = cur_tok.symbol;
    if (cur_sym == SYMBOL_COMMA) {
        cur_tok = lex.next();
        goto expect_derived_column;
    }
    if (cur_sym != SYMBOL_FROM)
        goto err_expect_comma_or_from;
    goto expect_table_expression;
err_expect_comma_or_from:
    expect_any_error(ctx, {SYMBOL_COMMA, SYMBOL_FROM});
    return false;
expect_table_expression:
    if (! parse_table_expression(ctx, cur_tok, table_expression))
        return false;
    goto push_query_specification;
push_query_specification:
    if (ctx.opts.disable_statement_construction)
        return true;
    out = std::make_unique<query_specification_t>(
            distinct, selected_columns, table_expression);
    return true;
}

// <table expression> ::=
//     <from clause>
//     [ <where clause> ]
//     [ <group by clause> ]
//     [ <having clause> ]
bool parse_table_expression(
        parse_context_t& ctx,
        token_t& cur_tok,
        std::unique_ptr<table_expression_t>& out) {
    lexer_t& lex = ctx.lexer;
    symbol_t cur_sym = cur_tok.symbol;
    std::vector<std::unique_ptr<table_reference_t>> referenced_tables;
    std::unique_ptr<table_reference_t> table_ref;
    std::vector<grouping_column_reference_t> group_by_columns;
    std::unique_ptr<search_condition_t> where_condition;
    std::unique_ptr<search_condition_t> having_condition;

    cur_sym = cur_tok.symbol;
    if (cur_sym != SYMBOL_FROM)
        return false;
    cur_tok = lex.next();
    goto expect_table_reference;
expect_table_reference:
    if (! parse_table_reference(ctx, cur_tok, table_ref))
        return false;
    referenced_tables.emplace_back(std::move(table_ref));
    goto comma_or_where_group_having;
comma_or_where_group_having:
    // We get here after consuming a table reference and now we expect to find
    // either a comma, indicating another table reference should be next, or
    // one of the GROUP BY, WHERE or HAVING symbols, indicating those clauses
    // are to follow
    cur_sym = cur_tok.symbol;
    switch (cur_sym) {
        case SYMBOL_COMMA:
            cur_tok = lex.next();
            goto expect_table_reference;
        case SYMBOL_WHERE:
            cur_tok = lex.next();
            goto process_where;
        case SYMBOL_GROUP:
            cur_tok = lex.next();
            goto expect_by;
        case SYMBOL_HAVING:
            cur_tok = lex.next();
            goto process_having;
        default:
            goto push_table_expression;;
    }
process_where:
    cur_sym = cur_tok.symbol;
    if (! parse_search_condition(ctx, cur_tok, where_condition))
        return false;
    goto group_by_having_or_statement_ending;
group_by_having_or_statement_ending:
    // We get here after consuming the FROM and optional WHERE clauses. We can
    // now get either the end of statement, the GROUP BY or the HAVING clause
    cur_sym = cur_tok.symbol;
    switch (cur_sym) {
        case SYMBOL_GROUP:
            cur_tok = lex.next();
            goto expect_by;
        case SYMBOL_HAVING:
            cur_tok = lex.next();
            goto process_having;
        default:
            goto push_table_expression;
    }
expect_by:
    // We get here after finding the GROUP symbol, which must be followed by
    // the BY symbol and then one or more grouping column references
    cur_sym = cur_tok.symbol;
    if (cur_sym != SYMBOL_BY)
        goto err_expect_by;
    cur_tok = lex.next();
    cur_sym = cur_tok.symbol;
    goto process_group_by_column;
err_expect_by:
    expect_error(ctx, SYMBOL_BY);
    return false;
process_group_by_column:
    cur_sym = cur_tok.symbol;
    if (cur_sym != SYMBOL_IDENTIFIER)
        goto err_expect_identifier;
    group_by_columns.emplace_back(grouping_column_reference_t(cur_tok.lexeme));
    cur_tok = lex.next();
    goto optional_collation;
err_expect_identifier:
    expect_error(ctx, SYMBOL_IDENTIFIER);
    return false;
optional_collation:
    // We get here after consuming an identifier for a grouping column
    // reference and now we can get an optional collation for that column
    // reference
    cur_sym = cur_tok.symbol;
    if (cur_sym == SYMBOL_COLLATE) {
        cur_tok = lex.next();
        cur_sym = cur_tok.symbol;
        if (cur_sym != SYMBOL_IDENTIFIER)
            goto err_expect_identifier;
    }
    if (cur_sym == SYMBOL_IDENTIFIER) {
        grouping_column_reference_t& gcr = group_by_columns.back();
        gcr.collation = cur_tok.lexeme;
        cur_tok = lex.next();
    }
    cur_sym = cur_tok.symbol;
    if (cur_sym == SYMBOL_COMMA) {
        cur_tok = lex.next();
        goto process_group_by_column;
    }
    goto having_or_statement_ending;
process_having:
    cur_sym = cur_tok.symbol;
    if (! parse_search_condition(ctx, cur_tok, having_condition))
        return false;
    goto push_table_expression;
having_or_statement_ending:
    cur_sym = cur_tok.symbol;
    if (cur_sym == SYMBOL_HAVING) {
        cur_tok = lex.next();
        goto process_having;
    }
    goto push_table_expression;
push_table_expression:
    if (ctx.opts.disable_statement_construction)
        return true;
    out = std::make_unique<table_expression_t>(
            referenced_tables, where_condition, group_by_columns,
            having_condition);
    return true;
}

} // namespace sqltoast


text:
/* __GDPR__
   "language_server.enabled" : {
      "duration" : { "classification": "SystemMetaData", "purpose": "FeatureInsight", "isMeasurement": true },
      "errorname" : { "classification": "CallstackOrException", "purpose": "PerformanceAndHealth" },
      "errorstack" : { "classification": "CallstackOrException", "purpose": "PerformanceAndHealth" },
      "lsversion" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
   }
*/
/* __GDPR__
   "language_server.ready" : {
      "duration" : { "classification": "SystemMetaData", "purpose": "FeatureInsight", "isMeasurement": true },
      "errorname" : { "classification": "CallstackOrException", "purpose": "PerformanceAndHealth" },
      "errorstack" : { "classification": "CallstackOrException", "purpose": "PerformanceAndHealth" },
      "lsversion" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
   }
*/
/* __GDPR__
   "language_server.request" : {
      "duration" : { "classification": "SystemMetaData", "purpose": "FeatureInsight", "isMeasurement": true },
      "errorname" : { "classification": "CallstackOrException", "purpose": "PerformanceAndHealth" },
      "errorstack" : { "classification": "CallstackOrException", "purpose": "PerformanceAndHealth" },
      "lsversion" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "method" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
   }
*/
/* __GDPR__
   "language_server.startup" : {
      "duration" : { "classification": "SystemMetaData", "purpose": "FeatureInsight", "isMeasurement": true },
      "errorname" : { "classification": "CallstackOrException", "purpose": "PerformanceAndHealth" },
      "errorstack" : { "classification": "CallstackOrException", "purpose": "PerformanceAndHealth" },
      "lsversion" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
   }
*/
/* __GDPR__
   "language_server/analysis_complete" : {
      "common.remotename" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "common.uikind" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "configparseerroroccurred" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "elapsedms" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "externalmb" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "fatalerroroccurred" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "heaptotalmb" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "heapusedmb" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "installsource" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "isdone" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "isfirstrun" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "lsversion" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "numfilesanalyzed" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "numfilesinprogram" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "peakrssmb" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "resolverid" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "rssmb" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" }
   }
*/
/* __GDPR__
   "language_server/analysis_exception" : {
      "errorname" : { "classification": "CallstackOrException", "purpose": "PerformanceAndHealth" },
      "errorstack" : { "classification": "CallstackOrException", "purpose": "PerformanceAndHealth" },
      "lsversion" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" }
   }
*/
/* __GDPR__
   "language_server/completion_accepted" : {
      "autoimport" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "dictionarykey" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
   }
*/
/* __GDPR__
   "language_server/completion_coverage" : {
      "failures" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "lsversion" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "overallfailures" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "overallsuccesses" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "overalltotal" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "successes" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "total" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
   }
*/
/* __GDPR__
   "language_server/completion_metrics" : {
      "installsource" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "lastknownmembernamehash" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "lastknownmodulehash" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "lsversion" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "packagehash" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "unknownmembernamehash" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
   }
*/
/* __GDPR__
   "language_server/completion_slow" : {
      "bindcallcount" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "bindtime" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "correlationid" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "custom_autoimportadditiontimeinms" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "custom_autoimportedittimeinms" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "custom_autoimportimportaliascount" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "custom_autoimportimportaliastimeinms" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "custom_autoimportindexcount" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "custom_autoimportindextimeinms" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "custom_autoimportindexused" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "custom_autoimportitemcount" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "custom_autoimportmoduleresolvetimeinms" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "custom_autoimportmoduletimeinms" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "custom_autoimportsymbolcount" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "custom_autoimporttotaltimeinms" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "custom_autoimportuserindexcount" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "custom_completionitems" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "custom_completionitemtelemetrybuildtimeinms" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "custom_extensiontotaltimeinms" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "custom_selecteditemtelemetrybuildtimeinms" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "lsversion" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "parsecallcount" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "parsetime" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "readfilecallcount" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "readfiletime" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "resolvecallcount" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "resolvetime" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "tokenizecallcount" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "tokenizetime" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "totaltime" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "typeevalcount" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "typeevaltime" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" }
   }
*/
/* __GDPR__
   "language_server/exception_intellicode" : {
      "common.remotename" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "common.uikind" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
   }
*/
/* __GDPR__
   "language_server/execute_command" : {
      "lsversion" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "name" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
   }
*/
/* __GDPR__
   "language_server/import_heuristic" : {
      "avgcost" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "avglevel" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "conflicts" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "nativemodules" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "nativepackages" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "reason_because_it_is_not_a_valid_directory" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "reason_could_not_parse_output" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "reason_did_not_find_file" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "reason_no_python_interpreter_search_path" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "reason_typeshed_path_not_found" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "resolverid" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "success" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "total" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
   }
*/
/* __GDPR__
   "language_server/import_metrics" : {
      "absolutestubs" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "absolutetotal" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "absoluteunresolved" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "absoluteuserunresolved" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "builtinimportstubs" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "builtinimporttotal" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "common.remotename" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "common.uikind" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "installsource" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "localimportstubs" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "localimporttotal" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "lsversion" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "nativemodules" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "nativepackages" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "relativestubs" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "relativetotal" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "relativeunresolved" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "resolverid" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "stubs" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "thirdpartyimportstubs" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "thirdpartyimporttotal" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "total" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "unresolvedmodules" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "unresolvedpackages" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "unresolvedpackageslowercase" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "unresolvedtotal" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
   }
*/
/* __GDPR__
   "language_server/index_slow" : {
      "bindcallcount" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "bindtime" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "custom_count" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "lsversion" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "parsecallcount" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "parsetime" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "readfilecallcount" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "readfiletime" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "resolvecallcount" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "resolvetime" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "tokenizecallcount" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "tokenizetime" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "totaltime" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "typeevalcount" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "typeevaltime" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" }
   }
*/
/* __GDPR__
   "language_server/installed_packages" : {
      "packages" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "packageslowercase" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "resolverid" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
   }
*/
/* __GDPR__
   "language_server/intellicode_completion_item_selected" : {
      "class" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "common.remotename" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "common.uikind" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "count" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "elapsedtime" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "failurereason" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "id" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "index" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "installsource" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "isintellicodecommit" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "language" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "lsversion" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "memoryincreasekb" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "method" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "methods" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "modeltype" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "modelversion" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "selecteditemtelemetrybuildtimeinms" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" }
   }
*/
/* __GDPR__
   "language_server/intellicode_enabled" : {
      "common.remotename" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "common.uikind" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "enabled" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "installsource" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "lsversion" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "startup" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
   }
*/
/* __GDPR__
   "language_server/intellicode_model_load_failed" : {
      "errorname" : { "classification": "CallstackOrException", "purpose": "PerformanceAndHealth" },
      "errorstack" : { "classification": "CallstackOrException", "purpose": "PerformanceAndHealth" },
      "installsource" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "lsversion" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "reason" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" }
   }
*/
/* __GDPR__
   "language_server/intellicode_onnx_load_failed" : {
      "errorname" : { "classification": "CallstackOrException", "purpose": "PerformanceAndHealth" },
      "errorstack" : { "classification": "CallstackOrException", "purpose": "PerformanceAndHealth" },
      "installsource" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "lsversion" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "reason" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" }
   }
*/
/* __GDPR__
   "language_server/rename_files" : {
      "affectedfilescount" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "bindcallcount" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "bindtime" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "filerenamed" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "parsecallcount" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "parsetime" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "readfilecallcount" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "readfiletime" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "resolvecallcount" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "resolvetime" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "tokenizecallcount" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "tokenizetime" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "totaltime" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "type" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "typeevalcount" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "typeevaltime" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" }
   }
*/
/* __GDPR__
   "language_server/semantictokens_slow" : {
      "bindcallcount" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "bindtime" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "custom_count" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "lsversion" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "parsecallcount" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "parsetime" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "readfilecallcount" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "readfiletime" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "resolvecallcount" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "resolvetime" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "tokenizecallcount" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "tokenizetime" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "totaltime" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "typeevalcount" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "typeevaltime" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" }
   }
*/
/* __GDPR__
   "language_server/settings" : {
      "autoimportcompletions" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "autosearchpaths" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "completefunctionparens" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "enableextractcodeaction" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "hasconfigfile" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "hasextrapaths" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "indexing" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "openfilesonly" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "typecheckingmode" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "useimportheuristic" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "uselibrarycodefortypes" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
      "workspacecount" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
   }
*/
/* __GDPR__
   "language_server/startup_metrics" : {
      "analysisms" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "peakrssmb" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "presetfileopenms" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "tokendeltams" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "tokenfullms" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "tokenrangems" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "totalms" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "userindexms" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" }
   }
*/
/* __GDPR__
   "language_server/workspaceindex_slow" : {
      "bindcallcount" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "bindtime" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "custom_count" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "lsversion" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "parsecallcount" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "parsetime" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "readfilecallcount" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "readfiletime" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "resolvecallcount" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "resolvetime" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "tokenizecallcount" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "tokenizetime" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "totaltime" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "typeevalcount" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
      "typeevaltime" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" }
   }
*/
/* __GDPR__
   "language_server/workspaceindex_threshold_reached" : {
      "index_count" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" }
   }
*/


text:
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
<meta http-equiv="X-UA-Compatible" content="IE=9"/>
<meta name="generator" content="Doxygen 1.8.13"/>
<meta name="viewport" content="width=device-width, initial-scale=1"/>
<title>CometEngine: CometEngineClient/CometEngineWin32/Win32/CometEngineWin32.cpp 파일 참조</title>
<link href="tabs.css" rel="stylesheet" type="text/css"/>

<link href="navtree.css" rel="stylesheet" type="text/css"/>

<link href="search/search.css" rel="stylesheet" type="text/css"/>

<link href="doxygen.css" rel="stylesheet" type="text/css" />

CometEngine
    0.0.1

매크로

CometEngineWin32.cpp 파일 참조

#include "CometEngineWin32.h"

#include <string>

CometEngineWin32.cpp에 대한 include 의존 그래프

<map name="_comet_engine_client_2_comet_engine_win32_2_win32_2_comet_engine_win32_8cpp" id="_comet_engine_client_2_comet_engine_win32_2_win32_2_comet_engine_win32_8cpp">
<area shape="rect" id="node2" href="_comet_engine_win32_8h.html" title="CometEngineWin32.h" alt="" coords="71,95,219,121"/>
</map>

이 파일의 소스 코드 페이지로 가기

매크로

#define 	UNICODE

매크로 문서화

◆ UNICODE

          #define UNICODE

CometEngineWin32.cpp 파일의 1 번째 라인에서 정의되었습니다.

CometEngineClient

CometEngineWin32

Win32

CometEngineWin32.cpp

다음에 의해 생성됨 :

     1.8.13


text:
#ifndef __SOT_FACTORY_HH__
#define __SOT_FACTORY_HH__

/* --------------------------------------------------------------------- */
/* --- INCLUDE --------------------------------------------------------- */
/* --------------------------------------------------------------------- */

#include <dynamic-graph/factory.h>

#define SOT_FACTORY_FEATURE_PLUGIN(sotFeatureType, className) \
  DYNAMICGRAPH_FACTORY_ENTITY_PLUGIN(sotFeatureType, className)
/* -------------------------------------------------------------------------- */
/* --- TASK REGISTERER ------------------------------------------------------ */
/* -------------------------------------------------------------------------- */

#define SOT_FACTORY_TASK_PLUGIN(sotTaskType, className) \
  DYNAMICGRAPH_FACTORY_ENTITY_PLUGIN(sotTaskType, className)

#endif /* #ifndef __SOT_FACTORY_HH__ */


text:
all: king-county-live sf-canned

# fetches a fixed test set from S3
king-county-canned:
		mkdir -p king_county
		curl -o king_county/Food_Establishment_Inspection_Data.csv 'https://s3.amazonaws.com/data.codeforamerica.org/lives/King+County/Food_Establishment_Inspection_Data.csv'

# fetches the live data from King County
king-county-live:
	 	mkdir -p king_county
	 	curl -o king_county/Food_Establishment_Inspection_Data.csv 'https://data.kingcounty.gov/api/views/f29f-zza5/rows.csv?accessType=DOWNLOAD'

# fetches fixed test set from SF CfA Brigade Github account
sf-canned:
		mkdir -p san_francisco
		curl -o san_francisco/lives-sf.csv https://raw.github.com/sfbrigade/SFLivesData/master/lives-sf.csv

clean:
		rm king_county/Food_Establishment_Inspection_Data.csv
		rmdir -p king_county
		rmdir -p san_francisco


text:
<?php

namespace Drupal\Tests\migrate_drupal_ui\Functional;

use Drupal\views\Entity\View;
use Drupal\Tests\BrowserTestBase;

/**
 * Tests for the MigrateController class.
 *
 * @group migrate_drupal_ui
 */
class MigrateControllerTest extends BrowserTestBase {

  /**
   * {@inheritdoc}
   */
  protected static $modules = [
    'dblog',
    'migrate_drupal_ui',
    'views_ui',
  ];

  /**
   * {@inheritdoc}
   */
  protected $defaultTheme = 'stark';

  /**
   * {@inheritdoc}
   */
  protected function setUp(): void {
    parent::setUp();

    // Log in as user 1. Migrations in the UI can only be performed as user 1.
    $this->drupalLogin($this->rootUser);

    // Create a migrate message for testing purposes.
    \Drupal::logger('migrate_drupal_ui')->notice('A test message');

  }

  /**
   * Tests the upgrade report with the view enabled, disabled and uninstalled.
   */
  public function testUpgradeReport() {
    $session = $this->assertSession();

    $this->assertTrue(View::load('watchdog')->status(), 'Watchdog view is enabled');
    // Tests redirection to report page when the watchdog view is enabled.
    $this->drupalGet('admin/reports/upgrade');
    $session->optionExists('type[]', 'migrate_drupal_ui')->isSelected();
    $session->pageTextContainsOnce('A test message');

    // Disable the watchdog view.
    $this->drupalGet('admin/structure/views');
    $this->assertTrue($this->clickViewsOperationsLink('Disable', '/watchdog/'));
    $session->statusCodeEquals(200);

    // Tests redirection to report page when the watchdog view is disabled.
    $this->drupalGet('admin/reports/upgrade');
    $session->optionExists('type[]', 'migrate_drupal_ui')->isSelected();
    $session->pageTextContainsOnce('A test message');

    \Drupal::service('module_installer')->uninstall(['views_ui', 'views']);
    // Tests redirection to report page when views is uninstalled.
    $this->drupalGet('admin/reports/upgrade');
    $session->optionExists('type[]', 'migrate_drupal_ui')->isSelected();
    $session->pageTextContainsOnce('A test message');
  }

  /**
   * Clicks a view link to perform an operation.
   *
   * @param string $label
   *   Text between the anchor tags of the link.
   * @param string $href_part
   *   A unique string that is expected to occur within the href of the link.
   *
   * @return bool
   *   TRUE when link found and clicked, otherwise FALSE.
   */
  public function clickViewsOperationsLink($label, $href_part) {
    $links = $this->xpath('//a[normalize-space(text())=:label]', [':label' => (string) $label]);
    foreach ($links as $link_index => $link) {
      $position = strpos($link->getAttribute('href'), $href_part);
      if ($position !== FALSE) {
        $index = $link_index;
        $this->clickLink((string) $label, $index);
        return TRUE;
      }
    }
    return FALSE;
  }

}


text:
namespace NuGetConsole.Implementation.Console
{
    internal interface IPrivateConsoleStatus : IConsoleStatus
    {
        void SetBusyState(bool isBusy);
    }
}


text:
[#]: collector: (lujun9972)
[#]: translator: ( )
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (4 tools to help you drive Kubernetes)
[#]: via: (https://opensource.com/article/19/6/tools-drive-kubernetes)
[#]: author: (Scott McCarty https://opensource.com/users/fatherlinux/users/fatherlinux/users/fatherlinux/users/fatherlinux)

4 tools to help you drive Kubernetes
======
Learning to drive Kubernetes is more important that knowing how to build
it, and these tools will get you on the road fast.
![Tools in a workshop][1]

In the third article in this series, _[Kubernetes basics: Learn how to drive first][2]_ , I emphasized that you should learn to drive Kubernetes, not build it. I also explained that there is a minimum set of primitives that you have to learn to model an application in Kubernetes. I want to emphasize this point: the set of primitives that you _need_ to learn are the easiest set of primitives that you _can_ learn to achieve production-quality application deployments (i.e., high-availability [HA], multiple containers, multiple applications). Stated another way, learning the set of primitives built into Kubernetes is easier than learning clustering software, clustered file systems, load balancers, crazy Apache configs, crazy Nginx configs, routers, switches, firewalls, and storage backends—all the things you would need to model a simple HA application in a traditional IT environment (for virtual machines or bare metal).

In this fourth article, I'll share some tools that will help you learn to drive Kubernetes quickly.

### 1\. Katacoda

[Katacoda][3] is the easiest way to test-drive a Kubernetes cluster, hands-down. With one click and five seconds of time, you have a web-based terminal plumbed straight into a running Kubernetes cluster. It's magnificent for playing and learning. I even use it for demos and testing out new ideas. Katacoda provides a completely ephemeral environment that is recycled when you finish using it.

![OpenShift Playground][4]

[OpenShift playground][5]

![Kubernetes Playground][6]

[Kubernetes playground][7]

Katacoda provides ephemeral playgrounds and deeper lab environments. For example, the [Linux Container Internals Lab][3], which I have run for the last three or four years, is built in Katacoda.

Katacoda maintains a bunch of [Kubernetes and cloud tutorials][8] on its main site and collaborates with Red Hat to support a [dedicated learning portal for OpenShift][9]. Explore them both—they are excellent learning resources.

When you first learn to drive a dump truck, it's always best to watch how other people drive first.

### 2\. Podman generate kube

The **podman generate kube** command is a brilliant little subcommand that helps users naturally transition from a simple container engine running simple containers to a cluster use case running many containers (as I described in the [last article][2]). [Podman][10] does this by letting you start a few containers, then exporting the working Kube YAML, and firing them up in Kubernetes. Check this out (pssst, you can run it in this [Katacoda lab][3], which already has Podman and OpenShift).

First, notice the syntax to run a container is strikingly similar to Docker:

```
`podman run -dtn two-pizza quay.io/fatherlinux/two-pizza`
```

But this is something other container engines don't do:

```
`podman generate kube two-pizza`
```

The output:

```
# Generation of Kubernetes YAML is still under development!
#
# Save the output of this file and use kubectl create -f to import
# it into Kubernetes.
#
# Created with podman-1.3.1
apiVersion: v1
kind: Pod
metadata:
creationTimestamp: "2019-06-07T08:08:12Z"
labels:
app: two-pizza
name: two-pizza
spec:
containers:
\- command:
\- /bin/sh
\- -c
\- bash -c 'while true; do /usr/bin/nc -l -p 3306 < /srv/hello.txt; done'
env:
\- name: PATH
value: /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
\- name: TERM
value: xterm
\- name: HOSTNAME
\- name: container
value: oci
image: quay.io/fatherlinux/two-pizza:latest
name: two-pizza
resources: {}
securityContext:
allowPrivilegeEscalation: true
capabilities: {}
privileged: false
readOnlyRootFilesystem: false
tty: true
workingDir: /
status: {}
\---
apiVersion: v1
kind: Service
metadata:
creationTimestamp: "2019-06-07T08:08:12Z"
labels:
app: two-pizza
name: two-pizza
spec:
selector:
app: two-pizza
type: NodePort
status:
loadBalancer: {}
```

You now have some working Kubernetes YAML, which you can use as a starting point for mucking around and learning, tweaking, etc. The **-s** flag created a service for you. [Brent Baude][11] is even working on new features like [adding Volumes/Persistent Volume Claims][12]. For a deeper dive, check out Brent's amazing work in his blog post "[Podman can now ease the transition to Kubernetes and CRI-O][13]."

### 3\. oc new-app

The **oc new-app** command is extremely powerful. It's OpenShift-specific, so it's not available in default Kubernetes, but it's really useful when you're starting to learn Kubernetes. Let's start with a quick command to create a fairly sophisticated application:

```
oc new-project -n example
oc new-app -f <https://raw.githubusercontent.com/openshift/origin/master/examples/quickstarts/cakephp-mysql.json>
```

With **oc new-app** , you can literally steal templates from the OpenShift developers and have a known, good starting point when developing primitives to describe your own applications. After you run the above command, your Kubernetes namespace (in OpenShift) will be populated by a bunch of new, defined resources.

```
`oc get all`
```

The output:

```
NAME READY STATUS RESTARTS AGE
pod/cakephp-mysql-example-1-build 0/1 Completed 0 4m
pod/cakephp-mysql-example-1-gz65l 1/1 Running 0 1m
pod/mysql-1-nkhqn 1/1 Running 0 4m

NAME DESIRED CURRENT READY AGE
replicationcontroller/cakephp-mysql-example-1 1 1 1 1m
replicationcontroller/mysql-1 1 1 1 4m

NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
service/cakephp-mysql-example ClusterIP 172.30.234.135 <none> 8080/TCP 4m
service/mysql ClusterIP 172.30.13.195 <none> 3306/TCP 4m

NAME REVISION DESIRED CURRENT TRIGGERED BY
deploymentconfig.apps.openshift.io/cakephp-mysql-example 1 1 1 config,image(cakephp-mysql-example:latest)
deploymentconfig.apps.openshift.io/mysql 1 1 1 config,image(mysql:5.7)

NAME TYPE FROM LATEST
buildconfig.build.openshift.io/cakephp-mysql-example Source Git 1

NAME TYPE FROM STATUS STARTED DURATION
build.build.openshift.io/cakephp-mysql-example-1 Source Git@47a951e Complete 4 minutes ago 2m27s

NAME DOCKER REPO TAGS UPDATED
imagestream.image.openshift.io/cakephp-mysql-example docker-registry.default.svc:5000/example/cakephp-mysql-example latest About aminute ago

NAME HOST/PORT PATH SERVICES PORT TERMINATION WILDCARD
route.route.openshift.io/cakephp-mysql-example cakephp-mysql-example-example.2886795271-80-rhsummit1.environments.katacoda.com cakephp-mysql-example <all> None
```

The beauty of this is that you can delete Pods, watch the replication controllers recreate them, scale Pods up, and scale them down. You can play with the template and change it for other applications (which is what I did when I first started).

### 4\. Visual Studio Code

I saved one of my favorites for last. I use [vi][14] for most of my work, but I have never found a good syntax highlighter and code completion plugin for Kubernetes (if you have one, let me know). Instead, I have found that Microsoft's [VS Code][15] has a killer set of plugins that complete the creation of Kubernetes resources and provide boilerplate.

![VS Code plugins UI][16]

First, install Kubernetes and YAML plugins shown in the image above.

![Autocomplete in VS Code][17]

Then, you can create a new YAML file from scratch and get auto-completion of Kubernetes resources. The example above shows a Service.

![VS Code autocomplete filling in boilerplate for an object][18]

When you use autocomplete and select the Service resource, it fills in some boilerplate for the object. This is magnificent when you are first learning to drive Kubernetes. You can build Pods, Services, Replication Controllers, Deployments, etc. This is a really nice feature when you are building these files from scratch or even modifying the files you create with **Podman generate kube**.

### Conclusion

These four tools (six if you count the two plugins) will help you learn to drive Kubernetes, instead of building or equipping it. In my final article in the series, I will talk about why Kubernetes is so exciting for running so many different workloads.

--------------------------------------------------------------------------------

via: https://opensource.com/article/19/6/tools-drive-kubernetes

作者:[Scott McCarty][a]
选题:[lujun9972][b]
译者:[译者ID](https://github.com/译者ID)
校对:[校对者ID](https://github.com/校对者ID)

本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译,[Linux中国](https://linux.cn/) 荣誉推出

[a]: https://opensource.com/users/fatherlinux/users/fatherlinux/users/fatherlinux/users/fatherlinux
[b]: https://github.com/lujun9972
[1]: https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/tools_workshop_blue_mechanic.jpg?itok=4YXkCU-J (Tools in a workshop)
[2]: https://opensource.com/article/19/6/kubernetes-basics
[3]: https://learn.openshift.com/subsystems/container-internals-lab-2-0-part-1
[4]: https://opensource.com/sites/default/files/uploads/openshift-playground.png (OpenShift Playground)
[5]: https://learn.openshift.com/playgrounds/openshift311/
[6]: https://opensource.com/sites/default/files/uploads/kubernetes-playground.png (Kubernetes Playground)
[7]: https://katacoda.com/courses/kubernetes/playground
[8]: https://katacoda.com/learn
[9]: http://learn.openshift.com/
[10]: https://podman.io/
[11]: https://developers.redhat.com/blog/author/bbaude/
[12]: https://github.com/containers/libpod/issues/2303
[13]: https://developers.redhat.com/blog/2019/01/29/podman-kubernetes-yaml/
[14]: https://en.wikipedia.org/wiki/Vi
[15]: https://code.visualstudio.com/
[16]: https://opensource.com/sites/default/files/uploads/vscode_-_kubernetes_red_hat_-_plugins.png (VS Code plugins UI)
[17]: https://opensource.com/sites/default/files/uploads/vscode_-_kubernetes_service_-_autocomplete.png (Autocomplete in VS Code)
[18]: https://opensource.com/sites/default/files/uploads/vscode_-_kubernetes_service_-_boiler_plate.png (VS Code autocomplete filling in boilerplate for an object)


text:
Using the Orphanage
===================

If you are providing a create-form with file uploads you can easily run into a problem if the user decides to not submit the form. You then have uploaded files that don't belong to any Entity or the like. For these use cases the OneupUploaderBundle has the possibility to use a so called `Orphanage`.

The purpose of the `Orphanage` is to collect orphaned files until you come along and collect them or choose to clean up. To enable the `Orphanage` simply switch the `use_orphanage` property in your mapping to `true`.

```yaml
# app/config/config.yml

oneup_uploader:
    mappings:
        gallery:
            use_orphanage: true
```

As soon as you have `use_orphanage` set to true, uploaded files are not going to be moved directly to the configured directory. Instead, they will be moved to the directory specified under the `orphanage` key in the configuration. (see _Configure the Orphanage_)
They will be moved to the correct place as soon as you trigger the `uploadFiles` method on the Storage.

## Prerequisites
The `Orphanage` will save your files based on the current SessionId. Because of that you need a running session, even if you provide an uploader for anonymous users.

```yaml
# app/config/security.yml

security:
    firewalls:
        main:
            pattern: ^/
            anonymous: true
```

## The Controller part
Upload the files by triggering the `uploadFiles` method on the correct orphanage storage.

```php
// src/Acme/Controller/AcmeController.php

class AcmeController extends Controller
{
    public function storeAction()
    {
        $manager = $this->get('oneup_uploader.orphanage_manager')->get('gallery');
        $files = $manager->uploadFiles();
    }
}
```

You will get an array containing the moved files.

> If you are using Gaufrette, these files are instances of `Gaufrette\File`, otherwise `Symfony\Component\HttpFoundation\File\File`.

## Configure the Orphanage
You can configure the `Orphanage` by using the following configuration parameters.

```
oneup_uploader:
    orphanage:
        maxage: 86400
        directory: %kernel.cache_dir%/uploader/orphanage
```

You can choose a custom directory to save the orphans temporarily while uploading by changing the parameter `directory`.

## Clean up
The `OrphanageManager` can be forced to clean up orphans by using the command provided by the OneupUploaderBundle.

    $> php app/console oneup:uploader:clean-orphans

This parameter will clean all orphaned files older than the `maxage` value in your configuration.

## Known Limitations
The `Orphanage` will save uploaded files in a directory like the following:

    %kernel.cache_dir%/uploader/orphanage/{session_id}/uploaded_file.ext

It is currently not possible to change the part after `%kernel.cache_dir%/uploader/orphanage` dynamically. This has some implications. If a user will upload files through your `gallery` mapping, and choose not to submit the form, but instead start over with a new form handled by the `gallery` mapping, the newly uploaded files are going to be moved in the same directory. Therefore you will get both the files uploaded the first time and the second time if you trigger the `uploadFiles` method.


text:
using Igneel.Assets;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Igneel.Components
{
    public abstract class SurfaceMaterial : Resource
    {
        private LayerSurface _surface;
        private bool _containsAlpha;

        public SurfaceMaterial()
        {
            _surface = LayerSurface.Default;
        }

        public SurfaceMaterial(string name) :
            base(name, null)
        {
            _surface = LayerSurface.Default;
        }

        public SurfaceMaterial(string name, ResourceManager manager) : base(name, manager)
        {
            _surface = LayerSurface.Default;
        }

        public LayerSurface Surface
        {
            get { return _surface; }
            set { _surface = value; }
        }

        public Color3 Diffuse
        {
            get
            {
                return (Color3)_surface.Diffuse;
            }
            set
            {
                _surface.Diffuse = new Color4(value, _surface.Diffuse.A);
            }
        }

        public float SpecularIntensity
        {
            get
            {
                return _surface.Specular;
            }
            set
            {
                _surface.Specular = value;
            }
        }

        public float Alpha
        {
            get { return _surface.Diffuse.A; }
            set
            {
                _surface.Diffuse.A = value;
                if (value != 1)
                    _containsAlpha = true;
            }
        }

        public float Reflectivity { get { return _surface.Reflectivity; } set { _surface.Reflectivity = value; } }

        public float Refractitity { get { return _surface.Refractitity; } set { _surface.Refractitity = value; } }

        public float SpecularPower { get { return _surface.SpecularPower; } set { _surface.SpecularPower = value; } }

        public float EmisiveIntensity { get { return _surface.Emisive; } set { _surface.Emisive = value; } }

        public bool ContainsTrasparency { get { return _containsAlpha; } protected set { _containsAlpha = value; } }

    }

}


text:
using DragonSpark.Model.Selection;
using System;
using System.Threading.Tasks;

namespace DragonSpark.Model.Operations;

public class Operation<T> : Select<T, ValueTask>, IOperation<T>
{
	public Operation(ISelect<T, ValueTask> select) : this(select.Get) {}

	public Operation(Func<T, ValueTask> select) : base(select) {}
}

public class Operation : IOperation
{
	readonly Func<ValueTask> _select;

	public Operation(Func<ValueTask> select) => _select = select;

	public ValueTask Get() => _select();
}


text:
* **atmega328p** - source code for the mega328p main controller
* **esp8266** - source code for the ESP8266 WiFi module
* **schematics** - Cadsoft Eagle schematic file for the project

####gh-pages
* **index.html** - web interface for the coffee pot monitor
* **styles.css** - styling for the web interface


text:
::Sequel.migration do
  change do
    alter_table(:filter_papers) do
      drop_column :number_of_rows
      drop_column :number_of_columns
    end

    alter_table(:locations) do
      drop_column :position
    end

    rename_table(:locations, :filter_paper_aliquots)
  end
end


text:
#ifndef CONST_ACCOUNT_HPP_INCLUDED
#define CONST_ACCOUNT_HPP_INCLUDED

enum class AccountReply : short
{
	Exists = 1,
	NotApproved = 2,
	Created = 3,
	ChangeFailed = 5,
	Changed = 6,
	Continue = 1000 // TODO: Check this for the real value
};

enum class LoginReply : short
{
	WrongUser = 1,
	WrongUserPass = 2,
	OK = 3,
	LoggedIn = 5,
	Busy = 6
};

#endif // CONST_ACCOUNT_HPP_INCLUDED


text:
require 'kayako_client/mixins/ticket_api'

require 'kayako_client/staff'
require 'kayako_client/user'

module KayakoClient
    class TicketPost < KayakoClient::Tickets
        include KayakoClient::TicketAPI
        include KayakoClient::PostClient

        supports :all, :get, :post, :delete

        CREATOR_STAFF = 1
        CREATOR_USER  = 2

        property :id,                :integer, :readonly => true
        property :date_line,         :date,    :readonly => true
        property :user_id,           :integer, :new => true
        property :full_name,         :string,  :readonly => true
        property :email,             :string,  :readonly => true
        property :email_to,          :string,  :readonly => true
        property :ip_address,        :string,  :readonly => true
        property :has_attachments,   :boolean, :readonly => true
        property :creator,           :integer, :readonly => true, :range => 1..2
        property :is_third_party,    :boolean, :readonly => true
        property :is_html,           :boolean, :readonly => true
        property :is_emailed,        :boolean, :readonly => true
        property :staff_id,          :integer, :new => true
        property :is_survey_comment, :boolean, :readonly => true
        property :contents,          :string,  :new => true, :required => :post
        property :ticket_id,         :integer, :new => true, :required => :post
        property :subject,           :string,  :new => true, :required => :post
        property :ticket_post_id,    :integer, :readonly => true

        associate :user,             :user_id,  User
        associate :staff,            :staff_id, Staff

        def created_by_staff?
            !creator.nil? && creator == CREATOR_STAFF
        end

        alias_method :has_staff?, :created_by_staff?

        def created_by_user?
            !creator.nil? && creator == CREATOR_USER
        end

        alias_method :has_user?, :created_by_user?

    private

        def validate(method, params)
            if method == :post
                unless params[:user_id] || params[:staff_id]
                    raise ArgumentError, ":user_id or :staff_id is required"
                end
            end
        end

    end
end